Concurrent Version Research Articles

Children’s limited tooling ability in a novel concurrent tool use task supports the innovation gap

School-aged children have consistently shown a surprising developmental lag when attempting to innovate solutions to tool use tasks, despite being capable of learning to solve these problems from a demonstrator. We suggest that this “innovation gap” arises from tool tasks with more complex spatial relations. Following Fragaszy and Mangalam’s new tooling theory, we predicted that innovating a new “sticker slide” task should be more challenging when two tools need to be used at the same time (concurrently) rather than one at a time (sequentially), despite the similarity of the other task elements. In line with previous work, both versions of the task were challenging for all ages of children (4–9 years) that we tested. However, the youngest group showed particularly extreme difficulties, which was marked by not a single child innovating the concurrent version. Although success significantly increased with age, even the oldest group failed to reach 50% success on the concurrent version of the task, whereas the majority of the two older groups could solve the sequential version. Thus, in this first study of concurrent tool use in children, we found support for the prediction that increasing the complexity of spatial relations in tooling exacerbates the innovation gap.

Computing with Infinite Objects: the Gray Code Case

Infinite Gray code has been introduced by Tsuiki as a redundancy-free representation of the reals. In applications the signed digit representation is mostly used which has maximal redundancy. Tsuiki presented a functional program converting signed digit code into infinite Gray code. Moreover, he showed that infinite Gray code can effectively be converted into signed digit code, but the program needs to have some non-deterministic features (see also H. Tsuiki, K. Sugihara, "Streams with a bottom in functional languages"). Berger and Tsuiki reproved the result in a system of formal first-order intuitionistic logic extended by inductive and co-inductive definitions, as well as some new logical connectives capturing concurrent behaviour. The programs extracted from the proofs are exactly the ones given by Tsuiki. In order to do so, co-inductive predicates $\bS$ and $\bG$ are defined and the inclusion $\bS \subseteq \bG$ is derived. For the converse inclusion the new logical connectives are used to introduce a concurrent version $\S_{2}$ of $S$ and $\bG \subseteq \bS_{2}$ is shown. What one is looking for, however, is an equivalence proof of the involved concepts. One of the main aims of the present paper is to close the gap. A concurrent version $\bG^{*}$ of $\bG$ and a modification $\bS^{*}$ of $\bS_{2}$ are presented such that $\bS^{*} = \bG^{*}$. A crucial tool in U. Berger, H. Tsuiki, "Intuitionistic fixed point logic" is a formulation of the Archimedean property of the real numbers as an induction principle. We introduce a concurrent version of this principle which allows us to prove that $\bS^{*}$ and $\bG^{*}$ coincide. A further central contribution is the extension of the above results to the hyperspace of non-empty compact subsets of the reals.

Locksynth: Deriving Synchronization Code for Concurrent Data Structures with ASP

AbstractWe present Locksynth, a tool that automatically derives synchronization needed for destructive updates to concurrent data structures that involve a constant number of shared heap memory write operations. Locksynth serves as the implementation of our prior work on deriving abstract synchronization code. Designing concurrent data structures involves inferring correct synchronization code starting with a prior understanding of the sequential data structure’s operations. Further, an understanding of shared memory model and the synchronization primitives is also required. The reasoning involved transforming a sequential data structure into its concurrent version can be performed using Answer Set Programming, and we mechanized our approach in previous work. The reasoning involves deduction and abduction that can be succinctly modeled in ASP. We assume that the abstract sequential code of the data structure’s operations is provided, alongside axioms that describe concurrent behavior. This information is used to automatically derive concurrent code for that data structure, such as dictionary operations for linked lists and binary search trees that involve a constant number of destructive update operations. We also are able to infer the correct set of locks (but not code synthesis) for external height-balanced binary search trees that involve left/right tree rotations. Locksynth performs the analyses required to infer correct sets of locks and as a final step, also derives the C++ synchronization code for the synthesized data structures. We also provide a performance analysis of the C++ code synthesized by Locksynth with the hand-crafted versions available from the Synchrobench microbenchmark suite. To the best of our knowledge, our tool is the first to employ ASP as a backend reasoner to perform concurrent data structure synthesis.

Toward an Analysis Method of Software Evolution Triggered by Place Change in Mobile Computing

Software dynamic evolution is a hot topic in software engineering. Traditional evolution is caused by the change in user requirements and running environments. However, in mobile computing systems, there is a new problem that place change leads to the change in software configuration, deployment, and function, which is called the problem of software evolution triggered by place change. Facing this new problem, traditional evolution methods fail to formally describe their evolution process and analyze their evolution performance. Therefore, a new method needs to be developed to ensure the reliability of software evolution triggered by place change. We first address various situations regarding the change of the software function caused by place change in physical space, which are described by a Bigraph model. Then, the triggering conditions for software evolution are defined, and a reaction system corresponding to software evolution is discussed. A theory about software function change caused by place change is developed, including a novel algorithm for identifying software evolution rules that involve place information and the control process for the whole software evolution (CPSE) in a mobile computing environment. Finally, some real case studies illustrate the effectiveness and correctness of our proposed method. Extensive experiments show that our algorithm CPSE outperforms Quiescence and version consistency (VC)-concurrent versions (CV) algorithms in timeliness and average disruption.

Generating Concurrent Programs From Sequential Data Structure Knowledge Using Answer Set Programming

We tackle the problem of automatically designing concurrent data structure operations given a sequential data structure specification and knowledge about concurrent behavior. Designing concurrent code is a non-trivial task even in simplest of cases. Humans often design concurrent data structure operations by transforming sequential versions into their respective concurrent versions. This requires an understanding of the data structure, its sequential behavior, thread interactions during concurrent execution and shared memory synchronization primitives. We mechanize this design process using automated commonsense reasoning. We assume that the data structure description is provided as axioms alongside the sequential code of its algebraic operations. This information is used to automatically derive concurrent code for that data structure, such as dictionary operations for linked lists and binary search trees. Knowledge in our case is expressed using Answer Set Programming (ASP), and we employ deduction and abduction -- just as humans do -- in the reasoning involved. ASP allows for succinct modeling of first order theories of pointer data structures, run-time thread interactions and shared memory synchronization. Our reasoner can systematically make the same judgments as a human reasoner, while constructing provably safe concurrent code. We present several reasoning challenges involved in transforming the sequential data structure into its equivalent concurrent version. All the reasoning tasks are encoded in ASP and our reasoner can make sound judgments to transform sequential code into concurrent code. To the best of our knowledge, our work is the first one to use commonsense reasoning to automatically transform sequential programs into concurrent code. We also have developed a tool that we describe that relies on state-of-the-art ASP solvers and performs the reasoning tasks involved to generate concurrent code.

RCU‐HTM: A generic synchronization technique for highly efficient concurrent search trees

AbstractConcurrent search trees (STs) are among the most widely used data structures to store and retrieve data in contemporary multithreaded applications. Despite the high amount of prior work, it still remains challenging to implement highly efficient concurrent STs. This is mainly due to the fact that both traditional synchronization methods (i.e., locks and atomic operations) and more novel ones (i.e., read‐copy‐update and transactional memory) fail to provide solutions that are generic and at the same time able to attain high performance under diverse workloads and contention levels. In this work, we present RCU‐HTM, a technique that combines read‐copy‐update (RCU) and hardware transactional memory (HTM), and: (a) supports the implementation of a concurrent version of any type of search tree, and (b) achieves high performance across all execution scenarios. We also incorporate a low‐overhead, epoch‐based memory reclamation scheme to make our RCU‐HTM trees practical for large‐scale long‐running applications. To showcase the capabilities of our technique, we implement and evaluate multiple RCU‐HTM trees and compare their performance with several state‐of‐the‐art competitors. More specifically, we apply RCU‐HTM to 12 different types of binary, B+ and (a,b)‐trees and compare against 18 state‐of‐the‐art implementations that use four different synchronization mechanisms, namely, locks, atomic operations, RCU, and HTM. We evaluate the trees under different levels of contention by varying the size of the tree, the operations mix, and the number of threads, for a total of 210 execution scenarios for each implementation. Our evaluation shows that in the majority of executions, RCU‐HTM trees outperform their state‐of‐the‐art alternatives, and even in the cases where they do not, their performance is very close to that of the best implementation.

Concepts of variation control systems

Version control systems are an integral part of today’s software engineering. They facilitate the collaborative management of revisions (sequential versions) and variants (concurrent versions) of software systems under development. Typical version control systems maintain revisions of files and variants of whole software systems. Variants are supported via branching or forking mechanisms that conceptually clone whole systems in a coarse-grained way. Unfortunately, such cloning leads to high maintenance efforts. To avoid these disadvantages and support fine-grained variation, developers need to employ custom configuration mechanisms, which leads to a misappropriation of tools and undesired context switches. Addressing this trade-off, a number of variation control systems has been conceived, providing a richer set of capabilities for handling variants. Variation control systems decompose a software system into finer-grained variable entities and offer high-level metaphors to automatically manage this variability. In this paper, we classify and compare variation control systems and illustrate their core concepts and characteristics. All investigated variation control systems offer an iterative (checkout–modify–commit) workflow, but there are essential differences affecting developers. We highlight challenges and discuss research perspectives for developing the next generation of version and variation control systems.

Latent semantic analysis of game models using LSTM

We are proposing a method for identifying whether the observed behaviour of a function at an interface is consistent with the typical behaviour of a particular programming language. This is a challenging problem with significant potential applications such as in security (intrusion detection) or compiler optimisation (profiling). To represent behaviour we use game semantics, a powerful method of semantic analysis for programming languages. It gives mathematically accurate models (‘fully abstract’) for a wide variety of programming languages. Game-semantic models are combinatorial characterisations of all possible interactions between a term and its syntactic context. Because such interactions can be concretely represented as sets of sequences, it is possible to ask whether they can be learned from examples. Concretely, we are using LSTM, a technique which proved effective in learning natural languages for automatic translation and text synthesis, to learn game-semantic models of sequential and concurrent versions of Idealised Algol (IA), which are algorithmically complex yet can be concisely described. We will measure how accurate the learned models are as a function of the degree of the term and the number of free variables involved. Finally, we will show how to use the learned model to perform latent semantic analysis between concurrent and sequential Idealised Algol.

Context/Resource-Aware Mission Planning Based on BNs and Concurrent MDPs for Autonomous UAVs.

This paper presents a scalable approach to model uncertainties within a UAV (Unmanned Aerial Vehicle) embedded mission manager. It proposes a concurrent version of BFM models, which are Bayesian Networks built from FMEA (Failure Mode and Effects Analysis) and used by MDPs (Markov Decision Processes). The models can separately handle different applications during the mission; they consider the context of the mission including external constraints (luminosity, climate, etc.), the health of the UAV (Energy, Sensor) as well as the computing resource availability including CPU (Central Processing Unit) load, FPGA (Field Programmable Gate Array) use and timing performances. The proposed solution integrates the constraints into a mission specification by means of FMEA tables in order to facilitate their specifications by non-experts. Decision-making processes are elaborated following a “just enough” quality management by automatically providing adequate implementation of the embedded applications in order to achieve the mission goals, in the context given by the sensors and the on-board monitors. We illustrate the concurrent BFM approach with a case study of a typical tracking UAV mission. This case also considers a FPGA-SoC (FPGA-System on Chip) platform into consideration and demonstrates the benefits to tune the quality of the embedded applications according to the environmental context.

CONSUMER CENTRIC ENDPOINT COMPUTATION FOR MULTIVERSIONED SOA BASED SYSTEMS

The tremendous expansion of internet based applications and programs have created a new dimension in the Service Oriented Architecture based systems. Change Management and the need for enhancing the existing systems have resulted in creation of multiple versions in Web Services. With the availability of concurrent multiple versions, it is necessary to provide a suitable method for computing the endpoint which suits the needs of service consumers based on consumers’ infrastructure and usage. Since there is no standardized method for finding the endpoint and recommending appropriate version to the consumer, a method for determining the endpoint is proposed.

HBS-CRA: scaling impact of change request towards fault proneness: defining a heuristic and biases scale (HBS) of change request artifacts (CRA)

Accurately calculating the impact of existing change requests is vital for estimating the probability of fault occurrence in future change requests. For a new request like bug fixing, effectiveness in current change requests is required. In a real-time scenario, bug trackers are deployed to save change requests and their associated information. The trackers and associated information are saved in CVS version control systems and these systems assist programmers to carry out multiple analytical functions and generating descriptions. In our earlier works, we devised the set of change request artifacts and also proposed novel statistical bipartite weighted graphical models to evaluate DFP degree of future change requests. With the motivation gained from this model, here we propose a novel strategy that estimates the DFP of the request by assessing the impact of a change request artifact towards fault-proneness that considers the correlation between code blocks as another factor, which is in addition to our earlier strategy. A novel heuristic and biases scale to evaluate the effectiveness of change request for DFP is devised here in this paper that titled as “Defining a Heuristic and Biases Scale (HBS) of Change Request Artifacts (CRA)”, in short HBS-CRA. The devised model makes use of information retrieval methods to identify the change request artifacts of the request. In addition, it also checks for DFP scope through HBS-CRA. The HBS-CRA is empirically assessed by applying on concurrent versioning and Change request logs of the production level maintenance project.

On the Learnability of Programming Language Semantics

Game semantics is a powerful method of semantic analysis for programming languages. It gives mathematically accurate models ("fully abstract") for a wide variety of programming languages. Game semantic models are combinatorial characterisations of all possible interactions between a term and its syntactic context. Because such interactions can be concretely represented as sets of sequences, it is possible to ask whether they can be learned from examples. Concretely, we are using long short-term memory neural nets (LSTM), a technique which proved effective in learning natural languages for automatic translation and text synthesis, to learn game-semantic models of sequential and concurrent versions of Idealised Algol (IA), which are algorithmically complex yet can be concisely described. We will measure how accurate the learned models are as a function of the degree of the term and the number of free variables involved. Finally, we will show how to use the learned model to perform latent semantic analysis between concurrent and sequential Idealised Algol.

A classification of variation control systems

Version control systems are an integral part of today's software and systems development processes. They facilitate the management of revisions (sequential versions) and variants (concurrent versions) of a system under development and enable collaboration between developers. Revisions are commonly maintained either per file or for the whole system. Variants are supported via branching or forking mechanisms that conceptually clone the whole system under development. It is known that such cloning practices come with disadvantages. In fact, while short-lived branches for isolated development of new functionality (a.k.a. feature branches) are well supported, dealing with long-term and fine-grained system variants currently requires employing additional mechanisms, such as preprocessors, build systems or custom configuration tools. Interestingly, the literature describes a number of variation control systems, which provide a richer set of capabilities for handling fine-grained system variants compared to the version control systems widely used today. In this paper we present a classification and comparison of selected variation control systems to get an understanding of their capabilities and the advantages they can offer. We discuss problems of variation control systems, which may explain their comparably low popularity. We also propose research activities we regard as important to change this situation.

Selfish cops and passive robber: Qualitative games

Several variants of the cops and robbers (CR) game have been studied in the literature. In this paper we examine a novel variant, which is played between two cops, each one independently trying to catch a “passive robber”. We call this the Selfish Cops and Passive Robber (SCPR) game. In short, SCPR is a stochastic two-player, zero-sum game where the opponents are the two cop players. We study sequential and concurrent versions of the SCPR game. For both cases we prove the existence of value and optimal strategies and present algorithms for the computation of these.

Solving large batches of traveling salesman problems with parallel and distributed computing

In this paper, we describe and compare serial, parallel, and distributed solver implementations for large batches of Traveling Salesman Problems using the Lin–Kernighan Heuristic (LKH) and the Concorde exact TSP Solver. Parallel and distributed solver implementations are useful when many medium to large size TSP instances must be solved simultaneously. These implementations are found to be straightforward and highly efficient compared to serial implementations. Our results indicate that parallel computing using hyper-threading for solving 150- and 200-city TSPs can increase the overall utilization of computer resources up to 25% compared to single thread computing. The resulting speed-up/physical core ratios are as much as ten times better than a parallel and concurrent version of the LKH heuristic using SPC3 in the literature. For variable TSP sizes, a longest processing time first heuristic performs better than an equal distribution rule. We illustrate our approach with an application in the design of order picking warehouses.

Understanding Open Source Software Evolution Using Fuzzy Data Mining Algorithm for Time Series Data

Source code management systems (such as Concurrent Versions System (CVS), Subversion, and git) record changes to code repositories of open source software projects. This study explores a fuzzy data mining algorithm for time series data to generate the association rules for evaluating the existing trend and regularity in the evolution of open source software project. The idea to choose fuzzy data mining algorithm for time series data is due to the stochastic nature of the open source software development process. Commit activity of an open source project indicates the activeness of its development community. An active development community is a strong contributor to the success of an open source project. Therefore commit activity analysis along with the trend and regularity analysis for commit activity of open source software project acts as an important indicator to the project managers and analyst regarding the evolutionary prospects of the project in the future.

Eastern Indonesia and the Writing of History

The present article is a discussion of the proliferation of history-writing about eastern Indonesia (mainly Nusa Tenggara, Maluku and Papua) and Timor-Leste during the last decades. While a substantial corpus of Portuguese historical writings on Timor-Leste appeared up to the 1970s, very little was done in respect to eastern Indonesia, at any rate after decolonization. However, a number of anthropologists have included studies of historical data in their work since the 1970s. The challenges from anthropology have contributed to a new output of historical research since the 1990s. The possibilities of the colonial archive to yield social and cultural data have been tested. Not least, the independence of Timor-Leste in 1999-2002 has been a catalyst for fresh studies. The article presents an overview of the themes and methodologies taken up since the late 20th century in works written in English, Dutch, Portuguese, French, German, and Indonesian. It is emphasized that a historian working in this area must take account of the resources of the colonial archive, as well as to alternative claims to the past – oral tradition, linguistics, heritage objects, and so on. In traditionally non-literate and small-scale societies, analyses of concurrent versions of history will be crucial in the mapping of the past.

Concurrency cannot be observed, asynchronously

The paper is devoted to an analysis of the concurrent features of asynchronous systems. A preliminary step is represented by the introduction of a non-interleaving extension of barbed equivalence. This notion is then exploited in order to prove thatconcurrency cannot be observedthrough asynchronous interactions, i.e., that the interleaving and concurrent versions of a suitable asynchronous weak equivalence actually coincide. The theory is validated on some case studies, related to nominal calculi (π-calculus) and visual specification formalisms (Petri nets). Additionally, we prove that a class of systems which is deemed (output-buffered) asynchronous, according to a characterization that was previously proposed in the literature, falls into our theory.

A network-conscious π-calculus and its coalgebraic semantics

Traditional process calculi usually abstract away from network details, modeling only communication over shared channels. They, however, seem inadequate to describe new network architectures, such as Software Defined Networks, where programs are allowed to manipulate the infrastructure. In this paper we present the Network Conscious π-calculus ( NCPi), a proper extension of the π-calculus with an explicit notion of network: network links and nodes are represented as names, in full analogy with ordinary π-calculus names, and observations are routing paths through which data is transported. However, restricted links do not appear in the observations, which thus can possibly be as abstract as in the π-calculus. Then we construct a presheaf-based coalgebraic semantics for NCPi along the lines of Turi–Plotkin's approach, by indexing processes with the network resources they use: we give a model for observational equivalence in this context, and we prove that it admits an equivalent nominal automaton (HD-automaton), suitable for verification. Finally, we give a concurrent semantics for NCPi where observations are multisets of routing paths. We show that bisimilarity for this semantics is a congruence, and this property holds also for the concurrent version of the π-calculus.

Research on the Security Technologies of Power Grid EMS Based on SOA

This article analyzes the accidents of power grid in some domestic region to discuss the security problems existing in the power grid Energy Management Systems (EMS). Combined with the security requirements of EMS, the method of improving EMS security based on SOA is proposed and the involving key technologies are studied as follows: the loosely coupled EMS based on SOA, the graded and modularity security configuration, the management of security configuration based on Concurrent Version System (CVS) and the mirror of Real-Time Databases (RTD) based on cloud computing. All the above technologies proposed in this paper greatly improve the security of EMS.