Patent Grant
8880853
1. Technical Field
The present application relates generally to an improved data processing system and method. More specifically, the present application is directed to a mechanism to wake a sleeping thread based on an asynchronous event.
2. Description of Related Art
Multithreading is multitasking within a single program. Multithreading allows multiple streams of execution to take place concurrently within the same program, each stream processing a different transaction or message. In order for a multithreaded program to achieve true performance gains, it must be run in a multitasking or multiprocessing environment, which allows multiple operations to take place.
Certain types of applications lend themselves to multithreading. For example, in an order processing system, each order can be entered independently of the other orders. In an image editing program, a calculation-intensive filter can be performed on one image, while the user works on another. Multithreading is also used to create synchronized audio and video applications.
In addition, a symmetric multiprocessing (SMP) operating system uses multithreading to allow multiple CPUs to be controlled at the same time. An SMP computing system is a multiprocessing architecture in which multiple central processing units (CPUs) share the same memory. SMP speeds up whatever processes can be overlapped. For example, in a desktop computer, SMP may speed up the running of multiple applications simultaneously. If an application is multithreaded, which allows for concurrent operations within the application itself, then SMP may improve the performance of that single application.
If a process, or thread, is waiting for an event, then the process goes to sleep. A process is said to be “sleeping,” if the process is in an inactive state. The thread remains in memory, but is not queued for processing until an event occurs. Typically, this event is detected when there is a change to a value at a particular address or when there is an interrupt.
As an example of the latter, a processor may be executing a first thread, which goes to sleep. The processor may then begin executing a second thread. When an interrupt occurs, indicating that an event for which the first thread was waiting, the processor may then stop running the second thread and “wake” the first thread. However, in order to receive the interrupt, the processor must perform interrupt event handling, which is highly software intensive. An interrupt handler has multiple levels, typically including a first level interrupt handler (FLIH) and a second level interrupt handler (SLIH); therefore, interrupt handling may be time-consuming.
In the former case, the processor may simply allow the first thread to periodically poll a memory location to determine whether a particular event occurs. The first thread performs a get instruction and a compare instruction (GET&CMP) to determine whether a value at a given address is changed to an expected value. When one considers that a computing system may be running thousands of threads, many of which are waiting for an event at any given time, there are many wasted processor cycles spent polling memory locations when an expected event has not occurred.
In one illustrative embodiment, a method, in a data processing system, performs a wake-and-go operation in response to detecting a thread spinning on a lock. The method comprises detecting that a thread is spinning on a lock at a target address. Responsive to detecting the thread spinning on the lock, the method populates a wake-and-go storage array with the target address and places the thread in a sleep state. Responsive to an event associated with the target address, the method places the thread in a non-sleep state.
In another illustrative embodiment, a data processing system comprises a wake-and-go mechanism and a wake-and-go storage array. The wake-and-go mechanism is configured to detect that a thread is spinning on a lock at a target address. Responsive to detecting the thread spinning on the lock, the wake-and-go mechanism is configured to populate the wake-and-go storage array with the target address and place the thread in a sleep state. Responsive to an event associated with the target address, the wake-and-go mechanism is configured to places the thread in a non-sleep state.
In another illustrative embodiment, a computer program product comprises a computer useable medium having a computer readable program. The computer readable program, when executed on a computing device, causes the computing device to detect that a thread is spinning on a lock at a target address. Responsive to detecting the thread spinning on the lock, the computer readable program causes the computing device to populate a wake-and-go storage array with the target address and place the thread in a sleep state. Responsive to an event associated with the target address, the computer readable program causes the computing device to place the thread in a non-sleep state.
These and other features and advantages of the present invention will be described in, or will become apparent to those of ordinary skill in the art in view of, the following detailed description of the exemplary embodiments of the present invention.
The invention, as well as a preferred mode of use and further objectives and advantages thereof, will best be understood by reference to the following detailed description of illustrative embodiments when read in conjunction with the accompanying drawings, wherein:
With reference now to the figures and in particular with reference to
Processor cards 111a-111n connect to symmetric multiprocessing (SMP) bus 115. SMP bus 115 supports a system planar 120 that contains processor cards 111a-111n and memory cards 123. The system planar also contains data switch 121 and memory controller/cache 122. Memory controller/cache 122 supports memory cards 123 that includes local memory 116 having multiple dual in-line memory modules (DIMMs).
Data switch 121 connects to bus bridge 117 and bus bridge 118 located within a native I/O (NIO) planar 124. As shown, bus bridge 118 connects to peripheral components interconnect (PCI) bridges 125 and 126 via system bus 119. PCI bridge 125 connects to a variety of I/O devices via PCI bus 128. As shown, hard disk 136 may be connected to PCI bus 128 via small computer system interface (SCSI) host adapter 130. A graphics adapter 131 may be directly or indirectly connected to PCI bus 128. PCI bridge 126 provides connections for external data streams through network adapter 134 and adapter card slots 135a-135n via PCI bus 127.
An industry standard architecture (ISA) bus 129 connects to PCI bus 128 via ISA bridge 132. ISA bridge 132 provides interconnection capabilities through NIO controller 133 having serial connections Serial 1 and Serial 2. A floppy drive connection 137, keyboard connection 138, and mouse connection 139 are provided by NIO controller 133 to allow data processing system 100 to accept data input from a user via a corresponding input device. In addition, non-volatile RAM (NVRAM) 140 provides a non-volatile memory for preserving certain types of data from system disruptions or system failures, such as power supply problems. A system firmware 141 also connects to ISA bus 129 for implementing the initial Basic Input/Output System (BIOS) functions. A service processor 144 connects to ISA bus 129 to provide functionality for system diagnostics or system servicing.
The operating system (OS) resides on hard disk 136, which may also provide storage for additional application software for execution by data processing system. NVRAM 140 stores system variables and error information for field replaceable unit (FRU) isolation. During system startup, the bootstrap program loads the operating system and initiates execution of the operating system. To load the operating system, the bootstrap program first locates an operating system kernel type from hard disk 136, loads the OS into memory, and jumps to an initial address provided by the operating system kernel. Typically, the operating system loads into random-access memory (RAM) within the data processing system. Once loaded and initialized, the operating system controls the execution of programs and may provide services such as resource allocation, scheduling, input/output control, and data management.
The present invention may be executed in a variety of data processing systems utilizing a number of different hardware configurations and software such as bootstrap programs and operating systems. The data processing system 100 may be, for example, a stand-alone system or part of a network such as a local-area network (LAN) or a wide-area network (WAN).
In accordance with the illustrative embodiment, a wake-and-go mechanism for a microprocessor includes wake-and-go array 222 attached to the SMP fabric. The SMP fabric is a communication medium through which processors communicate. The SMP fabric may comprise a single SMP bus or a system of busses, for example. In the depicted example, the SMP fabric comprises bus 220. A thread, such as thread 202, for example, may include instructions that indicate that the thread is waiting for an event. The event may be an asynchronous event, which is an event that happens independently in time with respect to execution of the thread in the data processing system. For example, an asynchronous event may be a temperature value reaching a particular threshold, a stock price falling below a given threshold, or the like. Alternatively, the event may be related in some way to execution of the thread. For example, the event may be obtaining a lock for exclusive access to a database record or the like.
Typically, the instructions may comprise a series of get-and-compare sequences; however, in accordance with the illustrative embodiment, the instructions include instructions, calls to operating system 210 or API 212, or calls to a background sleeper thread, such as thread 204, for example, to update wake-and-go array 222. These instructions store a target address in wake-and-go array 222, where the event the thread is waiting for is associated with the target address. After updating wake-and-go array 222 with the target address, thread 202 may go to sleep.
When thread 202 goes to sleep, operating system 210 or other software or hardware saves the state of thread 202 in thread state storage 234, which may be allocated from memory 232 or may be a hardware private array within the processor (not shown) or pervasive logic (not shown). When a thread is put to sleep, i.e., removed from the run queue of a processor, the operating system must store sufficient information on its operating state such that when the thread is again scheduled to run on the processor, the thread can resume operation from an identical position. This state information is sometime referred to as the thread's “context.” The state information may include, for example, address space, stack space, virtual address space, program counter, instruction register, program status word, and the like.
If a transaction appears on bus 220 that modifies a value at an address in wake-and-go array 222, then operating system 210 may wake thread 202. Operating system 210 wakes thread 202 by recovering the state of thread 202 from thread state storage 234. Thread 202 may then determine whether the transaction corresponds to the event for which the thread was waiting by performing a get-and-compare operation, for instance. If the transaction is the event for which the thread was waiting, then thread 202 will perform work. However, if the transaction is not the event, then thread 202 will go back to sleep. Thus, thread 202 only performs a get-and-compare operation if there is a transaction that modifies the target address.
Alternatively, operating system 210 or a background sleeper thread, such as thread 204, may determine whether the transaction is the event for which the thread was waiting. Before being put to sleep, thread 202 may update a data structure in the operating system or background sleeper thread with a value for which it is waiting.
In one exemplary embodiment, wake-and-go array 222 may be a content addressable memory (CAM). A CAM is a special type of computer memory often used in very high speed searching applications. A CAM is also known as associative memory, associative storage, or associative array, although the last term is more often used for a programming data structure. Unlike a random access memory (RAM) in which the user supplies a memory address and the RAM returns the data value stored at that address, a CAM is designed such that the user supplies a data value and the CAM searches its entire memory to see if that data value is stored within the CAM. If the data value is found, the CAM returns a list of one or more storage addresses where the data value was found. In some architectures, a CAM may return the data value or other associated pieces of data. Thus, a CAM may be considered the hardware embodiment of what in software terms would be called an associative array.
Thus, in the exemplary embodiment, wake-and-go array 222 may comprise a CAM and associated logic that will be triggered if a transaction appears on bus 220 that modifies an address stored in the CAM. A transaction that modifies a value at a target address may be referred to as a “kill”; thus, wake-and-go array 222 may be said to be “snooping kills.” In this exemplary embodiment, the data values stored in the CAM are the target addresses at which threads are waiting for something to be written. The address at which a data value, a given target address, is stored is referred to herein as the storage address. Each storage address may refer to a thread that is asleep and waiting for an event. Wake-and-go array 222 may store multiple instances of the same target address, each instance being associated with a different thread waiting for an event at that target address. Thus, when wake-and-go array 222 snoops a kill at a given target address, wake-and-go array 222 may return one or more storage addresses that are associated with one or more sleeping threads.
In one exemplary embodiment, software may save the state of thread 202, for example. The state of a thread may be about 1000 bytes, for example. Thread 202 is then put to sleep. When wake-and-go array 222 snoops a kill at a given target address, logic associated with wake-and-go array 222 may generate an exception. The processor that was running thread 202 sees the exception and performs a trap. A trap is a type of synchronous interrupt typically caused by an exception condition, in this case a kill at a target address in wake-and-go array 222. The trap may result in a switch to kernel mode, wherein the operating system 210 performs some action before returning control to the originating process. In this case, the trap results in other software, such as operating system 210, for example, to reload thread 202 from thread state storage 234 and to continue processing of the active threads on the processor.
In an illustrative embodiment, when a thread, such as thread 302, first starts executing, a wake-and-go mechanism automatically allocates space for thread state in hardware private array 308 and space for a target address and other information, if any, in wake-and-go array 322. Allocating space may comprise reserving an address range in a memory, such as a static random access memory, that is hidden in hardware, such as processor 300, for example. Alternatively, if hardware private array 308 comprises a reserved portion of system memory, such as memory 332, then the wake-and-go mechanism may request a sufficient portion of memory, such as 1000 bytes, for example, to store thread state for that thread.
Thus hardware private array 308 may be a memory the size of which matches the size of thread state information for all running threads. When a thread ends execution and is no longer in the run queue of processor 300, the wake-and-go mechanism de-allocates the space for the thread state information for that thread.
In accordance with the illustrative embodiment, a wake-and-go mechanism for a microprocessor includes wake-and-go array 322 attached to the SMP fabric. The SMP fabric is a communication medium through which processors communicate. The SMP fabric may comprise a single SMP bus or a system of busses, for example. In the depicted example, the SMP fabric comprises bus 320. A thread, such as thread 302, for example, may include instructions that indicate that the thread is waiting for an event. The event may be an asynchronous event, which is an event that happens independently in time with respect to execution of the thread in the data processing system. For example, an asynchronous event may be a temperature value reaching a particular threshold, a stock price falling below a given threshold, or the like. Alternatively, the event may be related in some way to execution of the thread. For example, the event may be obtaining a lock for exclusive access to a database record or the like.
Typically, the instructions may comprise a series of get-and-compare sequences; however, in accordance with the illustrative embodiment, the instructions include instructions, calls to operating system 310 or API 312, or calls to a background sleeper thread, such as thread 304, for example, to update wake-and-go array 322. These instructions store a target address in wake-and-go array 322, where the event the thread is waiting for is associated with the target address. After updating wake-and-go array 322 with the target address, thread 302 may go to sleep.
When thread 302 goes to sleep, operating system 310 or other software or hardware within processor 300 saves the state of thread 302 in hardware private array 308 within processor 300. In an alternative embodiment, hardware private array may be embodied within pervasive logic associated with bus 320 or wake-and-go array 322. When a thread is put to sleep, i.e., removed from the run queue of processor 300, operating system 310 must store sufficient information on its operating state such that when the thread is again scheduled to run on processor 300, the thread can resume operation from an identical position. This state information is sometime referred to as the thread's “context.” The state information may include, for example, address space, stack space, virtual address space, program counter, instruction register, program status word, and the like, which may comprise about 1000 bytes, for example.
If a transaction appears on bus 320 that modifies a value at an address in wake-and-go array 322, then operating system 310 may wake thread 302. Operating system 310 wakes thread 302 by recovering the state of thread 302 from hardware private array 308. Thread 302 may then determine whether the transaction corresponds to the event for which the thread was waiting by performing a get-and-compare operation, for instance. If the transaction is the event for which the thread was waiting, then thread 302 will perform work. However, if the transaction is not the event, then thread 302 will go back to sleep. Thus, thread 302 only performs a get-and-compare operation if there is a transaction that modifies the target address.
Hardware private array 308 is a thread state storage that is embedded within processor 300 or within logic associated with bus 320 or wake-and-go array 322. Hardware private array 308 may be a memory structure, such as a static random access memory (SRAM), which is dedicated to storing thread state for sleeping threads that have a target address in wake-and-go array 322. In an alternative embodiment, hardware private array 308 may be a hidden area of memory 332. Hardware private array 308 is private because it cannot be addressed by the operating system or work threads.
Hardware private array 308 and/or wake-and-go array 322 may have a limited storage area. Therefore, each thread may have an associated priority. The wake-and-go mechanism described herein may store the priority of sleeping threads with the thread state in hardware private array 308. Alternatively, the wake-and-go mechanism may store the priority with the target address in wake-and-go array 322. When a thread, such as thread 302, for example, goes to sleep, the wake-and-go mechanism may determine whether there is sufficient room to store the thread state of thread 302 in hardware private array 308. If there is sufficient space, then the wake-and-go mechanism simply stores the thread state in hardware private array 308.
If there is insufficient space in hardware private array 308, then if the hardware private array is a portion of system memory 332, then the wake-and-go mechanism may ask for more of system memory 332 to be allocated to the hardware private array 308.
If there is insufficient space in hardware private array 308, then the wake-and-go mechanism may compare the priority of thread 302 to the priorities of the threads already stored in hardware private array 308 and wake-and-go array 322. If thread 302 has a lower priority than all of the threads already stored in hardware private array 208 and wake-and-go array 322, then thread 302 may default to a flee model, such as polling or interrupt as in the prior art. If thread 302 has a higher priority than at least one thread already stored in hardware private array 308 and wake-and-go array 322, then the wake-and-go mechanism may “punt” a lowest priority thread, meaning the thread is removed from hardware private array 308 and wake-and-go array 322 and converted to a flee model.
In an alternative embodiment, priority may be determined by other factors. For example, priority may be time driven. That is, the wake-and-go mechanism may simply punt the stalest thread in hardware private array 308 and wake-and-go array 322.
Alternatively, operating system 310 or a background sleeper thread, such as thread 304, may determine whether the transaction is the event for which the thread was waiting. Before being put to sleep, thread 302 may update a data structure in the operating system or background sleeper thread with a value for which it is waiting.
In one exemplary embodiment, wake-and-go array 322 may be a content addressable memory (CAM). A CAM is a special type of computer memory often used in very high speed searching applications. A CAM is also known as associative memory, associative storage, or associative array, although the last term is more often used for a programming data structure. Unlike a random access memory (RAM) in which the user supplies a memory address and the RAM returns the data value stored at that address, a CAM is designed such that the user supplies a data value and the CAM searches its entire memory to see if that data value is stored within the CAM. If the data value is found, the CAM returns a list of one or more storage addresses where the data value was found. In some architectures, a CAM may return the data value or other associated pieces of data. Thus, a CAM may be considered the hardware embodiment of what in software terms would be called an associative array.
Thus, in the exemplary embodiment, wake-and-go array 322 may comprise a CAM and associated logic that will be triggered if a transaction appears on bus 320 that modifies an address stored in the CAM. A transaction that modifies a value at a target address may be referred to as a “kill”; thus, wake-and-go array 322 may be said to be “snooping kills.” In this exemplary embodiment, the data values stored in the CAM are the target addresses at which threads are waiting for something to be written. The address at which a data value, a given target address, is stored is referred to herein as the storage address. Each storage address may refer to a thread that is asleep and waiting for an event. Wake-and-go array 322 may store multiple instances of the same target address, each instance being associated with a different thread waiting for an event at that target address. Thus, when wake-and-go array 322 snoops a kill at a given target address, wake-and-go array 322 may return one or more storage addresses that are associated with one or more sleeping threads.
When a transaction appears on SMP fabric 420 with an address that matches the target address A2, array 422 returns the storage address that is associated with thread 410. The operating system (not shown) or some other hardware or software then wakes thread 410 by retrieving the thread state information from thread state storage 412 and placing the thread in the run queue for the processor. Thread 410 may then perform a compare-and-branch operation to determine whether the value written to the target address represents the event for which thread 410 is waiting. In the depicted example, the value written to the target address does not represent the event for which thread 410 is waiting; therefore, thread 410 goes back to sleep.
In one exemplary embodiment, software may save the state of thread 410, for example. Thread 410 is then put to sleep. When wake-and-go array 422 snoops a kill at target address A2, logic associated with wake-and-go array 422 may generate an exception. The processor sees the exception and performs a trap, which results in a switch to kernel mode, wherein the operating system may perform some action before returning control to the originating process. In this case, the trap results in other software to reload thread 410 from thread state storage 412 and to continue processing of the active threads on the processor.
In one exemplary embodiment, thread state storage 412 is a hardware private array. Thread state storage 412 is a memory that is embedded within the processor or within logic associated with bus 420 or wake-and-go array 422. Thread state storage 412 may comprise memory cells that are dedicated to storing thread state for sleeping threads that have a target address in wake-and-go array 422. In an alternative embodiment, thread state storage 412 may be a hidden area of memory 332, for example. Thread state storage 412 may private in that it cannot be addressed by the operating system or work threads.
Turning to
When a transaction appears on SMP fabric 420 with an address that matches the target address A2, array 422 returns the storage address that is associated with thread 410. The operating system (not shown) or some other hardware or software then wakes thread 410 by retrieving the thread state information from thread state storage 412 and placing the thread in the run queue for the processor. Thread 410 may then perform a compare-and-branch operation to determine whether the value written to the target address represents the event for which thread 410 is waiting. In the depicted example, the value written to the target address does represent the event for which thread 410 is waiting; therefore, thread 410 updates the array to remove the target address from array 422, and performs more work.
When a transaction appears on SMP fabric 520 with an address that matches the target address A2, array 522 returns the storage address that is associated with thread 510. Operating system 530 or some other hardware or software then wakes thread 510 by retrieving the thread state information from thread state storage 512 and placing the thread in the run queue for the processor. Thread 510 may then perform a compare-and-branch operation to determine whether the value written to the target address represents the event for which thread 510 is waiting. In the depicted example, the value written to the target address does not represent the event for which thread 510 is waiting; therefore, thread 510 goes back to sleep.
In one exemplary embodiment, software may save the state of thread 510, for example. Thread 510 is then put to sleep. When wake-and-go array 522 snoops a kill at target address A2, logic associated with wake-and-go array 522 may generate an exception. The processor sees the exception and performs a trap, which results in a switch to kernel mode, wherein operating system 530 may perform some action before returning control to the originating process. In this case, the trap results in the operating system 530 to reload thread 510 from thread state storage 512 and to continue processing of the active threads on the processor.
In one exemplary embodiment, thread state storage 512 is a hardware private array. Thread state storage 512 is a memory that is embedded within the processor or within logic associated with bus 520 or wake-and-go array 522. Thread state storage 512 may comprise memory cells that are dedicated to storing thread state for sleeping threads that have a target address in wake-and-go array 522. In an alternative embodiment, thread state storage 512 may be a hidden area of memory 332, for example. Thread state storage 512 may private in that it cannot be addressed by the operating system or work threads.
Turning to
When a transaction appears on SMP fabric 520 with an address that matches the target address A2, array 522 returns the storage address that is associated with thread 510. Operating system 530 or some other hardware or software then wakes thread 510 by retrieving the thread state information from thread state storage 512 and placing the thread in the run queue for the processor. Thread 510 may then perform a compare-and-branch operation to determine whether the value written to the target address represents the event for which thread 510 is waiting. In the depicted example, the value written to the target address does represent the event for which thread 510 is waiting; therefore, thread 510 updates the array to remove the target address from array 522, and performs more work.
When a transaction appears on SMP fabric 620 with an address that matches the target address A2, array 622 returns the storage address that is associated with thread 610. Operating system 630 or some other hardware or software then wakes thread 610 by retrieving the thread state information from thread state storage 612 and placing the thread in the run queue for the processor. Background sleeper thread 640 may then perform a compare-and-branch operation to determine whether the value written to the target address represents the event for which thread 610 is waiting. If the value written to the target address does represent the event for which thread 610 is waiting, then background sleeper thread 640 does nothing. However, if the value written to the target address does represent the event for which thread 610 is waiting, then background sleeper thread 640 wakes thread 640. Thereafter, thread 610 updates the array 622 to remove the target address from array 622 and performs more work.
In one exemplary embodiment, software may save the state of thread 610, for example. Thread 610 is then put to sleep. When wake-and-go array 622 snoops a kill at target address A2, logic associated with wake-and-go array 622 may generate an exception. The processor sees the exception and performs a trap, which results in a switch to kernel mode, wherein the operating system may perform some action before returning control to the originating process. In this case, the trap results in other software, such as background sleeper thread 640 to reload thread 610 from thread state storage 612 and to continue processing of the active threads on the processor.
In one exemplary embodiment, thread state storage 612 is a hardware private array. Thread state storage 612 is a memory that is embedded within the processor or within logic associated with bus 620 or wake-and-go array 622. Thread state storage 612 may comprise memory cells that are dedicated to storing thread state for sleeping threads that have a target address in wake-and-go array 622. In an alternative embodiment, thread state storage 612 may be a hidden area of memory 332, for example. Thread state storage 612 may private in that it cannot be addressed by the operating system or work threads.
Accordingly, blocks of the flowchart illustrations support combinations of means for performing the specified functions, combinations of steps for performing the specified functions and program instruction means for performing the specified functions. It will also be understood that each block of the flowchart illustrations, and combinations of blocks in the flowchart illustrations, can be implemented by special purpose hardware-based computer systems which perform the specified functions or steps, or by combinations of special purpose hardware and computer instructions.
Furthermore, the flowcharts are provided to demonstrate the operations performed within the illustrative embodiments. The flowcharts are not meant to state or imply limitations with regard to the specific operations or, more particularly, the order of the operations. The operations of the flowcharts may be modified to suit a particular implementation without departing from the spirit and scope of the present invention.
With reference now to
If the end of the thread is not reached in block 706, the processor determines whether the next instruction updates the wake-and-go array (block 708). An instruction to update the wake-and-go array may be a specialized processor instruction, an operating system call, a call to a background sleeper thread, or a call to an application programming interface. If the next instruction does not update the wake-and-go array, operation returns to block 704 to perform more work.
If the next instruction does update the wake-and-go array in block 708, the processor updates the array with a target address associated with an event for which the thread is waiting (block 710). The update to the wake-and-go array may be made by the thread through a specialized processor instruction, the operating system, or a background sleeper thread. Next, the operating system then determines whether to put the thread to sleep (block 712). The operating system may keep the thread active in the processor if the processor is underutilized, for instance; however, the operating system may put the thread to sleep if there are other threads waiting to be run on the processor. If the operating system determines that the thread is to remain active, operation returns to block 704 to perform more work, in which case the thread may simply wait for the event.
In one exemplary embodiment, f the operating system determines that the thread is to be put to sleep in block 712, then the operating system or some other software or hardware saves the state of the thread (block 714) and puts the thread to sleep (block 716). Thereafter, operation proceeds to
In an alternative embodiment, if the operating system determines that the thread is to be put to sleep in block 712, then the operating system or some other software or hardware saves the state of the thread (block 714) in the hardware private array and puts the thread to sleep (block 716). Thereafter, operation proceeds to
With reference now to
In one exemplary embodiment, when the wake-and-go mechanism snoops a kill at a target address, the wake-and-go mechanism may generate an exception. The processor sees the exception and performs a trap, which results in a switch to kernel mode, wherein the operating system may perform some action before returning control to the originating process. In this case, the trap results in other software to reload the thread from the thread state storage and to continue processing of the active threads on the processor in block 702.
In one exemplary embodiment, when the wake-and-go mechanism snoops a kill at a target address, software or hardware reloads the thread from the hardware private array and the processor continues processing the active threads on the processor in block 702.
If the kill does not correspond to the event for which the thread is waiting in block 722, then operation returns to block 718 to snoop a kill from the SMP fabric. In
In an alternative embodiment, the wake-and-go mechanism may be a combination of logic associated with the wake-and-go array and software within the thread itself. In such an embodiment, the thread will wake every time there is a kill to the target address. The thread itself may then perform a compare operation to determine whether to perform more work or to go back to sleep. If the thread decides to go back to sleep, it may again save the state of the thread. The over head for waking the thread every time there is a kill to the target address will likely be much less than polling or event handlers.
Prioritization of Threads
If the end of the thread is not reached in block 806, the processor determines whether the next instruction updates the wake-and-go array (block 808). An instruction to update the wake-and-go array may be a specialized processor instruction, an operating system call, a call to a background sleeper thread, or a call to an application programming interface. If the next instruction does not update the wake-and-go array, operation returns to block 804 to perform more work.
If the next instruction does update the wake-and-go array in block 808, the wake-and-go mechanism determines whether there is sufficient space for the thread state in the hardware private array (block 810). If there is sufficient space available, the wake-and-go mechanism allocates space for the thread state in the hardware private array (block 812). This allocation may simply comprise reserving the requisite space for the thread space, which may be about 1000 bytes, for example. If the hardware private array is reserved portion of system memory, then allocating space may comprise requesting more system memory to be reserved for the hardware private array. Then, the wake-and-go mechanism saves the state of the thread in the hardware private array (block 814), updates the wake-and-go array with the target address and other information, if any (block 816), and puts the thread to sleep (block 818). Thereafter, operation proceeds to
If there is insufficient space for the thread state available in the hardware private array in block 810, then the wake-and-go mechanism determines whether there is at least one lower priority thread in the hardware private array or wake-and-go array (block 820). As described above, each thread may have an associated priority parameter that is stored in the hardware private array or wake-and-go array. Alternatively, priority may be determined by other factors, such as staleness. If there is at least one lower priority thread in the hardware private array, the wake-and-go mechanism removes the lower priority thread from the hardware private array and wake-and-go array (block 822) and converts the lower priority thread to a flee model (block 824). Thereafter, operation proceeds to block 814 to save the state of the new thread, update the wake-and-go array, and put the thread to sleep.
If there is not a lower priority thread in the hardware private array in block 820, the wake-and-go mechanism converts the new thread to a flee model (block 826). Thereafter, operation proceeds to block 818 to put the thread to sleep.
With reference now to
In one exemplary embodiment, when the wake-and-go mechanism snoops a kill at a target address, software or hardware reloads the thread from the hardware private array and the processor continues processing the active threads on the processor in block 802.
If the kill does not correspond to the event for which the thread is waiting in block 830, then operation returns to block 826 to snoop a kill from the SMP fabric. In
Dynamic Allocation in Hardware Private Array
If the end of the thread is not reached in block 908, the processor determines whether the next instruction updates the wake-and-go array (block 912). An instruction to update the wake-and-go array may be a specialized processor instruction, an operating system call, a call to a background sleeper thread, or a call to an application programming interface. If the next instruction does not update the wake-and-go array, operation returns to block 906 to perform more work.
If the next instruction does update the wake-and-go array in block 912, the wake-and-go mechanism updates the wake-and-go array with a target address associated with an event for which the thread is waiting (block 914). The update to the wake-and-go array may be made by the thread through a specialized processor instruction, the operating system, or a background sleeper thread. Next, the operating system then determines whether to put the thread to sleep (block 916). The operating system may keep the thread active in the processor if the processor is underutilized, for instance; however, the operating system may put the thread to sleep if there are other threads waiting to be run on the processor. If the operating system determines that the thread is to remain active, operation returns to block 906 to perform more work, in which case the thread may simply wait for the event.
If the operating system determines that the thread is to be put to sleep in block 916, then the operating system or some other software or hardware saves the state of the thread (block 918) in the hardware private array and puts the thread to sleep (block 920). Thereafter, operation proceeds to
With reference now to
If the kill does not correspond to the event for which the thread is waiting in block 922, then operation returns to block 922 to snoop a kill from the SMP fabric. In
Hardware Wake-and-Go Mechanism
Wake-and-go mechanism 1008 is a hardware implementation within processor 1000. In an alternative embodiment, hardware wake-and-go mechanism 1008 may be logic associated with wake-and-go array 1022 attached to bus 1020 or a separate, dedicated wake-and-go engine as described in further detail below.
In accordance with the illustrative embodiment, hardware wake-and-go mechanism 1008 is provided within processor 1000 and wake-and-go array 1022 is attached to the SMP fabric. The SMP fabric is a communication medium through which processors communicate. The SMP fabric may comprise a single SMP bus or a system of busses, for example. In the depicted example, the SMP fabric comprises bus 1020. A thread, such as thread 1002, for example, may include instructions that indicate that the thread is waiting for an event. The event may be an asynchronous event, which is an event that happens independently in time with respect to execution of the thread in the data processing system. For example, an asynchronous event may be a temperature value reaching a particular threshold, a stock price falling below a given threshold, or the like. Alternatively, the event may be related in some way to execution of the thread. For example, the event may be obtaining a lock for exclusive access to a database record or the like.
Processor 1000 may pre-fetch instructions from storage (not shown) to memory 1032. These instructions may comprise a get-and-compare sequence, for example. Wake-and-go mechanism 1008 within processor 1000 may examine the instruction stream as it is being pre-fetched and recognize the get-and-compare sequence as a programming idiom that indicates that thread 1002 is waiting for data at a particular target address. A programming idiom is a sequence of programming instructions that occurs often and is recognizable as a sequence of instructions. In this example, an instruction sequence that includes load (LD), compare (CMP), and branch (BC) commands represents a programming idiom that indicates that the thread is waiting for data to be written to a particular target address. In this case, wake-and-go mechanism 1008 recognizes such a programming idiom and may store the target address in wake-and-go array 1022, where the event the thread is waiting for is associated with the target address. After updating wake-and-go array 1022 with the target address, wake-and-go mechanism 1008 may put thread 1002 to sleep.
Wake-and-go mechanism 1008 also may save the state of thread 1002 in thread state storage 1034, which may be allocated from memory 1032 or may be a hardware private array within the processor (not shown) or pervasive logic (not shown). When a thread is put to sleep, i.e., removed from the run queue of a processor, the operating system must store sufficient information on its operating state such that when the thread is again scheduled to run on the processor, the thread can resume operation from an identical position. This state information is sometime referred to as the thread's “context.” The state information may include, for example, address space, stack space, virtual address space, program counter, instruction register, program status word, and the like.
If a transaction appears on bus 1020 that modifies a value at an address in wake-and-go array 1022, then wake-and-go mechanism 1008 may wake thread 1002. Wake-and-go mechanism 1008 may wake thread 1002 by recovering the state of thread 1002 from thread state storage 1034. Thread 1002 may then determine whether the transaction corresponds to the event for which the thread was waiting by performing a get-and-compare operation, for instance. If the transaction is the event for which the thread was waiting, then thread 1002 will perform work. However, if the transaction is not the event, then thread 1002 will go back to sleep. Thus, thread 1002 only performs a get-and-compare operation if there is a transaction that modifies the target address.
Alternatively, operating system 1010 or a background sleeper thread, such as thread 1004, may determine whether the transaction is the event for which the thread was waiting. Before being put to sleep, thread 1002 may update a data structure in the operating system or background sleeper thread with a value for which it is waiting.
In one exemplary embodiment, wake-and-go array 1022 may be a content addressable memory (CAM). A CAM is a special type of computer memory often used in very high speed searching applications. A CAM is also known as associative memory, associative storage, or associative array, although the last term is more often used for a programming data structure. Unlike a random access memory (RAM) in which the user supplies a memory address and the RAM returns the data value stored at that address, a CAM is designed such that the user supplies a data value and the CAM searches its entire memory to see if that data value is stored within the CAM. If the data value is found, the CAM returns a list of one or more storage addresses where the data value was found. In some architectures, a CAM may return the data value or other associated pieces of data. Thus, a CAM may be considered the hardware embodiment of what in software terms would be called an associative array.
Thus, in an exemplary embodiment, wake-and-go array 1022 may comprise a CAM and associated logic that will be triggered if a transaction appears on bus 1020 that modifies an address stored in the CAM. A transaction that modifies a value at a target address may be referred to as a “kill”; thus, wake-and-go array 1022 may be said to be “snooping kills.” In this exemplary embodiment, the data values stored in the CAM are the target addresses at which threads are waiting for something to be written. The address at which a data value, a given target address, is stored is referred to herein as the storage address. Each storage address may refer to a thread that is asleep and waiting for an event. Wake-and-go array 1022 may store multiple instances of the same target address, each instance being associated with a different thread waiting for an event at that target address. Thus, when wake-and-go array 1022 snoops a kill at a given target address, wake-and-go array 1022 may return one or more storage addresses that are associated with one or more sleeping threads.
The wake-and-go mechanism may recognize the poll operation idiom. When the wake-and-go mechanism recognizes such a programming idiom, the wake-and-go mechanism may store the target address from GPR A in the wake-and-go array, where the event the thread is waiting for is associated with the target address. After updating the wake-and-go array with the target address, the wake-and-go mechanism may put the thread to sleep.
With reference now to
The wake-and-go mechanism may perform a look-ahead polling operation for each programming idiom. In the depicted example, idioms A, B, C, and D fail. In those cases, the wake-and-go mechanism may update wake-and-go array 1122. In this example, idiom E passes; therefore, there is no need to update wake-and-go array 1122, because there is no need to put the thread to sleep when idiom E executes.
In one exemplary embodiment, the wake-and-go mechanism may update wake-and-go array 1122 only if all of the look-ahead polling operations fail. If at least one look-ahead polling operation passes, then the wake-and-go mechanism may consider each idiom as it occurs during execution.
When a transaction appears on SMP fabric 1220 with an address that matches the target address A2, array 1222 returns the storage address that is associated with thread 1210. The wake-and-go mechanism then wakes thread 1210 by retrieving the thread state information from thread state storage 1212 and placing the thread in the run queue for the processor. Thread 1210 may then perform a compare-and-branch operation to determine whether the value written to the target address represents the event for which thread 1210 is waiting. In the depicted example, the value written to the target address does not represent the event for which thread 1210 is waiting; therefore, thread 1210 goes back to sleep.
Turning to
When a transaction appears on SMP fabric 1220 with an address that matches the target address A2, array 1222 returns the storage address that is associated with thread 1210. The wake-and-go mechanism then wakes thread 1210 by retrieving the thread state information from thread state storage 1212 and placing the thread in the run queue for the processor. Thread 1210 may then perform a compare-and-branch operation to determine whether the value written to the target address represents the event for which thread 1210 is waiting. In the depicted example, the value written to the target address does represent the event for which thread 1210 is waiting; therefore, thread 1210 updates the array to remove the target address from array 1222, and performs more work.
If the end of the thread is not reached in block 1306, the processor determines whether the next instructions comprise a wake-and-go idiom, such as a polling operation, for example (block 1308). A wake-and-go idiom may comprise a series of instructions, such as a load, compare, and branch sequence, for example. If the next instructions doe not comprise a wake-and-go idiom, the wake-and-go mechanism returns to block 1304 to perform more work.
If the next instructions do comprise a wake-and-go idiom in block 1308, the wake-and-go mechanism determines whether to put the thread to sleep (block 1310). The wake-and-go mechanism may keep the thread active in the processor if the processor is underutilized, for instance; however, the wake-and-go mechanism may put the thread to sleep if there are other threads waiting to be run on the processor. If the wake-and-go mechanism determines that the thread is to remain active, operation returns to block 1304 to perform more work, in which case the thread may simply wait for the event.
If the wake-and-go mechanism determines that the thread is to be put to sleep in block 1310, then the wake-and-go mechanism updates the array with a target address associated with an event for which the thread is waiting (block 1312). The update to the wake-and-go array may be made by the thread through a specialized processor instruction, the operating system, or a background sleeper thread. Next, the wake-and-go mechanism then saves the state of the thread (block 1314) and puts the thread to sleep (block 1316). Thereafter, operation proceeds to
With reference now to
If the kill does not correspond to the event for which the thread is waiting in block 1322, then operation returns to block 1318 to snoop a kill from the SMP fabric. In
Look-Ahead Polling
When a transaction appears on SMP fabric 1420 with an address that matches the target address A2, array 1422 returns the storage address that is associated with thread 1410. The wake-and-go mechanism then wakes thread 1410 by retrieving the thread state information from thread state storage 1412 and placing the thread in the run queue for the processor. Thread 1410 may then perform a compare-and-branch operation to determine whether the value written to the target address represents the event for which thread 1410 is waiting. In the depicted example, the value written to the target address does not represent the event for which thread 1410 is waiting; therefore, thread 1410 goes back to sleep.
Turning to
When a transaction appears on SMP fabric 1420 with an address that matches the target address A2, array 1422 returns the storage address that is associated with thread 1410. The wake-and-go mechanism then wakes thread 1410 by retrieving the thread state information from thread state storage 1412 and placing the thread in the run queue for the processor. Thread 1410 may then perform a compare-and-branch operation to determine whether the value written to the target address represents the event for which thread 1410 is waiting. In the depicted example, the value written to the target address does represent the event for which thread 1410 is waiting; therefore, thread 1410 updates the array to remove the target address from array 1422, and performs more work.
If the wake-and-go look-ahead engine has not reached the end of the thread in block 1504, the wake-and-go look-ahead engine determines whether the thread comprises at least one wake-and-go programming idiom that indicates that the thread is waiting for a data value to be written to a particular target address (block 1506). If the thread does not comprise a wake-and-go programming idiom, operation ends.
If the thread does comprise at least one wake-and-go programming idiom in block 1506, then the wake-and-go look-ahead engine performs load and compare operations for the at least one wake-and-go programming idiom (block 1508). Thereafter, the wake-and-go look-ahead engine determines whether all of the load and compare operations fail (block 1510). If all of the look-ahead polling operations fail, then the wake-and-go look-ahead engine updates the wake-and-go array for the at least one programming idiom (block 1512), and operation ends. If at least one look-ahead polling operation succeeds, then operation ends without updating the wake-and-go array. In an alternative embodiment, the look-ahead engine may set up the wake-and-go array without performing look-ahead polling.
Speculative Execution
Look-ahead wake-and-go engine 1620 analyzes the instructions in thread 410 ahead of execution. Look-ahead wake-and-go engine 1620 may recognize the poll operation idioms and perform look-ahead polling operations for each idiom. If the look-ahead polling operation fails, the look-ahead wake-and-go engine 1620 populates wake-and-go array 1622 with the target address. In the depicted example from
If a look-ahead polling operation succeeds, look-ahead wake-and-go engine 1620 may record an instruction address for the corresponding idiom so that the wake-and-go mechanism may have thread 1610 perform speculative execution at a time when thread 1610 is waiting for an event. During execution, when the wake-and-go mechanism recognizes a programming idiom, the wake-and-go mechanism may store the thread state in thread state storage 1612. Instead of putting thread 1610 to sleep, the wake-and-go mechanism may perform speculative execution.
When a transaction appears on SMP fabric 1620 with an address that matches the target address A1, array 1622 returns the storage address that is associated with thread 1610 to the wake-and-go mechanism. The wake-and-go mechanism then returns thread 1610 to the state at which idiom A was encountered by retrieving the thread state information from thread state storage 1612. Thread 1610 may then continue work from the point of idiom A.
If the wake-and-go look-ahead engine has not reached the end of the thread in block 1704, the wake-and-go look-ahead engine determines whether next sequence of instructions comprises a wake-and-go programming idiom that indicates that the thread is waiting for a data value to be written to a particular target address (block 1706). If the next sequence of instructions does not comprise a wake-and-go programming idiom, operation returns to block 502 to examine the next sequence of instructions in the thread. A wake-and-go programming idiom may comprise a polling idiom, as described with reference to
If the next sequence of instructions does comprise a wake-and-go programming idiom in block 1706, then the wake-and-go look-ahead engine performs load and compare operations for the wake-and-go programming idiom (block 1708). Thereafter, the wake-and-go look-ahead engine determines whether the load and compare operation passes (block 1710). If the look-ahead polling operation fails, then the wake-and-go look-ahead engine updates the wake-and-go array for the programming idiom (block 1712), and operation returns to block 1702 to examine the next sequence of instructions in the thread. If the look-ahead polling operation passes, then the look-ahead wake-and-go engine records an instruction address for the successful programming idiom to be used for speculative execution later (block 1714). Thereafter, operation ends.
If the end of the thread is not reached in block 1806, the processor determines whether the next instructions comprise a wake-and-go idiom, such as a polling operation, for example (block 1808). A wake-and-go idiom may comprise a series of instructions, such as a load, compare, and branch sequence, for example. If the next instructions do not comprise a wake-and-go idiom, the wake-and-go mechanism returns to block 1804 to perform more work.
If the next instructions do comprise a wake-and-go idiom in block 1808, the wake-and-go mechanism saves the state of the thread (block 1810). Then, the wake-and-go mechanism determines whether to perform speculative execution (block 1812). The wake-and-go mechanism may make this determination by determining whether the look-ahead wake-and-go engine previously performed a successful look-ahead polling operation and recorded an instruction address.
If the wake-and-go mechanism determines that the processor cannot perform speculative execution, the wake-and-go mechanism puts the thread to sleep. Thereafter, operation proceeds to
If the wake-and-go mechanism determines that the processor can perform speculative execution from a successful polling idiom, the wake-and-go mechanism begins performing speculative execution from the successfully polled idiom (block 616). Thereafter, operation proceeds to
With reference now to
If the kill does not correspond to the event for which the thread is waiting in block 1822, then operation returns to block 1818 to snoop a kill from the SMP fabric. In
Data Monitoring
Returning to
The get-and-compare sequence may load a data value from a target address, perform a compare operation based on an expected data value, and branch if the compare operation matches. Thus, the get-and-compare sequence had three basic elements: an address, an expected data value, and a comparison type. The comparison type may be, for example, equal to (=), less than (<), greater than (>), less than or equal to (≦), or greater than or equal to (≧) Thus, wake-and-go mechanism 1008 may store the address, data value, and comparison value in wake-and-go array 1022.
Thread 1002 may alternatively include specialized processor instructions, operating system calls, or application programming interface (API) calls that instruct wake-and-go mechanism 1008 to populate wake-and-go array 1022 with a given address, data value, and comparison type.
Wake-and-go mechanism 1008 also may save the state of thread 1002 in thread state storage 1034, which may be allocated from memory 1032 or may be a hardware private array within the processor (not shown) or pervasive logic (not shown). When a thread is put to sleep, i.e., removed from the run queue of a processor, the operating system must store sufficient information on its operating state such that when the thread is again scheduled to run on the processor, the thread can resume operation from an identical position. This state information is sometime referred to as the thread's “context.” The state information may include, for example, address space, stack space, virtual address space, program counter, instruction register, program status word, and the like.
If a transaction appears on bus 1020 that modifies a value at an address where the value satisfies the comparison type in wake-and-go array 1022, then wake-and-go mechanism 1008 may wake thread 1002. Wake-and-go array 1022 may have associated logic that recognizes the target address on bus 1020 and performs the comparison based on the value being written, the expected value stored in wake-and-go array 1022, and the comparison type stored in wake-and-go array 1022. Wake-and-go mechanism 1008 may wake thread 1002 by recovering the state of thread 1002 from thread state storage 1034. Thus, thread 1002 only wakes if there is a transaction that modifies the target address with a value that satisfies the comparison type and expected value.
Thus, in an exemplary embodiment, wake-and-go array 1022 may comprise a CAM and associated logic that will be triggered if a transaction appears on bus 1020 that modifies an address stored in the CAM. A transaction that modifies a value at a target address may be referred to as a “kill”; thus, wake-and-go array 1022 may be said to be “snooping kills.” In this exemplary embodiment, the data values stored in the CAM are the target addresses at which threads are waiting for something to be written, an expected value, and a comparison type. The address at which a data value, a given target address, is stored is referred to herein as the storage address.
Each storage address may refer to a thread that is asleep and waiting for an event. Wake-and-go array 1022 may store multiple instances of the same target address, each instance being associated with a different thread waiting for an event at that target address. The expected values and comparison types may be different. Thus, when wake-and-go array 1022 snoops a kill at a given target address, wake-and-go array 1022 may return one or more storage addresses that are associated with one or more sleeping threads. When wake-and-go array 1022 snoops a kill at the given target address, wake-and-go array 1022 may also return the expected value and comparison type to associated logic that performs the comparison. If the comparison matches, then the associated logic may return a storage address to wake-and-go mechanism 1008 to wake the corresponding thread.
The wake-and-go array of each processor 1902-1908 snoops bus 1920. If a transaction appears on bus 1920 that modifies a value at an address where the value satisfies the comparison type in a wake-and-go array, then the wake-and-go mechanism may wake a thread. Each wake-and-go array may have associated logic that recognizes the target address on bus 1920 and performs the comparison based on the value being written, the expected value stored in the wake-and-go array, and the comparison type stored in the wake-and-go array. Thus, the wake-and-go mechanism may only wake a thread if there is a transaction on bus 1920 that modifies the target address with a value that satisfies the comparison type and expected value.
When a transaction appears on SMP fabric 2020 with an address that matches the target address A2, logic associated with wake-and-go array 2022 may perform a comparison based on the value being written, the expected value D2 and the comparison type T2. If the comparison is a match, then the logic associated with wake-and-go array 2022 returns the storage address that is associated with thread 2010. The wake-and-go mechanism then wakes thread 2010 by retrieving the thread state information from thread state storage 2012 and placing the thread in the run queue for the processor.
Parallel Lock Spinning
Returning to
Wake-and-go mechanism 1008 within processor 1000 may recognize the spinning on lock idiom that indicates that thread 1002 is spinning on a lock. When wake-and-go mechanism 1008 recognizes such a programming idiom, wake-and-go mechanism 1008 may store the target address in wake-and-go array 1022 with a flag to indicate that thread 1002 is spinning on a lock. After updating wake-and-go array 1022 with the target address and setting the lock flag, wake-and-go mechanism 1008 may put thread 1002 to sleep. Thus, wake-and-go mechanism 1008 allows several threads to be spinning on a lock at the same time without using valuable processor resources.
If a transaction appears on bus 1020 that modifies a value at an address in wake-and-go array 1022, then wake-and-go mechanism 1008 may wake thread 1002. Wake-and-go mechanism 1008 may wake thread 1002 by recovering the state of thread 1002 from thread state storage 1034. Thread 1002 may then determine whether the transaction corresponds to the event for which the thread was waiting by performing a get-and-compare operation, for instance. If the lock bit is set in wake-and-go array 1022, then it is highly likely that the transaction is freeing the lock, in which case, wake-and-go mechanism may automatically wake thread 1002.
The processor may then run thread 2130, which performs some work. The wake-and-go mechanism may recognize a spin on lock operation idiom, responsive to which the wake-and-go mechanism stores the target address A2 in wake-and-go array 2122, set the lock bit 2124, and store thread state information for thread 2130 in thread state storage 2112. After updating wake-and-go array 2122 with the target address A2, the wake-and-go mechanism may put the thread 2130 to sleep.
Turning to
If the end of the thread is not reached in block 2206, the processor determines whether the next instructions comprise a spin on lock idiom (block 2208). A spin on lock idiom may comprise a series of instructions, such as a load, compare, and branch sequence, for example. If the next instructions do not comprise a spin on lock idiom, the wake-and-go mechanism returns to block 2204 to perform more work.
If the next instructions do comprise a spin on lock idiom in block 2208, the wake-and-go mechanism updates the array with a target address associated with an event for which the thread is waiting (block 2210) and sets the lock bit in the wake-and-go array (block 2212). The update to the wake-and-go array may be made by the thread through a specialized processor instruction, the operating system, or a background sleeper thread. Next, the wake-and-go mechanism saves the state of the thread (block 2214) and puts the thread to sleep (block 2216). Thereafter, operation proceeds to
With reference now to
If the kill does not correspond to the event for which the thread is waiting in block 2220, then operation returns to block 2218 to snoop a kill from the SMP fabric. In
Central Repository for Wake-and-Go Engine
As stated above with reference to
Wake-and-go engine 2350 snoops bus 2320. If a transaction appears on bus 2320 that modifies a value at an address where the value satisfies the comparison type in a wake-and-go array, then the wake-and-go engine 2350 may wake a thread. Wake-and-go engine 2350 may have associated logic that recognizes the target address on bus 2320 and performs the comparison based on the value being written, the expected value stored in the wake-and-go array, and the comparison type stored in central repository wake-and-go array 2352. Thus, wake-and-go engine 2350 may only wake a thread if there is a transaction on bus 2320 that modifies the target address with a value that satisfies the comparison type and expected value.
The wake-and-go engine 2350 may use the thread ID 2402 to identify the thread and the CPU ID 2404 to identify the processor. Wake-and-go engine 2350 may then place the thread in the run queue for the processor identified by CPU ID 2404. Wake-and-go engine 2350 may also use thread state pointer 2416 to load thread state information, which is used to wake the thread to the proper state.
Programming Idiom Accelerator
In a sense, a wake-and-go mechanism, such as look-ahead wake-and-go engine 2350, is a programming idiom accelerator. A programming idiom is a sequence of programming instructions that occurs often and is recognizable as a sequence of instructions. In the examples described above, an instruction sequence that includes load (LD), compare (CMP), and branch (BC) commands represents a programming idiom that indicates that the thread is waiting for data to be written to a particular target address. Wake-and-go engine 2350 recognizes this idiom as a wake-and-go idiom and accelerates the wake-and-go process accordingly, as described above. Other examples of programming idioms may include spinning on a lock or traversing a linked list.
As another example, if programming idiom accelerator 2550 accelerates lock spinning programming idioms, programming idiom accelerator 2550 may obtain the lock for the processor, if the lock is available, thus making the lock spinning programming sequence of instructions unnecessary. Programming idiom accelerator 2550 may accelerate any known or common sequence of instructions or future sequences of instructions. Although not shown in
As stated above with respect to the wake-and-go engine, programming idiom accelerator 2550 may be a hardware device within the data processing system. In an alternative embodiment, programming idiom accelerator 2550 may be a hardware component within each processor 2502-2508. In another embodiment, programming idiom accelerator 2550 may be software within an operating system running on one or more of processors 2502-2508. Thus, in various implementations or embodiments, programming idiom accelerator 2550 may be software, such as a background sleeper thread or part of an operating system, hardware, or a combination of hardware and software.
In one embodiment, the programming language may include hint instructions that may notify programming accelerator 2550 that a programming idiom is coming.
Idiom begin hint 2604 exposes the programming idiom to the programming idiom accelerator. Thus, the programming idiom accelerator need not perform pattern matching or other forms of analysis to recognize a sequence of instructions. Rather, the programmer may insert idiom hint instructions, such as idiom begin hint 2604, to expose the idiom 2602 to the programming idiom accelerator. Similarly, idiom end hint 2606 may mark the end of the programming idiom; however, idiom end hint 2606 may be unnecessary if the programming idiom accelerator is capable of identifying the sequence of instructions as a recognized programming idiom.
In an alternative embodiment, a compiler may recognize programming idioms and expose the programming idioms to the programming idiom accelerator.
Compiler 2710 includes programming idiom exposing module 2712, which parses high level program code 2702 and identifies sequences of instructions that are recognized programming idioms. Compiler 2710 then compiles the high level program code 2702 into machine instructions and inserts hint instructions to expose the programming idioms. The resulting compiled code is machine code with programming idioms exposed 2714. As machine code 2714 is fetched for execution by a processor, one or more programming idiom accelerators may see a programming idiom coming up and perform an action to accelerate execution.
If the sequence of code includes a recognized programming idiom, the compiler inserts one or more instructions to expose the programming idiom to the programming idiom accelerator (block 2808). The compiler compiles the sequence of code (block 2810). If the sequence of code does not include a recognized programming idiom in block 2806, the compiler proceeds to block 2810 to compile the sequence of code.
After compiling the sequence of code in block 2810, the compiler determines if the end of the high level program code is reached (block 2812). If the end of the program code is not reached, operation returns to block 2804 to consider the next sequence of high level program instructions. If the end of the program code is reached in block 2812, then operation ends.
The compiler may recognize one or more programming idioms from a set of predetermined programming idioms. The set of predetermined programming idioms may correspond to a set of programming idiom accelerators that are known to be supported in the target machine. For example, if the target data processing system has a wake-and-go engine and a linked list acceleration engine, then the compiler may provide hints for these two programming idioms. The hint instructions may be such that they are ignored by a processor or data processing system that does not support programming idiom accelerators.
Thus, the illustrative embodiments solve the disadvantages of the prior art by providing a wake-and-go mechanism for a microprocessor. When a thread is waiting for an event, rather than performing a series of get-and-compare sequences, the thread updates a wake-and-go array with a target address associated with the event. The target address may point to a memory location at which the thread is waiting for a value to be written. The thread may update the wake-and-go array using a processor instruction within the program, a call to the operating system, or a call to a background sleeper thread, for example. The thread then goes to sleep until the event occurs.
The wake-and-go array may be a content addressable memory (CAM). When a transaction appears on the symmetric multiprocessing (SMP) fabric that modifies the value at a target address in the CAM, which is referred to as a “kill,” the CAM returns a list of storage addresses at which the target address is stored. The operating system or a background sleeper thread associates these storage addresses with the threads waiting for an event at the target addresses, and may wake the one or more threads waiting for the event.
It should be appreciated that the illustrative embodiments may take the form of a specialized hardware embodiment, a software embodiment that is executed on a computer system having general processing hardware, or an embodiment containing both specialized hardware and software elements that are executed on a computer system having general processing hardware. In one exemplary embodiment, the mechanisms of the illustrative embodiments are implemented in a software product, which may include but is not limited to firmware, resident software, microcode, etc.
Furthermore, the illustrative embodiments may take the form of a computer program product accessible from a computer-usable or computer-readable medium providing program code for use by or in connection with a computer or any instruction execution system. For the purposes of this description, a computer-usable or computer-readable medium can be any apparatus that can contain, store, communicate, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device.
The medium may be an electronic, magnetic, optical, electromagnetic, or semiconductor system, apparatus, or device. Examples of a computer-readable medium include a semiconductor or solid state memory, magnetic tape, a removable computer diskette, a random access memory (RAM), a read-only memory (ROM), a rigid magnetic disk, and an optical disk. Current examples of optical disks include compact disk-read-only memory (CD-ROM), compact disk-read/write (CD-R/W) and DVD.
The program code of the computer program product may comprise instructions that are stored in a computer readable storage medium in a client or server data processing system. In a client data processing system embodiment, the instructions may have been downloaded over a network from one or more remote data processing systems, such as a server data processing system, a client data processing system, or a plurality of client data processing systems using a peer-to-peer communication methodology. In a server data processing system embodiment, the instructions may be configured for download, or actually downloaded, over a network to a remote data processing system, e.g., a client data processing system, for use in a computer readable storage medium with the remote data processing system.
A data processing system suitable for storing and/or executing program code will include at least one processor coupled directly or indirectly to memory elements through a system bus. The memory elements can include local memory employed during actual execution of the program code, bulk storage, and cache memories which provide temporary storage of at least some program code in order to reduce the number of times code must be retrieved from bulk storage during execution.
Input/output or I/O devices (including but not limited to keyboards, displays, pointing devices, etc.) can be coupled to the system either directly or through intervening I/O controllers. Network adapters may also be coupled to the system to enable the data processing system to become coupled to other data processing systems or remote printers or storage devices through intervening private or public networks. Modems, cable modems and Ethernet cards are just a few of the currently available types of network adapters.
The description of the present invention has been presented for purposes of illustration and description, and is not intended to be exhaustive or limited to the invention in the form disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art. The embodiment was chosen and described in order to best explain the principles of the invention, the practical application, and to enable others of ordinary skill in the art to understand the invention for various embodiments with various modifications as are suited to the particular use contemplated.
This invention was made with United States Government support under Agreement No. HR0011-07-9-0002 awarded by DARPA. The Government has certain rights in the invention.
| Number | Name | Date | Kind |
|---|---|---|---|
| 4439828 | Martin | Mar 1984 | A |
| 4733352 | Nakamura et al. | Mar 1988 | A |
| 4918653 | Johri et al. | Apr 1990 | A |
| 5083266 | Watanabe | Jan 1992 | A |
| 5161227 | Dias et al. | Nov 1992 | A |
| 5202988 | Spix et al. | Apr 1993 | A |
| 5243596 | Port et al. | Sep 1993 | A |
| 5247693 | Bristol | Sep 1993 | A |
| 5274809 | Iwasaki et al. | Dec 1993 | A |
| 5392433 | Hammersley et al. | Feb 1995 | A |
| 5471633 | Colwell et al. | Nov 1995 | A |
| 5483641 | Jones et al. | Jan 1996 | A |
| 5524223 | Lazaravich et al. | Jun 1996 | A |
| 5598560 | Benson | Jan 1997 | A |
| 5678026 | Vartti et al. | Oct 1997 | A |
| 5832272 | Kalantery | Nov 1998 | A |
| 5852731 | Wang et al. | Dec 1998 | A |
| 5890200 | Merchant | Mar 1999 | A |
| 5928322 | Bitar et al. | Jul 1999 | A |
| 5930490 | Bartkowiak et al. | Jul 1999 | A |
| 5974439 | Bollella | Oct 1999 | A |
| 6044220 | Breternitz, Jr. | Mar 2000 | A |
| 6105049 | Govindaraju et al. | Aug 2000 | A |
| 6122692 | Okpisz et al. | Sep 2000 | A |
| 6128710 | Greenspan et al. | Oct 2000 | A |
| 6157940 | Marullo et al. | Dec 2000 | A |
| 6195676 | Spix et al. | Feb 2001 | B1 |
| 6223208 | Kiefer et al. | Apr 2001 | B1 |
| 6247025 | Bacon | Jun 2001 | B1 |
| 6269391 | Gillespie | Jul 2001 | B1 |
| 6324622 | Okpisz et al. | Nov 2001 | B1 |
| 6324686 | Komatsu et al. | Nov 2001 | B1 |
| 6343344 | Arimilli et al. | Jan 2002 | B1 |
| 6353875 | Arimilli et al. | Mar 2002 | B1 |
| 6411982 | Williams | Jun 2002 | B2 |
| 6493741 | Emer et al. | Dec 2002 | B1 |
| 6591321 | Arimilli et al. | Jul 2003 | B1 |
| 6594783 | Dollin et al. | Jul 2003 | B1 |
| 6633897 | Browning et al. | Oct 2003 | B1 |
| 6662354 | Krablin et al. | Dec 2003 | B1 |
| RE38388 | Sarangdhar et al. | Jan 2004 | E |
| 6675191 | Ito | Jan 2004 | B1 |
| 6681345 | Storino et al. | Jan 2004 | B1 |
| 6697899 | Kasuga | Feb 2004 | B1 |
| 6704843 | Arimilli et al. | Mar 2004 | B1 |
| 6704844 | Arimilli et al. | Mar 2004 | B2 |
| 6735769 | Brenner et al. | May 2004 | B1 |
| 6779036 | Deshpande | Aug 2004 | B1 |
| 6779089 | Lin et al. | Aug 2004 | B2 |
| 6785774 | Arimilli et al. | Aug 2004 | B2 |
| 6859834 | Arora et al. | Feb 2005 | B1 |
| 6874144 | Kush | Mar 2005 | B1 |
| 6886064 | Dawkins et al. | Apr 2005 | B2 |
| 6889344 | Williams | May 2005 | B2 |
| 6892286 | Hangal et al. | May 2005 | B2 |
| 6904535 | Yamada et al. | Jun 2005 | B2 |
| 6910211 | Wilhelm | Jun 2005 | B1 |
| 6934950 | Tuel et al. | Aug 2005 | B1 |
| 6956865 | Khaunte et al. | Oct 2005 | B1 |
| 6965961 | Scott | Nov 2005 | B1 |
| 7028299 | Chang | Apr 2006 | B1 |
| 7039794 | Rodgers et al. | May 2006 | B2 |
| 7058948 | Hoyle | Jun 2006 | B2 |
| 7065765 | Cadden et al. | Jun 2006 | B2 |
| 7065766 | Brenner | Jun 2006 | B2 |
| 7124249 | Darcy | Oct 2006 | B1 |
| 7162666 | Bono | Jan 2007 | B2 |
| 7171649 | Lawrence | Jan 2007 | B1 |
| 7185338 | Chamdani et al. | Feb 2007 | B2 |
| 7188262 | Arends et al. | Mar 2007 | B2 |
| 7203932 | Gaudet et al. | Apr 2007 | B1 |
| 7210146 | Hsieh | Apr 2007 | B2 |
| 7237071 | Jahnke | Jun 2007 | B2 |
| 7245302 | Donham et al. | Jul 2007 | B1 |
| 7269713 | Anderson et al. | Sep 2007 | B2 |
| 7293163 | Caprioli et al. | Nov 2007 | B2 |
| 7296264 | Zatloukal et al. | Nov 2007 | B2 |
| 7301832 | Trinh et al. | Nov 2007 | B2 |
| 7302684 | Hsieh | Nov 2007 | B2 |
| 7310722 | Moy et al. | Dec 2007 | B2 |
| 7328293 | Hammarlund et al. | Feb 2008 | B2 |
| 7350024 | Chen et al. | Mar 2008 | B2 |
| 7363474 | Rodgers et al. | Apr 2008 | B2 |
| 7434000 | Barreh et al. | Oct 2008 | B1 |
| 7461148 | Beloussov et al. | Dec 2008 | B1 |
| 7533242 | Moll et al. | May 2009 | B1 |
| 7603502 | Richter et al. | Oct 2009 | B2 |
| 7647443 | Chatterjee et al. | Jan 2010 | B1 |
| 7738367 | Aggarwal et al. | Jun 2010 | B1 |
| 7788657 | Wannamaker et al. | Aug 2010 | B2 |
| 7856636 | Bhatia et al. | Dec 2010 | B2 |
| 7904685 | Alverson et al. | Mar 2011 | B1 |
| 8015379 | Arimilli et al. | Sep 2011 | B2 |
| 8082315 | Arimilli et al. | Dec 2011 | B2 |
| 8127080 | Arimilli et al. | Feb 2012 | B2 |
| 8250396 | Arimilli et al. | Aug 2012 | B2 |
| 8516226 | Collard et al. | Aug 2013 | B1 |
| 20030046518 | Karp et al. | Mar 2003 | A1 |
| 20030051064 | Curtis | Mar 2003 | A1 |
| 20030060898 | Jenkins | Mar 2003 | A1 |
| 20030061258 | Rodgers et al. | Mar 2003 | A1 |
| 20030140338 | Bowers | Jul 2003 | A1 |
| 20030225870 | Sandadi et al. | Dec 2003 | A1 |
| 20040002974 | Kravitz et al. | Jan 2004 | A1 |
| 20040010667 | Brenner | Jan 2004 | A1 |
| 20040015969 | Chang | Jan 2004 | A1 |
| 20040025160 | Dice et al. | Feb 2004 | A1 |
| 20040068607 | Narad | Apr 2004 | A1 |
| 20040073752 | Musumeci | Apr 2004 | A1 |
| 20040073905 | Emer et al. | Apr 2004 | A1 |
| 20040093602 | Huston et al. | May 2004 | A1 |
| 20040154011 | Wang et al. | Aug 2004 | A1 |
| 20040158822 | Sandham et al. | Aug 2004 | A1 |
| 20040168007 | Okazawa et al. | Aug 2004 | A1 |
| 20040246980 | Balakrishnan | Dec 2004 | A1 |
| 20040263521 | Booth et al. | Dec 2004 | A1 |
| 20040267996 | Hammarlund et al. | Dec 2004 | A1 |
| 20050022173 | Kanade | Jan 2005 | A1 |
| 20050033945 | Chauvel et al. | Feb 2005 | A1 |
| 20050055594 | Doering et al. | Mar 2005 | A1 |
| 20050060705 | Katti et al. | Mar 2005 | A1 |
| 20050080962 | Penkovski et al. | Apr 2005 | A1 |
| 20050081185 | Stoodley et al. | Apr 2005 | A1 |
| 20050081200 | Rutten et al. | Apr 2005 | A1 |
| 20050081204 | Schopp | Apr 2005 | A1 |
| 20050108711 | Arnold et al. | May 2005 | A1 |
| 20050125802 | Wang et al. | Jun 2005 | A1 |
| 20050132378 | Horvitz et al. | Jun 2005 | A1 |
| 20050138629 | Samra | Jun 2005 | A1 |
| 20050149697 | Enright et al. | Jul 2005 | A1 |
| 20050149936 | Pilkington | Jul 2005 | A1 |
| 20050149937 | Pilkington | Jul 2005 | A1 |
| 20050166195 | Kawahito | Jul 2005 | A1 |
| 20050262270 | Latorre et al. | Nov 2005 | A1 |
| 20050268106 | Mansell et al. | Dec 2005 | A1 |
| 20060005197 | Saha et al. | Jan 2006 | A1 |
| 20060037020 | Accapadi et al. | Feb 2006 | A1 |
| 20060048149 | Clift | Mar 2006 | A1 |
| 20060048160 | Olszewski et al. | Mar 2006 | A1 |
| 20060053423 | Jones et al. | Mar 2006 | A1 |
| 20060069738 | Hoogerbrugge | Mar 2006 | A1 |
| 20060090168 | Ogasawara et al. | Apr 2006 | A1 |
| 20060093044 | Grantham et al. | May 2006 | A1 |
| 20060117316 | Cismas et al. | Jun 2006 | A1 |
| 20060130062 | Burdick et al. | Jun 2006 | A1 |
| 20060136915 | Aingaran et al. | Jun 2006 | A1 |
| 20060136919 | Aingaran et al. | Jun 2006 | A1 |
| 20060143415 | Naik | Jun 2006 | A1 |
| 20060149935 | Eickemeyer et al. | Jul 2006 | A1 |
| 20060168283 | Georgiou et al. | Jul 2006 | A1 |
| 20060200826 | Tamura et al. | Sep 2006 | A1 |
| 20060212945 | Donlin et al. | Sep 2006 | A1 |
| 20060218556 | Nemirovsky et al. | Sep 2006 | A1 |
| 20060225077 | Anderson | Oct 2006 | A1 |
| 20060236136 | Jones | Oct 2006 | A1 |
| 20060242645 | Codrescu et al. | Oct 2006 | A1 |
| 20060259907 | Bhatia et al. | Nov 2006 | A1 |
| 20070006231 | Wang et al. | Jan 2007 | A1 |
| 20070043915 | Moir et al. | Feb 2007 | A1 |
| 20070050603 | Vorbach et al. | Mar 2007 | A1 |
| 20070061805 | Brenner | Mar 2007 | A1 |
| 20070067774 | Kukanov et al. | Mar 2007 | A1 |
| 20070073693 | Harris et al. | Mar 2007 | A1 |
| 20070083730 | Vorbach et al. | Apr 2007 | A1 |
| 20070094431 | Fachan | Apr 2007 | A1 |
| 20070106983 | Owen et al. | May 2007 | A1 |
| 20070124545 | Blanchard et al. | May 2007 | A1 |
| 20070143755 | Sahu et al. | Jun 2007 | A1 |
| 20070150658 | Moses et al. | Jun 2007 | A1 |
| 20070156971 | Sistla et al. | Jul 2007 | A1 |
| 20070157182 | Zatloukal et al. | Jul 2007 | A1 |
| 20070180187 | Olson et al. | Aug 2007 | A1 |
| 20070186028 | Kissell | Aug 2007 | A2 |
| 20070198772 | Dai et al. | Aug 2007 | A1 |
| 20070240124 | Taneda et al. | Oct 2007 | A1 |
| 20070260855 | Gschwind et al. | Nov 2007 | A1 |
| 20070271404 | Dearth et al. | Nov 2007 | A1 |
| 20070271564 | Anand et al. | Nov 2007 | A1 |
| 20070282838 | Shavit et al. | Dec 2007 | A1 |
| 20070283357 | Jeter et al. | Dec 2007 | A1 |
| 20070300227 | Mall et al. | Dec 2007 | A1 |
| 20080016374 | Gee et al. | Jan 2008 | A1 |
| 20080034146 | Duncan et al. | Feb 2008 | A1 |
| 20080034190 | Rodgers et al. | Feb 2008 | A1 |
| 20080098208 | Reid et al. | Apr 2008 | A1 |
| 20080104223 | D'Amora et al. | May 2008 | A1 |
| 20080126764 | Wu et al. | May 2008 | A1 |
| 20080127202 | Stall | May 2008 | A1 |
| 20080141012 | Yehia et al. | Jun 2008 | A1 |
| 20080148259 | Hankins et al. | Jun 2008 | A1 |
| 20080177985 | Sandham et al. | Jul 2008 | A1 |
| 20080209422 | Coha | Aug 2008 | A1 |
| 20080263321 | Le et al. | Oct 2008 | A1 |
| 20080282056 | Bond | Nov 2008 | A1 |
| 20090037927 | Sangili et al. | Feb 2009 | A1 |
| 20090125913 | Bradford et al. | May 2009 | A1 |
| 20090132796 | Snyder et al. | May 2009 | A1 |
| 20090144519 | Codrescu et al. | Jun 2009 | A1 |
| 20090199028 | Arimilli et al. | Aug 2009 | A1 |
| 20090199029 | Arimilli et al. | Aug 2009 | A1 |
| 20090199030 | Arimilli et al. | Aug 2009 | A1 |
| 20090199183 | Arimilli et al. | Aug 2009 | A1 |
| 20090199184 | Arimilli et al. | Aug 2009 | A1 |
| 20090199197 | Arimilli et al. | Aug 2009 | A1 |
| 20100107166 | Topaloglu | Apr 2010 | A1 |
| 20100268790 | Arimilli et al. | Oct 2010 | A1 |
| 20100268791 | Arimilli et al. | Oct 2010 | A1 |
| 20100268915 | Arimilli et al. | Oct 2010 | A1 |
| 20100269115 | Arimilli et al. | Oct 2010 | A1 |
| 20100287341 | Arimilli et al. | Nov 2010 | A1 |
| 20100293340 | Arimilli et al. | Nov 2010 | A1 |
| 20100293341 | Arimilli et al. | Nov 2010 | A1 |
| 20100332753 | Gray et al. | Dec 2010 | A1 |
| 20110173417 | Arimilli et al. | Jul 2011 | A1 |
| 20110173419 | Arimilli et al. | Jul 2011 | A1 |
| 20110173423 | Arimilli et al. | Jul 2011 | A1 |
| 20110173593 | Arimilli et al. | Jul 2011 | A1 |
| 20110173625 | Arimilli et al. | Jul 2011 | A1 |
| 20110173630 | Arimilli et al. | Jul 2011 | A1 |
| 20110173631 | Arimilli et al. | Jul 2011 | A1 |
| 20110173632 | Arimilli et al. | Jul 2011 | A1 |
| Entry |
|---|
| Akkary, Haitham et al., “A Dynamic Multithreading Processor”, Microarchitecture, 1998, MICRO-31, Proceedings, 31st Annual ACM/IEEE International Symposium on Nov. 30-Dec. 2, 1998. pp. 226-236. |
| Bik, Aart J. et al., “Automatic Detection of Saturation and Clipping Idioms”, Languages and Compliers for Parallel Computing, 15th Workshop, vol. 2481, Jul. 2002, pp. 61-74. |
| Buntinas, D. et al., “Optimizing Synchronization Operations for Remote Memory Communication Systems”, Proceedings of the International Parallel and Distributed Processing Symposium, Apr. 2003, 8 pages. |
| Grossman, Dan, “Type-Safe Multithreading in Cyclone”, ACM SIGPLAN notices, vol. 38, Issue 3, TLDI '03, Jan. 18, 2003, 13 pages. |
| Haight, Jeff et al., “Bus Request-Response Trace for a SMART Interconnect System”, First Silicon Solutions Division of MIPS Technologies Inc., and Mobileye Vision Technologies Ltd., 2006, pp. 1-6. |
| Hovemeyer, David et al., “Atomic Instructions in Java”, ECOOP 2002—Object Oriented Programming, 16th European Conference, vol. 2374, Jun. 2002, 22 pages. |
| Jidin, Razali, “Extending the Thread Programming Model Across Hybrid FPGA/CPU Architectures”, Information Technology and Telecommunications Center (ITTC), University of Kansas; Apr. 15, 2005; 39 pages. |
| Kawahito, Motohiro et al., “A New Idiom Recognition Framework for Exploiting Hardware-Assist Instructions”, Computer Architecture News, vol. 34, No. 5, Dec. 2006, pp. 382-393. |
| Kotlyar, Vladimir et al., “Detecting Overlow Detection”, International Conference on Hardware/Software Codesign and Systems Synthesis, Sep. 2004, pp. 36-41. |
| U.S. Appl. No. 12/024,797, filed Feb. 1, 2008, Arimilli et al. |
| U.S. Appl. No. 12/024,705, filed Feb. 1, 2008, Arimilli et al. |
| U.S. Appl. No. 12/024,419, filed Feb. 1, 2008, Arimilli et al. |
| U.S. Appl. No. 12/024,508, filed Feb. 1, 2008, Arimilli et al. |
| U.S. Appl. No. 12/024,364, filed Feb. 1, 2008, Arimilli et al. |
| U.S. Appl. No. 12/024,384, filed Feb. 1, 2008, Arimilli et al. |
| U.S. Appl. No. 12/024,479, filed Feb. 1, 2008, Arimilli et al. |
| U.S. Appl. No. 12/024,250, filed Feb. 1, 2008, Arimilli et al. |
| U.S. Appl. No. 12/024,347, filed Feb. 1, 2008, Arimilli et al. |
| U.S. Appl. No. 12/024,242, filed Feb. 1, 2008, Arimilli et al. |
| U.S. Appl. No. 12/024,204, filed Feb. 1, 2008, Arimilli et al. |
| U.S. Appl. No. 12/024,540, filed Feb. 1, 2008, Arimilli et al. |
| U.S. Appl. No. 12/024,466, filed Feb. 1, 2008, Arimilli et al. |
| U.S. Appl. No. 12/024,703, filed Feb. 1, 2008, Arimilli et al. |
| U.S. Appl. No. 12/024,507, filed Feb. 1, 2008, Arimilli et al. |
| U.S. Appl. No. 12/024,595, filed Feb. 1, 2008, Arimilli et al. |
| U.S. Appl. No. 12/024,669, filed Feb. 1, 2008, Arimilli et al. |
| U.S. Appl. No. 12/144,011, filed Jun. 23, 2008, Arimilli et al. |
| Lu, Jiwei et al., “Design and Implementation of a Lightweight Dynamic Optimization System”, Journal of Instruction-Level Parallelism, Apr. 2004, pp. 1-24. |
| Marcuello, Pedro et al., “Thread-Spawning Schemes for Speculative Multithreading”, Proceedings of the Eighth International Symposium on High-Performance Computer Architecture (HPCA '02), 1503-0897/02, 2002, 10 pages. |
| Martinez, Jose F. et al., “Speculative Synchronization: Applying Thread-Level Speculation to Explicitly Parallel Applications”, Proceedings of the 10th International Conference on Architectural Support for Programming Languages and Operating Systems, Oct. 2002, pp. 18-29. |
| Monod, Maxime et al., “Looking Ahead in Open Multithreaded Transactions”, Proceedings of the Ninth IEEE International Symposium on Object and Component-Oriented Real-Time Distributed Computing 0-7695-2561-X/06, 2006, 11 pages. |
| Naik, Mayur et al., “Conditional Must Not Aliasing for Static Race Detection”, ACM SIGPLAN notices, vol. 42, Issue 1, POPL '07, Jan. 17-19, 2007, pp. 327-338. |
| Sassone, Peter G. et al., “On the Extraction and Analysis of Prevalent Dataflow Patterns”, IEEE International Workshop on Workload Characterization, Oct. 2004, pp. 11-18. |
| Schmidt, Douglas C. , “Scoped Locking”, Siemens AG 1999, pp. 1-8. |
| Sinharoy, B et al., “POWER5 system microarchitecture”, IBM J. Res. & Dev., vol. 49, No. 4/5, Jul./Sep. 2005, pp. 505-521. |
| Vinoski, Steve, “Concurrency with Erlang”, http://www.computer.org/portal/site/dsonline/menuitem.9ed3d9924aebOdcd82ccc6716bbe36ec/index.jsp?&pName=dso—level1&path=dsonline/2007/10&file=w5tow.xml&xsl=article.xsl&, IEEE Internet Computing, vol. 11, Sep.-Oct. 2007, 6 pages. |
| Weissman, Boris , “Active Threads: an Extensible and Portable Light-Weight Thread System”, International Computer Science Institute, TR-97-036, Sep. 1997, 80 pages. |
| U.S. Appl. No. 12/024,540. |
| U.S. Appl. No. 12/024,595. |
| U.S. Appl. No. 12/024,669. |
| U.S. Appl. No. 12/024,703. |
| U.S. Appl. No. 12/024,705. |
| U.S. Appl. No. 12/024,797. |
| U.S. Appl. No. 12/144,011. |
| U.S. Appl. No. 12/424,952. |
| U.S. Appl. No. 12/424,983. |
| U.S. Appl. No. 12/425,023. |
| U.S. Appl. No. 12/425,057. |
| U.S. Appl. No. 12/024,466. |
| U.S. Appl. No. 12/024,204. |
| U.S. Appl. No. 12/024,242. |
| U.S. Appl. No. 12/024,250. |
| U.S. Appl. No. 12/024,347. |
| U.S. Appl. No. 12/024,364. |
| U.S. Appl. No. 12/024,384. |
| U.S. Appl. No. 12/024,419. |
| U.S. Appl. No. 12/024,479. |
| U.S. Appl. No. 12/024,507. |
| U.S. Appl. No. 12/024,508. |
| Krishnan, Venkat et al., “A Chip-Multiprocessor Architecture with Speculative Multithreading”, IEEE Transactions on Computers, vol. 48, No. 9, pp. 866-880, Sep. 1999, doi:10.1109/12 795218. |
| McCool, Michael D. , “Scalable Programming Models for Massively Multicore Processors”, IEEE, Proceedings of the IEEE, vol. 96, No. 5, May 2008, pp. 816-831. |
| “The Authoritative Dictionary of IEEE Standards Terms”, Seventh Edition, IEEE Press, 2000, pp. 1234-1235. |
| Lee, Yui-Wah, “Operation-based Update Propagation in a Mobile File System”, The Chinese University of Hong Kong, Jan. 2000, 204 pages. |
| Li, Jian et al., “The Thrifty Barrier: Energy-Aware Synchronization in Shared-Memory Multiprocessors”, International Symposium on High-Performance Computer Architecture (HPCA), Madrid, Spain, Feb. 2004 , 10 pages. |
| Eyerman, Stijn et al., “A Memory-Level Parallelism Aware Fetch Policy for SMT Processors”, IEEE, 2007, pp. 240-249. |
| Chou, Yuan et al., “Instruction Path Coprocessors”, ISCA '00 Proceedings of the 27th Annual International Symposium on Computer Architecture, 2000, pp. 270-281. |
| Rinard, Martin C. et al., “Jade: A High-Level, Machine-Independent Language for Parallel Programming”, IEEE, Computer, vol. 26, Issue 6, 1993, pp. 28-38. |
| Number | Date | Country | |
|---|---|---|---|
| 20090199189 A1 | Aug 2009 | US |
