‫تخصیص شی روی استک در دات نت 10 (Object Stack Allocation)

• روی heap: اگر احتمال داشته باشد آبجکت بعد از خروج از متد هنوز زنده باشد.
• روی stack: اگر مطمئن باشد عمر آبجکت فقط در همین متد و همین call-frame هست (یعنی "فرار نمی‌کند" = no escape).

Foo MakeFoo() {
    return new Foo();
}

class Bar { public Foo F; }
void Save(Bar b) {
    b.F = new Foo();
}

void Print(object o) => Console.WriteLine(o);
void Test() {
    Print(new Foo());
}

void Test() {
    var foo = new Foo();
    foo.DoSomething();
}

Span<int> s = stackalloc int[10];
s[0] = 42;

void Wrapper() {
    var f = MakeFoo();
    f.DoSomething();
}
Foo MakeFoo() => new Foo();

public int Sum(int y)
{
    Func<int, int> addY = x => x + y;
    return DoubleResult(addY, y);
}

• یک closure برای نگهداری y
• یک delegate که به متد closure اشاره می‌کنه

• می‌بیند delegate فقط به DoubleResult پاس داده میشود.
• DoubleResult هم inline میشود (یعنی کد آن مستقیم داخل Sum کپی میشود).
• بعد JIT بررسی می‌کند: "آیا این delegate جایی خارج از Sum یا DoubleResult ذخیره میشود یا برمی‌گردد؟"جواب: خیر!

• تخصیص حافظه نصف میشود (از 88 بایت به 24 بایت).
• سرعت اجرای متد تقریباً ۳ برابر بهتر میشود.

• تو اول یه دفترچه برمی‌داری و عدد ۴۲ رو داخلش می‌نویسی (این میشه closure).
• بعد یه برگه کاغذ جدا درست می‌کنی که روش نوشته: "برو از دفترچه عدد رو بخون، بعد با ورودی جمع کن" (این میشه delegate).
• هر بار دوستت بخواد این کار رو انجام بده، باید هم دفترچه رو داشته باشه هم برگه رو.
• دو تا وسیله باید همراهت باشه (۲ تا allocation).

• اینجا هنوز دفترچه لازمه (چون y باید یه جایی ذخیره بشه).
• ولی برگه کاغذ (delegate) کاملاً حذف میشه.
• فقط یک وسیله همراهته (۱ allocation).

Process(new string[] { "a", "b", "c" });

• کامپایلر C# یک آرایه string[] روی heap می‌سازد (new string[3]).
• این آرایه حاوی "a", "b", "c" است.
• چون روی heap است، باید توسط GC مدیریت شود.
• حتی اگر Process فقط داخل همان متد اجرا شود و هیچ ارجاعی به بیرون نرود، باز هم آن allocation روی heap انجام می‌شود.
• نتیجه: هزینه‌ی ساخت و هزینه‌ی GC وجود دارد.

• بررسی می‌کند آیا این آرایه‌ی string از متد خارج می‌شود یا نه (مثلاً return شود، یا در فیلد ذخیره شود، یا به متدی ناشناخته پاس داده شود).
• اگر ببیند این آرایه فقط در همین scope مصرف می‌شود، نتیجه می‌گیرد که این آرایه escape ندارد.

• به جای heap allocation، آن را روی stack بسازد (مثل stackalloc) ولی شفاف برای برنامه‌نویس.
• وقتی متد تمام شد، stack frame آزاد می‌شود و هیچ اثری از آن آرایه باقی نمی‌ماند.

• در Delegate، JIT فهمید شی delegate لازم نیست روی heap باشد پس حذف شد.
• در Array، JIT فهمید آرایه از scope خارج نمی‌شود پس از heap رفت به stack.

• تو باید این سه تا کلمه رو توی یک جعبه مقوایی بزرگ بذاری (یعنی آرایه روی heap).
• جعبه رو میدی دست دوستت پس اون کلمات رو یکی یکی برمی‌داره.

• جعبه باید از قبل ساخته بشه.
• وقتی کارت تموم شد، هنوز باید جعبه رو بریزی توی سطل آشغال (اینجا GC باید جمعش کنه).
• یعنی هزینه بیشتر + فشار روی سیستم.

• JIT نگاه می‌کنه می‌بینه: "این سه تا کلمه فقط همین‌جا مصرف میشن، هیچ‌جاشون ذخیره یا نگه‌داری نمی‌شن."
• میگه: "خب، چرا باید جعبه بزرگ بسازم؟ همین‌جا روی میز (یعنی stack) می‌چینمشون."
• وقتی کار متد تموم میشه، میز خالی میشه پس بدون اینکه لازم باشه جعبه بسازی یا GC جمعش کنه.
• سریع‌تر + بدون فشار به GC.

private byte[] _buffer = new byte[3];
[Benchmark]
public void Test() => Copy3Bytes(0x12345678, _buffer);
[MethodImpl(MethodImplOptions.NoInlining)]
private static void Copy3Bytes(int value, Span<byte> dest) =>
    BitConverter.GetBytes(value).AsSpan(0, 3).CopyTo(dest);

• BitConverter.GetBytes(int) همیشه یک آرایه‌ی 4 بایتی روی heap می‌سازد.
• این آرایه شامل بایت‌های عدد ورودی است.
• بعد با AsSpan(0,3) سه بایت اول آن انتخاب می‌شود.
• سپس با CopyTo(dest) این بایت‌ها کپی می‌شوند.
• حتی اگر این آرایه فقط موقت استفاده شود، چون روی heap ساخته شده، باید توسط GC مدیریت شود.
• نتیجه: 32 بایت allocation (24 بایت سربار object header + 4 بایت length + 4 بایت داده، گرد شده به 32).

• Inlining: متد BitConverter.GetBytes و AsSpan را inline می‌کند تا رفتار داخلی دیده شود.
• Escape analysis: می‌بیند آرایه‌ای که GetBytes می‌سازد: فقط همان‌جا به Span تبدیل می‌شود. هیچ جایی ذخیره نمی‌شود یا return نمی‌شود. یعنی escape ندارد.

• به جای ساخت آرایه روی heap، JIT آن 4 بایت را روی stack می‌سازد.
• بعد همان داده‌ها به dest کپی می‌شوند.
• وقتی متد تمام شد، stack frame آزاد می‌شود پس بدون GC است.

byte[] buffer = new byte[3];
Copy3Bytes(0x12345678, buffer);

• BitConverter.GetBytes(value) یه جعبه بزرگ 4 بایتی روی heap می‌سازه.
• بعد از اون، سه بایت اول رو برمی‌داری و روی buffer کپی می‌کنی.
• وقتی کار تموم شد، GC باید جعبه‌ی ۴ بایتی رو جمع کنه.
• یعنی هزینه‌ی اضافی حافظه و سرعت پایین‌تر.

• JIT نگاه می‌کنه می‌فهمه: این ۴ بایت فقط همین‌جا استفاده میشه و فرار نمی‌کنه.
• پس به جای ساختن جعبه روی heap، اون ۴ بایت رو مستقیم روی میز کار (stack) می‌چینه.
• بعد از کپی به buffer، وقتی متد تموم شد، میز خالی میشه → هیچ چیزی روی heap نمی‌ره.