Enterprise

IO_URING cat with liburing

'liburing'를 이용한 cat 프로그램

우리는 파일을 읽는 프로그램처럼 간단한 것을 구축하는 것이 'io_uring'으로는 간단하지 않을 수 있다는 것을 알았습니다. 동기식 I/O로 파일을 읽는 프로그램보다 더 많은 코드가 있다는 것이 밝혀졌습니다. 그러나 하위 수준 'io_uring' 인터페이스를 사용한 cat 유틸리티의 코드를 분석하면, 대부분의 코드에는 별도의 파일에 쉽게 숨길 수 있고 애플리케이션 로직에 방해가 되지 않는 상용구 코드가 있다는 것을 알게 될 것입니다. 어쨌든 우리는 작동 방식을 더 잘 이해하기 위해 의도적으로 낮은 수준의 'io_uring' 세부 정보를 학습하고 있습니다. 그건 그렇고, 이제 'liburing'을 사용하여 기능적으로 유사한 프로그램을 어떻게 구현할 수 있는지 살펴보겠습니다.

#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <liburing.h>
#include <stdlib.h>

#define QUEUE_DEPTH 1
#define BLOCK_SZ    1024

struct file_info {
    off_t file_sz;
    struct iovec iovecs[];      /* Referred by readv/writev */
};

/*
* Returns the size of the file whose open file descriptor is passed in.
* Properly handles regular file and block devices as well. Pretty.
* 열린 파일 설명자가 전달된 파일의 크기를 반환합니다.
* 일반 파일 및 블록 장치도 올바르게 처리합니다.
* */

off_t get_file_size(int fd) {
    struct stat st;

    if(fstat(fd, &st) < 0) {
        perror("fstat");
        return -1;
    }

    if (S_ISBLK(st.st_mode)) {
        unsigned long long bytes;
        if (ioctl(fd, BLKGETSIZE64, &bytes) != 0) {
            perror("ioctl");
            return -1;
        }
        return bytes;
    } else if (S_ISREG(st.st_mode))
        return st.st_size;

    return -1;
}

/*
 * Output a string of characters of len length to stdout.
 * We use buffered output here to be efficient,
 * since we need to output character-by-character.
 * len 길이의 문자열을 stdout으로 출력합니다.
 * 문자별로 출력해야 하므로 여기서는 효율적으로 버퍼링된 출력을 사용합니다.
 * */ 
void output_to_console(char *buf, int len) {
    while (len--) {
        fputc(*buf++, stdout);
    }
}

/*
 * Wait for a completion to be available, fetch the data from
 * the readv operation and print it to the console.
 * 완료가 가능할 때까지 기다리고 'readv' 작업에서 데이터를 가져와서 콘솔에 인쇄합니다.
 * */
 
int get_completion_and_print(struct io_uring *ring) {
    struct io_uring_cqe *cqe; // completion queue event
    int ret = io_uring_wait_cqe(ring, &cqe);
    if (ret < 0) {
        perror("io_uring_wait_cqe");
        return 1;
    }
    if (cqe->res < 0) {
        fprintf(stderr, "Async readv failed.\n");
        return 1;
    }
    struct file_info *fi = io_uring_cqe_get_data(cqe);
    int blocks = (int) fi->file_sz / BLOCK_SZ; // 1024
    if (fi->file_sz % BLOCK_SZ) blocks++;
    for (int i = 0; i < blocks; i ++)
        output_to_console(fi->iovecs[i].iov_base, fi->iovecs[i].iov_len);

    io_uring_cqe_seen(ring, cqe);
    return 0;
}

/*
 * Submit the readv request via liburing
 * liburing을 통해 readv 요청을 제출하세요.
 * */
int submit_read_request(char *file_path, struct io_uring *ring) {
    int file_fd = open(file_path, O_RDONLY);
    if (file_fd < 0) {
        perror("open");
        return 1;
    }
    off_t file_sz = get_file_size(file_fd); // 파일의 크기를 리턴, -1 체크 필요.  
    off_t bytes_remaining = file_sz;
    off_t offset = 0;
    int current_block = 0;
    int blocks = (int) file_sz / BLOCK_SZ;
    if (file_sz % BLOCK_SZ) blocks++;
    struct file_info *fi = malloc(sizeof(*fi) +
                                          (sizeof(struct iovec) * blocks));
    char *buff = malloc(file_sz);
    if (!buff) {
        fprintf(stderr, "Unable to allocate memory.\n");
        return 1;
    }

    /*
     * For each block of the file we need to read, we allocate an iovec struct
     * which is indexed into the iovecs array. This array is passed in as part
     * of the submission. If you don't understand this, then you need to look
     * up how the readv() and writev() system calls work.
	 * 읽어야 하는 파일의 각 블록에 대해 iovec 배열에 인덱싱된 iovec 구조체를 할당합니다. 
	 * 이 배열은 제출의 일부로 전달됩니다.
	 * 이것을 이해하지 못한다면 readv() 및 writev() 시스템 호출이 어떻게 작동하는지 살펴봐야 합니다.
     * */
    while (bytes_remaining) {
        off_t bytes_to_read = bytes_remaining;
        if (bytes_to_read > BLOCK_SZ)
            bytes_to_read = BLOCK_SZ;

        offset += bytes_to_read;
        fi->iovecs[current_block].iov_len = bytes_to_read;
        void *buf;
		// posix_memalign(): 특정 크기의 메모리 블록을 특정 기준에 맞춰 할당하는 데 사용됩니다. 
		// 이 함수는 메모리 할당 시 정렬을 보장해야 하는 경우에 유용합니다.
        if( posix_memalign(&buf, BLOCK_SZ, BLOCK_SZ)) {
            perror("posix_memalign");
            return 1;
        }
        fi->iovecs[current_block].iov_base = buf;

        current_block++;
        bytes_remaining -= bytes_to_read;
    }
    fi->file_sz = file_sz;

    /* Get an SQE */
    struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
    /* Setup a readv operation */
    io_uring_prep_readv(sqe, file_fd, fi->iovecs, blocks, 0);
    /* Set user data */
    io_uring_sqe_set_data(sqe, fi);
    /* Finally, submit the request */
    io_uring_submit(ring);

    return 0;
}

int main(int argc, char *argv[]) {
    struct io_uring ring;

    if (argc < 2) {
        fprintf(stderr, "Usage: %s [file name] <[file name] ...>\n",
                argv[0]);
        return 1;
    }

    /* Initialize io_uring */
    io_uring_queue_init(QUEUE_DEPTH, &ring, 0);

    for (int i = 1; i < argc; i++) {
        int ret = submit_read_request(argv[i], &ring);
        if (ret) {
            fprintf(stderr, "Error reading file: %s\n", argv[i]);
            return 1;
        }
        get_completion_and_print(&ring);
    }

    /* Call the clean-up function. */
    io_uring_queue_exit(&ring);
    return 0;
}

⚛ 원문

Email 답글이 올라오면 이메일로 알려드리겠습니다.