JPH09204299A - Program development device - Google Patents

Abstract

PROBLEM TO BE SOLVED: To describe the operations of the entire system altogether and to perform system development of not being conscious of the operations of respective programs by generating source codes for executing a communication processing in the respective programs from the source code described with the specification of a linkage processing between the programs in a distributed processing system. SOLUTION: A language program 4 for generating program codes 5 and 6 for executing mutually linked processings for the respective programs A and B from a linkage definition source code 1 for defining linkage between the respective programs A and B for constituting the distributed processing system is provided. From the program codes 5 and 6 generated in the language processor 4 and respective intrinsic processing source programs 2 and 3 for describing the processings intrinsic to the respective programs A and B, object programs 9 and 10 for the respective programs A and B are generated by compiler-linkers 7 and 8.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a software development technique, and more particularly to a program development apparatus suitable for improving the software development productivity of a distributed processing system.

[0002]

2. Description of the Related Art With the recent progress of networks and the cost reduction of computers, many distributed processing systems represented by a client / server model have been developed. In this distributed processing system, each information processing apparatus that constitutes the system operates while communicating between the programs. Due to the difficulty of the design related to the communication, the software of the distributed processing system has a higher degree of program difficulty than other software, which hinders the improvement of its productivity.

As a conventional technique for improving the efficiency of the development of such a communication program, for example, Japanese Patent Laid-Open No. 4-352 is known.
There is one described in Japanese Patent No. 029. In this technology, a programming language for communication software development has been proposed, and the description of a program is facilitated by describing the operation of the program in one state transition table. That is, a state variable indicating the communication state is assigned to the program, and the object code generated by the language processor automatically manages the communication state using this. According to this technique, since the object code generated by the language processor automatically manages the communication state, the program developer does not need to explicitly describe the management of the program state, and the program development becomes easy.

However, this programming language automatically manages the states of individual programs, and does not manage the overall state of a distributed processing system in which a plurality of programs operate in cooperation. Therefore, even if this programming language is used, it is necessary to design the entire distributed processing system according to the conventional design procedure. Therefore, the difficulty in designing synchronization and protocols between programs remains, and the software designer pays close attention to appropriately define the function allocation for each program and maintain consistency (synchronization) between the programs. A consistent protocol must be designed. This puts a huge load on the designer. Further, when one of the programs is modified for some reason, it is necessary to modify the other program in accordance with the modification. Such workload impedes the improvement of software productivity of the distributed processing system.

[0005]

The problem to be solved by the prior art is that in the prior art, the specifications of each individual program, including the synchronization and protocols between the programs that make up the distributed processing system, are described independently. This is a point that must be done. An object of the present invention is to solve these problems of the prior art and to generate source code for executing communication processing in individual programs from source code in which specifications of cooperative processing between programs in a distributed processing system are described. The purpose of the present invention is to provide a program development device that enables the description of the operation of the entire system as a whole and enables the system development without being aware of the operation of individual programs.

[0006]

In order to achieve the above object, a program development device of the present invention is a program development device for a distributed processing system that performs a single process by linking a plurality of information processing devices, Corresponding to each event that may occur in the distributed processing system and requires cooperation between each program of each information processing device, processing to be executed for each active state of each program at the time of occurrence of this event, Based on the source code 1 in which processing instruction information including at least a program to execute this processing and an instruction to change the active state of the program after execution of the processing is described, first for each program and for each event and active state of the program, If the program that should execute the process is its own program, the program code that executes the process that should be executed If the program to be executed is another program, the other program to be executed this processing,
A program code that generates a program code that requests execution of a process to be executed, and changes the active state of its own program and the program state of another program if there is an instruction to change the active state of the program after execution of the process Then, by receiving, for each individual program, a processing request from another program for the processing to be executed by the own program, and by generating a program code for executing the processing corresponding to the received processing request, A first language processor (language processor 4) that generates source programs 5 and 6 for each communication processing routine for each of programs A and B, and source programs 5 for each communication processing routine for each program that is generated by this language processor 4. 6 and each source program 2, which describes the processing unique to each program From and providing a second language processor to generate individual programs Another object program 9,10 (compiler linker 8).

[0007]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS In the present invention, if the operation of the entire system can be described collectively without paying attention to the operation of each program constituting the distributed processing system, the above-mentioned conventional problems can be solved. Focusing on this, by defining a specification of processing that requires cooperation between programs, and providing a first language processor (language processor 4) that generates a communication processing routine of each program from the specification definition information, It enables system design that does not consider the operation of individual programs. This language processor 4
The description contents of the specification definition information to be input to are as follows.

That is, the specification definition information includes (a) the state of the entire system that changes in association with the cooperation between programs, (b) an event that requires cooperation between programs that may occur on the system, and (c). The state transition of the system and the processing to be performed by each program at that time are described in correspondence with the state and event of the system. This is to extend the program state of the specification definition information described in JP-A-4-352029 to the state of the distributed processing system as a whole, and further to execute the process to be performed corresponding to each event and state. Is logically equivalent to the one to which information for identifying is added.

Next, the structure of the program code generated by the language processor 4 based on the specification definition information will be described. A plurality of program codes generated by the language processor 4 are generated for each program constituting the system. Each program code is composed of a subroutine corresponding to the event defined by the specification definition information described above and one subroutine for message reception. The subroutine corresponding to the event defined by the specification definition information changes the system state according to the result of judging the current system state and executes the defined process. At this time, the system state is changed by bloatcasting in synchronization with all programs at once. The execution of the defined process is realized by transmitting a process request message to the program that should actually execute the process. On the other hand, the receiving subroutine receives a process request message from another program and actually executes the requested process.

Incidentally, such a program code can be generated by adding the following procedure to the technique described in Japanese Patent Laid-Open No. 4-352029. (A) When generating a code for changing the state variable, a code for notifying other programs of the state change is added. (B) When generating the code of the process to be executed at the time of state transition, instead of directly generating the code, the "procedure for notifying the process request" to the program that should execute the process
Generate code. (C) The code of the above-mentioned receiving subroutine is added to the program code.

In this way, in the program incorporating the program code generated by the language processor 4, when any event occurs in the program, a subroutine corresponding to the event in the program code is called. When this subroutine is called, the system state is changed in each program all at once, and a process request message is sent to the program to execute the process. The reception subroutine is registered in the reception interrupt exit of the program, receives a processing request message from another program, and actually executes the requested processing. In this way, the program code generated by the language processor 4 satisfies the logical specifications described in the specification definition information without any problem.

Embodiments of the present invention will be described below with reference to the drawings.
This will be described in more detail. FIG. 1 is a block diagram showing an embodiment of the configuration of the program development apparatus of the present invention according to the present invention. In FIG. 1, 1 is a cooperation definition source code according to the present invention that defines a cooperation relationship between programs in the distributed processing system, and 2 and 3 are processes unique to the programs A and B constituting the distributed processing system. Specific processing source code, 4 is a language processor as a first language processor according to the present invention that generates a program code based on the cooperation definition source code 1, and 5 and 6 are for programs A and B generated by the language processor 4, respectively. , 7 and 8 are the compiler / linker as the second language processor according to the present invention for compiling and linking the program codes 5 and 6 and the intrinsic processing source codes 2 and 3, respectively, and 9 and 10 are the compiler and linker, respectively. Load modules (objects) of programs A and B generated by linkers 7 and 8 Is a program).

Cooperation definition source code 1 and unique processing source code 2 in which processing unique to each program is described
3 is created directly by the program developer. The language processor 4 inputs the cooperation definition source code 1,
The program codes 5 and 6 for realizing the cooperative processing to be performed by the individual programs A and B are output. In this embodiment, the program codes 5 and 6 are the compiler / linker 7,
8 source code. The program developer, for example, creates the unique processing source code 2, 3 created by himself.
And the program code 5, generated by the language processor 4,
6 is compiled and linked by existing compilers / linkers 7 and 8 to generate load modules 9 and 10 of the programs A and B, respectively.

The structure of the cooperation definition source code 1 will be described below with reference to FIGS. 2 and 3. FIG. 2 is an explanatory diagram showing a configuration example of a state transition table showing the operation of the entire distributed processing system of the program development target. Assuming that the state of each program constituting the distributed processing system changes at the same time as other programs, the cooperative processing between the programs is a state transition table showing the operation of the entire system as shown in FIG. It can be simply written as 20. In this state transition table 20, each row shows some events 21 that require cooperation between programs, and each column shows possible states 22 of the program. In each cell where the rows and columns of the state transition table 20 intersect, a process 23 to be executed is described corresponding to each event 21 and state 22.

The language processor 4 in FIG. 1 uses, as an input source, the cooperation definition source code 1 in FIG. 1 which is logically equivalent to the state transition table 20. A description example of this input source is shown in FIG. FIG. 3 is an explanatory diagram showing an example of the source code in FIG. As shown in FIG. 3, the cooperation definition source code 1 includes a declaration unit 1a and a definition unit 1b for processing related to communication. In the declaration section 1a, the program name (“PROC prA, pr in the figure” for identifying the generated code (program code 5, 6 in FIG. 1)
B ”), status variables and status names (“ STATUS st = ST0, ST1 ”in the figure) that represent the possible states of the program, event names that require cooperation (“ METHOD ev1, ev2 ”in the figure), and execution Declare the processing to be performed (“ACTION ac1, ac2, ac3” in the figure). Further, the definition unit 1b describes the change of the program state and the process to be executed for each combination of the event name (ev1, ev2) and the state name (ST0, ST1) in the declaration unit 1a.

The language processor 4 in FIG. 1 generates the program codes 5 and 6 for each program in FIG. 1 from the cooperation definition source code 1 as shown in FIG. FIG. 4 is an explanatory diagram showing an example of a procedure for generating a program code from a source code by the language processor in FIG. For example, when the cooperation definition source code 1 of the description content shown in FIG. 3 is input, the language processor 4 of FIG. 1 first creates the table having the hierarchical structure shown in FIG. At this time, in the route table 41 of the hierarchy,
It holds a list of program names (prA, prB) defined in the linkage definition source code 1 in FIG.

Each entry of this route table 41 is
Event list tables 42a and 42b (described as ev1 and ev2 in the figure) that store the event names (ev1 and ev2) in FIG. 3 and the processing (ac in FIG. 3) executed by the program (prA and prB)
Action list tails 45a, 4 storing (1, ac2)
5b (indicated as ac1 and ac2 in the figure). However, only the processes requested by other programs are registered in the action list tables 45a and 45b. Each entry of the event list tables 42a and 42b is
Status list tables 43a to 43d (ST0, ST1 in the figure) storing the state names (ST0, ST1) of the program of FIG.
And the status list table 4
3a to 43d are processing definition tables 44a to 4 which store statuses (ST0, ST1), processes (ac1 to ac3) to be executed, and program names (prA, prB) to execute the processes.
4h. The process definition tables 44a to 44h
Has two flags (indicated as NE and EQ in the figure) and sets "NE" when the stored status name or program name is different from the name of the upper table entry.

Based on the table created in this way,
The language processor 4 of FIG. 1 generates a program code (program code 5, 6 in FIG. 1) of each program (prA, prB) for each entry of the route table 41. Next, the program code thus generated will be described with reference to FIGS. 5 and 6.

FIG. 5 is an explanatory diagram showing a structural example of a function generated by the language processor in FIG. As shown in FIG. 5A, the program codes 5 and 6 in FIG. 1 include a plurality of functions 51 generated corresponding to the event names in the event list tables 42a and 42b in FIG.
As shown in (b), it is composed of one reception processing function 57. First, as shown in FIG. 5A, the function 51 corresponding to the event name has a process of suppressing the change of the state variable by another program (step 52), a process of releasing this suppression (step 56), and a state change. It is composed of a process of judging and branching (step 53), a process of changing the state (step 54) and a process of executing the corresponding process (branching block consisting of step 55).

Here, the step 53 of branching based on the judgment of the state is the status list table 43a-43a of FIG.
It is generated so as to have a branch destination for each state name registered in 43d, and branches to the branch destination corresponding to the current program state. The block at the branch destination includes the process definition table 4 of FIG.
Based on the contents of 4a to 44h, step 54 for changing the state and step 55 for executing the process are expanded. However,
If no state change has occurred, the state change step 54 is not expanded. Further, in step 55 of the process execution, as shown in FIG.
If the program executing the process registered in the process definition tables 44a to 44h is the own program, the process is expanded as it is, and if it is another program, the process request message transmission to the program is expanded.

Next, in FIG. 5B, the reception processing function 57 receives the message (step 58),
It is composed of a branch block including a process of judging a request and branching (step 59) and a process of executing the process (step 60). The step 59 of judging the request and branching is the action list table 45 of FIG.
It is generated so as to have a branch for each processing registered in a and 45b, and branches to the corresponding branch destination according to the requested processing code (ac1 to ac3). Step 60 for executing processing
Includes action list tables 45a and 45b in FIG.
Expand the processing (ac1 to ac3) registered in. FIG. 6 shows an example of the program codes 5 and 6 in FIG. 1 which are actually developed by such a procedure.

FIG. 6 is an explanatory diagram showing an example of program code generated by the language processor in FIG.
In the example shown in FIG. 6, the program state change inhibition in step 52, the change inhibition release in step 56, the program state change in step 54,
It is assumed that the processing request in step 55 and the message reception in step 58 are provided as a library. Operations of the function 51 and the reception processing function 57 in FIG. 5 generated by the language processor 4 in FIG. 1 will be described with reference to FIG.

Function 5 associated with the event in FIG.
1 is a processing routine when an event requiring inter-program cooperation occurs (“method called when event 1 occurs”, “method called when event 2 occurs” in FIG. 6), and the reception processing function 57: An interrupt routine when a processing request is issued from another program (see FIG. 6).
"Execute the request process from the partner program" in)) is incorporated into the program. The function 51 associated with the event of FIG. 5 first uses “LOCK ()” in FIG. 6 to prevent the program state from being changed by another program (FIG. 5).
Step 52). That is, when a plurality of programs request state change inhibition at the same time, the processing of one program is suspended until the other program releases the state change inhibition.

Next, the "switch (st)" in FIG. 6 is used to judge the current program state (step 53 in FIG. 5).
Branch to the branch destination that matches this with "case ST0", "case ST1", and "default". After branching, send a program status change request message with "st = ST1" and "SET (prB, ST1)" in FIG. 6 to change the status of the own program and other programs (step in FIG. 5). 54).
The program that receives this message changes the status of its own program to the specified value.

Thereafter, the defined processing is executed by "ac1 (arg)" in FIG. 6 (step 55 in FIG. 5). If the designated processing is to be executed by another program, a processing request message is transmitted to the corresponding program by "SEND (prB, AC1, arg)" in FIG. When the processing is completed, the program state change suppression is canceled by "UNLOCK ()" in FIG. 6 (step 56 in FIG. 5).
Then, the function ends.

On the other hand, the reception processing function 57 of FIG. 5 ("void d_receive (void) {...}" in FIG. 6) is interrupted and called when a message from another program is received. Then, the reception processing function 57 of FIG. 5 receives the message sent by “RECEIVE (& ev, argb)” of FIG. 6 (step 58 of FIG. 5), and “swit
With “ch (ev)” and “case AC2”, branch to the branch destination corresponding to the request type (step 59 in FIG. 5). At this branch destination, the process defined by "ac2 (argb)" in FIG. 6 is executed (step 60 in FIG. 5). In this way, the equivalence of states between a plurality of programs is guaranteed, and the cooperation definition source code 1 of FIG. 1 input by the language processor 4 of FIG.
Then, the logical equivalence of the generated program codes 5 and 6 for each of the programs A and B is guaranteed.

As described above with reference to FIGS. 1 to 6, in the language processor of this embodiment, the language processor 4
By using, it becomes possible to describe the complicated processing when linking between programs simply. That is, by using the language processor 4 to develop a program, it is possible to design and develop the program based on only the state transitions of the system without being aware of the difficult program communication processing of the distributed processing system. Along with this,
It is expected that the efficiency of program development work will be improved and the number of bugs created in the program will be reduced. Further, since the related processing between a plurality of programs can be described as one source code, the source code can be efficiently maintained and managed.

The present invention is not limited to the embodiment described with reference to FIGS. 1 to 6, and can be variously modified without departing from the gist thereof. For example, although the distributed processing system including the two programs A and B has been described as an example in the present embodiment, the present invention can be applied to a system including two or more programs.

[0029]

According to the present invention, the source code for executing the communication process in each program can be generated from the source code in which the specifications of the cooperative process between the programs in the distributed processing system are described. It is not necessary to describe the specifications of each program independently, including the synchronization between the programs forming the processing system and the protocol, and it is possible to improve the software productivity of the distributed processing system.

[Brief description of drawings]

FIG. 1 is a block diagram showing an embodiment of a configuration according to the present invention of a program development device of the present invention.

FIG. 2 is an explanatory diagram showing a configuration example of a state transition table showing the operation of the entire distributed processing system for which a program is developed.

FIG. 3 is an explanatory diagram showing an example of a source code in FIG.

FIG. 4 is an explanatory diagram showing an example of a procedure for generating a program code from a source code by the language processor in FIG.

5 is an explanatory diagram showing a structural example of a function generated by the language processor in FIG.

6 is an explanatory diagram showing an example of program code generated by a language processor in FIG. 1. FIG.

[Explanation of symbols]

1: Coordination definition source code, 1a: Declaration part, 1b: Definition part, 2, 3: Unique processing source code, 4: Language processor, 5, 6: Program code, 7, 8: Compiler
Linker, 9: Program A load module, 10:
Load module of program B, 20: state transition table,
21: event, 22: state, 23: processing to be executed, 4
1: route table, 42a, 42b: event list table, 43a-43d: status list table, 44a-44h: process definition table, 45a, 45
b: Action list table.

Claims (1)

[Claims] 1. A development device for a program of a distributed processing system, wherein a plurality of information processing devices cooperate with each other to perform a single process, and between the programs of each of the information processing devices that can occur in the distributed processing system. Corresponding to each event that requires cooperation with each other, according to the activation state of each program when the event occurs, the process to be executed, the program to execute the process, and the activity of the program after the process is executed. Based on the source code in which the processing instruction information including at least the state change instruction is described, if the program for executing the above processing is the own program for each individual program and each event and active state of the program, the execution is performed. If the program that executes the above process is another program, the program code that executes the process In another program to be executed, generate a program code requesting the execution of the process to be executed, and if there is an instruction to change the active state of the program after executing the process, the active state of the own program,
And, generate a program code to change the program state of other programs, for each of the above programs,
It receives a processing request from another program for processing to be executed by its own program, generates a program code for executing the processing corresponding to the received processing request, and generates a source program of each communication processing routine for each program. From the first language processor, the source program of each communication processing routine for each program generated by the first language processor, and each source program describing the processing unique to each of the programs, A program development device, comprising: a second language processor for generating an object program.