JPH02130631A - Unification and separating system for soft module - Google Patents

Abstract

PURPOSE:To improve soft productivity by updating the module constitution of a whole soft system each time respective soft modules are prepared and executing the design and development of the soft module. CONSTITUTION:When the internal processing of the soft module, for which input/output data are determined, is designed, the matching of the contents of message data is checked between the soft module and the already prepared module each time the soft module is prepared. Next, the possibility of matching and separation for the message data is displayed and relation between the soft module, which prepares the message data, and the soft module to use the message data is checked. Then, by displaying the possibility of unification and separation for the soft module, the number of the message data, which constitute the whole distributed soft system, and soft modules can be arbitrarily adjusted.

Description

[Detailed Description of the Invention] [Field of Industrial Application] The present invention relates to a software module integration/separation method for providing programming support when software modules are developed in a distributed manner, and in particular relates to a system for integrating and separating software modules to provide programming support when software modules are developed in a distributed manner. Create a program by designing the processing section using
The module configuration of the entire system is related to the integration and separation method of software modules, which will be done later.

[Prior art]

In conventional software development methods, the module configuration of the entire software system was first determined, and then, using that configuration as a prerequisite, the internal processing of each software module was designed and programmed according to the order of operation.

Therefore, if even part of the module configuration of the entire software system has not been determined, it is not possible to start designing or developing individual software modules.

Further, if a change occurs during the design or development of a software module, it may affect the module configuration of the entire software system and may require changes to the developed software module.

For this reason, a method was adopted in which individual software modules were created in order according to the startup control flow, from upstream to downstream, or from downstream to upstream, where changes would have an impact. . With this method, it was not possible to design and program each software module independently and in parallel.

Note that related devices of this type include, for example, Japanese Patent Application Laid-Open No. 61-208540.

[Problem to be solved by the invention]

In the above conventional technology, the entire software system configuration is determined,
With this as a prerequisite, we perform a top-down design that divides into modules, and create programs sequentially according to the control flow.

For this reason, independent and parallel software design and development for each module in a distributed computer system has been difficult, making it difficult to improve software productivity.

The purpose of the present invention is to improve these problems.

By designing and developing each software module independently and in parallel, and updating the module configuration of the entire software system each time each software module is created, we can improve software productivity by performing bottom-up design and development. The purpose of this invention is to provide a software module integration and separation method that improves the performance of software modules.

[Means to solve the problem]

In order to achieve the above object, the software module integration and separation method of the present invention is applied to a distributed software system consisting of a plurality of software modules connected by exchanging message data, in which input/output data is internal to a determined software module. When designing a process, each time a soft module is created, it is possible to integrate and separate message data by checking the consistency of message data between that soft module and previously created soft modules. In addition to displaying the message data, it also checks the relationship between the software module that creates the message data and the software module that uses the message data.
Rough 1 - A feature is that the number of message data and software modules constituting the entire distributed software system can be arbitrarily adjusted by displaying the possibility of integrating and separating modules.

In addition, when integrating the above software modules, among the output data of the software modules before integration, the output data that will not be sent outside the processing device in which the integrated software modules are stored must be registered in the table (transmission suppression content code table). , when running a program composed from soft modules after their integration.

The feature is that only self-reception processing is performed on registered output data.

In addition, when configuring a program by integrating the above software modules, the input processing part, arithmetic processing part, and output processing part of the software module program before integration are collected to form the input processing part of one program code, It is characterized by having an arithmetic processing part and an output processing part.

[Operation] In the present invention, the contents of message data can be collated and if there is an inclusion relationship, they can be integrated.

That is, since the integrated message data includes the content before integration, and the input/output data of the software module is secured, the number of message data is reduced in the system as a whole, and the number of modules remains unchanged.

Furthermore, message data can also be separated from this inclusion relationship. Since the input/output data of the software module can be secured by using any of the separated message data alone or by combining them, the number of message data increases in the system as a whole, and the number of modules remains unchanged.

Furthermore, the corresponding software modules can be integrated in relation to the creation and use of message data.

That is, if there is only one software module that creates message data and only one software module that uses it, the creation module and the usage module can be combined into one software module.

In this case, since the corresponding message data is reduced, the number of message data and the number of modules are reduced in the system as a whole.

Furthermore, even if there are multiple software modules that use the same message data, they can be integrated.

In this case, the number of message data in the entire system remains the same, but the number of modules decreases.

Moreover, when restoring a previously integrated software module, the software module is separated.

In this way, by integrating and separating the software modules and message data that make up the system, it is possible to intentionally change the overall structure of the program.

〔Example〕

An embodiment of the present invention will be described below with reference to the drawings.

FIG. 2 is a functional configuration diagram of the program design support system according to the first embodiment of the present invention.

In FIG. 2, 1 is a processing device, 2 is a content code table, 3 is a module table, 4 is a data item table, 5 is an integrated history table, 6 is a definition input program, and 7
8 is a module configuration check program, and 8 is a module configuration update program.

9 is a processing unit storage area.

This processing unit storage area 9 stores programs for processing procedures of modules.

FIG. 3 is an explanatory diagram showing the structure of the content code table shown in FIG. 2.

In FIG. 3, 21 is a content code, 22 is the number of data items, and 23 is a data item name.

This content code 21 indicates the content of message data input/output by each software module, and the number of data items is 22.
This is for identifying the corresponding data item names 23 as a whole. Further, this format is repeated for each content code 21.

FIG. 4 is an explanatory diagram showing the structure of the module table 3 of FIG. 2, and shows the structure of a format that is repeated for each module.

In FIG. 4, 31 is the number of input content codes, 32 is the input content code, 33 is the number of output content codes, 34 is the output content code, 35 is the number of input data items, 36 is the input data item name, and 37 is the output data item. number, 38 is the output data item name, 39 is the module name, 40 is the processing unit storage address,
41 is the length of the processing section.

In this embodiment, the processing section of the software module indicated by the module name 39 is located from the processing section storage address 40 to the processing section length 4.
Stored in 1 byte.

In addition, there are 31 input content codes 32 required as inputs to the software module, and 33 output content codes 34 as outputs. These input content code 32 and output content code 3
4 indicates the data specifications of the message data.

The premise of the processing of this software module is a data group represented by an input data item name 36 of 35 input data items and an output data item name 38 of 37 output data items.

FIG. 5 is an explanatory diagram showing the structure of the data item table 4 of FIG. 2.

The data item table 4 of this embodiment shows the contents of each data item 23 of the content code table 2 shown in FIG.
It is composed of a data unit length 42, number of array elements 43, data code 44, and presence/absence of sign 45 indicating the attributes of the data item name 23, and these are repeated for each data item name 23.

FIG. 6 is an explanatory diagram showing the structure of the integrated history table 5 of FIG. 2.

In FIG. 6, 51 is the name of the module before integration, and 52 is the name of the module after integration.

In this embodiment, the pre-integration module name 51 and the post-integration module name 52 are set as a pair, and the corresponding data in the module table 3 for the pre-integration module is saved and used when canceling the integration and returning to the pre-integration state. .

FIG. 7 is a processing flowchart of the definition input program 6 shown in FIG.

In this embodiment, when defining input/output data in a software module, the content code 21 including the input/output data item name 36, 38 input according to the module unit format of the module table 3 is searched for (701).

Specifically, the content code table 2 shown in FIG. 3 is searched using each of the input data item names 36 shown in FIG. 4 as a key.

As a result, if there is no match for that key, a new content code 21 is determined, and data is created by pairing it with the data item name 23 belonging to that content code 21 and registering it in the content code table 2 (702). .

Furthermore, if the data item name 23 is not in the data item table 4 of FIG. The data is registered in the item table 4 (704).

Next, data item name 2 belonging to these content codes 21
3 and the input/output data item names 36 and 38, the validity of the inclusion relationship is checked (705). In addition.

Whether input/output data item name 36.38 is included in data item name 23 belonging to content code 21, data unit length 41, number of array elements 42, data code 4
3. Presence of sign 44 The rationality check is to check whether there is any difference in the attributes of the data.

If this rationality check is OK, each of the content code table 2, module table 3, and data item table 4 is updated (706).

FIG. 1 is a processing flowchart of the module configuration check program 7 shown in FIG.

In this embodiment, in the content code table 2, the data item names 23 belonging to the content codes 21 are compared with each other to check the inclusion relationship (101).

For example, if the data item name 23 is an element of a set and the content code 21 is a set base, if a union relationship is established, there is a possibility that these content codes 21 can be integrated into the content code of the union.

Further, if there is a subset relationship between the content codes 21 with the data item name 23 as an element, the content code forming the subset can be integrated with the other content code.

Thus, if there is an integration possibility (102), the content of the integration possibility is displayed on the CRT (103).

Next, the content code separation is checked (104).

In other words, if a union relationship is established in a set whose elements are data item names 23 between content codes 21, it can be separated into a sum of subsets.

The content of this separability is displayed on the CRT (105,
106).

Next, check the possibility of module integration (107
).

In this case, in the module table 3, if all of the output content codes 34 of a certain software module are all of the input content codes 32 of another software module,
Both software modules may be integrated.

Furthermore, this possibility of module integration is displayed on a CRT (108, 109).

Next, a module integration release check is performed (110).

Note that module unintegration, that is, separation of software modules, means returning the integrated software modules to their original state.

Therefore, if there is a possibility of module unintegration (
111), and displays the contents of the integrated history table 5 on the CRT (112).

FIG. 8 is a processing flowchart of the module configuration update program 8 of FIG.

In this embodiment, when changing the configuration of a created software module, it is first determined whether the content codes 21 are to be integrated or separated (801).

That is, if the content code 21 is the target, it is confirmed whether it is integrated or separated (802), and the content code table 2 is updated according to the content (803, 804).

Also, if the target is a software module (801
), if it is integration (805), the module table 3 is updated (807), and the contents of the software module before integration are saved in the integration history table 5 (808).

If it is separated (unintegrated) (805), the corresponding data is moved from the integration history table 5 to the module table 3 and restored (806).

FIG. 9 is a functional configuration diagram of a program design support system according to a second embodiment of the present invention.

In FIG. 9, 10 is a sending suppression program, 11 is an interface for transmitting and receiving data with other computers, and 1
2 is a module integrated editing program, 13 is a transmission suppression content code table, and 14 is a transmission path, and the other tables and programs are the same as in the first embodiment (FIG. 2).

In this embodiment, if the software module integration conditions are satisfied in steps 107 to 109 in FIG. 1, module integration is realized during program execution, and program integration is performed by module integration.

FIG. 10 shows the transmission suppression content code table 13 in FIG.
FIG. 2 is an explanatory diagram showing the configuration of.

In this embodiment, the transmission suppression content code table 13 stores the content code output by the software module as the transmission suppression content code 61 when the software module performs self-reception processing without outputting the content code to another computer. When the data of the content code registered in the transmission suppression content code table 13 is output, the interface 11 is instructed to perform self-reception processing.

FIG. 11 is an explanatory diagram showing module integration during program execution in the second embodiment of the present invention.

In this embodiment, the pre-integration module P71 has a content code S
This module inputs the data of 73 and outputs the content code m75 and content code n76. In addition, the pre-integration module Q72 has a content code n75 and a content code m7.
6 is input, and content code t74 is output.

In this case, when the module integration conditions are satisfied in steps 107 to 109 in FIG. Post-integration module P that outputs code t74
It is realized at the time of execution so that Q70 is obtained.

FIG. 12 is a processing flowchart of the sending suppression program 10 of FIG. 9.

In this embodiment, if the module integration conditions are satisfied in steps 107 to 109 in FIG.
1).

As a result, if the corresponding content code is not registered (1
202), instructs the interface 11 to send the content code to another computer via the transmission path 14 (
1203).

Furthermore, if the corresponding content code is registered, it will not be sent to the outside.

FIG. 13 is a flowchart showing the processing of the interface 11 of FIG.

In this embodiment, if there is a sending instruction from the sending suppression program 10 (1301, 1302), data to be sent by the interface 11 is sent to the outside via the transmission path 14 (1303).

Also, unless there is a transmission instruction, the data will not be transmitted to the outside.

Thereafter, the corresponding data is processed as its own received data (1304).

As a result, the pre-integration module P71 in FIG. 11 outputs the content code m75 and content code n76, but they are not sent to other computers and are received only by the pre-integration module Q72.

Therefore, from other computers, only the post-integration module PQ70 that inputs the content code s73 and outputs the content code t74 is recognized, but the pre-integration module P71 and the pre-integration module Q72 are not recognized.

FIG. 14 is an explanatory diagram showing program integrated editing in the second embodiment of the present invention, and FIG. 15 is a processing flowchart of the module integrated editing program of FIG. 9.

FIG. 14(a) shows the module inclusion relationship before and after integration.

In this case, module A82 before integration has content code P84.
input the data and output the content code q85. Further, the pre-integration module B83 inputs the data of the content code P84 and outputs the content code r86.

By integrating these modules, the integrated module AB81 inputs the data of the content code p84 and outputs the content code q85 and the content code r86.

Moreover, (b) shows an example of a program before and after integration when a program is edited by integrating the pre-integration module A82 and the pre-integration module B83 in (a).

When configuring the software module (a) as a program, the module integration editing program 12 uses the input section A92 that configures the pre-integration module A program 98.
, module A processing 93, and output section A94 are respectively integrated with input section 95, module B processing 96, and output section B97 that constitute module B program 99 before integration.

In other words, as shown in FIG. 15, by integrating the command section (1501) of the input section, integrating the processing section (1502), and integrating the output section (1503), the integrated module has a simple configuration. Edit AB program 91.

〔Effect of the invention〕

According to the present invention, it is possible to independently process and design each software module for which input/output data has been determined, and update the overall system configuration while programming. This enables parallel production of modules and increases software productivity. Improve.

[Brief explanation of the drawing]

FIG. 1 is a processing flowchart of the module configuration check program in the first embodiment of the present invention, FIG. 2 is a functional configuration diagram of the program design support system in the first embodiment of the present invention, and FIG. FIG. 4 is an explanatory diagram showing the structure of the content code table in FIG. 2, FIG. 5 is an explanatory diagram showing the structure of the data item table in FIG. 2, and FIG. An explanatory diagram showing the structure of the integrated history table in Fig. 2, Fig. 7 is a processing flowchart of the definition input program in Fig. 2, Fig. 8 is a processing flowchart of the module configuration update program in Fig. 2, and Fig. 9 is a processing flowchart of the module configuration update program in Fig. 2. A functional configuration diagram of the program design support system in the second embodiment of the invention, FIG. 10 is an explanatory diagram showing the configuration of the sending suppression content code table in FIG. 9, and FIG. 11 is a functional configuration diagram of the program design support system in the second embodiment of the invention. An explanatory diagram showing module integration during program execution; FIG. 12 is a processing flowchart of the sending suppression program in FIG. 9; FIG. 13 is a flowchart showing the interface processing in FIG. 9;
This figure is an explanatory diagram showing program integrated editing in the second embodiment of the present invention, and FIG. 15 is a processing flowchart 1 to 1 of the module integrated editing program of FIG. 9. 1: Processing device, 2: Content code table, 3: Module table, 4 data item table. 5: Integrated history table, 6: Definition input program. 7: Module configuration check program, 8: Module configuration update program, 9: Processing unit storage area, 10:
Sending suppression program, 11: Ink face, 12: Module integrated editing program. 13: Sending suppression content code table, 14: Transmission path. 2]: Content code, 22: Number of data items, 23: Arter item name, 31: Number of input content codes, 32: Input content code, 33: Number of output content codes, 34: Output content code,
35: Number of input data items, 36 Two-person data item name, 3
7: Number of output data items, 38: Output data item name, 39
: Module name, 40: Processing unit storage address, 41: Processing unit length, 42: Data unit length, 43: Number of array elements, 4
4: Data code, 45: Sign presence/absence, 51: [Pre-module name. 52: Post-integration module name, 61: Sending suppression content code, 70: Post-integration module PQ, 71: Pre-integration module P, 72: Pre-integration module Q. 73: Content code S, 74: Content code t, 75: Content code m, 76: Content code n, 81: Module AB after integration, 82: Module A before integration. 83: Module B before integration, 84.: Content code p. 85: Content code q, 86: Content code r, 91: Module AB program after integration, 92: Input part A, 93
: Module A processing, 94: Output section A. 95: Input section B, 96: Module B processing, 97: Output section B, 98: Module A program before integration. 99: Module B program before integration. Patent applicant: Hitachi, Ltd.

Claims (1)

[Claims] 1. In a distributed software system composed of a plurality of software modules connected by exchanging message data, when designing the internal processing of a software module whose input/output data is determined, the software module Each time it is created, it checks the content consistency of the message data between this soft module and the already created software modules, displays the possibility of merging and separating the message data, and By checking the relationship between the software module to be created and the software module that uses the message data, and displaying the possibility of integrating and separating the software modules, the message data and software modules that make up the entire distributed software system can be checked. A software module integration/separation method characterized by arbitrarily adjusting the number of software modules. 2. When integrating the above software modules, among the output data of the software modules before integration, output data that will not be sent outside the processing device where the integrated software module is stored is registered in the table, and the output data from the integrated software module is registered in the table. 2. The software module integration and separation method according to claim 1, wherein only self-receiving processing is performed on registered output data when the configured program is executed. 3. When editing a program by integrating the above software modules, collect the input processing part, arithmetic processing part, and output processing part in the software module program before integration, and edit the input processing part of one program code,
2. The software module integration/separation method according to claim 1, wherein the software module has an arithmetic processing section and an output processing section.