کتابخانه‌ی استاندارد · زمان و همروندی

استخر pool

حلقه‌ی موازی، استخر کارگر محدود، وظیفه‌های شبیه گوروتین، گروه با خطا و آینده.

واردسازی استخر

نام آرگومان‌ها شناسه‌ی خود کد است و معادل فارسی ندارد؛ گونه‌ها، کلیدواژه‌ها و نام بسته‌ها با معادل فارسی نوشته می‌شوند.

اگر هر دور یک حلقه مستقل از بقیه است، مثل پردازش جداگانه‌ی هر خانه‌ی یک آرایه، برای موازی دورها را بین چند نخ کارگر پخش می‌کند و تا پایان همه صبر می‌کند. بدنه‌ی حلقه یک تابع با ورودی صحیح۶۴ است که شماره‌ی دور را می‌گیرد.

این بسته یک استخر کارگر ماندگار و محدود هم دارد، پاسخ سلام به گوروتین. نخ‌ساز برای هر فراخوانی بی‌هیچ سقفی یک نخ سیستم‌عامل می‌سازد؛ اما استخر نخ نخ‌هایش را یک بار راه می‌اندازد و هرگز بیشتر نمی‌کند، حداکثر به اندازه‌ی queue وظیفه در صف نگه می‌دارد و وقتی صف پر است ارسال منتظر می‌ماند، پس تولیدکننده‌ی تند نمی‌تواند کار بی‌پایان روی هم تلنبار کند. برو وظیفه را روی یک استخر مشترک به اندازه‌ی هسته‌ها اجرا می‌کند، گروه کار تعداد وظیفه‌های هم‌زمان را محدود می‌کند و اولین خطا را نگه می‌دارد، و ناهمزمان یک آینده برمی‌گرداند که با منتظر ماندن نتیجه‌اش را می‌گیرید. برای دریافت از چند کانال، گزینش را در کانال ببینید.

وظیفه‌ها نخ هستند نه نخ سبز: وظیفه‌ای که مسدود شود کارگرش را مشغول نگه می‌دارد، پس یک وظیفه نباید منتظر وظیفه‌ای بماند که پشت سرش در صف است. وقتی وظیفه‌ها خودشان وظیفه می‌فرستند از ارسال با اجرای مستقیم استفاده کنید. برای داده‌ی مشترک، همگام سازی و اتمی را ببینید.

اشتباه‌های رایج:

  • تکیه بر ترتیب دورها، یا تغییر داده‌ی مشترک از درونشان بدون قفل. نوشتن هر دور در خانه‌ی خودش امن است؛ هر چیز دیگری اتمی یا قفل لازم دارد.
  • دورهای خیلی کوچک. گرفتن شماره‌ی دور بعدی یک قفل هزینه دارد و هر فراخوانی نخ می‌سازد و به آن‌ها می‌پیوندد، پس هر دور باید کار قابل‌توجهی انجام دهد (تکه‌ها را ببینید).
  • صدا زدن برای موازی در یک حلقه‌ی پرتکرار. هر فراخوانی هزینه‌ی ساختن نخ را می‌پردازد؛ حلقه‌ی بیرونی را موازی کنید، نه درونی را.

هر دور یک سطر

بهترین جا برای برای موازی داده‌ای است که سطر به سطر چیده شده، مثل پیکسل‌های یک تصویر یا خط‌های یک جدول. هر دور را مسئول یک سطر کنید: دورها به حافظه‌های جدا دست می‌زنند، پس قفل نمی‌خواهند و نتیجه به هر ترتیبی که اجرا شده باشند یکی است.

pool-guide-pixels.salam
واردسازی استخر
واردسازی حافظه
واردسازی رشته

ناپایا پیکسل‌ها := پوچ برگردان صحیح*
پهنا := ۸
بلندا := ۶

تابع روشن کردن سطر(ع: صحیح۶۴):
    تکرار پهنا در س:
        ای := (ع برگردان صحیح) * پهنا + س
        ناپایا م := پیکسل‌ها[ای] + ۶۰
        اگر م > ۲۵۵:
            م = ۲۵۵
        پایان
        پیکسل‌ها[ای] = م
    پایان
پایان

تابع ریشه:
    پیکسل‌ها = حافظه.تخصیص صفرشده(اندازه‌گونه(صحیح) * ((پهنا * بلندا) برگردان طبیعی۶۴)) برگردان صحیح*
    تکرار پهنا * بلندا در ای:
        پیکسل‌ها[ای] = (ای * ۳۷) % ۲۵۶
    پایان
    استخر.برای موازی(بلندا، ۳، (ع: صحیح۶۴): روشن کردن سطر(ع) پایان)
    تکرار بلندا در ع:
        ناپایا خط := ""
        تکرار پهنا در س:
            خط = خط + رشته.از عدد(پیکسل‌ها[ع * پهنا + س]) + " "
        پایان
        سرچاپ خط.پیراست()
    پایان
    حافظه.آزادسازی(پیکسل‌ها برگردان تهی*)
پایان
خروجی60 97 134 171 208 245 255 63 100 137 174 211 248 255 66 103 140 177 214 251 255 69 106 143 180 217 254 255 72 109 146 183 220 255 255 75 112 149 186 223 255 255 78 115 152 189 226 255

بدنه‌ی حلقه این‌جا یک لامبدای کوتاه است که یک تابع نام‌دار را صدا می‌زند. اگر کار اصلی در تابع نام‌دار باشد، می‌توانید آن را جدا و بدون هیچ نخی آزمایش کنید.

تکه‌ها، نه تک‌تک قلم‌ها

هر دور هزینه‌ی کوچکی برای خودش دارد، پس یک میلیون دور که هر کدام یک عدد را جمع می‌کنند بیشتر وقتشان صرف حساب‌وکتاب می‌شود تا جمع. به‌جای آن کار را به چند تکه‌ی بزرگ ببرید، هر دور را مسئول یک تکه کنید تا نتیجه‌ی جزئی‌اش را در خانه‌ی خودش بنویسد، و در پایان خانه‌ها را روی نخ اصلی با هم جمع کنید.

pool-guide-chunks.salam
واردسازی استخر
واردسازی حافظه

ناپایا جزئی := پوچ برگردان صحیح۶۴*
کل عددها := ۱۰۰۰۰۰۰ برگردان صحیح۶۴
تکه‌ها := ۸

تابع جمع تکه(ت: صحیح۶۴):
    اندازه := کل عددها / (تکه‌ها برگردان صحیح۶۴)
    اول := ت * اندازه + ۱
    ناپایا آخر := اول + اندازه - ۱
    اگر ت == تکه‌ها برگردان صحیح۶۴ - ۱:
        آخر = کل عددها
    پایان
    ناپایا ج := ۰ برگردان صحیح۶۴
    ناپایا ع := اول
    تا ع <= آخر:
        ج += ع
        ع++
    پایان
    جزئی[ت] = ج
پایان

تابع ریشه:
    جزئی = حافظه.تخصیص صفرشده(اندازه‌گونه(صحیح۶۴) * (تکه‌ها برگردان طبیعی۶۴)) برگردان صحیح۶۴*
    استخر.برای موازی خودکار(تکه‌ها، (ت: صحیح۶۴): جمع تکه(ت) پایان)
    ناپایا جمع := ۰ برگردان صحیح۶۴
    تکرار تکه‌ها در ت:
        جمع += جزئی[ت]
    پایان
    سرچاپ "تکه‌ها:"، تکه‌ها
    سرچاپ "جمع ۱ تا"، کل عددها، "="، جمع
    سرچاپ "درستی:"، جمع == کل عددها * (کل عددها + ۱) / ۲
    حافظه.آزادسازی(جزئی برگردان تهی*)
پایان
خروجیتکه‌ها: 8 جمع ۱ تا 1000000 = 500000500000 درستی: true

برای موازی خودکار تعداد کارگرها را از تعداد پردازنده‌ها برمی‌دارد. چند تکه برای هر کارگر اندازه‌ی خوبی است: آن‌قدر که اگر بعضی تکه‌ها کندتر بودند کار میان کارگرها پخش شود، و آن‌قدر کم که هزینه‌ی اضافه کوچک بماند.

جمع کردن نتیجه با شمارنده‌ی اتمی

وقتی دورها چیزی تولید می‌کنند که باید در یک جا جمع شود، مثل تعداد موارد پیداشده، ساده‌ترین انتخاب امن یک اتمی.صحیح۶۴ است. این‌جا هر عدد کوچک‌تر از ۱۰۰۰۰۰ یک دور است و هر دوری که عدد اول پیدا کند یکی به شمارنده‌ی مشترک می‌افزاید.

pool-guide-primes.salam
واردسازی استخر
واردسازی اتمی

ناپایا پیداشده := اتمی.صحیح۶۴ {}

تابع اول است(ع: صحیح۶۴): منطقی:
    اگر ع < ۲:
        برگشت نادرست
    پایان
    ناپایا م := ۲ برگردان صحیح۶۴
    تا م * م <= ع:
        اگر ع % م == ۰:
            برگشت نادرست
        پایان
        م++
    پایان
    برگشت درست
پایان

تابع ریشه:
    پیداشده = اتمی.صحیح۶۴ جدید(۰)
    استخر.برای موازی(۱۰۰۰۰۰، استخر.تعداد پردازنده()، (ع: صحیح۶۴):
        اگر اول است(ع):
            اتمی.افزودن(پیداشده، ۱)
        پایان
    پایان)
    سرچاپ "عددهای اول کوچک‌تر از ۱۰۰۰۰۰:"، اتمی.بارگذاری(پیداشده)
    اتمی.نابودسازی صحیح۶۴(پیداشده)
پایان
خروجیعددهای اول کوچک‌تر از ۱۰۰۰۰۰: 9592

یک افزودن اتمی برای هر مورد پیداشده وقتی خوب است که این موارد نسبت به کار هر دور کم باشند. اگر قرار است هر دور شمارنده را تغییر دهد، مثل بخش قبل از نتیجه‌ی جزئی برای هر تکه استفاده کنید.

قاعده‌های بدنه‌ی حلقه

  • هرگز به ترتیب دورها تکیه نکنید. دور ۵ ممکن است پیش از دور ۰ تمام شود.
  • هر دور آزادانه می‌تواند در خانه‌ی خودش بنویسد. هر چیز مشترکی همگام سازی.قفل یا یک مقدار اتمی می‌خواهد.
  • از درون بدنه‌ی حلقه چاپ نکنید؛ خط‌ها درهم می‌شوند. نتیجه‌ها را نگه دارید و پس از برگشتن برای موازی چاپ کنید.
  • برای موازی منتظر همه‌ی دورها می‌ماند، پس همین که برگشت همه‌ی نتیجه‌ها آماده‌اند و پیوستنی لازم نیست.
  • حلقه‌های کوچک بدون نخ سریع‌ترند. فقط وقتی موازی کنید که یک بار اجرای حلقه زمان قابل‌توجهی بگیرد.

گونه‌ها

گروه کار Group

ساختار گروه کار
مجموعه‌ای از وظیفه‌ها با سقف تعداد اجرای هم‌زمان و یک خطای اول مشترک.
نامانگلیسیگونهتوضیح
وضعیتstateتهی*وضعیت درونی گروه.
pool-Group.salam
واردسازی استخر

تابع check(n: صحیح): رشته:
    اگر n برابر 7:
        برگشت "item 7 is bad"
    پایان
    برگشت ""
پایان

تابع ریشه:
    جی := استخر.گروه کار جدید(3 برگردان صحیح۶۴)
    تکرار 20 در شمارنده:
        استخر.گروه برو(جی، (): برگشت check(شمارنده) پایان)
    پایان
    سرچاپ استخر.گروه انتظار(جی)
    سرچاپ استخر.گروه شکست خورده(جی)
    استخر.گروه توقف(جی)
پایان
خروجیitem 7 is bad true

آینده Future

ساختار آینده
نتیجه‌ی وظیفه‌ای که هنوز در حال اجراست.
نامانگلیسیگونهتوضیح
مقدارvalueصحیح۶۴*خانه‌ای که نتیجه صحیح۶۴ را نگه می‌دارد.
متنtextرشته*خانه‌ای که نتیجه متنی را نگه می‌دارد.
انجام شدdoneصحیح۶۴*پرچمی که با پایان وظیفه تنظیم می‌شود.
قفلmuهمگام سازی.قفلقفل دور نتیجه.
شرطcvهمگام سازی.متغیر شرطشرطی که منتظر نتیجه را بیدار می‌کند.
pool-Future.salam
واردسازی استخر

تابع fib(n: صحیح۶۴): صحیح۶۴:
    اگر n کوچکتر 2:
        برگشت n
    پایان
    برگشت fib(n - 1) + fib(n - 2)
پایان

تابع ریشه:
    ویژگی_محلی := استخر.جدید(2 برگردان صحیح۶۴، 4 برگردان صحیح۶۴)
    الف := استخر.ناهمزمان(ویژگی_محلی، (): برگشت fib(25 برگردان صحیح۶۴) پایان)
    بافر_محلی := استخر.ناهمزمان متن(ویژگی_محلی، (): برگشت "done" پایان)
    سرچاپ استخر.منتظر ماندن(الف)
    سرچاپ استخر.منتظر ماندن متن(بافر_محلی)
    سرچاپ استخر.آماده(الف)
    استخر.رها کردن(الف)
    استخر.رها کردن(بافر_محلی)
    استخر.توقف(ویژگی_محلی)
پایان
خروجی75025 done true

استخر نخ Pool

ساختار استخر نخ
استخر محدودی از نخ‌های کارگر.
نامانگلیسیگونهتوضیح
وضعیتstateتهی*وضعیت درونی استخر.
pool-Pool.salam
واردسازی حافظه
واردسازی استخر
واردسازی همگام سازی

ناپایا انجام := پوچ برگردان صحیح۶۴*
ناپایا متغیر_gate := پوچ برگردان صحیح۶۴*

تابع work:
    همگام سازی.خواب میلی ثانیه(2)
    اتمی‌بیفزا(انجام، 1 برگردان صحیح۶۴)
پایان

تابع hold:
    تا اتمی‌بخوان(متغیر_gate) نابرابر 0:
        همگام سازی.خواب میلی ثانیه(1)
    پایان
پایان

تابع ریشه:
    انجام = حافظه.تخصیص صفرشده(8 برگردان طبیعی۶۴) برگردان صحیح۶۴*
    متغیر_gate = حافظه.تخصیص صفرشده(8 برگردان طبیعی۶۴) برگردان صحیح۶۴*

    ویژگی_محلی := استخر.جدید(4 برگردان صحیح۶۴، 8 برگردان صحیح۶۴)
    سرچاپ "workers: "، استخر.کارگرها(ویژگی_محلی)
    تکرار 100:
        استخر.ارسال(ویژگی_محلی، (): work() پایان)
    پایان
    استخر.انتظار(ویژگی_محلی)
    سرچاپ "finished: "، اتمی‌بخوان(انجام)
    استخر.توقف(ویژگی_محلی)

    کیو := استخر.جدید(1 برگردان صحیح۶۴، 1 برگردان صحیح۶۴)
    اتمی‌بنویس(متغیر_gate، 1 برگردان صحیح۶۴)
    استخر.ارسال(کیو، (): hold() پایان)
    تا استخر.در حال اجرا(کیو) برابر 0:
        همگام سازی.خواب میلی ثانیه(1)
    پایان
    سرچاپ "queued: "، استخر.تلاش برای ارسال(کیو، (): work() پایان)
    سرچاپ "full: "، استخر.تلاش برای ارسال(کیو، (): work() پایان)
    سرچاپ "pending: "، استخر.در صف(کیو)
    اتمی‌بنویس(متغیر_gate، 0 برگردان صحیح۶۴)
    استخر.توقف(کیو)
    سرچاپ "drained: "، اتمی‌بخوان(انجام)

    حافظه.آزادسازی(انجام برگردان تهی*)
    حافظه.آزادسازی(متغیر_gate برگردان تهی*)
پایان
خروجیworkers: 4 finished: 100 queued: true full: false pending: 1 drained: 101

تابع‌ها

تعداد پردازنده CPUCount

تابع تعداد پردازنده(): صحیح۶۴
تعداد هسته‌های فعال پردازنده؛ دست‌کم ۱.
pool-ParallelFor.salam
واردسازی استخر
واردسازی حافظه

ناپایا مربع‌ها := پوچ برگردان صحیح۶۴*

تابع ریشه:
    سرچاپ استخر.تعداد پردازنده() >= ۱
    مربع‌ها = حافظه.تخصیص صفرشده(۸۰ برگردان طبیعی۶۴) برگردان صحیح۶۴*
    استخر.برای موازی(۱۰، ۴، (ای: صحیح۶۴): مربع‌ها[ای] = ای * ای پایان)
    ناپایا جمع := ۰ برگردان صحیح۶۴
    تکرار ۱۰ در ای:
        جمع += مربع‌ها[ای]
    پایان
    سرچاپ جمع
    استخر.برای موازی خودکار(۱۰، (ای: صحیح۶۴): مربع‌ها[ای] = -ای پایان)
    سرچاپ مربع‌ها[۹]
    حافظه.آزادسازی(مربع‌ها برگردان تهی*)
پایان
خروجیtrue 285 -9

برای موازی ParallelFor

تابع برای موازی(n: صحیح۶۴، workers: صحیح۶۴، body: تابع(صحیح۶۴))
بدنه را برای شماره‌های صفر تا n - 1 روی workers نخ تازه، حداکثر n نخ، اجرا می‌کند و وقتی همه‌ی دورها تمام شدند برمی‌گردد. اگر n صفر یا کمتر باشد کاری نمی‌کند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-ParallelFor.salam

برای موازی خودکار ParallelForAuto

تابع برای موازی خودکار(n: صحیح۶۴، body: تابع(صحیح۶۴))
مثل برای موازی، با یک نخ برای هر هسته طبق تعداد پردازنده.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-ParallelFor.salam

جدید New

تابع جدید(workers: صحیح۶۴، queue: صحیح۶۴): استخر نخ
یک استخر با workers نخ و جا برای queue وظیفه‌ی منتظر می‌سازد. هر دو دست‌کم یک می‌شوند. تعداد نخ‌ها هرگز بیشتر نمی‌شود.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Pool.salam

جدید کشسان NewElastic

تابع جدید کشسان(min: صحیح۶۴، max: صحیح۶۴، queue: صحیح۶۴): استخر نخ
مثل جدید، اما با min کارگر شروع می‌کند و هر بار که وظیفه‌ای منتظر است و همه‌ی کارگرها مشغول‌اند یکی اضافه می‌کند، تا max. هرگز از max بیشتر نمی‌شود و کم هم نمی‌شود. وقتی وظیفه‌ها ممکن است منتظر هم بمانند از آن استفاده کنید.
pool-Elastic.salam
واردسازی کانال
واردسازی حافظه
واردسازی استخر

ناپایا جعبه := کانال.کانال {} برگردان کانال.کانال<صحیح۶۴>
ناپایا گرفته := پوچ برگردان صحیح۶۴*

تابع waiter():
    ناپایا موفق := نادرست
    مقدار_محلی := جعبه.دریافت(موفق)
    اتمی‌بنویس(گرفته، مقدار_محلی)
پایان

تابع sender():
    جعبه.فرستادن(7 برگردان صحیح۶۴)
پایان

تابع ریشه:
    جعبه.مقداردهی(1 برگردان صحیح۶۴)
    گرفته = حافظه.تخصیص صفرشده(8 برگردان طبیعی۶۴) برگردان صحیح۶۴*
    ویژگی_محلی := استخر.جدید کشسان(1 برگردان صحیح۶۴، 4 برگردان صحیح۶۴، 8 برگردان صحیح۶۴)
    سرچاپ "start: "، استخر.کارگرها(ویژگی_محلی)
    استخر.ارسال(ویژگی_محلی، (): waiter() پایان)
    استخر.ارسال(ویژگی_محلی، (): sender() پایان)
    استخر.انتظار(ویژگی_محلی)
    سرچاپ "received: "، اتمی‌بخوان(گرفته)
    سرچاپ "grew: "، استخر.کارگرها(ویژگی_محلی) بزرگتر 1
    سرچاپ "capped: "، استخر.کارگرها(ویژگی_محلی) کوچکتربرابر 4
    استخر.توقف(ویژگی_محلی)
    جعبه.آزادسازی()
    حافظه.آزادسازی(گرفته برگردان تهی*)
پایان
خروجیstart: 1 received: 7 grew: true capped: true

جدید خودکار NewAuto

تابع جدید خودکار(): استخر نخ
استخری با یک کارگر برای هر هسته و صفی چهار برابر آن.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Pool.salam

ارسال Submit

تابع ارسال(p: استخر نخ، task: تابع()): منطقی
یک وظیفه را در صف می‌گذارد. تا پر بودن صف صبر می‌کند، و همین فشار برگشتی استخر را محدود نگه می‌دارد. فقط وقتی استخر متوقف شده باشد نادرست برمی‌گرداند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Pool.salam

تلاش برای ارسال TrySubmit

تابع تلاش برای ارسال(p: استخر نخ، task: تابع()): منطقی
بی‌صبر کردن وظیفه را در صف می‌گذارد. اگر صف پر یا استخر متوقف باشد نادرست برمی‌گرداند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Pool.salam

انتظار Wait

تابع انتظار(p: استخر نخ)
صبر می‌کند تا صف خالی شود و هیچ وظیفه‌ای در حال اجرا نباشد. بعدش می‌شود دوباره از استخر استفاده کرد.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Pool.salam

توقف Stop

تابع توقف(p: استخر نخ)
وظیفه‌های صف را تمام می‌کند، به کارگرها می‌پیوندد و استخر را آزاد می‌کند. پس از آن از استخر استفاده نکنید.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Pool.salam

در حال اجرا Running

تابع در حال اجرا(p: استخر نخ): صحیح۶۴
تعداد وظیفه‌هایی که الان در حال اجرا هستند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Pool.salam

در صف Pending

تابع در صف(p: استخر نخ): صحیح۶۴
تعداد وظیفه‌هایی که در صف منتظرند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Pool.salam

کارگرها Workers

تابع کارگرها(p: استخر نخ): صحیح۶۴
تعداد نخ‌های کارگر استخر.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Pool.salam

ارسال با اجرای مستقیم SubmitOrRun

تابع ارسال با اجرای مستقیم(p: استخر نخ، task: تابع())
وظیفه را در صف می‌گذارد، یا اگر صف پر بود روی همین نخ اجرایش می‌کند. برای وظیفه‌هایی که وظیفه می‌فرستند امن است.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Pool.salam

برو Go

تابع برو(task: تابع())
وظیفه را روی یک استخر مشترک با یک کارگر برای هر هسته اجرا می‌کند؛ استخر در اولین استفاده ساخته می‌شود.
pool-Go.salam
واردسازی حافظه
واردسازی استخر

ناپایا برخوردها := پوچ برگردان صحیح۶۴*

تابع ریشه:
    برخوردها = حافظه.تخصیص صفرشده(8 برگردان طبیعی۶۴) برگردان صحیح۶۴*
    تکرار 100:
        استخر.برو((): اتمی‌بیفزا(برخوردها، 1 برگردان صحیح۶۴) پایان)
    پایان
    استخر.انتظار برو()
    سرچاپ اتمی‌بخوان(برخوردها)
    حافظه.آزادسازی(برخوردها برگردان تهی*)
پایان
خروجی100

انتظار برو GoWait

تابع انتظار برو()
صبر می‌کند تا همه‌ی وظیفه‌هایی که با برو شروع شدند تمام شوند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Go.salam

گروه کار جدید NewGroup

تابع گروه کار جدید(limit: صحیح۶۴): گروه کار
گروهی می‌سازد که هر بار حداکثر limit وظیفه را اجرا می‌کند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Group.salam

گروه برو GroupGo

تابع گروه برو(g: گروه کار، task_fn: تابع(): رشته): منطقی
وظیفه‌ای را اضافه می‌کند که متن خطا برمی‌گرداند، خالی یعنی موفق. وقتی یکی از وظیفه‌ها شکست بخورد، وظیفه‌هایی که هنوز شروع نشده‌اند رد می‌شوند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Group.salam

گروه شکست خورده GroupFailed

تابع گروه شکست خورده(g: گروه کار): منطقی
درست است اگر یکی از وظیفه‌های گروه خطا برگردانده باشد.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Group.salam

گروه انتظار GroupWait

تابع گروه انتظار(g: گروه کار): رشته
منتظر گروه می‌ماند و متن اولین خطا یا یک متن خالی برمی‌گرداند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Group.salam

گروه توقف GroupStop

تابع گروه توقف(g: گروه کار)
گروه و نخ‌هایش را آزاد می‌کند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Group.salam

ناهمزمان Async

تابع ناهمزمان(p: استخر نخ، task_fn: تابع(): صحیح۶۴): آینده
وظیفه‌ای را که صحیح۶۴ برمی‌گرداند اجرا می‌کند و یک آینده برایش برمی‌گرداند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Future.salam

ناهمزمان متن AsyncStr

تابع ناهمزمان متن(p: استخر نخ، task_fn: تابع(): رشته): آینده
مثل ناهمزمان برای وظیفه‌ای که متن برمی‌گرداند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Future.salam

منتظر ماندن Await

تابع منتظر ماندن(f: آینده): صحیح۶۴
منتظر وظیفه می‌ماند و نتیجه‌ی صحیح۶۴ آن را برمی‌گرداند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Future.salam

منتظر ماندن متن AwaitStr

تابع منتظر ماندن متن(f: آینده): رشته
منتظر وظیفه می‌ماند و نتیجه‌ی متنی آن را برمی‌گرداند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Future.salam

آماده Ready

تابع آماده(f: آینده): منطقی
درست است اگر وظیفه تمام شده باشد، بی‌آنکه صبر کند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Future.salam

رها کردن Release

تابع رها کردن(f: آینده)
پس از گرفتن نتیجه، آینده را آزاد می‌کند.

نمونه‌ی این مورد همراه با موارد بالاتر آمده است: pool-Future.salam

نگاشت موازی Map

تابع نگاشت موازی(n: صحیح۶۴، workers: صحیح۶۴، task_fn: تابع(صحیح۶۴): صحیح۶۴): وکتور<صحیح۶۴>
تابع را برای 0 تا n - 1 روی حداکثر workers نخ صدا می‌زند و نتیجه‌ها را به ترتیب برمی‌گرداند.
pool-Map.salam
واردسازی استخر

تابع ریشه:
    متغیر_squares := استخر.نگاشت موازی(10 برگردان صحیح۶۴، 4 برگردان صحیح۶۴، (شمارنده: صحیح۶۴): برگشت شمارنده * شمارنده پایان)
    سرچاپ "count: "، متغیر_squares.طول()
    ناپایا مجموع := 0 برگردان صحیح۶۴
    تکرار متغیر_squares.طول() در شمارنده:
        مجموع += متغیر_squares.بگیر(شمارنده)
    پایان
    سرچاپ "sum: "، مجموع
    سرچاپ "first and last: "، متغیر_squares.بگیر(0)، متغیر_squares.بگیر(9)
    سرچاپ "empty: "، استخر.نگاشت موازی(0 برگردان صحیح۶۴، 4 برگردان صحیح۶۴، (شمارنده: صحیح۶۴): برگشت شمارنده پایان).طول()
پایان
خروجیcount: 10 sum: 285 first and last: 0 81 empty: 0