Placing a task of a multithreaded environment in a known state

• US 20040078795A1
• Filed: 10/10/2003
• Published: 04/22/2004
• Est. Priority Date: 11/13/1998
• Status: Active Grant

• 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.
• Granted Patent: US 7,426,732 B2
• Time in Patent Office: Days
• US Class Current: 718/100
• 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 task having multiple threads executing on streams of the computer system, the method comprising:

notifying each of the threads of the task executing on a stream to enter a known state; and

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.

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 supporting multiple streams, the task having multiple threads executing on the streams, the method comprising:

notifying each of the threads of the task to exit the known state; and

for each thread,

in response to receiving the notification, executing instructions that were to be executed prior to entering 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 known state, the task having multiple threads executing on streams of the system, the system comprising:

a component for notifying each of the threads of the task executing on a stream to enter a known state; and

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.

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, the task having multiple threads executing on the streams, the system comprising:

a component for notifying each of the threads of the task to exit 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.

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.