Quingo: A Programming Framework for Heterogeneous Quantum-Classical Computing with NISQ Features

The increasing control complexity of Noisy Intermediate-Scale Quantum (NISQ) systems underlines the necessity of integrating quantum hardware with quantum software. While mapping heterogeneous quantum-classical computing (HQCC) algorithms to NISQ hardware for execution, we observed a few dissatisfactions in quantum programming languages (QPLs), including difficult mapping to hardware, limited expressiveness, and counter-intuitive code. In addition, noisy qubits require repeatedly performed quantum experiments, which explicitly operate low-level configurations, such as pulses and timing of operations. This requirement is beyond the scope or capability of most existing QPLs. We summarize three execution models to depict the quantum-classical interaction of existing QPLs. Based on the refined HQCC model, we propose the Quingo framework to integrate and manage quantum-classical software and hardware to provide the programmability over HQCC applications and map them to NISQ hardware. We propose a six-phase quantum program life-cycle model matching the refined HQCC model, which is implemented by a runtime system. We also propose the Quingo programming language, an external domain-specific language highlighting timer-based timing control and opaque operation definition, which can be used to describe quantum experiments. We believe the Quingo framework could contribute to the clarification of key techniques in the design of future HQCC systems.

Device Hopping

Existing OS techniques for homogeneous many-core systems make it simple for single and multithreaded applications to migrate between cores. Heterogeneous systems do not benefit so fully from this flexibility, and applications that cannot migrate in mid-execution may lose potential performance. The situation is particularly challenging when a switch of language runtime would be desirable in conjunction with a migration. We present a case study in making heterogeneous CPU + GPU systems more flexible in this respect. Our technique for fine-grained application migration, allows switches between OpenMP, OpenCL, and CUDA execution, in conjunction with migrations from GPU to CPU, and CPU to GPU. To achieve this, we subdivide iteration spaces into slices, and consider migration on a slice-by-slice basis. We show that slice sizes can be learned offline by machine learning models. To further improve performance, memory transfers are made migration-aware. The complexity of the migration capability is hidden from programmers behind a high-level programming model. We present a detailed evaluation of our mid-kernel migration mechanism with the First Come, First Served scheduling policy. We compare our technique in a focused evaluation scenario against idealized kernel-by-kernel scheduling, which is typical for current systems, and makes perfect kernel to device scheduling decisions, but cannot migrate kernels mid-execution. Models show that up to 1.33× speedup can be achieved over these systems by adding fine-grained migration. Our experimental results with all nine applicable SHOC and Rodinia benchmarks achieve speedups of up to 1.30× (1.08× on average) over an implementation of a perfect but kernel-migration incapable scheduler when migrated to a faster device. Our mechanism and slice size choices introduce an average slowdown of only 2.44% if kernels never migrate. Lastly, our programming model reduces the code size by at least 88% if compared to manual implementations of migratable kernels.

A Survey of IoT Stream Query Execution Latency Optimization within Edge and Cloud

IoT (Internet of Things) streaming data has increased dramatically over the recent years and continues to grow rapidly due to the exponential growth of connected IoT devices. For many IoT applications, fast stream query processing is crucial for correct operations. To achieve better query performance and quality, researchers and practitioners have developed various types of query execution models—purely cloud-based, geo-distributed, edge-based, and edge-cloud-based models. Each execution model presents unique challenges and limitations of query processing optimizations. In this work, we provide a comprehensive review and analysis of query execution models within the context of the query execution latency optimization. We also present a detailed overview of various query execution styles regarding different query execution models and highlight their contributions. Finally, the paper concludes by proposing promising future directions towards advancing the query executions in the edge and cloud environment.

Programming and execution models for parallel bounded exhaustive testing

Bounded-exhaustive testing (BET), which exercises a program under test for all inputs up to some bounds, is an effective method for detecting software bugs. Systematic property-based testing is a BET approach where developers write test generation programs that describe properties of test inputs. Hybrid test generation programs offer the most expressive way to write desired properties by freely combining declarative filters and imperative generators. However, exploring hybrid test generation programs, to obtain test inputs, is both computationally demanding and challenging to parallelize. We present the first programming and execution models, dubbed Tempo, for parallel exploration of hybrid test generation programs. We describe two different strategies for mapping the computation to parallel hardware and implement them both for GPUs and CPUs. We evaluated Tempo by generating instances of various data structures commonly used for benchmarking in the BET domain. Additionally, we generated CUDA programs to stress test CUDA compilers, finding four bugs confirmed by the developers.

Durable functions: semantics for stateful serverless

Serverless, or Functions-as-a-Service (FaaS), is an increasingly popular paradigm for application development, as it provides implicit elastic scaling and load based billing. However, the weak execution guarantees and intrinsic compute-storage separation of FaaS create serious challenges when developing applications that require persistent state, reliable progress, or synchronization. This has motivated a new generation of serverless frameworks that provide stateful abstractions. For instance, Azure's Durable Functions (DF) programming model enhances FaaS with actors, workflows, and critical sections. As a programming model, DF is interesting because it combines task and actor parallelism, which makes it suitable for a wide range of serverless applications. We describe DF both informally, using examples, and formally, using an idealized high-level model based on the untyped lambda calculus. Next, we demystify how the DF runtime can (1) execute in a distributed unreliable serverless environment with compute-storage separation, yet still conform to the fault-free high-level model, and (2) persist execution progress without requiring checkpointing support by the language runtime. To this end we define two progressively more complex execution models, which contain the compute-storage separation and the record-replay, and prove that they are equivalent to the high-level model.

A Taxonomy for Model-Based Systems Engineering

In this paper, we define Model Based Systems Engineering (MBSE) as a set of different approaches which vary in scope and in purpose, as opposed to defining it as a monolithic concept. To do so, we inductively extract common themes from papers proposing new MBSE methods based on the type of Systems Engineering (SE) artifacts produced and the expected benefits of MBSE implementation. These themes are then validated against the experiences depicted in a second set of papers evaluating the deployment of MBSE methods in practice. We propose a taxonomy for MBSE which identifies three main categories: system specification repositories, system execution models, and design automation models. The proposed categories map well onto common discussions of the nature of the SE activity, in that the first is employed in the management of system development processes and the second in the understanding of system performance and emergent properties. The third category is almost exclusively discussed in an academic context and is therefore more difficult to relate to SE practice, but its features are clearly distinct from the other two. The proposed taxonomy clarifies what MBSE is and what it can be, therefore helping focus research on the issues that still prevent MBSE practice from living up to expectations.

Interface Risk Reduction in an Integrated SURF-SPS Scope Execution

The paper provides a detailed estimation of the interfaces that exist in a split SURF-SPS execution model and provides a qualitative comparison to an integrated SURF-SPS execution model. A comprehensive matrix of dependencies between SURF and SPS is presented and is categorized into engineering, procurement, construction/fabrication and installation work packages. The matrix is used to illustrate the exact scope dependencies and thus, the sources of interfaces. A hypothetical greenfield development has been assumed to develop the interface matrix and to use it for comparison of the two execution models. The comparison also reveals how interfaces are naturally eliminated in an integrated SURF-SPS execution model. In each of the workstreams (E-P-C-I), top risks have been identified and monetary liability estimates for those risks have been provided. By transfer of these risks from company to contractor, monetary liability gets transferred to the contractor, thus, resulting in significant savings for operating companies. The following tangible results are provided in the paper: a) % of interface(s) reduced in the E-P-C-I areas; b) Risk reduction in monetary terms for operators – estimated values. This paper justifies the fact that there is a significant interface scope and risk reduction for operators, if they adopt an integrated SURF-SPS execution model.