Enhanced thread processing

• US 6,654,781 B1
• Filed: 12/11/1998
• Issued: 11/25/2003
• Est. Priority Date: 12/11/1998
• Status: Expired due to Term

• Current Assignee: Google LLC (Alphabet Inc.)
• Original Assignee: International Business Machines Corporation
• Inventors: Browning, Luke Matthew
• Primary Examiner(s): Courtenay, III, St. John
• Assistant Examiner(s): Anya, Charles E.
• Application Number:
  US09/210,095
• Time in Patent Office: 1,810 Days
• Field of Search: 711/6, 711/100-173, 709/104, 709/100-108
• US Class Current: 718/104
• CPC Class Codes: G06F 9/4843 by program, e.g. task dispatcher, supervisor, operating system
• CPC Class Codes: G06F 9/5016 the resource being the memory

Abstract

A method and implementing computer system is provided for the creation of large numbers of threads in a computer system. An exemplary embodiment supports up to sixteen segments in memory of thread private data for each process or application program running on the system. Each segment contains support for 2K threads. These segments are identified in process'"'"' user structure which is located in the process private data segment of memory allowing cleanup collection on a per-segment basis. The thread'"'"'s private data is composed of two parts, viz. its private kernel thread stack (96K) and uthread data structure. The uthread contains the individual data fields that are referenced only by the thread, including the register save area for the thread.

Claims

1. A method for managing threads of a computer system by allocating its resources, said method comprising:

creating a new kernel thread segment;

moving a calling thread'"'"'s kernel stack and uthread structure to said new kernel thread segment;

separating the kernel stack and the uthread structure from shared data between threads; and

locating the kernel stack and uthread structure into an overlaid segment as the calling thread is executing.

2. The method as set forth in claim 1 wherein after changing said kernel stack, said method further including:

allocating a uthread structure; and

initializing said uthread structure.

3. The method as set forth in claim 2 and after initializing, said method further including:

allocating a new uthread structure; and

initializing said new uthread structure.

4. The method as set forth in claim 1 and further including:

identifying an instance of said kernel thread segment to be loaded into a segment register;

identifying an offset of said uthread structure in a kernel thread stack segment; and

offsetting in said kernel stack segment for said thread'"'"'s kernel stack.

5. The method as set forth in claim 4 and further including:

attaching said uthread to said kernel stack segment.

6. The method as set forth in claim 5 and further including:

returning a thread ID of said newly created thread.

7. A method for managing threads of a computer system, said method comprising:

creating a new thread having a kernel stack and a uthread structure as context management data; and

placing context management data that is private to the new thread in a dedicated segment that is not accessible to other threads during execution of the other threads.

8. A method for processing threads in a computer system, said method comprising:

placing a kernel stack and a uthread structure in a dedicated segment that is not accessible to other threads during execution of the other threads;

dispatching a thread in kernel mode; and

loading the dedicated segment of the thread into kernel address space of the thread so that it has access to the kernel stack and the uthread structure.

9. The method as set forth in claim 8 further including loading the dedicated segment into a fixed position in the kernel address space of the kernel thread when the thread is dispatched so that each kernel thread has its own kernel stack and uthread structure and does not have access to another thread'"'"'s kernel stack and uthread structure.

10. The method as set forth in claim 9 and further including sequentially overlaying an infinite amount of dedicated segments at a same position within the kernel address space.