JPH0689186A - Sort processing method - Google Patents

Abstract

PURPOSE:To shorten the processing time of the sort function in the programming language processing system. CONSTITUTION:A copmpiler 101 reads in a sort statement from a source program 100 and generates a comparison function 117 only for this sort statement in an object program 111. A sort processing part 124 of a sort routine 121 receives the address of the comparison function 117 when being called, and it is called (125) to realize the sort function. The time to the start of the actual sort processing is shortened by omission of sort key information analysis processing in the initial processing of the sort routine, and the processing speed is increased by omission of key information reference and analysis in the comparison processing of the sort processing, and the sort processing time is shortened as the whole.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a sorting method for efficiently sorting data according to a method of determining an order relation designated by a user.

[0002]

2. Description of the Related Art When a sort function provided by a programming language is used, a user specifies the order relation of data in a source program by a sort key and a direction in which the keys are aligned (ascending order / descending order). A conventional compiler is configured to read this and generate an object that calls a sort routine by using the information of the sort key as a parameter. Further, when the compiled object program is executed, the conventional sort routine analyzes the key information passed as a parameter from the object program, and compares the data while referring to the sort key information stored inside during the sort process. It was configured to sort by.

As for publicly known documents, "HITAC
According to pages 197 to 205 of "Program Product VOS3 COBOL85 User's Guide" (manual number 8090-3-855-30, Hitachi, Ltd.), the COBOL compiler uses the SORT statement of the source program as "extended sort merge XSORT.""(Sort merge program) to generate the parameters to be passed. This parameter is the key position,
A set of four items of length, data format, and orientation is repeated by the number of keys.

Then, "program product VOS3
As described on page 7 of "Extended Sort Merge XSORT E2 Explanation / Grammar Manual" (manual number 6180-3-470, Hitachi, Ltd.), "Extended Sort Merge XSOR"
"T" analyzes those parameters ("extended sort merge control statement" in the literature) and then executes sort processing.

[0005]

In the method of executing the sort routine by using the sort key information on the source program as a parameter, the sort key information parameter must be analyzed on the sort routine side, and when the sort function is executed, Each time a key is compared, the key information must be referenced to perform the comparison, which has been a factor in increasing the time of the entire sort process.

An object of the present invention is to provide a sort processing method capable of shortening the time of the whole sort processing by eliminating the above factors for increasing the processing time.

More specifically, one object of the present invention is to prevent the sort key information from being passed to the sort routine and to eliminate the parameter analysis phase in the sort routine, so that the actual sort processing can be performed. The goal is to reduce the time it takes to get started. Another object of the present invention is to speed up data comparison processing by eliminating the need to refer to key information in each sort routine during each comparison.

[0008]

According to the present invention, when a source program is compiled, a compiler compares a data comparison processing routine required for sorting from a sort order determination method written in the source program by a method specific to a programming language. It is characterized in that it is generated in a program, and when the object program is executed, a sort program is used to sort data by using a data comparison processing routine generated in the object program.

[0009]

Since the analysis processing of the sort key information is unnecessary in the initial processing of the sorting routine, the time until the actual sorting processing starts is shortened by this amount. Further, since the process of referring to and interpreting the key information in the comparison process during the sort process of the sort routine becomes unnecessary, the processing speed is improved accordingly. As a result of such two time reductions, it is possible to reduce the time of the entire sorting process. In addition, if the compiler has an optimization function, it can be expected to speed up by optimizing the data comparison processing routine dedicated to the sort processing.

[0010]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS An embodiment of the present invention in a COBOL language processing system will be described below with reference to the drawings. In the description, JIS X0128 is used to express the flow of processing.
The PAD diagram of is used.

FIG. 1 shows the structures of a compiler and a sorting routine according to an embodiment of the present invention, and a calling relationship between the compiled object program and the sorting routine. Reference numerals 1 and 2 are a central processing unit (CPU) and a storage device of the computer. Here, the source program 100, the compiler 101, the object program 111, and the sort routine 121 are all shown on the storage device 2. Further, although not shown, a data file to be sorted, a data file after sorting, and the like are also stored in the storage device 2.

The overall structure of the compiler 101 is similar to the conventional one, and a front part 102 for analyzing the source program 100 to generate a program of an intermediate language expression, and a back part for inputting the front part 102 to generate an object program 111. And 104. The front section 102 includes a sort statement expansion processing section 103, which is a section that analyzes a sort statement on a source program and generates an intermediate language that realizes a data sorting function.

Conventionally, in this sort statement expansion processing unit 103,
An intermediate language program that analyzes sort key information and calls a sort routine by using it as an argument is generated.
However, according to the present invention, this sort sentence expansion portion 103
Changes the function so that an intermediate language function that performs data comparison necessary for sorting is generated, and the argument when calling the sort routine when the object program is executed is the address of the function.

The overall structure of the sort routine 121 is the same as that of the conventional one and includes an initialization processing section 122, a record receiving (data input) processing section 123, a sorting processing section 124,
The routine includes a record passing (data output) processing unit 126 and an end processing unit 127. However, according to the present invention, the sort key information parameter interpretation processing conventionally included in the initialization processing unit 122 is eliminated. Further, according to the present invention, the contents of the data comparison process of the sort processing unit 124 are:
The method is different from the conventional method of comparing sort key information while interpreting it, and is a method of passing two pieces of data to be compared to a data comparison function generated by the compiler 101 and determining a return value thereof. The record receiving processing unit 12
3, the record delivery processing unit 126 and the end processing unit 127 are the same as the conventional ones.

Reference numeral 111 is an object program output by the compiler 101. In this object program 111, 112 to 116 are the expanded parts of the SORT statement on the source program 100, and call the corresponding parts of the sort routine 121. 117
Is a comparison function (data comparison processing routine for sorting) generated from the SORT statement by the compiler 101.

Next, the call relationship between the object program 111 and the sort routine 121 will be described.

In the initial process call 112 of the object program 111, the record length of the data to be sorted and the maximum number of records are used as arguments, and the sort routine 121
The initial processing unit 122 is called, and the initial processing unit 122 secures a necessary work area.

In the record receiving processing call 113 of the object program 111, the sort target data is set in the record for sorting (sorting) by the method specified by the SORT statement, and the record area address is used as an argument to receive the record. The processing unit 123 is called. The record reception processing unit 123 receives one record and stores it in the work area secured by the initial processing unit 122.
Repeat this call until there are no more data to sort.

The sort processing call 114 of the object program 111 calls the sort processing unit 124. The sort processing unit 124 selects two records to be compared from the records stored by the record reception processing unit 123 according to the sorting algorithm, and calls the comparison function 117 using the address of this record as an argument (comparison function call 125). . In the comparison function 117, S
The two records are compared according to the sort key information of the ORT statement, it is determined whether the order of the records needs to be changed, and if necessary, "Swap" is selected.
"Replace" is returned as the return value. When the control returns, the sort processing unit 124 "replaces" the return value.
Then swap the order of the records, otherwise don't. In this way, all the data are sorted.

In the record delivery processing call 115 of the object program 111, the record delivery processing unit 126 is repeatedly called with the address of the record area for sorting to be received as an argument, and the records are received in the sorted order and specified in the SORT statement. Process as described. The record delivery processing unit 126 stores the sorted data in the record area of the argument one record each time it is called. In the end processing call 116, the end processing unit 127 is called. The end processing unit 127 releases the work area used in the sort routine 121.

Next, in order to realize such a calling relationship during program execution, the compiler 101 uses the SOR.
The process of expanding the T sentence will be described.

FIG. 2 is a PAD diagram showing the flow of processing of the SORT sentence expansion processing unit 103 of the compiler 101. In this figure, "expanding" means expanding the processing of the intermediate language expression.

First, the comparison function 117 is expanded from the sort key information of the SORT statement (step 201), and then the initial process call 112 of the sort routine is expanded (step 202). Next, the record receiving processing call 113 for passing data to the sort routine is expanded (step 203). Next, the sort process call 114 of the sort routine is expanded (step 204). Next, the record transfer processing call 205 for receiving data from the sort routine is expanded (step 20).
5). Finally, call the end processing of the sort routine 11
6 is expanded (step 206).

FIG. 3 is a PAD diagram showing in detail the comparison function expansion processing step 201 of FIG. FIG. 4 shows FIG.
It is a PAD diagram showing the parts of the process to be assembled by the process of. The specification of the comparison function to be assembled is record 1
And record 2 as arguments, and if record 1 is in the previous order and it is determined that it needs to be swapped, then "swap", otherwise "do not swap"
Is returned as a Ritan value. Here P
Although a method of generating a function will be described by a method of assembling an AD diagram, the process of the intermediate language expression corresponding to the assembled PAD diagram is actually developed.

In FIG. 4, reference numeral 401 denotes an entry portion of the comparison function, which receives record 1 and record 2. An exit portion 402 of the comparison function returns the set return value to the calling source. 403 to 406 are processes for the n-th sort key (hereinafter referred to as key n).

Reference numerals 403 and 404 denote processes for the designated key which is not the last one. Reference numeral 403 denotes a process when the keys are in ascending order. When the key n of the record 1 is larger than the key n of the record 2, "replace" is set, and when it is smaller, "do not replace" is set as the return value. The processing when neither is done is open so that other processing components can be connected. 404 is a process when the keys are in descending order, and the determination condition is the opposite of 403, but the process when neither is 40
It is vacant as in 3.

Reference numerals 405 and 406 are processes for the last designated key. 405 is a process when the keys are in ascending order. When the key n of the record 1 is larger than the key n of the record 2, "replace" is set, and otherwise, "do not replace" is set as the return value. 406 is a process when the keys are in descending order, and the determination condition is the reverse of 403.

Next, a method of expanding the comparison function will be described with reference to FIG. First, the part 401 is expanded to create a function entrance (step 301). Then, the next process is performed while setting the number of times in the variable n only (the number of keys specified in the SORT sentence-1) times (step 302).

That is, if the key n has an ascending order designation (step 303), the portion 403 at the bottom right of the PAD diagram.
(Step 304), otherwise connect the portion 404 at the bottom right of the PAD diagram (step 30).
5). 3 if only one key is specified
The processing of 02 to 305 is not performed even once.

Next, the variable n is set to the number of keys specified in the SORT statement (step 306).
If the last key is the ascending order designation (step 307), the part 405 is connected to the lower rightmost part of the PAD diagram (step 308), and the part 406 is connected to the lowermost right part of the PAD diagram otherwise. (Step 309). And finally, the part 402 is expanded to the lower left and the exit of this function is made (step 310).

The specific comparison operation method differs depending on the data attribute (character, binary format, zone format, pack format, etc.), but like the comparison operation of other parts of the source program, the back part of the compiler 101 is used. This is solved by generating different objects in 104. In this way, the comparison function 117 dedicated to the specific SORT sentence is generated.

Next, the SO of the actual COBOL program
An example of the comparison function expanded from the RT statement by the method described with reference to FIGS. 3 and 4 will be described with reference to FIGS. 5 and 6.

FIG. 5 shows an example of a COBOL program including a SORT statement. Reference numeral 501 is a portion that specifies the structure of records in a sort file. 502
And 503 are portions that specify the record structures of the input file and the output file, respectively. 504 is SOR
It is a T sentence. In the SOR statement 504, 505 specifies that the first key S-URIAGE-KOSU should be arranged in descending order, 506 specifies that the S-CODE of the second key should be arranged in ascending order, and 507 and 508 respectively. Input file and output file are specified.

FIG. 6 shows the SO of this COBOL program.
PA showing the contents of the comparison function generated from the RT statement 504
FIG. 601 is an expanded version of 401 in FIG.
Receive record 1 (C1-RECORD) and record 2 (C2-RECORD). Record 1 and record 2 are set inside the compiler so as to have the record structures indicated by 610 and 611 in the figure, respectively. Note that these record structures are the same as the record structure of the sort file specified in the portion 91 of the COBOL program in FIG. 602 is a SORT statement 5 of the source program
Since the first key S-URIAGE-KOSU is designated in descending order in 04, 404 in FIG. 4 is expanded. Record 1 C1-
If URIAGE-KOSU is smaller than C2-URIAGE-KOSU of record 2, set the return value to "swap", and if it is larger, set it to "not swap". 603 is expanded to the processing when neither is. This is a SORT statement 504
The key S-CODE next to is an ascending order designation, and since this key is the last key, it is an expanded version of 405 in FIG. If the C1-CODE of record 1 is greater than the C2-CODE of record 2, set the return value to "swap", otherwise set to "not swap". The end of this function is the expanded 604 of 82 in FIG. 4, where
Returns the return value to the caller.

As described above, at the compile stage, the compiler analyzes the sort statement in the front part and generates the function of the intermediate language expression for comparing the data, thereby specializing in the method of determining the data order specified by the user. The sorted comparison function (sort-only data comparison routine) is generated in the object program. Then, when the object program is executed, the sort key parameter analysis process is not required in the initial processing unit of the sort routine, and the time until the actual sort process is started can be shortened. Also, in the sort processing section of the sort routine,
Instead of comparing the sort key information while comparing it, by calling the comparison function generated by the compiler and judging the return value, there is no processing to interpret,
The comparison process can be speeded up. Furthermore, if the compiler has an optimization function, it can be expected that this comparison function will also be optimized and become faster.

[0036]

According to the present invention, the time until the actual sort processing is started is shortened by the amount of the analysis processing of the sort key information in the initial processing of the sort routine being shortened, and the comparison processing during the sort processing is further reduced. , The processing speed is increased by the amount of time when the key information is not referred to and interpreted, and as a result, the entire sort processing time can be shortened.

[Brief description of drawings]

FIG. 1 is a diagram showing a general structure of a compiler and a sort routine in one embodiment of the present invention, and a calling relationship between a compiled object program and a sort routine.

FIG. 2 is a PAD diagram showing a process of developing a SORT sentence.

FIG. 3 is a PAD diagram showing a process of expanding a comparison function.

FIG. 4 is a PAD diagram showing processing components used in comparison function expansion processing.

FIG. 5 is a diagram showing an example of a COBOL program including a SORT statement.

FIG. 6 is a PAD diagram showing the contents of a comparison function generated from a COBOL program example.

[Explanation of symbols]

 100 Source Program 101 Compiler 102 Front Section 103 Sort Statement Expansion Processing Section 104 Back Section 111 Object Program 112 Initial Processing Call 113 Record Reception Processing Call 114 Sort Processing Call 115 Record Passing Processing Call 116 End Processing Call 117 Comparison Function 121 Sort Routine 122 Initial Processing unit 123 Record receiving processing unit 124 Sort processing unit 125 Comparison function call 126 Record passing processing unit 127 End processing unit 501 Record structure specifying unit for sorting file 502 Record structure specifying unit for input file 503 Record structure specifying unit for output file 504 SORT sentence 610 Structure of record 1 611 Structure of record 2

 ─────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor Hiroyoshi Imaoka 5030 Totsuka-cho, Totsuka-ku, Yokohama City, Kanagawa Prefecture Software Development Division, Hitachi Ltd. 81-chome Hitachi Software Engineering Co., Ltd. (72) Inventor Ryoichi Watanabe 6-81 Onoue-cho, Naka-ku, Yokohama-shi Kanagawa Hitachi Software Engineering Co., Ltd. In-house

Claims (1)

[Claims] 1. When compiling a source program, the compiler generates a data comparison processing routine required for sorting in the object program from the method of determining the sort order written in the source program by a method specific to the programming language, A sort processing method characterized in that a sort program is executed at the time of execution to sort data by using a data comparison processing routine generated in an object program.