Cheetah: Boosting Scientific Computing with Heterogeneous Processors

Commodity hardware nowadays includes not only many-core CPUs but also Graphics Processing Units (GPUs), whose data-parallel computational capabilities have been growing at an exponential rate. This computational power can be used for purposes other than graphics-oriented applications, such as processor-intensive algorithms like those found in the scientific computing setting. Cheetah is a framework that distributes computationally intensive programs over a networked set of CPUs and GPUs, allowing to use these resources in a Single System Image-like approach. A software developer using Cheetah only needs to specify a set of processor-independent OpenCL kernels to enable her program to use all of the available processing units. This program may then scale up as more powerful and diverse computing resources become available with no need for further customization or recompilation. Our experimentation has shown that the system, even in the presence of limited computing resources, can in some cases enable speedups of up to two orders of magnitude with reduced application development efforts.

CTL — Consistent Software Transactonal Layer

2009/11/01 — CTL is a Software Transactional Memory Framework based in TL2 by Dave Dice, Ori Shalev and Nir Shavit. It includes a number of new features and optiizations over TL2. These new features and optimizations are btter described in Goçalo Cunha's MSc thesis (see below). CTL also includes a GNU Autoconf script to ease the installatioin process.

Fiddle - Flexible Interface for Distributed Debugging (Library and Engine)

Fiddle is a distributed debugging engine, independent from the user interface, and supports on-line interactive correctness debugging of distributed programs executing in heterogeneous systems. It include support for high-level user-definable abstractions, multiple user-interfaces concurrently steering the same distributed program, which are synchronized to always have a consistent view of the program being debugged.

JTraceView — A Visualizer for Transactional Memory Computations

2010/11/07 — JTraceView is a tool that logs the starting and ending of memory transactions and all the memory accesses within those memory transactions. This log is then used to visualize the program behavior, graphically displaying both statistical information and a time-space diagram. Developed under the supervision of Prof. João Lourenço, with contributions from Ricardo Dias, Vasco Pessanha, Ricardo Pinto, and Diogo Sousa.

If you use this software please cite the following paper:

LaTeX thesis template “NOVAthesis”


The NOVAthesis LaTeX class is a template for academic monographs, initially designed for PhD and MSc thesis/dissertations at NOVA School of Science and Technology (FCT-NOVA), Portugal. The class provides utilities to easily set up the cover page, the front matter pages, the page headers, etc. complying to the official guidelines of the FCT-NOVA.

MoTH: Practical Verification of High-Level Dataraces in Transactional Memory Programs

Transactional Memory (TM) is an approach to concurrency control in general purpose programming languages that inherits the concept of transaction from the database setting. Unlike other language constructs such as locks, TM has an optimistic approach to concurrency control by allowing more than one thread to access simultaneously the same critical section. A transaction always executes as if it is alone in the system, and in the end its effects are undone (rolled back) if it conflicts with another concurrent transactions. In spite of the potential for increasing scalability and performance, TM is a recent and developing programming model and still has a very limited impact in real-world applications.

Designing and developing concurrent software is difficult and error prone. Concurrent programs exhibit concurrency anomalies that originate faults and failures. Despite some claims that TM programs are less error prone, they still exhibit concurrency anomalies such as high-level dataraces, i.e., wrong delimitations of transactions' scope, and stale-value errors, that occur when the value of a shared variable jumps from an atomic block to another.

Programs with this kind of anomalies can exhibit unpredictable and wrong behaviour, not fulfilling the goals for which they were conceived.

This work aims the detection of anomalies through static analysis of transactional Java ByteCode programs that execute in strong atomicity. A extensible and flexible framework is proposed, which can be extended with plugins that detect specific types of anomalies.

With this framework we expect to prove that high-level dataraces and stale-value errors can be detected with reasonable precision through static analysis.