Ստատիկ և դինամիկ dispatch Rust-ում
Երկու մեխանիզմներից յուրաքանչյուրն ունի իր առավելություններն ու թերությունները և բերում է լրացուցիչ նկատառումներ, որոնք պետք է հիշել կոդը սպասարկելիս։
Այս գրառման մեջ ուզում եմ խորանալ Rust-ում ստատիկ և դինամիկ ֆունկցիաների կանչերի նուրբ մանրամասների մեջ։ Ձեզանից շատերը հավանաբար այս թեման ուղղակիորեն կապում են Rust-ի պոլիմորֆիզմի հետ, սակայն ստատիկ ընդդեմ դինամիկ dispatch-ը դուրս է գալիս պոլիմորֆիզմի, trait-երի և trait object-ների սահմաններից. սա ավելի լայն թեմա է, որի մասին հուսով եմ ստորև ավելի մանրամասն խոսել։ Հենց dispatch մեխանիզմներից բացի, կդիտարկենք նաև հարակից հարցեր, ինչպես inlining-ը, Sized trait-ը/մեթոդների սահմանափակումները և դինամիկ dispatch-ը async համատեքստում. դրանք բոլորը ինչ-որ կերպ կապված են այն բանի հետ, թե ինչպես է dispatch-ը աշխատում Rust-ում։
Ինչ է նշանակում dispatch
Կարելի է dispatch բառը պատկերացնել պարզապես որպես ֆունկցիայի կանչ, իսկ ստատիկ/դինամիկ dispatch-ը՝ որպես այն ձև, որով ֆունկցիայի կանչերը լուծվում (resolve են արվում) են։ Ինչպես սկզբում ասացի, dispatch մեխանիզմը հաճախ կապվում է պոլիմորֆիզմի և այն որոշելու հետ, թե տրված trait-ի որ իրականացումը պետք է կանչվի, բայց այն կարելի է դիտարկել նաև ավելի լայն՝ որպես մի բան, որ վերաբերում է ընդհանրապես ֆունկցիաների և մեթոդների կանչերին։ Ես ցույց կտամ երկու dispatch մեխանիզմներն էլ երկու համատեքստերում՝ պոլիմորֆիզմով և առանց դրա, որպեսզի հասկացությունն ավելի հեշտ ընկալվի, եթե Ձեզ պետք լինի։
Ստատիկ Dispatch
Ստատիկ dispatch-ի ամենահիմնական օրինակը Rust-ում սովորական ֆունկցիայի կանչն է.
fn compute(x: i32) -> i32 {
x + 1
}
fn main() {
let result = compute(5);
println!("Result: {}", result);
}
compute(5) կանչը լուծվում է կոմպիլյացիայի ժամանակ։ Ստատիկ dispatch-ը լռելյայնն է և ընդգրկում է սովորական ֆունկցիաների կանչերի մեծ մասը, երբ կոնկրետ տիպերը հայտնի են կոմպիլյացիայի ժամանակ։ Մտածելով՝ այս սահմանումը բնականորեն տարածվում է ցանկացած generic դեպքի վրա, երբ տեղի է ունենում ստատիկ dispatch։
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);
}
Քանի որ տիպերը կոմպիլյացիայի ժամանակ կարելի է համապատասխանեցնել կոնկրետ իրականացումներին, սա ստատիկ dispatch-ի ևս մեկ դեպք է, ճիշտ ինչպես նախորդը՝ սովորական ֆունկցիաներով։
Նախորդ օրինակը հենվում էր PartialOrd trait-ի վրա՝ ամբողջ թվերի լռելյայն իրականացմամբ, բայց ավելի պարզ դարձնելու համար կարող ենք սահմանել մեր սեփական trait-երն ու իրականացումները.
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 trait-ն իրականացնող ցանկացած տիպ։ Նման իրավիճակներում Rust-ը հենվում է ստատիկ dispatch-ի վրա՝ կոնկրետ տիպի համար speak մեթոդը կատարելու համար։ Ահա թե ինչ է տեղի ունենում.
- կոմպիլյացիայի ժամանակ Rust-ի կոմպիլյատորը պարզում է արգումենտի կոնկրետ տիպը (Dog կամ Cat)։
- Յուրաքանչյուր տիպի համար Rust-ը ստեղծում է
make_noiseֆունկցիայի առանձին տարբերակ. ստացվում է մեկ կոնկրետ տարբերակ Dog-ի համար և առանձին մեկը՝ Cat-ի։
Քանի որ այս կանչերը լուծվում են կոմպիլյացիայի ժամանակ, runtime տիպերի ստուգումներ կամ դինամիկ dispatch պետք չեն։ Ուստի կատարումն ավելի արագ է և կանխատեսելի, քանի որ ֆունկցիաների հասցեները նախապես հայտնի են և ներդրված են կոդի մեջ։ Generic տիպը մի քանի կոնկրետ ֆունկցիայի տարբերակների վերածելը հայտնի է որպես monomorphization, և այն speak-ի կանչերը դարձնում է նույնքան արդյունավետ, կարծես trait-եր կամ generic-ներ ընդհանրապես չլինեին։ Սակայն monomorphization-ն ունի նաև թերություններ. այն կարող է երկարացնել կոմպիլյացիայի ժամանակը և կարող է նվազեցնել պրոցեսորի հրահանգների քեշի արդյունավետությունը, քանի որ նույնական հրահանգների մի քանի օրինակները կարող են այն ուռճացնել։
Նշում #[inline] անոտացիաների մասին
Հաճախ կլսեք, որ generic-ների և ստատիկ dispatch-ի դեպքում կոմպիլյատորը կոնկրետ տիպերի համար ֆունկցիաները inline է անում։
Սա միայն կեսն է ճշմարիտ. կոմպիլյացիայի ժամանակ գործում են սովորական inlining մեխանիզմները։ Rust-ի կոմպիլյատորը բավականին լավ է գնահատում, թե երբ պետք է ֆունկցիան inline արվի, սակայն այդ գնահատականը կախված է մի քանի գործոններից, ինչպես ֆունկցիայի բարդությունը և այն, թե որքան հաճախ է այն կանչվում։
Շատ իրավիճակներում դեռևս կարող է օգտակար լինել բացահայտ ավելացնել #[inline] կամ #[inline(always)] անոտացիաներ։ rustc-ն նախագծված է monomorphization-ի ընթացքում generic ֆունկցիաները ագրեսիվ inline անելու համար, հատկապես երբ կոմպիլյացիան կատարվում է օպտիմալացման դրոշներով, ինչպես --release-ը։ Երբ հանդիպեք Ձեր կոդի արդյունավետության համար կարևոր մասերի, կամ ունենաք փոքր ֆունկցիա, որը հաճախ է կանչվում, փորձեք այն բացահայտ նշել #[inline]-ով կամ #[inline(always)]-ով և ստուգեք՝ արդյունավետությունը բարելավվում է արդյոք։ Այս անոտացիաները կարող են օգտակար լինել նաև գրադարանային crate-ի օժանդակ ֆունկցիայի համար, որը, ըստ Ձեզ, կշահի իրենից կախված crate-ներում inline արվելուց։
Դինամիկ Dispatch
Ինչպես հավանաբար կռահեցիք, դինամիկ dispatch-ը բավականին տարբերվում է ստատիկից։ Այն թույլ է տալիս կանչել trait-ի մեթոդը՝ առանց կոմպիլյացիայի ժամանակ իմանալու օբյեկտի կոնկրետ տիպը կամ իրականացումը. լուծումը տեղի է ունենում runtime-ում։
Վերցնելով մեր պարզ Շների և Կատուների օրինակը՝ դինամիկ տարբերակը կարող է այսպիսին լինել.
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 է։ Այս անգամ կատարվելիք ճշգրիտ մեթոդը լուծվում է runtime-ում վիրտուալ մեթոդների աղյուսակի (vtable) միջոցով։ Փաստացի &dyn-ը մեզ տալիս է տիպը և, runtime-ում կանչելիս, այդ տիպի մեթոդի հասցեն։ Այդ երկու տեղեկությունը ստուգում ենք vtable-ի դեմ՝ որոշելու համար, թե ճիշտ որ ֆունկցիան պետք է կանչել։
Լայն ցուցիչներ (Wide Pointers) և Trait Object-ներ
animal-ը մեր ֆունկցիային փոխանցում ենք հասցեով, քանի որ կոմպիլյացիայի ժամանակ արգումենտի ճշգրիտ չափը հայտնի չէ, մինչդեռ ցուցիչի չափը հայտնի է, ուստի կոդը կարելի է կոմպիլյացնել։ Քանի որ փաստացի փոխանցում ենք ոչ միայն ցուցիչ տիպին, այլ նաև vtable-ի հասցեն, որտեղ ամեն ինչ լուծվում է, մեզ պետք է այն, ինչ կոչվում է wide pointer։
Ոչ յուրաքանչյուր wide pointer է trait object, բայց յուրաքանչյուր trait object լրացուցիչ տեղեկություն կրող ցուցիչ է։ Այստեղ դա նշանակում է ցուցիչ կոնկրետ տիպի տվյալներին գումարած ցուցիչ vtable-ին, որը պարունակում է այդ տիպի trait-ի մեթոդների իրականացումները։
Ինչպես պարզվում է, wide pointer պահելու ունակ ցանկացած տիպ, ինչպես Box-ը և Arc-ը, կարող է օգտագործվել դինամիկ dispatch-ի համար։ Նայեք այս օրինակին.
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 trait-ի սահմանափակումը
Sized trait-ի սահմանափակումը, որը հատուկ է դինամիկ dispatch-ի համատեքստում, թույլ է տալիս վերահսկել, թե արդյոք trait-երն ու մեթոդները կարող են օգտագործվել դինամիկ dispatch-ի հետ։ Սա կարող է ազդել նրանց վրա, ովքեր օգտագործում են Ձեր trait-երը կամ մեթոդները։ Self: Sized սահմանափակմամբ կարող եք արգելափակել trait object-ների ստեղծումը և ստիպել ստատիկ dispatch։
Rust-ի տիպերի մեծ մասը Sized trait-ը իրականացնում է ավտոմատ կերպով. այն ըստ էության ասում է, որ տիպի չափը հայտնի է կոմպիլյացիայի ժամանակ։ Self: Sized սահմանափակումը trait-ին կամ trait-ի ներսի մեթոդին ավելացնելը նշում է, որ այն կարող է օգտագործվել միայն Sized տիպերի հետ, այսինքն՝ այն տիպերի, որոնց չափը պետք է հայտնի լինի կոմպիլյացիայի ժամանակ։
Ինչպես բացատրվեց նախորդ բաժնում, Trait Object դիմում ենք հենց այն պատճառով, որ չգիտենք մեր ֆունկցիային արգումենտով փոխանցվող trait-ի չափը։ Trait object-ները !Sized են, այսինքն՝ Sized չեն, և նրանց չափը կոմպիլյացիայի ժամանակ հայտնի չէ. trait object-ի ներսի ցուցիչը կարող է վերաբերել իրականացնող տիպի ցանկացած օրինակի։ Այլ կերպ ասած՝ trait-ը Sized նշելը հայտարարում է, որ այն կարող է օգտագործվել միայն կոմպիլյացիայի ժամանակ հայտնի չափով տիպերի հետ և չի կարող օգտագործվել trait object-ներ կառուցելու համար (ուստի չի կարող օգտագործվել դինամիկ dispatch-ի հետ)։
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-ի մեկ կոնկրետ մեթոդի վրա դնելը հենց այդ մեթոդը անհասանելի է դարձնում trait object-ի միջոցով, մինչդեռ հենց trait object-ը դեռ կարող է ստեղծվել և օգտագործվել։
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.
}
Դինամիկ Dispatch async կոդում
Rust-ի trait-երը ուղղակիորեն չեն աջակցում async ֆունկցիաներ, և դրանց օգտագործումը գալիս է լրացուցիչ դժվարություններով և նրբություններով, որոնք արժե իմանալ։ async մեթոդը վերադարձնում է Future, որի չափը կոմպիլյացիայի ժամանակ հայտնի չէ, քանի որ կախված է async բլոկի գրաված վիճակից, ինչը իր բնույթով դրանք դարձնում է !Sized։
Future վերադարձնող սովորական trait մեթոդները չեն կարող ուղղակիորեն օգտագործվել, քանի որ future-ների անհայտ չափը խանգարում է դրանց ուղղակիորեն վերադարձվել dyn Trait-ի մեթոդից։ Սա նման է Self: Sized-ի դրած սահմանափակմանը, միայն թե հակառակը. trait-ը չի պահանջում հայտնի չափ, այլ վերադարձվող տիպն ինքն է զուրկ հայտնի չափից։
Սա շրջանցելու համար կարող ենք վերադարձնել ինչ-որ Sized բան, որը փաթաթում է մեր future-ը, որպեսզի հետո կարողանանք աշխատել դրա հետ։ Դրա համար trait-ի մեթոդները կարող են վերադարձնել Box<dyn Future<Output = T> + Send>։ Այս մոտեցումը future-ը փաթաթում է trait object-ի մեջ՝ թույլ տալով մեզ տարբեր future տիպերի հետ գործ ունենալ մեկ ընդհանուր ինտերֆեյսով։
Շարունակելով Dog/Cat օրինակը՝ ահա async տարբերակը՝ 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>> վերադարձվող տիպը։ Այդ վերադարձվող տիպը box արված future է, որը Sized է։ Pin-ն այստեղ օգտագործվում է, որպեսզի future-ը ստեղծվելուց հետո հիշողության մեջ չտեղափոխվի։ Սա անվտանգության միջոց է, քանի որ հենց Future-ը կարող է պարունակել ինքնահղումներ։ Dog-ում և Cat-ում async բլոկները box են արվում ձեռքով, որպեսզի հայտնվեն heap-ում, և վերադարձվում է ցուցիչ դրանց վրա։ move բանալի բառը բոլոր գրավված փոփոխականները տեղափոխում է future-ի միջավայր։
Async_trait գրադարանը
Նախորդ օրինակը ցույց տվեց, թե ինչպես օգտագործել Box<dyn Future<Output = T> + Send>-ը որպես trait-ի async ֆունկցիայի վերադարձվող տիպ, բայց կա ավելի լավ ձև։ Փաստորեն, 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-ը մեզ տալիս է ավտոմատ boxing. անոտացիայի շնորհիվ async trait մեթոդները կոմպիլյացիայի ժամանակ փոխակերպվում են, որպեսզի վերադարձնեն Box<dyn Future<Output = T> + Send> (կամ Box<dyn Future<Output = T>>, երբ Send պետք չէ), ուստի մեզ պետք չէ գրել pinning-ի և boxing-ի շուրջ ողջ boilerplate-ը. դա կատարվում է մեր փոխարեն։
Ամփոփում
Ամփոփելով՝ ստատիկ dispatch-ի համեմատ դինամիկ dispatch-ը կրճատում է կոմպիլյացիայի ժամանակը, քանի որ նույն մեթոդները պետք չէ անընդհատ կոմպիլյացնել տարբեր տիպերի համար։ Նմանապես պրոցեսորի հրահանգների քեշն այլևս չի ուռճանում։ Սակայն, ինչպես մնացած ամեն ինչ, այն ունի իր թերությունները. մեր կոդը կոմպիլյացնելիս կիրառվում են ավելի քիչ օպտիմալացումներ, և ոչինչ մեզ համար inline չի արվում։ Դրան գումարած՝ կա փոքր runtime ծախս՝ vtable-ում կոնկրետ ֆունկցիան փնտրելու համար։
Ցանկացած ծրագրավորող պետք է հասկանա այս մեխանիզմներն ու դրանց փոխզիջումները՝ struct-երի/trait-երի և մեթոդների նախագծման ձևը որոշելիս և այն, թե դա ինչ ազդեցություն կարող է ունենալ արդյունավետության վրա։ Երկու մեխանիզմներից յուրաքանչյուրն ունի իր առավելություններն ու թերությունները և բերում է լրացուցիչ նկատառումներ, որոնք պետք է հիշել մեր կոդը սպասարկելիս։