الجزء الخامس: هندسة بلا تخصيص للذاكرة في Rust¶
نتتبع اتصالًا من قبوله إلى الاستجابة عبر مخزن مؤقت واحد ثابت الحجم، وندرس هياكل البيانات المتزامنة التي تتيح لكثير من خيوط الاتصالات مشاركة الحالة دون تخصيص في الكومة على مسار الطلب. وحيث تحتاج سلامة الذاكرة في العادة إلى آليات خاصة بها (عدادات القراء، والساحات، وجداول الواصفات، وسلاسل التفكيك)، نبين كيف توفرها ملكية Rust بدلًا منها.
حلقة الاتصال¶
خيط لكل اتصال، بحد أعلى¶
يتشارك عمال استقبال الاتصالات (--workers، واحد لكل وحدة CPU افتراضيًا، و64 على الأكثر) مقبس الاستماع. يُسلَّم كل اتصال مُستقبَل إلى خيط خاص به مع مكدس من ميغابايت واحد، وتعود حلقة استقبال الاتصالات مباشرة إلى accept. الخيط الذي ينهي اتصاله يتوقف وينتظر ثم يأخذ الاتصال التالي، لأن إنشاء خيط وإنهاءه لكل اتصال كان يعطل الخيوط الأخرى (الجزء الثامن، SID 0002). أما البديل، أي خدمة الاتصال حتى نهايته على خيط الاستقبال، فكان التصميم الأول: كانت قياساته جيدة مع عميل واحد وسيئة مع أربعة وستين، لأن ستين منهم انتظروا عاملًا حتى ينهي حصته من 256 طلبًا، ونما زمن الاستجابة في الذيل مع كل عميل منتظر. مع خيط لكل اتصال، يبقى p99 عند 64 اتصالًا تحت ميلي ثانية واحدة في كل عبء عمل للمنتج الكامل، من 305 us إلى 857 us (benchmarks/results/product-latest.md؛ الجزء الثامن).
عدد خيوط الاتصالات محدود بـ --max-connections (1,024 افتراضيًا، و8,192 على الأكثر). بعد هذا الحد، تجيب حلقة استقبال الاتصالات بـ 503 Service Unavailable على المقبس الجديد وتغلقه دون أن تطلق أي خيط، وتُحصي الحدث في sibuna_overloaded_total.
fn accept_loop(server: &Arc<Server>, listener: &TcpListener) {
while !server.is_stopping() {
let stream = match listener.accept() {
Ok((stream, _)) => stream,
// ... نفدت الواصفات أو الذاكرة: انتظر 1 ms بدل الدوران
};
let limit = server.max_connections.load(Ordering::Relaxed);
if server.connections.fetch_add(1, Ordering::Relaxed) >= limit {
server.connections.fetch_sub(1, Ordering::Relaxed);
server.metrics.overloaded.bump();
let text = "Service Unavailable: connection limit reached";
reject(server, &stream, text);
continue;
}
set_no_delay(&stream);
let task_server = Arc::clone(server);
let launched = server.tasks.launch(move || {
let _counted = Counted(&task_server);
crate::connection::serve(&task_server, &stream);
});
// ... إخفاق الإطلاق يعيد المكان ويُحصي حالة حمل زائد
}
}
Counted حارس يعيد Drop الخاص به مكان الاتصال ضمن الحد أيًّا كانت طريقة انتهاء الخيط، بالعودة أو بالذعر. يستنزف مسار 503 ما أرسله العميل قبل أن يغلق جانبه من المقبس: إغلاق مقبس فيه بايتات غير مقروءة يُرسل إعادة ضبط (reset)، وإعادة الضبط تُسقط 503.
تأتي الخيوط من TaskPool (cmd/sibuna/src/tasks.rs)، وهو جدول ثابت من مواضع قابلة للضم (join). يحتفظ الخيط المنتهي بمكدسه حتى يُضَم، لذلك يُضَم الموضع عندما يؤخذ مرة أخرى، وتأخذ المهمة الجديدة أدنى موضع منتهٍ بدل تقديم مؤشر دوار. فالمؤشر الدوار لن يبلغ موضعًا منتهيًا مرة أخرى إلا بعد لفة كاملة على الجدول، تاركًا آلاف الخيوط المنتهية مقيمة في الذاكرة، فتنمو الذاكرة مع عدد الاتصالات المخدومة بدل عدد الاتصالات المفتوحة. ويُعلِّم حارس ثانٍ، Finished، الموضعَ حرًّا عند انتهاء المهمة، فيحرر الاتصال الذي يذعر موضعه أيضًا.
تُحَد الذاكرة بالطريقة نفسها. يحمل خيط الاتصال مخزن القراءة من 64 KiB ومخزن الكتابة من 16 KiB على مكدسه، ومساحة عمل للوكيل من 40 KiB في الكومة، تُخصَّص مرة واحدة عند بدء الاتصال. وبذلك تكون أسوأ حالة عددًا معروفًا لا دالة في عدد المقابس التي يستطيع عميل فتحها. ويغلق جامع الاتصالات الخاملة (أدناه) الاتصالات التي تتوقف عن الإرسال، فلا يستطيع عميل بطيء احتجاز خيط بعد --idle-timeout.
اختيار مخصص الذاكرة¶
يثبت Rust 1.100 الأجزاء الأساسية من واجهة Allocator ومعاملات مخصص الذاكرة لكل من Vec و``Box`` (ملاحظات الإصدار). يمكننا اختيار مخصص لمجموعة واحدة من دون استبدال مخصص العملية. لا توفر لنا هذه الواجهة تخصيصات إضافية في مسار الطلب: فالطلبات على الاتصالات المهيأة لا تخصص ذاكرة أصلا، كما يتحقق cmd/sibuna/tests/steady_state.rs و``crates/net/tests/steady_state.rs``. يخصص الوكيل مخازنه الثلاثة مرة واحدة لكل اتصال ويعيد استخدامها. كذلك يخصص المحدد ومجموعة البراهين المستهلكة جدوليْهما مرة واحدة؛ وتسمح التخصيصات المصفرة ببقاء الصفحات غير المستخدمة خارج الذاكرة المقيمة، كما يتحقق crates/store/tests/resident.rs.
عند دراسة تغيير المخصص سنقيس أولا بناء لقطات السياسة وتحليل JSON في وحدة التحكم. تخصص مجموعاتها المؤقتة ذاكرة خارج مسار الطلب، لكن مخصص المجموعة لا يتحكم تلقائيا في تخصيصات عناصرها. تملك شجرة JSON أيضا السلاسل ذات محارف الهروب من خلال Cow<str>، الذي تكون صيغته المالكة String؛ وليس لـ``String`` معامل مخصص في Rust 1.100. وتبقى Arc::new_in غير مستقرة في هذا الإصدار (توثيق الواجهة). تظل المحركات المنشورة مشتركة عبر Arc حتى يحررها آخر قارئ، ولذلك لا يمكن لإعادة البناء تصفير ذاكرة ما زال محرك أقدم يستخدمها. يجب أن تحافظ ساحة الذاكرة على هذه الأعمار وحدود مدخلات المحلل.
نبقي المخصص العام الحالي WipeOnFree لوحدة WebAssembly الخاصة بوحدة التحكم في cmd/console-ui/src/abi.rs. يمحو الكتل المحررة، ومنها الكتلة القديمة بعد إعادة التخصيص. اختيار System مباشرة لمجموعة سيتجاوز هذا المحو. لا تحتوي وحدة WebAssembly لإثبات العمل على مخصص كومة، ويستخدم Argon2 بالفعل مساحة عمل يملكها المستدعي ويعيد استخدامها. لذلك نبقي المخصصات الحالية والتوافق مع Rust 1.94 حتى يبرر حمل مقاس تغييرا. يجب أن يحسن البديل زمن الاستجابة أو الذاكرة المقيمة مع الحفاظ على المحو والمعالجة المحدودة للمدخلات ومسار الطلب الخالي من التخصيص.
مخزن مؤقت واحد لكل اتصال¶
كل تخصيص ديناميكي على مسار الطلب أداة يمكن استغلالها لحجب الخدمة: تجزؤ على مدى أيام، وتنافس على قفل المُخصِّص بين الخيوط، وتضخيم من مهاجمين يصوغون طلبات تزيد التخصيص إلى أقصاه. قاعدة Sibuna مطلقة: التصنيف والتحقق والتسليم إلى الوكيل تجري بلا أي تخصيص في الكومة. يملك معالج الاتصال مخزن قراءة من 64 KiB ومخزن كتابة من 16 KiB طوال عمر المقبس؛ وكل ما عدا ذلك مقاطع منهما.
pub fn serve(server: &Server, stream: &TcpStream) {
let Some(lease) = server.idle.register(stream) else { return };
// ...
let mut read_buffer = [0u8; MAX_REQUEST_BYTES]; // 64 KiB
let mut write_buffer = [0u8; WRITE_BUFFER]; // 16 KiB
let mut reader = Reader::new(stream, &mut read_buffer[..]);
let mut peer = PeerText::default();
peer.format(stream.peer_addr().ok());
let mut link = Link {
server,
stream,
writer: Writer::new(stream, &mut write_buffer[..]),
workspace: Workspace::new(),
cache: EngineCache::new(),
activity: lease.activity(),
last: false,
};
for served in 0..MAX_REQUESTS_PER_CONNECTION {
link.last = served + 1 == MAX_REQUESTS_PER_CONNECTION;
if !serve_one(&mut reader, &mut link, peer.as_bytes()) {
break;
}
lease.touch();
}
}
تملأ read_head المخزن حتى يظهر السطر الفارغ، باحثةً فقط في البايتات التي وصلت منذ البحث الأخير، وترفض الرؤوس التي تزيد على 16 KiB بـ 431. تنتج parse_request (الحزمة sibuna-http) قيمة Request<'a> تكون طريقتها ومسارها واستعلامها وترويساتها وملفات تعريف الارتباط فيها مقاطع من المخزن. يُملأ الجسم المُعلَن بقدر ما يتسع ويُقتطَع بعد الرأس. ثم تُقدِّم reader.consume(head_len + body_len) القارئ، فيبدأ طلب keep-alive التالي بداية نظيفة؛ ولا ينقل القارئ البايتات غير المقروءة إلى المقدمة إلا عند حاجته إلى مساحة. يُفك ترميز الجسم المجزأ (chunked) في مكانه خلف الرأس (SID 0009): يُقتطَع تأطير كل خطوة من المخزن، فتبقى البادئة المفكوكة متصلة للفحص. المسارات الداخلية محددة الطول وتُبقي الاتصال مفتوحًا. والطلبات المُمرَّرة عبر الوكيل تُبقيه مفتوحًا أيضًا، بشرط أن تكون استجابة الخادم الأصلي مؤطَّرة وأن يكون الجسم قد خُزِّن بالكامل؛ وتبين الأقسام التالية كيف يقرر الوكيل ذلك.
fn serve_one<W: Write>(
reader: &mut Reader<'_, &TcpStream>,
link: &mut Link<'_, W>,
peer: &[u8],
) -> bool {
let head_len = match read_head(reader) {
Head::Complete(length) => length,
Head::TooLarge => { /* 431 "Request head exceeds 16 KB" */ return false; }
Head::Closed | Head::Failed => return false,
};
let framing = {
let bytes = reader.buffered();
let head = bytes.get(..head_len).unwrap_or_default();
let request = match parse_request(head) {
Ok(request) => request,
Err(error) => return reject_head(link, error),
};
let declared = request.content_length().unwrap_or(0);
// ... Expect: 100-continue
if declared == 0 && !request.chunked {
let upload = Upload::declared(&request);
let pending = bytes.get(head_len..).unwrap_or_default();
let keep = dispatch(link, request, pending, upload, 0, peer);
reader.consume(head_len);
return keep;
}
(declared, request.chunked)
};
serve_with_body(reader, link, peer, head_len, framing)
}
إعادة كتابة الرأس في الوكيل¶
لا يُمرَّر الرأس حرفيًا. تعيد write_request_head (crates/net/src/request.rs، الحزمة sibuna-net) إصدار سطر الطلب وكل ترويسة إلى كاتب الخادم الأصلي، مُسقطةً الحقول الخاصة بكل قفزة (Connection وKeep-Alive وProxy-Connection وTransfer-Encoding وTE وTrailer وUpgrade وحقول تفويض الوكيل)، وأي حقل تمرير أو تدقيق وارد (X-Forwarded-For وX-Real-IP وForwarded وX-Forwarded-Proto وX-Forwarded-Host وX-Forwarded-Port وX-Sibuna-Status وX-Sibuna-Rule)، وExpect، وContent-Length، وكل حقل تسميه ترويسة Connection في الطلب. ثم تضيف مجموعة التدقيق. يُولَّد تأطير الجسم ولا يُنسخ أبدًا:
for header in request.headers() {
if is_hop_by_hop(header.name) || nominated(request, header.name) {
continue;
}
out.write_all(header.name)?;
out.write_all(b": ")?;
out.write_all(header.value)?;
out.write_all(b"\r\n")?;
}
match upload {
Upload::None => {}
Upload::Length(length) => {
out.write_all(b"Content-Length: ")?;
write_decimal(out, *length)?;
out.write_all(b"\r\n")?;
}
Upload::Chunked(_) => out.write_all(b"Transfer-Encoding: chunked\r\n")?,
}
يُعاد إصدار Content-Length. والجسم المجزأ الذي انتهى داخل مخزن الاتصال يُفك ترميزه في مكانه ويُرسل مع طوله. أما الأطول منه فيُعلَن بـ Transfer-Encoding: chunked ويُعاد تجزيئه قراءةً بقراءة (SID 0009): تصل كل قراءة إلى مخزن الرفع للوكيل من 16 KiB، ويُفك ترميزها هناك في مكانها، وتخرج جزءًا واحدًا بصيغة قياسية، فلا يرى الخادم الأصلي أبدًا أحجام أجزاء العميل ولا امتداداته ولا حقوله الختامية (trailers). مجموعة التدقيق:
Connection: keep-alive
X-Forwarded-For: <client>
X-Forwarded-Proto: <scheme>
X-Real-IP: <client>
X-Sibuna-Status: PASS
X-Sibuna-Rule: session | robots-txt | ip/cidr-trie | ...
تُرحَّل الأجسام الأكبر من المخزن على قطع من 16 KiB من العميل إلى كاتب الخادم الأصلي (relay_body) قبل بث الاستجابة عائدةً. يؤكد اختبار الوحدة proxy_head_rewrite_drops_hop_by_hop_headers_and_injects_audit_fields في crates/net/src/request.rs أن إعادة الكتابة تُسقط X-Forwarded-For المزيف وتحقن حقول التدقيق.
تعيش مخازن الوكيل الثلاثة، أي مخزن القراءة من الخادم الأصلي (رأس استجابة واحد، 16 KiB)، ومخزن الكتابة إلى الخادم الأصلي (8 KiB)، ومخزن الرفع (16 KiB)، في Workspace يخصصها الاتصال مرة واحدة ويعيد استخدامها لكل طلب. تجعل مساحة العمل عمر هذه المخازن عمر الاتصال لا عمر التبادل، ويستعيرها قارئ الخادم الأصلي وكاتبه لتبادل واحد في كل مرة.
ترحيل استجابة الخادم الأصلي¶
كان الوكيل الأول يبث بايتات الخادم الأصلي حتى يغلق الخادم الأصلي ثم يغلق العميل: تأطير صحيح بلا تحليل، لكن بثمن اتصال TCP جديد لكل طلب مُمرَّر. وتحت مولد حمل، ظهر هذا الثمن في صورة عشرات الآلاف من المقابس في TIME_WAIT، وفي واجهة الاسترجاع (loopback) في صورة منافذ مؤقتة مستنفدة. يقرأ الوكيل الآن رأس الخادم الأصلي (16 KiB على الأكثر) ويصنف الجسم وفق قواعد RFC 9112:
pub enum Framing { None, Length(u64), Chunked, UntilClose }
pub fn parse_response_head(
head: &[u8],
head_request: bool,
) -> Option<ResponseHead> {
let status = status_code(head)?;
let mut fields = FramingFields {
keep_alive: head.get(7) == Some(&b'1'),
..Default::default()
};
for line in crlf_lines(head).skip(1) {
if line.is_empty() {
break;
}
fields.read_line(line)?; // Transfer-Encoding, Content-Length, Connection
}
let mut framing = fields.length.map_or(Framing::UntilClose, Framing::Length);
if head_request || status / 100 == 1 || status == 204 || status == 304 {
framing = Framing::None;
} else if fields.encoded {
framing =
if fields.chunked { Framing::Chunked } else { Framing::UntilClose };
}
let mut keep_alive = fields.keep_alive;
if framing == Framing::UntilClose || fields.closing {
keep_alive = false;
}
if fields.nominates_framing {
return None;
}
Some(ResponseHead { status, framing, keep_alive })
}
يرفض المحلل ما يجب ألا يرحِّله الوكيل: سطر حالة معيبًا، واسم حقل ليس رمزًا لغويًا (token)، وبايت تحكم في قيمة، وأطوالًا متعارضة، وترميز chunked مكررًا أو غير أخير، وحقل Connection يسمي Content-Length أو Transfer-Encoding. عمله خطي في طول الرأس، ولا يذعر أبدًا.
يُعاد إصدار الرأس إلى العميل مع استبدال ترويسات Connection الخاصة بالخادم الأصلي بقرار Sibuna نفسه، ويُرحَّل الجسم بدقة: copy_exact للطول، وجزءًا بجزء (سطر الحجم، والبيانات، والذيول) للترميز المجزأ، وcopy_remaining للحالة القديمة. الحالة القديمة وحدها تغلق العميل. يُبنى كل ترحيل على خطوة نسخ واحدة: مرِّر كل ما يحمله المصدر بالفعل، ولا تفرِّغ الوجهة ثم تقرأ مرة واحدة إلا عندما لا يحمل شيئًا. وبذلك يُسلَّم تيار من الكتابات الصغيرة كما يُنتَج، بينما يظل النقل الكبير ينقل مخزنًا كاملًا في كل قراءة وكتابة.
let keep = client_keep_alive && parsed.framing != Framing::UntilClose;
write_client_head(client, head, keep).map_err(client_head_error)?;
origin.consume(head_length);
match parsed.framing {
Framing::None => {}
Framing::Length(length) => copy_exact(origin, client, length, progress)?,
Framing::Chunked => relay_chunked(origin, client, progress)?,
Framing::UntilClose => copy_remaining(origin, client, progress)?,
}
client.flush().map_err(|_| ProxyError::ClientFailed)?;
Ok(Relayed { client_keep: keep, origin_reusable: parsed.keep_alive })
يستغرق تحليل رأس خادم أصلي من ثمانية حقول 322 ns، ويستغرق طلب GET بنمط keep-alive مع استجابة من 1 KiB مُمرَّرة عبر واجهة الاسترجاع 29.8 us (قيس في أكتوبر 2026؛ يوثق crates/net/src/lib.rs هذا القياس).
مجمع اتصالات الخادم الأصلي¶
يخبر تحليل التأطير الوكيل أيضًا ما إذا كان مقبس الخادم الأصلي قابلًا للاستخدام مرة أخرى: استجابة HTTP/1.1 بلا Connection: close (أو استجابة HTTP/1.0 مع keep-alive) استُهلك جسمها بالكامل تترك المقبس عند حد طلب نظيف. تدخل هذه المقابس مجمعًا ثابتًا من 256 اتصالًا خاملًا بالخادم الأصلي، ويأخذ الطلب المُمرَّر التالي واحدًا منها بدل الاتصال من جديد. من دون المجمع، يفتح كل طلب مُمرَّر اتصالًا جديدًا بالخادم الأصلي، ويحتجز كل اتصال مغلق منفذه المحلي في TIME_WAIT؛ وتحت الحمل، تنفد المنافذ المؤقتة سريعًا لدى وكيل على واجهة الاسترجاع، وتنهار إنتاجيته.
المجمع تحت قفل واحد يجعل كل طلب مُمرَّر يتنافس على ذلك القفل. لذلك يُقسَّم المجمع (crates/net/src/pool.rs) إلى شرائط: 16 شريطًا في كل منها 16 مقبسًا، وكل شريط Mutex<Vec<Arc<TcpStream>>> على سطر ذاكرة مخبئية (cache line) خاص به. يُسنَد إلى الخيط شريط أصلي بالتناوب الدوري عند أول استخدام، فيعيد المقابس إليه ويأخذها منه أولًا، ثم ينظر في الشرائط الأخرى، دون انتظار قفل محجوز، قبل أن يتصل من جديد.
pub fn take(&self) -> Option<Arc<TcpStream>> {
if self.is_stopping() {
return None;
}
let home = home_stripe();
if let Some(socket) =
self.stripe(home).and_then(|stripe| lock(&stripe.sockets).pop())
{
return Some(socket);
}
(1..STRIPES).find_map(|offset| {
let stripe = self.stripe((home + offset) % STRIPES)?;
try_lock(&stripe.sockets)?.pop()
})
}
قد يكون الخادم الأصلي قد أغلق المقبس المُجمَّع أثناء خموله. يلاحظ الوكيل ذلك بإحدى طريقتين، كتابة فاشلة أو نهاية تيار قبل أول بايت من الاستجابة، وفي الحالتين لم يصل شيء إلى العميل بعد، فيغلق المقبس ويعيد المحاولة مرة واحدة على اتصال جديد، لا على مقبس مُجمَّع آخر أبدًا: بعد فترة خمول قد يكون كل مقبس مُجمَّع قديمًا، والنسخة الأولى من إعادة المحاولة هذه، التي كانت تأخذ مقبسًا مُجمَّعًا ثانيًا، أجابت بـ 502 على أول طلب بعد كل فترة هدوء. لا يُسمح بإعادة المحاولة إلا لطريقة آمنة (GET وHEAD وOPTIONS) خُزِّن جسمها بالكامل. فغياب الرد ليس دليلًا على أن الخادم الأصلي لم ينفذ تعديلًا، والجسم الذي رُحِّل على قطع لا يمكن إرساله مرة أخرى؛ وفي الحالتين يحصل العميل على 502.
let safe = matches!(request.method, Method::Get | Method::Head | Method::Options);
let buffered = exchange.upload.is_buffered(request.body.len());
let retryable = safe && buffered;
for attempt in 0..2 {
// إعادة المحاولة تتصل دائمًا من جديد: بعد فترة خمول قد يكون كل مقبس
// في المجمع قديمًا، ومقبس قديم ثانٍ سيُفشل الطلب.
let pooled = if attempt == 0 { pool.take() } else { None };
// ... اتصل إن لم يكن في المجمع مقبس، وألحِقه بالنشاط، ثم بادِل
match outcome {
Ok(relayed) => {
if relayed.origin_reusable {
pool.give(origin);
}
return Ok(relayed.client_keep && buffered);
}
Err(error) => {
drop(origin);
let stale = was_pooled
&& retryable
&& matches!(
error,
ProxyError::UpstreamClosed | ProxyError::UpstreamWriteFailed
);
// ... أي خطأ آخر يُبلَّغ عنه فورًا
}
}
}
ترحِّل اختبارات الوحدة سلاسل بايتات ثابتة عبر الدوال نفسها وتؤكد أن الخرج مطابق بايتًا ببايت باستثناء ترويسة الاتصال (crates/net/src/relay/tests.rs). ويرسل اختبار من طرف إلى طرف للبرنامج الخدمي طلبين مُمرَّرين على مقبس عميل واحد ويتحقق، عبر ترويسة تسلسل يضيفها الخادم الأصلي الوهمي (stub)، من أن الطلب الثاني أعاد استخدام اتصال الخادم الأصلي المُجمَّع. ويعيد اختبار متجهات في crates/net/tests/ تشغيل سيناريوهات وكيل مسجلة (طلب عميل خام واستجابة خادم أصلي جاهزة) ويقارن كل بايت يتلقاه الخادم الأصلي والعميل.
مهل الخمول¶
يسجل كل اتصال عميل مقبسه في IdleTable (crates/net/src/idle.rs) ويتلقى Lease. يحمل Activity الخاص بعقد الإيجار هذا الوقت الذي تحركت فيه البايتات آخر مرة على الاتصال. يحدِّثه البرنامج الخدمي بعد كل طلب مخدوم؛ ويحدِّثه الوكيل في كل قراءة من الخادم الأصلي ولكل 16 KiB من الرفع، ويُلحق به مقبس الخادم الأصلي للتبادل الجاري. يستيقظ خيط الجامع كل ربع أقصر مهلة (بين 200 ms وثانية واحدة) ويغلق كل اتصال صامت لمدة أطول من مهلته، مع مقبس الخادم الأصلي الملحق به، فيرى الخيط المتوقف في انتظار أي من الجانبين نهاية التيار ويحرر موضعه.
لذلك تقيس المهل الصمت، لا طول الاستجابة أبدًا: التنزيل الكبير الذي يظل يتحرك لا يُقطع أبدًا. أما بايتات الرفع فتأتي من الجانب غير الموثوق ولا تحدِّث الطابع الزمني إلا لكل 16 KiB، فيُطلب من العميل 16 KiB على الأقل في كل فترة خمول، وهذا هو الدفاع ضد الأجسام البطيئة الذي توفره مهل الطلبات ذات المعدل الأدنى.
للجدول قفل صغير لكل موضع، ولا قفل على مستوى الجدول كله. يحمل نسخة try_clone من كل مقبس عميل وArc لكل مقبس خادم أصلي ملحق، للسبب المذكور أعلاه. يلغي Lease تسجيل اتصاله في Drop، ويبقى الموضع المحصود مملوكًا لعقد الإيجار الخاص به حتى ذلك الحين، فلا يستطيع اتصال قديم أبدًا تحرير موضع أخذه اتصال جديد.
الاتصالات المُرقّاة¶
بعد 101 مُتحقَّق منها، يُرحَّل الاتصال المُرقّى إلى WebSocket في الاتجاهين. يجري كل اتجاه على خيط خاص به مع مخزن ثابت واحد: يحمل خيط الاتصال نفسه البايتات من الخادم الأصلي إلى العميل، ويحمل خيط محدود النطاق (scoped) بمكدس من 128 KiB البايتات من العميل إلى الخادم الأصلي. كان يمكن لخيط واحد أن يخدم الاتجاهين باستخدام poll(2)، لكن المكتبة القياسية لـ Rust لا توفرها؛ وخيطان مع مهل للمقابس يُبقيان الترحيل خاليًا من unsafe. لذلك يحمل الاتصال المُرقّى خيطين، فقد يبلغ عدد خيوط الاتصالات ضعف --max-connections عندما تكون كل الاتصالات مُرقّاة.
يتشارك الاتجاهان مهلة خمول واحدة (--websocket-idle-timeout، 300 ثانية افتراضيًا): البايتات المتحركة في أي اتجاه تحدِّث طابعًا زمنيًا واحدًا. يحمل كل انتظار على مقبس مهلة تساوي الوقت المتبقي؛ والانتظار الذي تنتهي مهلته يعيد قراءة الطابع المشترك ثم إما ينتظر مرة أخرى للمدة الباقية أو ينهي الترحيل. عندما يبلغ أحد الاتجاهين نهاية التيار، يُغلق جانب الإرسال في المقبس الآخر (إغلاق نصفي)؛ وعندما يفشل اتجاه، يُغلق المقبسان كلاهما فينتهي الاتجاه الآخر أيضًا. قبل تمرير الترقية عبر الوكيل، يحرر الاتصال محرك السياسة المخزَّن لديه مؤقتًا، فلا يُبقي اتصال قد يعيش ساعات محركًا قديمًا حيًّا.
الإيقاف¶
يوقف Running::stop، وكذلك Drop لـ Running، البرنامج الخدمي بترتيب ثابت. يرفع علم الإيقاف ويوقظ كل عامل قبول بالاتصال بالمستمع، ويضم العمال، ويغلق كل مقبس عميل مسجل ومقبس الخادم الأصلي الملحق به (IdleTable::shutdown)، ويوقف مجمع الخادم الأصلي، ويضم كل خيط اتصال، ويضم الجامع، ويغلق المقابس المُجمَّعة.
تصل SIGINT وSIGTERM إلى هذا التسلسل عبر Rust العادية. قبل أن يطلق البرنامج الخدمي أي خيط، يحجب الإشارتين كلتيهما (ويرث كل خيط لاحق القناع) ويخصص خيطًا واحدًا لـ sigwait، الذي يسجل الطلب ويوقظ الخيط الرئيسي فورًا. لا تجري أي شيفرة في معالج إشارة، ولا يستطلع أي خيط علمًا. تحمل وحدة الإشارات (cmd/sibuna/src/signals.rs) شيفرة unsafe الوحيدة في البرنامج الخدمي: تصريحات الدوال القليلة من مكتبة C التي لا تغلفها std.
ما قسناه¶
يعرض الجدول Shield في وضع الوكيل العكسي على معالج Ryzen 9 5950X واحد: البرنامج الخدمي مثبت على أربع وحدات معالجة، وwrk بخيطين و64 اتصالًا على ثماني وحدات معالجة أخرى، وتشغيلات من خمس ثوانٍ، والوسيط من ثلاثة. الصفوف منسوخة من benchmarks/results/product-latest.md؛ ويضم الجزء الثامن السجل الكامل.
| عبء العمل | الحالة | req/s | p50 / p99 (us) | زمن المعالج لكل طلب (us) |
|---|---|---|---|---|
| مقبول بجلسة، مُمرَّر عبر الوكيل | 200 | 138,965 | 438 / 857 | 28.57 |
| خاضع لتحدٍّ (الصفحة الوسيطة) | 200 | 195,188 | 162 / 328 | 13.73 |
| مسار ملفات ثابتة مسموح، مُمرَّر عبر الوكيل | 200 | 145,673 | 415 / 746 | 27.27 |
| مرفوض من WAF (مع جلسة) | 403 | 209,507 | 151 / 306 | 12.17 |
يُبقي wrk 64 طلبًا قيد التنفيذ، لذلك تصطف الطلبات على المسارات المُمرَّرة المحدودة بالمعالج في انتظار وحدات المعالجة الأربع، ويكون p99 هناك ذيل المُجدوِل لا تكلفة طلب واحد. أما المولد ذو الحلقة المفتوحة، الذي يرسل بمعدل ثابت ويقيس زمن كل طلب من موعد إرساله المقصود، فيقيس زمن الاستجابة عند حمل معروض متساوٍ. للطلبات المقبولة في وضع الوكيل العكسي، يبلغ p99 قيمة 65 us عند 10,000 طلب في الثانية و100 us عند 100,000؛ وعند حمل معروض قدره 150,000 تتشبع وحدات المعالجة الأربع، فيتحقق 134,344 طلبًا في الثانية، وينمو الطابور إلى ثوانٍ (benchmarks/results/latency-latest.md). يخدم اتصال keep-alive دافئ كل قرار دون تخصيص في الكومة: يُحصي cmd/sibuna/tests/steady_state.rs تخصيصات البرنامج الخدمي، ولا يجد crates/net/tests/steady_state.rs أي تخصيص على مدى 500 طلب keep-alive مُمرَّر.
حالة متزامنة بلا تخصيص¶
يخصص كل مخزن في sibuna-store سعته الثابتة مرة واحدة عند بنائه، ولا يخصص بعد ذلك أبدًا ولا يُحجب على قفل عام. ولا يحتاج أي منها إلى منظف في الخلفية: تُستعاد الحالة المنتهية في مكانها.
الأقفال والتقسيم إلى شرائح¶
الأقسام الحرجة في جداول Sibuna بطول عشرات التعليمات، أقصر بكثير من رحلة ذهاب وإياب إلى futex في النواة. تُقسَم الجداول إلى 16 شريحة وفق تجزئة المفتاح، فتتنافس عمليتان باحتمال \(1/16\)، وتقع كل شريحة على سطر ذاكرة مخبئية خاص بها، فلا تتشارك الأقفال المتجاورة السطر نفسه زيفًا (false sharing).
تستخدم الجداول std::sync::Mutex: عملية مقارنة وتبديل واحدة عند غياب التنافس، ودوران قصير أثناء عمل الحامل، ثم انتظار futex. البديل قفل دوار ذري ذو حالتين مع تلميح حلقة الدوران في حلقة الانتظار. طلب منا SID 0010 أن نختار بينهما بالقياس. يوفر القفل الدوار نحو نانوثانية لكل عملية بلا تنافس، لكنه يخسر تحت التنافس:
| عبء العمل | Mutex |
قفل دوار |
|---|---|---|
| مجموعة الحلول المُنفَقة، 16 خيطًا | 10.8 M/s | 8.6 M/s |
| مجموعة الحلول المُنفَقة، 64 خيطًا (أكثر من وحدات المعالجة) | 11.2 M/s | 6.9 M/s |
| GCRA على ستة عناوين ساخنة، 16 خيطًا | 44.9 M/s | 19.3 M/s |
| GCRA على ستة عناوين ساخنة، 64 خيطًا | 37.4 M/s | 6.5 M/s |
يشغِّل خادم الحافة خيوط اتصالات أكثر من وحدات المعالجة، وقفل الدوران الذي يُستبَق حامله يجعل كل منتظر يحرق حصته الزمنية، لذلك نبقي على القفل (mutex). يُدخَل القفل المسموم بدل نشر التسميم: لا تذعر أي عملية وهي تحمل شريحة، وتبقى الشريحة صالحة بنيويًا حتى لو ذعرت إحداها.
مجموعة Robin Hood للحلول المُنفَقة¶
لا يدخل مجموعة الحلول المُنفَقة إلا الإثباتات المقبولة (الجزء الثالث). لها 16 شريحة، كل منها مصفوفة بعنونة مفتوحة من 4,096 موضعًا من النوع Option<Entry>، حيث المُدخَل { tag: [u8; 16], expires_at: u64, dist: u8 }. يزيح الإدراج بأسلوب Robin Hood (Celis، 1986) أي شاغل أقرب إلى موضعه الأصلي من المفتاح الوارد، وهذا يُبقي أطوال السبر متقاربة بإحكام؛ ويتوقف البحث حالما يصادف مُدخَلًا أقرب إلى موضعه الأصلي مما هو إلى موضعه.
fn insert(
&mut self,
tag: &Tag,
expires_at: u64,
now: u64,
) -> Result<(), SpendError> {
if !self.can_insert(tag, now) {
return Err(SpendError::Full);
}
let mut carry = Entry { tag: *tag, expires_at, dist: 0 };
let mut idx = Self::home(tag);
while carry.dist < MAX_PROBE {
let slot = &mut self.entries[idx];
let Some(e) = slot else {
*slot = Some(carry);
return Ok(());
};
// الكتابة فوق شاغل منتهٍ آمنة فقط إذا لم تكن المسافة الجديدة
// أصغر، فتظل المفاتيح التي تسبر متجاوزةً هذا الموضع تجتاز
// اختبار التوقف المبكر.
if e.is_expired(now) && carry.dist >= e.dist {
*e = carry;
return Ok(());
}
if carry.dist > e.dist {
std::mem::swap(&mut carry, e);
// المُدخَل المنتهي المُزاح يُسقَط ببساطة.
if carry.is_expired(now) {
return Ok(());
}
}
idx = (idx + 1) % SHARD_CAPACITY;
carry.dist += 1;
}
Err(SpendError::Full)
}
قاعدة الموضع المنتهي هي الجزء الدقيق: لا يجوز الكتابة فوق مُدخل منتهٍ في مكانه إلا بمفتاح يبعد عن موضعه الأصلي بقدر بعده على الأقل، وإلا فإن مفتاحًا لاحقًا يسبر متجاوزًا الموضع سيتوقف مبكرًا ويضيع. أما المُدخلات المنتهية التي تُزاح فتُسقط ببساطة. ولا حاجة إلى خيط منظف. يحاكي الإدراج أولًا مسار الإزاحة دون تغيير أي شيء (can_insert) ويتحقق من أن الإزاحة المحدودة يمكن أن تنجح دون فقد وسم حي.
الموضع من النوع Option<Entry>. الموضع الفارغ لا يحوي وسمًا يُقرأ، فلا يوجد علم occupied قد ينسى قارئ فحصه، ولن تُترجَم match حتى تُعالَج الحالتان كلتاهما. ونوع الخطأ دقيق بالقدر نفسه: يمكن أن تفشل مجموعة الحلول المُنفَقة بطريقتين (DoubleSpend وFull)، وSpendError يسميهما بالضبط.
GCRA: تحديد المعدل بعدد صحيح واحد¶
خوارزمية Generic Cell Rate Algorithm (ATM Forum، 1996) هي صيغة الجدولة الافتراضية للدلو المثقوب. تخزن لكل عميل وقت وصول نظريًا واحدًا (TAT). مع فاصل الإصدار \(T = \max(1, \lceil W / N \rceil)\) لحد موجب \(N\) في كل نافذة \(W\)، والتسامح مع الدفعات \(\tau = (N - 1) T\):
fn arrive(
cells: &mut [Cell; SLOTS_PER_SHARD],
key: u64,
now_ms: u64,
limits: Limits,
) -> Decision {
let interval = limits.emission_interval();
let tau = limits.burst_tolerance();
let Some(cell) = locate(cells, key, now_ms, tau) else {
return Decision {
limited: true,
capacity_exhausted: true,
retry_after_ms: interval,
remaining: 0,
};
};
let tat = cell.tat_ms.max(now_ms);
let horizon = now_ms.saturating_add(tau);
if tat > horizon {
return Decision {
limited: true,
capacity_exhausted: false,
retry_after_ms: tat - tau - now_ms,
remaining: 0,
};
}
cell.tat_ms = tat.saturating_add(interval);
// ... remaining = min(rate, floor((t + tau - TAT) / T) + 1)
}
تأخذ check الخاصة بالشريحة القفل وتستدعي arrive مع الخلايا المقفولة؛ ويحرر الحارس القفل عند عودة check. حجم الخلية 16 بايت (مفتاح وTAT) في 16 شريحة، في كل منها 512 موضعًا مع نافذة سبر من 16 موضعًا، أي نحو 128 KiB إجمالًا. الخلية التي يكون TAT فيها أقدم من \(t - \tau\) قد استُنزفت وتُستعاد في الحال. وتُحسب ترويسة Retry-After من الحساب نفسه. نوافذ السبر المشبعة ترفض العملاء الجدد بدل طرد حالة حصص نشطة، والقرار يذكر ذلك (capacity_exhausted)، فلا يصعِّد المستدعي رفض التشبع إلى حظر. والمعدل المضبوط على صفر يرفض الطلبات. يخدم محدِّد واحد عدة قواعد: مفتاح الخلية تجزئة Wyhash لعنوان العميل مع بذرة هي نطاق القاعدة، فيكون للعميل نفسه في نطاقات مختلفة ميزانيات مستقلة.
جدول الحظر ذو الإصدارات¶
يستخدم الحظر 4,096 موضعًا بحقول ذرية للإصدار والمفتاح ووقت الانتهاء، بعنونة مفتوحة وفق تجزئة ذات مفتاح للعنوان المحظور، مع نافذة سبر من 8 مواضع. يحيط الكاتب، الذي يُسلسَل مع الكتاب الآخرين بقفل (mutex)، كل تحديث بزيادتين في الإصدار؛ ولا يأخذ القراء أي قفل، ولا يقبلون إلا إصدارًا زوجيًا مستقرًا، ويعيدون المحاولة عند التغييرات المتزامنة.
pub fn ban(&self, banned: &[u8], until: u64, now: u64) {
let key = slot_key(banned);
let _writers = self.lock_writers();
let victim = &self.slots[self.victim(key, now)];
// المفتاح ووقت الانتهاء قيمة منطقية واحدة: أحِط الاستبدال
// بإصدار فردي حتى لا يجمع القراء مفتاحًا قديمًا مع وقت انتهاء
// المفتاح التالي.
victim.version.fetch_add(1, Ordering::SeqCst);
victim.until.store(until, Ordering::SeqCst);
victim.key.store(key, Ordering::SeqCst);
victim.version.fetch_add(1, Ordering::SeqCst);
}
fn read_slot(&self, slot: &Slot) -> (u64, u64) {
loop {
let before = slot.version.load(Ordering::SeqCst);
if before & 1 != 0 {
std::hint::spin_loop();
continue;
}
let key = slot.key.load(Ordering::SeqCst);
let until = slot.until.load(Ordering::SeqCst);
if before == slot.version.load(Ordering::SeqCst) {
return (key, until);
}
}
}
يمنع الاتساق التسلسلي خلط هوية قديمة بوقت انتهاء بديل: ينتمي كل وصول إلى ترتيب كلي واحد، وهذا يُبقي الحجة بسيطة. لا يأخذ القراء قفلًا، لكنهم قد ينتظرون كاتبًا وليسوا خالين من الانتظار (wait-free). لهذه العمليات الذرية تكلفة حقيقية، تُقاس بصورة غير مباشرة في أداة اختبار HTTP بدل افتراض أنها مجانية. عندما تمتلئ نافذة السبر، يُكتب فوق موضع منتهٍ، وإلا فوق الموضع الذي ينتهي أولًا. ترفع clear كل حظر لكنها تترك المفاتيح في أماكنها، لأن موضعًا مُفرَّغًا قد يخفي مفتاحًا متصادمًا يقع لاحقًا في سلسلة سبر.
حلقة الحوادث MPSC¶
عندما يرفض وضع Shield طلبًا أو تنطلق المصيدة، يُنسخ الحادث إلى سجل ثابت من نحو 1.3 KB (عنوان العميل، وUser-Agent، والطريقة، والمسار، والفئة، والحمولة، وكل منها مقطوع عند سعته) ويُدفع إلى حلقة محدودة متعددة المنتجين وحيدة المستهلك (تصميم Vyukov الذي يسم المواضع بأرقام تسلسل، 512 موضعًا، BoundedQueue<IncidentRecord, 512>). المنتجون خيوط الاتصالات؛ والمستهلك خيط التخزين. الحلقة الممتلئة تُسقط أحدث سجل بدل حجب استجابة، وهي سياسة فقد صريحة لا ضمان ديمومة. ويجعل عداد الإسقاط هذا الفقد قابلًا للملاحظة.
/// ينسخ `incident` إلى الحلقة؛ والحلقة الممتلئة تُسقطه وتُحصي الإسقاط.
pub(crate) fn record(&self, incident: &Incident<'_>) {
if self.queue.push(IncidentRecord::from_incident(incident)).is_err() {
self.metrics.incidents_dropped.bump();
}
}
بعد نقل سجل إلى دفعة معلقة، يحتفظ به خيط التخزين، مع الصفوف المُعدَّة، حتى يُؤكَّد الإيداع (commit)؛ ولا يتخلص منه بصمت عند خطأ في قاعدة البيانات، وإعادة المحاولة تكتب الدفعة نفسها.
يحمل كل موضع رقم تسلسل يخبر المنتجين ما إذا كان الموضع حرًّا ويخبر المستهلك ما إذا كان ممتلئًا، فلا يأخذ أي من الجانبين قفلًا. لا يمكن كتابة حلقة كهذه بلغة Rust الآمنة: يلمس المنتجون والمستهلك مواضع مختلفة من مصفوفة واحدة في الوقت نفسه، وبروتوكول التسلسل وحده، لا نظام الأنواع، هو الذي يثبت أي خيط يجوز له لمس أي موضع. لذلك تحفظ الوحدة crates/store/src/ring.rs قيمها في مواضع UnsafeCell<MaybeUninit<T>>، وتسمي كل كتلة unsafe خطوة البروتوكول التي تسوِّغها:
if diff == 0 {
// Relaxed: لا تفصل CAS إلا في أي منتج يملك الموضع `pos`.
match self.tail.0.compare_exchange_weak(
pos, pos.wrapping_add(1), Ordering::Relaxed, Ordering::Relaxed,
) {
Ok(_) => {
// SAFETY: منحت CAS هذا الخيطَ الموضع `pos`، و
// يدل `sequence == pos` على أن الموضع فارغ؛ ولا يستطيع منتج آخر
// المطالبة بـ `pos`، ولا يقرؤه المستهلك قبل التخزين بترتيب Release
// أدناه.
unsafe { (*slot.value.get()).write(value) };
// Release: ينشر القيمة المكتوبة للمستهلك.
slot.sequence.store(pos.wrapping_add(1), Ordering::Release);
return Ok(());
}
Err(current) => pos = current,
}
} else if diff < 0 {
return Err(value);
}
اصطلاحان من اصطلاحات الحلقة يُعبَّر عنهما بالأنواع لا بالتعليقات. على الحلقة الممتلئة تعيد push القيمة Err(value)، فتعيد السجل إلى المستدعي ليقرر أيُحصيه أم يُسقطه؛ أما false المجردة فكانت ستضيعه. للحلقة مستهلك واحد، وpop تأخذ &mut self، ويجب على الشيفرة المشتركة أن تطالب أولًا بـ Consumer الفريد، فالمستهلك الثاني لا يُترجَم أو يُرفض في وقت التشغيل.
نشر المحرك بأسلوب القراءة والنسخ والتحديث¶
يُعاد بناء محرك السياسة خارج المسار الساخن عند تغير السياسات. يجب ألا ترى الطلبات أبدًا محركًا نصف مبني، ويجب ألا يُحرَّر محرك أبدًا ما دام طلب ما يقرؤه. ينشر Sibuna كل محرك بوصفه Arc<Engine> في EngineSlot، ويقرؤه كل اتصال عبر EngineCache:
pub struct EngineSlot {
current: RwLock<Arc<Engine>>,
generation: AtomicU64,
}
pub fn publish(&self, engine: Engine) {
let fresh = Arc::new(engine);
let previous = {
let mut current =
self.current.write().unwrap_or_else(PoisonError::into_inner);
std::mem::replace(&mut *current, fresh)
};
self.generation.fetch_add(1, Ordering::Release);
// يُسقَط المحرك القديم خارج القفل (إذا كان هذا آخر حامل له).
drop(previous);
}
pub struct EngineCache {
generation: u64,
engine: Option<Arc<Engine>>,
}
pub fn refresh(&mut self, slot: &EngineSlot) -> &Engine {
let generation = slot.generation();
if self.generation != generation {
// إذا وقع نشر بين التحميل أعلاه وهذا النسخ، وُسم محرك أحدث
// بجيل أقدم؛ والتحديث التالي يحمِّل من جديد ببساطة.
self.generation = generation;
self.engine = None;
}
self.engine.get_or_insert_with(|| slot.load())
}
يُخزَّن الجيل بترتيب release بعد أن يستقر المحرك في مكانه، ويُحمَّل بترتيب acquire: القارئ الذي يرى جيلًا جديدًا يرى أيضًا المحرك المخزَّن قبله. السباق المذكور في التعليق غير ضار. إذا وقع نشر بين تحميل القارئ للجيل ونسخه، يخزن القارئ المحرك الأحدث مؤقتًا تحت رقم الجيل الأقدم، ويلاحظ تحديثه التالي عدم التطابق فيحمِّل مرة أخرى. قد يتأخر القارئ محركًا واحدًا لطلب واحد؛ لكنه لا يستطيع أبدًا أن يرى محركًا نصف مبني، لأن الموضع لا يُخزَّن فيه إلا محركات كاملة.
لماذا ذاكرة مؤقتة وليس قفلًا ببساطة؟ طلب منا SID 0010 أن نقيس تكلفة القراءة مع 16 خيطًا ونختار بين RwLock<Arc<Engine>> وبديل بلا أقفال بلغة Rust الآمنة. القراءة عبر القفل تأخذ كلمة القفل وعداد المراجع، وهما سطرا ذاكرة مخبئية تكتب فيهما كل نواة. أما الجيل فيُكتب مرة واحدة لكل نشر ويُقرأ فقط في غير ذلك، فتحتفظ كل نواة بنسختها منه:
| القارئ | خيط واحد | 16 خيطًا |
|---|---|---|
حارس القراءة لـ RwLock فقط |
4.2 ns | 752 ns |
قراءة RwLock ونسخ Arc |
7.6 ns | 833 ns |
فحص الجيل مع Arc مخزَّن مؤقتًا |
0.8 ns | 1.8 ns |
تحت التنافس تكون القراءة المخزَّنة مؤقتًا أرخص من القفل بأكثر من 400 مرة، لذلك يستخدم مسار الطلب الذاكرة المؤقتة، ولا يستخدم RwLock إلا على المسار البطيء للتحديث. القياس هو الاختبار المُتجاهَل read_cost_under_contention في cmd/sibuna/src/slot.rs. ويحدِّث كل استخدام على مسار الطلب الذاكرة المؤقتة، فيرى الطلب المحرك الحالي عند تلك الخطوة. والمحرك نفسه صغير: 209,052 بايت، أي نحو 204 KiB، من جداول مضغوطة في الكومة (engine_bytes في benchmarks/results/primitives-latest.json)، مع سعة لـ 128 قاعدة، وأسماء قواعد من 128 بايت، و8,192 عقدة في الشجرة.