SearcharxivSearch

arXiv subjects

Camille Coti

Publications and source records attributed to Camille Coti.

At least 19 recordsLinked to original sources

Quantum State Certification via Effective Parent Hamiltonians from Local Measurement Data

The preparation and certification of quantum states is a fundamental challenge across quantum information technology. We introduce a tomography-free state certification method that lower-bounds the fidelity by estimating expectation values of engineered parent-Hamiltonian terms from local measurement data. We apply this framework to construct a parent Hamiltonian that enables certification and variational optimization across the Dicke-state family, which includes the single-excitation $W_n$ state. We experimentally validate the framework on IBM quantum hardware, certifying genuine multipartite entanglement for $W_n$ states up to six qubits and establishing positive lower bounds on the state fidelity up to thirteen qubits. For Dicke states with two- and three-excitations, we certify genuine multipartite entanglement up to seven qubits. Within this stringent certification framework, these results constitute among the largest witness-certified demonstrations of such states on a programmable quantum processor.

quant-ph

Mid-circuit measurement as an algorithmic primitive

We explore the usefulness of mid-circuit measurements to enhance quantum algorithmics. Specifically, we assess how quantum phase estimation (QPE) and mid-circuit measurements can improve the performance of variational quantum algorithms. Our focus is on the single-qubit version of QPE namely, the Hadamard test applied to the Quantum Approximate Optimization Algorithm (QAOA) ansatz. We demonstrate that a mid-circuit measurement acts as a low-energy filter when the desired outcome is obtained. When the other outcome is measured we heuristically rely on the mixer to repopulate the low energy states. Numerical simulations show that this method effectively amplifies the ground state. We validate our approach on real quantum hardware namely the IBM Quantum system one ibm_quebec.

quant-ph

Parallel Computation of Multi-Slice Clustering of Third-Order Tensors

Machine Learning approaches like clustering methods deal with massive datasets that present an increasing challenge. We devise parallel algorithms to compute the Multi-Slice Clustering (MSC) for 3rd-order tensors. The MSC method is based on spectral analysis of the tensor slices and works independently on each tensor mode. Such features fit well in the parallel paradigm via a distributed memory system. We show that our parallel scheme outperforms sequential computing and allows for the scalability of the MSC method.

cs.DC

Just-in-Time autotuning

Performance portability is a major concern on current architectures. One way to achieve it is by using autotuning. In this paper, we are presenting how we exten ded a just-in-time compilation infrastructure to introduce autotuning capabiliti es triggered at run-time. When a function is executed, the first iterations optimize it, and once the best solution has been found, it is used for subsequent calls to the function. This just-in-time autotuning infrastructure is relevant for optimizing computation kernels that will be called numerous times with similar parameters through the execution, re-optimizes kernels when they are called with other parameters, and the programmer can obtain the optimal parameters to use them for other kernels. We present an experimental performance evaluation of our approach. Compiling the code introduces an overhead on the first iterations, and this overhead is compensated for during subsequent iterations. We also determined that the optimum found seems stable and accurate.

cs.DC

STaKTAU: profiling HPC applications' operating system usage

This paper presents a approach for measuring the time spent by HPC applications in the operating system's kernel. We use the SystemTap interface to insert timers before and after system calls, and take advantage of its stability to design a tool that can be used with multiple versions of the kernel. We evaluate its performance overhead, using an OS-intensive mini-benchmark and a raytracing mini app.

cs.DC

SKaMPI-OpenSHMEM: Measuring OpenSHMEM Communication Routines

Benchmarking is an important challenge in HPC, in particular, to be able to tune the basic blocks of the software environment used by applications. The communication library and distributed run-time environment are among the most critical ones. In particular, many of the routines provided by communication libraries can be adjusted using parameters such as buffer sizes and communication algorithm. As a consequence, being able to measure accurately the time taken by these routines is crucial in order to optimize them and achieve the best performance. For instance, the SKaMPI library was designed to measure the time taken by MPI routines, relying on MPI's two-sided communication model to measure one-sided and two-sided peer-to-peer communication and collective routines. In this paper, we discuss the benchmarking challenges specific to OpenSHMEM's communication model, mainly to avoid inter-call pipelining and overlapping when measuring the time taken by its routines. We extend SKaMPI for OpenSHMEM for this purpose and demonstrate measurement algorithms that address OpenSHMEM's communication model in practice. Scaling experiments are run on the Summit platform to compare different benchmarking approaches on the SKaMPI benchmark operations. These show the advantages of our techniques for more accurate performance characterization.

cs.DC

A task-based approach to parallel parametric linear programming solving, and application to polyhedral computations

Parametric linear programming is a central operation for polyhedral computations, as well as in certain control applications.Here we propose a task-based scheme for parallelizing it, with quasi-linear speedup over large problems.This type of parallel applications is challenging, because several tasks mightbe computing the same region. In this paper, we are presenting thealgorithm itself with a parallel redundancy elimination algorithm, andconducting a thorough performance analysis.

cs.CG

On-the-fly Optimization of Parallel Computation of Symbolic Symplectic Invariants

Group invariants are used in high energy physics to define quantum field theory interactions. In this paper, we are presenting the parallel algebraic computation of special invariants called symplectic and even focusing on one particular invariant that finds recent interest in physics. Our results will export to other invariants. The cost of performing basic computations on the multivariate polynomials involved evolves during the computation, as the polynomials get larger or with an increasing number of terms. However, in some cases, they stay small. Traditionally, high-performance software is optimized by running it on a smaller data set in order to use profiling information to set some tuning parameters. Since the (communication and computation) costs evolve during the computation, the first iterations of the computation might not be representative of the rest of the computation and this approach cannot be applied in this case. To cope with this evolution, we are presenting an approach to get performance data and tune the algorithm during the execution.

cs.DC

Quasi-Optimal Partial Order Reduction

A dynamic partial order reduction (DPOR) algorithm is optimal when it always explores at most one representative per Mazurkiewicz trace. Existing literature suggests that the reduction obtained by the non-optimal, state-of-the-art Source-DPOR (SDPOR) algorithm is comparable to optimal DPOR. We show the first program with $\mathop{\mathcal{O}}(n)$ Mazurkiewicz traces where SDPOR explores $\mathop{\mathcal{O}}(2^n)$ redundant schedules and identify the cause of the blow-up as an NP-hard problem. Our main contribution is a new approach, called Quasi-Optimal POR, that can arbitrarily approximate an optimal exploration using a provided constant k. We present an implementation of our method in a new tool called Dpu using specialised data structures. Experiments with Dpu, including Debian packages, show that optimality is achieved with low values of k, outperforming state-of-the-art tools.

cs.PL

Parametric, Probabilistic, Timed Resource Discovery System

This paper presents a fully distributed resource discovery and reservation system. Verification of such a system is important to ensure the execution of distributed applications on a set of resources in appropriate conditions. A semi-formal model for his system is presented using probabilistic timed automata. This model is timed, parametric and probabilistic, making it a challenge to the parameter synthesis community.

cs.DC

Parallel Galton Watson Process

In this paper, we study a parallel version of Galton-Watson processes for the random generation of tree-shaped structures. Random trees are useful in many situations (testing, binary search, simulation of physics phenomena,...) as attests more than 49000 citations on Google scholar. Using standard analytic combinatorics, we first give a theoretical, average-case study of the random process in order to evaluate how parallelism can be extracted from this process, and we deduce a parallel generation algorithm. Then we present how it can be implemented in a task-based parallel paradigm for shared memory (here, Intel Cilk). This implementation faces several challenges, among which efficient, thread-safe random bit generation, memory management and algorithmic modifications for small-grain parallelism. Finally, we evaluate the performance of our implementation and the impact of different choices and parameters. We obtain a significant efficiency improvement for the generation of big trees. We also conduct empirical and theoretical studies of the average behaviour of our algorithm.

cs.DC

Fault Tolerant QR Factorization for General Matrices

This paper presents a fault-tolerant algorithm for the QR factorization of general matrices. It relies on the communication-avoiding algorithm, and uses the structure of the reduction of each part of the computation to introduce redundancies that are sufficient to recover the state of a failed process. After a process has failed, its state can be recovered based on the data held by one process only. Besides, it does not add any significant operation in the critical path during failure-free execution.

cs.DC

Formally Proving and Enhancing a Self-Stabilising Distributed Algorithm

This paper presents the benefits of formal modelling and verification techniques for self-stabilising distributed algorithms. An algorithm is studied, that takes a set of processes connected by a tree topology and converts it to a ring configuration. The Coloured Petri net model not only facilitates the proof that the algorithm is correct and self-stabilising but also easily shows that it enjoys new properties of termination and silentness. Further, the formal results show how the algorithm can be simplified without loss of generality.

cs.DC

Time Petri Net Models for a New Queuless and Uncentralized Resource Discovery System

In this report, we detail the model using Petri Nets of a new fully distributed resource reservation system. The basic idea of the considered distributed system is to let a user reserve a set of resources on a local network and to use them, without any specific, central administration component such as a front-end node. Resources can be, for instance, computing resources (cores, nodes, GPUs...) or some memory on a server. In order to verify some qualitative and quantitative properties provided by this system, we need to model it. We detail the algorithms used by this system and the Petri Net models we made of it.

cs.DC

OS-level Failure Injection with SystemTap

Failure injection in distributed systems has been an important issue to experiment with robust, resilient distributed systems. In order to reproduce real-life conditions, parts of the application must be killed without letting the operating system close the existing network communications in a "clean" way. When a process is simply killed, the OS closes them. SystemTap is a an infrastructure that probes the Linux kernel's internal calls. If processes are killed at kernel-level, they can be destroyed without letting the OS do anything else. In this paper, we present a kernel-level failure injection system based on SystemTap. We present how it can be used to implement deterministic and probabilistic failure scenarios.

cs.OS