WO2000031636A1 - Distributed monitor concurrency control - Google Patents
Distributed monitor concurrency control Download PDFInfo
- Publication number
- WO2000031636A1 WO2000031636A1 PCT/US1999/027854 US9927854W WO0031636A1 WO 2000031636 A1 WO2000031636 A1 WO 2000031636A1 US 9927854 W US9927854 W US 9927854W WO 0031636 A1 WO0031636 A1 WO 0031636A1
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- thread
- computer
- local
- logical
- threads
- Prior art date
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/52—Program synchronisation; Mutual exclusion, e.g. by means of semaphores
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/448—Execution paradigms, e.g. implementations of programming paradigms
- G06F9/4488—Object-oriented
- G06F9/449—Object-oriented method invocation or resolution
Definitions
- the present invention relates to computer hardware and software, and more particularly to a system for thread synchronization in a distributed computing environment wherein multiple threads of execution span across different computing platforms.
- unsynchronized multithreading may be accomplished by time-multiplexing the microprocessor. This means that the -microprocessor, or CPU, divides its time between two or more stacks such that all stacks make some progress over time, without havmg the stacks explicitly call each other. The first stack would wait while execution proceeded on the second stack, and vice versa.
- Concurre threads means that two or more threads are in various stages of execution concurrently. Concurrent threads may be executmg one at a time in a time multiplexmg scheme. Alternatively, a computer with parallel processors may have concurrent threads executing simultaneously.
- time-multiplexing There are a number of known techniques for time-multiplexing, including "preemptive" and “non-preemptive” multitasking.
- preemptive multitasking scheme the operatmg system allocates time among the threads.
- non-preemptive scheme the active thread controls the time at which it relinquishes execution.
- Resources that may be shared among concurrent threads, such as memory, must be protected in a manner that prevents corrupnon between the threads
- the thread must show evidence that it has acquired the lock, or alternatively, the entire system must respect a convention which threads without locks refram from accessmg the shared resource
- the shared resource may only allow one lock to issue at any time, thus preventing any concurrent access to the resource
- Locks can be difficult to use in a layered or nested architecture because the lock evidence must be explicitly supplied to allow access to the shared resource This presents a problem when a first thread acquires a lock, then waits for results from a second thread which also needs access to the same resource This scenario can lead to a "deadlock" in which the first and second threads are each waitmg for the other, as descnbed in the following example
- Local "monitors” are a well known technique for thread synchronization They are fairly easy to use and map well to object-onented systems
- a local monitor can be viewed as a programming construct in which a lock is assigned to a thread
- a simple lock (as descnbed m the example above) is typically assigned to a shared resource
- the local monitor is associated with the thread's section of code in which shared access is performed
- Each local monitor comprises a queue and a lock As a thread proceeds mto a monitor, the thread will either be assigned a spot on the queue, or will be granted access to the resource while other threads wait on the queue In this manner, a lock does not have to be passed from thread to thread
- Another technique for thread synchronization mvolves a "request server"
- a separate computing platform constitutes the request server, and clients to this server are the mdividual threads of execution
- the server creates mdividual (local) threads of execution to handle each request from a client
- One of the drawbacks of this approach is the large overhead required to generate a new thread for each client request
- U S Patent 5,341,491 discloses an apparatus and method for ensunng that lock requests are serviced in a multiprocessor system
- a lock queue includes a plurality of registers pipelined together, wherein lock requests only enter the lock queue if they are refused access to a shared resource a predetermined number of times
- U S Patents 5,636,376 and 5,675,798 disclose a system and method for selectively and contemporaneously monitormg processes in a multiprocessing server
- a status utility selectively accesses information to determine the status of the mdividual multiple processes executmg on the server workstation.
- the information is of a granulanty to identify processes which are hung up on semaphores, message queues, or the like.
- U.S Patent 5,590,335 discloses a process for analysis of deadlocks in an operatmg system.
- the process includes the step of searchmg for any thread stopped on a lock, and further for the thread that holds that lock, and further up the cham until a cycle is found. In this manner, the user can reconstruct the cycle determining the deadlock
- U S. Patent 5,590,326 discloses a shared data management scheme usmg shared data locks for multi-threading. In this scheme, different shared data identifiers are assigned to different threads, and different locks are set up for different shared data identifiers, so as to enable the detection of an access in violation to the locks
- U.S. Patent 5,524,247 discloses a system for schedulmg programming units to a resource based on status vanables mdicatmg a lock or lock-wait state. The central processmg unit (CPU) sets a predetermined value in the status vanable corresponding to a thread when the thread starts waitmg for a resource which it shares with other threads.
- CPU central processmg unit
- the scheduler refers to the status vanable, selects, with pnonty, a thread other than the thread waitmg for the shared resource, and allocates the CPU to the thread thus selected
- Patent 5,706,515 discloses a system for implementing an atomic wait for notification operations.
- a resource allocation subsystem mcludes an "initialization” procedure for initializing monitors, a "notify” procedure and a "wait” procedure
- Each monitor has an associated event data structure denoting the status of the monitor as Signaled or Unsignaled.
- Each monitor also stores a value mdicatmg how many threads are waiting on the monitor.
- Patent 5,247,675 discloses preemptive and non-preemptive schedulmg and execution of program threads m a multitaskmg operatmg system.
- the operatmg system permits application programs to influence the schedule of execution of program threads.
- a pnonty level is assigned to each thread, and the highest pnonty thread is executed first.
- U.S. Patent 5,481,706 discloses a system and method for creatmg thread-safe shared branes The system insures correct functioning and integnty of the library functions accessible by multiple threads. A wnte-exclusive lock is used to protect shared resources.
- Computer networks can allow different computing platforms to exchange data and to share network resources and peripheral devices
- software will only execute within a smgle platform, although data may be accessed from vanous resources within the network.
- the issues surrounding thread synchronization typically remain local to each computmg platform.
- More recent developments in computer networking have enabled the execution of threads to progress across several different computing platforms
- a "thread jump" occurs when a thread is executmg on a first computmg platform, and subsequently contmues its execution on a second computing platform within the network Networks of computmg platforms that allow thread jumps are herein referred to a "distnubbed systems"
- the present invention extends the applicability of monitors to distnubbed systems.
- An important element of the present mvention is the "logical thread" which is compnsed of one or more "local threads " While a local thread exists within a smgle computmg platform, a logical thread may span several local threads, and thereby span the platforms on which the local threads reside. For example, m an object-oriented system, if an object on machme A makes a method call on an object on machme B, local threads on each machme (the calling thread and the called thread) belong to the same logical thread of execution.
- monitors may be adapted to work with logical threads
- mapping exists within each computmg platform which maps local threads to logical threads.
- the mapping may be in the form of a hash table, or any other programmmg construct which associates local threads with logical threads. As new local threads are spawned by calls from other parts of the network, the new local threads are assigned to logical threads by the mapping construct
- Monitors within each platform are designed to function with logical threads instead of local threads
- access to the shared resource is determined on the basis of the logical thread to which the local thread is affiliated
- Figure 1 is a logic diagram representation of two local threads on different computers that belong to the same logical thread.
- Figure 2 is a logic diagram representation of local threads and logical threads accordmg to the present mvention, wherein logical thread 1 is compnsed of several local threads.
- Figure 3 is a logic diagram representation of a monitor.
- Block 1 10 is representative of a first computer (Machme A) within a distnaded network.
- Block 112 is representative of a second computer (Machme B) which is also connected within the same distnubbed network as Block 110.
- a bar representative of a local thread of execution within its respective machme.
- bar 114 is a local thread of execution with machme 110
- bar 116 is a local thread of execution withm machine 112
- Each of the local threads of execution, 114 and 116 are shown schematically as proceedmg stepwise from top to bottom m Figure 1.
- local thread 114 proceeds m its stepwise execution starting from the top of bar 114, until it reaches lme 118
- Line 118 represents a local call from thread 114 that spawns another local thread withm Machme A
- the arrow-head on lme 118 represents a "return" of local thread 118, at which pomt local thread 118 is terminated
- Traditional thread synchronization schemes can be applied as long as local threads are spawned and returned withm the same platform (Machine A)
- This type of remote call is a feature of new distnaded computmg environments.
- the remote call 120 spawns a new local thread on Machme B shown by bar 116
- Local thread 116 can make local calls that spawn new threads withm Machme B. as shown by lme 122 Additionally, local thread 116 can make remote calls to other machmes that are connected to the distnaded computmg environment, which will spawn new local threads withm those machmes. In each case, every new thread spawned from the o ⁇ gmal logical thread will become part of the same logical thread. Logical threads can thereby extend over an arbitrary number of platforms withm a distnubbed computmg environment
- Local threads which are threads of execution withm a single computing platform, are tied together to form logical threads.
- event queumg and delivery could also tie multiple local threads to a smgle logical thread "Thread jumps" result m tying local threads together to form logical threads
- the series of local threads shown in Figure 1 constitute a smgle logical thread.
- logical thread is holdmg a lock on a monitor. If any one of the local threads ceases to exist, it is essential that the monitor lock be released in a timely manner to avoid lockmg out other access requests to the shared resource which the monitor controls.
- This problem is addressed, accordmg to the present mvention, with "reference counting” or “keep alive” mechanisms similar to "lease” type distnubbed garbage collectors.
- a logical thread may be created, and stopped, accordmg to the examples in the following code.
- the comments precedmg the code descnbe the function of certain program elements. It will be understood by skilled programmers that vanous equivalent implementations exist, mclud g different logical constructions of programmmg objects which, m aggregate, will perform the same function
- the sample code is wntten for a JAVA Virtual Machme (JVM)
- startLog ⁇ calThread( ) creates one and makes the * association Calls to startLog ⁇ calThread( ) MUST be balanced by calls
- stopLogicalThread( ) * to stopLogicalThread( ). Generally this is accomplished with try/finally * blocks.
- stopLogicalThread( ) is called (nesting depth is zero)
- thread.count 0 ) mapping.remove( Thread.currentThread( ) ); else thread.count—; ⁇
- FIG. 2 two computers are shown as machine 1 (200) and machine 2 (202), which are connected in a distributed computing environment.
- Dashed line 208 in Figure 2 represents a logical separation between computing platforms 200 and 202, which are still connected through a network.
- Local threads on each machine are shown as tl, t2, and t3, which comprise a single logical thread LTI.
- a table within each machine is updated at each thread jump to maintain current affiliations of local threads with logical threads.
- a local thread, tl is shown executing steps associated with function 1 in machine 1.
- Function 1 makes a call, "enter(x)" which is representative of a call to a monitor.
- Local thread tl thus acquires a lock on a monitor.
- a thread jump occurs during execution of function 2, spawning a new local thread t2 within machine 2.
- a table within machine 1 (204) records the affiliation of local thread tl with logical thread LTI .
- a table within machine 2 (206) records the affiliation of local thread t2 with the same logical thread LTI.
- After a call to function 3, local thread t2 jumps back to machme 1 , thus spawning a new local thread t3 on machine 1.
- the table within machine 1 (204) is updated accordingly to reflect that t3 belongs to LTI.
- the thread context is an identification assigned to local threads which is guaranteed to be unique among logical threads across all elements of the distnubbed system.
- the thread context is an identification assigned to local threads which is guaranteed to be unique among logical threads across all elements of the distnubbed system.
- the new local thread is given a thread context with the same identification as the thread from which the jump is bemg made.
- the lock is tagged with that unique identification, thus ensurmg the shared resource is locked for all the constituent local threads of the logical thread.
- monitors typically operate with local threads, m a distnaded momtor the lockmg function is associated with a logical thread.
- a distnaded monitor preferable allows only a smgle logical thread to hold the lock at any one time.
- the logical thread that holds the lock can be identified through an Object Identifier (OID), which is one embodiment of the unique thread context.
- OID Object Identifier
- the mappmg is preferably updated whenever the association changes.
- the following sample code illustrates one way of mappmg local threads to logical threads.
- the comments precedmg the code descnbe the function of certain program elements. It will be understood by skilled programmers that vanous equivalent implementations exist, including different logical constructions of programmmg objects which, m aggregate, will perform the same function.
- the sample code is wntten for a JVM
- Hashtable mappmg new Hashtable ( )
- a local thread may also be associated with a logical thread
- Figure 3 represents the operation of a monitor Withm a smgle platform, monitors have long been used to synchronize threads
- the present invention extends the use of monitors to distnubbed computmg environments.
- a distnubbed monitor accordmg to the present invention is designed to work with logical threads, mstead of local threads
- Distnubbed monitors "belong" to objects, m the sense that the acquisition of a lock by an object is logically similar to “lockmg” the monitor.
- Two concurrent threads are illustrated in Figure 3. Each thread is local to a different computing platform-
- Thread 1 which is shown as line 300, and Thread 2 which is shown as line 302.
- the tick marks on each thread represent steps m the execution of each respective thread.
- Thread 1 proceeds with its steps of execution until it reaches a step 310 m which it must acquire access to certain data, shown diagrammahcally as 304.
- Smce data 304 is a shared resource, it has a monitor 306 associated with it.
- the monitor 306 is compnsed of a queue 308, a lock 320, and the data 304. It will be understood by practitioners that monitor 306, as shown m Figure 3, is a highly stylized and simplified schematic that is used herein for purposes of illustration More accurate representations of monitors may be found m reputable texts descnbmg operating system architecture
- Thread 1 "enters" the monitor. This action is shown schematically by the arrow 312 extending from step 310 to the monitor 306 m Figure 3. In this example, there are no other threads waitmg m the Queue 308 at the time that Thread 1 entered the monitor. Therefore, Thread 1 gams access to the lock 320, which functionally prevents other threads from accessmg the data 304. The action of gammg access to the lock 320 is shown by arrow 314, which extends from the monitor 306 back to the next step m Thread 1, shown as step 316 along lme 300 Havmg gamed access to the lock 320, Thread 1 proceeds through its steps of execution as shown schematically by successive tick marks along lme 300.
- Thread 1 has access and control of the shared resource 304 which it uses to perform its calculations.
- a second thread (labeled Thread 2 and shown schematically by lme 302) attempts to gam access to the shared resource 304 while Thread 1 holds the lock 320.
- Thread 2 is not part of the same logical thread as Thread 1 Therefore Thread 2 is forced to wait in a queue 308, as shown by the arrow labeled 318
- the queue 308 may hold several threads which are each waitmg to gam access to the shared resource 304
- the monitor 306 may be designed to service the queue 308 with a first-in-first-out (FIFO) scheme. A more sophisticated monitor 306 may arrange pnonty in the queue 308 based on performance-enhancing cnte ⁇ a.
- FIFO first-in-first-out
- LogicalThread thread Log ⁇ calThread.startLog ⁇ calThread( ) try
- OID oid (object mstanceof Proxy) ( (Proxy)object) . getOID( ) ObjectTable.put( object ),
- Monitor getMon ⁇ tor( object ) .mon ⁇ torLock( ),
- OID oid (object mstanceof Proxy) ? ((Proxy)object) .getOID( ) .
Abstract
Description
Claims
Priority Applications (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
EP99960576A EP1137989A1 (en) | 1998-11-24 | 1999-11-23 | Distributed monitor concurrency control |
AU17441/00A AU1744100A (en) | 1998-11-24 | 1999-11-23 | Distributed monitor concurrency control |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US09/198,477 | 1998-11-24 | ||
US09/198,477 US6622155B1 (en) | 1998-11-24 | 1998-11-24 | Distributed monitor concurrency control |
Publications (1)
Publication Number | Publication Date |
---|---|
WO2000031636A1 true WO2000031636A1 (en) | 2000-06-02 |
Family
ID=22733547
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/US1999/027854 WO2000031636A1 (en) | 1998-11-24 | 1999-11-23 | Distributed monitor concurrency control |
Country Status (4)
Country | Link |
---|---|
US (1) | US6622155B1 (en) |
EP (1) | EP1137989A1 (en) |
AU (1) | AU1744100A (en) |
WO (1) | WO2000031636A1 (en) |
Cited By (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN1302384C (en) * | 2003-01-31 | 2007-02-28 | 英特尔公司 | Recckoning multiroute operation quided by controlling quasi-independent point |
CN1311351C (en) * | 2003-02-19 | 2007-04-18 | 英特尔公司 | Programmable event driven yield mechanism which may activate other threads |
Families Citing this family (41)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6952827B1 (en) * | 1998-11-13 | 2005-10-04 | Cray Inc. | User program and operating system interface in a multithreaded environment |
US6970925B1 (en) * | 1999-02-03 | 2005-11-29 | William H. Gates, III | Method and system for property notification |
CA2302959A1 (en) * | 2000-03-23 | 2001-09-23 | Ibm Canada Limited-Ibm Canada Limitee | Priority resource allocation in programming environments |
US7143410B1 (en) * | 2000-03-31 | 2006-11-28 | Intel Corporation | Synchronization mechanism and method for synchronizing multiple threads with a single thread |
US20050125251A1 (en) * | 2000-10-12 | 2005-06-09 | Berger Kenneth A. | System and method for enterprise resource management |
US6669926B1 (en) * | 2000-10-16 | 2003-12-30 | Mallinckrodt, Inc. | Hydrophilic light absorbing indole compounds for determination of physiological function in critically ill patients |
US6735760B1 (en) * | 2000-11-08 | 2004-05-11 | Sun Microsystems, Inc. | Relaxed lock protocol |
US7694302B1 (en) * | 2001-04-05 | 2010-04-06 | Network Appliance, Inc. | Symmetric multiprocessor synchronization using migrating scheduling domains |
US7178137B1 (en) | 2001-04-05 | 2007-02-13 | Network Appliance, Inc. | Automatic verification of scheduling domain consistency |
US7496654B2 (en) * | 2001-06-29 | 2009-02-24 | Microsoft Corporation | Multi-threaded system for activating a process using a script engine and publishing data descriptive of the status of the process |
GB0118294D0 (en) * | 2001-07-27 | 2001-09-19 | Ibm | Method and system for deadlock detection and avoidance |
US7137120B2 (en) * | 2001-12-17 | 2006-11-14 | International Business Machines Corporation | Dynamic diagnostic program for determining thread wait time |
US7107267B2 (en) * | 2002-01-31 | 2006-09-12 | Sun Microsystems, Inc. | Method, system, program, and data structure for implementing a locking mechanism for a shared resource |
US7117498B2 (en) * | 2002-06-14 | 2006-10-03 | Intel Corporation | Thread optimization for lock and unlock operations in a multi-thread environment |
US8095657B2 (en) * | 2002-07-24 | 2012-01-10 | Oracle America, Inc. | First thread lock management for distributed data systems |
US20040019660A1 (en) * | 2002-07-24 | 2004-01-29 | Sandhya E. | Lock holding multi-threaded processes for distibuted data systems |
US7565406B2 (en) * | 2002-07-24 | 2009-07-21 | Sun Microsystems, Inc. | Last thread lock management for multi-threaded process and distributed data systems |
US20040205313A1 (en) * | 2003-04-10 | 2004-10-14 | Hudson Richard L. | Method, apparatus and article for lock management |
JP3892829B2 (en) * | 2003-06-27 | 2007-03-14 | 株式会社東芝 | Information processing system and memory management method |
US7373640B1 (en) | 2003-07-31 | 2008-05-13 | Network Appliance, Inc. | Technique for dynamically restricting thread concurrency without rewriting thread code |
US8190780B2 (en) * | 2003-12-30 | 2012-05-29 | Sap Ag | Cluster architecture having a star topology with centralized services |
US20050155011A1 (en) * | 2004-01-12 | 2005-07-14 | Stephan Heik | Method and system for restricting access in a distributed job environment |
US8171480B2 (en) * | 2004-01-27 | 2012-05-01 | Network Appliance, Inc. | Method and apparatus for allocating shared resources to process domains according to current processor utilization in a shared resource processor |
US9189230B2 (en) | 2004-03-31 | 2015-11-17 | Intel Corporation | Method and system to provide concurrent user-level, non-privileged shared resource thread creation and execution |
US7809825B2 (en) * | 2004-05-05 | 2010-10-05 | International Business Machines Corporation | Dissolving network resource monitor |
US7496918B1 (en) * | 2004-06-01 | 2009-02-24 | Sun Microsystems, Inc. | System and methods for deadlock detection |
JP4717426B2 (en) * | 2004-12-07 | 2011-07-06 | キヤノン株式会社 | Information processing apparatus and method |
US7954062B2 (en) * | 2005-01-03 | 2011-05-31 | International Business Machines Corporation | Application status board mitigation system and method |
US7620852B2 (en) * | 2005-03-02 | 2009-11-17 | Microsoft Corporation | Systems and methods of reporting multiple threads involved in a potential data race |
US8037476B1 (en) * | 2005-09-15 | 2011-10-11 | Oracle America, Inc. | Address level log-based synchronization of shared data |
US8347293B2 (en) * | 2005-10-20 | 2013-01-01 | Network Appliance, Inc. | Mutual exclusion domains to perform file system processes on stripes |
US8024405B2 (en) * | 2006-03-30 | 2011-09-20 | Microsoft Corporation | Declarative model for concurrency-control across lightweight threads |
US9405564B2 (en) * | 2006-05-10 | 2016-08-02 | The Mathworks, Inc. | System and method for targeting commands to concurrent computing units executing a concurrent computing process |
US7631168B1 (en) * | 2006-05-10 | 2009-12-08 | The Math Works, Inc. | Graphical interface for grouping concurrent computing units executing a concurrent computing process |
US8392008B2 (en) * | 2006-10-20 | 2013-03-05 | Rockwell Automation Technologies, Inc. | Module arbitration and ownership enhancements |
US8601435B2 (en) * | 2006-10-20 | 2013-12-03 | Rockwell Automation Technologies, Inc. | Module class subsets for industrial control |
US20080209422A1 (en) * | 2007-02-28 | 2008-08-28 | Coha Joseph A | Deadlock avoidance mechanism in multi-threaded applications |
JP4888272B2 (en) * | 2007-07-30 | 2012-02-29 | 富士通セミコンダクター株式会社 | Software simulation method, software simulation program, and software simulation apparatus |
EP2290562A1 (en) * | 2009-08-24 | 2011-03-02 | Amadeus S.A.S. | Segmented main-memory stored relational database table system with improved collaborative scan algorithm |
US8627331B1 (en) | 2010-04-30 | 2014-01-07 | Netapp, Inc. | Multi-level parallelism of process execution in a mutual exclusion domain of a processing system |
US9626228B1 (en) * | 2014-02-04 | 2017-04-18 | Emc Corporation | Synchronizing stateless process across multiple instances |
Citations (6)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP0697654A1 (en) * | 1994-07-19 | 1996-02-21 | Canon Kabushiki Kaisha | Load distribution method and system |
US5590326A (en) * | 1993-09-13 | 1996-12-31 | Kabushiki Kaisha Toshiba | Shared data management scheme using shared data locks for multi-threading |
US5666533A (en) * | 1991-09-06 | 1997-09-09 | International Business Machines Corporation | Program execution management using process enclaves which define the scope of high-level language semantics and threads improving cooperation between processes written in multiple languages |
EP0794490A2 (en) * | 1996-03-08 | 1997-09-10 | International Business Machines Corporation | Dynamic execution unit management for high performance server system |
EP0840215A1 (en) * | 1996-11-04 | 1998-05-06 | Sun Microsystems, Inc. | Method and apparatus for thread synchronization in object-based systems |
WO1998043193A2 (en) * | 1997-03-21 | 1998-10-01 | University Of Maryland | Spawn-join instruction set architecture for providing explicit multithreading |
Family Cites Families (12)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4814971A (en) | 1985-09-11 | 1989-03-21 | Texas Instruments Incorporated | Virtual memory recovery system using persistent roots for selective garbage collection and sibling page timestamping for defining checkpoint state |
AU633724B2 (en) | 1990-06-29 | 1993-02-04 | Digital Equipment Corporation | Interlock queueing |
US5151987A (en) | 1990-10-23 | 1992-09-29 | International Business Machines Corporation | Recovery objects in an object oriented computing environment |
US5247675A (en) | 1991-08-09 | 1993-09-21 | International Business Machines Corporation | Preemptive and non-preemptive scheduling and execution of program threads in a multitasking operating system |
JP2866241B2 (en) | 1992-01-30 | 1999-03-08 | 株式会社東芝 | Computer system and scheduling method |
US5469562A (en) | 1992-06-26 | 1995-11-21 | Digital Equipment Corporation | Durable atomic storage update manager |
EP0636985B1 (en) | 1993-07-27 | 1998-04-08 | International Business Machines Corporation | Process monitoring in a multiprocessing server |
FR2708766B1 (en) | 1993-08-03 | 1995-09-08 | Bull Sa | Method for analyzing deadlocks in an operating system. |
US5481706A (en) | 1993-11-01 | 1996-01-02 | International Business Machines Corporation | System and method for creating thread-safe shared libraries |
US5594861A (en) | 1995-08-18 | 1997-01-14 | Telefonaktiebolaget L M Ericsson | Method and apparatus for handling processing errors in telecommunications exchanges |
US5706515A (en) | 1996-03-25 | 1998-01-06 | Sun Microsystems, Inc. | System and method for implementing an atomic wait for notification operation |
JP2882475B2 (en) * | 1996-07-12 | 1999-04-12 | 日本電気株式会社 | Thread execution method |
-
1998
- 1998-11-24 US US09/198,477 patent/US6622155B1/en not_active Expired - Lifetime
-
1999
- 1999-11-23 AU AU17441/00A patent/AU1744100A/en not_active Abandoned
- 1999-11-23 WO PCT/US1999/027854 patent/WO2000031636A1/en not_active Application Discontinuation
- 1999-11-23 EP EP99960576A patent/EP1137989A1/en not_active Withdrawn
Patent Citations (6)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5666533A (en) * | 1991-09-06 | 1997-09-09 | International Business Machines Corporation | Program execution management using process enclaves which define the scope of high-level language semantics and threads improving cooperation between processes written in multiple languages |
US5590326A (en) * | 1993-09-13 | 1996-12-31 | Kabushiki Kaisha Toshiba | Shared data management scheme using shared data locks for multi-threading |
EP0697654A1 (en) * | 1994-07-19 | 1996-02-21 | Canon Kabushiki Kaisha | Load distribution method and system |
EP0794490A2 (en) * | 1996-03-08 | 1997-09-10 | International Business Machines Corporation | Dynamic execution unit management for high performance server system |
EP0840215A1 (en) * | 1996-11-04 | 1998-05-06 | Sun Microsystems, Inc. | Method and apparatus for thread synchronization in object-based systems |
WO1998043193A2 (en) * | 1997-03-21 | 1998-10-01 | University Of Maryland | Spawn-join instruction set architecture for providing explicit multithreading |
Cited By (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN1302384C (en) * | 2003-01-31 | 2007-02-28 | 英特尔公司 | Recckoning multiroute operation quided by controlling quasi-independent point |
CN1311351C (en) * | 2003-02-19 | 2007-04-18 | 英特尔公司 | Programmable event driven yield mechanism which may activate other threads |
Also Published As
Publication number | Publication date |
---|---|
US6622155B1 (en) | 2003-09-16 |
EP1137989A1 (en) | 2001-10-04 |
AU1744100A (en) | 2000-06-13 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
WO2000031636A1 (en) | Distributed monitor concurrency control | |
JP3953130B2 (en) | Space efficient object locking system and method | |
US6510437B1 (en) | Method and apparatus for concurrent thread synchronization | |
US6247025B1 (en) | Locking and unlocking mechanism for controlling concurrent access to objects | |
Craig | Building FIFO and priorityqueuing spin locks from atomic swap | |
US5701470A (en) | System and method for space efficient object locking using a data subarray and pointers | |
US6173442B1 (en) | Busy-wait-free synchronization | |
US5404521A (en) | Opportunistic task threading in a shared-memory, multi-processor computer system | |
Michael et al. | Nonblocking algorithms and preemption-safe locking on multiprogrammed shared memory multiprocessors | |
Craig | Queuing spin lock algorithms to support timing predictability | |
US7844973B1 (en) | Methods and apparatus providing non-blocking access to a resource | |
Brandenburg | Multiprocessor real-time locking protocols | |
US20080184249A1 (en) | System, method and program for managing locks | |
US20020199069A1 (en) | Method of memory management in a multi-threaded environment and program storage device | |
US20010034753A1 (en) | Priority resource allocation in programming environments | |
JP4620871B2 (en) | Monitor conversion in multi-threaded computer systems | |
Arcangeli et al. | Using Read-Copy-Update Techniques for System V IPC in the Linux 2.5 Kernel. | |
Kashyap et al. | Scaling Guest {OS} Critical Sections with {eCS} | |
WO2012036791A1 (en) | Run-time parallelization of computer software using data associated tokens | |
Michael et al. | Relative performance of preemption-safe locking and non-blocking synchronization on multiprogrammed shared memory multiprocessors | |
Takada et al. | A novel approach to multiprogrammed multiprocessor synchronization for real-time kernels | |
McKenney | Priority-boosting RCU read-side critical sections | |
Kleiman et al. | Symmetric multiprocessing in Solaris 2.0 | |
EP1008935A2 (en) | Method and apparatus for converting a lightweight monitor to a heavyweight monitor | |
Fukuoka et al. | An efficient inter-node communication system with lightweight-thread scheduling |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
ENP | Entry into the national phase |
Ref country code: AU Ref document number: 2000 17441 Kind code of ref document: A Format of ref document f/p: F |
|
AK | Designated states |
Kind code of ref document: A1 Designated state(s): AE AL AM AT AU AZ BA BB BG BR BY CA CH CN CR CU CZ DE DK DM EE ES FI GB GD GE GH GM HR HU ID IL IN IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MA MD MG MK MN MW MX NO NZ PL PT RO RU SD SE SG SI SK SL TJ TM TR TT TZ UA UG UZ VN YU ZA ZW |
|
AL | Designated countries for regional patents |
Kind code of ref document: A1 Designated state(s): GH GM KE LS MW SD SL SZ TZ UG ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE BF BJ CF CG CI CM GA GN GW ML MR NE SN TD TG |
|
121 | Ep: the epo has been informed by wipo that ep was designated in this application | ||
DFPE | Request for preliminary examination filed prior to expiration of 19th month from priority date (pct application filed before 20040101) | ||
WWE | Wipo information: entry into national phase |
Ref document number: 1999960576 Country of ref document: EP |
|
WWP | Wipo information: published in national office |
Ref document number: 1999960576 Country of ref document: EP |
|
REG | Reference to national code |
Ref country code: DE Ref legal event code: 8642 |
|
WWW | Wipo information: withdrawn in national office |
Ref document number: 1999960576 Country of ref document: EP |