TIOVX 学习笔记其二：TIVOX

Reference:

1. Hardware Accelerated Structure From Motion on TDA4VM
2. TIOVX （TI OpenVX）简介及例程

CPU（Central Processing Unit，中央处理器）发展出来三个分枝，一个是DSP（Digital Signal Processing/Processor，数字信号处理），另外两个是MCU（Micro Control Unit，微控制器单元）和 MPU（Micro Processor Unit，微处理器单元）。

MCU 集成了片上外围器件；MPU 不带外围器件（例如存储器阵列），是高度集成的通用结构的处理器，是去除了集成外设的 MCU；DSP运算能力强，擅长很多的重复数据运算，而 MCU 则适合不同信息源的多种数据的处理诊断和运算，侧重于控制，速度并不如 DSP。MCU区别于 DSP 的最大特点在于它的通用性，反应在指令集和寻址模式中。

1. TIOVX(TI’s OpenVX)

TIOVX 是 TI 对 OpenVX 标准的实现。

TIOVX 允许用户使用 OpenVX API 创建视觉和计算应用程序。TIOVX 完全符合 OpenVX v1.1 规范，这些 OpenVX 应用完全可以在如 TDA2x、TDA3x 等 TI SoC 上执行。TIOVX 还为 C66x DSP(C66x 可以看成是一种 DSP 架构？TDA4上搭载了一个C7x和两个C66x)提供了优化的 OpenVX 内核。扩展 API 允许用户集成自己本地开发的自定义内核，并使用 OpenVX API 调用它们。

TIOVX 的顶层框图如下所示：

其中：

• OpenVX API：由 Khronos 定义的 OpenVX API；
• TIOVX API：为了在 TI 平台上有效地使用 OpenVX，TI 扩展和额外的 API；
• Target kernel：TI 特定的接口，用于在 target CPU(如DSP-Digital signal processors) 上集成 user kernel; The OpenVX specification describes how users can plugin their own kernels (which are only executed on the host core) into OpenVX.
• User kernel：使用标准的 Khronos OpenVX API 在 host CPU 上集成 user kernel 的接口; Since the OpenVX specification only supports host-side user kernels, TI has created its own vendor extension which adds support for users to add kernels on other targets in the system.
  这里的 target 和 host CPU 与交叉编译中的意思不太相同---- target CPU 将处理后的数据传递给 host CPU， 如一些硬件加速模块 VPAC 等；而 host CPU 可以看做是通用 CPU 模块，做最终集成，如 A72。（可以看成是 master 和 slave 的区别）
  HOST：User Thread on HOST CPU, calls OpenVX APIs；
  Taeget：TI OpenVX “Target” executes vision kernels. Target can run on same CPU as HOST. Multiple Targets on a CPU possible. Target execute in parallel to each other；

TIVOX Framework 为 TI 对 OpenVX 规范的实现，包含了官方和 TI 扩展框架，其中：

• OpenVX: Context, Parameter, Kernel, Node, Graph Array, Image, Scalar, Pyramid, ObjectArray;
• TI: Target, Target Kernel, Obj Desc。

TIOVX Kernel Wrapper 提供了由硬件模块 VPAC视觉处理加速器(Vision Pre-processing Accelerator)（其中的LDC模块常用于做remap）和 DMPAC深度和运动处理加速器(Depth and Motion Perception Accelerator)封装成的 Kernel，用户也可用 Wrapper 将自定义的算法(如 OpenCV 算法, DSP 算法)封装成 Kernel。
(VPAC contains modules to accelerate different image pre-processingsub tasks such as tone mapping, noise filtering, lens distortion correction, and so forth. VPAC 包括加速不同的图像预处理子任务，如色调映射，噪声滤波，镜头失真校正等)
(DMPAC contains two modules, a Stereo Disparity Engine, or SDE, to accelerate stereo depth estimation, and a Dense Optical Flow Engine, or DOF engine, to accelerate DOF. DMPAC 包含两个模块，一个是双目视差引擎，用于加速双目深度估计，另一个是密集光流引擎，用于加速 DOF。)

2. 步骤示例：Mono-camera Analytics Processing Graph

上图重点在于不同的 node，可以在不同的 target 上运作。

该示例的分布式图执行见下图：

分布式图形执行最小化了主机 ARM CPU 的开销，并减少了系统延迟。

2.1 代码实现步骤

Load and Save VX images—>Image manipulation using VXU APIs—>Image manipulation using graph and VX node APIs —>Graph with multiple targets, DSP1 and DSP2—>Graph generated with PyTIOVX tool —>Graph with user kernels on ARM—>Graph with target kernels on DSP

3 Node 和 Graph 参数定义

• Graph 参数：在 pipelining 模式下识别用户可排队在一个 graph 中的参数。通过创建一个图参数并显式地从 graph 中进入和离开该参数，应用程序就能够访问对象数据。否则，当使用流水线时，非 graph 参数在 graph 执行期间是不可访问的。
• Node 参数：在 TIOVX 实现中，应用使用 node 参数来标识在流水线的情况下需要在何处创建多个缓冲区。

4 流水线¹

• tivxSetNodeParameterNumBufByIndex: 在开发流水线应用时，必须在流水线之间创建多个缓冲区²，以避免流水线中的任何停顿。根据 graph 中节点的延迟情况，需要针对特定的应用调整缓冲区的数量。这个 API 允许 graph 开发人员指定 框架在给定节点参数处内部使用的缓冲区数量。提供给这个 API 的节点参数必须是输出类型。此外，提供给该 API 的节点参数必须不能作为 graph 参数创建。要创建如下图所示的场景，使用 tivxSetNodeParameterNumBufByIndex 将 Node1 输出的缓冲区数设置为N。
  
• tivxSetGraphPipelineDepth: 这个 API 允许应用程序开发人员显式地设置给定 graph 的管道深度。默认情况下，该值设置为 1。然而，为了获得充分的硬件利用率，需要根据 graph 配置设置管道深度值。考虑下图中所示的基本图表。这张图在 SoC 上使用了 3 个核心:一个 ISP, DSP 和 CPU。
  
  如果没有流水线，一个新的 graph 执行将不能开始，直到最初的 graph 执行完成。然而，因为这里面的每个内核都可以并发运行，这个 graph 的执行并没有考虑到最佳的硬件利用率。TIOVX 流水线实现考虑到基于管道深度在内部创建多个 graph 实例来充分利用硬件。因此，这些 graph 中的每一个都将同时执行，这样每个核心都在积极地处理。tivxSetGraphPipelineDepth 允许应用开发人员告诉框架要创建多少个这个 graph 的内部 instance。（注意：即使一个节点实现可以在多个核上运行，graph 的内部 instance 也被限制为跨所有 instance 的同一个核。）此值的最佳值必须基于给定的 graph 配置进行调整。下面的图片显示了这种情况的图解说明、如果上面显示的基本 graph 被设置为 3，框架将把图形当作有 3 个 instance 同时处理相同的 graph。下图显示了 T=2 时的图形处理，每个处理单元都是活动的。
  
  除了设置流水线深度之外，上面所示的基本 graph 还可以使用 tivxSetNodeParameterNumBufByIndex API 在节点的输出处设置多个缓冲区。下图显示了当每个输出的 tivxSetNodeParameterNumBufByIndex 设置为 4 时，框架如何处理基本图形。如图所示，节点将写入缓冲区队列中的缓冲区，而下游节点正在处理缓冲区队列中的前一个缓冲区。
  当使用 TIOVX 设计流水线 graph 时，在实现 tivxSetGraphPipelineDepth 和 tivxSetNodeParameterNumBufByIndex API 时需要进行权衡。虽然性能会随着这些 API 设置的值的增加而增加，但使用的内存也会增加。对于 tivxSetGraphPipelineDepth API，如果管道深度值设置得太高，可能会创建不必要的内部创建的图结构。类似地，如果 tivxSetNodeParameterNumBufByIndex API 创建的缓冲区多于所需的，那么框架内用于额外缓冲区的内存也将是不必要的。TI 对应用程序开发的建议是，首先在初始开发时使用较大的管道深度和缓冲区数量，然后减少这些值，直到观察到性能下降。

5 Key API

5.1 vxCreateContext

vx_context VX_API_CALL vxCreateContext()

这必须首先在任何 OpenVX API 调用之前完成，返回的上下文被用作后续 OpenVX API 的输入。

vx_context context;
context = vxCreateContext();

5.2 vxReleaseContext

vx_status VX_API_CALL vxReleaseContext ( vx_context * context )

当使用完了 OpenVX 上下文时，释放掉它。在使用 vxCreateContext() 再次创建上下文之前，不应该再调用 OpenVX API。

vxReleaseContext(&context);

5.3 vxGetStatus

vx_status VX_API_CALL vxGetStatus ( vx_reference reference )

提供一个通用API，在对象构造函数失败时返回状态值。
如，检查 kernel 是否被成功加入到 OpenVX 上下文中：

vx_status status;
status = vxGetStatus((vx_reference)kernel);

5.4 vxAllocateUserKernelId

vx_status VX_API_CALL vxAllocateUserKernelId ( vx_context context,
                                                                                  vx_enum * pKernelEnumId )

分配并注册用户定义的 kernel 枚举到上下文。
如，动态分配一个 kernel ID 并将其存储在 ‘phase rgb user kernel ID’ 中：

// Kernel ID of the registered user kernel. Used to create a node for the kernel function.
static vx_enum phase_rgb_user_kernel_id = (vx_status)VX_ERROR_INVALID_PARAMETERS;//
status = vxAllocateUserKernelId(context, &phase_rgb_user_kernel_id);

5.5 vxAddUserKernel

vx_kernel VX_API_CALL vxAddUserKernel ( vx_context context, // 上下文的引用
                                                                        const vx_char name[VX_MAX_KERNEL_NAME],
// kernel对应的字符串名
                                                                        vx_enum enumeration,
// 客户端要使用的kernel的枚举值
                                                                        vx_kernel_f func_ptr,
// 要调用的进程局部函数指针&&对于user kernel，该函数必须为non-NULL，对于target kernel，该函数必须为NULL
                                                                        vx_uint32 numParams,
// 这个kernel的参数个数
                                                                        vx_kernel_validate_f validate,
// 指向 vx_kernel_validate_f，它验证这个内核的参数&&对于OpenVX user kernel和TIOVX target kernel，这个函数的实现是相同的
                                                                        vx_kernel_initialize_f init,
// kernel 的初始化函数&&这个函数通常只在user kernel中实现，在target kernel中为NULL
                                                                        vx_kernel_deinitialize_f deinit
// kernel的de-init函数----这个函数在vxReleaseGraph期间被调用
) // Returns: vx_kernel 应该使用 vxGetStatus 检查任何可能阻止成功创建的错误…
(返回值为‘0’表明在添加kernel时有错误发生了||为‘*’表明kernel被成功添加到OpenVX)

将 kernel 注册到 OpenVX 上下文。
一个 kernel 可以用它的 kernel ID(vxAllocateUserKernelId 分配的)来标识；一个 kernel 也可以用它唯一的 kernel 名称字符串来标识。

kernel = vxAddUserKernel(
                    context,
                    TIVX_TUTORIAL_KERNEL_PHASE_RGB_NAME,
                    phase_rgb_user_kernel_id,
                    phase_rgb_user_kernel_run, // 这个函数在图形执行过程中被调用。在这里，实现了读取输入数据和写入输出数据的实际内核函数。
                    2, /* number of parameters objects for this user function */
                    phase_rgb_user_kernel_validate, // kernel validate function. Called during graph verify.
                    phase_rgb_user_kernel_init, // kernel init function. Called after  phase_rgb_user_kernel_validate() during graph verify
                    phase_rgb_user_kernel_deinit); // kernel deinit function. Called during graph release.

5.6 vx_kernel_validate_f

typedef vx_status( * vx_kernel_validate_f)(vx_node node, const vx_reference parameters[], vx_uint32 num, vx_meta_format metas[])
// metas: 指向预先分配的系统保存的结构引用数组的指针。系统预先分配了一些 vx_meta_format 结构，仅用于输出参数，使用与 parameters[] 相同的索引索引。validation 函数为系统填写正确的类型、格式和维度，以用于创建内存或针对现有内存进行检查。

用户定义的 kernel node 参数验证函数。该函数只需要填充元数据结构。

5.7 vxAddParameterToKernel

vx_status VX_API_CALL vxAddParameterToKernel ( vx_kernel kernel,
                                                                                     vx_uint32 index,
// 参数在函数参数列表中的索引
                                                                                     vx_enum dir,
// 参数的方向: VX_INPUT 或 VX_OUTPUT
                                                                                     vx_enum data_type,
// 参数数据对象类型
                                                                                     vx_enum state
// 参数状态: VX_PARAMETER_STATE_REQUIRED 或 VX_PARAMETER_STATE_OPTIONAL)

为 kernel 定义参数。

index = 0;
if ( status == (vx_status)VX_SUCCESS){
    status = vxAddParameterToKernel(kernel,
        index,
        (vx_enum)VX_INPUT,
        (vx_enum)VX_TYPE_IMAGE,
        (vx_enum)VX_PARAMETER_STATE_REQUIRED
        );
    index++;
}
if ( status == (vx_status)VX_SUCCESS){
    status = vxAddParameterToKernel(kernel,
        index,
        (vx_enum)VX_OUTPUT,
        (vx_enum)VX_TYPE_IMAGE,
        (vx_enum)VX_PARAMETER_STATE_REQUIRED
        );
    index++;
}

5.8 vxFinalizeKernel

vx_status VX_API_CALL vxFinalizeKernel ( vx_kernel kernel )

将所有参数添加到 kernel 并准备好使用 kernel 之后，调用这个 API。注意，在调用 vxFinalizeKernel 之后，对 vxAddUserKernel 创建的 kernel 的引用仍然有效。(在 kernel 的所有参数定义好之后调用，即在 vxAddParameterToKernel 之后调用)

if (status == (vx_status)VX_SUCCESS){
    status = vxFinalizeKernel(kernel);
}

5.9 vxReleaseKernel

vx_status VX_API_CALL vxReleaseKernel ( vx_kernel * kernel )

释放对 kernel 的引用。除非对象的总引用计数为零，否则不会对该对象进行垃圾收集。

if( status != (vx_status)VX_SUCCESS){
    printf(" phase_rgb_user_kernel_add: ERROR: vxAddParameterToKernel, vxFinalizeKernel failed (%d)!!!\n", status);
    vxReleaseKernel(&kernel);
    kernel = NULL;
}

5.10 vxRemoveKernel

vx_status VX_API_CALL vxRemoveKernel ( vx_kernel kernel )

从上下文中删除一个自定义 kernel 并释放它。

static vx_kernel phase_rgb_user_kernel = NULL; // 首先在程序开头，要注册user kernel的句柄
phase_rgb_user_kernel = kernel; // 设置kernel句柄为全局user kernel句柄, 这个全局句柄在以后使用时用来释放kernel

status = vxRemoveKernel(phase_rgb_user_kernel); // 从上下文中删除kernel
phase_rgb_user_kernel = NULL; // 将全局phase_rgb_user_kernel设置为NULL

5.11 tivxCreateNodeByKernelEnum

vx_node tivxCreateNodeByKernelEnum ( vx_graph graph,
                                                                   vx_enum kernelenum,
                                                                   vx_reference params[], // 与枚举的kernel相对应的参数引用列表
                                                                   vx_uint32 num // 参数列表中参数引用的数量)

如 5.5 中标识符所说，还有其他两种方式来使用相同 node 来创建 kernel：tivxCreateNodeByKernelRef 和 tivxCreateNodeByKernelName，用法相似。

vx_node node;
vx_reference refs[] = {(vx_reference)in, (vx_reference)out}; // 将参数放入引用数组中
node = tivxCreateNodeByKernelEnum(graph, // TIOVX API用graph、kernel ID和参数引用数组作为输入来创建节点
            phase_rgb_user_kernel_id,
            refs, sizeof(refs)/sizeof(refs[0])
            );

5.12 vxSetReferenceName

vx_status VX_API_CALL vxSetReferenceName ( vx_reference ref, const vx_char * name )

此函数用于将名称与被引用的对象关联。OpenVX 实现可以在日志消息和任何其他报告机制中(如 vxQueryReference)使用这个名称。OpenVX 实现不会检查名称在引用范围(上下文或 graph)中是否唯一。多个引用可以具有相同的名称。

vxSetReferenceName((vx_reference)node, "PHASE_RGB");
vxSetReferenceName((vx_reference)in_image, "INPUT");

5.13 vxQueryImage

vx_status VX_API_CALL vxQueryImage ( vx_image image, vx_enum attribute, void * ptr, vx_size size )
// attribute: 要查询的属性，使用了 vx_image_attribute_e

下面为所有可以查询的属性——查询图像的宽度、高度、格式、平面、大小、空间、范围、范围和内存类型：

vxQueryImage(image, (vx_enum)VX_IMAGE_WIDTH, &width, sizeof(vx_uint32));
vxQueryImage(image, (vx_enum)VX_IMAGE_HEIGHT, &height, sizeof(vx_uint32));
vxQueryImage(image, (vx_enum)VX_IMAGE_FORMAT, &df, sizeof(vx_df_image));
vxQueryImage(image, (vx_enum)VX_IMAGE_PLANES, &num_planes, sizeof(vx_size));
vxQueryImage(image, (vx_enum)VX_IMAGE_SIZE, &size, sizeof(vx_size));
vxQueryImage(image, (vx_enum)VX_IMAGE_SPACE, &color_space, sizeof(vx_enum));
vxQueryImage(image, (vx_enum)VX_IMAGE_RANGE, &channel_range, sizeof(vx_enum));
vxQueryImage(image, (vx_enum)VX_IMAGE_MEMORY_TYPE, &memory_type, sizeof(vx_enum));

5.14 vxQueryReference

vx_status VX_API_CALL vxQueryReference ( vx_reference ref, vx_enum attribute, void * ptr, vx_size size )
// attribute: 要查询的属性，使用了 vx_reference_attribute_e

5.12中 vxSetReferenceName 设置的名字，通过下面方式可以获取：

// vx_reference_attribute_e:VX_REF_ATTRIBUTE_COUNT, VX_REF_ATTRIBUTE_TYPE, VX_REF_ATTRIBUTE_NAME
vxQueryReference((vx_reference)image, (vx_enum)VX_REFERENCE_NAME, &ref_name, sizeof(vx_char*));
vxQueryReference((vx_reference)image, (vx_enum)VX_REFERENCE_COUNT, &ref_count, sizeof(vx_uint32)); // 返回对象的引用计数

5.15 tivxMemShared2TargetPtr

void* tivxMemShared2TargetPtr ( const tivx_shared_mem_ptr_t * shared_ptr )

将 shared 指针转换成 target 指针

/* Get the Src and Dst descriptors */
src_desc = (tivx_obj_desc_image_t *)obj_desc[PHASE_RGB_IN0_IMG_IDX];
dst_desc = (tivx_obj_desc_image_t *)obj_desc[PHASE_RGB_OUT0_IMG_IDX];

/* Get the target pointer from the shared pointer for all buffers */
src_desc_target_ptr = tivxMemShared2TargetPtr(&src_desc->mem_ptr[0]);
dst_desc_target_ptr = tivxMemShared2TargetPtr(&dst_desc->mem_ptr[0]);

/* Map all buffers, which invalidates the cache */
tivxMemBufferMap(src_desc_target_ptr,
    src_desc->mem_size[0], (vx_enum)VX_MEMORY_TYPE_HOST,
    (vx_enum)VX_READ_ONLY);
tivxMemBufferMap(dst_desc_target_ptr,
    dst_desc->mem_size[0], (vx_enum)VX_MEMORY_TYPE_HOST,
    (vx_enum)VX_WRITE_ONLY);

5.16 tivxMemBufferMap

vx_status tivxMemBufferMap ( void * host_ptr, // 要映射的缓冲区内存
                                                 uint32_t size, // 以字节为单位映射的内存大小
                                                 vx_enum mem_type, // 该指针所属的内存类型
                                                 vx_enum maptype // 映射类型: VX_READ_ONLY, VX_WRITE_ONLY, VX_READ_AND_WRITE)

映射已分配的缓冲区地址，这会使缓存失效。示例见 5.15。

5.17 vxCreateTensor

vx_tensor VX_API_CALL vxCreateTensor ( vx_context context,
                                                                      vx_size number_of_dims, // 维度的数量，一般用的二维，即值为2
                                                                      const vx_size * dims,
                                                                      vx_enum data_type, // 数据类型
                                                                      vx_int8 fixed_point_position // 当输入元素类型为整数时，指定定点位置。如果为0，则执行整数数学计算。)

创建一个对 tensor 数据缓冲的不透明引用。

vx_size = {OUTPUT_SIZE, MAX_NUM_OF_OBJECTS};
vx_tensor cout_tensor = vxCreateTensor(context, 2, size, VX_TYPE_FLOAT32, 0);

5.18 vxVerifyGraph

vx_status VX_API_CALL vxVerifyGraph ( vx_graph graph )

在执行 graph 之前验证其状态。这对于捕获程序错误非常有用。如果未验证，则 graph 在处理之前进行验证。

5.19 vxScheduleGraph

vx_status VX_API_CALL vxScheduleGraph ( vx_graph graph )

为将来的执行安排一个 graph。如果 graph 还没有被验证，那么将立即执行对 graph 的验证（意思就是会自动做 5.18 vxVerifyGraph 的操作咯）。如果验证失败，这个函数将返回一个与 vxVerifyGraph 返回的状态相同的状态。在 graph 验证成功后，处理将会接着发生。如果 graph 之前通过 vxVerifyGraph 或 vxProcessGraph 验证，则该 graph 将被处理。

5.20 vxWaitGraph

vx_status VX_API_CALL vxWaitGraph ( vx_graph graph )

等待指定的 graph 完成。如果自最后一次调用 vxWaitGraph 以来，graph 已经被调度多次，则 vxWaitGraph 只在最后一次调度执行完成时返回。

status = vxVerifyGraph(graph); //5.18

if(status==(vx_status)VX_SUCCESS)
{
	vxScheduleGraph(graph); //5.19
	vxWaitGraph(graph); //5.20
}

5.21 tivxMapTensorPatch

VX_API_ENTRY vx_status VX_API_CALL tivxMapTensorPatch ( vx_tensor tensor,
                                                                                                        vx_size number_of_dims, //tensor的维数
                                                                                                        const vx_size * view_start, //每个维度中的patch起始点的数组。这是可选参数，当为NULL时为零。
                                                                                                        const vx_size * view_end,
                                                                                                        vx_map_id * map_id, //vx映射id变量的地址，该函数返回一个映射标识符。tivxUnmapTensorPatch时有用
                                                                                                        vx_size * stride, //以字节为单位的所有维度的stride数组。索引0处的stride值必须是张量数据元素类型的大小。
                                                                                                        void ** ptr, //指针的地址，函数将其设置为可以访问所请求数据的地址。返回的(*ptr)地址只在函数调用和对应的tivxUnmapTensorPatch调用之间有效。
                                                                                                        vx_enum usage, //VX_READ_ONLY,VX_READ_AND_WRITE,VX_WRITE_ONLY
                                                                                                        vx_enum mem_type //VX_MEMORY_TYPE_NONE,VX_MEMORY_TYPE_HOST
)

允许应用获得一个 patch of tensor object 的直接访问。

5.22 tivxCheckStatus

static void tivxCheckStatus ( vx_status * status, // 状态变量，注意是地址
                                               vx_status status_temp // 暂时的状态变量
)

如果 status_temp 不为 VX_SUCCESS，将状态值赋给 status。

\newline
\newline

点击跳转：
TIOVX 学习笔记其一：OpenVX.
TIOVX 学习笔记其三：concerto makefile.
TIOVX 学习笔记其四：Objects.

---

1. 流水线
   Non-pipelined Execution：
   Frame-Level Pipelined Execution：
   ↩︎

2. 为什么要引入缓冲区？
   高速设备与低速设备的不匹配，势必会让高速设备花时间等待低速设备，我们可以在这两者之间设立一个缓冲区。
   
   缓冲区的作用：
   * 可以解除两者的制约关系：数据可以直接送往缓冲区，高速设备不用再等待低速设备，提高了计算机的效率。（例如：我们使用打印机打印文档，由于打印机的打印速度相对较慢，我们先把文档输出到打印机相应的缓冲区，打印机再自行逐步打印，这时我们的CPU可以处理别的事情）
   * 可以减少数据的读写次数，如果每次数据只传输一点数据，就需要传送很多次，这样会浪费很多时间，因为开始读写与终止读写需要花上较多时间，如果将数据送往缓冲区，待缓冲区满后再进行传送会大大减少读写次数，这样就可以节省很多时间。（例如：我们想将数据写入到磁盘中，不是立马将数据写到磁盘中，而是先输入缓冲区中，当缓冲区满了以后，再将数据写入到磁盘中，这样就可以减少磁盘的读写次数，不然磁盘很容易坏掉。）
   
   简单来说，缓冲区就是一块内存区，它用在输入输出设备和 CPU 之间，用来存储数据。它使得低速的输入输出设备和高速的 CPU 能够协调工作，避免低速的输入输出设备占用 CPU，解放出 CPU，使其能够高效率工作。 ↩︎