Giriş

Günümüzde veri akış hızları ve miktarları arttıkça, uygulamalarımızda verimlilik ve performansın artırılması artık bir zorunluluk haline gelmiştir. Rust dilinde bu ihtiyacı karşılamak için Tokio ve mIO gibi kütüphaneler geliştirilmiştir. Zero-Copy TCP Streaming, veri akışlarını daha verimli bir şekilde işleyerek performansın artırılmasını sağlar. Bu makalede, Rust'ta async/await ile Tokio ve mIO için Zero-Copy TCP Streaming hakkında teknik detaylar vereceğiz.

Teknik Detaylar

Zero-Copy TCP Streaming, veri akışlarını bir seferde bellekte okuyup işleyerek, bellekte bir kopyalama gerektirmeden veri aktarımını sağlar. Bu teknoloji, Tokio ve mIO kütüphaneleri ile birlikte çalışabilir.

Tokio

Tokio, Rust dilinde async/await destekli bir kütüphancedir. Tokio, TCP streaming için tokio::net::TcpStream sınıfını sağlar. Bu sınıf, TCP streaming için bir akış sınıfıdır.

rustKopyala
use tokio::net::{TcpListener, TcpStream};
use tokio::prelude::*;

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;

    loop {
        let (mut stream, _) = listener.accept().await?;

        tokio::spawn(async move {
            let mut buf = [0; 1024];
            let mut count = stream.read(&mut buf).await?;

            while count > 0 {
                // Veri işleme
                println!("Received: {:?}", buf[..count]);

                count = stream.read(&mut buf).await?;
            }
        });
    }
}

mIO

mIO, Rust dilinde async/await destekli bir kütüphancedir. mIO, TCP streaming için mio::net::TcpStream sınıfını sağlar. Bu sınıf, TCP streaming için bir akış sınıfıdır.

rustKopyala
use mio::net::TcpStream;
use mio::ready::Ready;
use mio::Poll;
use mio::Token;

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let poll = Poll::new()?;
    let mut token = Token(1);

    let stream = TcpStream::connect("127.0.0.1:8080").await?;

    poll.register(&stream, token, Ready::readable(), Poll::empty()).await?;

    loop {
        poll.poll(&mut [stream], None).await?;

        if stream.is_readable() {
            let mut buf = [0; 1024];
            let count = stream.read(&mut buf).await?;

            // Veri işleme
            println!("Received: {:?}", buf[..count]);
        }
    }
}

Zero-Copy

Zero-Copy, veri akışlarını bir seferde bellekte okuyup işleyerek, bellekte bir kopyalama gerektirmeden veri aktarımını sağlar. Rust dilinde, std::io::Read ve std::io::Write arayüzlerini kullanarak Zero-Copy gerçekleştirebiliriz.

rustKopyala
use std::io;

struct MyRead;

impl std::io::Read for MyRead {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        // Veri akışı işleme
        println!("Read: {:?}", buf);
        Ok(buf.len())
    }
}

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let stream = TcpStream::connect("127.0.0.1:8080").await?;

    let mut reader = MyRead;
    let mut buf = [0; 1024];

    loop {
        let count = stream.read(&mut buf).await?;

        if count > 0 {
            reader.read(&mut buf[..count]).await?;
        }
    }
}

Kombinasyon

Tokio, mIO ve Zero-Copy teknolojilerini bir araya getirebiliriz.

rustKopyala
use tokio::net::{TcpListener, TcpStream};
use tokio::prelude::*;
use mio::net::TcpStream;
use mio::ready::Ready;
use mio::Poll;
use mio::Token;

struct MyRead;

impl std::io::Read for MyRead {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        // Veri akışı işleme
        println!("Read: {:?}", buf);
        Ok(buf.len())
    }
}

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;

    loop {
        let (mut stream, _) = listener.accept().await?;

        tokio::spawn(async move {
            let mut token = Token(1);
            let poll = Poll::new()?;
            poll.register(&stream, token, Ready::readable(), Poll::empty()).await?;

            loop {
                poll.poll(&mut [stream], None).await?;

                if stream.is_readable() {
                    let mut buf = [0; 1024];
                    let count = stream.read(&mut buf).await?;

                    if count > 0 {
                        let mut reader = MyRead;
                        reader.read(&mut buf[..count]).await?;
                    }
                }
            }
        });
    }
}