André Rauber Du Bois

Kanga: A Skeleton-Based Generic Interface for Parallel Programming

Concurrent programming tools strive to exploit hardware resources as much as possible. Nonetheless, the lack of high level abstraction of such tools often require from the user a reasonable amount of knowledge in order to achieve satisfactory performance requirements as well as they do not prevent error prone situations. In this paper we present Kanga, a framework based on the abstractions of skeletons to provide a generic tool that encapsulate many common parallel patterns. Through two case studies we validate the framework implementation.

Profiling Patterns of Bit Flipping for Software Transactional Memories

Software Transactional Memory (STM) is a synchronization method proposed as an alternative to lockbased synchronization. It provides a higher-level abstraction that is easier to program, and that enables software composition. Transactions are defined by programmers, but the runtime system is responsible for detecting conflicts and avoiding race conditions. Phase Change Memory (PCM) is a new technology that is being developed to replace Dynamic Random Access Memories (DRAMs) in large datacenters. PCM write operations are much more expensive than reads in both energy and time. In this paper, we analyze performance, energy consumption, and write patterns in software transactional memories (STMs) to determine the potential of optimization for PCM scenarios. As the write operations are more expensive both in time and energy in PCMs, benchmarks from the STAMP suite were instrumented to count bits swapped due to store instructions, and experiments were executed using TinySTM. Our results showed a pattern of few bits being flipped for each memory write, and performance was inversely proportional to the number of writes. For most benchmarks, there was a small increase in energy consumption with more threads, which may be explained by the timid contention manager used by TinySTM.

Certified Bit-Coded Regular Expression Parsing

We describe the formalization of a regular expression (RE) parsing algorithm that produces a bit representation of its parse tree in the dependently typed language Agda. The algorithm computes bit-codes using Brzozowski derivatives and we prove that produced codes are equivalent to parse trees ensuring soundness and completeness w.r.t an inductive RE semantics. We include the certified algorithm in a tool developed by us, named verigrep, for regular expression based search in the style of the well known GNU grep. Practical experiments conducted with this tool are reported.

A user level approach to schedule BoT applications on private clouds

This paper presents a user level approach to schedule tasks generated by bag of tasks (BoT) applications on a private cloud. At this level, the scheduler consolidates the load of the tasks in a given number of virtual machines providing the estimated makespan. We present the proposed algorithm as well as a model for BoT applications and a performance assessment in a OpenStack based IaaS infrastructure. The results show that the makespan can be reduced by grouping tasks in coarse units of loads.

FJQuantum - A Quantum Object Oriented Language

Several languages and libraries has been proposed to work with quantum programs, usually considering the imperative and functional paradigms. In this paper, we discuss the application of the FJQuantum language, an object-oriented language based on Featherweight Java to develop programs that handle quantum data and operations.

Interpretations on Quantum Fuzzy Computing

Quantum processes provide a parallel model for fuzzy connectives. Calculations of quantum states may be simultaneously performed by the superposition of membership and non-membership degrees of each element regarding the intuitionistic fuzzy sets. This work aims to interpret Atanassovs intuitionistic fuzzy logic through quantum computing, where not only intuitionistic fuzzy sets, but also their basic operations and corresponding connectives (negation, conjuntion, disjuntion, difference, codifference, implication, and coimplication), are interpreted based on the traditional quantum circuit model.

Concurrent Hash Tables for Haskell

This paper presents seven hash table Haskell implementations, ranging from low-level synchronization mechanisms to high-level ones such as transactional memories. The result of the comparison between the algorithms showed that the implementation using the STM Haskell transactional memory library and fine-grain synchronization presented the best performance and good scalability.

Impact of Version Management on Transactional Memories' Performance

Software Transactional Memory (STM) is a synchronization method proposed as an alternative to lock-based synchronization. It provides a higher-level of abstraction that is easier to program, and that enables software composition. Transactions are defined by programmers, but the runtime system is responsible for detecting conflicts and avoiding race conditions. One of the design axis in STMs is how version management is implemented in order to secure atomicity. There are two type of version management: Eager Versioning and Lazy Versioning. In this work, we evaluate the version management options implemented in Tiny STM through an orthogonal analysis and performance evaluation.

Composable Memory Transactions for Java Using a Monadic Intermediate Language

Transactional memory is a new programming abstraction that simplifies concurrent programming. This paper describes the parallel implementation of a Java extension for writing composable memory transactions in Java. Transactions are composable i.e., they can be combined to generate new transactions, and are first-class values, i.e., transactions can be passed as arguments to methods and can be returned as the result of a method call. We describe how composable memory transactions can be implemented in Java as a state passing monad, in which transactional blocks are compiled into an intermediate monadic language. We show that this intermediated language can support different transactional algorithms, such as TL2i¾?[9] and SWissTMi¾?[10]. The implementation described here also provides the high level construct retry, which allows possibly-blocking transactions to be composed in sequence. Although our prototype implementation is in Java using BGGA Closures, it could be implemented in any language that supports objects and closures in some way, e.g. C#, C++, and Python.

Aggregation Operators on the Fuzzy e-Xor and e-XNor Classes

This paper considers the study of the fuzzy e-Xor connectives, their properties, dual constructions, and the corresponding fuzzy implications. Based on such study, the concept of fuzzy subXor connectives is introduced as a generalization of fuzzy Xor connectives, by relaxing boundary conditions. As the main contribution, based on n-ary aggregation functions the (ε, A)-operator is introduced, providing a methodology to obtain fuzzy e-subXor connectives. In particular, by taking the arithmetic mean as the aggregation operator performed over the product triangular norm and the probabilistic sum, graphical representations of fuzzy e-Xor connectives are also presented.