J.H.Anderson, S.Ramammurthy, K.Jeffay, "RealTime Computing with Lock-Free Shared Objects ", Proc. Real-Time Systems Symposium, IEEE Computer Society Press, Los Alamitos, Calif., 1995, pp. 28-38.  Home/Search   Document Details and Download   Summary   Related Articles   Check

.... queues to enable communication between the regular Java threads and the real time NHRT follows research in recent years, in which several researchers have investigated the use of wait free shared object algorithms as an alternative to lock based mechanisms in object based real time systems [1, 2, 3, 7, 15, 17]. Moreover, research in real time operating systems [6, 11, 9, 19] has also shown how to incorporate wait free techniques in real time kernels. Wait free implementation of shared data objects is an alternative approach for the problem of inter task communication and synchronization. Wait free ....

J. Anderson, S. Ramamurthy, and K. Jeay. Real-time computing with lock-free shared objects. ACM Transactions on Computer Systems, 15(2):134-165, May 1997. 18

....we need 7 message buffers (4 for the fast readers, and 1 for each of the slow readers) as compared to 22 buffers needed with the original Chen s algorithm. Figure 4(a) shows a particular execution state of the task set with Latest points to the 4 buffer slot. Since Reading[0] and Reading [2] point to the 4 and 5 buffer slots, the writer knows these may be in use, and will not use these buffers. Instead, it will cyclically select and write to the next available slot after Latest, the 6 buffer. The worst case scenario occurs when the last slow reader now makes a read ....

....ReaderCnt[i] representing the number of readers currently using either buffer in the row, and a flag, Cl[i] indicating which of the two buffers is more current. A variable, 0 0 1 0 0 0 1 1 P 1 CL [P 1] ReaderCnt [P 1] 1 0 0 0 1 0 0 3 P: number of readers Latest Buff [P 1] [2] Figure 5: Constructs in the Double Buffer algorithm. Latest, points to the row containing the most recently written data. A reader task first reads Latest, and indicates it is using the row by incrementing the usage count. It then reads the buffer indicated by the row s Cl flag, and decrements ....

[Article contains additional citation context not shown here]

J. Anderson, S. Ramamurthy, and K. Jeffay. Real-time computing with lock-free shared objects. In Proceedings of the 16th IEEE Real-Time Systems Symposium, pages 28--37, Dec 1995.

....programs to finish their critical section. Wait free synchronization mechanisms satisfy a stronger form of freedom from blocking than lock free synchronization (discussed in the next paragraph) as they guarantee freedom from starvation. Therefore, some authors (e.g. Anderson et al. ARJ97b] point out that wait free synchronization is a special case of lock free synchronization. However, wait free synchronization can also be implemented using locks, albeit with a nonblocking helping scheme. For example, a locking scheme with priority inheritance can be considered a wait free ....

....retry loop) However, it is not immediately apparent that this also applies to lock free synchronization. On the surface, lock free methods (like the ones in Figure 4.1 in Section 4.2.3) look dangerous because of their potentially unlimited number of retries. Fortunately, Anderson and colleagues [ARJ97b] recently determined upper bounds for the number of retries that occur in priority based systems. They derived scheduling conditions for hard real time, periodic tasks that share lock free objects, and reported that lock free shared objects often incur less overhead than object implementations ....

James H. Anderson, Srikanth Ramamurthy, and Kevin Jeffay. Real-time computing with lock-free shared objects. ACM Transactions of Computer Systems, 15(2):134--165, May 1997.

....line speeds. nanoProtean combines the use of a Shared Arena to expose instantaneous resource scheduling and nonblocking data structures to improve system efficiency. Nonblocking data structures [8] have been used previously to implement efficient regular [9] and real time operating system services[10] and priority scheduling[11] The novel approach for routing is attaching kernel schedulable entities (kernel threads) to every packet, and an operating system design that efficiently provides threading without having to disable interrupts including periods during a context switch. The thread ....

J. Anderson and et. al., "Real-time computing with lock-free shared objects, " ACM Transactions on Computer Systems, 134--165.

....to help; no retry loop) it is not immediately apparent that this also applies to lock free synchronization. On the surface, lock free methods (like the ones in Figure 3 in Section 4.3) look dangerous because of their potentially unlimited number of retries. Fortunately, Anderson and colleagues [3] recently determined upper bounds for the number of retries that occur in priority based systems. They derived scheduling conditions for hard real time, periodic tasks that share lock free objects, and reported that lock free shared objects often incur less overhead than object implementations ....

James H. Anderson, Srikanth Ramamurthy, and Kevin Jeffay. Real-time computing with lock-free shared objects. ACM Transactions of Computer Systems, 15(2):134--165, May 1997.

....lower priority task. The waiting or blocking in addition causes problems in the scheduler as well as the schedulability of task sets. While the non blocking approach could be a promising solution to these problems, the time and space overheads of an implementation must be kept low and bounded [2, 5, 21]. This requirement is very important to ensure that timing behaviours of tasks are predictable as well as analyzable. This report presents a three slot asynchronous mechanism to implement data objects shared between a single reader and a single writer within shared memory multiprocessor real time ....

Anderson, J., Ramamurthy, S., and Jeffay, K. Real-Time Computing with Lock-Free Shared Objects. In Proc. of the 16th IEEE Real-Time Systems Symposium (1995), pp. 28--37.

....satisfy application requirements, trade off between the time and space overheads is thus necessary. For real time applications, a lock free implementation must ensure that the time and space overheads are kept low and bounded so that timing behaviours of tasks are reasonable as well as analyzable [2, 5, 20]. This report presents an asynchronous mechanism to realize non blocking data sharing between a single writer and multiple readers within shared memory multiprocessor real time systems. The mechanism is loop free, as well as wait free, in the sense that no loop of read and check operations is ....

Anderson, J., Ramamurthy, S., and Jeffay, K. Real-Time Computing with Lock-Free Shared Objects. In Proc. of the 16th IEEE Real-Time Systems Symposium (1995), pp. 28--37.

....apparent that lock free shared objects can be employed if tasks must adhere to strict timing constraints. In particular, repeated interferences can cause a given operation to take an arbitrarily long time to complete. Fortunately, such interferences can be bounded by scheduling tasks appropriately [4]. As explained in the next section, the key to scheduling such tasks is to allow enough spare processor time to accommodate the failed object updates that can occur over any interval. The number of failed updates in such an interval is bounded by the number of task preemptions within that ....

....lock free objects clearly do not give rise to priority inversions, it may seem that unbounded retry loops render such objects useless in real time systems. Nonetheless, Anderson et al. have shown that if tasks on a uniprocessor are scheduled appropriately, then such loops are indeed bounded [4]. We now explain why such bounds exist. For the sake of explanation, let us call an iteration of a retry loop a successful update if it successfully completes, and a failed update otherwise. Thus, an invocation of a lock free operation consists of any number of failed updates followed by one ....

[Article contains additional citation context not shown here]

J. Anderson, S. Ramamurthy, and K. Jeffay "Real-Time Computing with Lock-Free Shared Objects", Proceedings of the 16th IEEE Real-Time Systems Symposium, 1995, pp. 28-37.

....notions about utilization utilization represents the fraction of the time the processor must be active for a valid schedule of the task set. If that fraction is greater than one, then there is more work than time available, and the task set has no valid schedule. We follow the work of [ARJ 97] Theorem 3.1 ( ARJ 97] If a task set is schedulable, its utilization must be at most 1. Proof: Assume that there is a valid schedule for some task set T . Then every deadline of the task set will be met. Thus, we know that each task i is scheduled for e i time units every p i time units ....

.... utilization represents the fraction of the time the processor must be active for a valid schedule of the task set. If that fraction is greater than one, then there is more work than time available, and the task set has no valid schedule. We follow the work of [ARJ 97] Theorem 3. 1 ( ARJ 97] If a task set is schedulable, its utilization must be at most 1. Proof: Assume that there is a valid schedule for some task set T . Then every deadline of the task set will be met. Thus, we know that each task i is scheduled for e i time units every p i time units after r i . Thus, for t r i ....

J. Anderson, S. Ramamurthy, and K. Jeffay, Real-Time Computing with Lock-Free Shared Objects (Technical Report), scheduled to appear in ACM Transactions on Computer Systems, 15(2), 1997.

....variable to implement an object. In contrast, helping schemes for asynchronous systems typically require one announce variable per task [1, 2, 8] In addition, 1 The first and third author and colleagues have done much recent work on the use of lock free shared objects in real time systems [3, 4, 6]. Lockfree and wait free objects are related, but different, notions. As explainedin [3, 4, 6] lock free algorithms constitute an optimistic notion of nonblocking user level synchronization. Uniprocessor Schemes Multiprocessor Schemes IHI: Incremental helping with inheritance. IHC: ....

....typically require one announce variable per task [1, 2, 8] In addition, 1 The first and third author and colleagues have done much recent work on the use of lock free shared objects in real time systems [3, 4, 6] Lockfree and wait free objects are related, but different, notions. As explainedin [3, 4, 6], lock free algorithms constitute an optimistic notion of nonblocking user level synchronization. Uniprocessor Schemes Multiprocessor Schemes IHI: Incremental helping with inheritance. IHC: Incremental helping with ceilings. CH1: Cyclic helping with one helping ring. CHN: Cyclic helping with ....

[Article contains additional citation context not shown here]

J. Anderson, S. Ramamurthy, and K. Jeffay, "RealTime Computing with Lock-Free Shared Objects", ACM Trans. on Computer Systems, 15(2), May 1997, pp. 134-165.

....end Figure 2: Lock free enqueue operation. 2. 1 Scheduling with Lock Free Objects For real time applications on uniprocessors, we have shown through work on task scheduling that lock free objects often outperform both conventional lock based schemes and wait free objects by a substantial margin [3]. The good performance of lock free objects in this context is primarily due to the fact that they avoid priority inversions with no kernel support for object sharing (in contrast to lock based schemes) and with low algorithmic overhead (in contrast to wait free objects, which usually require a ....

.... contrast to wait free objects, which usually require a more complicated implementation since all waiting dependencies are precluded) We have validated these claims both formally, based on scheduling models, and experimentally, based on research involving a desktop videoconferencing system (see [3] for details) Although it should be clear that lock free objects do not give rise to priority inversions, it may seem that unbounded retry loops render such objects useless in real time systems. The main contribution of [3] is to show that if tasks on a uniprocessor are scheduled appropriately, ....

[Article contains additional citation context not shown here]

J. Anderson, S. Ramamurthy, and K. Jeffay "Real-Time Computing with Lock-Free Shared Objects (Extended Abstract)", Proceedings of the 16th IEEE Real-Time Systems Symposium, IEEE Computer Society Press, December 1995, pp. 28-37.

.... overhead required of lock based protocols (although, to our knowledge, no one has verified this experimentally) On uniprocessors, Anderson, Ramamurthy, and Jeffay have shown that such overhead can be avoided altogether by using lock free object implementations, rather than wait free ones [5]. On the surface, it is not immediately apparent that lock free shared objects can be employed if tasks must adhere to strict timing constraints. In particular, lock free implementations permit concurrent operations to interfere with each other, and repeated interferences can cause a given ....

....can be employed if tasks must adhere to strict timing constraints. In particular, lock free implementations permit concurrent operations to interfere with each other, and repeated interferences can cause a given operation to take an arbitrarily long time to complete. The main contribution of [5] is to show that such interferences can be bounded on uniprocessors by judicious scheduling. Another possible reason for the lack of acceptance of wait free and lock free object implementations among real time practitioners is that many published implementations require strong synchronization ....

J. Anderson, S. Ramamurthy, and K. Jeffay, "RealTime Computing with Lock-Free Shared Objects", Proceedings of the 16th IEEE Real-Time Systems Symposium, 1995, pp. 28-37.

....operating system to identify those tasks that may lock a semaphore, which results in additional complexity in operating system services. This information is used to ensure that the priority of a task holding a semaphore is at least that of the highest priority task that locks that semaphore. In [1], we propose using lock free objects as an alternative for object sharing in real time systems. Lock free objects are usually implemented using retry loops . For example, in the universal, lock free implementation presented in [2] a task performs an operation by repeating the following steps: ....

....and a local copy of the object is made; then, the desired operation is performed on the local copy; finally, a store conditional is performed to attempt to swing the shared object pointer to point to the local copy. These steps are repeated until the last step succeeds. The main contribution of [1] is to derive scheduling conditions for periodic tasks that share lock free objects on a uniprocessor. This work pertains to hard real time systems, 2 and encompasses both static and dynamic priority schemes. The scheduling conditions we derive show that for hard real time applications on a ....

J. Anderson, S. Ramamurthy, and K. Jeffay, "RealTime Computing with Lock-Free Shared Objects", Technical Report, Department of Computer Science, The University of North Carolina, 1995.

....within a critical section, then other tasks are prevented from accessing that critical section. In several related papers, we have presented general techniques that can be used to implement lock free objects in real time uniprocessor systems [3, 18] and to schedule tasks that share such objects [3, 4]. Related research includes work on techniques for implementing specific lock free objects (such as read write buffers) 13, 19, 20] and work on synchronization mechanisms that are similar to lock free objects but are implemented using kernel support [12, 19, 20] Operations on lock free objects ....

....apparent that lock free shared objects can be employed if tasks must adhere to strict timing constraints. In particular, repeated interferences can cause a given operation to take an arbitrarily long time to complete. Fortunately, such interferences can be bounded by scheduling tasks appropriately [4]. As explained in the next section, the key to scheduling such tasks is to allow enough spare processor time to accommodate the failed object updates due to interferences that can occur over any interval. The number of interferences within an interval is bounded by the number of task preemptions ....

[Article contains additional citation context not shown here]

J. Anderson, S. Ramamurthy, and K. Jeffay "Real-Time Computing with Lock-Free Shared Objects", Proceedings of the 16th IEEE Real-Time Systems Symposium, 1995, pp. 28-37.

....how these features can be exploited in order to provide the foundations for non blocking synchronization. In particular, we show how CAS can be efficiently implemented in SCRAMNet systems. Anderson et al. recognized the utility of nonblocking shared object implementations in real time systems [4] and implemented universal primitives for such systems [14] These results exploit the characteristics of common real time schedulers. In contrast, the results presented here do not rely on any scheduling assumptions; instead we exploit features of the underlying hardware. In particular, each ....

J. Anderson, S. Ramamurthy, and K. Jeffay, "RealTime Computing with Lock-Free Shared Objects", Proceedings of the 16th IEEE Real-Time Systems Symposium, 1995, pp. 28-37.

....apparent that lock free shared objects can be employed if tasks must adhere to strict timing constraints. In particular, repeated interferences can cause a given operation to take an arbitrarily long time to complete. Fortunately, such interferences can be bounded by scheduling tasks appropriately [4]. As explained in the next section, the key to scheduling such tasks is to allow enough spare processor time to accommodate the failed object updates that can occur over any interval. The number of failed updates in such an interval is bounded by the number of task preemptions within that ....

....objects do not give rise to priority inversions, it may seem that unbounded retry loops render such objects useless in realtime systems. Nonetheless, Anderson, Ramamurthy, and Jeffay have shown that if tasks on a uniprocessor are scheduled appropriately, then such loops are indeed bounded [4]. We now explain intuitively why such bounds exist. For the sake of explanation, let us call an iteration of a retry loop a successful update if it successfully completes, and a failed update otherwise. Thus, a single invocation of a lock free operation consists of any number of failed updates ....

[Article contains additional citation context not shown here]

J. Anderson, S. Ramamurthy, and K. Jeffay "RealTime Computing with Lock-Free Shared Objects", Proceedings of the 16th IEEE Real-Time Systems Symposium, 1995, pp. 28-37.

....returns Qtype repeat old : H ; if old = NULL then return NULL fi; new : old Gamma next until CAS2( H ; old Gamma next ) old ; new ; new ; NULL) return(old) Figure 1: Lock free queue implementation. in such applications was first established by Anderson, Ramamurthy, and Jeffay [4]. Operations on lockfree objects are usually implemented using retry loops . Figure 1 depicts an example, a lock free queue implementation. An item is enqueued in this implementation by using a two word compare and swap (CAS2) instruction 2 to atomically update a shared tail pointer and the ....

....1 allows a given task to experience repeated failed loop iterations due to interfering concurrent enqueues. Anderson et al. observed that, on a uniprocessor, the cost of such failed loop iterations over an interval of time can be bounded by the number of job releases 3 within that interval [4]. This observation is the basis of scheduling conditions presented in [4] for the rate monotonic (RM) 15] deadline monotonic (DM) 14] and earliest deadline first (EDF) 15] schemes. Each of these conditions is based on the same insight: a set of tasks that share lock free objects is ....

[Article contains additional citation context not shown here]

J. Anderson, S. Ramamurthy and K. Jeffay, "Real-Time Computing with Lock-Free Shared Objects (Extended Abstract)", Proceedings of the 16th IEEE Real-Time Systems Symposium, IEEE Computer Society Press, December 1995, pp. 28-37.

.... scheduling overhead required of lock based protocols (although, to our knowledge, no one has verified this experimentally) On uniprocessors, Anderson, Ramamurthy, and Jeffay have shown that such overhead can be avoided altogether by using lock free, rather than wait free, object implementations [2]. On the surface, it is not immediately apparent that lock free shared objects can be employed if tasks must adhere to strict timing constraints. In particular, lock free implementations permit concurrent operations to interfere with each other, and repeated interferences can cause a given ....

....can be employed if tasks must adhere to strict timing constraints. In particular, lock free implementations permit concurrent operations to interfere with each other, and repeated interferences can cause a given operation to take an arbitrarily long time to complete. The main contribution of [2] is to show that such interferences can be bounded on uniprocessors by judicious scheduling. Another possible reason for the lack of acceptance of wait free and lock free object implementations among real time practitioners is that many published implementations require strong synchronization ....

J. Anderson, S. Ramamurthy, and K. Jeffay, "RealTime Computing with Lock-Free Shared Objects", to appear in the Proceedings of the 16th IEEE Real-Time Systems Symposium, 1995.

....the earliest deadline first scheme with dynamic deadline modification (EDF DDM) 10] An alternative to such schemes is to use lock free algorithms for implementing objects. The general utility of lock free objects in real time applications was first established by Anderson, Ramamurthy, and Jeffay [3]. Operations on lock free objects are usually implemented using retry loops . 1 Figure 1 depicts lock free queue operations Work supported by NSF grants CCR 9216421 and CCR 9510156, by an Alfred P. Sloan ResearchFellowship, and by a Young InvestigatorAward from the U.S. Army Research Office, ....

....1 allows a given task to experience repeated failed loop iterations due to interfering concurrent enqueues. Anderson et al. observed that, on a uniprocessor, the cost of such failed loop iterations over an interval of time can be bounded by the number of job releases 3 within that interval [3]. This observation is the basis of scheduling conditions presented in [3] for the rate monotonic (RM) 13] deadlinemonotonic (DM) 12] and earliest deadline first (EDF) 13] schemes. Note that, with lock free objects, the overhead term is the cost of failed loop iterations, and lower priority ....

[Article contains additional citation context not shown here]

J. Anderson, S. Ramamurthy and K. Jeffay, "Real-Time Computing with Lock-Free Shared Objects (Extended Abstract)", Proceedings of the 16th IEEE Real-Time Systems Symposium, IEEE Computer Society Press, December 1995, pp. 28-37.

No context found.

J.H.Anderson, S.Ramammurthy, K.Jeffay, "RealTime Computing with Lock-Free Shared Objects ", Proc. Real-Time Systems Symposium, IEEE Computer Society Press, Los Alamitos, Calif., 1995, pp. 28-38.

No context found.

Anderson, James H., Ramamurthy, Srikanth, and Jeffay, Kevin, "Real- Time Computing with Lock-Free Shared Objects", University of North Carolina, 1997.

No context found.

J.H. Anderson, S. Ramamurthy, and K. Jeffay, Real-Time Computing with LockFree Shared Objects, IEEE Real-Time Systems Symposium 1995, pp. 28-37.

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC