Synchronous Kleene algebra

AbstractThe work presented here investigates the combination of Kleene algebra with the synchrony model of concurrency from Milner’s SCCS calculus. The resulting algebraic structure is called synchronous Kleene algebra. Models are given in terms of sets of synchronous strings and finite automata accepting synchronous strings. The extension of synchronous Kleene algebra with Boolean tests is presented together with models on sets of guarded synchronous strings and the associated automata on guarded synchronous strings. Completeness w.r.t. the standard interpretations is given for each of the two new formalisms. Decidability follows from completeness. Kleene algebra with synchrony should be included in the class of true concurrency models. In this direction, a comparison with Mazurkiewicz traces is made which yields their incomparability with synchronous Kleene algebras (one cannot simulate the other). On the other hand, we isolate a class of pomsets which captures exactly synchronous Kleene algebras. We present an application to Hoare-like reasoning about parallel programs in the style of synchrony

Packet Transactions: High-level Programming for Line-Rate Switches

Many algorithms for congestion control, scheduling, network measurement, active queue management, security, and load balancing require custom processing of packets as they traverse the data plane of a network switch. To run at line rate, these data-plane algorithms must be in hardware. With today's switch hardware, algorithms cannot be changed, nor new algorithms installed, after a switch has been built. This paper shows how to program data-plane algorithms in a high-level language and compile those programs into low-level microcode that can run on emerging programmable line-rate switching chipsets. The key challenge is that these algorithms create and modify algorithmic state. The key idea to achieve line-rate programmability for stateful algorithms is the notion of a packet transaction : a sequential code block that is atomic and isolated from other such code blocks. We have developed this idea in Domino, a C-like imperative language to express data-plane algorithms. We show with many examples that Domino provides a convenient and natural way to express sophisticated data-plane algorithms, and show that these algorithms can be run at line rate with modest estimated die-area overhead.Comment: 16 page

Completeness and Incompleteness of Synchronous Kleene Algebra

Synchronous Kleene algebra (SKA), an extension of Kleene algebra (KA), was proposed by Prisacariu as a tool for reasoning about programs that may execute synchronously, i.e., in lock-step. We provide a countermodel witnessing that the axioms of SKA are incomplete w.r.t. its language semantics, by exploiting a lack of interaction between the synchronous product operator and the Kleene star. We then propose an alternative set of axioms for SKA, based on Salomaa's axiomatisation of regular languages, and show that these provide a sound and complete characterisation w.r.t. the original language semantics.Comment: Accepted at MPC 201

Is your Model Checker on Time? On the Complexity of Model Checking for Timed Modal Logics

This paper studies the structural complexity of model checkingfor (variations on) the specification formalisms used in the tools CMCand Uppaal, and fragments of a timed alternation-free mu-calculus. Foreach of the logics we study, we characterize the computational complexityof model checking, as well as its specification and program complexity,using timed automata as our system model

Enhancing the Compilation of Synchronous Dataflow Programs with a Combined Numerical-Boolean Abstraction

RR version = http://hal.inria.fr/hal-00780521/enInternational audienceIn this paper, we propose an enhancement of the compilation of synchronous programs with a combined numerical-Boolean abstraction. While our approach applies to synchronous dataflow languages in general, here, we consider the SIGNAL language for illustration. In the new abstraction, every signal in a program is associated with a pair of the form ( clock, value ), where clock is a Boolean function and value is a Boolean or numeric function. Given the performance level reached by recent progress in Satisfiability Modulo Theory (SMT), we use an SMT solver to reason on this abstraction. Through sample examples, we show how our solution is used to determine absence of reaction captured by empty clocks; mutual exclusion captured by two or more clocks whose associated signals never occur at the same time; or hierarchical control of component activations via clock inclusion. We also show that the analysis improves the quality of the code generated automatically by a compiler, e.g., a code with smaller footprint, or a code executed more efficiently thanks to optimizations enabled by the new abstraction. The implementation of the whole approach includes a translator of synchronous programs towards the standard input format of SMT solvers, and an ad hoc SMT solver that integrates advanced functionalities to cope with the issues of interest in this wor

An empirical study of negation in datalog programs

Datalog is the fusion of prolong and database technologies aimed at producing an difficultly logic-based, declarative language for databases. Since negation was added to Datalog, Datalog has become more expressive. In this thesis, I focus my attention on adding negation to DatalogIC which is a language which has been implemented by Mark P. Wassell, a past MSc student in the Department of Computer Science at UCT. I analyse and compare stratified, well-founded and inflationary semantics for negation, each of which has been implemented on top of INFORMIX; we call the resulting system NDatalog. According to the test results, we find that some results are unexpected. For example, when we evaluate a recursive stratified program, the results show that NDatalogstra is slower than NDatalogwellf although NDatalogwellf is more complex. After further investigation, I find the problem is that the NDatalog system has to spend a lot of time imitating the MINUS function, which does not exist in INFORMIX-SQL. So the running time depends on what kind of database system is used as backend. When we consider the time spent on pure evaluation, excluding auxiliary functions, we find that the results support our expectations, namely, that NDatalogstra is faster than NDatalogwellf which is faster than NDataloginf