Placing a task of a multithreaded environment in a known state

• US 7,426,732 B2
• Filed: 10/10/2003
• Issued: 09/16/2008
• Est. Priority Date: 11/13/1998
• Status: Expired due to Term

• Current Assignee: CRAY Incorporated (Hewlett-Packard Enterprise Company)
• Original Assignee: CRAY Incorporated (Hewlett-Packard Enterprise Company)
• Inventors: Alverson, Gail A., Koblenz, Brian D., Smith, Burton J., Callahan, Charles David II, Korry, Richard D., Coatney, Susan L.
• Primary Examiner(s): An; Meng-Ai
• Assistant Examiner(s): To; Jennifer N
• Application Number:
  US10/683,774
• Publication Number:
  US 20040078795A1
• Time in Patent Office: 1,803 Days
• Field of Search: 709/103, 709/102, 718100-108, 719/318
• US Class Current: 718/108
• CPC Class Codes: G06F 2209/481 Exception handling
• CPC Class Codes: G06F 9/461 Saving or restoring of program or task context
• CPC Class Codes: G06F 9/4812 by interrupt, e.g. masked
• CPC Class Codes: G06F 9/485 Task life-cycle, e.g. stopping, restarting, resuming execution G06F9/4881 takes precedence
• CPC Class Codes: G06F 9/52 Program synchronisation; Mutual exclusion, e.g. by means of semaphores

Abstract

A method and system that prepares a task for being swapped out from processor utilization that is executing on a computer with multiple processors that each support multiple streams. The task has one or more teams of threads, where each team represents threads executing on a single processor. The task designates, for each stream that is executing a thread, one stream as a team master stream and one stream as a task master stream. For each team master stream, the task notifies the operating system that the team is ready to be swapped out when each other thread of the team has saved its state and has quit its stream. Finally, for the task master stream, the task notifies the operating system that the task is ready to be swapped when it has saved its state and each other team has notified that it is ready to be swapped out.

Claims

1. A method in a computer system for placing a task in a known state, the computer system having an operating system, the task having multiple threads executing on streams of a processor of the computer system, the processor having multiple streams for simultaneously executing threads of the task, the method comprising:

under control of the operating system,

notifying each of the threads of the task executing on a stream of the processor to enter a known state, the known state being an active state in which the thread is not making productive use of the processor;

for each of the threads,

in response to receiving the notification, entering the known state so that an action can be performed with the task being in the known state, and

notifying a designated thread of the task that the thread has entered a known state; and

under control of the designated thread,

determining whether a notification has been received from each of the other threads of the task, and

when it is determined that a notification has been received from each of the other threads of the task, notifying the operating system that the task is now in the known state.

2. The method of claim 1 wherein the known state is a quiescent state.

3. The method of claim 1 wherein the known state is where each of the threads is executing idle instructions.

4. The method of claim 1 wherein the known state is where the threads stop executing instructions.

5. The method of claim 1 wherein the task is assigned to a protection domain and the notifying includes raising a domain signal for the protection domain.

6. The method of claim 1 wherein prior to entering the known state each thread saves its state.

7. The method of claim 1 wherein a thread of the task initiates the notifying.

8. The method of claim 7 wherein the thread initiates the notifying by sending a request to an operating system.

9. The method of claim 7 wherein the task notifies an operating system that the task is blocked from further productive use of a resource until an event occurs prior to entering the known state.

10. The method of claim 1 wherein the action to be performed is swapping out the task from processor utilization.

11. The method of claim 10 wherein prior to entering the known state each thread saves its state information.

12. The method of claim 1 wherein each thread of the task has state information and the action to be performed is review of the state information.

13. The method of claim 12 wherein the review of the state information is by a debugger.

14. The method of claim 13 wherein the debugger executes as a thread of the task that does not enter the known state.

15. The method of claim 1 wherein the action is to process a signal indicated by an operating system.

16. The method of claim 1 wherein the action is to perform an inter- thread long jump.

17. The method of claim 1 wherein the known state is waiting on a synchronization indication.

18. The method of claim 17 wherein the waiting is performed by accessing a memory location with a synchronization access mode of future.

19. The method of claim 1 wherein entering the known state includes invoking an operating system call.

20. The method of claim 1 wherein a master thread is designated for notifying an operating system when the task is in the known state.

21. The method of claim 1 wherein one of the threads enters a known state of processing signals while the other threads are in a known state that is a quiescent state.

22. The method of claim 21 wherein after processing the signals each of the threads exits the known state.

23. A method in a computer system for a task to exit a known state, the computer system having an operating system and supporting multiple streams, the task having multiple threads executing on the streams that are in the known state, the known state being an active state in which the thread is not making productive use of the processor, the method comprising:

under control of the operating system,

notifying a designated thread of the task to exit the known state;

under control of the designated thread of the task,

notifying each of the other threads of the task executing on a parallel processor architecture having multiple simultaneously executing protection domains to exit the know state; and

after notifying each of the other threads, executing instructions that were to be executed prior to entering the know state to effect the exiting of the known state; and

for each of the threads,

in response to receiving the notification, executing instructions that were to be executed prior to entering the known state to effect the exiting of the known state.

24. The method of claim 23 wherein the known state is a quiescent state.

25. The method of claim 23 wherein the known state is where the threads are executing idle instructions.

26. The method of claim 23 wherein the known state is where the threads stop executing instructions.

27. The method of claim 23 wherein the known state is where the threads are waiting on a synchronization indication.

28. The method of claim 27 wherein the notifying includes indicating the synchronization.

29. The method of claim 23 wherein each thread restores state information that was saved prior to the state entering the known state.

30. The method of claim 29 wherein one thread performs signal processing upon exiting the known state.

31. The method of claim 30 wherein the other threads wait until the signals are processed before executing instructions that were to be executed prior to entering the known state.

32. The method of claim 23 including reserving a number of streams for the task.

33. The method of claim 23 wherein after receiving the notification, the task creates streams for the threads.

34. A system for placing a task in a know state, the task having multiple threads executing on streams of the system, the system comprising:

a central processing unit;

an operating system;

a component under control of the operating system for notifying each of the threads of the task executing on a parallel processor architecture having multiple simultaneously executing streams to enter a known state, the known state being an active state in which the thread is not making productive use of the processor;

a component for each of the threads that,

in response to receiving the notification, causes the thread to enter the known state so that an action can be performed with the task being in the known state; and

notifies a designated thread of the task that the thread has entered a known state; and

a component for the designated thread that,

when a notification has been received from each of the other threads, notifies the operating system that the task is now in the known state.

35. The system of claim 34 wherein the known state is a quiescent state.

36. The system of claim 34 wherein the known state is where each of the threads is executing idle instructions.

37. The system of claim 34 wherein the known state is where the threads stop executing instructions.

38. The system of claim 34 wherein the task is assigned to a protection domain and the notifying includes raising a domain signal for the protection domain.

39. The system of claim 34 wherein prior to entering the known state each thread saves its state.

40. The system of claim 36 wherein a thread of the task initiates the notifying.

41. The system of claim 40 wherein the thread initiates the notifying by sending a request to an operating system.

42. The system of claim 40 wherein the task notifies an operating system that the task is blocked from further productive use of a resource until an event occurs prior to entering the known state.

43. The system of claim 34 wherein the action to be performed is swapping out the task from processor utilization.

44. The system of claim 43 wherein prior to entering the known state each thread saves its state information.

45. The system of claim 34 wherein each thread of the task has state information and the action to be performed is review of the state information.

46. The system of claim 45 wherein the review of the state information is by a debugger.

47. The system of claim 46 wherein the debugger executes as a thread of the task that does not enter the known state.

48. The system of claim 34 wherein the action is to process a signal indicated by an operating system.

49. The system of claim 34 wherein the action is to perform an inter-thread long jump.

50. The system of claim 34 wherein the known state is waiting on a synchronization indication.

51. The system of claim 50 wherein the waiting is performed by accessing a memory location with a synchronization access mode of future.

52. The system of claim 34 wherein entering the known state includes invoking an operating system call.

53. The system of claim 34 wherein a master thread is designated for notifying an operating system when the task is in the known state.

54. The system of claim 34 wherein one of the threads enters a known state of processing signals while the other threads are in a known state that is a quiescent state.

55. The system of claim 34 wherein after processing the signals each of the threads exits the known state.

56. A system for use by a task to exit a known state, the system supporting multiple streams and including an operating system and a central processing unit, the task having multiple threads executing on the streams that are in the known state, the known state being an active state in which the thread is not making productive use of the processor, the system comprising:

a component under control of the operating system for notifying a designated thread of the task to exit the known state, wherein the task is executing on a parallel processor architecture having multiple simultaneously executing protection domain;

a component of the designated thread for notifying each of the other threads of the task to exit the known state and that after notifying each of the other threads, causes the designated thread to execute instructions that were to be executed prior to entering the known state to effect the exiting of the known state; and

a component for each thread that,

in response to receiving the notification, executes instructions that were to be executed prior to entering the known state to effect the exiting of the known state.

57. The system of claim 56 wherein the known state is a quiescent state.

58. The system of claim 56 wherein the known state is where the threads are executing idle instructions.

59. The system of claim 56 wherein the known state is where the threads stop executing instructions.

60. The system of claim 56 wherein the known state is where the threads are waiting on a synchronization indication.

61. The system of claim 60 wherein the notifying includes indicating the synchronization.

62. The system of claim 56 wherein each thread restores state information that was saved prior to the state entering the known state.

63. The system of claim 62 wherein one thread performs signal processing upon exiting the known state.

64. The system of claim 63 wherein the other threads wait until the signals are processed before executing instructions that were to be executed prior to entering the known state.

65. The system of claim 56 including reserving a number of streams for the task.

66. The system of claim 56 wherein after receiving the notification, the task creates streams for the threads.