STM Concurrency Control for Embedded Real-Time Software with Tighter Time Bounds

Transcription

1 STM Concurrency Control for Embedded Real-me Software with ghter me Bounds Mohammed El-Shambakey ECE Dept., Virginia Tech Blacksburg, VA 246, USA Binoy Ravindran ECE Dept., Virginia Tech Blacksburg, VA 246, USA ABSTRACT We consider software transactional memory STM) concurrency control for multicore real-time software, and present a novel contention manager CM) for resolving transactional conflicts, called length-based CM or LCM). We upper bound transactional retries and response times under LCM, when used with G-EDF and G- RMA schedulers. We identify the conditions under which LCM outperforms previous real-time STM CMs and lock-free synchronization. Our implementation and experimental studies reveal that G-EDF/LCM and G-RMA/LCM have shorter or comparable retry costs and response times than other synchronization techniques. Categories and Subect Descriptors C.3 [Special-Purpose and Application-based Systems]: Real-time and embedded systems General Terms Design, Experimentation, Measurement Keywords Software transactional memory STM), real-time contention manager 1. INTRODUCTION Lock-based concurrency control suffers from programmability, scalability, and composability challenges [12]. These challenges are exacerbated in emerging multicore architectures, on which improved software performance must be achieved by exposing greater concurrency. Transactional memory TM) is an alternative synchronization model for shared memory obects that promises to alleviate these difficulties. With TM, programmers organize code that read/write shared obects as transactions, which appear to execute atomically. Two transactions conflict if they access the same obect and one access is a write. When that happens, a contention manager or CM) resolves the conflict by aborting one and allowing the other to commit, yielding the illusion of) atomicity. In addition Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. DAC 212, June 3-7, 212, San Francisco, California, USA. Copyright 212 ACM /12/6...$1.. to a simple programming model, TM provides performance comparable to highly concurrent fine-grained locking and lock-free approaches, and is composable. TM has been proposed in hardware, called HTM, and in software, called STM, with the usual tradeoffs: HTM has lesser overhead, but needs transactional support in hardware; STM is available on any hardware. See [11] for an excellent overview on TM. Given STM s programmability, scalability, and composability advantages, we consider it for concurrency control in multicore real-time software. Doing so requires bounding transactional retries, as real-time threads, which subsume transactions, must satisfy time constraints. Retry bounds in STM are dependent on the CM policy at hand. Thus, real-time CM is logical. Past research on real-time CM have proposed resolving transactional contention using dynamic and fixed priorities of parent threads, resulting in Earliest-Deadline-First-based CM ) and Rate Monotonic Assignment-based CM ), respectively [7 9]. These works show that, and, when used with the Global EDF G-EDF) and Global RMA G-RMA) multicore schedulers, respectively, achieve higher schedulability than lock-free synchronization techniques only under some ranges for the maximum atomic section length. This raises a fundamental question: is it possible to increase the atomic section length by an alternative CM design, so that STM s schedulability advantage has a larger coverage? We answer this question by designing a novel CM that can be used with both dynamic and fixed priority global) multicore realtime schedulers: length-based CM or LCM Section 4.1). LCM resolves conflicts based on the priority of conflicting obs, besides the length of the interfering atomic section, and the length of the interfered atomic section. We establish LCM s retry and response time upper bounds, when used with G-EDF Section 4.2) and with G-RMA Section 4.5) schedulers. We identify the conditions under which G-EDF/LCM outperforms Section 4.3) and lockfree synchronization Section 4.4), and G-RMA/LCM outperforms Section 4.6). We implement LCM and competitor CM techniques in the Rochester STM framework [14] and conduct experimental studies Section 5). Our study reveals that G-EDF/LCM and G-RMA/LCM have shorter or comparable retry costs and response times than competitors. Thus, the paper s contribution is LCM with superior timeliness properties. This result thus allows programmers to reap STM s significant programmability and composability benefits for a broader range of multicore embedded real-time software than what was previously possible. 2. RELATED WORK Transactional-like concurrency control without using locks, for real-time systems, has been previously studied in the context of

2 non-blocking data structures e.g., [1]). Despite their numerous advantages over locks e.g., deadlock-freedom), their programmability has remained a challenge. Past studies show that they are best suited for simple data structures where their retry cost is competitive to the cost of lock-based synchronization [3]. In contrast, STM is semantically simpler [12], and is often the only viable lock-free solution for complex data structures e.g., red/black tree) [1] and nested critical sections [15]. STM concurrency control for real-time systems has been previously studied in [2, 7, 9, 1, 13, 16, 17]. [13] proposes a restricted version of STM for uniprocessors. Uniprocessors do not need contention management. [9] bounds response times in distributed systems with STM synchronization. They consider Pfair scheduling, limit to small atomic regions with fixed size, and limit transaction execution to span at most two quanta. In contrast, we allow transaction lengths with arbitrary duration. [16] presents real-time scheduling of transactions and serializes transactions based on deadlines. However, the work does not bound retries and response times. In contrast, we establish such bounds. [17] proposes real-time HTM. The work does not describe how transactional conflicts are resolved. Besides, the retry bound assumes that the worst case conflict between atomic sections of different tasks occurs when the sections are released at the same time. However, we show that this is not the worst case. We develop retry and response time upper bounds based on much worse conditions. [1] upper bounds retries and response times for with G- EDF, and identify the tradeoffs with locking and lock-free protocols. Similar to [17], [1] also assumes that the worst case conflict between atomic sections occurs when the sections are released simultaneously. The ideas in [1] are extended in [2], which presents three real-time CM designs. But no retry bounds or schedulability analysis techniques are presented for those CMs. [7] presents the and contention managers, and upper bounds transactional retries and response times under them. The work also identifies the conditions under which and are superior to lock-free synchronization. In particular, they show that, STM s superiority holds only under some ranges for the maximum atomic section length. Our work builds upon this result. 3. PRELIMINARIES We consider a multiprocessor system with m identical processors and n sporadic tasks 1, 2,..., n. The k th instance or ob) of a task i is denoted k i. Each task i is specified by its worst case execution time WCET) c i, its minimum period T i between any two consecutive instances, and its relative deadline D i, where D i = T i. Job i is released at time ri and must finish no later than its absolute deadline d i = r i + D i. Under a fixed priority scheduler such as G- RMA, p i determines i s fixed) priority and it is constant for all instances of i. Under a dynamic priority scheduler such as G- EDF, a ob i s priority, pi, differs from one instance to another. A task may interfere with task i for a number of times during an interval L, and this number is denoted as G i L). Shared obects. A task may need to read/write shared, in-memory data obects while it is executing any of its atomic sections, which are synchronized using STM. The set of atomic sections of task i is denoted s i. s k i is the k th atomic section of i. Each obect, θ, can be accessed by multiple tasks. The set of distinct obects accessed by i is θ i without repeating obects. The set of atomic sections used by i to access θ is s i θ), and the sum of the lengths of those atomic sections is lens i θ)). s k i θ) is the kth atomic section of i that accesses θ. s k i θ) executes for a duration lensk i θ)). The set of tasks sharing θ with i is denoted γ i θ). Atomic sections are non-nested supporting nested STM is future work). Each section is assumed to access only one obect; this allows us to be consistent with the assumptions in [7], enabling a comparison with retry-loop lock-free synchronization [5], which is an important goal of this paper. The maximum-length atomic section in i that accesses θ is denoted s imax θ), while the maximum one among all tasks is s max θ), and the maximum one among tasks with priorities lower than that of i is s i maxθ). STM retry cost. If two or more atomic sections conflict, the CM will commit one section and abort and retry the others, increasing the time to execute the aborted sections. The increased time that an atomic section s p i θ) will take to execute due to a conflict with another section s k p θ), is denoted Wi s k θ)). If an atomic section, sp i, is already executing, and another atomic section s k tries to access a shared obect with s p i, then sk is said to interfere" or conflict" with s p i. The ob sk is the interfering ob", and the ob sp i is the interfered ob." The total time that a task i s atomic sections have to retry over T i is denoted RCT i ). The additional amount of time that a task causes to response time of i when interfering with i during L, without considering retries due to atomic sections, is denoted W i L). 4. LENGTH-BASED CM LCM resolves conflicts based on the priority of conflicting obs, besides the length of the interfering atomic section, and the length of the interfered atomic section. This is in contrast to and [7], where conflicts are resolved using the priority of the conflicting obs. This strategy allows lower priority obs, under LCM, to retry for lesser time than that under and, but higher priority obs, sometimes, wait for lower priority ones with bounded priority-inversion. 4.1 Design and Rationale Algorithm 1: LCM Data: s k i θ) interfered atomic section. s l θ) interfering atomic section. ψ predefined threshold [,1]. δ k i θ) remaining execution length of sk i θ) Result: which atomic section of s k i θ) or sl θ) aborts 1 if p k i > pl then 2 s l θ) aborts; 3 else 4 c kl i = lensl θ))/lensk i θ)); 5 α kl i = lnψ)/lnψ) ckl i ); 6 α = lens k i θ)) δk i θ)) /lens k i θ)); 7 if α α kl i then 8 s k i θ) aborts; 9 else 1 s l θ) aborts; 11 end 12 end For both and, s k i θ) can be totally repeated if sl θ) which belongs to a higher priority ob b than a i conflicts with s k i θ) at the end of its execution, while sk i θ) is ust about to commit. Thus, LCM, shown in Algorithm 1, uses the remaining

3 length of s k i θ) when it is interfered, as well as lensl θ)), to decide which transaction must be aborted. If p k i was greater than p l, then s k i θ) would be the one that commits, because it belongs to a higher priority ob, and it started before s l θ) step 2). Otherwise, ckl i is calculated step 4) to determine whether it is worth aborting s k i θ) in favor of s l θ), because lensl θ)) is relatively small compared to the remaining execution length of s k i θ) explained further). We assume that: c kl i = lensl θ))/lensk i θ)) 1) where c kl i ], [, to cover all possible lengths of sl θ). Our idea is to reduce the opportunity for the abort of s k i θ) if it is close to committing when interfered and lens l θ)) is large. This abort opportunity is increasingly reduced as s k i θ) gets closer to the end of its execution, or lens l θ)) gets larger. On the other hand, as s k i θ) is interfered early, or lensl θ)) is small compared to s k i θ) s remaining length, the abort opportunity is increased even if s k i θ) is close to the end of its execution. To decide whether s k i θ) must be aborted or not, we use a threshold value ψ [,1] that determines α kl i step 5), where αkl i is the maximum percentage of lens k i θ)) below which sl θ) is allowed to abort s k i θ). Thus, if the already executed part of sk i θ) when s l θ) interferes with sk i θ) does not exceed αkl i lensk i θ)), then s k i θ) is aborted step 8). Otherwise, sl θ) is aborted step 1). Abort percent s =.1s i s =.1s i s =s i s =1s i s =1s i s l θ) aborts sk i θ) if the latter has not executed more than α3 percentage shown in Figure 1) of its execution length. As lens l θ)) decreases, the corresponding α kl i increases as shown in Figure 1, α3 > α2 > α1). Equation 2) achieves the desired requirement that the abort opportunity is reduced as s k i θ) gets closer to the end of its execution as α 1, f c kl i,1) ), or as the length of the conflicting transaction increases as c kl i, f,α) ). Meanwhile, this abort opportunity is increased as s k i θ) is interfered closer to its release as α, f c kl i,) 1), or as the length of the conflicting transaction decreases as c kl i, f,α) 1). LCM is not a centralized CM, which means that, upon a conflict, each transactions has to decide whether it must commit or abort. CLAIM 1. Let s l θ) interfere once with sk i θ) at αkl i. Then, the maximum contribution of s l θ) to sk i θ) s retry cost is: ) ) Wi k sl θ)) αkl i len s k i θ) + len s l θ) 3) Proofs of all claims are provided in the Supplementary Material section at the end of the paper.) CLAIM 2. An atomic section of a higher priority ob, b, may have to abort and retry due to a lower priority ob, a i, if sl θ) interferes with s k i θ) after the αkl i percentage. s retry time, due to s k i θ) and sl θ), is upper bounded by: ) ) W l sk i θ)) 1 α kl i len s k i θ) 4) CLAIM 3. A higher priority ob, z i, suffers from priority inversion for at most number of atomic sections in z i. CLAIM 4. The maximum delay suffered by s l θ) due to priority inversion is caused by the maximum length atomic section accessing obect θ, which belongs to a lower priority ob than b that owns s l θ). α1 α2 α s i percent α) Figure 1: Interference of s k i θ) by various lengths of sl θ) The behavior of LCM is illustrated in Figure 1. In this figure, the horizontal axis corresponds to different values of α ranging from to 1, and the vertical axis corresponds to different values of abort opportunities, f c kl i,α), ranging from to 1 and calculated by 2): f c kl ckl i α i,α) = e 1 α 2) where c kl i is calculated by 1). Figure 1 shows one atomic section s k i θ) whose α changes along the horizontal axis) interfered by five different lengths of s l θ). For a predefined value of f c kl i,α) denoted as ψ in Algorithm 1), there corresponds a specific value of α which is α kl i in Algorithm 1) for each curve. For example, when lens l θ)) =.1 lensk i θ)), 4.2 Response me of G-EDF/LCM CLAIM 5. RCT i ) for a task i under G-EDF/LCM is upper bounded by: ) RCT i ) = T h γ i θ θ i θ h h len s l h θ) s l h θ) ) )) + α hl maxlen s h maxθ) + ) ) 1 α iy max len s i maxθ) s y i θ) where α hl max is the α value that corresponds to ψ due to the interference of s h maxθ) by s l h θ). αiy max is the α value that corresponds to ψ due to the interference of s i maxθ) by s y i θ). Response time of i is calculated by 11) in [7]. 5)

4 Jh h i p p+1 h h h h h T T t) Figure 2: p h has a higher priority than x i 4.3 Schedulability of G-EDF/LCM and We now compare the schedulability of G-EDF/LCM with [7] to understand when G-EDF/LCM will perform better. Toward this, we compare the total utilization of with that of G-EDF/LCM. For each method, we inflate the c i of each task i by adding the retry cost suffered by i. Thus, if method A adds retry cost RC A T i ) to c i, and method B adds retry cost RC B T i ) to c i, then the schedulability of A and B are compared as: c i + RC A T i ) c i + RC B T i ) T i i T i i RC A T i ) RC B T i ) T i i 6) T i i Thus, schedulability is compared by substituting the retry cost added by the synchronization methods in 6). CLAIM 6. Let s max be the maximum length atomic section accessing any obect θ. Let α max and α min be the maximum and minimum values of α for any two atomic sections s k i θ) and sl θ). Given a threshold ψ, schedulability of G-EDF/LCM is equal or better than if for any task i : 1 α min 1 α max 7) T h γ i h 4.4 G-EDF/LCM versus Lock-free We consider the retry-loop lock-free synchronization for G-EDF given in [5]. This lock-free approach is the most relevant to our work. CLAIM 7. Let s max denote lens max ) and r max denote the maximum execution cost of a single iteration of any retry loop of any task in the retry-loop lock-free algorithm in [5]. Now, G-EDF/LCM achieves higher schedulability than the retry-loop lock-free approach if the upper bound on s max /r max under G-EDF/LCM ranges between.5 and 2 which is higher than that under ). 4.5 Response me of G-RMA/LCM CLAIM 8. Let λ 2,θ) = lens l l θ)) + αmaxlensmaxθ)) s l θ) where αmax l is the α value corresponding to ψ due to the interference of smaxθ) by s l θ). The retry cost of any task i under G-RMA/LCM during T i is given by: RC T i ) = + s y i θ) θ θ i θ ) 1 α iy max ) len ),θ)) + 1 λ 2 T ) s i maxθ) 8) where = { γ i ) p > p i )}. The response time is calculated by 17) in [7] with replacing RCR up i ) with RCT i ). 4.6 Schedulability of G-RMA/LCM and CLAIM 9. Under the same assumptions of Claims 6 and 8, G- RMA/LCM s schedulability is equal or better than if: ) 1 α min 1 α max + 1 9) T 5. EXPERIMENTAL EVALUATION Having established LCM s retry and response time upper bounds, and the conditions under which it outperforms,, and lock-free synchronization, we now would like to understand how LCM s retry and response times in practice i.e., on average) compare with that of competitor methods. Since this can only be understood experimentally, we implement LCM and the competitor methods and conduct experimental studies. 5.1 Experimental Setup We used the ChronOS real-time Linux kernel [4] and the RSTM library [14]. We modified RSTM to include implementations of,, G-EDF/LCM, and G-RMA/LCM contention managers, and modified ChronOS to include implementations of G-EDF and G-RMA schedulers. For the retry-loop lock-free implementation, we used a loop that reads an obect and attempts to write to the obect using a compareand-swap CAS) instruction. The task retries until the CAS succeeds. We use an 8 core, 2GHz AMD Opteron platform. The average time taken for one write operation by RSTM on any core is µs, and the average time taken by one CAS-loop operation on any core is µs. We used the periodic task set shown in Table 1. Each task runs in its own thread and has an atomic section. Atomic section properties are probabilistically controlled for experimental evaluation) using three parameters: the maximum and minimum lengths of any atomic section within the task, and the total length of atomic sections within any task. All task atomic sections access the same obect, and do write operations on the obect thus, contention is the highest). 5.2 Results Figure 3 shows the retry cost RC) for each task in the three task sets in Table 1, where each task s atomic section length is equal to half of the task length. Each data point in the figure has a confidence level of.95. We observe that G-EDF/LCM and G- RMA/LCM achieve shorter or comparable retry cost than and. Since all tasks are initially released at the same time, and due to the specific nature of task properties, tasks with lower IDs somehow have higher priorities under the G-EDF scheduler. Note that tasks with lower IDs have higher priorities under G-RMA, since tasks are ordered in non-decreasing order of their periods. Thus, we observe that G-EDF/LCM and G-RMA/LCM achieve comparable retry costs to and for some tasks with lower IDs. But when task ID increases, LCM for both schedulers achieves much shorter retry costs than and. This is because, higher priority tasks in LCM suffers blocking by lower priority tasks, which is not the case for and. However, as task priority decreases, LCM, by definition, prevents higher priority tasks from aborting lower priority ones if a higher priority task

5 Table 1: Task sets. a) Task set 1: 5-task set; b) Task set 2: 1-task set; c) Task set 3: 12-task set b) T i µs) c i µs) a) T i µs) c i µs) c) T i µs) c i µs) e+9 1.8e+9 1.6e+9 1.4e+9 1.2e+9 1e+9 8e+8 6e+8 4e+8 2e+8-2e e+1 9e+9 8e+9 7e+9 6e+9 5e+9 4e+9 a) Task set 1 interferes with a lower priority one after a specified threshold. In contrast, under and, lower priority tasks abort in favor of higher priority ones. G-EDF/LCM and G-RMA/LCM also achieve shorter retry costs than the retry-loop lock-free algorithm. Figure 4 shows the response time of each task in the Table 1 task sets with a confidence level of.95. Again, each task s atomic section length is equal to half of the task length.) We observe that G- EDF/LCM and G-RMA/LCM achieve shorter response time than the retry-loop lock-free algorithm, and shorter or comparable response time than and. We repeated the experiments by varying three parameters: the relative total length of all atomic sections to the length of the task, the maximum relative length of any atomic section to the length of the task, and the minimum relative length of any atomic section to the length of the task. Full set of results are omitted here due to space constraints; however additional results are included in the Supplementary Material section. Full set of results are given in Appendix B in [6]. 6. CONCLUSIONS In and, a task incurs at most 2s max retry cost for each of its atomic section due to conflict with another task s atomic section. With LCM, this retry cost is reduced to 1 + α max )s max for each aborted atomic section. In and, tasks do not retry due to lower priority tasks, whereas in LCM, they do so. In G-EDF/LCM, retry due to a lower priority ob is encountered only from a task s last ob instance during i s period. This is not the case with G-RMA/LCM, because, each higher priority task can be aborted and retried by any ob instance of lower priority tasks. Schedulability of G-EDF/LCM and G-RMA/LCM is better or equal to and, respectively, by proper choices for 3e+9 2e+9 1e+9 1.2e+17 1e+17 8e+16 6e+16 4e+16 2e+16-2e b) Task set c) Task set 3 Figure 3: Task retry costs under LCM and competitor synchronization methods

6 α min and α max. Schedulability of G-EDF/LCM is better than retryloop lock-free synchronization for G-EDF if the upper bound on s max /r max is between.5 and 2, which is higher than that achieved by. Res-mensec) Res-mensec) Res-mensec) 4.5e+9 4e+9 3.5e+9 3e+9 2.5e+9 2e+9 1.5e+9 1e+9 5e+8 1.4e+1 1.2e+1 1e+1 8e+9 6e+9 4e+9 2e+9 9e+9 8e+9 7e+9 6e+9 5e+9 4e+9 3e+9 2e+9 1e a) Task set b) Task set c) Task set 3 Figure 4: Task response times under LCM and competitor synchronization methods Acknowledgments This work is supported in part by US National Science Foundation under grants CNS , CNS , CNS 11318, and CNS REFERENCES [1] J. Anderson, S. Ramamurthy, and K. Jeffay. Real-time computing with lock-free shared obects. In RTSS, pages 28 37, [2] A. Barros and L. Pinho. Managing contention of software transactional memory in real-time systems. In IEEE RTSS, Work-In-Progress, 211. [3] B. B. Brandenburg et al. Real-time synchronization on multiprocessors: To block or not to block, to suspend or spin? In RTAS, pages , 28. [4] M. Dellinger, P. Garyali, and B. Ravindran. Chronos linux: a best-effort real-time multiprocessor linux kernel. In Design Automation Conference DAC), th ACM/EDAC/IEEE, pages IEEE, 211. [5] U. C. Devi, H. Leontyev, and J. H. Anderson. Efficient synchronization under global EDF scheduling on multiprocessors. In ECRTS, pages 75 84, 26. [6] M. El-Shambakey and B. Ravindran. On the design of real-time stm contention managers. Technical report, ECE Department, Virginia Tech, 211. Available as tech-report-rt-stm-cm11.pdf. [7] M. Elshambakey and B. Ravindran. Stm concurrency control for multicore embedded real-time software: me bounds and tradeoffs. In SAC, 212. [8] S. Fahmy, B. Ravindran, and E. Jensen. Response time analysis of software transactional memory-based distributed real-time systems. In ACM SAC, pages , 29. [9] S. Fahmy, B. Ravindran, and E. D. Jensen. On bounding response times under software transactional memory in distributed multiprocessor real-time systems. In DATE, pages , 29. [1] S. F. Fahmy. Collaborative Scheduling and Synchronization of Distributable Real-me Threads. PhD thesis, Virginia Tech, 21. [11] T. Harris, J. Larus, and R. Rawar. Transactional Memory. Morgan & Claypool Publishers, 2nd. edition, December 21. [12] M. Herlihy. The art of multiprocessor programming. In PODC, pages 1 2, 26. [13] J. Manson, J. Baker, et al. Preemptible atomic regions for real-time Java. In RTSS, pages 1 71, 26. [14] V. Marathe, M. Spear, C. Heriot, A. Acharya, D. Eisenstat, W. Scherer III, and M. Scott. Lowering the overhead of nonblocking software transactional memory. In Workshop on Languages, Compilers, and Hardware Support for Transactional Computing TRANSACT), 26. [15] B. Saha, A.-R. Adl-Tabatabai, et al. McRT-STM: a high performance software transactional memory system for a multi-core runtime. In PPoPP, pages , 26. [16] T. Sarni, A. Queudet, and P. Valduriez. Real-time support for software transactional memory. In RTCSA, pages , 29. [17] M. Schoeberl, F. Brandner, and J. Vitek. RTTM: Real-time transactional memory. In ACM SAC, pages , 21. Supplementary Material This section includes proofs of all Claims. S.1 Proof of Claim 1 PROOF. If s l θ) interferes with sk i θ) at a ϒ percentage, where ϒ < α kl i, then the retry cost of sk i θ) is ϒlensk i θ)) + lensl θ)),

7 which is lower than that calculated in 3). Besides, if s l θ) interferes with s k i θ) after αkl i percentage, then sk i θ) will not abort. S.2 Proof of Claim 2 PROOF. It is derived directly from Claim 1, as s l θ) will have to retry for the remaining length of s k i θ). S.3 Proof of Claim 3 PROOF. Assuming three atomic sections, s k i θ), sl θ) and sb aθ), where p > p i and s l θ) interferes with sk i θ) after αkl i. Then sl θ) will have to abort and retry. At this time, if s b aθ) interferes with the other two atomic sections, and the LCM decides which transaction to commit based on comparison between each two transactions. So, we have the following cases:- p a < p i < p, then s b aθ) will not abort any one because it is still in its beginning and it is of the lowest priority. So. is not indirectly blocked by a. p i < p a < p and even if s b aθ) interferes with s k i θ) before α kb ia, so, sb aθ) is allowed abort s k i θ). Comparison between s l θ) and sb aθ) will result in LCM choosing s l θ) to commit and abort s b aθ) because the latter is still beginning, and is of higher priority. If s b aθ) is not allowed to abort s k i θ), the situation is still the same, because s l θ) was already retrying until s k i θ) finishes. p a > p > p i, then if s b aθ) is chosen to commit, this is not priority inversion for because a is of higher priority. if a preempts i, then LCM will compare only between s l θ) and s b aθ). If p a < p, then s l θ) will commit because of its task s higher priority and s b aθ) is still at its beginning, otherwise, s l θ) will retry, but this will not be priority inversion because a is already of higher priority than. If a does not access any obect but it preempts i, then CM will choose s l θ) to commit as only already running transactions are competing together. So, by generalizing these cases to any number of conflicting obs, it is seen that when an atomic section, s l θ), of a higher priority ob is in conflict with a number of atomic sections belonging to lower priority obs, s l θ) can suffer from priority inversion by only one of them. So, each higher priority ob can suffer priority inversion at most its number of atomic section. Claim follows. S.4 Proof of Claim 4 PROOF. Assume three atomic sections, s k i θ), sl θ), and sz h θ), where p > p i, p > p h, and lens k i θ)) > lensz h θ)). Now, αkl i > α zl h and ckl i < czl h. By applying 4) to obtain the contribution of s k i θ) and sz h θ) to the priority inversion of sl θ) and dividing them, we get: ) W l sk i θ)) W l sz h θ)) = By substitution for αs from 2): = 1 α kl i 1 α zl h 1 lnψ )lens k lnψ c kl i θ)) i 1 lnψ )lens z lnψ c zl h θ)) = h lens k i ) θ)) lens z h θ)) ckl i lnψ c kl i )lens k i θ)) czl h )lens z lnψ c zl h θ)) h lnψ and c kl i,ckl h >, by substitution from 1) = lensl θ))/lnψ ckl i ) lens l θ))/lnψ czl h ) = lnψ c zl h lnψ c kl > 1 i Thus, as the length of the interfered atomic section increases, the effect of priority inversion on the interfering atomic section increases. Claim follows. S.5 Proof of Claim 5 PROOF. The maximum number of higher priority instances of h that can interfere with x i is, as shown in Figure 2, where one instance of h and p h coincides with the absolute deadline of x i. By using Claims 1, 2, 3, and 4, and Claim 1 in [7] to determine the effect of atomic sections belonging to higher and lower priority instances of interfering tasks to x i, claim follows. S.6 Proof of Claim 6 PROOF. Under, RCT i ) is upper bounded by: RCT i ) T h γ i θ θ i θ h ) h 2lens max ) 1) s z h θ) with the assumption that all lengths of atomic sections of 4) and 8) in [7] and 5) are replaced by s max. Let α hl max in 5) be replaced with α max, and α iy max in 5) be replaced with α min. As α max, α min, and lens max ) are all constants, 5) is upper bounded by: RCT i ) h γ i θ θ i θ h s l h θ) 1 + α max ) ) )) ) ) len s max + 1 α min len s max s y i θ) 11) If β ih 1 is the total number of times any instance of h accesses shared obects with i, then β ih 1 = θ θ i θ h ) s z h θ). Furthermore, if β i 2 is the total number of times any instance of i accesses shared obects with any other instance, β i 2 = s y i θ), where θ is shared with another task. Then, β i = max{max h γ i {β ih } is the maximum 1 },βi 2 number of accesses to all shared obects by any instance of i or h. Thus, 1) becomes: and 11) becomes: RCT i ) h γ i 2 RCT i ) β i lens max ) + h γ i β i lens max ) 12) 1 α min ) ) 1 + α max ) 13) We can now compare the total utilization of G-EDF/LCM with

8 that of by comparing 11) and 13) for all i : i 1 α min ) + h γ i 1 + α max ) T i h γ i 2 14) T i i 14) is satisfied if for each i, the following condition is satisfied: ) 1 α min ) α max ) 2 T h γ i h T h γ i h Claim follows. S.7 Proof of Claim 7 1 α min 1 α max T h γ i h PROOF. From [5], the retry-loop lock-free algorithm is upper bounded by: ) RLT i ) = + 1 β i r max 15) h γ i where β i is as defined in Claim 6. The retry cost of i in G- EDF/LCM is upper bounded by 13). By comparing G-EDF/LCM s total utilization with that of the retry-loop lock-free algorithm, we get: )) 1 α min )+ h γ i T 1+α max ) β i s max h i T i ) h γ i T +1 β i r max h i s max r max T i ) h γ i T +1 β i h i T i )) 16) 1 α min )+ h γ i T 1+α max ) β i h i T i Let the number of tasks that have shared obects with i be ω i.e., h γ i = ω 1 since at least one task has a shared obect with i ; otherwise, there is no conflict between tasks). Let the total number of tasks be n, so 1 ω n 1, and [1, [. To find the minimum and maximum values for the upper bound on s max /r max, we consider the following cases: α min,α max 16) will be: s max r max 1 + ω 1 i T i By substituting the edge values for ω and 1+ h γ i T h i T i 17) that the upper bound on s max /r max lies between 1 and 2. α min,α max 1 16) becomes s max r max.5 + ) in 17), we derive ω.5 i T i 18) 1+2 h γ i T h i T i By applying the edge values for ω and in 18), we derive that the upper bound on s max /r max lies between.5 and 1. α min 1,α max This case is reected since α min α max. α min 1,α max 1 16) becomes: ω s max i.5 + r 19) max h γ i T 2 h i T i By applying the edge values for ω and in 19), we derive that the upper bound on s max /r max lies between.5 and 1, which is similar to that achieved by. Summarizing from the previous cases, the upper bound on s max /r max lies between.5 and 2, whereas for [7], it lies between.5 and 1. Claim follows. S.8 Proof of Claim 8 PROOF. Under G-RMA, all instances of a higher priority task,, can conflict with a lower priority task, i, during T i. 3) can be used to determine the contribution of each conflicting atomic section in to i. Meanwhile, all instances of any task with lower priority than i can conflict with i during T i. Claims 2 and 3 can be used to determine the contribution of conflicting atomic sections in lower priority tasks to i. Using the previous notations and Claim 3 in [7], the claim follows. S.9 Proof of Claim 9 PROOF. Under the same assumptions as that of Claims 6 and 8, 8) can be upper bounded as: ) RCT i ) + 1 )1 + α max )lens max )β i T + 1 α min )lens max )β i 2) For, 16) in [7] for RCT i ) is upper bounded by: ) RCT i ) + 1 2β i lens max ) T By comparing the total utilization of G-RMA/LCM with that of, we get: ) )) lens max )β i 1 α min )+ T +1 1+α max ) i T i ) 2lens max )β i T +1 i T i 21) 21) is satisfied if i 9) is satisfied. Claim follows. S.1 EXTENDED RESULTS The three parameters x, y, z for each figure specify respectively the relative total length of all atomic sections to the length of the task, the maximum relative length of any atomic section to the length of the task, and the minimum relative length of any atomic section to the length of the task.

9 2e+9 1.8e+9 4e+9 3.5e+9 3e+9 1.6e+9 2.5e+9 1.4e+9 1.2e+9 1e+9 Res-mensec) 2e+9 1.5e+9 8e+8 1e+9 6e+8 4e+8 5e+8 2e a) Task set 1 a) Task set 1 9e+9 8e+9 1.2e+1 1e+1 7e+9 6e+9 8e+9 5e+9 4e+9 Res-mensec) 6e+9 3e+9 4e+9 2e+9 1e+9 2e b) Task set 2 b) Task set 2 1.2e+17 1e+17 9e+9 8e+9 8e+16 7e+9 6e+16 4e+16 Res-mensec) 6e+9 5e+9 4e+9 3e+9 2e+16 2e c) Task set 3 Figure 5: Task retry costs under LCM and competitor synchronization methods.5,.2,.2) 1e c) Task set 3 Figure 6: Task response times under LCM and competitor synchronization methods.5,.2,.2)

10 2.5e+9 2e+9 1e+1 9e+9 8e+9 7e+9 1.5e+9 1e+9 Res-mensec) 6e+9 5e+9 4e+9 3e+9 5e+8 2e+9 1e a) Task set 1 a) Task set 1 2e+1 1.8e+1 6e+1 1.6e+1 5e+1 1.4e+1 4e+1 1.2e+1 1e+1 8e+9 Res-mensec) 3e+1 6e+9 2e+1 4e+9 1e+1 2e b) Task set 2 b) Task set 2 1.2e+17 1e+17 4e+1 3.5e+1 3e+1 8e e+1 6e+16 Res-mensec) 2e+1 1.5e+1 4e+16 1e+1 2e+16 5e c) Task set 3 c) Task set 3 Figure 7: Task retry costs under LCM and competitor synchronization methods.8,.5,.2) Figure 8: Task response times under LCM and competitor synchronization methods.8,.5,.2)