Part 1
요약·해설
RTIO가 해결하는 hardware coupling 문제부터 io_uring 기반 두 ring, executor scheduling, iodev contract, 취소 한계, memory-pool ownership과 84개 C API까지 설명합니다.
SQE · chain · transaction
Executor · iodev · DMA
CQE · mempool · release
Part 2
접을 수 있는 영어 원문 전체
영어 원문 전체 펼치기
9B7EC1A9BDD99C98454B06FD136A5B6C96604A5CF9F5392A5F6E1E72DACBEC22
.. _rtio:
Real Time I/O (RTIO)
####################
.. contents::
:local:
:depth: 2
.. image:: ../../../../services/rtio/rings.png
:width: 800
:alt: Submissions and Completion Ring Queues
RTIO provides a framework for doing asynchronous operation chains with event
driven I/O. This section covers the RTIO API, queues, executor, iodev,
and common usage patterns with peripheral devices.
RTIO takes a lot of inspiration from Linux's io_uring in its operations and API
as that API matches up well with hardware transfer queues and descriptions such as
DMA transfer lists.
Problem
*******
An application wishing to do complex DMA or interrupt driven operations today
in Zephyr requires direct knowledge of the hardware and how it works. There is
no understanding in the DMA API of other Zephyr devices and how they relate.
This means doing complex audio, video, or sensor streaming requires direct
hardware knowledge or leaky abstractions over DMA controllers. Neither is ideal.
To enable asynchronous operations, especially with DMA, a description of what
to do rather than direct operations through C and callbacks is needed. Enabling
DMA features such as channels with priority, and sequences of transfers requires
more than a simple list of descriptions.
Using DMA and/or interrupt driven I/O shouldn't dictate whether or not the
call is blocking or not.
Inspiration, introducing io_uring
*********************************
It's better not to reinvent the wheel (or ring in this case) and io_uring as an
API from the Linux kernel provides a winning model. In io_uring there are two
lock-free ring buffers acting as queues shared between the kernel and a userland
application. One queue for submission entries which may be chained and flushed to
create concurrent sequential requests. A second queue for completion queue events.
Only a single syscall is actually required to execute many operations, the
io_uring_submit call. This call may block the caller when a number of
operations to wait on is given.
This model maps well to DMA and interrupt driven transfers. A request to do a
sequence of operations in an asynchronous way directly relates
to the way hardware typically works with interrupt driven state machines
potentially involving multiple peripheral IPs like bus and DMA controllers.
Submission Queue
****************
The submission queue (sq), is the description of the operations
to perform in concurrent chains.
For example imagine a typical SPI transfer where you wish to write a
register address to then read from. So the sequence of operations might be...
1. Chip Select
2. Clock Enable
3. Write register address into SPI transmit register
4. Read from the SPI receive register into a buffer
5. Disable clock
6. Disable Chip Select
If anything in this chain of operations fails give up. Some of those operations
can be embodied in a device abstraction that understands a read or write
implicitly means setup the clock and chip select. The transactional nature of
the request also needs to be embodied in some manner. Of the operations above
perhaps the read could be done using DMA as its large enough make sense. That
requires an understanding of how to setup the device's particular DMA to do so.
The above sequence of operations is embodied in RTIO as chain of
submission queue entries (sqe). Chaining is done by setting a bitflag in
an sqe to signify the next sqe must wait on the current one.
Because the chip select and clocking is common to a particular SPI controller
and device on the bus it is embodied in what RTIO calls an iodev.
Multiple operations against the same iodev are done in the order provided as
soon as possible. If two operation chains have varying points using the same
device its possible one chain will have to wait for another to complete.
Completion Queue
****************
In order to know when a sqe has completed there is a completion
queue (cq) with completion queue events (cqe). A sqe once completed results in
a cqe being pushed into the cq. The ordering of cqe may not be the same order of
sqe. A chain of sqe will however ensure ordering and failure cascading.
Other potential schemes are possible but a completion queue is a well trod
idea with io_uring and other similar operating system APIs.
Executor
********
The RTIO executor is a low overhead concurrent I/O task scheduler. It ensures
certain request flags provide the expected behavior. It takes a list of
submissions working through them in order. Various flags allow for changing the
behavior of how submissions are worked through. Flags to form in order chains of
submissions, transactional sets of submissions, or create multi-shot
(continuously producing) requests are all possible!
IO Device
*********
Turning submission queue entries (sqe) into completion queue events (cqe) is the
job of objects implementing the iodev (IO device) API. This API accepts requests
in the form of the iodev submit API call. It is the io devices job to work
through its internal queue of submissions and convert them into completions. In
effect every io device can be viewed as an independent, event driven actor like
object, that accepts a never ending queue of I/O like requests. How the iodev
does this work is up to the author of the iodev, perhaps the entire queue of
operations can be converted to a set of DMA transfer descriptors, meaning the
hardware does almost all of the real work.
Cancellation
************
Canceling an already queued operation is possible but not guaranteed. If the
SQE has not yet started, it's likely that a call to :c:func:`rtio_sqe_cancel`
will remove the SQE and never run it. If, however, the SQE already started
running, the cancel request will be ignored.
Memory pools
************
In some cases requests to read may not know how much data will be produced.
Alternatively, a reader might be handling data from multiple io devices where
the frequency of the data is unpredictable. In these cases it may be wasteful
to bind memory to in flight read requests. Instead with memory pools the memory
to read into is left to the iodev to allocate from a memory pool associated with
the RTIO context that the read was associated with. To create such an RTIO
context the :c:macro:`RTIO_DEFINE_WITH_MEMPOOL` can be used. It allows creating
an RTIO context with a dedicated pool of "memory blocks" which can be consumed by
the iodev. Below is a snippet setting up the RTIO context with a memory pool.
The memory pool has 128 blocks, each block has the size of 16 bytes, and the data
is 4 byte aligned.
.. code-block:: C
#include <zephyr/rtio/rtio.h>
#define SQ_SIZE 4
#define CQ_SIZE 4
#define MEM_BLK_COUNT 128
#define MEM_BLK_SIZE 16
#define MEM_BLK_ALIGN 4
RTIO_DEFINE_WITH_MEMPOOL(rtio_context,
SQ_SIZE, CQ_SIZE, MEM_BLK_COUNT, MEM_BLK_SIZE, MEM_BLK_ALIGN);
When a read is needed, the caller simply needs to replace the call
:c:func:`rtio_sqe_prep_read` (which takes a pointer to a buffer and a length)
with a call to :c:func:`rtio_sqe_prep_read_with_pool`. The iodev requires
only a small change which works with both pre-allocated data buffers as well as
the mempool. When the read is ready, instead of getting the buffers directly
from the :c:struct:`rtio_iodev_sqe`, the iodev should get the buffer and count
by calling :c:func:`rtio_sqe_rx_buf` like so:
.. code-block:: C
uint8_t *buf;
uint32_t buf_len;
int rc = rtio_sqe_rx_buff(iodev_sqe, MIN_BUF_LEN, DESIRED_BUF_LEN, &buf, &buf_len);
if (rc != 0) {
LOG_ERR("Failed to get buffer of at least %u bytes", MIN_BUF_LEN);
return;
}
Finally, the consumer will be able to access the allocated buffer via
:c:func:`rtio_cqe_get_mempool_buffer`.
.. code-block:: C
uint8_t *buf;
uint32_t buf_len;
int rc = rtio_cqe_get_mempool_buffer(&rtio_context, &cqe, &buf, &buf_len);
if (rc != 0) {
LOG_ERR("Failed to get mempool buffer");
return rc;
}
/* Release the cqe events (note that the buffer is not released yet */
rtio_cqe_release_all(&rtio_context);
/* Do something with the memory */
/* Release the mempool buffer */
rtio_release_buffer(&rtio_context, buf);
When to Use
***********
RTIO is useful in cases where concurrent or batch like I/O flows are useful.
From the driver/hardware perspective the API enables batching of I/O requests, potentially in an optimal way.
Many requests to the same SPI peripheral for example might be translated to hardware command queues or DMA transfer
descriptors entirely. Meaning the hardware can potentially do more than ever.
There is a small cost to each RTIO context and iodev. This cost could be weighed
against using a thread for each concurrent I/O operation or custom queues and
threads per peripheral. RTIO is much lower cost than that.
API Reference
*************
.. doxygengroup:: rtio
Part 3
한국어 전문 번역
RTIO(Real Time I/O)는 event-driven I/O로 asynchronous operation chain을 실행하는 framework입니다. 이 문서는 RTIO API, queue, executor, iodev와 peripheral 사용 pattern을 설명합니다.
설계는 Linux io_uring에서 크게 영감을 받았습니다. Submission과 completion을 분리한 ring API가 DMA transfer list나 hardware queue와 잘 맞기 때문입니다.

Problem
기존 Zephyr application이 복잡한 DMA 또는 interrupt-driven operation을 만들려면 hardware 세부와 동작 방식을 직접 알아야 합니다. DMA API는 다른 Zephyr device와의 관계를 이해하지 못합니다.
따라서 audio, video, sensor streaming은 DMA controller 내부를 application에 노출하거나 abstraction이 hardware 세부를 새게 만듭니다. 둘 다 유지보수와 이식성에 불리합니다.
필요한 것은 C function과 callback을 즉시 호출하는 방식이 아니라 '무엇을 수행할지' 기술하는 request입니다. Priority channel과 transfer sequence 같은 DMA 기능은 단순 descriptor list보다 풍부한 관계 표현이 필요하며, DMA·interrupt 사용 여부가 caller의 blocking 여부를 강제해서도 안 됩니다.
Inspiration, introducing io_uring
Linux io_uring은 kernel과 user application이 공유하는 두 lock-free ring buffer를 둡니다. Submission ring에는 chain 가능한 request가 들어가고, completion ring에는 완료 event가 들어갑니다.
여러 operation을 실행하는 데 필요한 syscall은 io_uring_submit 하나뿐이며, 기다릴 operation 수를 주면 caller를 block할 수도 있습니다. 이 모델은 interrupt state machine, bus controller와 DMA controller가 함께 움직이는 hardware transfer에도 자연스럽게 대응합니다.
Submission Queue
Submission queue(SQ)는 동시에 진행할 수 있는 operation chain을 기술합니다. 예를 들어 SPI register를 읽는 transaction은 chip select, clock enable, address write, receive-buffer read, clock disable, chip-select disable 순서가 될 수 있습니다.
- Chip Select
- Clock Enable
- SPI transmit register에 register address 쓰기
- SPI receive register에서 buffer로 읽기
- Clock Disable
- Chip Select Disable
Chain 중 하나가 실패하면 뒤 operation을 포기해야 합니다. Clock과 chip select 같은 공통 동작은 read·write를 이해하는 device abstraction에 숨길 수 있고, 큰 read는 device별 DMA 설정을 이용할 수 있습니다.
RTIO는 각 operation을 SQE(submission queue entry)로 표현합니다. SQE flag로 '다음 SQE는 현재 SQE가 끝날 때까지 기다린다'고 표시해 chain을 만듭니다. 특정 SPI controller와 bus device에 공통인 제어는 iodev가 담당합니다.
같은 iodev에 대한 operation은 제공된 순서대로 가능한 한 빨리 실행됩니다. 서로 다른 두 chain이 같은 device를 사용하는 구간이 있으면 한 chain이 다른 chain의 완료를 기다릴 수 있습니다.
Completion Queue
SQE 완료를 알리기 위해 completion queue(CQ)에 CQE(completion queue event)를 넣습니다. 일반적으로 완료된 SQE 하나가 CQE 하나를 만들지만 CQE 순서는 SQE 제출 순서와 다를 수 있습니다. 다만 SQE chain은 내부 ordering과 failure cascading을 보장합니다.
다른 완료 전달 방식도 가능하지만 completion queue는 io_uring을 비롯한 OS API에서 이미 검증된 모델입니다.
Executor
RTIO executor는 overhead가 낮은 concurrent I/O task scheduler입니다. Submission 목록을 순서대로 살피며 flag가 요구하는 동작을 보장합니다. In-order chain, 전체를 하나로 보는 transactional set, 계속 결과를 만드는 multishot request를 표현할 수 있습니다.
IO Device
SQE를 CQE로 바꾸는 주체가 iodev(IO device) API 구현입니다. Executor가 iodev의 submit method로 request를 넘기면 iodev는 내부 queue를 처리해 completion을 생성합니다.
각 iodev는 끝없이 들어오는 I/O request를 받는 독립적인 event-driven actor처럼 볼 수 있습니다. 구현자는 interrupt state machine을 쓸 수도 있고, queue 전체를 DMA transfer descriptor로 바꾸어 실제 작업 대부분을 hardware에 맡길 수도 있습니다.
Cancellation
이미 queue에 들어간 operation의 cancel은 시도할 수 있지만 성공이 보장되지는 않습니다. SQE가 아직 시작하지 않았다면 rtio_sqe_cancel()이 제거할 가능성이 높지만, 실행을 시작한 뒤에는 cancel request가 무시됩니다. 따라서 cancel을 hardware abort와 같은 의미로 사용하면 안 됩니다.
Memory pools
Read 결과 크기를 미리 모르거나 여러 iodev의 data 도착 주기가 불규칙하면, in-flight read마다 buffer를 미리 묶어 두는 것은 낭비입니다. RTIO mempool을 사용하면 iodev가 해당 RTIO context의 pool에서 실제 수신 시점에 memory를 할당합니다.
RTIO_DEFINE_WITH_MEMPOOL은 전용 memory-block pool이 있는 context를 만듭니다. 아래 예는 SQ와 CQ 각 4개, 16-byte block 128개, 4-byte alignment를 사용합니다.
#include <zephyr/rtio/rtio.h>
#define SQ_SIZE 4
#define CQ_SIZE 4
#define MEM_BLK_COUNT 128
#define MEM_BLK_SIZE 16
#define MEM_BLK_ALIGN 4
RTIO_DEFINE_WITH_MEMPOOL(rtio_context,
SQ_SIZE, CQ_SIZE, MEM_BLK_COUNT, MEM_BLK_SIZE, MEM_BLK_ALIGN);
Caller는 buffer pointer와 length를 받는 rtio_sqe_prep_read() 대신 rtio_sqe_prep_read_with_pool()을 사용합니다. Iodev는 미리 배정된 buffer와 mempool request를 모두 처리하도록 rtio_sqe_rx_buf() 계열로 buffer와 count를 얻습니다. 다음은 공식 원문의 code를 그대로 보존한 것입니다.
uint8_t *buf;
uint32_t buf_len;
int rc = rtio_sqe_rx_buff(iodev_sqe, MIN_BUF_LEN, DESIRED_BUF_LEN, &buf, &buf_len);
if (rc != 0) {
LOG_ERR("Failed to get buffer of at least %u bytes", MIN_BUF_LEN);
return;
}
Consumer는 CQE에서 rtio_cqe_get_mempool_buffer()로 실제 buffer를 얻습니다. CQE release와 buffer release는 별개입니다. 먼저 CQE를 반환해도 data buffer는 유지되며, 사용을 마친 뒤 반드시 rtio_release_buffer()로 pool에 돌려줘야 합니다.
uint8_t *buf;
uint32_t buf_len;
int rc = rtio_cqe_get_mempool_buffer(&rtio_context, &cqe, &buf, &buf_len);
if (rc != 0) {
LOG_ERR("Failed to get mempool buffer");
return rc;
}
/* Release the cqe events (note that the buffer is not released yet */
rtio_cqe_release_all(&rtio_context);
/* Do something with the memory */
/* Release the mempool buffer */
rtio_release_buffer(&rtio_context, buf);
When to Use
RTIO는 concurrent 또는 batch I/O flow에 적합합니다. Driver는 같은 SPI peripheral의 여러 request를 hardware command queue나 DMA descriptor로 한꺼번에 바꾸어 최적화할 수 있습니다.
각 RTIO context와 iodev에는 작은 memory cost가 있지만 operation마다 thread를 만들거나 peripheral마다 custom queue와 worker thread를 두는 것보다 훨씬 낮습니다. 단순한 단발성 synchronous I/O라면 기존 API가 더 간단할 수 있으므로 batching·concurrency·DMA offload 이득과 context 비용을 함께 판단해야 합니다.
API Reference
다음 84개 항목은 공식 RTIO doxygen group의 operation, definition macro, queue·pool helper, executor·iodev helper와 public structure를 빠짐없이 옮긴 것입니다.
RTIO_IODEV_I2C_STOP- I2C message의
I2C_MSG_STOP과 같은 stop 조건 flag입니다. RTIO_IODEV_I2C_RESTART- I2C message의
I2C_MSG_RESTART와 같은 repeated-start flag입니다. RTIO_IODEV_I2C_10_BITS- I2C message의
I2C_MSG_ADDR_10_BITS와 같은 10-bit address flag입니다. RTIO_OP_NOP- 아무 일도 하지 않고 즉시 완료되는 operation입니다.
RTIO_OP_RX- Data를 receive, 즉 read하는 operation입니다.
RTIO_OP_TX- Data를 transmit, 즉 write하는 operation입니다.
RTIO_OP_TINY_TX- 작은 write data를 SQE 내부로 복사해 전송하는 operation입니다.
RTIO_OP_CALLBACK- 지정한 callback function을 호출하는 operation입니다.
RTIO_OP_TXRX- Read와 write를 동시에 수행하는 transceive operation입니다.
RTIO_OP_I2C_RECOVER- I2C bus recovery를 요청하는 operation입니다.
RTIO_OP_I2C_CONFIGURE- I2C bus configuration을 요청하는 operation입니다.
RTIO_IODEV_DEFINE- RTIO iodev를 정적으로 정의하고 초기화합니다.
RTIO_BMEM- 구성에서 허용하면 객체를 BSS, 즉 zero-initialized memory에 배치합니다.
RTIO_DMEM- 구성에서 허용하면 객체를 initialized data memory에 배치합니다.
RTIO_DEFINE- 지정한 SQ·CQ 크기의 RTIO context를 정적으로 정의하고 초기화합니다.
RTIO_DEFINE_WITH_MEMPOOL- SQ·CQ와 전용 memory-block pool을 가진 RTIO context를 정적으로 정의합니다.
rtio_callback_tRTIO_OP_CALLBACKoperation이 호출하는 callback signature입니다.rtio_mempool_block_size- RTIO context에 연결된 memory pool의 block 크기를 반환합니다.
rtio_sqe_prep_nop- 즉시 완료되는 no-op SQE를 준비합니다.
rtio_sqe_prep_read- Caller가 제공한 buffer로 read operation SQE를 준비합니다.
rtio_sqe_prep_read_with_pool- Context mempool에서 receive buffer를 얻는 read SQE를 준비합니다.
rtio_sqe_prep_read_multishot- 한 SQE에서 여러 completion을 생성할 수 있는 multishot read를 준비합니다.
rtio_sqe_prep_write- 제공된 buffer의 data를 전송하는 write SQE를 준비합니다.
rtio_sqe_prep_tiny_write- 작은 payload를 SQE에 직접 복사하는 tiny-write SQE를 준비합니다.
rtio_sqe_prep_callback- RTIO 실행 흐름 안에서 function을 호출하는 callback SQE를 준비합니다.
rtio_sqe_prep_transceive- 송신과 수신을 동시에 수행하는 transceive SQE를 준비합니다.
rtio_sqe_pool_alloc- RTIO context의 pool에서 iodev SQE object를 할당합니다.
rtio_sqe_pool_free- Pool에 iodev SQE object를 반환합니다.
rtio_cqe_pool_alloc- RTIO context의 pool에서 CQE object를 할당합니다.
rtio_cqe_pool_free- Pool에 CQE object를 반환합니다.
rtio_block_pool_alloc- RTIO memory-block pool에서 필요한 크기의 buffer block을 할당합니다.
rtio_block_pool_free- 할당한 memory block을 RTIO pool에 반환합니다.
rtio_sqe_acquirable- 현재 acquire할 수 있는 submission queue entry 수를 반환합니다.
rtio_txn_next- 같은 transaction에 속한 다음 SQE를 얻습니다.
rtio_chain_next- 같은 chain에 속한 다음 SQE를 얻습니다.
rtio_iodev_sqe_next- Iodev 관점에서 현재 chain 또는 transaction의 다음 SQE를 얻습니다.
rtio_sqe_acquire- 비어 있는 submission queue entry 하나를 acquire하며 없으면 null을 반환합니다.
rtio_sqe_drop_all- 아직 submit하지 않은 acquired SQE를 모두 버립니다.
rtio_cqe_acquire- 생산 가능한 completion queue slot 하나를 acquire합니다.
rtio_cqe_produce- 작성한 completion queue event를 consumer가 볼 수 있도록 produce합니다.
rtio_cqe_consume- 완료된 CQE 하나를 non-blocking 방식으로 consume합니다.
rtio_cqe_consume_block- CQE가 생길 때까지 기다린 뒤 하나를 consume합니다.
rtio_cqe_release- Consume을 마친 completion queue event를 queue에 반환합니다.
rtio_cqe_compute_flagsrtio_iodev_sqe의 chain·transaction·multishot 상태에서 CQE flag를 계산합니다.rtio_cqe_get_mempool_buffer- Mempool read가 CQE와 함께 돌려준 allocated buffer와 길이를 얻습니다.
rtio_executor_submit- 새 submission이 들어왔음을 executor에 알립니다.
rtio_executor_ok- Submission이 성공했음을 executor에 알리고 다음 scheduling을 진행합니다.
rtio_executor_err- Submission이 실패했음을 executor에 알리고 chain·transaction error 규칙을 적용합니다.
rtio_iodev_sqe_ok- Iodev가 현재 submission을 성공 completion으로 마칩니다.
rtio_iodev_sqe_err- Iodev가 현재 submission을 error result로 마칩니다.
rtio_cqe_submit- Result와 userdata를 담은 CQE를 직접 submission합니다.
rtio_sqe_rx_buf- 일반 buffer 또는 mempool 중 SQE가 요구한 receive buffer와 길이를 iodev가 얻습니다.
rtio_release_buffer- RTIO memory pool에서 할당된 buffer를 반환합니다.
rtio_access_grant- User thread가 RTIO context를 사용할 수 있도록 kernel object access를 grant합니다.
rtio_sqe_cancel- 아직 시작하지 않은 SQE를 취소하려 시도합니다. 이미 실행 중이면 취소가 보장되지 않습니다.
rtio_sqe_copy_in_get_handles- SQE 배열을 queue에 복사하면서 각 entry의 resulting handle도 돌려받습니다.
rtio_sqe_copy_in- SQE 배열을 submission queue에 복사합니다.
rtio_cqe_copy_out- 완료된 CQE 배열을 caller buffer로 복사하고 queue에서 꺼냅니다.
rtio_submit- 준비된 I/O request를 underlying executor에 submit하고 필요한 completion 수를 기다릴 수 있습니다.
rtio_partition- 모든 RTIO context 정보가 사용하는 memory partition입니다.
rtio_sqe- Operation code, priority, flags, iodev, buffer와 userdata를 담는 submission queue entry입니다.
rtio_sqe.op- 실행할 RTIO operation code입니다.
rtio_sqe.prio- Operation priority입니다.
rtio_sqe.flags- Chain·transaction·multishot 등 operation 동작을 제어하는 flag입니다.
rtio_sqe.iodev_flags- Iodev 구현이 해석하는 device-specific flag입니다.
rtio_sqe.iodev- Operation을 수행할 RTIO IO device입니다.
rtio_sqe.userdata- 완료 때 CQE로 그대로 돌려주는 caller data입니다.
rtio_sqe.buf_len- 일반 TX·RX buffer 길이입니다.
rtio_sqe.buf- 일반 TX·RX에 사용할 buffer pointer입니다.
rtio_sqe.tiny_buf_len- SQE 내부 tiny buffer에 복사한 data 길이입니다.
rtio_sqe.tiny_buf- Tiny write payload를 보관하는 inline buffer입니다.
rtio_sqe.arg0- Callback operation에 전달하는 마지막 argument입니다.
rtio_sqe.i2c_configRTIO_OP_I2C_CONFIGURE에 전달할 I2C configuration입니다.rtio_cqe- Operation result, userdata와 completion flags를 담는 completion queue event입니다.
rtio_cqe.result- Operation의 성공 값 또는 negative errno result입니다.
rtio_cqe.userdata- 원래 SQE에서 연결한 caller userdata입니다.
rtio_cqe.flags- Chain continuation, transaction 또는 multishot 상태를 나타내는 completion flag입니다.
rtio_sqe_pool- Iodev가 작업할 entry를 보관·할당하는 submission object pool입니다.
rtio_cqe_pool- Completion object를 보관·할당하는 pool입니다.
rtio- Submission ring, completion ring, executor와 optional mempool을 결합한 RTIO context입니다.
rtio_iodev_sqe- Iodev에 전달된 SQE와 executor bookkeeping을 결합한 in-flight request입니다.
rtio_iodev_api- RTIO IO device implementation이 제공해야 하는 API table입니다.
rtio_iodev_api.submit- Iodev가 request를 queue하거나 즉시 실행하도록 호출되는 submit method입니다.
rtio_iodev- 특정 peripheral·bus 또는 virtual endpoint에 RTIO request를 전달하는 IO device object입니다.
Source
출처
영어 원문에는 문단, 문서 지시문, 표, 코드, 코드 심벌, 경로를 그대로 보존했습니다.