The concurrency of edges, quantified by the number of edges that share a common node at a given time point, may be an important determinant of epidemic processes in temporal networks. We propose theoretically tractable Markovian temporal network models in which each edge flips between the active and inactive states in continuous time. The different models have different amounts of concurrency while we can tune the models to share the same statistics of edge activation and deactivation (and hence the fraction of time for which each edge is active) and the structure of the aggregate (i.e., static) network. We analytically calculate the amount of concurrency of edges sharing a node for each model. We then numerically study effects of concurrency on epidemic spreading in the stochastic susceptible-infectious-susceptible and susceptible-infectious-recovered dynamics on the proposed temporal network models. We find that the concurrency enhances epidemic spreading near the epidemic threshold, while this effect is small in many cases. Furthermore, when the infection rate is substantially larger than the epidemic threshold, the concurrency suppresses epidemic spreading in a majority of cases. In sum, our numerical simulations suggest that the impact of concurrency on enhancing epidemic spreading within our model is consistently present near the epidemic threshold but modest. The proposed temporal network models are expected to be useful for investigating effects of concurrency on various collective dynamics on networks including both infectious and other dynamics.

Time is a crucial factor in modelling dynamic behaviours of intelligent agents: activities have a determined temporal duration in a real-world environment, and previous actions influence agents’ behaviour. In this paper, we propose a language for modelling concurrent interaction between agents that also allows the specification of temporal intervals in which particular actions occur. Such a language exploits a timed version of Abstract Argumentation Frameworks to realise a shared memory used by the agents to communicate and reason on the acceptability of their beliefs with respect to a given time interval. An interleaving model on a single processor is used for basic computation steps, with maximum parallelism for time elapsing. Following this approach, only one of the enabled agents is executed at each moment. To demonstrate the capabilities of the language, we also show how it can be used to model interactions such as debates and dialogue games taking place between intelligent agents. Lastly, we present an implementation of the language that can be accessed via a web interface.

One of the main advantages of Prolog is its potential for the implicit exploitation of parallelism and, as a high-level language, Prolog is also often used as a means to explicitly control concurrent tasks. Tabling is a powerful implementation technique that overcomes some limitations of traditional Prolog systems in dealing with recursion and redundant sub-computations. Given these advantages, the question that arises is if tabling has also the potential for the exploitation of concurrency/parallelism. On one hand, tabling still exploits a search space as traditional Prolog but, on the other hand, the concurrent model of tabling is necessarily far more complex, since it also introduces concurrency on the access to the tables. In this paper, we summarize Yap's main contributions to concurrent tabled evaluation and we describe the design and implementation challenges of several alternative table space designs for implicit and explicit concurrent tabled evaluation that represent different trade-offs between concurrency and memory usage. We also motivate for the advantages of using fixed-size and lock-free data structures, elaborate on the key role that the engine's memory allocator plays on such environments, and discuss how Yap's mode-directed tabling support can be extended to concurrent evaluation. Finally, we present our future perspectives toward an efficient and novel concurrent framework which integrates both implicit and explicit concurrent tabled evaluation in a single Prolog engine.

Constraint Handling Rules (CHR) is both an effective concurrent declarative programming language and a versatile computational logic formalism. In CHR, guarded reactive rules rewrite a multi-set of constraints. Concurrency is inherent, since rules can be applied to the constraints in parallel. In this comprehensive survey, we give an overview of the concurrent, parallel as well as distributed CHR semantics, standard and more exotic, that have been proposed over the years at various levels of refinement. These semantics range from the abstract to the concrete. They are related by formal soundness results. Their correctness is proven as a correspondence between parallel and sequential computations. On the more practical side, we present common concise example CHR programs that have been widely used in experiments and benchmarks. We review parallel and distributed CHR implementations in software as well as hardware. The experimental results obtained show a parallel speed-up for unmodified sequential CHR programs. The software implementations are available online for free download and we give the web links. Due to its high level of abstraction, the CHR formalism can also be used to implement and analyse models for concurrency. To this end, the Software Transaction Model, the Actor Model, Colored Petri Nets and the Join-Calculus have been faithfully encoded in CHR. Finally, we identify and discuss commonalities of the approaches surveyed and indicate what problems are left open for future research.

We introduce a systematic, concurrent execution scheme for Constraint Handling Rules (CHR) based on a previously proposed sequential goal-based CHR semantics. We establish strong correspondence results to the abstract CHR semantics, thus guaranteeing that any answer in the concurrent, goal-based CHR semantics is reproducible in the abstract CHR semantics. Our work provides the foundation to obtain efficient, parallel CHR execution schemes.

The C++// language (pronounced C++parallel) was designed and implemented with the aim of importingreusability into parallel and concurrentprogramming, in the framework of a mimd model.From a reduced set of rather simple primitives,comprehensive and versatile libraries are defined.In the absence of any syntactical extension,the C++// user writes standard C++ code.The libraries are themselvesextensible by the final users, making C++// an open system. Two specific techniques to improve performances ofa distributed object language such as C++// arethen presented: Shared-on-Read and Overlapping of Communicationand Computation.The appliance of those techniques is guided by the programmer ata very high-level of abstraction, so the additional work to yieldthose good performance improvements is kept to the minimum.