A mutual exclusion mechanism that is both fair and space efficient can be highly valuable for shared memory systems under time and memory constraints such as embedded real-time systems. Several algorithms that utilize only one shared variable and guarantee a certain level of fairness have been proposed. However, these use hypothetical read-modify-write operations that have never been implemented in any system. This paper presents two fair algorithms that do not use such operations, each of which uses a single additional shared variable. The proposed algorithms employ commonly available operations, fetch&store and read/write, on two shared variables. The first algorithm satisfies the bounded-bypass condition. The second is an improvement on the first that satisfies the FIFO condition, which is the most stringent fairness condition. Additionally, it is shown that achieving the bounded-bypass condition using the same set of operations requires two shared variables. Both of the algorithms are thus optimal with respect to the number of shared variables.

Many nonblocking algorithms have been proposed for shared queues. Previous studies indicate that link-based algorithms perform best. However, these algorithms have a memory management problem: a dequeued node cannot be freed or reused without proper handling. The problem is usually overlooked; one just assumes the existence of a lower level mechanism, which takes care of all the details of a lower level mechanism, which takes care of all the details of handling the problem. Employing such a mechanism incurs significant overheads, and consequently the link-based queues may not perform as well as claimed. A new non-blocking queue algorithm based on a finite array is proposed. Compared with the link-based algorithms, the new algorithm provides the same degree of concurrency without being subject to the memory problem, hence suggests a good performance.

Two fast mutual exclusion algorithms using read-modify-write and atomic read/write registers are presented. The first one uses both compare&swap and fetch&store; the second uses only fetch&store. Fetch&store are more commonly available than compare&swap. It is impossible to obtain better algorithms if "time" is measured by counting remote memory references. We were able to maintain the same level of performance with or without the support of compare&swap. However, fairness is degraded from 1-bounded bypass to lockout freedom without the support.

A mobile computing environment allows hosts to roam while retaining access to the Internet. Multicasting is one of the most important facilities for constructing reliable distributed systems and cooperative applications. Host mobility, however, challenges multicasting in this environment: the established multicast delivery paths may frequently restructure along with host migrations, incurring expensive overheads. This paper presents a framework for network-layer multicasting while keeping a low overhead in adapting multicast routes to mobile host locations. This is achieved by partitioning the mobile environment into non-overlapping regions, so that changes in the multicast routes due to host intra-region movements are hidden from other regions. An analytical model was developed for performance evaluation. It shows that, compared with the best known proposal, our scheme reduces the average multicast latency by more than 66%, while causing less than 7% overhead.

Three fast mutual exclusion algorithms using read-modify-write and atomic read/write registers are presented in a sequence, with an improvement from one to the next. The last algorithm is shown to be optimal in minimizing the number of remote memory accesses required in a resource busy period. Remote memory access is the key factor of memory access bottleneck in large shared-memory multiprocessors. The algorithm is particularly suitable in such systems for applications with small critical sections and frequent resource requests.

The circular list-based mutual exclusion algorithm proposed by Fu and Tzeng (1997) is subject to a race condition that leads to a deadlock under subtle situations. An execution sequence evidences the race, and a modified version is provided. The performance of the original algorithm remains unchanged.

Concurrent programs are more difficult to test than sequential programs because of non-deterministic behavior. An execution of a concurrent program non-deterministically exercises a sequence of synchronization events called a synchronization sequence (or SYN-sequence). Non-deterministic testing of a concurrent program P is to execute P with a given input many times in order to exercise distinct SYN-sequences. In this paper, we present a new testing approach called reachability testing. If every execution of P with input X terminates, reachability testing of P with input X derives and executes all possible SYN-sequences of P with input X. We show how to perform reachability testing of concurrent programs using read and write operations. Also, we present results of empirical studies comparing reachability and non-deterministic testing. Our results indicate that reachability testing has advantages over non-deterministic testing.

Concurrent programs are more difficult to test than sequential programs because of nondeterministic behavior. An execution of a concurrent program nondeterministically exercises a sequence of synchronization events, called a synchronization sequence (or SYN-sequence). Nondeterministic testing of a concurrent program P is to execute P with a given input many times in order to exercise distinct SYN-sequences and produce different results. We present a new testing approach, called reachability testing. If P with input X contains a finite number of SYN-sequences, reachability testing of P with input X can execute all possible SYN-sequences of P with input X. We show how to perform reachability testing of concurrent programs using read and write operations. Also, we present results of empirical studies comparing reachability and nondeterministic testing. Our results indicate that reachability testing has advantages over nondeterministic testing.>

A new lock synchronization algorithm, proposed independently by Craig and the authors, not only eliminates memory contention caused by process spinning but also preserves first in first out property. A previous result, the MCS lock algorithm, requires both compare and swap and fetch and store instructions, or the FIFO property is lost and hence starvation may occur. The new one requires only fetch and store. We provide an assertional proof for the new algorithm. Most of behavioral proofs of concurrent programs are error-prone since it is difficult and tedious to take all possibilities of interleaving among the processes into consideration. An assertional proof replaces a large number of possibilities of interleaving by a small number of invariants. New techniques in this proof are: an assertional characterization of token bit accessibility; the definition of effective assignments that brings about the notion of token creation/destruction; the definition of token count that derives the mutual exclusion theorem; and the constructing procedure of a token-list that faithfully records the arrival time sequence of lock requests so that FIFO ordering can be enforced.

The processor allocation problem in a hypercube system is to find a free subcube for a given request. The subcube recognition capability of existing allocation strategies, e.g. the buddy strategy and the Gray code strategy, is far below the theoretical upper bound due to their incomplete representation of the hypercube interconnection structure. A complete strategy that outperforms the existing ones in subcube recognition capability and average waiting time but incurs a higher overhead is proposed. Efficient implementation of the complete strategy is also studied.>