Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

runtime-এর হাতে নিয়ন্ত্রণ ছেড়ে দেওয়া

“আমাদের প্রথম async প্রোগ্রাম” অংশ থেকে মনে করুন, প্রতিটি await point-এ, await করা future প্রস্তুত না থাকলে Rust runtime-কে task থামিয়ে অন্য task-এ যাওয়ার সুযোগ দেয়। উল্টোটাও সত্য: Rust শুধু await point-এই async block থামায় এবং runtime-এর হাতে নিয়ন্ত্রণ ফিরিয়ে দেয়। দুটি await point-এর মাঝের সবকিছু synchronous।

এর মানে, একটি async block-এ await point ছাড়া অনেক কাজ করলে সেই future অন্য সব future-এর অগ্রগতি আটকে দেবে। কখনো কখনো একে বলা হয় একটি future অন্য future-গুলোকে অভুক্ত রাখছে (starving)। কিছু ক্ষেত্রে এটি বড় কোনো ব্যাপার না-ও হতে পারে। তবে আপনি যদি ব্যয়বহুল কোনো প্রস্তুতি বা দীর্ঘ সময় ধরে চলা কাজ করেন, অথবা এমন একটি future থাকে যা অনির্দিষ্টকাল ধরে কোনো নির্দিষ্ট কাজ করতে থাকবে, তাহলে ভাবতে হবে কখন ও কোথায় runtime-এর হাতে নিয়ন্ত্রণ ফিরিয়ে দেবেন।

অভুক্ত রাখার সমস্যাটি দেখাতে চলুন দীর্ঘ সময় ধরে চলা একটি operation-এর অনুকরণ করি, তারপর দেখি কীভাবে এর সমাধান করা যায়। Listing 17-14-এ একটি slow function দেখানো হয়েছে।

Filename: src/main.rs
extern crate trpl; // required for mdbook test

use std::{thread, time::Duration};

fn main() {
    trpl::block_on(async {
        // পরে এখানে `slow` call করব
    });
}

fn slow(name: &str, ms: u64) {
    thread::sleep(Duration::from_millis(ms));
    println!("'{name}' ran for {ms}ms");
}
Listing 17-14: ধীর operation-এর অনুকরণ করতে thread::sleep ব্যবহার করা

এই কোড trpl::sleep-এর বদলে std::thread::sleep ব্যবহার করে, যাতে slow call করলে বর্তমান thread কয়েক millisecond-এর জন্য block হয়ে থাকে। দীর্ঘ সময় ধরে চলা এবং block করা, দুটোই এমন বাস্তব operation-এর বদলি হিসেবে slow ব্যবহার করতে পারি।

Listing 17-15-এ আমরা এক জোড়া future-এ এই ধরনের CPU-bound কাজের অনুকরণ করতে slow ব্যবহার করি।

Filename: src/main.rs
extern crate trpl; // required for mdbook test

use std::{thread, time::Duration};

fn main() {
    trpl::block_on(async {
        let a = async {
            println!("'a' started.");
            slow("a", 30);
            slow("a", 10);
            slow("a", 20);
            trpl::sleep(Duration::from_millis(50)).await;
            println!("'a' finished.");
        };

        let b = async {
            println!("'b' started.");
            slow("b", 75);
            slow("b", 10);
            slow("b", 15);
            slow("b", 350);
            trpl::sleep(Duration::from_millis(50)).await;
            println!("'b' finished.");
        };

        trpl::select(a, b).await;
    });
}

fn slow(name: &str, ms: u64) {
    thread::sleep(Duration::from_millis(ms));
    println!("'{name}' ran for {ms}ms");
}
Listing 17-15: ধীর operation-এর অনুকরণ করতে slow function call করা

প্রতিটি future অনেকগুলো ধীর operation সম্পন্ন করার পরেই কেবল runtime-এর হাতে নিয়ন্ত্রণ ফিরিয়ে দেয়। এই কোড চালালে এই output দেখবেন:

'a' started.
'a' ran for 30ms
'a' ran for 10ms
'a' ran for 20ms
'b' started.
'b' ran for 75ms
'b' ran for 10ms
'b' ran for 15ms
'b' ran for 350ms
'a' finished.

Listing 17-5-এর মতো, যেখানে দুটি URL নিয়ে আসা future-এর মধ্যে প্রতিযোগিতা করাতে trpl::select ব্যবহার করেছিলাম, a শেষ হওয়ার সঙ্গে সঙ্গে select এখনো শেষ হয়। তবে দুটি future-এর slow call-গুলোর মধ্যে কোনো মিশ্রণ নেই। a future তার trpl::sleep call-এর জন্য await না করা পর্যন্ত তার সব কাজ করে, তারপর b future তার নিজের trpl::sleep call-এর জন্য await না করা পর্যন্ত তার সব কাজ করে, আর শেষে a future শেষ হয়। দুটি future-কেই তাদের ধীর কাজের মাঝে মাঝে এগোতে দিতে আমাদের await point দরকার, যাতে runtime-এর হাতে নিয়ন্ত্রণ ফিরিয়ে দিতে পারি। অর্থাৎ এমন কিছু দরকার যার জন্য await করা যায়!

Listing 17-15-এ এই ধরনের হস্তান্তর ইতিমধ্যে ঘটতে দেখা যাচ্ছে: a future-এর শেষের trpl::sleep সরিয়ে দিলে b future একটুও না চলে এটি শেষ হয়ে যেত। operation-গুলোকে পালা করে এগোতে দেওয়ার একটি শুরুর বিন্দু হিসেবে চলুন trpl::sleep function ব্যবহার করে দেখি, যেমনটি Listing 17-16-এ দেখানো হয়েছে।

Filename: src/main.rs
extern crate trpl; // required for mdbook test

use std::{thread, time::Duration};

fn main() {
    trpl::block_on(async {
        let one_ms = Duration::from_millis(1);

        let a = async {
            println!("'a' started.");
            slow("a", 30);
            trpl::sleep(one_ms).await;
            slow("a", 10);
            trpl::sleep(one_ms).await;
            slow("a", 20);
            trpl::sleep(one_ms).await;
            println!("'a' finished.");
        };

        let b = async {
            println!("'b' started.");
            slow("b", 75);
            trpl::sleep(one_ms).await;
            slow("b", 10);
            trpl::sleep(one_ms).await;
            slow("b", 15);
            trpl::sleep(one_ms).await;
            slow("b", 350);
            trpl::sleep(one_ms).await;
            println!("'b' finished.");
        };

        trpl::select(a, b).await;
    });
}

fn slow(name: &str, ms: u64) {
    thread::sleep(Duration::from_millis(ms));
    println!("'{name}' ran for {ms}ms");
}
Listing 17-16: operation-গুলোকে পালা করে এগোতে দিতে trpl::sleep ব্যবহার করা

আমরা slow-এর প্রতিটি call-এর মাঝে await point-সহ trpl::sleep call যোগ করেছি। এখন দুটি future-এর কাজ মিশ্রিতভাবে চলে:

'a' started.
'a' ran for 30ms
'b' started.
'b' ran for 75ms
'a' ran for 10ms
'b' ran for 10ms
'a' ran for 20ms
'b' ran for 15ms
'a' finished.

b-এর হাতে নিয়ন্ত্রণ দেওয়ার আগে a future এখনো কিছুক্ষণ চলে, কারণ এটি trpl::sleep call করার আগেই slow call করে, তবে তারপর যখনই কোনো একটি await point-এ পৌঁছায়, future-গুলো পালা বদল করে। এই ক্ষেত্রে আমরা slow-এর প্রতিটি call-এর পরে তা করেছি, তবে কাজটি আমাদের কাছে যেভাবে সবচেয়ে অর্থবহ মনে হয় সেভাবে ভাগ করতে পারতাম।

তবে এখানে আমরা আসলে sleep করতে চাই না: আমরা যত দ্রুত সম্ভব এগোতে চাই। আমাদের শুধু runtime-এর হাতে নিয়ন্ত্রণ ফিরিয়ে দিতে হবে। trpl::yield_now function ব্যবহার করে সরাসরি তা করা যায়। Listing 17-17-এ আমরা ওই সব trpl::sleep call-এর জায়গায় trpl::yield_now বসাই।

Filename: src/main.rs
extern crate trpl; // required for mdbook test

use std::{thread, time::Duration};

fn main() {
    trpl::block_on(async {
        let a = async {
            println!("'a' started.");
            slow("a", 30);
            trpl::yield_now().await;
            slow("a", 10);
            trpl::yield_now().await;
            slow("a", 20);
            trpl::yield_now().await;
            println!("'a' finished.");
        };

        let b = async {
            println!("'b' started.");
            slow("b", 75);
            trpl::yield_now().await;
            slow("b", 10);
            trpl::yield_now().await;
            slow("b", 15);
            trpl::yield_now().await;
            slow("b", 350);
            trpl::yield_now().await;
            println!("'b' finished.");
        };

        trpl::select(a, b).await;
    });
}

fn slow(name: &str, ms: u64) {
    thread::sleep(Duration::from_millis(ms));
    println!("'{name}' ran for {ms}ms");
}
Listing 17-17: operation-গুলোকে পালা করে এগোতে দিতে yield_now ব্যবহার করা

এই কোড আসল উদ্দেশ্য সম্পর্কে আরও পরিষ্কার, আর sleep ব্যবহারের চেয়ে উল্লেখযোগ্যভাবে দ্রুতও হতে পারে, কারণ sleep-এর ব্যবহৃত timer-এর মতো timer-গুলো কতটা সূক্ষ্ম হতে পারে তার প্রায়ই সীমা থাকে। যেমন, আমরা যে sleep সংস্করণ ব্যবহার করছি, তাকে এক nanosecond-এর একটি Duration দিলেও এটি সবসময় অন্তত এক millisecond sleep করবে। আবারও, আধুনিক কম্পিউটার দ্রুত: এক millisecond-এ এরা অনেক কিছু করতে পারে!

এর মানে, আপনার প্রোগ্রাম আর কী করছে তার ওপর নির্ভর করে async compute-bound কাজের জন্যও কাজে লাগতে পারে, কারণ এটি প্রোগ্রামের বিভিন্ন অংশের সম্পর্ক সাজানোর একটি কাজের হাতিয়ার দেয় (তবে async state machine-এর বাড়তি খরচের বিনিময়ে)। এটি cooperative multitasking (সহযোগিতামূলক multitasking)-এর একটি রূপ, যেখানে প্রতিটি future-এর ক্ষমতা আছে await point-এর মাধ্যমে কখন নিয়ন্ত্রণ হস্তান্তর করবে তা ঠিক করার। তাই প্রতিটি future-এর দায়িত্বও আছে খুব দীর্ঘ সময় block না করার। Rust-ভিত্তিক কিছু embedded operating system-এ এটিই একমাত্র ধরনের multitasking!

অবশ্য বাস্তবের কোডে সাধারণত প্রতিটি লাইনে function call আর await point পালা করে রাখবেন না। এভাবে নিয়ন্ত্রণ ছেড়ে দেওয়া তুলনামূলকভাবে সস্তা হলেও বিনামূল্যে নয়। অনেক ক্ষেত্রে একটি compute-bound কাজ ভাগ করার চেষ্টা একে উল্লেখযোগ্যভাবে ধীর করে দিতে পারে, তাই কখনো কখনো সামগ্রিক performance-এর জন্য একটি operation-কে অল্প সময় block করতে দেওয়াই ভালো। আপনার কোডের আসল performance-এর বাধা কোথায় তা সবসময় মেপে দেখুন। তবে আপনি যদি concurrent-ভাবে ঘটবে বলে আশা করা অনেক কাজ ক্রমানুসারে ঘটতে দেখেন, তাহলে এর ভেতরের গতিপ্রকৃতি মনে রাখা গুরুত্বপূর্ণ!

নিজস্ব async abstraction তৈরি করা

future-গুলো একসঙ্গে জুড়ে নতুন pattern-ও তৈরি করা যায়। যেমন, আমাদের হাতে থাকা async উপাদান দিয়ে একটি timeout function বানাতে পারি। কাজ শেষ হলে ফলাফলটি হবে আরেকটি উপাদান, যা দিয়ে আরও async abstraction তৈরি করা যাবে।

Listing 17-18-এ দেখানো হয়েছে একটি ধীর future-এর সঙ্গে এই timeout কীভাবে কাজ করবে বলে আমরা আশা করি।

Filename: src/main.rs
extern crate trpl; // required for mdbook test

use std::time::Duration;

fn main() {
    trpl::block_on(async {
        let slow = async {
            trpl::sleep(Duration::from_secs(5)).await;
            "Finally finished"
        };

        match timeout(slow, Duration::from_secs(2)).await {
            Ok(message) => println!("Succeeded with '{message}'"),
            Err(duration) => {
                println!("Failed after {} seconds", duration.as_secs())
            }
        }
    });
}
Listing 17-18: সময়সীমাসহ একটি ধীর operation চালাতে আমাদের কল্পিত timeout ব্যবহার করা

চলুন এটি implement করি! শুরুতে timeout-এর API নিয়ে ভাবা যাক:

  • একে নিজেই একটি async function হতে হবে, যাতে এর জন্য await করা যায়।
  • এর প্রথম parameter হওয়া উচিত চালানোর জন্য একটি future। যেকোনো future-এর সঙ্গে কাজ করতে দিতে একে generic করতে পারি।
  • এর দ্বিতীয় parameter হবে অপেক্ষার সর্বোচ্চ সময়। একটি Duration ব্যবহার করলে trpl::sleep-এ পাঠানো সহজ হবে।
  • এটি একটি Result return করা উচিত। future সফলভাবে শেষ হলে Result হবে future-এর তৈরি মানসহ Ok। timeout আগে পেরিয়ে গেলে Result হবে timeout যতক্ষণ অপেক্ষা করেছে সেই duration-সহ Err।

Listing 17-19-এ এই ঘোষণাটি দেখানো হয়েছে।

Filename: src/main.rs
extern crate trpl; // required for mdbook test

use std::time::Duration;

fn main() {
    trpl::block_on(async {
        let slow = async {
            trpl::sleep(Duration::from_secs(5)).await;
            "Finally finished"
        };

        match timeout(slow, Duration::from_secs(2)).await {
            Ok(message) => println!("Succeeded with '{message}'"),
            Err(duration) => {
                println!("Failed after {} seconds", duration.as_secs())
            }
        }
    });
}

async fn timeout<F: Future>(
    future_to_try: F,
    max_time: Duration,
) -> Result<F::Output, Duration> {
    // আমাদের implementation এখানে বসবে!
}
Listing 17-19: timeout-এর signature সংজ্ঞায়িত করা

এতে type-এর ক্ষেত্রে আমাদের লক্ষ্য পূরণ হয়। এবার আমাদের দরকারি আচরণ নিয়ে ভাবা যাক: আমরা পাঠানো future আর duration-এর মধ্যে প্রতিযোগিতা করাতে চাই। duration থেকে একটি timer future তৈরি করতে trpl::sleep ব্যবহার করতে পারি, আর caller-এর পাঠানো future-এর সঙ্গে সেই timer চালাতে trpl::select ব্যবহার করতে পারি।

Listing 17-20-এ আমরা trpl::select-এর জন্য await করার ফলের ওপর match করে timeout implement করি।

Filename: src/main.rs
extern crate trpl; // required for mdbook test

use std::time::Duration;

use trpl::Either;

// --snip--

fn main() {
    trpl::block_on(async {
        let slow = async {
            trpl::sleep(Duration::from_secs(5)).await;
            "Finally finished"
        };

        match timeout(slow, Duration::from_secs(2)).await {
            Ok(message) => println!("Succeeded with '{message}'"),
            Err(duration) => {
                println!("Failed after {} seconds", duration.as_secs())
            }
        }
    });
}

async fn timeout<F: Future>(
    future_to_try: F,
    max_time: Duration,
) -> Result<F::Output, Duration> {
    match trpl::select(future_to_try, trpl::sleep(max_time)).await {
        Either::Left(output) => Ok(output),
        Either::Right(_) => Err(max_time),
    }
}
Listing 17-20: select আর sleep দিয়ে timeout সংজ্ঞায়িত করা

trpl::select-এর implementation ন্যায্য নয়: এটি সবসময় argument-গুলো যে ক্রমে পাঠানো হয়েছে সেই ক্রমে poll করে (অন্য select implementation এলোমেলোভাবে বেছে নেয় কোন argument আগে poll করবে)। তাই আমরা future_to_try-কে প্রথমে select-এ পাঠাই, যাতে max_time খুব ছোট duration হলেও এটি শেষ হওয়ার সুযোগ পায়। future_to_try আগে শেষ হলে select future_to_try-এর output-সহ Left return করবে। timer আগে শেষ হলে select timer-এর output ()-সহ Right return করবে।

future_to_try সফল হলে এবং আমরা একটি Left(output) পেলে Ok(output) return করি। এর বদলে sleep timer পেরিয়ে গেলে এবং আমরা একটি Right(()) পেলে _ দিয়ে () উপেক্ষা করে বরং Err(max_time) return করি।

এর মাধ্যমে আমাদের কাছে আরও দুটি async সহায়ক দিয়ে তৈরি একটি কাজ করা timeout আছে। কোডটি চালালে timeout-এর পরে এটি ব্যর্থতার অবস্থাটি print করবে:

Failed after 2 seconds

future যেহেতু অন্য future-এর সঙ্গে জোড়া লাগে, তাই ছোট ছোট async উপাদান দিয়ে সত্যিই শক্তিশালী হাতিয়ার বানানো যায়। যেমন, এই একই পদ্ধতিতে timeout-কে retry (আবার চেষ্টা)-এর সঙ্গে মেলাতে পারেন, আর সেগুলোকে আবার network call-এর মতো operation-এর সঙ্গে ব্যবহার করতে পারেন (যেমন Listing 17-5-এরগুলো)।

বাস্তবে আপনি সাধারণত সরাসরি async আর await নিয়ে কাজ করবেন, আর গৌণভাবে select-এর মতো function আর join! macro-র মতো macro নিয়ে, যাতে সবচেয়ে বাইরের future-গুলো কীভাবে চলবে তা নিয়ন্ত্রণ করা যায়।

একই সময়ে একাধিক future নিয়ে কাজ করার কয়েকটি উপায় আমরা দেখলাম। এরপর দেখব streams (stream) দিয়ে সময়ের সঙ্গে ক্রমানুসারে একাধিক future নিয়ে কীভাবে কাজ করা যায়।