تقدير المشروع
← كل المقالات

الاستدعاء الساكن والديناميكي (Dispatch) في Rust

لكل من الآليتين مزاياها وعيوبها الخاصة، وتفرض اعتبارات إضافية علينا أن نضعها في الحسبان أثناء صيانة شيفرتنا.

12 دقائق قراءة
RustAsync

في هذا المقال أودّ التعمق في التفاصيل الدقيقة لاستدعاءات الدوال الساكنة والديناميكية في Rust. ربما يربط كثير منكم هذا الموضوع مباشرة بتعدد الأشكال (polymorphism) في Rust، لكن الاستدعاء الساكن مقابل الديناميكي يتجاوز تعدد الأشكال والسمات (traits) وكائنات السمات (trait objects)؛ فهو موضوع أوسع آمل أن أتوسع فيه أدناه. وإلى جانب آليات الاستدعاء بحد ذاتها، سننظر أيضًا في مسائل ذات صلة مثل التضمين (inlining)، وقيود السمة/الدوال Sized، والاستدعاء الديناميكي في سياق غير متزامن (async) – وكلها مرتبطة بشكل ما بطريقة عمل الاستدعاء في Rust.

ماذا يعني الاستدعاء (dispatch)

يمكنكم اعتبار كلمة dispatch مجرد استدعاء دالة، واعتبار الاستدعاء الساكن/الديناميكي طريقة حلّ استدعاءات الدوال. وكما قلت في البداية، غالبًا ما تُربط آلية الاستدعاء بتعدد الأشكال وبتحديد أي تنفيذ لسمة معيّنة ينبغي استدعاؤه، لكن يمكن النظر إليها أيضًا بشكل أوسع، على أنها تنطبق على استدعاءات الدوال والدوال الأعضاء بصورة عامة. وسأوضح آليتي الاستدعاء في كلا السياقين، مع تعدد الأشكال وبدونه، ليسهل استيعاب المفهوم إن احتجتموه.

الاستدعاء الساكن (Static Dispatch)

أبسط مثال على الاستدعاء الساكن هو استدعاء دالة عادي في Rust:

fn compute(x: i32) -> i32 {
   x + 1
}

fn main() {
   let result = compute(5);
   println!("Result: {}", result);
}

يُحَلّ استدعاء compute(5) أثناء الترجمة. الاستدعاء الساكن هو الافتراضي، ويغطي معظم استدعاءات الدوال العادية التي تكون فيها الأنواع الفعلية معروفة وقت الترجمة. وعند التأمل، يمتد هذا التعريف بشكل طبيعي إلى أي حالة عامة (generic) يحدث فيها استدعاء ساكن.

fn max_value<'a, T: PartialOrd>(a: &'a T, b: &'a T) -> &'a T {
   if a > b {
       a
   } else {
       b
   }
}

fn main() {
   // Using max_value with integers
   let num1 = 10;
   let num2 = 20;
   let max_num = max_value(&num1, &num2);
   println!("The maximum number is {}", max_num);

   // Using max_value with floating-point numbers
   let float1 = 15.5;
   let float2 = 8.75;
   let max_float = max_value(&float1, &float2);
   println!("The maximum float is {}", max_float);

   // Using max_value with chars
   let char1 = 'a';
   let char2 = 'z';
   let max_char = max_value(&char1, &char2);
   println!("The maximum char is {}", max_char);
}

وبما أنه يمكن ربط الأنواع بتنفيذات فعلية أثناء الترجمة، فهذه حالة أخرى من الاستدعاء الساكن، تمامًا مثل الحالة السابقة مع الدوال العادية.

اعتمد المثال السابق على السمة PartialOrd مع التنفيذ الافتراضي للأعداد الصحيحة، لكن لتوضيح الأمور أكثر يمكننا تعريف سماتنا وتنفيذاتنا الخاصة:

trait Speak {
   fn speak(&self) -> String;
}

struct Dog;
struct Cat;

impl Speak for Dog {
   fn speak(&self) -> String {
       "Woof".to_string()
   }
}

impl Speak for Cat {
   fn speak(&self) -> String {
       "Meow".to_string()
   }
}

fn make_noise<T: Speak>(animal: &T) {
   println!("{}", animal.speak());
}

fn main() {
   let dog = Dog;
   let cat = Cat;
   make_noise(&dog); // Here, the compiler knows to call Speak for Dog at compile time.
   make_noise(&cat); // Here, the compiler knows to call Speak for Cat at compile time.
}

تأخذ الدالة make_noise أي نوع ينفّذ السمة Speak. وفي مثل هذه الحالات يعتمد Rust على الاستدعاء الساكن لتشغيل الدالة speak لنوع فعلي. وهذا ما يحدث:

  1. أثناء الترجمة، يحدد مترجم Rust النوع الفعلي للمعامل (Dog أو Cat).
  2. لكل نوع، ينتج Rust نسخة مخصصة من الدالة make_noise – فيعطي نسخة محددة لـ Dog وأخرى منفصلة لـ Cat.

ولأن هذه الاستدعاءات تُحَلّ أثناء الترجمة، فلا حاجة إلى فحوص أنواع وقت التشغيل أو إلى الاستدعاء الديناميكي. ولذلك يكون التنفيذ أسرع وأكثر قابلية للتنبؤ، لأن عناوين الدوال معروفة مسبقًا ومدمجة في الشيفرة. ويُعرف تحويل نوع عام إلى عدة نسخ فعلية من الدالة باسم monomorphization، وهو يجعل استدعاءات speak بكفاءة مماثلة لو لم تكن هناك سمات أو أنواع عامة. غير أن لـ monomorphization سلبيات أيضًا: فقد يطيل أزمنة الترجمة ويقلل فعالية ذاكرة التخزين المؤقت لتعليمات المعالج، إذ قد تنتفخ بنسخ متعددة من تعليمات متطابقة.

ملاحظة حول التعليقات التوضيحية #[inline]

ستسمعون كثيرًا أنه مع الأنواع العامة والاستدعاء الساكن يضمّن المترجم الدوال للأنواع الفعلية.

وهذا نصف صحيح فقط – ففي أثناء الترجمة تعمل آليات التضمين المعتادة. المترجم في Rust جيد جدًا في تقدير متى ينبغي تضمين دالة، لكن هذا التقدير يتوقف على عدة عوامل، مثل مدى تعقيد الدالة وعدد مرات استدعائها.

وفي حالات كثيرة قد يكون من المجدي مع ذلك إضافة التعليقات التوضيحية #[inline] أو #[inline(always)] صراحةً. فقد صُمم rustc لتضمين الدوال العامة بقوة أثناء monomorphization، خاصة عند الترجمة مع رايات التحسين مثل --release. وعندما تصادفون أجزاء حرجة الأداء في شيفرتكم، أو دالة صغيرة تُستدعى كثيرًا، جرّبوا وسمها صراحةً بـ #[inline] أو #[inline(always)] وتحققوا مما إذا كان الأداء يتحسن. ويمكن لهذه التعليقات أيضًا أن تكون مفيدة لدالة مساعدة في crate مكتبة ترون أنها ستستفيد من تضمينها في الـ crates التي تعتمد عليها.

الاستدعاء الديناميكي (Dynamic Dispatch)

كما خمّنتم على الأرجح، يختلف الاستدعاء الديناميكي كثيرًا عن الساكن. فهو يتيح لكم استدعاء دالة سمة دون معرفة النوع الفعلي للكائن أو تنفيذه وقت الترجمة؛ ويجري الحل وقت التشغيل.

وبأخذ مثالنا البسيط عن الكلاب والقطط، قد تبدو النسخة الديناميكية هكذا:

trait Speak {
   fn speak(&self) -> String;
}

struct Dog;
struct Cat;

impl Speak for Dog {
   fn speak(&self) -> String {
       "Woof".to_string()
   }
}

impl Speak for Cat {
   fn speak(&self) -> String {
       "Meow".to_string()
   }
}

fn make_noise(animal: &dyn Speak) {
   println!("{}", animal.speak());
}

fn main() {
   let dog = Dog;
   let cat = Cat;
   make_noise(&dog); // The specific method is looked up in the vtable at runtime.
   make_noise(&cat); // The specific method is looked up in the vtable at runtime.
}

المثير هنا، بطبيعة الحال، هو الدالة make_noise، التي معاملها من النوع &dyn Speak. هذه المرة تُحَلّ الدالة المحددة المراد تشغيلها وقت التشغيل عبر جدول دوال افتراضي (vtable). وعمليًا، يعطينا &dyn النوع، وعند الاستدعاء وقت التشغيل عنوان الدالة لذلك النوع. ونطابق هاتين المعلومتين مع الـ vtable لتحديد الدالة المطلوب استدعاؤها بالضبط.

المؤشرات العريضة وكائنات السمات

نمرّر animal إلى دالتنا بالعنوان لأن الحجم الدقيق للمعامل مجهول وقت الترجمة، بينما حجم المؤشر معروف، فيمكن ترجمة الشيفرة. وبما أننا نمرّر فعليًا ليس فقط مؤشرًا إلى النوع بل أيضًا عنوان vtable تُحَلّ فيه الأمور كلها، نحتاج إلى ما يسمى wide pointer (مؤشر عريض).

ليس كل مؤشر عريض كائن سمة، لكن كل كائن سمة هو مؤشر يحمل معلومات إضافية. وهنا يعني ذلك مؤشرًا إلى بيانات من نوع فعلي ومؤشرًا إلى vtable تحتوي تنفيذات ذلك النوع لدوال السمة.

وكما يتضح، يمكن استخدام أي نوع قادر على حمل مؤشر عريض، مثل Box وArc، للاستدعاء الديناميكي. ألقوا نظرة على هذا المثال:

trait Animal {
   fn speak(&self);
}

struct Dog;
struct Cat;

impl Animal for Dog {
   fn speak(&self) {
       println!("Woof!");
   }
}

impl Animal for Cat {
   fn speak(&self) {
       println!("Meow!");
   }
}

fn main() {
   // Using & reference for dynamic dispatch
   let dog = Dog;
   let cat = Cat;
   let animals: Vec<&dyn Animal> = vec![&dog, &cat];
   for animal in animals {
       animal.speak();
   }

   // Using Box for dynamic dispatch
   let boxed_dog: Box<dyn Animal> = Box::new(Dog);
   let boxed_cat: Box<dyn Animal> = Box::new(Cat);
   boxed_dog.speak();
   boxed_cat.speak();

   // Using Arc for dynamic dispatch
   use std::sync::Arc;
   let arc_dog: Arc<dyn Animal> = Arc::new(Dog);
   let arc_cat: Arc<dyn Animal> = Arc::new(Cat);
   arc_dog.speak();
   arc_cat.speak();
}

قيد السمة Self: Sized

قيد السمة Sized، وهو خاص في سياق الاستدعاء الديناميكي، يتيح لكم التحكم فيما إذا كان يمكن استخدام السمات والدوال مع الاستدعاء الديناميكي. وقد يؤثر ذلك في كل من يستخدم سماتكم أو دوالكم. فمع القيد Self: Sized يمكنكم منع إنشاء كائنات السمات وفرض الاستدعاء الساكن.

تنفّذ معظم الأنواع في Rust السمة Sized تلقائيًا؛ وهي تقول في جوهرها إن حجم النوع معروف وقت الترجمة. وإضافة القيد Self: Sized إلى سمة أو إلى دالة داخل سمة تعني أنه لا يجوز استخدامها إلا مع أنواع Sized – أي الأنواع التي يجب أن يكون حجمها معروفًا وقت الترجمة.

وكما شُرح في القسم السابق، نلجأ إلى كائن سمة (Trait Object) تحديدًا لأننا لا نعرف حجم السمة الممرّرة معاملًا إلى دالتنا. كائنات السمات هي !Sized، أي أنها ليست Sized وحجمها غير معروف وقت الترجمة؛ فقد يشير المؤشر داخل كائن السمة إلى أي نسخة من نوع منفّذ. وبعبارة أخرى، وسم السمة بأنها Sized يعني أنه لا يمكن استخدامها إلا مع أنواع معروفة الحجم وقت الترجمة، وأنه لا يمكن استخدامها لبناء كائنات سمات (فلا يمكن استخدامها مع الاستدعاء الديناميكي).

trait MyTrait: Sized {
   fn do_something(&self);
}

struct MyStruct;

impl MyTrait for MyStruct {
   fn do_something(&self) {
       println!("Doing something!");
   }
}

fn use_trait_object(trait_obj: &dyn MyTrait) {
   trait_obj.do_something();  // This would not compile because MyTrait is not object-safe due to Self: Sized bound.
}

أما وضع القيد Self: Sized على دالة بعينها من سمة فيجعل تلك الدالة وحدها غير متاحة عبر كائن السمة، بينما يظل بالإمكان إنشاء كائن السمة نفسه واستخدامه.

trait MyTrait {
   fn do_something(&self) where Self: Sized;
   fn do_anything(&self);
}

struct MyStruct;

impl MyTrait for MyStruct {
   fn do_something(&self) {
       println!("Doing something specific!");
   }
   fn do_anything(&self) {
       println!("Doing anything!");
   }
}

fn use_trait_object(trait_obj: &dyn MyTrait) {
   trait_obj.do_something();  // This will not compile because do_something requires Self: Sized.
   trait_obj.do_anything();  // This works fine.
}

الاستدعاء الديناميكي في الشيفرة غير المتزامنة

لا تدعم سمات Rust الدوال غير المتزامنة مباشرة، ويأتي استخدامها مع تحديات ودقائق إضافية تستحق المعرفة. فالدالة async تُرجع Future، وحجمه غير معروف وقت الترجمة لأنه يعتمد على الحالة التي تلتقطها كتلة async، مما يجعلها !Sized بطبيعتها.

ولا يمكن استخدام دوال السمات العادية التي تُرجع Future مباشرة، لأن الحجم المجهول للـ futures يمنع إرجاعها مباشرة من دالة في dyn Trait. وهذا مشابه للقيد الذي يفرضه Self: Sized، لكن بشكل معكوس – فبدلًا من أن تشترط السمة حجمًا معروفًا، يفتقر نوع الإرجاع نفسه إلى حجم معروف.

وللتحايل على ذلك، يمكننا إرجاع شيء Sized يغلّف الـ future الخاص بنا، فنتمكن من التعامل معه بعد ذلك. ولهذا يمكن لدوال السمات أن تُرجع Box<dyn Future<Output = T> + Send>. يغلّف هذا النهج الـ future في كائن سمة، فيتيح لنا التعامل مع أنواع futures شتى عبر واجهة مشتركة واحدة.

ومواصلةً لمثال Dog/Cat، إليكم النسخة غير المتزامنة باستخدام طريقة Box:

use tokio;
use std::future::Future;
use std::pin::Pin;

trait Animal {
   fn speak(&self) -> Pin<Box<dyn Future<Output = String> + Send>>;
}

struct Cat;
struct Dog;

impl Animal for Cat {
   fn speak(&self) -> Pin<Box<dyn Future<Output = String> + Send>> {
       Box::pin(async move {
           let response = "Meow".to_string();
           println!("{}", response);
           response
       })
   }
}

impl Animal for Dog {
   fn speak(&self) -> Pin<Box<dyn Future<Output = String> + Send>> {
       Box::pin(async move {
           let response = "Woof".to_string();
           println!("{}", response);
           response
       })
   }
}

#[tokio::main]
async fn main() {
   let cat = Cat;
   let dog = Dog;

   let cat_says = cat.speak().await;
   let dog_says = dog.speak().await;

   println!("The cat says: {}", cat_says);
   println!("The dog says: {}", dog_says);
}

أصبح لدالة speak الآن نوع الإرجاع Pin<Box<dyn Future<Output = String> + Send>>. وهذا النوع هو future مغلّف في Box، وهو Sized. يُستخدم Pin هنا لمنع نقل الـ future في الذاكرة بعد إنشائه. وهو إجراء أمان، إذ قد يحتوي الـ Future نفسه مراجع ذاتية. وفي كل من Dog وCat، تُغلَّف كتل async في Box يدويًا لتنتهي على الكومة (heap) ويُرجع مؤشر إليها. وتنقل الكلمة المفتاحية move جميع المتغيرات الملتقطة إلى بيئة الـ future.

مكتبة Async_trait

أوضح المثال السابق كيفية استخدام Box<dyn Future<Output = T> + Send> نوعَ إرجاع لدالة غير متزامنة في سمة، لكن هناك طريقة أفضل. فعلًا، تتولى مكتبة تُسمى async_trait هذا الأمر عنا تلقائيًا.

use async_trait::async_trait;
use tokio;

#[async_trait]
trait Animal {
   async fn speak(&self) -> String;
}

struct Cat;
struct Dog;

#[async_trait]
impl Animal for Cat {
   async fn speak(&self) -> String {
       let response = "Meow".to_string();
       println!("{}", response);
       response
   }
}

#[async_trait]
impl Animal for Dog {
   async fn speak(&self) -> String {
       let response = "Woof".to_string();
       println!("{}", response);
       response
   }
}

#[tokio::main]
async fn main() {
   let cat = Cat;
   let dog = Dog;

   let cat_says = cat.speak().await;
   let dog_says = dog.speak().await;

   println!("The cat says: {}", cat_says);
   println!("The dog says: {}", dog_says);
}

يمنحنا async_trait تغليفًا تلقائيًا في Box: بفضل التعليق التوضيحي، تُحوَّل دوال السمات غير المتزامنة وقت الترجمة لتُرجع Box<dyn Future<Output = T> + Send> (أو Box<dyn Future<Output = T>> عندما لا يلزم Send)، فلا نضطر إلى كتابة كل الشيفرة المتكررة حول التثبيت (pinning) والتغليف (boxing)؛ فهي تُعالَج عنا.

الخلاصة

خلاصة القول، مقارنةً بالاستدعاء الساكن، يقصّر الاستدعاء الديناميكي أزمنة الترجمة لأنه لا حاجة إلى ترجمة الدوال نفسها مرارًا لأنواع مختلفة. وبالمثل، لا تنتفخ ذاكرة التخزين المؤقت لتعليمات المعالج. لكنه، مثل كل شيء آخر، له سلبياته: فتُطبَّق تحسينات أقل عند ترجمة شيفرتنا، ولا يُضمَّن لنا شيء. وإضافة إلى ذلك، هناك كلفة صغيرة وقت التشغيل للبحث عن الدالة المحددة في الـ vtable.

ينبغي لكل مبرمج أن يفهم هذه الآليات وما بينها من مفاضلات عند اتخاذ قرار بشأن كيفية تصميم structs/السمات والدوال وما قد يترتب على ذلك من أثر في الأداء. ولكل من الآليتين مزاياها وعيوبها الخاصة، وتفرض اعتبارات إضافية علينا أن نضعها في الحسبان أثناء صيانة شيفرتنا.