• Refine Query
  • Source
  • Publication year
  • to
  • Language
  • 114
  • 19
  • 12
  • 9
  • 8
  • 3
  • 3
  • 2
  • 1
  • 1
  • 1
  • 1
  • Tagged with
  • 234
  • 69
  • 47
  • 47
  • 41
  • 39
  • 36
  • 32
  • 31
  • 31
  • 30
  • 29
  • 27
  • 26
  • 25
  • About
  • The Global ETD Search service is a free service for researchers to find electronic theses and dissertations. This service is provided by the Networked Digital Library of Theses and Dissertations.
    Our metadata is collected from universities around the world. If you manage a university/consortium/country archive and want to be added, details can be found on the NDLTD website.

Parallel programming in Go and Scala : A performance comparison

Johnell, Carl January 2015 (has links)
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.

Software Considerations in the Control of Digital Communications Switching Systems

Ward, Ronald P. 10 1900 (has links)
International Telemetering Conference Proceedings / October 26-29, 1992 / Town and Country Hotel and Convention Center, San Diego, California / Today's complex implementations of integrated packet and circuit switched digital communications networks demand that the software used for controlling these systems be robust, fault tolerant, and capable of runtime recovery from all but the most severe of operational errors. The typical modern switched communications system includes the use of multiple circuit switches, each with potentially thousands of end-user interfaces. Further, these switches are often inter-connected to each other via high-capacity trunks. A single connection between two end-user interfaces often traverses a number of intermediate circuit switches in order to effect the end-to-end communications desired. In this complex, distributed environment, the establishment and dissolution of end-to-end user connections involve far more than simple binary connection states indicating the existence, or non-existence, of a link. More commonly, a single end-to-end connection requires multiple node links across multiple, heterogeneous interfaces. The command and control software used to establish, monitor, and dissolve these connections must be capable of dealing with errors which arise at any node along the way in a consistent and reliable manner. Most critically, the system software must be capable of maintaining an accurate, multi-level mapping of distributed resources' availability, allocation, and status. Further, the software must have the capability of "healing itself" during operational run-time when it can, and of accurately reporting the nature of inconsistencies caused by anomalous events that cannot be fixed on the fly. The Edwards Digital Switch (EDS), developed by CSTI, provides a case study of possible solutions, and potential pitfalls, that can arise in the design, development, and implementation of the controlling software in today's dynamic, distributed communications' system architectures.

A no-thin-air memory model for programming languages

Pichon-Pharabod, Jean Yves Alexis January 2018 (has links)
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.


THAKUR, KISHOREKUMAR SINGH 01 January 2008 (has links)
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.

Serializable Isolation for Snapshot Databases

Cahill, Michael James January 2009 (has links)
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.

Concurrent Programming in Education: Time for a Change

Lieb, Christopher 26 April 2011 (has links)
Writing concurrent programs using shared memory causes many programmers much trouble, due primarily to unsafe semantics. Memory corruption, race conditions, deadlocks, and even livelocks are trivially easy to introduce into a program and painful to hunt down due the nearly infinite possible interleavings of instructions between the threads. Undergraduate curricula traditionally introduce students to the idea of shared memory multithreading in a systems programming or operating systems class, but rarely expose them to any alternate models of concurrent programming. This leaves them with the idea that shared memory is the only way to do concurrent programming. After students were exposed to alternate models, they came to prefer them to the standard shared memory model. This happened despite their distaste of the programming language that was utilized in performing the study. The students also expressed interest in alternate models of concurrency being taught in the computer science curricula at WPI.

A General Work for the Flow Analysis of Concurrent Programs

Lam, Patrick 08 1900 (has links)
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.

Concurrency Optimization for Integrative Network Analysis

Barnes, Robert Otto II 12 June 2013 (has links)
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

Constraint-Based Thread-Modular Abstract Interpretation

Kusano, Markus Jan Urban 25 July 2018 (has links)
In this dissertation, I present a set of novel constraint-based thread-modular abstract-interpretation techniques for static analysis of concurrent programs. Specifically, I integrate a lightweight constraint solver into a thread-modular abstract interpreter to reason about inter-thread interference more accurately. Then, I show how to extend the new analyzer from programs running on sequentially consistent memory to programs running on weak memory. Finally, I show how to perform incremental abstract interpretation, with and without the previously mentioned constraint solver, by analyzing only regions of the program impacted by a program modification. I also demonstrate, through experiments, that these new constraint-based static analyzers are significantly more accurate than prior abstract interpretation-based static analyzers, with lower runtime overhead, and that the incremental technique can drastically reduce runtime overhead in the presence of small program modifications. / Ph. D.

Efficient Concurrent Operations in Spatial Databases

Dai, Jing 16 November 2009 (has links)
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.

Page generated in 0.1051 seconds