Rc<T>, reference গুনে রাখা smart pointer
বেশিরভাগ ক্ষেত্রে ownership পরিষ্কার: আপনি ঠিক জানেন কোন variable একটি নির্দিষ্ট মানের মালিক। তবে এমন ক্ষেত্রও আছে যখন একটি মানের একাধিক owner থাকতে পারে। যেমন, graph data structure-এ একাধিক edge (সংযোগ-রেখা) একই node-কে নির্দেশ করতে পারে, আর ধারণাগতভাবে সেই node-এর মালিক হলো একে নির্দেশ করা সব edge। কোনো node-কে নির্দেশ করা একটিও edge না থাকলে, অর্থাৎ এর কোনো owner না থাকলে তবেই node-টি পরিষ্কার করা উচিত।
একাধিক ownership আপনাকে স্পষ্টভাবে চালু করতে হয় Rust-এর Rc<T> type ব্যবহার করে, যা reference counting-এর সংক্ষেপ। মানটি এখনো ব্যবহৃত হচ্ছে কি না তা নির্ধারণ
করতে Rc<T> type একটি মানের reference-এর সংখ্যা হিসাব রাখে। একটি মানের reference শূন্য হলে কোনো reference অবৈধ না করেই মানটি পরিষ্কার করা যায়।
Rc<T>-কে বসার ঘরের একটি TV হিসেবে কল্পনা করুন। প্রথম কেউ TV দেখতে ঢুকলে TV চালু করে। অন্যরাও ঘরে এসে TV দেখতে পারে। শেষ জন ঘর থেকে বেরোনোর সময় TV বন্ধ
করে দেয়, কারণ এটি আর ব্যবহৃত হচ্ছে না। অন্যরা দেখতে থাকা অবস্থায় কেউ TV বন্ধ করে দিলে বাকি দর্শকদের মধ্যে হইচই পড়ে যেত!
আমরা Rc<T> type ব্যবহার করি যখন প্রোগ্রামের একাধিক অংশের পড়ার জন্য heap-এ কিছু ডেটা allocate করতে চাই, আর compile time-এ নির্ধারণ করতে পারি না কোন অংশ ডেটা
ব্যবহার সবার শেষে শেষ করবে। কোন অংশ শেষে শেষ করবে তা জানলে আমরা সেই অংশটিকেই ডেটার owner বানিয়ে দিতে পারতাম, আর compile time-এ প্রয়োগ করা সাধারণ ownership-এর
নিয়মই কার্যকর হতো।
খেয়াল করুন, Rc<T> শুধু single-threaded (একটিমাত্র thread-যুক্ত) পরিস্থিতিতে ব্যবহারের জন্য। অধ্যায় 16-এ concurrency নিয়ে আলোচনার সময় দেখব multithreaded
প্রোগ্রামে কীভাবে reference counting করতে হয়।
ডেটা ভাগ করা
Listing 15-5-এর cons list উদাহরণে ফিরে যাই। মনে করুন, আমরা এটি Box<T> দিয়ে সংজ্ঞায়িত করেছিলাম। এবার আমরা দুটি তালিকা তৈরি করব, যারা দুজনেই তৃতীয় একটি তালিকার
ownership ভাগ করে নেবে। ধারণাগতভাবে এটি দেখতে Figure 15-3-এর মতো।
Figure 15-3: দুটি তালিকা, b আর c, তৃতীয় একটি তালিকা a-এর
ownership ভাগ করে নিচ্ছে
আমরা a তালিকা তৈরি করব, যাতে 5 আর তারপর 10 থাকবে। তারপর আরও দুটি তালিকা বানাব: 3 দিয়ে শুরু হওয়া b আর 4 দিয়ে শুরু হওয়া c। তারপর b আর c
দুটি তালিকাই 5 আর 10-যুক্ত প্রথম তালিকা a-তে গিয়ে মিশবে। অন্যভাবে বললে, দুটি তালিকাই 5 আর
10-যুক্ত প্রথম তালিকাটি ভাগ করে নেবে।
Box<T>-সহ আমাদের List-এর সংজ্ঞা দিয়ে এই পরিস্থিতি implement করার চেষ্টা কাজ করবে না, যেমনটি Listing 15-17-এ দেখানো হয়েছে।
enum List {
Cons(i32, Box<List>),
Nil,
}
use crate::List::{Cons, Nil};
fn main() {
let a = Cons(5, Box::new(Cons(10, Box::new(Nil))));
let b = Cons(3, Box::new(a));
let c = Cons(4, Box::new(a));
}
Box<T> ব্যবহার করে তৃতীয় একটি তালিকার ownership ভাগ করার চেষ্টা করা দুটি তালিকা রাখা অনুমোদিত নয়এই কোড compile করলে এই error পাই:
$ cargo run
Compiling cons-list v0.1.0 (file:///projects/cons-list)
error[E0382]: use of moved value: `a`
--> src/main.rs:11:30
|
9 | let a = Cons(5, Box::new(Cons(10, Box::new(Nil))));
| - move occurs because `a` has type `List`, which does not implement the `Copy` trait
10 | let b = Cons(3, Box::new(a));
| - value moved here
11 | let c = Cons(4, Box::new(a));
| ^ value used here after move
|
note: if `List` implemented `Clone`, you could clone the value
--> src/main.rs:1:1
|
1 | enum List {
| ^^^^^^^^^ consider implementing `Clone` for this type
...
10 | let b = Cons(3, Box::new(a));
| - you could clone this value
For more information about this error, try `rustc --explain E0382`.
error: could not compile `cons-list` (bin "cons-list") due to 1 previous error
Cons variant-গুলো তাদের রাখা ডেটার মালিক, তাই b তালিকা তৈরি করার সময় a সরে যায় b-তে এবং b a-এর মালিক হয়। তারপর c তৈরির সময় আবার a ব্যবহারের
চেষ্টা করলে তা অনুমোদিত হয় না, কারণ a সরে গেছে।
এর বদলে Cons-এর সংজ্ঞা বদলে reference রাখাতে পারতাম, কিন্তু তখন lifetime parameter উল্লেখ করতে হতো। lifetime parameter উল্লেখ করে আমরা বলে দিতাম যে তালিকার
প্রতিটি উপাদান অন্তত পুরো তালিকার সমান সময় বাঁচবে। Listing 15-17-এর উপাদান আর তালিকার ক্ষেত্রে তা সত্য, কিন্তু সব পরিস্থিতিতে নয়।
বরং আমরা List-এর সংজ্ঞা বদলে Box<T>-এর জায়গায় Rc<T> ব্যবহার করাব, যেমনটি Listing 15-18-এ দেখানো হয়েছে। প্রতিটি Cons variant এখন একটি মান আর একটি
List-কে নির্দেশ করা একটি Rc<T> রাখবে। b তৈরি করার সময় a-এর ownership না নিয়ে আমরা a-এর রাখা Rc<List> clone করব, ফলে reference-এর সংখ্যা এক থেকে দুই
হবে এবং a আর b সেই Rc<List>-এর ডেটার ownership ভাগ করে নিতে পারবে। c তৈরির সময়ও a clone করব, reference-এর সংখ্যা দুই থেকে তিন হবে। প্রতিবার
Rc::clone call করলে Rc<List>-এর ভেতরের ডেটার reference count বাড়বে, আর এর reference শূন্য না হওয়া পর্যন্ত ডেটা পরিষ্কার হবে না।
enum List {
Cons(i32, Rc<List>),
Nil,
}
use crate::List::{Cons, Nil};
use std::rc::Rc;
fn main() {
let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
let b = Cons(3, Rc::clone(&a));
let c = Cons(4, Rc::clone(&a));
}
Rc<T> ব্যবহার করা List-এর একটি সংজ্ঞাRc<T> prelude-এ নেই বলে একে scope-এ আনতে একটি use statement যোগ করতে হবে। main-এ আমরা 5 আর 10-যুক্ত তালিকাটি তৈরি করে a-তে একটি নতুন Rc<List>-এ
রাখি। তারপর b আর c তৈরির সময় Rc::clone function call করে argument হিসেবে a-এর Rc<List>-এর একটি reference পাঠাই।
Rc::clone(&a)-এর বদলে a.clone() call করতে পারতাম, কিন্তু এই ক্ষেত্রে Rust-এর রীতি হলো Rc::clone ব্যবহার করা। বেশিরভাগ type-এর clone implementation যেমন
সব ডেটার deep copy (পুরো ডেটার সম্পূর্ণ কপি) করে, Rc::clone-এর implementation তা করে না। Rc::clone call শুধু reference count বাড়ায়, যাতে খুব একটা সময়
লাগে না। ডেটার deep copy-তে অনেক সময় লাগতে পারে। reference counting-এর জন্য Rc::clone ব্যবহার করলে deep copy করা clone আর reference count বাড়ানো clone চোখে
দেখেই আলাদা করা যায়। কোডে performance-এর সমস্যা খোঁজার সময় শুধু deep copy করা clone বিবেচনা করলেই চলে, Rc::clone-এর call উপেক্ষা করা যায়।
reference count বাড়াতে clone করা
Listing 15-18-এর কাজ করা উদাহরণটি বদলাই, যাতে a-এর Rc<List>-এর reference তৈরি ও drop করার সময় reference count কীভাবে বদলায় তা দেখতে পারি।
Listing 15-19-এ আমরা main বদলে c তালিকার চারপাশে একটি ভেতরের scope রাখব; তাহলে c scope-এর বাইরে গেলে reference count কীভাবে বদলায় তা দেখতে পারব।
enum List {
Cons(i32, Rc<List>),
Nil,
}
use crate::List::{Cons, Nil};
use std::rc::Rc;
// --snip--
fn main() {
let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
println!("count after creating a = {}", Rc::strong_count(&a));
let b = Cons(3, Rc::clone(&a));
println!("count after creating b = {}", Rc::strong_count(&a));
{
let c = Cons(4, Rc::clone(&a));
println!("count after creating c = {}", Rc::strong_count(&a));
}
println!("count after c goes out of scope = {}", Rc::strong_count(&a));
}
প্রোগ্রামের যেখানে যেখানে reference count বদলায়, সেখানে আমরা reference count print করি, যা পাই Rc::strong_count function call করে। এই function-এর নাম count
না হয়ে strong_count, কারণ Rc<T> type-এর একটি weak_count-ও আছে; weak_count কী কাজে লাগে তা দেখব “Weak<T> দিয়ে reference cycle
ঠেকানো”-এ।
এই কোড এই output print করে:
$ cargo run
Compiling cons-list v0.1.0 (file:///projects/cons-list)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.45s
Running `target/debug/cons-list`
count after creating a = 1
count after creating b = 2
count after creating c = 3
count after c goes out of scope = 2
দেখতে পাচ্ছি, a-এর Rc<List>-এর প্রাথমিক reference count 1; তারপর প্রতিবার clone call করলে count 1 করে বাড়ে। c scope-এর বাইরে গেলে count 1 কমে। reference
count বাড়াতে যেমন Rc::clone call করতে হয়, কমাতে তেমন কোনো function call করতে হয় না: একটি Rc<T> মান scope-এর বাইরে গেলে Drop trait-এর implementation
স্বয়ংক্রিয়ভাবে reference count কমিয়ে দেয়।
এই উদাহরণে যা দেখা যায় না তা হলো, main-এর শেষে b আর তারপর a scope-এর বাইরে গেলে count 0 হয়, আর Rc<List> পুরোপুরি পরিষ্কার হয়ে যায়। Rc<T> ব্যবহার
করলে একটি মানের একাধিক owner থাকতে পারে, আর count নিশ্চিত করে যে যতক্ষণ কোনো owner বেঁচে আছে, ততক্ষণ মানটি বৈধ থাকে।
immutable reference-এর মাধ্যমে Rc<T> আপনাকে প্রোগ্রামের একাধিক অংশের মধ্যে শুধু পড়ার জন্য ডেটা ভাগ করতে দেয়। Rc<T> যদি একাধিক mutable reference রাখতেও দিত,
তাহলে অধ্যায় 4-এ আলোচিত borrowing-এর একটি নিয়ম ভঙ্গ হতে পারত: একই জায়গার একাধিক mutable borrow data race আর অসামঞ্জস্য ঘটাতে পারে। কিন্তু ডেটা পরিবর্তন করতে
পারা খুবই কাজের! পরের অংশে আমরা interior mutability pattern আর RefCell<T> type নিয়ে আলোচনা করব, যা Rc<T>-এর সঙ্গে মিলিয়ে ব্যবহার করে এই immutability-র
সীমাবদ্ধতার মধ্যেও কাজ করা যায়।