JP2000181727A - Process mapping method for thread function on virtual space system - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide the process mapping method of a thread function on a virtual space system mapping the thread function agasint a process in the virtual space system of a multiprocess system where the thread function is not mounted. SOLUTION: Initial value presence data 310 of a process, initial value absence data 320 and stacks 3-1' and 3-2' are arranged in a common space 3 on a virtual space system constituted of a common space 3 that can be accessed from respective processes 1 and 2 and plural process individual spaces 1 and 2 that can be accessed for respective processes. A thread management table managing the processes allocated as the thread in an application is generated. When the application disappears, the process allocated as the thread is compulsorily terminated by a system call and therefore the thread is mapped in the process being the execution unit of an operation system.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION In an operating system in which a thread function is not mounted on a virtual space system, a process mapping method of a thread function on the virtual space system for mapping a thread to a process which is an execution unit of the operation system. About.

[0002]

2. Description of the Related Art One of the programming languages characterized by cross-platform is Java.
Java is a virtual machine interpreter, and is characterized by supporting multithreading at a language level. The thread function is incorporated in the Java language itself, and the Java virtual machine also uses the thread function. Although Java is a cross-platform language, there are elements that depend on the operation system for implementing a Java virtual machine.
The handling of the thread function also depends on the Java virtual machine and the operation system. Therefore, in order to port and implement a Java virtual machine implemented in one operation system to another operation system, an implementation method of a thread function is an important issue.

Here, a Java virtual machine implemented as an application in UNIX (Unix) which supports a thread function at an API (Application Program Interface) level is changed to an operation system in which a thread function is not implemented at an API level. Consider the case of transplantation. In such a case, for example, a method of mapping a thread function to a process which is a minimum execution unit of the operation system can be considered.

FIG. 3 is a conceptual diagram showing a virtual space system in a conventional multi-process system in which a thread function is not mounted, which comprises an area independently allocated to each process in an address space and a shared area for each process. is there. In FIG. 3, the process individual space 100 independently allocated to the process 1 includes initial value data 1-1 having an initial value in advance, initial value no data 1-2 having no initial value, a stack 1-3, and a stack 1-3. It has areas allocated to program codes and the like. Also, the process individual space 2 assigned to another process 2
Similarly, 00 has respective areas allocated to data 2-1 with initial value, data 2-2 without initial value, stack 2-3, program code, and the like. Then, a shared space 3 which is an area shared by the processes 1 and 2
00 includes a text area 1-4 held by the process 1 and a text area 2-4 held by the process 2, and communication between the processes is performed using data in the shared space 300.

When a Java virtual machine implemented as an application in UNIX is ported and implemented on a virtual space system as shown in FIG. 3, a method of mapping a thread function to a process which is an execution unit of an operation system is considered. Can be However, when a thread function is mapped to a process in the virtual space system as shown in FIG. 3, there are the following problems.

[0006]

A first problem is that data with initial values and data without initial values of a process cannot be shared between processes.

A second problem is that the process stack cannot be accessed from other processes.

A third problem is that since the processes are independent of each other, they cannot be synchronized when the application is deleted.

The present invention solves each of the above problems, and in a virtual space system of a multi-process system in which a thread function is not mounted, a thread on a virtual space system capable of mapping a thread function to a process. It is intended to provide a process mapping method for functions.

[0010]

According to an aspect of the present invention, there is provided an operation system in which a thread function is not mounted, a shared space accessible from each process, and an access for each process. On a virtual space system consisting of multiple possible process individual spaces, data with initial value of the process, data without initial value, and stack are allocated in the shared space, and the process allocated as a thread in the application is managed. A thread management table is created, and a process assigned as a thread by a system call is forcibly terminated when an application is terminated, thereby mapping a thread to a process that is an execution unit of an operation system.

According to a second aspect of the present invention, the application is an application implemented by a virtual machine interpreter, and the virtual machine is configured as one process which is an execution unit of an operation system. Features. According to a third aspect of the present invention, when arranging the stack in a shared space,
When a process is started, a stack area is dynamically allocated from the shared space, whereby switching from the stack area in the process individual space allocated to each process to the stack area allocated in the shared space is performed.

[0012]

Embodiments of the present invention will be described below with reference to the drawings. First, a basic configuration of an embodiment of the present invention will be described with reference to FIGS.
A specific configuration will be described with reference to FIG.

As shown in FIG. 1, according to the present invention, as in the system shown in FIG. 3, a shared space area (shared space 3) accessible from all process units and a process individual space independent for each process unit are provided. (Process individual space 1,
On a virtual space system consisting of process individual spaces 2),
In addition, the present invention is applied to an operation system in which a thread function is not provided. The present invention is characterized in that a thread function is realized by mapping a thread function to a process which is an execution unit. Although FIG. 1 shows an example in which two process individual spaces are generated, the number of processes may be three or more.

In the conventional system, as shown in FIG. 3, in a virtual space system comprising a shared space area 300 accessible from all process units and process individual spaces 100 and 200 independent for each process unit, a process 1 , 2 share the text area with the shared space (1-
4, 2-4) and data with initial values (1-1, 2).
-1), data without initial value (1-2, 2-2) and stack (1-3, 2-3) are stored in process individual spaces 100, 20.
0 is held. On the other hand, in a system such as UNIX which uses a thread as an execution unit, a text area,
The data with the initial value and the data without the initial value are shared by all the threads existing in one process, and the stack is held for each thread unit. However, the data is read out from all the threads existing in one application (process). It must be possible.

Therefore, in the present invention, in a virtual space system managed by an operation system without a thread function, the thread function is realized by a process. First, as shown in FIG. The data, the data without the initial value, and the stack are arranged in the areas 310 and 320 in the shared space 3, respectively, and can be accessed from all processes. In particular, regarding the stack, since the stack is mounted in the process individual spaces 1 and 2 allocated to the processes 1 and 2 when the processes are started (3-1, 3-2), the stack is dynamically moved from the shared space 3 when the processes are started. The stack area is secured (3-1 ', 3-2'), and the process itself switches the stack.

Second, a thread management table is created in the shared space 3 in order to manage threads existing in the same application. When the application disappears, an arbitrary thread in the process refers to the thread management table, and Forcibly terminates all threads in the system by inter-process communication using a system call to the operation system. As a result, in the virtual space system of the operation system in which the thread function is not mounted as shown in FIGS. 3 and 1, the thread function can be mapped to the process.

Next, a specific configuration example of the embodiment of the present invention will be described with reference to FIG. Referring to FIG.
In the present embodiment, a Java application unit 10 created by a Java compiler, execution parts 20-1 and 20-2 by threads 1 and 2 therein, a Java virtual machine 30, an operation system 40 supporting a virtual space system, an operation It comprises execution unit processes 50-1 and 50-2 on the system.

The Java application unit 10 is referred to on the operation system 40 in a file format. The Java virtual machine 30 is configured as one process (process 0) on the operation system 40,
The Java virtual machine 30 reads, interprets, and executes the Java application 10.

If a description by the thread 20-1 exists at the time of interpreting, a new process execution unit (process 1) 50-1 is created. Thereafter, process 1 (50
-1) reads the Java application, and interprets and executes it. Also, a new thread 20
If the description by -2 exists, another process execution unit (process 2) 50-2 is created, and thereafter, the process 2 (50-2) reads the Java application, and executes the interpreter and the execution. That is, the Java virtual machine 30 associates the threads 20-1 and 20-2 described in the Java application with the processes 50-1 and 50-2 on the operating system 40 on a one-to-one basis.

Next, with reference to FIG. 3, FIG. 1, and FIG. 2, details of each procedure of the process mapping method of the thread function according to the embodiment of the present invention will be described. In the conventional system shown in FIG. 3, on a virtual space system including a shared space 300 accessible from the whole process and process individual spaces 100 and 200 independent for each process unit, the text area of the process is the shared space 1. −
4, 2-4, and other data with an initial value, data without an initial value, and a stack are stored in the areas 1-1, 1-2, 1-3 and the areas 2-1 and 2-1-2 for each process individual space.
2, 2-3.

On the other hand, in the present invention, Java
a. In order to map the thread of the application to the process, not only the text of the assigned process but also the data with initial value and the data without initial value must be shared. In order to realize this, not only the text of the process but also the data with initial values and the data without initial values are implemented in the shared space (the areas 310 and 310 in FIG. 1).
Region 320). In addition, the stack is owned by each thread, but reference must be possible from other threads. This is achieved by switching the stack area of each process from the stack area allocated to the individual process space by the operating system at the time of process startup to the stack area on the shared space that the process has independently secured. (Stacks 3-1 'and 3-2' in FIG. 1).

Then, a thread management table is created to manage threads in the same process (process in the Java application). Each time a thread is started, the identifier of the thread is stored in a table, and when the thread disappears, the identifier is deleted from the thread management table. Thus, when the Java application terminates, the process assigned to the resident thread in the Java application can be referred to from the thread management table, and all the resident threads in the application can be forcibly terminated by inter-process communication using a system call. become.

As described above, according to the present invention, an application using a thread function can be mounted on a virtual space system as shown in FIG. 3 using an operation system that does not provide a thread function. This is because a thread execution unit can be mapped to a process which is an execution unit of the virtual space system as shown in FIG. 3 by the system configuration shown in FIG. 1 as described above.

[0024]

According to the present invention, on a virtual space system composed of a shared space accessible from each process and a plurality of process individual spaces accessible for each process, data with initial value of the process, data without initial value, By allocating the stack in the shared space, creating a thread management table for managing the processes allocated as threads in the application, and forcibly terminating the processes allocated as threads by system calls when the application disappears, the operation Since threads are mapped to processes that are the execution units of the system, data with initial values and data without initial values can be shared between processes, the process stack can be accessed from other processes, and the application When extinguished It is become as take synchronization between processes. According to the invention as described above, it is possible to map a thread function to a process in a virtual space system of a multi-process system in which the thread function is not mounted.

[Brief description of the drawings]

FIG. 1 is a conceptual diagram showing a virtual space system according to the present invention.

FIG. 2 is a conceptual diagram showing a specific example of a method of mounting a Java virtual machine in the virtual space system according to the present invention shown in FIG.

FIG. 3 is a conceptual diagram showing a conventional virtual space system.

[Explanation of symbols]

 1, 2 individual process space 3 shared space 3-1, 3-1 ', 3-2, 3-2' stack

Claims (3)

[Claims] 1. An operation system in which a thread function is not implemented, wherein a process is executed on a virtual space system including a shared space accessible from each process and a plurality of process individual spaces accessible for each process. Creates a thread management table that manages processes assigned as threads in the application by allocating data with initial values, data without initial values, and the stack in the shared space, and assigning them as threads by system calls when the application disappears. A method for mapping a thread function on a virtual space system, wherein a thread is mapped to a process which is an execution unit of an operation system by forcibly terminating a process. 2. The method according to claim 1, wherein the application is a virtual machine
The method according to claim 1, wherein the application is implemented by an interpreter, and the virtual machine is configured as one process that is an execution unit of an operation system. 3. When arranging the stack in the shared space, the process dynamically secures a stack area from the shared space at the time of starting a process, so that the process individual space allocated to each process is transferred from the stack area to the shared space. 2. The process mapping method according to claim 1, wherein the switching to the stack area secured in the virtual space system is performed.