1. Technical Field
The present disclosure relates generally to information processing systems and, more specifically, to improvement of concurrent thread execution using user-level asynchronous signaling.
2. Background Art
Increasingly, multithreading is supported in hardware. For instance, in one approach, multiple processors (thread units) in a multi-processor system, such as a chip multiprocessor (“CMP”) system, may each act on one of the multiple software threads concurrently. In another approach, referred to as simultaneous multithreading (“SMT”), a single physical processor is made to appear as multiple logical processors (thread units) to operating systems and user programs. For SMT, multiple software threads can be active and execute simultaneously on a single processor without switching.
For a system that supports concurrent execution of software threads, such as SMT and/or CMP systems, an application may be parallelized into multi-threaded code to exploit the system's concurrent-execution potential. An otherwise single-threaded program may be parallelized into multi-threaded code by organizing the program into multiple threads and then concurrently running the threads, each thread on a separate thread unit. The threads of a multi-threaded application may need to communicate and synchronize, and this is often done through shared memory.
To parallelize code, speculative decisions may be made regarding whether a block of code is dependent on other code running concurrently on other threads. Processors can make this more efficient by providing support for detecting dependencies. For example, a processor may provide support to detect whether a speculative block of code reads any memory location that is subsequently modified by another concurrent thread. One common solution to accessing shared data in multiple core or multiple logical processor systems comprises the use of software locks to guarantee mutual exclusion across multiple accesses to shared data.