गोलांग

Question

में डेटाटाइक्चर/वर्ड संरेखण पैडिंग को अनुकूलित करना सी ++ में मैंने जो सीखा है, मुझे लगता है कि मुझे लगता है कि यह पैडिंग है जो दोनों structs के उदाहरणों के आकार में अंतर का कारण बनता है।

type Foo struct { 
    w byte //1 byte 
    x byte //1 byte 
    y uint64 //8 bytes 
} 
type Bar struct { 
    x byte //1 byte 
    y uint64 //8 bytes 
    w byte// 1 byte 
} 
func main() { 
    fmt.Println(runtime.GOARCH) 
    newFoo := new(Foo) 
    fmt.Println(unsafe.Sizeof(*newFoo)) 
    newBar := new(Bar) 
    fmt.Println(unsafe.Sizeof(*newBar)) 
} 

आउटपुट:

amd64 
16 
24 

• वहाँ एक बुनियादी नियम यह जब struct सदस्यों को परिभाषित करने का पालन करने के है? (प्रकारों के आकार के आरोही/अवरोही क्रम की तरह)
• क्या कोई संकलन समय अनुकूलन है जिसे हम पास कर सकते हैं, जो स्वचालित रूप से इसका ख्याल रख सकता है?
• या मुझे इस बारे में चिंतित नहीं होना चाहिए?

Answer 1

वर्तमान में कोई संकलन-समय अनुकूलन नहीं है; मान x64 पर 8 बाइट्स तक पैड किए गए हैं।

आप अंतरिक्ष का बेहतर उपयोग करने के लिए मैन्युअल रूप से structs व्यवस्थित कर सकते हैं; आमतौर पर बड़े प्रकार से छोटे से जाकर; उदाहरण के लिए लगातार 8 बाइट क्षेत्रों, केवल 8 बाइट्स का उपयोग करेगा, लेकिन एक भी बाइट एक 8 बाइट संरेखण के लिए गद्देदार किया जाएगा, इस पर विचार करें: https://play.golang.org/p/0qsgpuAHHp

package main 

import (
    "fmt" 
    "unsafe" 
) 

type Compact struct { 
    a, b     uint64 
    c, d, e, f, g, h, i, j byte 
} 

// Larger memory footprint than "Compact" - but less fields! 
type Inefficient struct { 
    a uint64 
    b byte 
    c uint64 
    d byte 
} 

func main() { 
    newCompact := new(Compact) 
    fmt.Println(unsafe.Sizeof(*newCompact)) 
    newInefficient := new(Inefficient) 
    fmt.Println(unsafe.Sizeof(*newInefficient)) 
} 

आप इसे ध्यान में रखते हैं; आप अपने structs के स्मृति पदचिह्न अनुकूलित कर सकते हैं।

Answer 2

या मुझे इस बारे में चिंतित नहीं होना चाहिए?

हां आपको चाहिए।
इसे mechanical sympathy भी कहा जाता है (यह Go Time podcast episode देखें), इसलिए यह आपके द्वारा संकलित हार्डवेयर आर्किटेक्चर पर भी निर्भर करता है।

चित्रण के रूप में देखें:

• "The day byte alignment came back to bite me" (जनवरी 2014)
• "On the memory alignment of Go slice values" (जुलाई 2016)

जाओ स्लाइस में मानों 16-बाइट गठबंधन कर रहे हैं। वे 32 बाइट गठबंधन नहीं हैं।
गो पॉइंटर्स बाइट-गठबंधन हैं।