رفتن به مطلب
مشاهده در اپلیکیشن

راهی بهتر برای مشاهده سایت بیشتر بدانید

وبلاگ شخصی سینا جلالوندی

یک برنامه تمام‌صفحه روی صفحه اصلی شما با دریافت نوتفیکیشن، نشان‌ها و امکانات بیشتر

برای نصب روی iOS و iPadOS
  1. Tap the Share icon in Safari
  2. منو را اسکرول کنید و روی Add to Home screen بزنید
  3. روی Add در گوشه‌ی بالا-راست بزنید
برای نصب روی اندروید
  1. روی منوی سه‌نقطه (⋮) در گوشه‌ی بالا-راست مرورگر بزنید.
  2. روی Add to Home screen یا Install app بزنید.
  3. با زدن روی نصب تأیید کنید.

Pin در Rust؛ وقتی جابه‌جایی یک متغیر می‌تواند ایمنی حافظه را به خطر بیندازد

(0 نقد)

یکی از ویژگی‌های جالب زبان Rust، کنترل دقیق نحوه استفاده از حافظه و جلوگیری از رفتارهای تعریف‌نشده (Undefined Behavior) است. سیستم Ownership و Borrowing بخش مهمی از این معماری را تشکیل می‌دهند؛ اما Rust برای حل برخی مسائل پیچیده‌تر، ابزار دیگری نیز در اختیار توسعه‌دهندگان قرار داده است: Pin.

این قابلیت در مقایسه با مفاهیمی مانند Ownership، Borrowing و Lifetimes کمتر مورد توجه قرار می‌گیرد، در حالی که نقش مهمی در طراحی سیستم Async، پیاده‌سازی Futureها و ساختارهای وابسته به آدرس حافظه دارد.

برای درک اهمیت Pin، ابتدا باید با یک مسئله نسبتاً غیرمعمول در مدیریت حافظه آشنا شویم: چه اتفاقی می‌افتد اگر یک ساختار داده، اشاره‌گری به یکی از اعضای داخلی خودش داشته باشد و سپس در حافظه جابه‌جا شود؟

۱. مسئله‌ای به نام Self-Referential Types

در بسیاری از زبان‌های برنامه‌نویسی، ساخت ساختارهایی که یکی از اعضای آن‌ها به عضو دیگری از همان ساختار اشاره می‌کند، امکان‌پذیر است.

به چنین ساختارهایی Self-Referential Types گفته می‌شود.

برای مثال، فرض کنید ساختاری داریم که یک رشته را نگهداری می‌کند و در کنار آن، یک اشاره‌گر به بخشی از همان رشته قرار گرفته است.

struct SelfReferential {
    data: String,
    pointer: *const u8,
}

در این مثال، فیلد pointer می‌تواند آدرس یکی از بایت‌های موجود در data را نگهداری کند.

مشکل از جایی شروع می‌شود که ساختار جابه‌جا شود.

در Rust، جابه‌جایی یک مقدار (Move) معمولاً به معنای انتقال مالکیت آن به یک محل جدید است. در چنین شرایطی، اگر یک ساختار حاوی اشاره‌گر داخلی باشد، انتقال آن می‌تواند باعث شود اشاره‌گر همچنان به آدرس قبلی اشاره کند؛ در حالی که داده موردنظر ممکن است دیگر در آن آدرس قرار نداشته باشد.

البته در این مثال، جابه‌جایی خود ساختار لزوماً به معنای جابه‌جایی حافظه Heap متعلق به String نیست؛ زیرا String یک بافر جداگانه در Heap دارد. مسئله اصلی زمانی آشکار می‌شود که اشاره‌گر به بخشی از خود ساختار یا داده‌ای وابسته به موقعیت آن اشاره کند.

این موضوع می‌تواند به یکی از مشکلات جدی مدیریت حافظه تبدیل شود.

۲. Pin دقیقاً چه کاری انجام می‌دهد؟

Rust برای مدیریت این شرایط، نوعی به نام Pin<P> ارائه کرده است.

Pin یک Pointer Wrapper است که قرارداد مشخصی درباره جابه‌جایی مقدار مورد اشاره ایجاد می‌کند.

هدف اصلی آن این است که وقتی یک مقدار در وضعیت Pin قرار گرفت، دسترسی‌های امن نتوانند آن مقدار را به شکلی جابه‌جا کنند که قرارداد ثبات آدرس حافظه نقض شود.

نکته مهم این است که Pin حافظه را قفل نمی‌کند، سیستم‌عامل را درگیر نمی‌کند و حتی لزوماً مانع جابه‌جایی خود Pointer نمی‌شود.

بلکه محدودیت موردنظر را روی مقدار مورد اشاره اعمال می‌کند.

برای مثال:

use std::pin::Pin;

fn main() {
    let value = Box::pin(String::from("Rust"));

    println!("{}", value.as_ref());
}

در این مثال، Box::pin یک مقدار String را در Heap قرار می‌دهد و یک Pin<Box<String>> برمی‌گرداند.

خود Box می‌تواند جابه‌جا شود، اما این جابه‌جایی به معنای انتقال مقدار String در Heap نیست.

در واقع باید میان دو مفهوم تفاوت قائل شویم:

  • جابه‌جایی Pointer: انتقال مالکیت یا محل نگهداری اشاره‌گر.

  • جابه‌جایی Pointee: انتقال خود مقداری که Pointer به آن اشاره می‌کند.

Pin عمدتاً با مفهوم دوم سروکار دارد.

۳. چرا Rust به Pin نیاز دارد؟

شاید این سؤال مطرح شود که اگر Rust از ابتدا سیستم Ownership قدرتمندی دارد، چرا به مکانیزم دیگری برای کنترل جابه‌جایی حافظه نیاز پیدا کرده است؟

پاسخ این است که Ownership به‌تنهایی تضمین نمی‌کند آدرس فیزیکی یک مقدار در طول عمر آن ثابت بماند.

برای مثال:

fn main() {
    let first = String::from("Hello Rust");

    let second = first;

    println!("{}", second);
}

در این مثال، مالکیت String از first به second منتقل می‌شود.

این رفتار کاملاً معتبر است و هیچ مشکلی ندارد.

اما در ساختارهایی که وابستگی مستقیمی به آدرس حافظه دارند، چنین جابه‌جایی‌هایی ممکن است خطرناک باشند.

Pin این امکان را فراهم می‌کند که API یک نوع داده اعلام کند: پس از قرار گرفتن در وضعیت Pin، مقدار نباید از طریق عملیات امنی که قرارداد Pin را نقض می‌کنند، جابه‌جا شود.

این قابلیت به‌خصوص برای ساختارهایی اهمیت دارد که نمی‌توان آن‌ها را به‌سادگی با Copy یا Clone جایگزین کرد.

۴. مفهوم Unpin؛ تفاوت مهمی که باید بدانیم

برای درک درست Pin، شناخت Trait دیگری به نام Unpin ضروری است.

در Rust، بسیاری از انواع داده به‌صورت خودکار Unpin هستند.

این Trait مشخص می‌کند که آیا یک نوع داده می‌تواند با وجود قرار گرفتن در Pin، همچنان به شکل معمول جابه‌جا شود یا خیر.

برای مثال، انواع ساده‌ای مانند i32 و بسیاری از ساختارهای معمولی Unpin هستند.

use std::pin::Pin;

fn main() {
    let number = Box::pin(42);

    let value: Pin<Box<i32>> = number;

    println!("{}", value.as_ref().get_ref());
}

در این مثال، چون i32 از Unpin پیروی می‌کند، محدودیت جابه‌جایی Pin برای آن معنای خاصی ندارد.

اما اگر نوعی از !Unpin باشد، شرایط متفاوت می‌شود.

علامت !Unpin به معنای نوعی است که Unpin را پیاده‌سازی نمی‌کند.

برای مثال، می‌توان از PhantomPinned استفاده کرد:

use std::marker::PhantomPinned;

struct MyData {
    value: String,
    _pin: PhantomPinned,
}

وجود PhantomPinned باعث می‌شود کامپایلر به‌صورت خودکار برای این ساختار Unpin را پیاده‌سازی نکند.

این یعنی اگر نمونه‌ای از MyData در Pin قرار بگیرد، دیگر نمی‌توان از طریق APIهای امن، آن را مانند یک مقدار عادی از محل خود خارج کرد.

البته یک نکته مهم وجود دارد: !Unpin بودن به‌تنهایی به معنای Self-Referential بودن نیست. این Trait صرفاً امکان ایجاد قرارداد ثبات آدرس را فراهم می‌کند.

۵. یک مثال عملی‌تر با Box::pin

حالا بیایید یک نمونه واقعی‌تر بسازیم.

use std::marker::PhantomPinned;
use std::pin::Pin;

struct Device {
    name: String,
    _pin: PhantomPinned,
}

fn main() {
    let device = Device {
        name: String::from("Network Controller"),
        _pin: PhantomPinned,
    };

    let pinned_device: Pin<Box<Device>> = Box::pin(device);

    println!("{}", pinned_device.as_ref().name);
}

در این مثال، ساختار Device به‌صورت !Unpin تعریف شده است.

سپس با استفاده از Box::pin در Heap قرار می‌گیرد و یک Pointer پین‌شده دریافت می‌کنیم.

از این لحظه، کد امن نمی‌تواند مقدار Device را به‌سادگی از طریق این Pin خارج کند و آن را به محل دیگری منتقل کند.

توجه داشته باشید که Pin تضمین نمی‌کند هیچ کدی تحت هیچ شرایطی نتواند مقدار را جابه‌جا کند. کد Unsafe همچنان می‌تواند قراردادهای Pin را نقض کند؛ بنابراین مسئولیت رعایت این قرارداد در طراحی APIهای Unsafe بسیار مهم است.

۶. ارتباط Pin با سیستم Async در Rust

شاید مهم‌ترین کاربرد عملی Pin را بتوان در سیستم Async زبان Rust مشاهده کرد.

وقتی یک تابع با استفاده از async تعریف می‌شود، کامپایلر آن را به ساختاری تبدیل می‌کند که وضعیت اجرای عملیات را نگهداری می‌کند.

برای مثال:

async fn download_data() {
    println!("Downloading...");
}

این تابع هنگام فراخوانی، عملیات را بلافاصله اجرا نمی‌کند؛ بلکه یک Future تولید می‌کند.

Futureها برای اجرا شدن به مکانیزمی به نام Poll نیاز دارند.

یک Future ممکن است در اولین فراخوانی Poll هنوز آماده نباشد و مقدار Poll::Pending را برگرداند. در این حالت، وضعیت داخلی آن حفظ می‌شود تا در آینده دوباره مورد بررسی قرار بگیرد.

حالا تصور کنید یک Future دارای چند متغیر داخلی باشد که یکی از آن‌ها به بخش دیگری از همان Future اشاره کند.

اگر چنین Futureای هنگام اجرای عملیات جابه‌جا شود، ممکن است اعتبار اشاره‌گرهای داخلی آن از بین برود.

به همین دلیل، امضای متد Poll در Trait استاندارد Future به شکل زیر تعریف شده است:

fn poll(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
) -> Poll<Self::Output>;

نکته کلیدی این امضا، استفاده از Pin<&mut Self> به‌جای &mut Self معمولی است.

این طراحی به Runtimeها و Executorهای Async اجازه می‌دهد Futureهایی را اجرا کنند که به ثبات آدرس حافظه نیاز دارند.

به بیان ساده، Pin یکی از قطعات مهم زیرساختی است که اجرای امن Futureهای وابسته به آدرس را امکان‌پذیر می‌کند.

۷. Pin Projection چیست و چرا اهمیت دارد؟

یکی از چالش‌های کار با Pin، دسترسی به فیلدهای داخلی یک ساختار پین‌شده است.

فرض کنید یک ساختار داریم که خودش !Unpin است و یکی از فیلدهای آن نیز باید قرارداد Pin را حفظ کند.

در چنین شرایطی، نمی‌توان بدون توجه به قواعد Pin، یک Reference معمولی قابل‌تغییر به فیلد داخلی تولید کرد.

اینجاست که مفهومی به نام Pin Projection مطرح می‌شود.

Pin Projection به معنای تبدیل یک Pin روی ساختار اصلی به Pin روی یکی از فیلدهای داخلی آن است؛ البته تنها در شرایطی که قراردادهای ایمنی اجازه چنین کاری را بدهند.

برای این کار معمولاً از ابزارهایی مانند crate معروف pin-project استفاده می‌شود.

این کتابخانه با فراهم کردن Macroهای مناسب، بخش زیادی از پیچیدگی پیاده‌سازی Projection را کاهش می‌دهد.

مثلاً:

use pin_project::pin_project;
use std::pin::Pin;

#[pin_project]
struct MyFuture {
    #[pin]
    inner: SomeFuture,

    counter: u32,
}

در این مثال، فیلد inner به‌عنوان فیلد پین‌شده مشخص شده است.

کتابخانه با استفاده از Macro، متدهای Projection لازم را تولید می‌کند تا دسترسی به فیلدهای داخلی مطابق قرارداد Pin انجام شود.

نکته جالب این است که تمام فیلدهای یک ساختار لزوماً به Pin نیاز ندارند. تنها فیلدهایی که باید ثبات آدرس داشته باشند، باید به شکل مناسب پین شوند.

۸. آیا Pin واقعاً مانع جابه‌جایی حافظه می‌شود؟

یکی از اشتباهات رایج در درک Pin این است که تصور کنیم این ابزار تمام عملیات جابه‌جایی را در سطح حافظه غیرممکن می‌کند.

چنین برداشتی دقیق نیست.

Pin در واقع یک قرارداد ایمنی است که از طریق APIهای امن Rust اجرا می‌شود.

برای مثال، اگر نوع داده Unpin باشد، امکان خارج کردن آن از Pin وجود دارد.

همچنین اگر برنامه‌نویس از Unsafe استفاده کند و قراردادهای Pin را نقض کند، ممکن است به رفتار تعریف‌نشده برسد.

بنابراین Pin یک مکانیزم جادویی برای قفل کردن حافظه نیست.

قدرت واقعی آن در ترکیب با سیستم Type، Ownership و Borrowing زبان Rust قرار دارد.

نکته فنی دیگری نیز وجود دارد: قرارداد Pin برای مقدار پین‌شده، شامل تضمین‌هایی درباره حفظ اعتبار مقدار تا پایان عمر آن است؛ از جمله اینکه Destructor آن نباید پیش از پایان عمر مورد انتظار، به شکلی ناسازگار اجرا شود. به همین دلیل، پیاده‌سازی انواع و APIهای مرتبط با Pin نیازمند دقت زیادی است.

۹. Pin چه کاربردهایی خارج از Async دارد؟

اگرچه Pin بیشتر در ارتباط با سیستم Async شناخته می‌شود، کاربردهای آن به این حوزه محدود نیست.

برخی از کاربردهای مهم آن عبارت‌اند از:

  • Self-Referential Structures: طراحی ساختارهایی که شامل Reference یا Pointer وابسته به بخش‌های داخلی خود هستند.

  • Async Runtime Development: پیاده‌سازی Executorها و مدیریت Futureها.

  • Low-Level Systems Programming: توسعه ابزارها و کتابخانه‌هایی که به کنترل دقیق طول عمر و آدرس داده‌ها نیاز دارند.

  • Intrusive Data Structures: ساختارهای داده‌ای که ارتباط میان اعضا از طریق اشاره‌گرهای ذخیره‌شده در خود عناصر مدیریت می‌شود.

  • Advanced Memory Management: پیاده‌سازی APIهایی که به تضمین‌های دقیق‌تری درباره محل قرارگیری داده نیاز دارند.

البته برای بسیاری از برنامه‌های معمولی، استفاده مستقیم از Pin ضرورتی ندارد و بهتر است تنها زمانی سراغ آن برویم که طراحی نرم‌افزار واقعاً به چنین تضمینی نیاز داشته باشد.

۱۰. جمع‌بندی؛ اهمیت Pin در معماری Rust

Rust تنها به جلوگیری از دسترسی‌های نامعتبر به حافظه اکتفا نمی‌کند؛ بلکه مجموعه‌ای از ابزارهای سطح پایین در اختیار توسعه‌دهنده قرار می‌دهد تا بتواند رفتار برنامه را با دقت بیشتری کنترل کند.

Pin یکی از نمونه‌های جالب این رویکرد است.

این قابلیت نشان می‌دهد که حتی مسئله‌ای به ظاهر ساده مانند جابه‌جایی یک مقدار در حافظه، در طراحی سیستم‌های پیچیده می‌تواند اهمیت بسیار زیادی داشته باشد.

ترکیب Pin با Ownership، Borrowing، Lifetimes و سیستم Type، امکان پیاده‌سازی ساختارهایی را فراهم می‌کند که در بسیاری از زبان‌ها به مدیریت دستی و پرریسک حافظه نیاز دارند.

شاید Pin قابلیتی نباشد که هر روز در کدهای معمولی Rust از آن استفاده کنیم؛ اما درک آن کمک می‌کند معماری داخلی Rust، به‌خصوص سیستم Async و مدل ایمنی حافظه آن، عمیق‌تر درک شود.

بازخورد کاربر

هیچ امتیازی برای نمایش وجود ندارد.

حساب

‏ناوبری‏

جستجو

جستجو

Configure browser push notifications

Chrome (Android)
  1. Tap the lock icon next to the address bar.
  2. Tap Permissions → Notifications.
  3. Adjust your preference.
Chrome (Desktop)
  1. Click the padlock icon in the address bar.
  2. Select Site settings.
  3. Find Notifications and adjust your preference.