Maurício L. Pilla

High-Performance Quantum Computing Simulation for the Quantum Geometric Machine Model

Due to the unavailability of quantum computers, simulation of quantum algorithms using classical computers is still the most affordable option for research of algorithms and models for quantum computing. As such simulation requires high computing power and memory resources, and computations are regular and data-intensive, GPUs become a suitable solution for accelerating the simulation of quantum algorithms. This work introduces an extension of the execution library for the VPE-qGM environment to support GPU acceleration. Hadamard gates with up to 20 quantum bits were simulated, and speedups of up to approximately 540× over a sequential simulation and of approximately 85× over a 8-core distributed simulation in the VirD-GM environment were achieved.

Quantum processes: A new interpretation for quantum transformations in the VPE-qGM environment

The simulation of quantum algorithms in classic computers is a task which requires high processing and storing capabilities, limiting the size of quantum systems supported by the simulators. However, optimizations for reduction of temporal and spatial complexities are promising, expanding the capabilities of some simulators. The main contribution of this work consists in designing optimizations resulting from the description of quantum transformations using Quantum Processes and Partial Quantum Processes conceived in the qGM theoretical model. These processes, when computed on the VPE-qGM execution environment, require low execution time and result in the improvement of the performance, allowing the simulation of more complex quantum algorithms. The performance evaluation of this proposal was performed by benchmarks used in similar works and included the sequential simulation of quantum algorithms up to 24 qubits. The results are promising when compared to the state-of-art, indicating the possibilities of advances in this research.

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.

Optimizing D-GM quantum computing by exploring parallel and distributed quantum simulations under GPUs arquitecture

The exponential increase in the temporal and spatial complexities is one of the main challenges in the widespread use of quantum algorithm simulation, especially in dense quantum transformations (QTs) such as the Hadamard transformation (H), which has found wide applications in computer and communication science and also comprising the simplest quantum universal set of QTs. The main reason for these costs is the expansion of QTs by using tensor product in multi-dimension quantum applications. In this work, new optimizations for the execution of reduction and decomposition based on the Identity operator are introduced in the Distributed Geometric Machine framework (D-GM). Instead of executing the quantum transformation in a single step, they are divided in sub-quantum transformations and only the values different from Identity transformations are stored. Mixed Partial Processes provide control over the increase in the size of read/write memory states in the calculation of a QT, thus contributing to increase the scalability of applications regarding hardware-GPUs memory limit. In the evaluation of this D-GM extension, Hadamard Transformations were simulated up to 28 qubits applications over a single GPU. Our new simulator is 10, 829χ faster and allows for the simulation of more qubits when compared to our previous implementation running on the same GPU.

Scalable quantum simulation by reductions and decompositions through the Id-operator

One of the main obstacles for the adoption of quantum algorithm simulation is the exponential increase in temporal and spatial complexities, due to the expansion of transformations and read/write memory states by using tensor product in multi-dimension applications. Reduction and decomposition optimizations via the Id-operator provide a smart and appropriate storage and distribution of quantum information. Reductions are achieved by avoiding replication and sparsity inherited from such operators. By using decompositions, applications may be divided into sub-steps to store only distinct values from Id-operators, instead of executing quantum transformations in a single step. Additional optimizations based on mixed partial processes provide control over increase in read/write memory states in quantum transformations, also contributing to increase the scalability regarding hardware-GPUs memory limit. Hadamard and Discret Quantum Fourier Transforms were simulated up to 28 qubits applications over a single GPU with drastic temporal complexity reduction and simulation time.

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.

Aproximating static list schedules in dynamic multithreaded applications

List scheduling algorithms are known to be efficient when the application to be executed can be described statically as a Directed Acyclic Graph (DAG) of tasks. Regardless of knowing the entire DAG beforehand, obtaining an optimal schedule in a parallel machine is a NP-hard problem. Moreover, many programming tools propose the use of scheduling techniques based on list strategies. This paper presents an analysis of scheduling algorithms for multithread programs in a dynamic scenario where threads are created and destroyed during execution. We introduce an algorithm to convert DAGs, describing applications as tasks, into Directed Cyclic Graphs (DCGs) describing the same application designed in a multithread programming interface. Our algorithm covers case studies described in previous works, successfully mapping from the abstract level of graphs to the application environment. These mappings preserve the guarantees offered by the abstract model, providing efficient scheduling of dynamic programs that follow the intended multithread model. We conclude the paper presenting some performance results we obtained by list schedulers in dynamic multithreaded environments. We also compare these results with the best scheduling we could obtain with similar static task schedulers.