JP3259682B2 - Program processing device - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program processing apparatus, and more particularly, to a program processing apparatus which sequentially reads a source program and compiles and executes the program almost simultaneously.

[0002]

2. Description of the Related Art Conventionally, in a source program execution processing method, a compiler that compiles, links, and executes all source programs of a source program before executing the source program, and an interpreter that executes the source program while interpreting the source program are well known. Have been.

On the other hand, recently, an intermediate method between the compiler and the interpreter has been proposed (for example, Japanese Patent Application Laid-Open No. 9-282174). In this method, source codes required for executing a source program are sequentially read, and compilation and execution are performed almost simultaneously in parallel.

[0004]

However, according to the invention disclosed in Japanese Patent Application Laid-Open No. 9-282174, the number of executable codes increases and the size of an executable file becomes excessive, or the load itself increases. As a result of the heavy load on the hardware of the computer system that processes the source program, the processing may be stopped,
Source program processing may not be smooth.

SUMMARY OF THE INVENTION The present invention has been made in view of the above circumstances, and monitors and controls the use state of hardware when sequentially reading a source program, compiling and executing the program in parallel, and smoothly executing the source program. An object of the present invention is to provide a program processing device that can be executed.

[0006]

According to a first aspect of the present invention, there is provided a program processing apparatus for converting a source program including a plurality of components into machine code and executing the source code. After compiling and executing the source program up to the position of the included function, obtain the component to which the function belongs and the component dependent on the function, compile and link the part necessary for executing the function, A computer system to be re-executed, connected to the computer system via a bus, storing a component to which the function included in the source program belongs and a component that depends on the function, and belonging to the function according to a request of the computer system Component and this function A program processing apparatus having a database providing a component that is dependent on the computer system, said computer cis
The hardware in the computer system.
A means for monitoring the load history of the
Means for storing the load history reported from the viewing means,
The load is large based on the function reception time and the load history.
Estimating means for estimating a function; and a load state of the hardware.
State and the presence of a function with a large load causes an overload condition
Determining means for predicting that the information from the determining means
Receiving the database from the computer system.
Component to which the function belongs and the function
Suspends demands on dependent components and increases load
Reclaim component when state is removed
Load control means, and the load status of the hardware in the self
It is constituted with a load monitoring controller that monitors and controls the state.

[0007]

[0008]

[0009]

[0010]

According to the invention having such a configuration, a function having a large load is estimated in advance, and the received function matches the estimated function with a large load, and the function reduces the hardware load by a predetermined value. Since the increase can be predicted in advance, it is possible for the computer system to determine and perform processing according to the usage status of the hardware.

According to a second aspect of the present invention, there is provided the program processing device, wherein the load monitoring control device determines that the hardware of the computer system is in an overloaded state.
The unprocessed component received from the database is discarded, and a re-request signal for the discarded component is created and stored.

According to the invention having such a configuration, the load on the hardware of the computer system can be reduced and the source program can be smoothly executed.

According to a third aspect of the present invention, the computer system converts the plurality of different source programs into machine codes in parallel.

According to the invention having such a configuration, in the program processing in which the source program is sequentially read, and the compilation and the execution are performed in parallel, the execution needs to be temporarily interrupted every time the function is inquired to the database. Even in this case, by performing multiple program processes in parallel,
Since another program can be processed while the processing of one program is interrupted, the overall processing speed is improved.

A program processing apparatus according to claim 4 , wherein the computer system manages a dependency relationship between components of the source program for each source program, and saves the change of the dependency relationship only on the computer system. It is provided with a dependency information table, and after executing all of the source programs, the component dependency information table can be reflected in the database.

According to the invention having such a configuration, the component dependency recorded in the computer system can be reflected in the database when the execution of the program processing is completed, so that the component dependency of the database is sequentially changed. The hardware load is smaller than in the case.

[0018]

DESCRIPTION OF THE PREFERRED EMBODIMENTS One embodiment of a program processing device according to the present invention will be described below with reference to the drawings. 1 and 2 are configuration diagrams showing a program processing device according to an embodiment of the present invention. The program processing device 1 is configured to execute a plurality of different source programs (pr
og1, prog2, prog3) in parallel with the server 2, which is a computer system, and function components (A, B, C, D, E,.
.) Is a network connected by a bus 4.

Although not shown, the server 2 has a compile for converting a source code into an object code, and a linker for linking the converted object code to produce an executable machine code. It also has a function inquiry queue for storing a function inquiry frame for inquiring a function in the database 3 and a database transfer data queue for storing a database transfer data frame transferred from the database 3. The server 2 has, for each source program, a component dependency relationship information table 10 that stores a relationship between a function, a component to which the function belongs, and a component that depends on the function, and manages the relationship for each source program. Further, it has a component search function for searching the component dependency relationship information table. Further, it has a storage unit 11 for storing components obtained from the database 3.

The source program executed by the server 2 is
All include functions stored in the database 3. The server 2 compiles and executes the source program up to the position of the function, suspends the temporary processing here, and stores the function in the component dependency information table 1 in the server 2.
0 and if the function is described here,
Compile and link as many as necessary to execute the function from the component to which the function belongs, and resume execution. When the function is not described in the component dependency information table 10, the function is inquired to the database 3.

The database 3 has a component dependency information table which can be registered by the server 2 for each program, and selects one data dependency. In this case, the user can designate the component-dependent table required for the previous execution by the program index, and can register and delete the table in the database. When the program is executed when there are no components that can be registered at the time of executing the program (that is, only the data of the component and the function), the number of inquiries between the server and the database is large. It is preferable to reduce the number of inquiries. In response to the function inquiry from the server 2, the component to which the function belongs and the component which depends on the function at this time are transferred to the server based on the selected dependency. The server 2 compiles and links a part necessary for the function of one or more components passed from the database 3 and resumes execution.

In the database 3, as shown in FIG. 2, in order to reduce the transfer amount of the entire data, the transferred components are marked with a transferred mark S, and only the other components can be transferred. Has become. When the component search function of the server 2 fails, the same component is requested to the database each time the component search function is executed and the data transfer is performed. As a result, the load on the disk increases, but the number of times of the data transfer is limited. This prevents overload.

FIG. 3 shows a specific example of the component dependency information table on the server 2. As shown in FIG. 3, the component dependency relationship information table associates a function index, a function name, a component to which the function belongs, and a component that depends on the function. The function index becomes necessary when the number of functions stored in the database increases and it becomes necessary to search for a target function, and is provided by the database.

The server 2 stores the components transferred from the database 3 in the storage means 11 and determines the dependency between the components on the function changed at the time of execution.
Store to 0.

Since the components are successively transferred from the database 3 and the source programs are sequentially compiled, the machine code increases and the processing increases accordingly. In the present invention, the hardware resources of the server 2 are monitored. The server 2 is provided with a load monitoring control device 5 for controlling. The load monitoring control device 5 acquires the component information to which the function transferred from the database 3 belongs, measures the hardware usage of the server 2 regarding compiling, linking, and execution, and analyzes these to analyze the function. Is sent to the database, and whether data including components is transferred from the database is determined, and control is performed to reduce the hardware load.

FIG. 6 is a block diagram showing the configuration of the load monitoring and control device 5. The load monitoring control device 5 measures a disk usage measuring unit 51 for measuring disk usage, a memory usage measuring unit 52 for measuring memory usage, and a CPU usage rate for the server hardware 21. The monitoring application 54 is connected to the monitoring application 54 via the CPU usage rate measuring unit 53, and the monitoring application 54 monitors the resource usage of the hardware 21 at regular intervals. The information of the monitoring application 54 is sent to the load detection processing unit 6. The information on the function transferred from the database 3 is passed from the hardware 21 of the server 2 to the database transfer data analysis unit 55.

After extracting necessary information, the database transfer data analysis unit 55 passes information on the function to the load detection processing unit 6. The load detection processing unit 6 creates data by combining an appropriate part of the data transferred from the received database and the hardware resource consumption information of the server, judges from this data, and inquires of the database about a function. Determine whether to do so or whether to receive the component from the database.

FIG. 7 is a block diagram showing the configuration of the load detection processing unit 6. The load detection processing unit 6 includes a load information storage unit 61, a load determination unit 62, and a load control unit 63.

FIG. 8 is a block diagram showing the configuration of the load information storage unit 61. The load information storage unit 61 includes a load history storage unit 611 that stores data reported from the monitoring application 54 that monitors the consumption status of the hardware resources of the server, and a function based on the transfer data passed from the database transfer data analysis unit 55. A database transmission record storage unit 612 for storing data obtained by extracting components to which names and functions belong, and load history data transmitted from the load history storage unit 611 and editing transmitted from the database transmission record storage unit 612 And a load data synthesizing unit 613 for synthesizing data.

FIG. 9 is a block diagram showing a configuration of the load determining section 62 shown in FIG. The load determining unit 62 includes a load cause estimating unit 621 that determines the cause of the increase in load from the composite data indicating the relationship between the called function and the load created by the load information storage unit 61, Load cause storage means 613 for storing as a function list
And load control determining means 623 for determining whether to control access to the database of the server.

FIG. 10 is a block diagram showing the configuration of the load control unit 63. The load control unit 63 includes a load determination unit 6
2 includes a load control sensing unit 631 for finding a flag issued when load control is required, and a load control execution unit 632 for actually controlling access to the database 3 of the server 2. Load control execution means 632
Refers to the load cause function list stored in the load cause storage means 622 to predict that an overload will occur,
Or in response to the overload flag being issued,
It controls the function inquiry frame entered in the function inquiry queue for inquiring the function to the database and the database transfer data frame returned to the database transfer data queue.

The operation of the above-described program processing apparatus according to the present embodiment will be described. Server 2 shown in FIG.
Compiles and executes a plurality of different user programs in parallel.

These user programs are composed of a plurality of components, and these components include functions. When the server 2 encounters these functions at the time of a source program execution instruction, the server 2 first checks the component dependency information table 10 managed for each source program in the server 2. If the function does not exist in the component dependence information table 10, the function inquiry queue inquires the database 3 of the function from the function inquiry queue. On the database 3 side, the component dependency information table specified by the user from the program index examines the component to which this function belongs and the component which is dependent on this function at this time, and transfers this to the server 2 by a database transfer frame. . The server 2 acquires this from the database transfer data queue.

When the server 2 acquires the component to which the function belongs, the function compiles the source code required for the execution and links the object program of the user program processed up to that time. Try again.

For example, as shown in FIG. 4, when the user program prog1 is compiled and the function func1 is encountered, an inquiry is made to the database, and the component dependency information table of the database shows the belonging component A and the function fu.
The component that depends on nc1 forwards B and C to the server, which in turn sends these components A, B, C
And compile, link, and re-run the necessary parts. Then, a component dependency information table for the function is newly created or updated.

In particular, the server 2 uses this component if it exists on the server when a component that depends on the function changes during execution compared to the previous process. If it does not exist, the database 3 is requested for this component.

For example, as shown in FIG. 5, the function func2 ()
Has the components A and C as dependencies when it was called last time, but it is assumed that the dependency of this function has changed for some reason thereafter. Function fu
When nc2 () is called for the first time, an attempt is made to compile and link from the dependent components A and C based on the component dependency information table on the server 2, but the component required for execution cannot be found. Therefore, when the database 3 is inquired about a function, the database 3 transfers information that the components A and X are components necessary for execution and the component X to the server. After receiving these, the server 2 compiles, links, and executes the function, and further updates the component dependency information table. The above is a case where the component X does not exist on the server 2. However, when the component X exists on the server 2, there is no need to transfer the component X.

In the present embodiment, during the execution of a program, only the component dependency information table 10 on the server 2 is changed, and the dependency between the components managed by the server 2 is changed. The relation information table 10 is not changed, and the user can reflect this in the database 3 after the program ends.

That is, after the program is completed, there is provided a means for displaying the dependency added or corrected in the course of processing and allowing the user to select whether or not to permit the change of the dependency. Is provided.

All of these changes in the dependency are temporarily stored on the server 2 that has executed the program. If the change of the dependency is permitted, the dependency is updated and then stored. I do. If not, the change of the dependency is deleted and the dependency before the change is returned. Permission and non-permission for changing these dependencies can be set by default values from the user (server) side. If you allow a dependency change, the server notifies the database of the change. In response to the change of the dependency notified from the server, the database updates the dependency by exclusive processing. As a result, inquiries about functions in the source program to be executed thereafter are made based on this dependency.

According to the present invention, there is a problem in such a program processing apparatus that processes two or more source programs in parallel, that is, the number of executable codes increases, the size of an executable file becomes excessive, or the load itself increases. If it is too long, the processing is stopped and the load monitoring control device 5 is provided in the server 2 in order to solve the problem that the source program processing may not proceed smoothly. Hereinafter, a method of determining the load on the hardware of the server by the load monitoring control device and a process of restricting an inquiry to the database will be described.

The monitoring application 54 includes a disk usage measuring unit 51, a memory usage measuring unit 52, a CPU
The usage resource measuring unit 53 monitors the hardware resources 5 of the server at regular intervals. The load history storage unit 611 of the load detection processing unit 6 receiving this information manages a table as shown in FIG. 11 based on the information at that time. As shown in FIG. 11, this table records, for example, a CPU usage rate, a memory usage rate, and a disk usage rate at a certain time, and is managed by the load history storage unit 611 as a load history list.

On the other hand, the data transferred from the database 3 is processed as follows. The hardware 21 of the server 2 converts the component information transferred from the database 3 to the database transfer data analysis unit 5
The database transfer data analysis unit 55 edits this information as shown in FIG. The edited transfer data table describes, for example, the name of the function transferred at the time of reception by the server, the name of the component to which the function belongs, and the name of the component dependent on the function, and is stored in the database transmission record holding unit 612. I do.

As shown in FIG. 13, the load data synthesizing unit 613 converts the edited transfer data table from the database transmission record holding unit 612 from the load history list closest to the edited time from the load history storage unit 611. Combine with history. The data created in this way is sent to the load determination unit 62.

In the load judgment section 62, the load cause estimating means 6
21 scans the load history list to which the edited transfer data synthesized by the load data synthesis unit 613 is linked, finds a location close to the limit increase rate of the load set by the monitoring application, and indicates a flag representing the cause. For example, a flag of a memory load sudden increase is set, and a transfer data table linked to the load history list is searched for a predetermined time before this.

For example, as shown in FIG. 14, the transfer data table when the memory usage rate rises sharply is searched to estimate the function that caused the transfer data table. If there is no characteristic function, a method is used in which a plurality of functions executed up to a predetermined time before are regarded as functions having a large load. If the function that caused the load can be identified, it is registered in the load cause function list. The load cause estimating unit 621 registers the load cause function list in the load cause storage unit 622. As shown in FIG. 15, the elements of the load cause function list include, for example, a function name for increasing any one of the CPU usage rate, the memory usage rate, and the disk usage rate at a certain rate or more, an index of the function, and a function. The name of the component to which it belongs and the load on the hardware.

The load determining unit 62 directly receives the disk usage rate, the memory usage rate,
Information on the PU usage rate is acquired at regular intervals, and it is determined whether any of these hardware resources is excessively used. When it is determined that it is being used excessively, an overload flag is set.

The load control sensing means 631 of the load control unit 63
Confirms that the excess load flag is set, and notifies the load control execution means 632 that the excess load flag is set. The load control execution unit 632 suspends inquiries to all the databases 3 while the information indicating that the overload flag is on is notified. Also,
As shown in FIG. 16, when there is a data transfer from the database, it is taken out, the component is deleted and invalidated, a function inquiry frame of this function is created again, and this is added to the head of the function inquiry queue. . If there is a subsequent one, the function inquiry frame is inserted sequentially from the beginning in that order. Thereby, the server 2
When the load of the hardware 21 is large, control can be performed to reduce the load. When the load on the hardware 21 decreases, the overload flag is released, the function inquiry frame inserted from the function inquiry queue is sent to the database 3, and the acquisition of the function from the database 3 is started.

Further, in this embodiment, even when the overload flag is not set, the load judgment unit 62 probes the load cause function list managed in the load cause storage unit 622 at regular time intervals, and reads the load cause function list. It is checked whether the function name (or function index) in the function list matches the function name recorded in the inquiry queue or the reception queue for the database 3. If they match, a load increase due to the processing caused by these factors is added to the current load status, and if it is determined that the load is over the area where the overload flag is set, a quasi-load control flag is set.

FIG. 17A shows the load control execution means 632.
The function inquiry frame is moved to the end of the function inquiry queue to hold the inquiry of these functions as shown in FIG. If there is only this function inquiry frame, the transfer of this frame is suspended until the semi-load control flag is cleared.

As shown in FIG. 17B, when there is a transfer from the database, the component is deleted to invalidate the data portion, a function inquiry frame of the function is created, and the inquiry queue of the inquiry queue is created. Insert this frame at the end. As a result, it is possible to prevent an excessive load on the hardware of the server, and to smoothly execute the source program processing.

According to the program processing device of this embodiment, the server compiles and executes a plurality of different user programs in parallel. As a result, the processing of another source program can be performed at the time of the function inquiry, and the overall processing time is reduced. In the present embodiment, only the server is illustrated, but in reality, a client-server system is generally used. In this case, a plurality of clients execute programs simultaneously.

As a result of querying the database for a function present in the source program, the server loads all the components to which the function belongs and the components which are dependent on the function, and compiles it.
It is possible to link and execute, change the dependencies between components that may occur at that time only on the server, and leave the decision on whether to reflect the corrected dependencies to the database after the source program ends. It is possible to build a flexible programming environment.

Further, since a component dependency information table for managing component dependencies in units of user source programs executed on the server is provided,
The changed component dependencies do not affect other running source programs.

In addition, as for the components on the database, a plurality of users can share and use these components if their dependencies have not changed for a while.

Further, it is also possible to use such that the execution of the source program after the source program is required is kept consistent.

Further, when the processing of a plurality of source programs on the server consumes a considerable amount of hardware resources of the server, a function inquiry to the database is suspended or data transfer including a component from the database is performed. A load monitoring and control device that can disable and restart data transfer to reduce the load on the server, prevent the source program processing from being stopped, and facilitate multiple different source program processing. You can proceed to.

If the user mistakenly deletes a necessary component at the time of execution, in the above-described embodiment, the component with the mark of transferred is not transferred to the server. For this reason, it is necessary for the server to send frames to the database when starting and ending the execution of the program so that the database can recognize that the execution of the program has started. As a result, the server can detect that the corresponding component is not present on the server and transfer the component from the database.

In the present embodiment, the case where one server and one database are used has been described.
There may be a plurality of databases.

Further, in the present embodiment, the server processes a plurality of source programs. However, these source programs may be described by an editor of a client and executed by the server.

[0061]

According to the program processing device of the present invention,
When executing the source program, which sequentially reads the source code and compiles and executes the program almost simultaneously, it is possible to smoothly execute the source program.

[Brief description of the drawings]

FIG. 1 is a configuration diagram showing a schematic configuration of a program processing device of the present invention.

FIG. 2 is a conceptual diagram showing components owned by each of a server and a database.

FIG. 3 is a conceptual diagram showing component dependency information and a component dependency information table.

FIG. 4 is a conceptual diagram illustrating a component dependency information table of a server.

FIG. 5 is a conceptual diagram illustrating a component dependency relationship information table read by a server and a state where the server acquires a new component from a database when a change occurs thereafter.

FIG. 6 is a block diagram showing a configuration of a load monitoring control device according to the present invention.

FIG. 7 is a block diagram illustrating a configuration of a load detection processing unit of the load monitoring control device.

FIG. 8 is a block diagram illustrating a configuration of a load information storage unit of the load detection processing unit.

FIG. 9 is a block diagram illustrating a configuration of a load determination unit of the load detection processing unit.

FIG. 10 is a block diagram illustrating a configuration of a load control unit of the load detection processing unit.

FIG. 11 is a conceptual diagram showing a load history and a load history list created by a load history storage unit.

FIG. 12 is a conceptual diagram showing transfer data edited by a database transfer data analysis unit.

FIG. 13 is a conceptual diagram showing transfer data and a load history list synthesized by a data synthesizer.

FIG. 14 is a conceptual diagram showing a search by a load estimating unit.

FIG. 15 is a conceptual diagram showing elements of a load cause function list registered by a load cause storage unit.

FIG. 16 is a conceptual diagram showing a state in which a load control execution unit processes a frame transferred from a database in response to a notification from a load control sensing unit.

17A is a conceptual diagram showing a state in which a function inquiry frame is moved to the end of a function inquiry queue at the time of semi-load control, and FIG. 17B shows a state in which a frame transferred from a database is processed. FIG.

[Explanation of symbols]

 REFERENCE SIGNS LIST 1 program processing device 2 computer system (server) 21 hardware 3 database 4 bus 5 load monitoring and control device 54 monitoring application 6 load detection processing unit 61 load information storage unit 62 load determination unit 53 load control unit

Claims (4)

(57) [Claims] When converting a source program including a plurality of components into machine code and executing the same, the source program is compiled and executed up to a function position included in the source program, and then the component to which the function belongs is included. And a computer system that obtains the component dependent on this function, compiles, links, and re-executes a part necessary for executing the function, and is connected to the computer system via a bus, and A database for storing the component to which the included function belongs and the component depending on the function, and providing the component to which the function belongs and the component depending on the function to the computer system at the request of the computer system; A program processing apparatus comprising, the computer system, the hardware load in said computer system
Means for monitoring the history at regular time intervals, and means for storing the load history reported from the monitoring means
And the load history based on the reception time of the function and the load history.
Estimating means for estimating a threshold function; and a load state of the hardware and a function having a large load.
Determining means for predicting an overload condition from the presence of the computer system;
From the system to the database to which the function belongs.
Components and components that depend on this function
Request when the high load condition is released.
A load control means for re-requesting a component, and a load control means for monitoring and controlling the load state of the internal hardware.
A program processing device comprising a load monitoring control device. 2. The program processing device according to claim 1 , wherein said load monitoring and control device receives said unprocessed hardware from said database when said hardware of said computer system is overloaded. A program processing apparatus for discarding a component, creating and storing a re-request signal for the discarded component. 3. The program processing device according to claim 1 , wherein said computer system converts a plurality of different source programs into machine codes in parallel. 4. The program processing apparatus according to claim 1, 2 or 3, wherein the computer system to manage the dependencies between the components of the source program for each source program, the computer changes the dependencies A program processing apparatus comprising: a component dependency relationship information table stored only on a system, wherein after executing all of the source programs, the component dependency relationship information table can be reflected in the database.