
۱) مقدمه: چرا کد تمیز در مقیاس بالا کافی نیست
کمابیش هر مهندسی که با سیستم های تعاملی سنگین کار کرده، آن لحظه را به یاد دارد: سیستمی می نویسی که از هر نظر تمیز است، کلاس ها سر جای خودشان اند، سلسله مراتب وراثت منطقی است، مسئولیت ها به درستی تفکیک شده اند، و روی چند صد موجودیت مثل ساعت کار می کند. اما همین که مقیاس را چند برابر می کنی ،از صدها به ده ها هزار موجودیت ،نرخ فریم فرومی ریزد. نکته ی گیج کننده این است که پردازنده بیکار به نظر می رسد، اما خروجی کند است. این مقاله دقیقا به همین معما می پردازد و نشان می دهد که ریشه ی مشکل نه در بد بودن شیءگرایی، بلکه در ناسازگاری ذاتی چیدمان حافظه ی آن با معماری پردازنده های مدرن است.
من در این مقاله پنج معماری رایج در موتور یونیتی را کنار هم گذاشتم: شیءگرایی (OOP)، معماری موجودیت مولفه سیستم (ECS)، پشته ی فناوری داده محور یونیتی (DOTS)، طراحی داده محور مبتنی بر (SODD) ScriptableObject و معماری مولفه محور (Component-Based). محور روایت، گذار از پارادایم شیءگرایی به طراحی داده محور (Data-Oriented Design) است، گذاری که به تعبیر منابع، پیامدهای واقعی عظیمی بر کارایی دارد، چون محور طراحی را از شیء به چیدمان داده در حافظه جابه جا می کند. تمام تحلیل، ارزیابی و اعداد این نوشته بر پایه ی شواهد مستند منابع بنا شده اند و با الهام از مفاهیم پایه ای در چارچوب ارزیابی معماری ATAM سازمان یافته اند.
۲) شیءگرایی و بن بست های آن در مقیاس بالا
۲.۱ کپسوله سازی و بهای پنهان آن
شیءگرایی بر اصولی مانند کپسوله سازی، وراثت، چندریختی و رابط ها استوار است و سطح انتزاع بالایی به توسعه دهنده می دهد. در یونیتی کلاسیک، هر موجودیت به صورت یک MonoBehaviour مدل می شود که داده و رفتار را با هم درون خود baked می کند، برای مثال یک کلاس LandTile با فیلدهای x، y، isOccupied و isActive و متدهایی که منطق را در همان شیء نگه می دارند. این مدل برای فهم انسان بسیار طبیعی است و ماژولاریتی شهودی می دهد، اما همین هم مکانی داده و رفتار در مقیاس بالا به یک بدهی کارایی تبدیل می شود.
۲.۲ ریشه ی مشکل: Cache Miss، حافظه ی پراکنده و تقابل Stack/Heap
در شیءگرایی، هر شیء به صورت مستقل روی Heap تخصیص داده می شود، حافظه به دو ناحیه تقسیم می شود: Stack (ترتیبی، LIFO، برای متغیرهای موقت و آرگومان ها) و Heap (تخصیص پویا و غیرترتیبی در زمان اجرا). آبجکت هایی که پشت سرهم ساخته می شوند می توانند در آدرس های کاملا متفاوت حافظه بیفتند. در یونیتی این وضعیت حادتر است: هر GameObject در واقع یک آبجکت سنگین ++C است که یک پوسته ی #C به آن اشاره می کند و هر دو می توانند هرجای حافظه باشند.

پیامد مهندسی این پراکندگی روشن است : وقتی پردازنده فقط به یک عدد از یک شیء نیاز دارد، کل آن شیء از حافظه واکشی می شود، این کار کش را آلوده می کند (Cache Pollution)، نرخ خطای کش (Cache Miss) را بالا می برد و مانع بهره گیری از دستورات برداری SIMD می شود. منابع این وضعیت را با عبارت گویای Cache misses galore ،یعنی سیل خطاهای کش ،توصیف می کنند. بدتر آنکه دسترسی تصادفی به حافظه باعث می شود نرخ این خطاها با تعداد موجودیت ها به صورت خطی رشد کند و در نهایت به یک فروپاشی کاملا محسوس منجر شود.
۲.۳ فروپاشی غیرخطی: یک امضای معماری، نه یک تصادف
یکی از یافته های کلیدی این است که افت کارایی OOP خطی نیست، بلکه شتاب دار است. در یکی از منابع، هزینه ی هر گام از افزایش تعداد موجودیت ها به روشنی ثبت شده است: در بازه ی ۱۵۰۰ به ۲۰۰۰ موجودیت تنها حدود ۱۰ میلی ثانیه به زمان اضافه می شود، اما در بازه ی ۲۵۰۰ به ۳۰۰۰ این افزایش به حدود ۳۲ میلی ثانیه می رسد. این رفتار غیرخطی نشان می دهد که محدودیت های OOP معماری اند، نه اتفاقی، یعنی با بهینه سازی های خرد قابل رفع نیستند و رفعشان نیازمند تغییر خود معماری است.

۲.۴ هم روندی در شیءگرایی: دشواری ذاتی
موازی سازی در OOP دشوار است: دو نخ نمی توانند بدون سربار روی یک آبجکت کار کنند، چون خطر Race Condition و تغییر غیرهمگام داده وجود دارد و هر نخ باید بداند نخ دیگری روی همان آبجکت کار می کند یا نه. در یونیتی کلاسیک، ساخت یا حذف Component نیازمند mutex lock روی فهرست سراسری id→pointer است. منابع تاکید می کنند که موتور اصلی یونیتی روی main thread اجرا می شود و اغلب توابع API آن thread-safe نیستند ، بنابراین Coroutine ها هم روندی ارائه می دهند نه موازی سازی و صرفا شبیه نخ هایی با قابلیت توقف / انتظارند. راهکار عملی OOP این است که الگوریتم های سنگین (مانند یافتن دشمنان در فاصله ی مشخص) به sub-thread ها منتقل شوند تا نرخ فریم افت نکند، در حالی که فراخوانی های API یونیتی روی main thread باقی می مانند، برای Singletonها نیز از قفل و double-checked locking استفاده می شود.
۲.۵ الگوهای ترمیمی کارایی در OOP
جامعه ی شیءگرا برای مقابله با این محدودیت ها الگوهای مشخصی ساخته است: الگوی Object Pool برای کنترل تخصیص حافظه و جلوگیری از بار Garbage Collector (که استخر را روی یک ساختمان داده ی Stack پیاده می کند و نسخه ی LinkedPool فقط به اشیای ذخیره شده حافظه تخصیص می دهد)، الگوی Dirty Flag برای پرهیز از محاسبه ی مجدد، و Spatial Partition برای دسترسی فضایی. حتی خود Data Locality در این ادبیات به عنوان یک الگوی بهینه سازی معرفی می شود ،یعنی جامعه ی OOP هم به اهمیت چیدمان حافظه واقف است، اما آن را به جای یک اصل معماری، به صورت یک وصله ی موضعی به کار می گیرد.
۳) معماری ECS و DOTS : طراحی حول داده
۳.۱ سه گانه ی Entity، Component، System
ECS یک الگوی معماری مبتنی بر ترکیب به جای وراثت (Composition over Inheritance) است که شیء را به سه بخش می شکند. موجودیت (Entity) دیگر یک شیء سنگین نیست، صرفا یک شناسه ی سبک 64 بیتی (شامل یک ایندکس و یک ورژن) است که هیچ داده یا رفتاری در خود ذخیره نمی کند. مولفه (Component) داده ی خالص است، یک struct ساده مانند TilePosition{int2}، TileOccupied{bool} یا NeedsUpdating که فقط حالت را نگه می دارد. سیستم (System) منطق است، کدی که روی مجموعه ای از موجودیت های Query شده اجرا می شود. یک EntityManager موجودیت ها را دنبال می کند و کوئری ها اغلب با توابع lambda نوشته می شوند. این تفکیک، درخت وراثت صلب را حذف می کند و انعطاف ترکیبی می دهد.

۳.۲ قلب کارایی: Archetype، Chunk و تقابل AoS با SoA
کلید برتری کارایی ECS در چیدمان حافظه است. موتور، همه ی موجودیت هایی را که مجموعه ی دقیقا یکسانی از مولفه ها دارند در یک Archetype گروه بندی می کند. حافظه در بلوک های پیوسته ای به نام Chunk (هرکدام حدود ۱۶ کیلوبایت) تخصیص می یابد و هر Chunk فقط داده ی یک Archetype را در خود دارد. حالا پیمایش سیستم به یک حلقه ی خطی روی حافظه ی فشرده تبدیل می شود، یک بار خواندن cache-line تقریبا ۸ تا ۱۶ موجودیت هم نوع را با هم بارگذاری می کند و Cache Miss به حداقل می رسد.
اما یک لایه ی معماری ظریف تر هم وجود دارد که اغلب زیر برچسب کلی ECS پنهان می ماند: تفاوت مدل AoS (آرایه ای از struct ها) با SoA (structی از آرایه ها). منابع تاکید می کنند که صرف جداسازی داده از منطق کافی نیست، این چیدمان داده ی زیرین است که عامل واقعی کارایی است. SoA داده های هم نوع را پیوسته می چیند، امکان دستورات SIMD و خواندن موازی آرایه ها را فراهم می کند و پایداری فریم بهتری می دهد، به طوری که در یک اندازه گیری، SoA در برابر AoS به ۶۵.۸۱ در برابر ۶۱.۵۱ فریم بر ثانیه رسید. archetype ها به صورت جدول ستونی (columnar) با دسترسی O(1) به مولفه پیاده می شوند.

۳.۳ Burst و SIMD : از داده ی مرتب تا کد ماشین بهینه
چون داده در ECS مرتب و پیوسته است، کامپایلر Burst می تواند کد #C را به دستورات بومی SIMD ترجمه کند و کد ماشین را دقیقا برای پردازنده ی دستگاه هدف تولید کند. این همان چیزی است که DOTS را به پیاده سازی صنعتی ECS تبدیل می کند. البته Burst قیودی دارد: فقط با انواع blittable کار می کند و برخی safety check ها را حذف می کند. تاثیر آن اما چشمگیر است و در بخش بنچمارک ها با عدد نشان داده خواهد شد.

۳.۴ موازی سازی: Job System، Command Buffer و Sync Point
DOTS دو سطح موازی سازی ارائه می دهد: Data Parallelism (تقسیم موجودیت های یک سیستم میان چند نخ) و Task Parallelism (اجرای هم زمان چند سیستم مستقل). Job System کد چندنخی #C را ممکن می کند و از worker thread ها (هر هسته ی منطقی یک worker) برای پرهیز از Context Switching استفاده می کند، برای پرهیز از Race Condition به جای ارجاع ، کپی داده را به هر Job می دهد. با اعلان ایستای ReadOnly / ReadWrite روی داده، زمان بندی Job ها بهینه تر می شود (Job هایی که فقط می خوانند منتظر هم نمی مانند).
تغییرات ساختاری (ساخت / حذف موجودیت یا مولفه) نمی توانند وسط پیمایش موازی رخ دهند، این تغییرات به صورت معوق (deferred) در یک Command Buffer انباشته و در Sync Point ها روی نخ اصلی اعمال می شوند. توصیه ی معماری این است که تعداد Sync Point ها کمینه بماند. در عمل، پیمایش ها بسته به تعداد هسته های پردازنده ی دستگاه هدف (مثلا بین ۶ تا ۷ نخ در یک پردازنده ی ۸ هسته ای) تقسیم می شوند و کارهایی که فقط روی نخ اصلی ممکن اند (مانند تغییر Texture) در Sync Point سفارشی انجام می گیرند.

۳.۵ واقعیت مدل هیبریدی و فرآیند baking
نکته ی مهم استقرار این است که ECS خالص همیشه ممکن نیست. برخی اجزا مانند دوربین ها، منابع نور و بعضی اسکریپت ها قابل تبدیل به entity نیستند و باید با GameObject / MonoBehaviour پیاده شوند، به همین دلیل اکثر پروژه های Unity ECS در عمل ماهیت شیءگرا هم دارند (رویکرد Hybrid / Companion GameObject). این هم زیستی اجباری، خود منبع پیچیدگی و کاپلینگ معماری است. از سوی دیگر، مدل هیبریدی یک مزیت استراتژیک دارد: نگه داشتن لایه ی UI GameObject و انتقال منطق پرتکرار به ECS ، مهاجرت کامل را لازم نمی کند و مانع پذیرش را پایین می آورد. الزامات ساختاری DOTS شامل نصب پکیج های Entities/Burst/Jobs و Hybrid Renderer + URP، پیاده سازی سیستم ها با SystemBase و مولفه ها با IComponentData، و فرآیند baking برای تبدیل GameObject به Entity است. (البته باید توجه داشت که در نسخه های جدید و ۱.۰ به بعد یونیتی، ساختار ISystem جایگزین SystemBase شده است تا کارایی بهتری ارائه دهد، اما اصول معماری ثابت مانده است).
۴) معماری SODD : داده به مثابه ی شهروند درجه یک
اگر ECS پاسخ مسئله ی کارایی است، SODD (طراحی داده محور مبتنی بر ScriptableObject) پاسخ مسئله ای متفاوت است: کاپلینگ و مدیریت حالت. بسیاری از دردهای واقعی تیم ها ربطی به سرعت خام ندارند، مشکل این است که یک تغییر کوچک در یک صحنه، ده جای دیگر را می شکند. SODD این گره را هدف می گیرد.
۴.۱ فلسفه : جداسازی چرخه ی حیات داده از صحنه
ایده ی محوری SODD این است که داده را به یک شهروند درجه یک ارتقا دهد: روند ScriptableObject چرخه ی حیات داده را از چرخه ی حیات شیء و صحنه جدا می کند و داده را به یک asset مستقل، سریالایزپذیر و قابل تزریق تبدیل می کند. نمونه های ساخته شده در Editor سریالایز و به صورت asset ذخیره می شوند و در زمان اجرا دی سریالایز و در RAM بارگذاری می گردند. از منظر نظری، این همان ایده ی Flyweight/حالت مشترک است که در سطح asset پیاده می شود: داده ی مشترک، مستقل از هر instance.
۴.۲ بلوک های سازنده: Variable، Event، RuntimeSet و Manager
SODD بر چند بلوک پایه استوار است. Scriptable Variable ها ظرف های ماژولار برای یک مقدار (مثل int/float/string) هستند که بین سیستم ها به اشتراک گذاشته می شوند تا سیستم ها برای خواندن/نوشتن state به هم وابسته نباشند. Scriptable Event ها کانال های رویداد مبتنی بر ScriptableObject با API به سبک Observer هستند: AddListener، RemoveListener و Invoke ،هم نام با UnityEvent و delegate های #C. سیستم ها به این رویدادها گوش می دهند و کاملا از یکدیگر Decouple می شوند، برای نمونه، Control Scheme Handler ها تغییر طرح کنترل را پایش و Scriptable Event متناظر را Trigger می کنند. در کنار اینها، RuntimeSet (معادل Collection) و GameEvent و Manager هایی به صورت ScriptableObject (مانند GameManager با SetTimeScale/LoadScene/Quit و ScoreManager با ارجاع به Variable<int> score) قرار دارند و سیستم های UI با Subscribe به تغییر Variable به روزرسانی می شوند.

۴.۳ جایگزینی Singleton و مدیریت حالت
SODD به طور مشخص الگوی Singleton را نقد می کند : اتصال سخت (tight coupling) ، مدیریت حالت سراسری با عوارض جانبی بین صحنه ها، دشواری دیباگ و تست، و ناسازگاری با Editor. Singleton یکی از بحث برانگیزترین الگوها / گاه ضدالگو توصیف می شود که مزایایی مانند دسترسی آسان و پایداری بین صحنه ها دارد اما وابستگی های پنهان و حالت سراسری تغییرپذیر می سازد. راه حل SODD جایگزینی آن با ScriptableObject Manager هاست تا حالت مشترک به شکل قابل کنترل و مستقل از صحنه مدیریت شود.
۴.۴ مرزها و محدودیت ها: بهایی که SODD می گیرد
مهندس خوب مرزها را می شناسد. سریالایزر پیش فرض یونیتی قادر به سریالایز رابط ها و کلاس های abstract نیست و SODD را به افزونه ی Odin وابسته می کند، پایداری داده در حالت Build آن طور که انتظار می رود کار نمی کند، callback های ScriptableObject غیرقابل اتکا توصیف شده اند، و یک شکاف واقعی در مستندسازی و اتکاپذیری وجود دارد. مسائل عملی دیگری هم هست: ترتیب callback های MonoBehaviour قطعی است اما ترتیب بین MonoBehaviour ها نیست و باید با Script Execution Order یک مقداردهی مرکزی تنظیم شود، برای پایداری بین صحنه ها از DontDestroyOnLoad استفاده می شود و تفاوت رفتار Build mode و Play mode باید مدیریت گردد. به گفته ی منبع، این معماری در حدود یک ماه ساخته شد و به آموزش و راهنمایی نیاز دارد. پس SODD ابزار انعطاف و مدیریت حالت است، نه لزوما ابزار کارایی خام.
۵) معماری مولفه محور (Component-Based) : ترکیب به جای وراثت
معماری مولفه محور در یونیتی دو چهره دارد. چهره ی اول همان مدل GameObject-Component است: افزودن Component ها به یک GameObject طبیعی و ماندگار است، اما چون پیاده سازی آن شیءگراست، به همان پراکندگی داده در حافظه و Cache Miss منجر می شود، در رویکرد سنتی، آبجکت مالک داده های خودش است (مثلا player مالک velocity/position). الگوی افزودن Component، Composition over Inheritance را تشویق می کند و سلسله مراتب را مسطح تر می کند، اما عیبی هم دارد: گاهی لازم است همان قابلیت چندبار نوشته شود.
چهره ی دوم، معماری مولفه محور اصیل تری است که در منابعی مثل RCSA / RAGE توصیف شده و تمرکزش بر بازاستفاده پذیری و انتقال پذیری است. در این مدل، مولفه ها به صورت جعبه ی سیاه (black box) با رابط ها و لایه بندی مشخص تعریف می شوند و از طریق Publish/Subscribe (پیام رسانی یک به چند و یک طرفه با Topic/Channel) با هم حرف می زنند. برخلاف Observer که در آن باید در خود منبع مشترک شوی، Publish/Subscribe منشا اعلان را Decouple می کند و مانند یک message router عمل می کند (پیاده سازی Broadcast Messaging نمونه ی همین ایده است). تمرکز صریح این معماری بر Portability است : مانع اصلی بازاستفاده، تنوع زبان ها/موتورها/سیستم عامل ها/پلتفرم های هدف است و این معماری برای انتقال پذیری مولفه ها بین محیط های فنی مختلف طراحی شده. جالب آنکه Data Locality هم در همین ادبیات به عنوان یک الگوی بهینه سازی برای بیشینه کردن استفاده از کش CPU فهرست شده است.

۶) مقایسه ی فنی معماری ها: حافظه، هم روندی و رویداد
جدول زیر تفاوت های بنیادین چهار محور معماری را در مدیریت حافظه، هم روندی و مدیریت رویداد جمع بندی می کند. این تفاوت ها مبنای همه ی ترید آف هایی هستند که در بخش های بعد تحلیل می شوند.



۷) سناریوهای کارایی و بنچمارک ها
در این بخش، اعداد مستند منابع را با ذکر شرایط محیطی مرور می کنیم. تاکید می کنیم که این اعداد در شرایط آزمونی مشخص به دست آمده اند و باید در همان بستر تفسیر شوند، همین دقت، تفاوت یک تحلیل مهندسی با یک ادعای تبلیغاتی است.
۷.۱ آزمون بنیادین: Conway's Game of Life روی یک میلیون سلول
شفاف ترین نمایش قدرت داده محوری در آزمون MY.GAMES دیده می شود. یک گام از الگوریتم Conway روی میدان ۱۰۰۰×۱۰۰۰ (یعنی ۱٬۰۰۰٬۰۰۰ سلول) روی پردازنده ی Intel Core i9-10900 (۱۰ هسته/۲۰ نخ) اجرا شد:
• پیاده سازی سنتی تک نخی (متد SimulateStep) : حدود ۳۸۰ میلی ثانیه (دقیقا ۳۸۱.۳۲ms در Profiler).
• با C# Job System (توزیع کار میان ۱۷ worker): حدود ۴۲ میلی ثانیه - تقریبا ۹ برابر سریع تر از حالت تک نخی.
• با Job System + Burst : کمتر یا مساوی ۲ میلی ثانیه - تقریبا ۱۹۰ برابر نسبت به نتیجه ی اولیه.
این توالی نشان می دهد که موازی سازی و کامپایل بومی، وقتی روی داده ی درست چیده شده اعمال شوند، بهبود را از مرتبه ی چند برابر به مرتبه ی صدها برابر می رسانند.

۷.۲ به روزرسانی وضعیت تایل ها: ۰٫۳۷ در برابر ۱٫۶۸ میلی ثانیه
در سناریوی به روزرسانی وضعیت اشغال ۲۵۰٬۰۰۰ تایل در هر فریم روی گرید ۵۰۰×۵۰۰ (اجرا داخل Unity Editor روی PC ویندوز، هر تست ۱۰ بار و میانگین گیری، فریم اول کنار گذاشته شد)، آرتیفکت مقایسه TileOccupationSystem (ECS/SystemBase) در برابر کلاس TileOccupation (MonoBehaviour) بود. ECS پیمایش را بین ۶ تا ۷ worker thread تقسیم می کند و Main Thread فقط Command Buffer را می سازد و اجرا می کند. نتیجه: نسخه ی MonoBehaviour به طور میانگین ۱.۶۸ میلی ثانیه (کمینه ۱.۴۹، بیشینه ۲.۷۴) و نسخه ی ECS تنها ۰.۳۷ میلی ثانیه (نخ اصلی ۰.۱۳، Jobها ۰.۲۴) طول کشید ،یعنی حدود ۴.۵ برابر سریع تر.
۷.۳ درس صادقانه: وقتی ECS کندتر می شود (تعامل با Texture)
در سناریوی رندر / به روزرسانی نقشه، ECS مجبور بود علاوه بر Command Buffer، داده ی رنگ را از یک Texture2D بگیرد، کپی و اعمال کند ،یعنی از دنیای داده محور بیرون بزند و با یک Unity Object تعامل کند. اینجا نتیجه معکوس شد: ECS ۱.۷۱ میلی ثانیه (نخ اصلی ۱.۶۸، Jobها ۰٫۰۳۳) در برابر MonoBehaviour ۱.۰۶ میلی ثانیه. حذف تغییر Texture، زمان نخ اصلی ECS را به طور مداوم ۱.۳۰ میلی ثانیه کوتاه کرد. در مجموع (رندر + منطق) ECS ۲.۰۸ در برابر OOP ۲.۷۴ میلی ثانیه بود. درس معماری روشن است: سربار تعامل با آبجکت های سنگین سنتی روی نخ اصلی برمی گردد و باید در طراحی لحاظ شود.
۷.۴ زمان های per-frame سیستم ها و بهره وری Chunk
در یک پروژه ی Unity ECS زمان های هر سیستم در هر فریم از پنل Debugger ثبت شد: aircraftSystem = ۰.۵۳، RenderMeshSystemV2 = ۱.۰۰، EndFrameTRSToLocalToWorldSystem = ۰٫۰۹، ExportPhysicsWorld =۰.۰۷، RenderBoundsUpdateSystem = ۰.۰۷ و چند سیستم سبک تر (میلی ثانیه در هر فریم). همچنین بهره وری Chunk گزارش شده ۹۵ و ۵۰ بود و موجودیت پیش فرض WorldTime مقادیر ElapsedTime و DeltaTime را نگه می داشت. این داده ها نشان می دهند که در ECS، رندر (RenderMeshSystemV2) اغلب سنگین ترین سیستم است، نه منطق شبیه سازی.
۷.۵ مقیاس پذیری: ۱۳×، ۹×، ۳× ،و یک استثناء مهم
پژوهش های مرجع، تصویری قدرتمند اما نه یک طرفه از مقیاس پذیری داده محوری می دهند: Männistö گزارش می کند DOTS تا ۳ برابر بهتر است، Näykki نشان می دهد ECS موازی ۱۳ برابر واحد بیشتر روی صفحه نگه می دارد و کد Burst به طور میانگین بیش از ۲ برابر کارایی می دهد، اما در بخش Animation رویکرد OOP ۳٫۵ برابر سریع تر از DOTS است، Borufka گزارش می کند ترکیب ECS + Job System + Burst ۹ برابر بهتر از MonoBehaviour کار می کند. برتری موازی سازی مشروط به تعداد بالای موجودیت است، در نمونه ی شبیه ساز پرواز با تنها یک موجودیت، مزیت بهره وری سخت افزار اصلا محقق نشد.
۷.۶ آزمون میدانی: شبیه سازی Life Below در Late-Game
یک نمونه ی واقعی از پایداری در بار سنگین، شبیه سازی اکوسیستم بازی Life Below است: یک سیو ۱۴ساعته با ۱۵.۰۰۰ موجودیت و بیش از ۴۵۰ سیستم فعال، در حالتی که Time Acceleration باعث می شود fixed update چندبار در هر فریم اجرا شود. با وجود این بار، شبیه سازی روان اجرا می شد: ۶۰ فریم بر ثانیه و تقریبا ۰.۵ میلی ثانیه زمان CPU در هر فریم برای شبیه سازی. نکته ی تعیین کننده: غیرفعال کردن Burst باعث شد شبیه سازی بیش از ۳ برابر طولانی تر شود ،شاهدی مستقیم بر نقش Burst در پایداری سیستم های بزرگ.
۷.۷ جابه جایی گلوگاه و مسئله ی رویدادها (Garbage)
دو یافته ی ظریف اما مهم را هم باید افزود. نخست، بهبود معماری CPU لزوما کل سیستم را سریع نمی کند، در ECS چندنخی، گلوگاه اغلب به GPU منتقل می شود (Gfx.WaitForPresent بین ۸ تا ۲۰ برابر زمان رندر). درس معماری: بهینه سازی یک بعد، بعد محدودکننده ی بعدی را آشکار می کند. دوم، در مقایسه ی UnityEvent با C# event (الگوی Observer)، رویدادهای UnityEvent دست کم 2 برابر کندتر هستند. رویدادهای #C هنگام فراخوانی (Invoke) هیچ زباله ای تولید نمی کنند، اما عمل ثبت نام و لغو ثبت نام (Subscribe/Unsubscribe) به خصوص هنگام استفاده از توابع بی نام (Lambda)، باعث تخصیص حافظه و تولید نمایی زباله می شود.
۸) ارزیابی معماری و ترید آف ها در چارچوب ATAM
برای ارزیابی روشمند، از واژگان کتاب Bass و مفاهیم کلیدی روش ATAM استفاده می کنیم (هرچند به دلیل محدودیت فضا، تمام فازهای رسمی مانند درخت مطلوبیت پیاده سازی نشده اند). نقطه ی حساسیت (Sensitivity Point) تصمیمی معماری است که اثری مشخص بر پاسخ یک ویژگی کیفی دارد، ترید آف (Trade-off) تصمیمی است که چند ویژگی کیفی به آن حساس اند و بهبود یکی به تضعیف دیگری می انجامد، و ریسک (Risk) تصمیمی مخاطره آمیز است.
۸.۱ نقاط حساس و ریسک ها
• چیدمان حافظه (Chunk پیوسته در برابر Heap پراکنده) یک نقطه ی حساس بحرانی است: کارایی مستقیما به data locality و اندازه ی کش CPU وابسته است و در OOP نرخ Cache Miss با تعداد موجودیت خطی رشد می کند و فروپاشی غیرخطی می سازد.
• انتخاب مدل چیدمان ECS (AoS در برابر SoA) نقطه ی حساس است: AoS هنگام iteration الگوی دسترسی تکه تکه دارد، SoA امکان SIMD و پایداری فریم بهتر می دهد (۶۵.۸۱ در برابر ۶۱.۵۱ FPS).
• رویداد immediate در سیستم موازی یک ریسک Race Condition است: مثلا در CollisionSystem نابودی فوری گلوله لازم است، اما اجرای موازی آن به دلیل تغییر هم زمان جدول archetype ناامن است.
• عدم اعمال به موقع رویداد staged یک ریسک Residual Conflict است: اگر رندر پیش از اعمال رویداد Destroy اجرا شود، موجودیت نابودشده رندر می شود، راهکار، sync barrier است.
• چندنخی CPU در ECS یک نقطه ی حساس است که گلوگاه را به GPU منتقل می کند (Gfx.WaitForPresent بین ۸ تا ۲۰ برابر رندر).
۸.۲ منحنی یادگیری و هزینه ی پیاده سازی
پذیرش معماری داده محور رایگان نیست. الزامات ساختاری DOTS (نصب پکیج های Entities/Burst/Jobs و Hybrid Renderer + URP، پیاده سازی با SystemBase و IComponentData، و فرآیند baking) به همراه boilerplate و تغییر ذهنیت، مانعی جدی است که در منابع حل نشده توصیف شده. محدودیت های زمان بندی نخ نیز وجود دارد: تغییرات ساختاری فقط روی نخ اصلی (WithoutBurst.Run) و زمان بندی پویا باید هر بار از نظر ایمنی بازبینی شود. در سمت SODD، معماری در حدود یک ماه ساخته شد و به دانش سریالایزیشن و ScriptableObject و افزونه ی Odin نیاز دارد. در مقابل، رویکردهایی مانند HECATE با نگاشت مفاهیم به ECS، منحنی یادگیری را از Steep به Moderate کاهش می دهند، حتی توسعه دهنده ی ناآشنا با ECS توانست با مطالعه ی فهرست System ها منطق را دنبال کند، هرچند معکوس شدن کنترل (inversion of control) در ECS پیچیدگی می افزاید.
۸.۳ ترید آف ها: چه چیزی فدای چه چیزی شد؟
جدول زیر جان کلام ارزیابی معماری است، اینکه هر تصمیم چه چیزی به دست آورد و چه چیزی را فدا کرد.


نکته ی مهم Bass این است که تاکتیک روی یک ویژگی کیفی واحد تمرکز دارد و درون تاکتیک ترید آف دیده نمی شود، اما در الگوهای معماری، ترید آف ها در خود الگو تعبیه شده اند. همچنین یافته ی Phalanx یادآوری می کند که مزیت ECS اغلب در Modifiability/Maintainability است نه لزوما سرعت خام، در Phalanx سرعت شبیه سازی تقریبا هم سطح سایر شبیه سازها ماند و اصول ECS حتی پیاده سازی پرمحاسبه ای را تحمیل کردند.
۹) همگرایی با مهندسی سیستم های توزیع شده: درس HECATE
یکی از جالب ترین یافته های این پژوهش این است که ECS/DOD صرفا یک ترفند کارایی بازی نیست، بلکه چارچوبی برای واردکردن مفاهیم مهندسی سیستم های توزیع شده به دامنه ای است که پیش تر تک پارچه بود. معماری HECATE نمونه ی شاخص این همگرایی است.
۹.۱ ساختار لایه ای و نقش Facade
HECATE یک معماری لایه ای سه گانه دارد:
Agent Abstraction Layer → ECS Core Layer → Infrastructure Layer، با اجتناب عمدی از کاپلینگ محکم بین لایه ها. عناصر آن همان سه گانه ی ECS است ،Entity (شناسه ی سبک)، Component (ظرف داده ی خالص) و System (پردازشگر منطق) ،به همراه مجموعه ای از Manager ها (Entity/Component/System/Event Manager) و یک Engine برای ارکستراسیون. مهم آنکه HECATE به عنوان یک Facade عمل می کند و پیچیدگی ECS را پنهان می کند، همچنین جداول نگاشت رسمی TAO→ECS ارائه می دهد تا انتزاعات مفهومی عامل ها به عناصر ECS نگاشته شوند و معنا حفظ گردد.
۹.۲ چرا این همگرایی مهم است؟
ارتباط رویداد-محور ECS ستون فقرات تعامل بدون کاپلینگ محکم است و از دو گونه رویداد پشتیبانی می کند: Immediate Events (بلافاصله) و Queued Events (به صف افزوده و در چرخه ی بعدی پردازش می شوند)، Event Manager رجیستری شنونده ها را نگه می دارد و رخدادها را dispatch می کند. همین ساختار است که پلی به مفاهیم توزیع شده می زند: بروکر پیام، مدل سرور/کلاینت و مقیاس پذیری افقی. به بیان دیگر، وقتی داده از رفتار جدا و ارتباط رویداد-محور شد، وارد کردن الگوهای سیستم های توزیع شده به موتور بازی طبیعی تر می شود. این هم راستا با کاربردهای فراتر از بازی ECS است: استفاده در co-simulation توزیع شده (Vico) و شبیه سازی GPU-محور یادگیری تقویتی (Madrona با رویکرد megakernel) نشان می دهد ECS یک الگوی عام معماری داده محور است، نه صرفا یک موتور بازی.
۹.۳ چالش های باز
این همگرایی هنوز کامل نیست. در HECATE، عملیات توزیع شده ی چندگره ای هنوز حل نشده است، تایید صوری (formal verification) وجود ندارد، انطباق با استاندارد FIPA-ACL برقرار نیست، و استدلال هنجاری پیچیده غایب است. در سطح کلان تر نیز منابع به فقدان معماری های عام و بازاستفاده پذیر فراپروژه ای اشاره می کنند: راه حل ها اغلب
game-/genre-/technology-specific می مانند و طراحی داده محور هنوز فقط سطحی مطالعه شده است. همچنین نبود صورت بندی رسمی برای معنای archetype در فریم ورک ها، استدلال درباره ی تعیین پذیری و جهش ساختاری را دشوار می کند.
۱۰) نتیجه گیری
این بررسی تطبیقی چند درس معماری روشن به دست می دهد. نخست، در مقیاس بالا دشمن کارایی الگوریتم نیست، چیدمان حافظه است، باید داده را برای پردازنده چید نه برای ذهن انسان، و همین است که چیدمان حافظه را از یک جزئیات پیاده سازی به یک نگرانی درجه یک معماری ارتقا می دهد. دوم، ECS و DOTS با محلی سازی داده، Burst و موازی سازی، دیوار کارایی شیءگرایی را می شکنند و اعداد ،از ۳۸۱ میلی ثانیه تا ۲ میلی ثانیه در آزمون Conway، و ۱،۶۸ در برابر ۰،۳۷ میلی ثانیه در به روزرسانی تایل ها ،این را تایید می کنند. سوم، SODD مسئله ی متفاوتی را حل می کند: انعطاف، جداسازی و مدیریت داده ی مستقل از صحنه، ابزار کاهش کاپلینگ، نه موتور کارایی خام. چهارم، معماری مولفه محور میان طبیعی بودن برای انسان و بازاستفاده پذیری Portability تعادل برقرار می کند.
اما مهم ترین درس، پیام مرکزی ATAM است: هیچ معماری ای مطلقا برنده نیست. هر تصمیم یک ترید آف است ،ECS سریع در تعامل با Texture کند می شود، بهبود CPU گلوگاه را به GPU می برد، و رویکرد شیءگرا در انیمیشن ۳.۵ برابر جلو می زند. کار ما به عنوان معمار، نه تعصب به یک پارادایم، بلکه شناخت این تعادل ها و انتخاب آگاهانه ی معماری متناسب با ویژگی های کیفی واقعی هر پروژه است. گذار از OOP به DOD نه یک جایگزینی کامل، بلکه یک همگرایی پراگماتیک (Hybrid) است: نگه داشتن آنچه OOP خوب انجام می دهد و سپردن بار سنگین داده به معماری داده محور.
هیچ معماری ای مطلقا بهتر نیست، انتخاب، تابع بافت مسئله است.
این مطلب، بخشی از تمرین های درس معماری نرم افزار در دانشگاه شهیدبهشتی است
منابع کلیدی بررسی شده
• Ylikoski ،پژوهش بنچمارک ECS در برابر MonoBehaviour در یونیتی، منبع اعداد به روزرسانی تایل/رندر و زمان های per-frame
• MY.GAMES / Ocean Hero ،گزارش صنعتی ECS روی موبایل، بنچمارک Conway (Conway/Job/Burst) و محرک های سخت افزاری معماری داده محور.
• The Essence of ECS ،مبانی مدل حافظه، Archetype/Chunk، AoS در برابر SoA، ایمنی هم روندی و مسائل باز.
• Benchmarking Unity DOTS ،سربار حافظه ی اولیه، جابه جایی گلوگاه به GPU و الزامات ساختاری DOTS.
• Pham (2020) ،Game Architectures in Unity Projects، مرجع اصلی معماری (SODD) ScriptableObject و نقد Singleton.
• Casals & Brandão (2025) ،HECATE: An ECS-based Framework، معماری لایه ای و همگرایی با سیستم های توزیع شده.
• Muratet & Garbarini (2020) ،Accessibility and serious games: ECS software architecture، سناریوی Modifiability.
• Mizutani و همکاران (2021) ،مرور نظام مند Software Architecture for Digital Game Mechanics، چالش های باز و MVC.
• Hansen & AL Halbouni (2020) ،A Scenario-Based Evaluation of Game Architecture.
• Ferrone ،مرجع مقایسه ی کارایی و Garbage میان C# events و UnityEvents، Object Pool، Dirty Flag و Data Locality.
• Baron ،الگوهای طراحی، ScriptableObject، Thread-safety و Coroutine.
• مطالعه ی کاپلینگ موتورها (Moose/Pharo، مدل Runtime Engine Architecture با ۱۶ زیرسیستم) و ارجاع به Cities Skylines 2 و Phalanx.
• Bass و همکاران ،Software Architecture in Practice، چارچوب ارزیابی ATAM و مفاهیم Trade-off/Sensitivity Point/Risk.