Abstract. Given a set of processes and a set of tests on these processes we show how to define in a natural way three different eyuitalences on processes. ThesP equivalences are applied to a particular language CCS. We give associated complete proof systems and fully abstract models. These models have a simple representation in terms of trees.

Abstmct- Threads (“lightweight ” processes) have become a common element of new languages and operating systems. This paper examines the performance implications of several data structure and algorithm alternatives for thread management in shared-memory multiprocessors. Both experimental measure-ments and analytical model projections are presented. For applications with fine-grained parallelism, small differ-ences in thread management are shown to have significant per-formance impact, often posing a tradeoff between throughput and latency. Per-processor data structures can be used to im-prove throughput, and in some circumstances to avoid locking, improving latency as well. The method used by processors to queue for locks is also shown to affect performance significantly. Normal methods of critical resource waiting can substantially degrade performance with moderate numbers of waiting processors. We present an Ethernet-style backoff algorithm that largely eliminates this ef-fect. Index Terms- Locking, multiprocessor, parallel computing, parallel software, performance, thread.

In most operating systems, the handling of interrupts is typically performed within the address space of the kernel. Moreover, interrupt handlers are invoked asynchronously during the execution of arbitrary processes. Unfortunately, this allows for a process’s time quantum to be consumed by arbitrary interrupt handling. To avoid significant impact to process execution and also to respond quickly enough to interrupts, interrupt servicing is usually split into two parts: a “top ” and “bottom ” half. The top half executes at interrupt time and is meant to be short enough to complete all necessary actions at the time of the interrupt. In contrast, the bottom half can be deferred to a more suitable point in time to complete servicing of a prior interrupt. Systems such as Linux may defer bottom half handling to a schedulable thread that may be arbitrarily delayed until there are no other processes to execute. A better approach would be to schedule bottom halves in accordance with the priorities of processes that are affected by their execution. Likewise, bottom half processing should be charged to the CPU-time usage of the affected process, or processes, where possible, to ensure fairer and more predictable resource management. This paper describes some of our approaches, both algorithmically and in terms of implementation on a Linux system, to combine interrupt scheduling and accountability. We show significant improvements in predictability of a Linux system by modifying the kernel to more accurately account for interrupt servicing costs and more precisely control when and to what extent interrupts can be serviced. ∗ This material is based upon work supported by the National Science Foundation under Grant No. 0615153. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the National Science

Abstract not found

It is all too easy to write unsafe multithreaded Java code, in part because the language’s notify() and wait() methods can be difficult to use correctly. In 1974, Tony Hoare proposed the concept of monitors for designing and reasoning about objects that are shared between multiple threads. The key property of these “Hoare-style ” monitors is that threads can wait until some specific assertion about the monitor’s state is true and will be guaranteed that the assertion is still true after the thread has been awakened. In this article, I describe a Java class library that supports the monitor concept much as Hoare originally proposed it. As I will demonstrate, object-oriented technology makes it possible to improve on Hoare’s concept by making assertions – which are traditionally stated as comments and then repeated in if statements and assert statements – executable objects. This approach reduces redundant coding and automates assertions checking during execution. I’ll start by explaining why multithreaded programming is as unavoidable as it is challenging, then introduce you to the use of exclusive access, conditions, and assertions in Hoare-style monitors. See the Resources section to download the Java-based monitors

Abstract—This paper proposes a View-Oriented Transactional Memory (VOTM) model to seamlessly integrate different concurrency control methods including locking mechanism and transactional memory. The model allows programmers to partition the shared memory into “views ” which are nonoverlapping sets of shared data objects. A Restricted Admission Control (RAC) scheme is proposed to control the number of processes accessing each view in order to reduce the number of aborts of transactions. The RAC scheme has the merits of both the locking mechanism and the transactional memory. Experimental results demonstrate that VOTM outperforms traditional transactional memory models such as TinySTM by up to five times. Also VOTM outperforms pure lockbased models in applications with long critical sections and has comparable performance with lock-based models in other cases. Keywords-View-Oriented Transactional Memory (VOTM), transactional memory, deadlock, concurrency control, Restricted

In the beginning, there was hardware. Now the hardware was formless and empty, darkness was over the surface of silicon. And then the creator said “let there be operating systems, ” and there were OSes. The creator saw that OSes were good. And the creator said “let there be processes, and threads. ” OSes were teeming with processes and threads carrying out different tasks. Then the creator said “let the processes and threads synchronize with each other. ” For this task, the creator appointed human-kind. But humans were fallible, and weak, and they failed to get synchronization correct, and fallen angel BSOD (pronounced beesod), spawn of Beelzebub, ruled the day with great evil. So the creator sent the following commandments. Commandment 0. Thou shalt live and die by coding conventions for synchronization. Remember the parable of Jebediah the Electrician, who wired up his house using only pink wires. He said onto the townsfolks “I saved a bundle by not buying properly