Skip to main content
Article thumbnail
Location of Repository

Representation and Implementation of CSP and VCR Traces

By Neil C.C. Brown and Marc L. Smith


Communicating Sequential Processes (CSP) was developed around a formal algebra of processes and a semantics based on traces (and failures and divergences). A trace is a record of the events engaged in by a process. Several programming languages use, or have libraries to use, CSP mechanisms to manage their concurrency. Most of these lack the facility to record the trace of a program. A standard trace is a flat list of events but structured trace models are possible that can provide more information such as the independent or concurrent engagement of the process in some of its events. One such trace model is View-Centric Reasoning (VCR), which offers an additional model of tracing, taking into account the multiple, possibly imperfect views of a concurrent computation. This paper also introduces ''structural'' traces, a new type of trace that reflects the nested parallelism in a CSP system. The paper describes the automated generation of these three trace types in the Communicating Haskell Processes (CHP) library, using techniques which could easily be applied in other libraries such as JCSP and C++CSP2. The ability to present such traces of a concurrent program assists in understanding the behaviour of real CHP programs and for debugging when the trace behaviours are wrong. These ideas and tools promote a deeper understanding of the association between practicalities of real systems software and the underlying CSP formalism

Topics: QA76
Publisher: IOS Press
Year: 2008
OAI identifier:

Suggested articles


  1. (2002). A debugger for concurrent haskell.
  2. (1996). A Design Strategy for Deadlock-Free Concurrent Systems.
  3. (1989). An introduction to event structures. In doi
  4. (2006). Communicating complex systems. doi
  5. (2008). Communicating Haskell Processes: Composable explicit concurrency using monads.
  6. (2005). Communicating mobile processes: introducing occam-pi.
  7. (1985). Communicating Sequential Processes. doi
  8. (2006). Compiling CSP.
  9. (2005). Composable memory transactions. doi
  10. (2006). Compositions of concurrent processes.
  11. (1994). Design Rules for Deadlock Freedom.
  12. (1989). Emulating Digital Logic using Transputer Networks (Very High Parallelism = Simplicity = Performance). doi
  13. (2004). Focusing on traces to link VCR
  14. (1997). Formal Systems (Europe) Ltd. Failures-Divergence Refinement: FDR2 Manual.
  15. (1999). Hierarchical vector clock: Scalable plausible clock for detecting causality in large distributed systems. doi
  16. (1993). Higher-Level Paradigms for Deadlock-Free HighPerformance Systems. In
  17. (1962). Kommunikation mit automaten. doi
  18. (1986). Modeling concurrency with partial orders. doi
  19. (1985). Petri Nets—An Introduction, doi
  20. (2004). Searching for deadlocks while debugging concurrent haskell programs. doi
  21. (2005). SimonMarlow, Simon Peyton-Jones, andMaurice Herlihy. Composable memory transactions. doi
  22. (1996). Strategic directions in concurrency research. doi
  23. (1987). The pursuit of deadlock freedom. doi
  24. (1974). The semantics of a simple language for parallel programming.
  25. (1997). The Theory and Practice of Concurrency. doi
  26. (1978). Time, clocks, and the ordering of events in a distributed system. doi
  27. (1988). Timestamps in message-passing systems that preserve the partial ordering.
  28. (1987). Trace theory. doi
  29. (2003). View-Centric Reasoning for Linda and Tuple Space computation. doi

To submit an update or takedown request for this paper, please submit an Update/Correction/Removal Request.