KR20000065846A - Method for zero-copy between kernel and user in operating system - Google Patents

Abstract

PURPOSE: A zero copy method in an OS(Operating System) is provided to share and transmit a data block without copying the data block when the data block is transmitted between the kernel and the user so that it can reduce a transmission overhead or a wasteful memory spending. CONSTITUTION: A zero copy method in an OS comprises a shared buffer allocation process and a shared buffer release process. The shared buffer allocation process includes steps of initializing a memory pool of a user area(30), allocating a zero copy area(31), generating a shared buffer on a kernel by a memory remapping(40), and acquiring the shared buffer(41). The shared buffer release process includes steps of executing a shared buffer return logic(42), executing a logic for eliminating the shred buffer on the kernel by mapping out the address of the shred buffer(43), releasing the shared buffer allocation(34) and releasing the initialization of the shared buffer(35).

Description

Method for zero-copy between kernel and user in operating system}

The present invention relates to a zero-copy method between a kernel and a user in an operating system (O / S). In particular, in a Solaris operating system, data is shared by each other without copying when data blocks are transferred between the kernel and a user. A zero-copy method between the kernel and the user in an operating system suitable for transferring blocks.

Kernel is a part of the function of the operating system that is responsible for resource allocation for the processes constituting the operating system and the programs running under the control of the operating system. Originally, it refers to the part where the main memory resides in the control program. In UNIX, the core part of the UNIX system configuration is the so-called operating system.

The kernel is located between the hardware and the user program, and provides the user with hardware support such as CPU, memory, hard disk, file system service, and I / O service.

In general, data transfer between kernel and user in operating system environment is virtual memory remapping between kernel and user or copy method using shared memory region. Is using. Among them, virtual memory remapping has not been disclosed in detail.

Zero-Copy is a method that can be used in the kernel without copying the buffer in the user space. Several papers suggest that virtual memory mapping is the user-space kernel space in CMNS. Remapping The reason for this is that, first, RTP / RTCP recommends that it be implemented at the user level as an application specific protocol itself. Therefore, the CMFS used by Neovis reads a file and kernel. After copying to memory, CMNS cuts packet size by sending header of RTP and sends to client. Therefore, when RTP is implemented in user space, there is a problem of copying the RTP header to the kernel space every time. However, the implementation at the kernel level does not take advantage of the RTP characteristics, so it was necessary to implement it in the kernel so that the information can be read at any time in the user space.

The second reason is that the user needs to easily understand the kernel module information at any time and to facilitate the control. This is because the system call time is reduced by eliminating unnecessary system calls to implement more efficient control.

Hereinafter, a method of transmitting data between a kernel and a user in a conventional operating system will be described.

Although the prior art has implemented such a function by using virtual memory remapping or shared memory, specific algorithms and methods that can be used are not disclosed. Therefore, only the basic algorithm of such technology will be described.

First of all, a manager that manages and creates a memory for unification of terms is called an originator, and using this is called a client.

First, Allocate an Aggregate Object in the Originator allocates a free virtual address in the Originator, allocates and clears the corresponding physical memory. Next, update the physical page table.

The Send Aggregate Object in the Originator then creates a list of allocated memory and protects the list. Next, update the physical table for consistency of TLB / cache.

The Receive Aggregate Object in the Receiver then finds a free virtual address in the address range of the receiver. Then, the physical page table is updated. Then obtain the destination memory from the memory list.

Free an Aggregate Object releases the virtual address and updates the physical page table. Finally, release the unused physical pages.

In the conventional operating system, the data transfer method between the kernel and the user is a method in which the originator hands the memory pool and hands it to the user, which is inconvenient for the user, and in time, because the physical table must be updated every time. There was a lot of overhead.

Disclosure of Invention The object of the present invention is to solve the problems of the prior art as described above. In particular, in an operating system that is suitable for reducing the overhead between kernel area and user area and providing a user-friendly interface. To provide a zero-copy method between the kernel and the user.

1 is a block diagram illustrating a zero-copy algorithm between a kernel and a user in an operating system of the present invention.

FIG. 2 is a block diagram illustrating a shared buffer allocation and release process in the zero-copy algorithm of the present invention shown in FIG.

3 is a flow chart for explaining the present invention zero-copy algorithm

* Description of the symbols for the main parts of the drawings *

1: CMNS Manager Library Module 2: Library Shared Buffer

3: memory pool 4: kernel virtual address

5: CMNS mode (kernel module) 10: user area

20 Kernel Area 32 Shared Buffer Memory Pool

33: Shared buffer 50: Zero-copy memory original area

60: zero-copy memory remapping region

A zero-copy method between a kernel and a user in an operating system of the present invention comprises an operating system including a shared storage area, a user area including a user memory, and a kernel area including a kernel virtual address, wherein the sharing of the user area is performed. Initializing a storage area, allocating the user memory to the shared storage area, creating a virtual shared storage area in the kernel area, and sharing any data in the user area with the virtual share of the kernel area. Zero-copy to the storage area.

Preferably, the step of allocating the user memory to the shared memory area further includes requesting memory remapping of the kernel area after the step of allocating the user memory to the shared memory area.

Preferably, when using memory alignment in allocating user memory to the shared storage area, allocating the user memory to a page size, and assigning a plurality of control buffers to the user memory allocated to the page size. And the real time transfer protocol buffer (RtpBuffer) are used separately.

Advantageously, creating a virtual shared storage area in the kernel area consists of remapping the memory of the user area in the kernel area.

Preferably, allocating the user memory to a page size when zero-copying any data of the user area to the virtual shared storage area of the kernel area, and assigning a plurality of pages to one page allocated to the page size. Shared buffers and remap the memory by the number of page sizes.

Hereinafter, a method of transmitting data between a kernel and a user in an operating system of the present invention will be described with reference to the accompanying drawings.

1 is a block diagram illustrating a zero-copy algorithm between a kernel and a user in an operating system of the present invention.

First, the basic configuration for explaining the zero-copy algorithm between the kernel and the user in the operating system of the present invention is a CMNS manager library module that provides an application program interface (API) to arbitrary users, as shown in FIG. Manager liblary module (1), a library shared buffer (2) that receives and stores programs written by the users from the CMNS manager library module (1), and a memory pool (3), which is a page-based user memory. Kernel virtual address 4 and any system call that share the program of the memory pool 3 according to the user area 10 and the program map in / program map out. Kernel configured in CMNS mode (5) to receive the user's address in the library shared buffer (2) of the user area 10 using Consists of an area 20.

In this case, the memory pool 3 and the library shared buffer 2 use the memory in page size units when memory align / memory free.

Solaris uses the concept of virtual memory, which is logically handled in page units (8Kbytes).

To do this, the application grabs the memory of the memory pool 3 in page units (8 Kbytes) or less.

In such a way, in the CMNS mode 5 of the kernel region 20, a user address is transmitted to the CMNS mode 5 in the user region 10, and in the CMNS mode 5, the program mapin: , which is abbreviated as prmapin), and its usage is as follows.

In prmapin (as, (caddr_t) u_cbufpt, 1), as denotes the address space of the thread currently being executed, u_cbufpt is the address of the user area 10 to be mapped, and 1 Is a read / write option of the buffer. If 1, it indicates read / write, and if 0, only read. The returned value of this function is the kernel virtual address.

FIG. 2 is a block diagram illustrating a shared buffer allocation and release process in the zero-copy algorithm of the present invention shown in FIG.

The shared buffer allocation and release process in the zero-copy algorithm of the present invention will be described by using a shared buffer call mechanism.

The shared buffer library is a library that provides a buffer for sharing an area called the shared buffer 33 between the user area and the kernel area. The order of use is as follows.

As the shared buffer allocation process (30) (31), first, the shared buffer 33 initialization logic is executed (Sbuf_init ()) (30).

That is, it is called in CMNS_Inti as a routine that opens / dve / zero for a memory map, which will be described with reference to the first logic. This is not necessary if you use memory align.

[First logic]

Logic

Open ("/ dev / zero")

Subsequently, the logic for allocating the shared buffer 33 (Sbuf_alloc (Sbuf_t type, int number)) is executed (31).

That is, memory remapping is requested in the CMNS mode by allocating user memory.

In this case, when using memory alignment (hereinafter, referred to as memalign), a page size (8K in the case of Solaris) may be allocated. This is because the prmapin / out used in the kernel area is made up of pages. In this case, type is an argument for distinguishing between ControlBuf_t and RtpBuf_t. For reference, ControlBuf is the control buffer and RtpBuf is the real-time transport protocol buffer.

And, number is the total number, which is equal to the maximum session number. For efficiency of memory usage, multiple pages of ControlBuffer and RtpBuffer are used to divide the memory of page size. This will be described with reference to the second logic as follows.

[Second logic]

Input

sbuf_t_type, int number

Logic

check number

if control buffer then

memalign

calculate num = PAGESIZE / sizeof (ControBuf_t)

sbuf_create_in_kernel

if Rtp buffer then

memalign

calculate num = PAGESIZE / sizeof (RtpBuf_t)

sbuf_create_in_kernel

Then, the logic for obtaining (Sbuf_get) the allocated shared buffer 33 from the shared buffer memory pool 32 is executed (Sbuf_get (int sid, sbuf_t type)).

This is the process of bringing and initializing the allocated shared buffer 33 for use in the shared buffer memory pool 32. At this time, all the shared buffers 33 are allotted initially, and the shared buffers 33 are statically assigned to each sid. A description with reference to the third logic is as follows.

[Third logic]

Input

int_sid, sbuf_t type

Logic

check sid

if control buffer then initialize and return it

if rtp buffer then initialize and return it

Subsequently, logic for returning the used shared buffer 33 to the shared buffer memory pool 32 (Sbuf_return) is executed (Sbuf_return (int sid, sbuf_t_type)).

This will be described with reference to the fourth logic as follows.

[Fourth logic]

Input

int sid, sbuf_t type

Logic

check sid

if control buffer then deinitialize it

if rtp buffer then deinitialize it

Next, as the release process 34 (35) of the shared buffer 33 of the shared buffer memory pool 32, the release logic of the shared buffer 33 is executed (Sbuf_dealloc (sbuf_t type, int number) 34).

At this time, Sbuf_dealloc is a part that frees the memory caught by Sbuf_alloc, and releases memory remapping to the CMNS mode of the kernel region. This will be described with reference to the fifth logic as follows.

[Fifth Logic]

Input

sbuf_t type, int number

Logic

check number

free memory

Then, the shared buffer initialization is canceled (35).

That is, it closes / dev / zero, which is open for memory maps.

A description with reference to the sixth logic is as follows.

[Sixth Logic]

Logic

Close (Sbuf-fd);

The zero-copy algorithm using the process of allocating and freeing a shared buffer in the zero-copy algorithm of the present invention will be described.

3 is a flowchart illustrating the present invention zero-copy algorithm.

The zero-copy algorithm of the present invention uses the first to second logic as shown in FIG. 2, and the zero-copy process and the shared buffer initialization 30 process of initializing the memory pool 3 of the user area (see FIG. 1). After the process of allocating the shared buffer 31 for allocating the region, a shared buffer is created in the kernel region through memory remapping (Sbuf_create_in_kernel (int sid, sbuf_t type, void * slot)) (40).

That is, by remapping the memory of the zero-copy memory original area 50 in the CMNS mode 5 of the kernel area, a plurality of shared buffers are configured in one page PAGE. This remaps the memory to the zero-copy memory remapping region 60 by the number of PAGESIZE / sizeof (controBuf_t or RtpBuf_t). The command transmitted to the CMNS mode 5 is CMNS_MAPIN_CBUF or CMNS_MAPIN_RBUF. Here, the address and the number to be mapped are passed as parameters.

This is shown using the seventh logic as follows.

[Seventh Logic]

Input

int sid, sbuf_t type, void * slot

Pseudo Code

if control buffer then

build cmnsmsg for it and SetCommand

if rpt buffer then

build cmnsmsg for it and SetCommand

The shared buffer is then obtained (41).

The releasing of the shared buffer is performed by using the fifth and sixth logics as described above with reference to FIG.

In this case, before the process of releasing the shared buffer 34, the shared buffer return (Sbuf_return (int sid, sbuf_t type)) logic using the fourth logic as described with reference to FIG. 2 is performed (42).

Next, logic (Sbuf_delete_in_kernel (int sid, sbuf_t_type)) for deleting the shared buffer of the kernel area is performed (43). This is a process of mapping out the address to which the shared buffer is mapped and mapping out the address mapped to the CMNS mode 5 as described in the seventh logic.

This will be described with reference to the eighth logic.

[8th Logic]

Input

intsid, sbuf_t type

Pseudo Code

if control buffer then

build cmnsmsg for it and SetCommand

if rpt buffer then

build cmnsmsg for it and SetCommand

In the zero-copy method between the kernel and the user in the operating system according to the present invention, the physical table must be updated every time since the kernel uses virtual memory without copying a buffer in the user area during data block transmission. There is no problem, which can reduce a lot of overhead in terms of time, eliminate memory waste, and provide a user-friendly interface environment.

Claims (5)

An operating system comprising a shared storage area, a user area including user memory, and a kernel area including a kernel virtual address, Initializing the shared storage area of the user area; Allocating the user memory to the shared storage area; Creating a virtual shared storage area in the kernel area; Zero-copying any data of the user area to the virtual shared storage area of the kernel area. The method of claim 1, wherein the allocating of the user memory to the shared memory area further comprises requesting memory remapping of the kernel area after the user memory is allocated to the shared memory area. Zero-copy method between kernel and user in operating system. 2. The method of claim 1, wherein in the case of using memory alignment in allocating user memory to the shared storage area, allocating the user memory to a page size and a plurality of control buffers to allocate the user memory to the page size. (ControlBuffer) and the real-time transport protocol buffer (RtpBuffer) is a zero-copy method between the kernel and the user in the operating system characterized in that divided use. 2. The zero-copy method between a kernel and a user in an operating system according to claim 1, wherein creating a virtual shared storage area in the kernel area comprises remapping memory of the user area in the kernel area. . 2. The method of claim 1, further comprising: allocating the user memory to a page size when zero-copying any data of the user area to the virtual shared storage area of the kernel area; A zero-copy method between a kernel and a user in an operating system, comprising configuring a plurality of shared buffers in a page and remapping memory by the number of page sizes.