KR960012418B1 - Chill case code - Google Patents

Abstract

A device using the method has a hardware having a main memory board(101), a CPU(102), an auxiliary memory unit(104), an input/output unit(105), and an UNIX operating unit(103). The method comprises the steps of; examining an input case label number by using a case label value or case selector value(201,202), examining a certain number of label number(203,205), performing stop after code generation, label value sorting and vector table organizing, or examining label dividing possibility(205,209), organizing a vector table, generating and finishing a dividing vector code(210,214), and generating and finishing a code generation by using organizing balance binary scale tree.

Description

How to Generate Code for Chill Case Structure

1 is a hardware block diagram to which the present invention is applied.

2 is an overall processing flow diagram for a code generation method according to the present invention.

3 is a detailed flowchart of the case label table separability investigation process.

4 is a detailed processing flowchart of a subprogram split (SPLIT) for constructing a separate cluster list.

* Explanation of symbols for main parts of the drawings

101: main memory 102: central processing board

103: general purpose operating system 104: auxiliary storage device

105: input / output device 106: system bus

The present invention relates to a method for generating code of a case structure of a CHILL (CCITT High Level Language) language, which is a programming language for the exchange recommended by CCITT.

Existing compilers classify the distribution of case label values into several types and generate code for each type when generating the case structure code. According to the classified type, codes are generated relatively efficiently by using if-then-else codes, vector codes, hashing functions, and codes using hashing tables. However, the existing compiler may not handle this even though the distribution of the case label is a distribution capable of generating efficient code. Therefore, the classification type of the existing label cannot generate the efficient case structure code.

Since the exchange program is operated synchronously by various messages transmitted / received among multiple processes, the overall structure of the program is composed based on the case structure.

Therefore, as the number of types of transmission / reception messages used in the program increases, many comparisons are made in order to go to a routine for processing the received message. For this reason, in the case of permanent embedded programs such as the exchange program, the improvement of the execution speed by efficient code generation of the case structure is absolutely important because it affects the performance of the entire system.

Accordingly, an object of the present invention is to provide a method of generating an efficient code based on the fact that the distribution of a case label is a distribution capable of efficient code generation.

In order to achieve the above object, the present invention relates to a code generation method of a chill case structure applied to hardware including a main memory board, a central processing unit, an auxiliary memory device, an input / output device, and a UNIX operating system. The method of claim 1, further comprising: reading a case label (L) value and a case selector value and checking whether the number of the input case label is less than four; A second step of generating a sequential comparison code if the number of case labels is less than a set number after performing the first step; and checking whether the maximum deviation between labels exceeds a set multiple of the number of labels if the number of the case labels is less than the set number; After performing the second step, if the set multiple is not exceeded, the case vector code is generated and the label value is sorted to construct the vector table, and the vector code is generated and terminated. A third step of investigation; A fourth step of constructing a separate case vector table and performing generation of the separated vector code by using the separated case vector table after performing the third step; If the case label table is not separable after performing the third step, it is checked whether the number of labels exceeds an arbitrary value, and if the number of labels does not exceed an arbitrary value, after generating with a sequential comparison code, the process ends and ends. A fifth step of constructing a balanced binary tree and ending after code generation when is greater than an arbitrary value; Characterized in that comprises a.

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

FIG. 1 is a block diagram of hardware to which the present invention is applied. In the drawings, reference numeral 101 denotes a main memory, 102 a central processing board, 103 a UNIX operating system unit, 104 an auxiliary memory device, and 105 an input / output device, respectively.

Looking at the function of each block shown in the drawings as follows.

The main memory 101 is a board on which an execution file having a case control structure is mounted, and the central processing board 102 is a board for executing a file mounted on the main memory 101. In addition, the auxiliary memory device 104 is a device for storing files and data, and stores files and tools not mounted in the main memory.

The input / output device 105 is a device for inputting / outputting files and data necessary for performing a separate compilation and all error messages generated during the execution.

The UNIX operating system unit 103 controls the boards and devices, and messages exchanged between the boards and devices are made through the system bus 106.

2 is a flow diagram of the overall process according to the present invention, which reads the label value and the selector value of the case structure and performs only a minimal comparison to generate an effective case structure code that goes to a routine matching the case selector value. Show the procedure.

First, a case label (L) value is read. This step is a preparation step for efficiently generating code generation of a case structure. The file including the case structure stored in the auxiliary memory device 104 is stored in the main memory (L). 101) and read the case label value and selector value from this file (201).

Next, if the number of input case labels is less than 4 (202), and if the result of the investigation is less than 4, the value of the case label and the case selector value are sequentially compared to the next execution statement of the label having the same value. After generating the sequential comparison code, the case structure code generation is completely terminated (203).

When the case label number is 4 or more, the maximum value max (L), minimum value min (L), and the difference R between them are calculated from the case label values. (204).

Next, we examine whether the difference R between the maximum value and the minimum value of the case label exceeds three times the number of labels (205). Here, the maximum deviation of the case label value is examined to find the most efficient vector code. Decide if you want to use it.

If the difference between the maximum value and the minimum value of the case label is less than or equal to three times the number of labels, the case vector table is configured (206). Here, a vector table is formed by pairing the input label and the start address of the execution statement for generating the vector code. First, after sorting the input label, a vector table having a size corresponding to the maximum deviation number of the label is allocated to store the label value and the jump address. Then, the label value and the corresponding statement jump address are sequentially registered in the vector table in the sorted order. If there is a difference between the adjacent labels, the label value is -1 by the difference of the values, and the jump address is the case structure. Assign as the end address of and register between adjacent labels.

Next, the number of vector codes corresponding to the number of array elements of the vector table is generated using the vector table, and the process ends (207). First, after generating the code of the execution statement corresponding to the input label, it is the most efficient code with the average comparison count of 1 to find the case selector value and the working case label, but it takes unnecessary storage waste when constructing the vector table. shall.

If the difference between the maximum value and the minimum value of the case label exceeds three times the number of labels, the possibility of label separation is examined (208). This step does not generate code using a vector table because the values of the labels are not clustered and distributed, but the values are clustered and distributed in a small number of clusters. Investigate whether to generate vector code using a split vector table. Here, when the case label table is separable, the label table is divided into cluster units and the separated clusters are configured as a list so that the cluster clusterPtr points.

The next step is to decide whether to go to the separation code generation process or the code generation step using a balanced binary tree with the result of the separation possibility (step of cluster_Ptr) checked in the previous step (208). If the value of the cluster (Cluster_Ptr) is null, it means that there is no separation. If the value of the cluster (Pluster_Ptr) is not null, it means that it is separated.

Next, a separate case vector table is constructed using the generated cluster table list (210). Here, after generating the separated vector code and replacing the address of the first vector table with the pointer SVT_Ptr that points to the generated vector table list (211), the value of the pointer is not null. Until the separated vector code is generated (212, 213), the pointer value is replaced with the address of the next table connected to the vector table currently indicated (214). When the value of the pointer SVT_PTR is null, all generation of the code is completely terminated (212).

If the case label table is not detachable as a result of step 209, it is checked whether the number of labels exceeds 8 (215). Here, it is decided which code pattern to select when generating the code of the case structure. If the number of labels does not exceed 8, all codes are completely generated after generating 216 with sequential comparison codes. The sequential comparison code increases the number of comparisons linearly as the number of labels increases as the average number of comparisons is (n + 1) / 2. However, if the number of labels does not exceed 8, it is compared with other codes. Does not fall

If the number of the resulting labels in step 215 exceeds 8, a balanced binary tree is constructed using the label table sorted in step 208 (step 217). In this case, a balanced binary tree is prepared so that a code can be generated by a binary search method.

Next, using the balanced binary tree generated in the previous step (217), a code for finding a case selector value is generated (218), and then all generations are completed. Here, when generating a case structure code having n labels, an efficient code having an average number of comparisons O (log n) is generated in which the number of comparisons does not increase linearly even if the number of labels increases.

3 is a detailed flowchart of the case label table separability investigation process, which shows a procedure of determining whether to separate case labels and separating case labels in a cluster unit and forming a list if possible.

First, the values of the case label table are sorted in ascending order (301). This step is a preparatory step to determine in what state the case label values are distributed.

Next, the pointer cluster (cluster_Ptr) value for pointing to the cluster list is replaced with null (302). This step indicates that there is no separation until the case labels are examined for separation. If the value of this pointer is null even after checking for separation, the case label is not separated.

Subsequently, a subprogram split (SPLIT) is called (303) which checks whether the labels are clustered and distributed using the maximum value of the case label table and the case label as parameters. After the end of this step, if the value of the global variable cluster list pointer (cluster_Pt) is null, it indicates that the labels were not separated into clusters. Indicates that the label is separated into clusters, the value of which is a pointer value that points to a separate list of cluster tables.

4 is a detailed flowchart of a subprogram split (SPLIT) for dividing a case label into clusters to form a separate cluster list.

First, when a function split SPLIT for constructing a separate cluster list is called, a case label table VT, a maximum value (max) and a minimum value (min) of a label are passed as parameters (401). This step starts the execution of the function when the SPLIT function is called. It takes parameter values from the caller.

Then, it is checked whether the maximum value (max) and the minimum value (min) of the received label match (402). This step is to decide whether or not to separate.

When the maximum value max and the minimum value min of the previous step 402 coincide, the execution of the function split SPLIT ends. This step ends the call to the split function.

If the resultant maximum value (max) and minimum value (min) do not coincide with the result of the process 402, the difference between the new median value mid, the mid value mid and the minimum value min R1, the number N1, the maximum value Compute the difference R2 and the number N2 between (max) and the minimum value (min) +1 (403).

It is calculated whether the value R1 calculated in the step 403 exceeds 3 x N1 (404). This step decides whether to construct a cluster table with label values between the minimum and mid values.

In step 404, if R1 exceeds 3xN1, it is calculated whether R2 exceeds 3xN2 (405). This step recursively invokes a function split (SPLIT) for cluster table construction with a mid value mid + 1 and a max value, respectively (412).

However, if in step 405 R2 does not exceed 3 x N2, we construct a new cluster table containing a label between mid + 1 and max (max), After registering in the table list (406), the function split (SPLIT) is recursively called (407) using the case label table, the minimum value (min) and the middle value (mid) as parameters.

If R1 is less than or equal to 3 × N1 as a result of the process 404, it is calculated whether R2 is less than or equal to 3 × N2 (408). In this step, the label values between the mid value (mid) + 1 and the maximum value (max) are also clustered under the condition that the cluster table is composed of the label values between the minimum value (min) and the mid value (mid). This step decides whether to configure (cluster) table.

In the process 408, when R2 is less than or equal to 3 x N2, two values each include a value between the minimum value (min) and the middle value (mid) and a value between the middle value (mid + 1) and the maximum value (max), respectively. The new cluster tables are configured, registered in the cluster table list (417), and the execution of the called split function is terminated.

As a result of the process 408, if R2 exceeds 3 × N2, a new cluster table including a label value between the minimum value (min) and the mid value (mid) is formed, and this is added to the cluster table list. After registration (409), the function split (SPLIT) is recursively called and terminated with the case label table, the middle value mid + 1 and the maximum value max as a parameter (410).

The present invention composed of the above-described processing procedure is supported by the operating system and when the compiler running on the central processing board 102 generates a chill case (CHILL case) structure code than the case code generated by the conventional commercialized compiler In addition to the case structure with fewer comparisons, it is applied to case structure code generation of other high level languages to generate efficient code.

Claims (3)

CHILL CASE structure applied to hardware having a main memory board 101, a central processing unit 102, an auxiliary memory 104, an input / output device 105, and a UNIX operating system unit 103. A method of generating a code, the method comprising: a first step (201, 202) of reading a case label (L) value and a case selector value and checking whether the number of input case labels is less than four; After performing the first steps 201 and 202, if the number of case labels is less than the set number, a sequential comparison code is generated. Two steps (203 to 205); After performing the second step (203 to 205), if the set times are not exceeded, the case vector code is generated and the label values are sorted to construct the vector table, and after the vector codes are generated and the set times are exceeded, A third step (205 to 209) of investigating the possibility of separation; A fourth step (210 to 214) of constructing a separate case vector table if possible, and generating and terminating a separate vector code using the same, after performing the third step (205 to 209); After performing the third step (205 to 209), if the case label table is not separable, it is checked whether the number of labels exceeds an arbitrary value, and if the number of labels does not exceed an arbitrary value, after generating the sequential comparison code A fifth step (215 to 218) of ending a code generation by constructing a balanced binary tree when the number of labels exceeds an arbitrary value; Code generation method of the chill case (CHILL CSAE) structure, characterized in that comprises a. The method of claim 1, wherein the method for checking the case label table detachability of the third step (205 to 209) comprises: a first process (310) for sorting values of the case label table in ascending order; A second step 302 of replacing a point cluster (cluster_Ptr) value with null; A third step 303 of calling and terminating the subprogram split by using the case label table and the maximum value of the case label as parameters; Code generation method of the chill case (CHILL CASE) structure, characterized in that comprises a. 3. The method of claim 2, wherein the third process (303) comprises: (401, 402) checking whether the maximum value (max) and the minimum value (min) of the label match when the function split is called; After performing the processes 401 and 402, if the maximum value max and the minimum value min coincide, the process is terminated. If not, the difference between the new intermediate value mid and the minimum value min R1 and the number N1, Calculating whether or not R1 exceeds 3 x N1 by calculating the difference R2 and the number N2 between the maximum value max and the minimum value min + 1 (403, 404); When R1 exceeds 3 × N1 after performing the processes 403 and 404, it is examined whether R2 exceeds 3 × N2. When R2 does not exceed 3 × N2, the median mid + 1 and the maximum value max Constructing a new cluster table including a label between < RTI ID = 0.0 >) < / RTI > and registering it in the list, and then calling the function split (405 to 407); After performing steps 403 and 404, if R1 is 3 × N1 or less, check whether R2 is 3 × N2 or less, and if R2 is 3 × N2 or less, construct a new cluster table, register it in the list, and then call split Terminating the execution of the function and constructing a cluster table when R2 exceeds 3 × N2, registering in the table list, calling and terminating the function split (409, 410); Code generation method of the chill case (CHILL CASE) structure, characterized in that comprises a.