The present invention relates to the field of data processing, and more particularly to program execution by means of multiple threads.

Background and prior art In a multi-thread environment the memory address space for global data is usually shared among the threads. In addition the threads require storage of thread private data in dedicated data areas of respective stacks.

For example, the data used in a program written in the programming language C can be classified into two categories: global variables and auto variables. In these two categories, the global variables, which correspond to the global data to be shared among the threads in the above described model, are usually allocated in the data space as they are to be accessible from a plurality of functions, while the auto variables are usually allocated on the stacks as they are declared within a function and valid only within that function.

In a multi-threaded environment it is necessary to employ a data management method for supporting thread private data on a per thread basis. Conventionally, the following two methods have been proposed for this purpose: (I) Method for allocating private data on stack dynamically.

In this method, thread private data are allocated on the stack by declaring data used in several functions as auto variables in a certain function that is executed by each thread. Here, however, when the allocated data are to be used in other functions than the function that declared the auto variable, it is not possible for the other functions to directly access the allocated auto variables. There arises a need for handing the address of the allocated variable as a function argument from the calling function to that called function.

Thus, in this conventional data management method for supporting private data for each thread, there is a need to pass the address of the private data as a function argument when calling one function from another function. Therefore, the program entry for the called function which operates on the private data must contain the argument specifying the address of the private data, and consequently the program becomes quite complicated. In addition, in the called function, there is a need to store the address of the private data on the stack.

(II) Method for expanding variables in correspondence to multiple threads, and accessing variables by using thread identifiers (IDs).

In this method, each part of the thread private data is globally declared as a global sequence having as many elements as there are threads. An access from each thread is made by using a thread ID which is uniquely assigned to each thread in advance. In this method, if the thread IDs are not supported at the OS level, it becomes necessary to support the thread IDs themselves by using the specialized method (I) described above. Moreover, even when the thread IDs are supported at the OS level, this method is not applicable to a case

in which a number of threads changes dynamically. Thus, in this conventional data management method for supporting the global data privately by each thread, there is a need to provide the thread IDs.

US Patent No. 5,511, 192 shows a method of managing thread private data in which the thread private data can be declared globally and which can deal with the change of the number of threads. The thread private data to be globally accessible from the multiple threads and to be managed separately by each one of the multiple threads are detected before the actual execution of the program, and a thread private data region for managing all the detected thread private data is allocated to the stack for each one of the multiple threads separately.

Then, a pointer to specify a base address of the thread private data region with respect to the stack for each one of the multiple threads is registered separately, such that while executing one of the multiple threads, accesses to the thread private data are made by making accesses to the thread private data region in the stack for that one of the multiple threads according to the base address specified by the pointer registered for that one of the multiple threads.

Summary of the invention The present invention provides a method of accessing thread private data in a computer for a program to be executed by using multiple threads. Each one of the multiple threads is associated with a different data area of its respective stack for storage of corresponding thread private data. The different stacks associated with these threads cover a contiguous address space in a memory of the computer which starts at a specific base address.

Each one of the threads has a stack pointer which is stored in a processor register while executing the thread on a processor. The thread identifier for a given thread is determined on the basis of the base address and its stack pointer. By means of the thread identifier, access to the corresponding data area for the thread private data is enabled.

In accordance with a preferred embodiment of the invention the stacks are of equal size. In this case the thread ID for a given thread is determined by calculating the integer value of the difference of the base address and the stack pointer of that thread divided by the stack size.

In accordance with a further preferred embodiment of the invention the stacks are not of equal size but an integer multiple of a given block size. This enables to make more efficient usage of the available memory in case the threads require stacks of various sizes.

When stacks having various sizes are used the thread ID is determined by first determining a block identifier (ID). The block ID is obtained on the basis of the base address and the stack pointer of the thread. In particular the block ID can be obtained by calculating the integer value of the difference of the base address and the stack pointer divided by block size. The resulting block ID is mapped to the corresponding thread ID. For this purpose a mapping table can be used.

In accordance with a further preferred embodiment of the invention all thread IDs allocated in accordance with described method have a non-negative sign.

For example the thread IDs 0,1, 2,... i, n-1 for a number of n threads are used, where i is an integer. In addition there can be a main thread which has an associated main stack of arbitrary size. Preferably the main thread has a thread ID having a sign which is opposed to the sign of the thread IDs of the multiple threads. For example thread ID of the main thread is-1.

The present invention is particularly advantageous as it greatly simplifies the determination of thread IDs and management of thread private data. This enables to considerably reduce the overhead required for thread determination.

Thus more efficient usage of the computers resources is made and program execution of a multi-threaded program can be accelerated.

Brief description of the drawings In the following preferred embodiments of the invention will be described in greater detail by making reference to the drawings in which: Figure 1 is a block diagram of a first embodiment of a computer system of the invention, Figure 2 is illustrative of a method for accessing thread private data on the basis of equal stack sizes, Figure 3 is a block diagram of a further preferred embodiment of a computer system of the invention, Figure 4 is illustrative of a flow chart for managing thread private data in case of various stack sizes.

Detailed description Figure 1 shows computer system 100 which has processor 102 for execution of program 104. Program 104 has multiple threads TO, T1, T2,... Ti,... Tn-1, where n is the number of threads of program 104. In the example considered here the thread ID of a thread Ti is i. Each one of the threads Ti has a stack pointer SP. Further program 104 has main thread 106. For example the thread ID of main thread 106 is-1.

Module 108 serves to determine the thread ID of any one of the threads of program 104. Module 108 can be implemented as a program module or as a dedicated logic circuitry or a combination of both.

Computer system 100 can have a plurality of processors 102. In this case the different threads of program 104 can be processed simultaneously on multiple processors 102.

Further computer system 100 has memory 110. Memory 110 is used for storing of stacks STO, ST1, ST2,..., STi,... STn-1 for the corresponding threads TO, T1, T2,..., Ti,... Tn-1. The index of the stack STi is identical to the index of the

thread Ti being assigned to that stack. In other words thread TO is assigned to stack STO, thread T1 to stack ST1, thread T2 to stack ST2,..., thread Ti to stack STi,..., thread Tn-1 to stack STn-1. Each one of the stacks STi has the same size S.

The stack pointer SP of main thread 106 points to main stack 112 which is also provided in memory 110.

The stacks STO, ST1, ST2,... STn-1 cover a contiguous address space within memory 110 which starts at base address A.

In operation one of the threads Ti needs to access its associated stack STi for reading and/or writing of thread private data. In order to obtain the thread ID for thread Ti, i. e. the value of i, module 108 is invoked. Module 108 calculates the difference between the stack pointer SP of thread Ti and base address A. This difference is divided by stack size S. The integer value of the result of the division is the value of i and thus the thread ID. The thread ID is identical to the index i of the stack to which thread Ti is assigned. This way access of thread Ti to its associated stack STi is enabled.

The calculation performed by module 108 in order to obtain a thread ID is given below : Thread fD = integer [ (SP-A)/S] When main thread 106 needs to access main stack 112 the same calculation is performed by module 108. As stack pointer SP of main thread 106 points to a memory location which is outside the contiguous address space covered by the stacks STi the result of the calculation performed by module 108 will be either below zero or above N-1. This way it is determined that a requesting thread is main thread 106 and not one of the multiple threads Ti. In the example considered here the result of the calculation performed by module 108 would be negative, if main thread 106 is requesting thread, as the stack pointer SP of main thread 106 is below base address A.

Figure 2 shows a corresponding flow chart. In step 200 one of the threads of a program requires access to its thread private data either for a read or a write operation. In response the thread ID of the requesting thread is determined in step 202 on the basis of the stack pointer SP of the requesting thread and the base address A of the contiguous address space covered by the different stacks of the multiple threads of the program.

Preferably this is done by calculating the integer value of the difference between stack pointer SP and base address divided by stack size S.

In step 204 the thread-private data being associated with the thread having the thread ID as determined in step 202 is accessed in the respective stack either to return to thread private data to the requesting thread or to write thread private data in step 206.

Figure 3 shows a block diagram of a further preferred embodiment. Elements of figure 3 which corresponds to elements of figure 1 are designated by like reference numerals having added 200.

In the embodiment of figure 3 the different stacks of the multiple threads Ti have not the same size but they are integer multiples of a certain predefined block size S. Each block Bj has the same size S. A stack of one of the multiple threads Ti has either the size S or an integer multiple of size S. As in the preferred embodiment of figure 1 the different stacks for the multiple threads cover a contiguous address space in memory 310.

In the example considered here stack STO of thread TO is identical to block BO starting at base address A. In contrast stack ST1 of thread T1 is constituted by blocks B1 and B2 and thus has a stack size of 2 * S.

Stack ST2 is constituted by block B3; stack STi is constituted by blocks Bj and Bj+1 ; stack STn-1 is constituted by block Bm. Thus a number of m stacks STO to STm-1 is constituted by a number of m blocks BO through Bm-1, where m is equal or greater than n.

Further, mapping table 314 is stored in memory 310. By means of mapping table 314 each one of the blocks is mapped to one of the threads. Block BO is mapped to thread TO ; block B1 is mapped to thread T1 ; block B2 is mapped to thread T1, block B3 is mapped to thread T2,...

As opposed to the embodiment of figure 1 module 308 in the embodiment of figure 3 does not provide the thread ID but the block ID, i. e. the value of block index j. The value of the block index j is used to determine the thread ID, i. e. the value of i by means of mapping table 314.

In operation one of the multiple threads Ti requires access to its thread private data. This invokes module 308. Module 308 calculates the block ID to which the stack pointer SP of the requesting thread Ti points by subtracting base address A from stack pointer SP and dividing the result by size S. The integer value of the division by the size S provides the block ID. The corresponding equation is given below : Block ID = integer [ (SP-A)/S].

The block ID, i. e. the value of the block index j, is used to determine the thread ID, i. e. the value of the thread index i, by means of mapping table 314. This way the thread ID is provided and the requesting Ti can perform the required access operation with respect to its thread private data.

Figure 4 shows a corresponding flow chart. In step 400 one of the threads Ti requires access to its thread private data. In step 402 the block ID is determined based on the stack pointer SP of the requesting thread Ti and by means of base address A. Preferably this is done by calculating the difference between SP and A, dividing the difference by size S and determining the integer value of the result of the division. In step 404 the thread ID of the requesting thread Ti is determined based on the block ID determined in step 402. Preferably this is done by using a mapping table which maps the block IDs to thread IDs.

Steps 406 and 408 are analogous to steps 204 and 206 of figure 2.

List of Reference Numerals 100 computer system 102 processor 104 program 106 main thread 108 module 110 memory 112 main stack 300 computer system 302 processor 304 program 306 main thread 308 module 310 memory 312 main stack 314 mapping table