JPH03100837A - Detection system for shared data access - Google Patents

Abstract

PURPOSE:To accurately observe the working of a user program and to improve the program debugging efficiency by displaying the access order of the shared variables used for processing the user programs working in parallel with each other. CONSTITUTION:An output source program 6 received from a pre-processor 2 is compiled, and an object program 8 is generated. When these programs are linked together, a library routine 3 of an access detecting part 1 for the shared data is set into a load module 10 via a linker 9. When the module 10 outputted from the linker 9 is executed, an access history file 11 is outputted concurrently with execution of a program. Then an access history display program 4 inputs the file 11 and outputs the access order relation of the shared variables to an access history list 13 based on a command received from an input device 12. Thus the working of a user program is accurately observed and the program debugging efficiency is improved.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to a shared data access detection method for detecting errors in exclusive control to be performed when accessing data shared between tasks.

[Conventional technology]

In a multiprocessor system, when the instruction code of a user program is divided into multiple tasks and each task is assigned to each processor of the multiprocessor to execute the parallel processing program, conventionally, the parallel processing program is When accessing data shared by multiple tasks, each task provided a lock variable for exclusive control processing. In other words, we use a lock procedure that waits until the lock is unlocked if it is already locked based on this lock variable, and then locks it after it is unlocked, and an unlock procedure that releases the lock that is already locked. When accessing shared data (also called shared variables), access is done during the lock-unlock procedure (lock section), and exclusive control processing is used to prevent simultaneous access by each task. It was carried out in the program.

[Problem to be solved by the invention]

In this way, when performing exclusive control processing in a user program, if a program error causes the program to forget to enter the lock section or call the unlock procedure at an incorrect position, each task may access the lock at the same time. This could cause problems such as incorrect program execution results or different results each time the program is executed. In this case, the user will not be able to know that a problem has occurred due to a bug in the exclusive control of shared variables, and even if the task is re-executed, the same result may not be obtained depending on the execution order of the tasks. The problem was that it took a lot of time to solve the problem. Also, when checking whether the lock interval of a shared variable is correct, it is necessary to manually examine the source program, consider the behavior between tasks, and check the order in which shared variables are accessed. However, depending on the size of the program, it requires a lot of effort, and if the access method is complicated, problems may be overlooked during investigation, resulting in poor program debugging efficiency.

The present invention improves these conventional drawbacks, and its purpose is to detect accesses to shared data that can accurately observe the behavior of user programs and improve program debugging efficiency. The goal is to provide a method.

[Means to solve the problem]

The shared data access detection method of the present invention includes a preprocessor that reads a user's source program and changes a source line where a shared variable access occurs to a call to a shared variable read and write access procedure;
A library means for processing the access procedure, an access history file for storing the history of the access procedure processing, and an access history display means for reading the access history file and displaying the order relationship in which arbitrary variables are accessed. It has

[For production]

The preprocessor reads the user's source program and changes the source line where shared variable access occurs to a call to an access procedure for reading and writing shared variables, and the library means processes the access means. At this time, the access history file stores a history such as the processing time and execution address of the access procedure, and the access history display means reads this access history file and displays the order relationship in which arbitrary variables are accessed. do.

〔Example〕

Hereinafter, one embodiment of the present invention will be described in detail with reference to the drawings.

FIG. 1 is a block diagram of one embodiment of the present invention.

In FIG. 1, 1 is a shared data access detection unit, 2 is a preprocessor, 3 is a library routine, 4 is an access history display program, 5 is an input source program, 6 is an output source program, 7 is a compiler, 8 is an object program, 9 is a linker, 10 is a load module, 11 is an access history file, 12 is an input device, and 13 is an access history list. In this embodiment, the shared data access detection unit 1 includes a preprocessor 2 and a library routine 3. and an access history display program 4.

The preprocessor 2 analyzes all the subroutines and programs to be processed using the input source program 5, and processes the parts where variables declared as shared data are accessed by calling the procedure of the library routine. At this time, locks and locks are applied to each individual piece of shared data.
Variables are declared and passed to library routine 3 as parameters. The preprocessor 2 also generates an output source program 6 as a result of the processing.

The output source program 6 output by the preprocessor 2 is compiled by the compiler 7 to generate an object program 8, and when linking the object program 8, the library routine 3 of the shared data access detection unit 1 is converted into a load module by the linker 9. 10 will be included. The load module 10 output by the linker 9 is a user's program, and when this is executed, the access history file 11 is output by the library routine 3 at the same time as the program is executed, and the access history display program 4 of the shared data access detection unit 1 is output. is access history file 1
1 is input, and in response to a command input from the input device 12, the access order relationship of shared variables is output to the access history list 13 as information on which tasks accessed and in what order.

FIG. 2 is a diagram showing an example of the library routine interface.

Library routines are broadly divided into COMWRTx, which assigns values to shared variables, and COMRD, which refers to shared variables.
There are two procedures with x. Here, X is a value indicating the type and size of the variable. FIG. 2 shows an interface of a library routine for REAL type 4-byte assignment and reference as an example. Procedure COMWRTR4 is a procedure for assigning a value to a shared variable. The first parameter of COMWRTR4 is the name of the shared variable to be assigned, the second parameter is whether the variable is an array, the third parameter is the array element if the variable is an array, the fourth parameter is the name of the lock variable, The fifth parameter is the value to be substituted.

Procedure COMRDR4 is a procedure that refers to a shared variable, and the first parameter is the name of the shared variable to be referenced, and the second
The parameter is whether the variable is an array, the third parameter is the array element if the variable is an array, and the fourth parameter is the name of the lock variable. The value you want to reference is returned as the return value of this procedure.

FIG. 5 is a diagram showing the contents of the access history file 13. The record is written into the access history file 13 by the library routine 3 as described above, and edited and output by the access history display program 4. For each record, the time when the access occurred, the type of access, and
Distinguishing references, variable addresses, variable values, array elements,
Execution address and other information are stored.

Next, the shared data access detection processing operation in such a configuration will be explained.

First, the preprocessor performs processing as shown in FIG.

That is, in FIG. 4, the source program of the input source program 5 accesses the shared variables V1 and V2. vl is a scalar variable and v2 is an array. The preprocessor 2 converts shared variable references and assignments in the source lines of the input source program 5 into procedure calls to the library routine 3, and generates an output source program 6. In library routine 3, processing as shown in FIG. 5 is performed.

Figure 5 shows an overview of the processing of library routine 3.
MWRTR4 is shown as an example. In FIG. 5, in step A1, it is checked whether the shared variable specified by the first parameter is locked by the lock variable specified by the fourth parameter. If it is locked, access is occurring in multiple tasks at the same time.In step A2, a message indicating that a non-exclusive access is occurring is output to the access history file 11. Step A3
Now, in order to access the shared variable, lock it using the lock variable of the fourth parameter. In step A4, assignment to the shared variable is performed, in step A5 output is performed to the access history file 11, and in step A6 it is unlocked. In the procedure for referencing values in the library routine 3, step A4 is where the values are read.

The access history display program 4 inputs this access history file 11 and assigns variables for each task.
Access history list 13 in order of reference time
Output. Users can use this access history list 13
By referring to , it is possible to know the order in which shared variables are accessed between tasks, and it is possible to investigate in what order the accesses occur. This makes it possible to detect program errors related to shared variable access.

〔Effect of the invention〕

As explained above, the present invention displays the access order of shared variables used in the processing of user programs running in parallel, so that when non-exclusive access occurs, the program Investigations can be easily carried out, which has the effect of making it possible to accurately observe the behavior of user programs and improving the efficiency of program debugging.

[Brief explanation of drawings]

Figure 1 is a block diagram of an embodiment of the present invention, Figure 2 is a diagram showing an example of the library routine interface, Figure 3 is a diagram showing the contents of an access history file, and Figure 4 is a diagram showing the processing of the preprocessor. FIG. 5, which is a diagram showing an example, is a flowchart showing an overview of the processing of the library routine. In FIG. 1, 1... shared data access detection unit, 2... preprocessor, 3... library routine, 4... access history display program, 5... input source program, 6... Output source program, 7... Compiler, 8... Object program, 9... Linker, lO... Load module, 11... Access history file, 12... Input device, 13...
Access history list.

Claims (1)

[Claims] A preprocessor that reads a user's source program and changes a source line where a shared variable access occurs to a call to an access procedure for reading and writing a shared variable, a library means that processes the access procedure, and a library that processes the access procedure. A shared data access detection method comprising: an access history file for storing access history, and an access history display means for reading the access history file and displaying the access order relationship of arbitrary variables. .