JPH0784952A - Interface device - Google Patents

Abstract

PURPOSE:To obtain a device which is small in the size of the interface and also light in the development load of the interface itself and can execute a program at high speed by providing the device with a call executing means which executes internal calls, a transmitting means which transmits external calls to nodes, and a call executing means which executes the external calls. CONSTITUTION:This device is provided with a host H, nodes A and B, and a communication line C which connects the host H and nodes A and B. The host H is provided with a classifying means which classifies system calls that the program issues into internal calls that the host H should execute and the external calls that the nodes A or B should execute. Further, an operating system(OS) as the means which executes the internal calls is mounted on the host H, and OSs as the means which execute the external calls are mounted on the nodes A and B respectively. Consequently, the external calls can be transferred to the nodes A or B regarding an old OS and executed, so a function for executing the external calls need not be incorporated in the host H.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an improvement of an interface device for executing a computer program using a system call to an operating system in a so-called cross environment.

[0002]

2. Description of the Related Art Computer programs such as application programs usually use system calls to an operating system (hereinafter referred to as "OS"). Here, the program in the present specification means not only an application program for a specific problem but also various programs such as a utility program and a system program. The operating system is a generic term for software that performs common resource management for each program, such as input / output in a computer, regardless of name. What is a system call?
It is a request for a certain operation from a program to the operating system.

By the way, generally, it is effective to improve the development efficiency of software by porting a program such as an application running on one OS to another OS. However, since it takes a lot of trouble to change the program itself according to the new OS, when there are many programs to be ported, the interface between OSs (rather than changing each program itself) It is more efficient to create compatible software and run the program through that software.

For the program, another environment different from the environment on which the development is based is called a cross environment, and the software as described above that makes different OSs compatible is generally called an interfacer. In many cases, the difference between OSs is the difference in system calls, so the main role of the interfacer is to provide the system call from the OS where the program originally operated (hereinafter referred to as "old OS"). This is to simulate the operation performed on a computer OS (hereinafter referred to as "new OS") which is a new execution environment.

The interfacer is also a program that runs on a computer with a new OS. However, a computer in which such an interface performs a predetermined operation focuses on a function called an interface (compatibility) and becomes an interface device. Can be called.

[0006]

By the way, the conventional interface device is realized on a single computer equipped with a new OS, and has the following problems.

First, in principle, a system call issued by a program and an OS service for the system call are directly transferred between the program and the OS, and another program called an interfacer is always provided between them. If it intervenes, extra processing is performed for each system call, and there is a problem that the execution efficiency of the program is reduced.

In particular, the interfacer is related to the function of the OS, and has various functions such as the function of the OS itself, the execution order of programs, devices (external input / output devices), and control of file management. In particular, in order to realize an interface device that can be applied to an arbitrary program, the interfacer needs to have all the functions lacking in the new OS, and such a function often covers most of the functions of the OS. Further, since the size of software is generally proportional to the variety of functions to be realized, the interface has to be extremely large. Therefore, the execution efficiency of the program in the interface device has been unavoidable.

On the other hand, in an execution environment with limited memory,
It is necessary to limit the function of the interfacer and compress the memory capacity occupied by the interfacer. However, limiting the function of the interfacer causes a program function that can be used on the old OS but not on the new OS. However, there is a problem that the versatility of the interface is reduced.

Further, when the computer of the new OS does not have the device that the computer of the old OS had, it is necessary to port the device to the computer of the new OS due to the function of the program. Here, in order for a computer to use a device, software called a device driver for controlling the device is usually required. Further, when the device driver mainly performs physical and electrical control, in order to use this device in the program in the form of a system call, a service routine is provided in the system code of the OS, and the service routine is provided by this routine. For a system call that accesses a device, it is necessary to realize an orderly series of operations of the device.

For this reason, if a new device is to be ported to an interface device realized on a computer with a new OS, the device driver and service routines need to be ported or newly installed, which is a laborious task that requires an extremely large number of steps. Therefore, it was difficult to improve the efficiency of the interface development itself.

On the other hand, there are cases where the device is not ported to a computer of the new OS and the operation of the required device is simulated by another similar device. However, such simulation has the disadvantage of a difference in hardware. Is replaced with the burden of software, which also causes a decrease in program execution speed.

The present invention has been proposed to solve the above-mentioned problems of the prior art, and its object is to reduce the size of the interfacer, to enable high-speed program execution, and to provide the interfacer. An object is to provide an excellent interface device which has a small development burden.

[0014]

In order to achieve the above object, an interface device according to claim 1 has a host and a node connected to the host, and is provided in the host and is a program to be executed. First classifying means for classifying a system call issued by the host into an internal call to be executed by the host and an external call to be executed by the node, and a first classification means provided in the host for executing the internal call. It is characterized by further comprising call executing means, transmitting means for transmitting the external call to the node, and second call executing means provided in the node for executing the external call.

According to a second aspect of the invention, in the interface device according to the first aspect, the first classifying means is
A first simulation configured to classify the internal call into an internal call that can be directly executed and an internal call that requires simulated execution, wherein the host simulates and executes the internal call that requires simulated execution. It is characterized by having means.

According to a third aspect of the invention, in the interface device according to the first aspect, the node classifies the external call into an external call that can be directly executed and an external call that requires simulation execution. Classification means of
It is characterized by further comprising a second simulating means for simulating and executing the external call which requires the simulating execution.

[0017]

The present invention having the above structure has the following functions. That is, according to the invention of claim 1, the external call to be executed by the node among the system calls can be transmitted to the node related to the old OS and executed. Therefore, it is not necessary to incorporate the function of executing the external call in the host. Therefore, the first execution means of the host is made compact and the execution speed of the program is improved. Further, since it is not necessary to port the device provided only to the node to the host, the development load of the interfacer can be reduced.

According to the second and third aspects of the present invention, among internal calls and external calls, those that can be directly executed by the OS of the host or node can be directly executed by each call executing means, so that the simulated execution is performed. This reduces the number of system calls that require, reduces the size of the interfacer, and reduces the development burden.

[0019]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS An interface device (hereinafter referred to as "this device"), which is an embodiment of the present invention, will be specifically described below with reference to the drawings. It should be noted that this device is realized on a computer, and each function of this device is realized by operating the computer in a predetermined procedure expressed in the form of a program. Therefore, the present apparatus will be described below assuming a virtual circuit block having each function of the apparatus.

(1) Configuration of Embodiment First, FIG. 1 is a block diagram showing the configuration of the present apparatus. This device is for executing the program running on the node A on the host H, and as shown in this figure, the host H, the nodes A and B, the host H and the nodes A and B. And a communication line C for connecting Further, the disk device D is connected to the node A, the printer P is connected to the node B,
Further, devices such as a keyboard and a CRT (not shown) are connected to the host H, respectively.

FIG. 2 is a functional block diagram showing the configuration of the host H. The host H, as shown in FIG.
A program storage unit 1 for storing a program to be executed, a program execution unit 2 for executing the program, and a system call issued by the program, an internal call to be executed by the host H and a node A.
Or a first classifying means 3 for classifying the external call to be executed by B. Further, the host H is equipped with an operating system OS_H for controlling a device (not shown) of the host H, and the OS_H is a first call executing means for executing the internal call.

FIG. 3 is a functional block diagram showing the configuration of the node A. As shown in FIG.
OS_A which is a second call executing means for controlling the disk device D and executing the external call is mounted.
The OS_A is an operating system different from the OS_H. The configuration of node B is also node A
Node B is replaced by OS_A instead of OS_A.
_B is installed.

Further, as shown in FIG. 2, the host H has an instruction message generator 4 for generating an instruction message which is a communication message including the external call, and a communication line C.
The first communication control unit 5 selectively transmits the instruction message to one of the node A and the node B through. Further, as illustrated in FIG. 3, the node A and the node B have a second communication control unit 6 that receives the instruction message. The instruction message generation unit 4 of the host H, the first communication control unit 5, the communication line C and the second communication control unit 6 of the nodes A and B constitute the transmission means.

Further, the first classifying means 3 provided in the host H is configured to classify the internal call into an internal call that can be directly executed and an internal call that requires simulation execution, and The host H first executes the internal call that requires the simulation execution.
It has the simulation means 7 of.

Further, the nodes A and B classify the external call into the external call which can be directly executed and the external call which requires the simulation execution, and the external call which requires the simulation execution. It has a second simulation means 9 for performing a simulation.

(2) Operation of the embodiment In the present apparatus having the above-mentioned configuration, the system call issued by the program is executed as follows. First, FIG. 4 is a flowchart showing the operation procedure of the host H when a system call is issued.

[System Call Classification] When a system call is issued from the program, the first classifying means 3 first classifies the system call into an internal call and an external call (step 41). The system calls issued by the program of this embodiment may include the following.

[0028]

[Table 1] Call SC1: read (fd, buf, nbyte); (Read file from disk device) Call SC2: cretsk (tid); (Launch task) Call SC3: print (fd); (Print file Output to)

Of these, the call SC1 is a system call executed by using the disk device D of the node A,
The call C3 is a system call executed by using the printer P of the node B.

Further, in the call SC1, fd is a file descriptor for specifying the file to be read, and is composed of, for example, the file path name, name and extension. Also, buf is the start address of the buffer area that stores the read contents, and nbyte is the size of the read file. Further, in the call SC2, the argument tid is a task identifier for identifying the task. Further, fd in the call SC3 is also a file descriptor for specifying the file to be processed.

In the present embodiment, the classification of these system calls is realized in the form of determining the execution machine, and this determination can be made based on the system call name. That is, although not shown, the first classifying unit 3 has a call name that is a name indicating the type of system call and a comparison table of the execution machine name and the additional argument corresponding to each call name. The following table shows an example of the structure of this comparison table.

[0032]

[Table 2]

Here, the additional argument is an argument that represents data required in addition to the normal argument when simulating a system call on the execution machine. For system calls that do not require additional arguments, enter 0 in the corresponding part of the table.
Is stored, which allows the first classifying means 3 to confirm the necessity of the additional argument.

Next, FIG. 5 is a flowchart showing a specific procedure for determining the execution machine, which is called from step 41 of FIG. In this figure, machine is a two-dimensional array variable, and each call name in Table 2 is stored in advance. Further, i is a loop counter, which is also used to specify the array element number. That is, in this procedure, i is incremented from 0 (step 51) (added by 1 / step 53), and each variable content machine is incremented.
The process of comparing [i] [0] with the call name of the issued system call is repeated (step 52), and when both match, this procedure (subroutine) is terminated, and the process shown in FIG.
The procedure returns to step 41 of the procedure (main routine) shown in FIG. As a result, when exiting this subroutine
The content of machine [i] [0] is the execution machine name.

For example, in the call SC1, the call name is re
Since it is ad, the execution machine is determined to be node A (Table 2). In the call SC2, the execution machine is determined to be the host H because the call name is cretsk (Table 2). Further, in the call SC3, since the call name is print, the execution machine is determined to be the node B (Table 2).

[Generation of Instruction Message] When the execution machine is the node A or B, the instruction message generator 4 generates an instruction message including a system call name and necessary arguments (step 42). For example, FIG. 6 shows call SC1.
It is a conceptual diagram which shows the data structure of the instruction message corresponding to. In this figure, the instruction message is a data block consisting of the system call name, the value of the argument, and the value of the additional argument. Between the argument and the additional argument, a termination symbol (separator) of 0 indicates Also, 0 is entered at the end of the message as an end code. Therefore, for example, when there is no additional argument, two 0s follow the argument.

[Transmission of Instruction Message] Subsequently, the first communication control unit 5 transmits the instruction message to the node A or B through the communication line C (step 43). For example, the instruction message corresponding to the call SC1 is transmitted to the node A.

[Classification and Execution of External Call] Here, FIG.
6 is a flowchart showing a procedure of executing a system call in each node. That is, in the node which is the execution machine, when the second communication control unit 6 receives the instruction message (step 71), the system call name and the argument are extracted from the instruction message, and the second classifying means 8 calls this system call. Classify into those that should be executed directly and those that should be simulated. In this embodiment, this classification is performed (step 73) following the determination of the execution pointer of the system call (step 72).

That is, FIG. 8 is a conceptual diagram showing the data structure of the simulation data included in the second classifying means 8. Of these, the table on the left is a comparison table of system call names and pointers that point to codes for executing the system calls, and the table on the right is execution code for executing system calls. This execution code is
If the OS_A or OS_B of the node A or B does not have a service routine that directly corresponds to the system call, it is an instruction sequence such as a machine language prepared for executing the system call, and this instruction sequence is , The operating procedure of the second simulating means 9 is determined.

Further, when the OS_A or OS_B of the node A or B has a service routine corresponding to the system call in advance, the execution code is a predetermined code indicating that simulation is unnecessary. When the execution code is this predetermined code, the second classifying means 8 uses OS_
Control is passed to the service routine of A or OS_B.

FIG. 9 is a flow chart showing a specific procedure for determining pointers in the nodes A and B. This flowchart shows the specific contents of step 72 of FIG. 7, and call is the name of the two-dimensional array variable that stores the contents of the table on the left side of FIG. In this array, the range of the first parameter is 0 (call name) and 1 (pointer)
Then, the range of the second parameter is the number of types of system calls. Further, i is a loop counter, which is also used to specify the array element number. That is, in this procedure, i is incremented from 0 (step 91) (added by 1 / step 93) while each variable content call [i]
[0] is compared with the issued system call name (step 92), and when both match, the process exits this loop and returns to step 72 in FIG.

As a result, the call [i] [0] at the time of exiting this subroutine becomes the pointer related to the system call to be executed. If the system call is to be executed directly (step 73), the OS_A or OS_B service routine directly executes the system call (step 74), otherwise, control is passed to the address pointed to by the pointer, and the node The second simulating means provided in A or B simulates and executes the operation corresponding to the system call by the operation based on the code group starting from the address (step 75).

For example, in call SC1, the call name is re
Since it is ad, the pointer is determined to point to code without simulation. That is, the disk device D is
Since it is connected only to node A, disk device D
When connecting to host H again,
Not only the device driver for controlling the disk device had to be prepared, but also the service routine for managing the logical file structure on the disk device D had to be prepared.

However, in the present embodiment, first, the application originally operates on the node A using the disk device D. Therefore, the OS of node A
_A originally includes a service routine that is a procedure for executing the system call read and a device driver for the disk device D. In this case, in this embodiment, since the call SC1 is executed on the node A, it is not necessary to newly install a device driver in the interfacer or replace the system call with another instruction sequence. Therefore, in the case of the call SC1 whose system call name is read, simulation is not necessary and the call SC1 is directly executed by OS_A. For this reason,
The interfacer is more compact than the conventional one,
At the same time, the development burden on the interface is reduced.

In the call SC3, the call name is prin.
Since it is t, the pointer is determined to be the code group EC2.
That is, for the call SC3, since the printer P is originally connected to the node B, the device driver for controlling the printer has been the node B before the construction of this apparatus.
What was present above can be diverted.

However, since the application in this embodiment was originally operated on the node A, the system call issued by this application is for OS_A and has a different format from that for OS_B. Therefore, in OS_B, since the system call SC3 for OS_A is simulated and executed on OS_B, it is necessary to replace the system call with another instruction sequence. Specifically, in the case of the call SC3 whose call name is print, the file descriptor fd cannot be used as it is, and it is necessary to specify the output content in the simulation of the operation.

Here, in the data of the first classification means 3 of the host H, as shown in Table 2, the system call print
Since the additional argument is set in the, the additional argument is added to the instruction message received in the node B. This additional argument is an array that stores information that identifies the file. As a result, in the node B, the control is passed to the code group EC2 based on the data of FIG. 8, and the file of the character string or the name sent by the additional argument is output to the printer P.

The first classifying means 3 of the host H, the first
Also by the call executing means OS_H and the first simulating means 7, the internal call is executed by the same procedure as shown in steps 72 to 75 of FIG. In addition, the execution data illustrated in FIG.
As a common file for A and B, it is stored as a single file on a network server, etc., and each execution machine H, A, B
You may refer to the file from. For example, the call SC3 that is an internal call has a call name cr
Since it is etsk, a simulation is necessary (step 44 in FIG. 4), and the first simulation means 7 of the host H executes the simulation using the code group EC1 (step 45). The system call directly executed by the host H (step 46) has the same format as the first call executing means of the host H.

When the execution of the system call is completed in the [End message] node, an end message including the value returned by the system call and the argument value is generated (step 76), and the second communication control unit 6 sends this end message. It is returned to the host H (step 77). FIG. 10 is a conceptual diagram showing the data structure of the end message corresponding to the call SC1, and in this end message, the value returned by the system call, the argument value, and the end code 0 are arranged consecutively.

In the host H, the first communication control unit 5 receives the end message (step 47), and the value returned by the system call and the argument value contained in this end message are stored in a predetermined memory area. Then, control is returned to the application program as if the execution of the system call had ended.

(3) Effects of the Embodiment As described above, according to the interface device of the present embodiment, the program running on the node A can be run on the host H. Then, of the system calls issued by this program, external calls to be executed by the nodes A and B are transmitted to the nodes A and B and executed. Therefore, it is not necessary to incorporate the function of executing the external call into the first call executing means OS_H of the host H or the first simulating means 7. Therefore, of the interfacers that determine the operation of the interface device, especially the portion arranged on the host H is made compact. As a result, the execution speed of the program is improved, and even when a computer having severe memory restrictions is set as the host H, the function restrictions are less likely to occur. Further, since it is not necessary to port the devices and service routines provided in the nodes A and B to the host H, the development load of the interfacer can be reduced.

In particular, in the present embodiment, among the internal calls and the external calls, those that can be directly executed are directly executed by the call executing means OS_H, OS_A, OS_B, so the number of system calls that need to be simulated is reduced. By doing so, the interface can be made compact and the development load can be reduced. That is, since the functions that can be used as they are in the existing computer and OS are utilized, the activity of the interfacer is reduced and the program execution is further speeded up.

In particular, in the present embodiment, like the printer output and the simple update of the disk contents without reading,
For operations that do not require an end message, the entire interface device is used as a multi-CPU system, and the CPU, which is the program executing means 2 of the host H, performs the original arithmetic processing while the nodes A and B print out or write to disk. It is also possible to speed up the processing by performing the above in parallel.

(4) Other Embodiments The present invention is not limited to the above embodiments,
The following other examples are also included. For example, the configuration of the interface device of the above embodiment is only an example, and the number of execution machines may be 2, 4 or more. Further, by connecting an execution machine serving as a node to a machine that is a node as viewed from the host H, the execution machines may be integrated in multiple layers to form an interface device. By doing so, it is possible to develop a comprehensive system by integrating a large number of excellent software of different OSs, and to use geographically dispersed hardware resources in an integrated manner across OS differences.

Although the interface device of the above embodiment is realized on a computer, a part of the function may be realized on a dedicated electronic circuit.

[0056]

As described above, according to the interface device of the present invention, an excellent interface device in which the size of the interface is small, high-speed program execution is possible, and the development load of the interface itself is small. Because it is provided, it is easy to use various software.

[Brief description of drawings]

FIG. 1 is a block diagram showing a configuration of an exemplary embodiment of the present invention.

FIG. 2 is a functional block diagram showing the configuration of a host H in the embodiment of the invention.

FIG. 3 is a functional block diagram showing the configuration of a node A in the embodiment of the invention.

FIG. 4 is a flowchart showing an operation procedure of a host relating to execution of a system call in the embodiment of the present invention.

FIG. 5 is a flowchart showing a procedure of determining an execution machine by a host in the embodiment of the present invention.

FIG. 6 is a conceptual diagram showing a data structure of an instruction message according to the embodiment of the present invention.

FIG. 7 is a flowchart showing a procedure of executing a system call by a node in the embodiment of the present invention.

FIG. 8 is a conceptual diagram showing a data structure of a second classifying unit of nodes in the embodiment of the present invention.

FIG. 9 is a flowchart showing a procedure of pointer determination by the second classifying unit of the node in the embodiment of the present invention.

FIG. 10 is a conceptual diagram showing a data structure of an end message according to the embodiment of the present invention.

[Explanation of symbols]

 1: Program storage means 2: Program execution means 3: First classification means 4: Instruction message generation section 5: First communication control section 6: Second communication control section 7: First simulation means 8: First 2 classification means 9: second simulation means C: communication line D: disk device EC: code group H: host OS: operating system P: printer S: each step of the procedure SC: system call

Claims (3)

[Claims] 1. A host and a node connected to the host, wherein an internal call to be executed by the host and the node execute a system call issued by a program that is provided in the host and is an execution target. First classifying means for classifying into external calls to be executed, and first provided for the host to execute the internal call
2. An interface device, comprising: a call executing means of 1 .; a transferring means for transferring the external call to the node; and a second call executing means provided in the node for executing the external call. 2. The first classifying unit is configured to classify the internal call into an internal call that can be directly executed and an internal call that requires simulation execution, and the host can execute the simulation execution. 2. The interface device according to claim 1, further comprising first simulating means for simulating and executing the required internal call. 3. The node simulates the external call that requires the simulated execution, and second classification means that classifies the external call into an external call that can be directly executed and an external call that requires simulated execution. The interface device according to claim 1, further comprising a second simulating means for executing.