Method and apparatus for handling threads in a data processing system

• US 7,275,247 B2
• Filed: 09/19/2002
• Issued: 09/25/2007
• Est. Priority Date: 09/19/2002
• Status: Expired due to Fees

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Schopp, Joel Howard, Mendoza, Alfredo V.
• Primary Examiner(s): NGUYEN, VAN H
• Application Number:
  US10/246,889
• Publication Number:
  US 20040060049A1
• Time in Patent Office: 1,832 Days
• Field of Search: 718/1, 718100-106, 711/100, 717/149
• US Class Current: 718/100
• CPC Class Codes: G06F 9/485 Task life-cycle, e.g. stopping, restarting, resuming execution G06F9/4881 takes precedence

Abstract

A system for managing threads. A kernel tread associated with a user thread is detected as being unneeded by the user tread. The kernel thread is semi-detached in which data for the thread does not change stacks in response to the kernel thread being unneeded.

Claims

1. A method in a data processing system for managing threads, the method comprising:

detecting by a processing unit in the data processing system a kernel thread associated with a user thread;

determining by the processing unit that the kernel thread is unneeded by the user thread;

responsive to the kernel thread being unneeded, semi-detaching, by the processing unit, the kernel thread by placing the kernel thread on a semi-detached list and in an unrunnable state concurrent with the user thread, wherein the kernel thread maintains information regarding a same user stack and signal mask of the user thread, and wherein data for the kernel thread remains on the same user stack as data for the user thread in case the user thread later needs the kernel thread, and wherein the threads execute in an operating system of the data processing system; and

responsive to the user thread waking from sleep, removing by the processing unit the kernel thread from the semi-detached list, wherein reattachment to the user thread is unnecessary.

2. The method of claim 1, wherein the threads execute in an advanced interactive executive operating system.

3. The method of claim 1, wherein data for the kernel thread remains on the same user stack without requiring copying of the data to a kernel stack to semi-detach the kernel thread.

4. The method of claim 1, wherein the detecting and semi-detaching steps are performed using a library.

5. The method of claim 1 further comprising:

responsive to the user thread waking from sleep, determining by the processing unit whether a second kernel tread is detached rather than semi-detached; and

responsive to the second kernel thread being detached, attaching by the processing unit the second kernel thread to the user thread.

6. The method of claim 1, wherein the unrunnable state is one of a waiting state or a sleeping state.

7. A data processing system for managing threads, the data processing system comprising:

a bus system;

a communications unit connected to the bus system;

a memory connected to the bus system, wherein the memory includes a set of instructions; and

a processing unit connected to the bus system, wherein the processing unit executes the set of instructions to perform the following steps;

detecting a kernel thread associated with a user thread;

determining that the kernel thread is unneeded by the user thread;

in response to the kernel thread being unneeded, semi-detaching the kernel thread by placing the kernel thread on a semi-detached list and in an unrunnable state concurrent with the user thread, wherein the kernel thread maintains information regarding a same user stack and signal mask of the user thread, and wherein data for the kernel thread remains on the same user stack as data for the user thread in case the user thread later needs the kernel thread, and wherein the threads execute in an operating system of the data processing system; and

in response to the user thread waking from sleep, removing by the processing unit the kernel thread from the semi-detached list, wherein reattachment to the user thread is unnecessary.

8. A data processing system for managing threads, the data processing system comprising:

a bus system;

a memory connected to the bus system;

detecting means for detecting a kernel thread associated with a user thread;

determining means for determining that the kernel thread is unneeded by the user thread;

semi-detaching means, responsive to the kernel thread being unneeded, for semi-detaching the kernel thread by placing the kernel thread on a semi-detached list and in an unrunnable state concurrent with the user thread, wherein the kernel thread maintains information regarding a same user stack and signal mask of the user thread, and wherein data for the kernel thread remains on the same user stack as data for the user thread in case the user thread later needs the kernel thread, and wherein the threads execute in an operating system of the data processing system; and

removing means, responsive to the user thread waking from sleep, for removing the kernel thread from the semi-detached list, wherein reattachment to the user thread is unnecessary.

9. The data processing system of claim 8, wherein the threads execute in an advanced interactive executive operating system.

10. The data processing system of claim 8, wherein data for the kernel thread remains on the same user stack without requiring copying of the data to a kernel stack to semi-detach the kernel thread.

11. The data processing system of claim 8, wherein the detecting and semi-detaching steps are performed using a library.

12. The data processing system of claim 8 further comprising:

determining means, responsive to the user thread waking from sleep, for determining whether a second kernel thread is detached rather than semi-detached; and

attaching means, responsive to the second kernel thread being detached, for attaching the second kernel thread to the user thread.

13. The data processing system of claim 8 wherein the unrunnable state is one of a waiting state or a sleeping state.

14. A computer program product in a computer readable storage medium for managing threads, the computer program product comprising:

first instructions for detecting a kernel thread associated with a user thread;

second instructions for determining that the kernel thread is unneeded by the user thread;

third instructions, responsive to the kernel thread being unneeded, for semi-detaching the kernel thread by placing the kernel thread on a semi-detached list and in an unrunnable state concurrent with the user thread, wherein the kernel thread maintains information regarding a same user stack and signal mask of the user thread, and wherein data for the kernel thread remains on the same user stack as data for the user thread in case the user thread later needs the kernel thread, and wherein the threads execute in an operating system of a data processing system; and

fourth instructions, responsive to the user thread waking from sleep, removing by a processing unit the kernel thread from the semi-detached list, wherein reattachment to the user thread is unnecessary.