مسالهی پایداری سرورها در برابر سرریز بار (overload) و مسالهی کارایی و نیاز به منابع سختافزاری کمتر، دو مسالهی برادرند با راه حلهایی با کاربرد دوگانه. در یک مجموعه نوشتار که نوشتارِ پیشِ رو بخش نخست آن است، به نکاتی از این راه حلها میپردازیم. بدیهیست که هر سیستمی یکتاست و نکات گفته شده تنها برای ایده گرفتناند، و تعمدا در سطح مفاهیماند و نه تکنولوژی.
فرض کنید سرویسی داریم برساخته از یک یا چند job (مثال)، هر یک مستقر روی تعدادی نمونه (instance). در این نوشتار منظور از «سرور»، همین نمونههاست، نه سرور فیزیکی. در سرویسمان مشخصا در پی این هستیم:
در این نوشتار ارجاعهای فراوانی به این سرویس سرهمیِ فروشگاه اینترنتی خواهیم داشت که برای فهم بهتر از مثالها، دست کم مرور دیاگرام آن توصیه میشود. برای ملموس شدن هدفهایی که در بالا گفته شد، همین سرویس را در نظر بگیرید که چینش سختافزاری آن ۱۵ نمونه از job «میاندار» و ۱۰ تا «انبارگرد» و … است: در معماری نرمافزار و ارتباطات jobها چه کنیم تا: (۱) در برابر سرریز بار مقاوم باشیم؛ (۲) به مثلا ۲۰٪ نمونههای کمتر (۱۲ به جای ۱۵ و ۸ به جای ۱۰) نیاز داشته باشیم؟
۱.۱. اصلا بهینهسازی بکنیم؟
پیش از هر بهینهسازی در یک سیستم مستقر و جاافتاده، نخستین پرسش پیش از جَوگیری، تخمین هزینه و فایده است: در یک سو نفر-ساعت و در یک سو درصد صرفهجویی ضربدر هزینهی سختافزار. در شرکت ما یک فرمول مشخص و اصلا یک فرم تعاملی وِب برای این مقایسه وجود دارد که مثلا وارد میکنیم X هزار CPU Core یا Y ترابایت RAM و پاسخ میگیریم که ارزش Z نفر-سال کار را دارد؛ روشن است که این تنها یک تخمین حدودیست (مثلا در سخن از نفر-سال، کدام «نفر» با چه حقوقی؟) و با نام برازندهی «قانون سرانگشتی» معروف است. گردآوری یک سیستم تخمین سرانگشتی مشابه به نظاممند شدن تلاشها میان تیمها کمک میکند و بسیار توصیه میشود.
اگر نه یک سیستم جاافتاده بلکه در حال طراحی یک سیستم نو هستید، برخی نکاتی که گفته خواهد شد نیازمند کار اضافی نیست و بهتر است از روز اَزل رعایت شود تا این که بعدتر با هزینهی بیشتر اصلاح شود.
همچنین پیش از خیز برای بهینهسازی ساختاری، نخست، میوههای دمِ دستتر را میچینیم: با profile کردن برنامههای سرورها در محیط عملیاتی (مثلا بجویید pprof)، که جزییاتش فراتر از این نوشتار است و منابع آنلاین برایش فراوان.
۲.۱. راهحل معمول و ناکارا ولی شاید کافی
یک رویهی معمول در کنترل بار که احتمالا زیاد دیدهاید یا استفاده کردهاید، تنظیم «طول صف ورودی» و «تعداد threadها» و سپس سپردن سلامت و بهرهگیری سرورها به این دو سوییچِ نادقیق است. مثلا اگر نیاز شد بهرهگیری برنامه را بالا ببریم، طول صف ورودی یا تعداد threadها را افزایش میدهیم تا کار بیشتری برداشته شود. یا اگر زمان پاسخ گند خورد یا دچار سرریز بار (overload) شدیم، سراغ کاهش طول صف ورودی یا تعداد threadها میرویم. در فصل بعدی، این سیستم گوجه خیاری را بهتر میکنیم.
همچنین یک رویهی معمول، انتشار وضعیت میان jobها (مثلا گلوگاه شدن یکی و اثرش بر کل سیستم) به صورت صورت منفعلانه و غیرمستقیم است، یعنی اطلاعات شلوغی/خلوتی jobها مستقیما منتشر و بر اساسش تصمیمگیری نمیشود، بلکه روی این حساب میکنیم که خود سیستم همگرا شود: اگر job الف شلوغ شد و درخواستها را از صف ورودیاش برنداشت پس job ب که بالادست الف است پشت الف معطل میشود و درخواستهایش را برنمیدارد و صف ورودی ب پر میشود و … و به همین شکل بار مجموع سیستم (مثلا یک stack یا درخت از jobها) با ظرفیت گلوگاه تنظیم میشود، یعنی به سمت آن «همگرا» میشود - البته در تئوری. یک پیششرط بزرگ برای این تئوری این است که مقیاس زمانی همگرا شدنِ سیستم در پیِ تغییرات شلوغی/خلوتی یک job، کوچکتر از مقیاس زمانی خود تغییرات باشد، ولی در عمل همیشه چنین نیست. به این مثال برخواهیم گشت.
یک تکسرور را تصور کنید زیر بار مثلا ۱۰۰qps، و نمودار بهرهگیری CPU این سرور را در نظر بگیرید: احتمالا به طور پیوسته و با فرکانس بسیار بالا (در مقیاس صدُم ثانیه) بین مثلا ۶۰٪ و ۱۰۰٪ در نوسان است، با بهرهگیری میانگین ۸۰٪. اگر این بهرهگیری را کمی بالاتر ببریم، قلههای این نوسان از ۱۰۰٪ رد میشود و مشکلات پایداری و تاخیر آغاز میشود.
در این فصل یکی (و تنها یکی) از کارهایی را خواهیم دید که توان «۱۰۰qps در ۸۰٪ بهرهگیری» را به مثلا «۱۱۰qps در ۸۰٪» افزایش میدهد و همچنین دامنهی نوسان گفته شده را از ۱۰۰-۶۰ به مثلا ۹۰-۷۰ کاهش میدهد و در نتیجه امکان افزایش میانگین بهرهگیری از ۸۰٪ به ۹۰٪ را فراهم میکند (بدون تجاوز قلهها از ۱۰۰٪) و این یعنی ممکن شدن ۱۲۰qps و افزایش ۲۰٪ی ظرفیت سیستم. (همهی این عددها شکمیست.)
از بین طراحی کد با فراخوانیهای ناهمگام (asynchronous IO) با threadهای کم (مثلا تنها ۲ thread به ازای هر هستهی CPU) و طراحی با فراخوانیهای همگام با threadهای فراوان، برتریهای مدل نخست به ویژه زمانی که پایِ کارایی و پایداری در میان است بزرگ و روشن است - و اگر برای شما نیز از پیش چنین است میتوانید از ادامهی این نوشتار رد شوید. ولی شخصا سوگیری نادرست در این زمینه را زیاد دیدهام و بنابراین در این فصل به بازبینی پایهایِ این دو با مثال میپردازیم. علاوه بر صِرف پیروی از مدل ناهمگام، کارهای دیگری هم معمولا بر روی آن برای کارایی بیشتر قابل انجام است مانند گره زدن درخواستها به threadها (پیش و پس از بازگشت از IO) و threadها به هستههای پردازشی (بجویید affinity) و دادهساختارهای cpu local/per cpu (+) و غیره که فراتر از این نوشتارند.
۱.۲. از طراحی چه کُدی صحبت میکنیم؟
ماهیت ۹۸/۲٪ (!) برنامههای دنیا که اجزای یک سرویس آنلاین را میسازند این شکلیست: درخواست را بردار، مقداری کار پردازشی انجام بده (مثلا جابهجا کردن fieldهای کلاسها و protoها از این دست به آن دست)، سپس یک کار IO (مثلا فراخوانی یک backend یا مخزن داده یا غیره)، باز مقداری کار پردازشی (مثلا این بار مقداری محاسبهی)، باز فلان فراخوانی دیگر و … و تمام. مثلا فرض کنید «میاندار» در این سیستم نمونه، درخواست را از «جلودار» تحویل میگیرد، درخواست دیگری برای فرستادن به «مقرراتچی» و «فضول ملت» آماده میکند و آنها را فرامیخواند، سپس دادهها را تنگ هم میزند و «عقبدار » را فرا میخواند، روی نتیجه مقداری محاسبه انجام میدهد، و پاسخ را پس میفرستد به «جلودار».
چنین برنامهای چه شکلی طراحی میشود؟ طبیعتا با تشت (pool)هایی از threadها: چه با یک تشت برای سر تا ته رسیدگی به یک درخواست و چه با یک تشت جداگانه برای هر فاز یا هر مولفه از برنامه؛ چه با threadهای وصل به لایهی سیستم عامل (مثل threadهای ++C و Java) و چه thread-نماهای لایهی apllication (مثل fiberهای کتابخانهی boost) و چه میان این دو (مثل goroutineهای Go).
۲.۲. مدل همگام
یک رویهی معمول این است که threadها فراخوانیهای همگام / مسدود کننده (synchronous / blocking IO) میکنند. یعنی مثلا در مثال بالا یک تشت thread داریم برای مولفهی اِعمال مقررات، که بخشی از وظیفهاش فراخوانی «مقرراتچی» است: هر یک از threadهای این تشت، درخواست را میفرستد و میخوابد تا آمدن پاسخ.
یعنی threadها بخوابند؟ بله، ظاهرا اشکالی ندارد، چون میتوان تعداد thread را تا صدها یا حتی هزارها زیاد کرد تا اگر بیشترشان هم مسدود/خواب بودند باز به اندازهی کافی thread بیدار و مشغول بهرهگیری از CPU داشته باشیم. اگر هم بیشترشان بیدار بودند، سیستم آنها را به خوبی مدیریت میکند و تنها به اندازهی CPU موجود کار انجام خواهد شد و مشکلی نیست.
اشکال این مدل کجاست؟ موازیبازی، سواری مفتی نیست که یک خروار thread بسازیم و سیستم برای ما مدیریت بهینه کند، هر چه قدر هم که نرمافزار را عالی و بدون گلوگاهِ همروندی (concurrency) طراحی کنیم. کاوش چرایی این مساله فراتر از این نوشتار است و هم به سیستم عامل و سختافزار برمیگردد و هم تئوری صفها. باز هم برای تجسم درست، لازم است یک معیار تعریف کنیم تا به ما شهود کمّی بدهد:
شهود گرفتیم؟ حالا تعداد thread زیاد و فراخوانیهای همگام یعنی چه؟
۳.۲. مدل ناهمگام
در طراحی نرمافزارِ کارا/efficient، اگر فراخوانیهای متعدد یا با تاخیر بالا یا با تاخیر پرنوسان داریم، فراخوانیهای ناهمگام (asynchronous) احتمالا به شکل مشهودی کاراتر خواهند بود. ولی آیا لزوما با ناهمگامی جلو برویم؟
سودمندی مدل ناهمگام: مدل ناهمگام یعنی فراخوانی را انجام بده و خداحافظ؛ صبر نکن. یا یک callback بده که وقتی پاسخ آمد اجرایش کنیم برای انجام بقیهی کار پس از دریافت پاسخ، یا یک بیلبیلک (مثل یک شیء future یا task که روی آن wait یا await میکنیم) بگیر که هر وقت خواستی روی آن منتظر پاسخ شوی.
اضافهکاری بالا برای چیست؟ برای این که بعد از ارسال فراخوانی، کار thread به پایان برسد---تصور کنید میرسیم با پایان تابعی در کُد که thread صدا کرده بود---و thread برود سراغ برداشتن کار/درخواست بعدی از تشت. چرا؟
سختی مدل ناهمگام: سرراست در نیامدن کُد (مستقل از زبان و سکو) برای نوشتن و نگهداری. کدی که یک فراخوانی همگام را انجام دهد و در خط بعدی به بقیهی کار بپردازد (هرچند با یک خواب بزرگ این وسط)، سادهتر و قابل دنبال کردنتر از کد شکسته و دو تکه شده بین پیش و پسِ فراخوانی است - مثلا یک تابع جداگانهی ()HandleResponse پیچیده شده در یک callback یا future و رساندن دادههای لازم به آن. شاید در روز نخست خیلی ساده و تمیز باشد ولی به مرور که کُدها بزرگ شدند، callbackها/futureها بین چند تابع دست به دست میشوند تا به نقطهی استفاده (فراخوانی ناهمگام) برسند، به مرور هر کدام هم چیزی به تَنگ callback میزنند تا پیش/پس از آن اجرا شود، زنجیرهها تشکیل میشوند و خلاصه نگهداری و اشکالزدایی در این فضا را سختتر میکنند.
نتیجه: نابهینگی در کارایی و بهرهگیری سرور (هزینهی سختافزار) یا نوسان در زمان پاسخ سرور چه قدر برای سرویسمان مهم است؟ تفاوت کارایی و زمان پاسخ بین دو مدل همگام و ناهمگام چه قدر خواهد بود؟ (کاملا بسته به ماهیت کار و زبان برنامهنویسی و لایهی threading است؛ ارزش یک پیادهسازی شبیهسازانه و تحلیل پیش از تعهد به یکی از دو مدل را دارد.) تفاوت پیچیدگی کد ما در مدل همگام و ناهمگام چه قدر خواهد بود؟ اصلا از چه threadهایی استفاده خواهیم کرد؟ اینها پرسشهاییست که طراحی ما را کارگردانی میکند. در سرویسهایی که بنده شخصا درگیرشان بودم، هر جا کارایی یا منابع پردازشی یا پایداری زمان پاسخ مهم بوده، ناهمگام کار کردیم، و در سرویسهای سادهتر و زیر بار سبک یا گهگاهی، همگام.
مطالب این فصل در راستای: (۱) کاهش دامنهی نوسانهای بهرهگیریِ لحظهایِ سرور، و (۲) بالا بردن معیار QPS per core که در مقدمه اشاره شد بود؛ هر دو تنها در سطح تک سرور. هنوز تا یک سیستم توزیع شدهی پایدار و کارا خیلی مانده و در بخشهای بعدیِ این مجموعه به آنها خواهیم پرداخت.