> For the complete documentation index, see [llms.txt](https://channyeintun.gitbook.io/blogs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://channyeintun.gitbook.io/blogs/go/memory-alignment-in-go.md).

# Memory Alignment in Go

#### Go မှာ Memory Alignment ဘယ်လို အလုပ်လုပ်သလဲ?

ကျနော်တို့ သိထားရမှာက CPU ဆိုတာ memory ထဲက data ကို ၁ byte ချင်းစီ သွားနှိုက်နေတာ မဟုတ်ပါဘူး။ သူက တစ်ခါဖတ်ရင် **Word Size** လို့ ခေါ်တဲ့ chunk လိုက်ကြီးပဲ ဖတ်တာပါ။ (ဥပမာ- 64-bit CPU ဆိုရင် တစ်ခါဖတ်ရင် 8 bytes ဖတ်ပါတယ်)။

အဲဒီမှာ ပြဿနာက ဘာလဲဆိုတော့ CPU က သူဖတ်မယ့် data ကို **Specific Boundary** (သူ့ရဲ့ word size နဲ့ စားလို့ပြတ်တဲ့ address) မှာ ရှိနေစေချင်တာပါ။

**၁။ ဘာကြောင့် Alignment လိုအပ်တာလဲ?**

ဥပမာ- ကျနော်တို့မှာ 8-byte int64 တစ်ခု ရှိတယ်ဆိုပါစို့။

* အကယ်၍ ဒီ int64 က memory address 0 ကနေ စတယ်ဆိုရင် CPU က တစ်ချက်တည်းနဲ့ ဖတ်လို့ရပါတယ်။ (Aligned ဖြစ်တယ်လို့ ခေါ်ပါတယ်)။
* ဒါပေမဲ့ အဲဒီ int64 က memory address 3 ကနေ သွားစနေမယ်ဆိုရင် CPU က သူ့ကို တစ်ခါတည်းနဲ့ ဖတ်လို့ မရတော့ပါဘူး။ ၂ ခါခွဲဖတ်ပြီးမှ ပြန်ပေါင်းရတဲ့အတွက် Program က နှေးသွားပါတယ်။

**၂။ Go က Padding ကို ဘယ်လို ထည့်တာလဲ?**

ဒါကြောင့် Go compiler က ကျနော်တို့ရဲ့ Struct field တွေကြားထဲမှာ **Padding** (နေရာလွတ်) တွေ ညှပ်ထည့်ပြီး data တစ်ခုချင်းစီကို သက်ဆိုင်ရာ **Boundary** မှာ သွားကျအောင် စီပေးလိုက်တာပါ။

ဒီ Code လေးကို ကြည့်ကြည့်ပါ။

```go
type MyStruct struct {
    a int8  // 1 byte ယူတယ်
    // ဒီနေရာမှာ 7 bytes padding ဝင်သွားမယ်
    b int64 // 8 bytes ယူတယ် (သူ့ကို 8-byte boundary မှာ ရှိစေချင်လို့)
    c int32 // 4 bytes ယူတယ်
    // ဒီနောက်မှာ 4 bytes padding ထပ်ဝင်မယ်
}
```

ဒီ struct မှာ ကျနော်တို့ သုံးထားတဲ့ data အစစ်အမှန်က 1 + 8 + 4 = 13 bytes ပဲ ရှိပေမယ့် unsafe.Sizeof နဲ့ စစ်ကြည့်ရင် **24 bytes** ဖြစ်နေပါလိမ့်မယ်။ ဘာလို့လဲဆိုတော့ Compiler က data တွေကို CPU ဖတ်ရ လွယ်အောင် Boundary တွေမှာ ညှိပေးလိုက်လို့ပါ။

**၃။ Memory သက်သာအောင် ဘယ်လို ရေးမလဲ?**

ဒါကို optimize လုပ်ဖို့အတွက် အလွယ်ဆုံးနည်းလမ်းကတော့ Struct field တွေကို **"Size အကြီးကနေ အငယ်"** ကို စီရေးလိုက်တာပါပဲ။

```go
type OptimizedStruct struct {
    b int64 // 8 bytes (အရင်စီမယ်)
    c int32 // 4 bytes (နောက်မှစီမယ်)
    a int8  // 1 byte (အသေးဆုံးကို အောက်ဆုံးပို့မယ်)
}
```

ဒီလို ရေးလိုက်ရင် Padding ထည့်ရတာ နည်းသွားတဲ့အတွက် memory usage သိသိသာသာ လျော့ကျသွားပါလိမ့်မယ်။

**အနှစ်ချုပ်ပြောရရင်**\
Memory Alignment ဆိုတာ CPU က data ကို အမြန်ဆုံး ဖတ်နိုင်အောင် memory address တွေရဲ့ **Boundary** မှာ အစီအစဉ်တကျ စီပေးတာပါ။ ကျနော်တို့က Struct field တွေကို အကြီးကနေ အငယ် စီပေးခြင်းအားဖြင့် မလိုအပ်တဲ့ Padding တွေကို လျှော့ချပြီး program ကို ပိုမြန်အောင် လုပ်နိုင်ပါတယ်။