Self-adjusting multi-granularity locking protocol for object-oriented databases

Object-oriented databases have the potential to be used for data-intensive, multi-user applications that are not well served by traditional applications. Despite the fact that there has been extensive research done for relational databases in the area of concurrency control; many of the approaches are not suitable for the complex data model of object-oriented databases. This thesis presents a self-adjusting multi-granularity locking protocol (SAML) which facilitates choosing an appropriate locking granule according to the requirements of the transactions and encompasses less overhead and provides better concurrency compared to some of the existing protocols. Though there has been another adaptive multi-granularity protocol called AMGL [1] which provides the same degree of concurrency as SAML: SAML has been proven to have significantly reduced the number of locks and hence the locking overhead compared to AMGL. Experimental results show that SAML performs the best when the workload is high in the system and transactions are long-lived

Zifazah: A Scientific Visualization Language for Tensor Field Visualizations

This thesis presents the design and prototype implementation of a scientific visualization language called Zifazah for composing and exploring 3D visualizations of diffusion tensor magnetic resonance imaging (DT-MRI or DTI) data. Unlike existing tools allowing flexible customization of data visualizations that are programmer-oriented, Zifazah focuses on domain scientists as end users in order to enable them to freely compose visualizations of their scientific data set. Verbal descriptions of end users about how they would build and explore DTI visualizations are analyzed to collect syntax, semantics, and control structures of the language. Zifazah makes use of the initial set of lexical terms and semantical patterns to provide a declarative language in the spirit of intuitive syntax and usage. Along with sample scripts representative of the main language design features, some new DTI visualizations created by end users using the novel language have also been presented

Submicron Systems Architecture: Semiannual Technical Report

No abstract available

A multiprocessor implementation of Little Smalltalk

In this project we have attempted to exploit the parallel programming features of a Sequent Balance multiprocessor to improve the performance of a Smalltalk interpreter. The block construct and the fork message together make Smalltalk a 'natural' parallel programming language. We describe how processes can be created from within the Smalltalk system to execute concurrently on different processors while sharing a common object memory. We have described a suite of programs that were run to test the implementation and we report the results of the benchmark tests

Programming with Purity Reflection: Peaceful Coexistence of Effects, Laziness, and Parallelism

We present purity reflection, a programming language feature that enables higher-order functions to inspect the purity of their function arguments and to vary their behavior based on this information. The upshot is that operations on data structures can selectively use lazy and/or parallel evaluation while ensuring that side effects are never lost or re-ordered. The technique builds on a recent Hindley-Milner style type and effect system based on Boolean unification which supports both effect polymorphism and complete type inference. We illustrate that avoiding the so-called \u27poisoning problem\u27 is crucial to support purity reflection. We propose several new data structures that use purity reflection to switch between eager and lazy, sequential and parallel evaluation. We propose a DelayList, which is maximally lazy but switches to eager evaluation for impure operations. We also propose a DelayMap which is maximally lazy in its values, but also exploits eager and parallel evaluation. We implement purity reflection as an extension of the Flix programming language. We present a new effect-aware form of monomorphization that eliminates purity reflection at compile-time. And finally, we evaluate the cost of this new monomorphization on compilation time and on code size, and determine that it is minimal