KR100248083B1 - Method for managing variable-length messages in circular queue - Google Patents

Abstract

1. TECHNICAL FIELD OF THE INVENTION

Variable length message handling in circular queue.

2. The technical problem to be solved by the invention

It is designed to maximize the efficiency of memory usage by effectively storing and reading variable length messages in a limited size memory.

3. Summary of Solution to Invention

The length information of the input message is obtained from the queue in which the memory area with the maximum message size is allocated after the logical queue size, the sequence number is assigned to the input message, and the inputted memory address is written to the memory address recorded in the tail value. The messages are stored in order, the new tail value is calculated using the message length information, the previous tail value is updated with the newly calculated tail value, and the sequence number of the next input message is increased by one. Read the message length information corresponding to the memory address of the head value, read the message stored in the memory address continuously as the message length, and calculate the new head value using the message length information of the read message. Update

4. Important uses of the invention

Used to control queues storing variable length messages.

Description

Variable length message handling in circular queue

The present invention relates to a variable length message processing method in a circular queue, and more particularly, to a variable length message processing method in a circular queue capable of maximizing memory efficiency by effectively storing and deleting a variable length message in a limited size memory. It is about.

Conventional general circular queues are abstract memory structures that store messages of fixed length. Currently, the message length is mostly variable, but in order to handle this, it is not suitable as a control method for processing a conventional fixed length message. In order to use the conventional method, there is a method of defining a maximum message length and assuming that it is a fixed length message. However, since there is a portion that is not used for each message, there is a problem that the efficiency of memory is lowered.

Accordingly, the present invention devised to solve the above problems of the prior art variable length message processing in a circular queue that can effectively store and delete a variable length message in a limited size memory to maximize memory usage efficiency The purpose is to provide a method.

1 is a view for schematically explaining the present invention.

2A and 2B are flowcharts of a variable length message processing method in a circular queue according to the present invention;

3 is a view for explaining a process of inserting one message;

4 is a view for explaining a process of deleting one message.

In order to achieve the above object, the present invention provides a variable length message processing method applied to a queue having a structure in which a memory area equal to the maximum message size is further allocated after a logical queue size. Acquiring a message and assigning a message sequence number to an input message; Reading a tail value and sequentially storing the input message at a memory address recorded in the tail value; Calculating a new tail value using message length information, updating a previous tail value with a newly calculated tail value, and increasing a sequence number of a next input message by one; Reading the message length information corresponding to the memory address stored in the head value, and continuously reading the message stored in the memory address by the message length information; And a fifth step of updating a previous head value by calculating a new head value using the message length information of the read message.

The principle of the present invention is briefly described as follows.

Variable-length messages are inserted into the queue with message length information. In the circular queue, logically, the beginning and the end are regarded as connected, but the real memory is not connected with the beginning and the end. Therefore, a case may exist where logically allocable parts exist but are physically separated and cannot be allocated. To solve this problem, in addition to the logical queue size, the physical size of the message should be empty. When a variable-length message's storage address is assigned to a non-contiguous portion, it is written as if it were written in a logical, contiguous manner.

Hereinafter, with reference to the accompanying drawings will be described an embodiment of the present invention;

1 illustrates a physical memory structure and a logical structure for storing a variable length message for explaining the present invention.

One variable-length message format consists of data, message length information, and other information. When a variable length message is stored in a queue, the length information of the variable length message must be specified at the beginning to clearly distinguish between the messages. In addition, the sequence number of the message should be included in order to know the number of messages stored in the queue. The number of messages currently stored in the queue is obtained by subtracting the number of messages stored in the head from the order to be given to the messages to be stored in the next step.

Information for controlling the queue includes head, tail, logical soft size, physical hard size, and the like. The head records the beginning address of the oldest stored message in the queue, and the tail points to the beginning address of the memory where the message to be inserted is stored in the next step. In the absence of any messages stored on the queue, the head and tail have the same memory address.

FIG. 2A is a flowchart illustrating a variable length message insertion process in a circular queue according to the present invention, and FIG. 3 is a diagram for explaining this.

In the initial state, the head and tail addresses are both '0' and the sequence number to be assigned to the next message is '0'.

When a message to be stored in the queue is input, length information is obtained from the input message, and the message sequence number is assigned to the input message (101, 102, 10 in Fig. 3).

Then, it checks whether there is space equal to the length of the message to be stored in the queue (103). If the memory space is insufficient, it notifies that the message cannot be stored (104). If the memory space is sufficient, the input message is sequentially stored at the address of the memory recorded in the tail (105), and the head is kept as it is (12, 13 in Fig. 3). To store the next message to be input, the tail value is added by the length of the currently stored message, and then the tail value is obtained through the modulo soft-limit. 106, 15 of FIG. 3). Then, the sequence number of the next message to be inserted is increased by one (107, 11 in Fig. 3).

Logically, the memory address after the portion indicated by the size of the logical queue is physically '0'. This part looks logically contiguous, but physically apart it is impossible to make physical memory logical. That is, the memory part including the logical queue size and the address '0' seems to be logically assignable, but the part to be stored continuously is physically separated and cannot be stored continuously. To solve this problem, allocate more memory space for the maximum message size after the logical queue size. Logically, the message to be allocated to the part including the logical queue size and the memory address '0' is stored continuously from the tail, and the tail calculation is the same as in the previous method.

As a result of this method, the physical and logical parts are actually inconsistent, but are logically in the form of complete circular queues.

2B and 4 are a flow chart and a diagram illustrating a deletion process of a message.

The deletion of the message stored in the circular queue is made using the information recorded in the head. This is to ensure that the first in first out (FIFO), that is, the oldest message is read first from the queue and must be serviced.

First, it checks whether there is a message stored in the queue (111), notifies the fact that there is no message stored in the queue (112), and if there is a message stored in the queue, the following steps are performed.

Since address information of the oldest message in the queue is stored in the head, the length of the message stored in the queue is read from the head (113) and the message is read (114). The subsequent new head value is added to the value of the previous head by the length of the message read, and the logical head size value is obtained through the rest of the operation, and the head value is changed to the calculated value (115, 17 in FIG. 4). .

Considering how the message is handled physically away from the insert, when reading a queued message, always read the physical contiguous portion of the head the length of the message.

The present invention described above is not limited to the above-described embodiment and the accompanying drawings, and various substitutions, modifications, and alterations are possible within the scope without departing from the technical spirit of the present invention. It will be clear to those who have knowledge of

The present invention as described above will be apparent through the following description.

In the case of controlling the variable maximum size of the message as the maximum size of the memory as in the conventional method, the size of the wasted memory is (total number of messages stored in the queue) x ((size of queue element) / 2). On average, half of the queue elements per message are emptied, so half the size of the queue element is multiplied. In contrast, the wasted memory size in the present invention is ((maximum size of queue element) / 2) x (total number of messages stored in queue) x (average message size) / (logical size of queue). Compared with the size of the wasted memory only, the present invention not only reduces the size of the wasted memory compared to the conventional method, but also the larger the logical queue size, that is, the larger the queue, the better the memory compared to the maximum queue element size. It can be seen that the usage rate.

Claims (4)

In the variable-length message processing method applied to a queue having a structure in which a memory area corresponding to the maximum message size is further allocated after the logical queue size, Acquiring message length information from the input message and assigning a message sequence number to the input message; Reading a tail value and sequentially storing the input message at a memory address recorded in the tail value; Calculating a new tail value using message length information, updating a previous tail value with a newly calculated tail value, and increasing a sequence number of a next input message by one; Reading the message length information corresponding to the memory address stored in the head value, and continuously reading the message stored in the memory address by the message length information; And And a fifth step of updating a previous head value by calculating a new head value using message length information of the read message. The method of claim 1, The new tail value is A method for processing a variable length message in a queue, wherein the previous tail value is added by the length of the currently stored message, and then calculated by performing a remainder operation on the logical queue size. The method of claim 1, The new head value is A method for processing a variable length message in a queue, wherein the previous head value is added by the length of the currently read message, and then calculated by performing a remainder operation on the logical queue size. The method of claim 1, The method of processing a variable-length message in a queue, when reading a message from the queue, starting from a memory address recorded in a head value and reading a physically contiguous portion by a message length.

Images