Results 11  20
of
39
Mutual Exclusion Revisited
"... A family of four mutual exclusion algorithms is presented. Its members vary from a simple threebit linear wait mutual exclusion to the fourbit firstcome firstserved algorithm immune to various faults. The algorithms are based on a scheme similar to the Morris's solution of the mutual exc ..."
Abstract

Cited by 8 (1 self)
 Add to MetaCart
A family of four mutual exclusion algorithms is presented. Its members vary from a simple threebit linear wait mutual exclusion to the fourbit firstcome firstserved algorithm immune to various faults. The algorithms are based on a scheme similar to the Morris's solution of the mutual exclusion with three weak semaphores. The presented algorithms compare favorably with equivalent published mutual exclusion algorithms in their program's size and the number of required communication bits.
Fischer's Protocol in Timed Process Algebra
, 1994
"... Timed algebraic process theories can be developed with quite different purposes in mind. One can aim for theoretical results about the theory itself (completeness, expressiveness, decidability), or one can aim for practical applicability to nontrivial protocols. Unfortunately, these aims do not go ..."
Abstract

Cited by 8 (2 self)
 Add to MetaCart
Timed algebraic process theories can be developed with quite different purposes in mind. One can aim for theoretical results about the theory itself (completeness, expressiveness, decidability), or one can aim for practical applicability to nontrivial protocols. Unfortunately, these aims do not go well together. In this paper we take two theories, which are probably of the first kind, and try to find out how well suited they are for practical verifications. We verify Fischer's protocol for mutual exclusion in the settings of discretetime process algebra (ACP dt ) and realtime process algebra (ACP ur ). We do this by transforming the recursive specification into an equivalent linear specification, and then dividing out the maximal bisimulation relation. The required mutual exclusion result can then be found by reasoning about the obtained process graph. Finally, we consider the ease of the verification, and ways to adapt the theory to make it more practical. It will turn out that the...
Process structuring
 Computing Surveys
, 1973
"... The concept of “process ” has come to play a central role in many efforts to master the complexity of large computer systems. The purpose of this paper is to discuss useful methods of structuring complex processes, and to relate these to the problems of improving the quality of large computer system ..."
Abstract

Cited by 7 (1 self)
 Add to MetaCart
(Show Context)
The concept of “process ” has come to play a central role in many efforts to master the complexity of large computer systems. The purpose of this paper is to discuss useful methods of structuring complex processes, and to relate these to the problems of improving the quality of large computer systems. Two distinct ways of structuring systems are presented, namely, process combination, and process abstraction; these are then used to discuss such topics as concurrency, synchronization, multiprogramming, interpreters, and programmable processors. This discussion is based on a set of precise definitions for such concepts as “process,” “processor, ” “computation, ” “combination, ” and “abstraction. ” The paper relates these definitions to both current research and practical applications, with particular concern for the problems of the performance, reliability, and modifiability of computer systems. Key words and phrases: sequential process, cooperating processes, asynchronous processes, parallelism, complexity, program, processor, interpreter, hierarchical structures, abstraction, refinement.
The Raven Kernel: a Microkernel for Shared Memory Multiprocessors
, 1993
"... This report presents a new operating system kernel which addresses the above factors for a shared memory multiprocessing environment. This design is geared specifically towards uniformly shared memory architectures, and not nonuniform architectures (NUMA) or distributed 1 ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
(Show Context)
This report presents a new operating system kernel which addresses the above factors for a shared memory multiprocessing environment. This design is geared specifically towards uniformly shared memory architectures, and not nonuniform architectures (NUMA) or distributed 1
Formal Verification of Concurrent Programs Based on Type Theory
, 1998
"... Interactive theorem proving provides a general approach to modeling and verification of both finitestate and infinitestate systems but requires significant human efforts to deal with many tedious proofs. On the other hand, modelchecking is limited to some application domain with small finitestate ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
(Show Context)
Interactive theorem proving provides a general approach to modeling and verification of both finitestate and infinitestate systems but requires significant human efforts to deal with many tedious proofs. On the other hand, modelchecking is limited to some application domain with small finitestate space. A natural thought for this problem is to integrate these two approaches. To keep the consistency of the integration and ensure the correctness of verification, we suggest to use type theory based theorem provers (e.g. Lego) as the platform for the integration and build a modelchecker to do parts of the verification automatically. We formalise a verification system of both CCS and an imperative language in the proof development system Lego which can be used to verify both finitestate and infinitestate problems. Then a modelchecker, LegoMC, is implemented to generate Lego proof terms for finitestate problems automatically. Therefore people can use Lego to verify a general problem ...
Author manuscript, published in "Science of Computer Programming (2012)" DOI: 10.1016/j.scico.2012.01.003 Model Checking and Performance Evaluation with CADP Illustrated on SharedMemory Mutual Exclusion Protocols
"... ..."
(Show Context)
A New Solution to Lamport's Concurrent Programming . . .
, 1983
"... A new solution to the concurrent programming control (mutual exclusion) problem that is immune to process failures and restarts is presented. The algorithm uses just four values of shared memory per process, which is within one value of the known lower bound. The algorithm is implemented using two b ..."
Abstract
 Add to MetaCart
A new solution to the concurrent programming control (mutual exclusion) problem that is immune to process failures and restarts is presented. The algorithm uses just four values of shared memory per process, which is within one value of the known lower bound. The algorithm is implemented using two binary variables that make it immune to read errors occurring during writes, that is, "flickering bits."
Abstract Title of Dissertation: Scalable Synchronization in Shared Memory Multiprocessing Systems
"... It is our thesis that scalable synchronization can be achieved with only minimal hardware support, specifically read/write atomicity. This is contrary to the conventional viewpoint that stronger hardware support is required for scalable synchronization; such support not only requires additional cost ..."
Abstract
 Add to MetaCart
(Show Context)
It is our thesis that scalable synchronization can be achieved with only minimal hardware support, specifically read/write atomicity. This is contrary to the conventional viewpoint that stronger hardware support is required for scalable synchronization; such support not only requires additional cost, but also leads to portability problems. As evidence in support of our thesis, we present a new scalable mutual exclusion algorithm based on read and write instructions. The performance of this algorithm is better than prior mutual exclusion algorithms based on read/write atomicity, and even rivals that of the fastest mutual exclusion algorithms that require stronger primitives. Our algorithm is based on the technique of local spinning, i.e., busywaiting on variables that are locallyaccessible to the waiting process. Localspinning minimizes remote accesses of shared memory, which tend to dominate performance under heavy contention.