The application of Discrete-Event Systems (DES) theory to the problem of guar- anteeably enforcing concurrency constraints in multi-threaded applications has been studied under certain assumptions, namely, the assumption of a static pool of pre- existing instantiated threads, whose creation and termination are not modelled. This work proposes an extension of this case to handle dynamically instantiated and termi- nated threads using a Petri net formalism and an online limited-lookahead state-space search technique. / Thesis (Master, Computing) -- Queen's University, 2010-05-27 17:00:15.99

Ensembles of distributed, autonomous and heterogenous entities that are situated in an environment, interacting over both space and time, and striving to uphold some global system coherence, mission, and goal characterize a new class of systems coined Open Computational Systems (OCS). OCS are materializing as a result of various enabling Internet technologies and examples include: ubiquitous computing, proactive computing, autonomic computing, network-centric computing, and network-centric warfare. OCS require a fundamental shift in the way we think about software development. In order to address these issues we advocate a holistic approach where models and tools come together to provide a platform for the building, understanding and monitoring of software based on the notion of these type of systems. In this research project, this was investigated by adopting the generative communication paradigm, a framework for entity communication and collaboration that will allow us to construct systems with characteristics of an OCS. Model-Driven Engineering (MDE) technologies (Domain Specific Modelling Languages and Transformation Engines) were used to provision a modelling environment for the construction, visualization and transformation of systems based on the notion of OCS. An initial mechanism was then established, and a prototype built for system understanding, verification and validation.

PhD / Many popular database management systems implement a multiversion concurrency control algorithm called snapshot isolation rather than providing full serializability based on locking. There are well-known anomalies permitted by snapshot isolation that can lead to violations of data consistency by interleaving transactions that would maintain consistency if run serially. Until now, the only way to prevent these anomalies was to modify the applications by introducing explicit locking or artificial update conflicts, following careful analysis of conflicts between all pairs of transactions. This thesis describes a modification to the concurrency control algorithm of a database management system that automatically detects and prevents snapshot isolation anomalies at runtime for arbitrary applications, thus providing serializable isolation. The new algorithm preserves the properties that make snapshot isolation attractive, including that readers do not block writers and vice versa. An implementation of the algorithm in a relational database management system is described, along with a benchmark and performance study, showing that the throughput approaches that of snapshot isolation in most cases.

Many hardware and compiler optimisations introduced to speed up single-threaded programs also introduce additional, sometimes surprising, behaviours for concurrent programs with shared mutable state. How many of these extra behaviours occur in practice depends on the combination of the hardware, compiler, runtime, etc. that make up the platform. A memory model, which prescribes what values each read of a concurrent program can read, allows programmers to determine whether a program behaves as expected without having to worry about the details of the platform. However, capturing these behaviours in a memory model without also including undesirable "out-of-thin-air" behaviours that do not occur in practice has proved elusive. The memory model of C and C++ allows out-of-thin-air behaviour, while the Java memory model fails to capture some behaviours that are introduced in practice by compiler optimisations. In this thesis, we propose a memory model that forbids out-of-thin-air behaviour, yet allows the behaviours that do occur. Our memory model follows operational intuitions of how the hardware and compilers operate. We illustrate that it behaves as desired on a series of litmus tests. We show that it captures at least some of the expected behaviours, that it forms an envelope around some common compiler optimisations, and that it is implementable on common hardware using the expected compilation schemes. We also show that it supports some established programming idioms.

In today's database management systems (DBMS), concurrency control is one of the main issues that draw a lot of attention. Concurrency control protocols prevent changes to the database made by one user to interfere with those made by another user. During last couple of decades, many new concurrency control mechanisms were introduced into the study of database management systems. Researchers have designed new concurrency control algorithms and examined their performances in comparison with well known concurrency control mechanisms, which are widely used in today's database management systems. The results reported to date, rather than being definitive, have tended to be quite contradictory [1]. The main cause of such findings is use of different assumptions and implications when defining a simulation model for database management systems. Different coding schemes and logical programmatic flows play another important role in obtaining questionable results. In this paper, rather than proposing yet another concurrency control algorithm, I will implement a standardized simulation model within windows application that can then be used by any researcher to test performance of his concurrency control protocol. I will implement Optimistic Concurrency control protocol to validate functionality of my application and compare it with two phase locking protocol.

M.Sc. (Computer Science) / Concurrency control is the problem that exists in a database management system when more than one transaction or application is executed simultaneously. If transactions or applications are executed sequentially there will- be no problem with the allocation of resources. It is however necessary to execute transactions concurrently to utilise computer and resource capacity to its maximum extent. It can lead to inconsistent data if this concurrent execution of transactions are not properly controlled. If this should happen the data would be of no more use to the users of a system. The thesis is divided in the following way. Chapter 1 gives background information on the concurrency control problem. In chapter 2 a couple of mechanisms for solving the concurrency control problem are studied briefly. Chapters 3 and 4 provides a more in depth study of two specific mechanisms namely two-phase locking and timestamps. 80th of these mechanisms have already been implemented in systems to. solve the concurrency control problem.- In chapter 5 a comparison is made of the two methods described in chapters 3 and 4. A third method for handling concurrency control is briefly described in chapter 6. This method hasn't received a lot of attention from researchers yet. And in the last chapter, chapter 7, the concurrency control method used in the SDD-1 system is studied in more detail. SDD-1 is a distributed database management system.

This thesis provides a performance comparison of parallel programming in Go and Scala. Go supports concurrency through goroutines and channels. Scala have parallel collections, futures and actors that can be used for concurrent and parallel programming. The experiment used two different types of algorithms to compare the performance between Go and Scala. Parallel versions of matrix multiplication and matrix chain multiplication were implemented with goroutines and channels in Go. Matrix multiplication was implemented with parallel collections and futures in Scala, and chain multiplication was implemented with actors.     The results from the study shows that Scala has better performance than Go, parallel matrix multiplication was about 3x faster in Scala. However, goroutines and channels are more efficient than actors. Go performed better than Scala when the number of goroutines and actors increased in the benchmark for parallel chain multiplication.     Both Go and Scala have features that makes parallel programming easier, but I found Go as a language was easier to learn and understand than Scala. I recommend anyone interested in Go to try it out because of its ease of use.

Standard techniques for analysing sequential programs are severely constrained when applied to a concurrent program because they cannot take full advantage of the concurrent structure of the program. In this work, we overcome this limitation using a novel approach which ``lifts'' a sequential dataflow analysis to a concurrent analysis. First, we introduce concurrency primitives which abstract away from the details of how concurrency features are implemented in real programming languages. Using these primitives, we describe how sequential analyses can be made applicable to concurrent programs. Under some circumstances, there is no penalty for concurrency: our method produces results which are as precise as the sequential analysis. Our lifting is straightforward, and we illustrate it on some standard analyses -- available expressions, live variables and generalized constant propagation. Finally, we describe how concurrency features of real languages can be expressed using our abstract concurrency primitives, and present analyses for finding our concurrency primitives in real programs.

Virginia Tech\'s Computational Bioinformatics and Bio-imaging Laboratory (CBIL) is exploring integrative network analysis techniques to identify subnetworks or genetic pathways that contribute to various cancers. Chen et. al. developed a bagging Markov random field (BMRF)-based approach which examines gene expression data with prior biological information to reliably identify significant genes and proteins. Using random resampling with replacement (bootstrapping or bagging) is essential to confident results but is computationally demanding as multiple iterations of the network identification (by simulated annealing) is required. The MATLAB implementation is computationally demanding, employs limited concurrency, and thus time prohibitive. Using strong software development discipline we optimize BMRF using algorithmic, compiler, and concurrency techniques (including Nvidia GPUs) to alleviate the wall clock time needed for analysis of large-scale genomic data. Particularly, we decompose the BMRF algorithm into functional blocks, implement the algorithm in C/C++ and further explore the C/C++ implementation with concurrency optimization. Experiments are conducted with simulation and real data to demonstrate that a significant speedup of BMRF can be achieved by exploiting concurrency opportunities. We believe that the experience gained by this research shall help pave the way for us to develop computationally efficient algorithms leveraging concurrency, enabling researchers to efficiently analyze larger-scale data sets essential for furthering cancer research. / Master of Science

As demanded by applications such as GIS, CAD, ecology analysis, and space research, efficient spatial data access methods have attracted much research. Especially, moving object management and continuous spatial queries are becoming highlighted in the spatial database area. However, most of the existing spatial query processing approaches were designed for single-user environments, which may not ensure correctness and data consistency in multiple-user environments. This research focuses on designing efficient concurrent operations on spatial datasets. Current multidimensional data access methods can be categorized into two types: 1) pure multidimensional indexing structures such as the R-tree family and grid file; 2) linear spatial access methods, represented by the Space-Filling Curve (SFC) combined with B-trees. Concurrency control protocols have been designed for some pure multidimensional indexing structures, but none of them is suitable for variants of R-trees with object clipping, which are efficient in searching. On the other hand, there is no concurrency control protocol designed for linear spatial indexing structures, where the one-dimensional concurrency control protocols cannot be directly applied. Furthermore, the recently designed query processing approaches for moving objects have not been protected by any efficient concurrency control protocols. In this research, solutions for efficient concurrent access frameworks on both types of spatial indexing structures are provided, as well as for continuous query processing on moving objects, for multiple-user environments. These concurrent access frameworks can satisfy the concurrency control requirements, while providing outstanding performance for concurrent queries. Major contributions of this research include: (1) a new efficient spatial indexing approach with object clipping technique, ZR+-tree, that outperforms R-tree and R+-tree on searching; (2) a concurrency control protocol, GLIP, to provide high throughput and phantom update protection on spatial indexing with object clipping; (3) efficient concurrent operations for indices based on linear spatial access methods, which form up the CLAM protocol; (4) efficient concurrent continuous query processing on moving objects for both R-tree-based and linear spatial indexing frameworks; (5) a generic access framework, Disposable Index, for optimal location update and parallel search. / Ph. D.