Compilation Step Research Articles

Aspmc: New frontiers of algebraic answer set counting

In the last decade, there has been increasing interest in extensions of answer set programming (ASP) that cater for quantitative information such as weights or probabilities. A wide range of quantitative reasoning tasks for ASP and logic programming, among them probabilistic inference and parameter learning in the neuro-symbolic setting, can be expressed as algebraic answer set counting (AASC) tasks, i.e., weighted model counting for ASP with weights calculated over some semiring, which makes efficient solvers for AASC desirable. In this article, we present ▪, a new solver for AASC that pushes the limits of efficient solvability. Notably, ▪ provides improved performance compared to the state of the art in probabilistic inference by exploiting three insights gained from thorough theoretical investigations in our work. Namely, we consider the knowledge compilation step in the AASC pipeline, where the underlying logical theory specified by the answer set program is converted into a tractable circuit representation, on which AASC is feasible in polynomial time. First, we provide a detailed comparison of different approaches to knowledge compilation for programs, revealing that translation to propositional formulas followed by compilation to sd-DNNF seems favorable. Second, we study how the translation to propositional formulas should proceed to result in efficient compilation. This leads to the second and third insight, namely a novel way of breaking the positive cyclic dependencies in a program, called TP-Unfolding, and an improvement to the Clark Completion, the procedure used to transform programs without positive cyclic dependencies into propositional formulas. Both improvements are tailored towards efficient knowledge compilation. Our empirical evaluation reveals that while all three advancements contribute to the success of ▪, TP-Unfolding improves performance significantly by allowing us to handle cyclic instances better.

Considerations on efficient lexical analysis in the context of compiler design

Each programming language needs a mechanism of translating source code into code understood by the computer, i.e., machine code or assembly. This is done by a compiler. A compiler is thus a fundamental tool for software development. Lexical analysis, as the first step of compilation, has an important role and should be performed in an optimal way. But not only compilers rely on lexical analysis. Its role lies nowadays also in pattern recognition or natural language processing. In this paper, we present some of the main aspects of lexical analysis and how to efficiently perform it. Our aim is to offer some guidelines in constructing a modern and efficient scanner (lexer), outlining the criteria, which should be considered, presenting some pitfalls, and comparing existent tools for compiler construction. The main contribution of the paper is to offer practical guidelines and recommendations, especially to graduate students and programmers, in constructing an efficient scanner (lexer), considering also the proper tools currently available.

A Constructive State-based Semantics and Interpreter for a Synchronous Data-flow Language with State Machines

Scade is a domain-specific synchronous functional language used to implement safety-critical real-time software for more than twenty years. Two main approaches have been considered for its semantics: (i) an indirect collapsing semantics based on a source-to-source translation of high-level constructs into a data-flow core language whose semantics is precisely specified and is the entry for code generation; a relational synchronous semantics , akin to Esterel, that applies directly to the source. It defines what is a valid synchronous reaction but hides, on purpose, if a semantics exists, is unique and can be computed; hence, it is not executable. This paper presents, for the first time, an executable , state-based semantics for a language that has the key constructs of Scade all together, in particular the arbitrary combination of data-flow equations and hierarchical state machines. It can apply directly to the source language before static checks and compilation steps. It is constructive in the sense that the language in which the semantics is defined is a statically typed functional language with call-by-value and strong normalization, e.g., it is expressible in a proof-assistant where all functions terminate. It leads to a reference, purely functional, interpreter. This semantics is modular and can account for possible errors, allowing to establish what property is ensured by each static verification performed by the compiler. It also clarifies how causality is treated in Scade compared with Esterel. This semantics can serve as an oracle for compiler testing and validation; to prototype novel language constructs before they are implemented, to execute possibly unfinished models or that are correct but rejected by the compiler; to prove the correctness of compilation steps. The semantics given in the paper is implemented as an interpreter in a purely functional style, in OCaml.

HasChor: Functional Choreographic Programming for All (Functional Pearl)

Choreographic programming is an emerging paradigm for programming distributed systems. In choreographic programming, the programmer describes the behavior of the entire system as a single, unified program -- a choreography -- which is then compiled to individual programs that run on each node, via a compilation step called endpoint projection. We present a new model for functional choreographic programming where choreographies are expressed as computations in a monad. Our model supports cutting-edge choreographic programming features that enable modularity and code reuse: in particular, it supports higher-order choreographies, in which a choreography may be passed as an argument to another choreography, and location-polymorphic choreographies, in which a choreography can abstract over nodes. Our model is implemented in a Haskell library, HasChor , which lets programmers write choreographic programs while using the rich Haskell ecosystem at no cost, bringing choreographic programming within reach of everyday Haskellers. Moreover, thanks to Haskell's abstractions, the implementation of the HasChor library itself is concise and understandable, boiling down endpoint projection to its short and simple essence.

Suppressing Quantum Circuit Errors Due to System Variability

We present a quantum circuit optimization technique that takes into account the variability in error rates that is inherent across present day noisy quantum computing platforms. This method can be run post qubit routing or post-compilation, and consists of computing isomorphic subgraphs to input circuits and scoring each using heuristic cost functions derived from system calibration data. Using an independent standard algorithmic test suite we show that it is possible to recover on average nearly 40% of missing fidelity using better qubit selection via efficient to compute cost functions. We demonstrate additional performance gains by considering qubit placement over multiple quantum processors. The overhead from these tools is minimal with respect to other compilation steps, such as qubit routing, as the number of qubits increases. As such, our method can be used to find qubit mappings for problems at the scale of quantum advantage and beyond.

A novel highly sensitive compilation-detachment fluorescence sensing strategy based on RNA-cleavage DNAzyme for MDA-MB-231 breast cancer biomarker determination.

Herein, we designed a novel and highly sensitive fluorescence multicomponent detachable platform for MDA-MB-231 breast cancer cell detection as a model. The RNA cleavage DNAzyme was used as a central operator of the multicomponent probe through which compilation and induced detachment of probe was done. During the compilation step, the dsDNA-Sybr green 1 complexes on gold nanoparticles (GNP@dsDNA@SG1) were assembled. The intercalated Sybr green in the DNA structure has been used as an amplified signal generator on one site of DNAzyme and magnetic nanoparticles (MNP) act as a biological carrier and probe collector on the opposite side. The enzyme activator co-factor (MDA-MB-231 cell cytoplasmic protein) provokes the activation of the catalytic core of enzyme sequence in the DNAzyme molecule, followed by cleavage reaction in the substrate sequence and releasing GNP@ dsDNA@SG1 into the solution. The results indicate that the Sybr green emission fluorescence (520 nm) increases with the increment of MDA-MB-231 protein concentration in the linear dynamic range of 8.10 × 10-2 to 1.95 ng ml-1 (0.77 × 10-3-0.019 cell ml-1) with a detection limit (LOD) of 1/72 × 10-2 pg ml-1 under optimal conditions. The proposed immunosensor has great potential in developing ultrasensitive and rapid diagnostic platforms.

Time-domain extrapolation method for tractor drive shaft loads in stationary operating conditions

The fatigue failure of critical parts of tractors over the whole life cycle has received much attention in recent years. Load extrapolation is a crucial step in load spectrum compilation and can extrapolate the product's life cycle load based on limited load data measurements. The traditional time-domain extrapolation method is limited because it neglects the time interval between the load changes and the load reconstruction within the threshold range. To address this problem, a time-domain extrapolation method for tractor drive shaft load based on the Markov chain Monte Carlo-peak over threshold (MCMC-POT) model is proposed. Firstly, an improved time-domain load reconstruction method based on MCMC that can reproduce the load change interval based on the measured load change characteristics was proposed. Secondly, in the POT model extrapolation process, an improved threshold selection algorithm that is an optimisation of the traditional mean excess function (MEF) method was proposed. This method avoids the errors caused by subjective factors under the premise of ensuring the fitting accuracy. Finally, the dynamic torque spectrum was obtained by extrapolating the tractor drive shaft load data measured under ploughing conditions. Case analysis results showed that the method can obtain extrapolation models with high fitting accuracy. The power spectral density values of the dynamic torque spectrum before and after extrapolation were very consistent with the mean correlation coefficient of 0.909. The spectrum can effectively reproduce the time-frequency characteristics of the load. Furthermore, the precision of the load spectrum is improved. • A time-domain load reconstruction method based on Markov chain Monte Carlo model. • The threshold selection method based on peak over threshold model was improved. • A load extrapolation method that can retain complete time-frequency information. • Tractor transmission shaft testing was implemented under ploughing conditions. • The extrapolated load has the consistent frequency spectrum with the measured.

Analisis Kebutuhan Pembangunan Tempat Pemakaman Umum di Perkotaan Tuban

The land availability in public cemeteries in Tuban currently under pressure towards the land capacity which is getting limited due to the population growth and inadequate facilities. This study, using the calculation to get the estimated area and the land capacity of the public cemetery in Tuban. The data compilation steps consists of primary survey and secondary survey. The primary survey activities carried out included field surveys and community aspirations which were carried out through in-depth interviews and Focus Group Discussions (FGD). Meanwhile, the secondary survey was conducted to find data, namely basic data on laws and policies, and data on social demographic conditions. The analytical method used is the analysis of grave needs by analyzing the projection of the mortality rate, calculating the need for cemetery land area per year, calculating the remaining land area for the cemetery, calculating the remaining land capacity of the cemetery, and calculating the remaining capacity of the cemetery with a one-time overlapping system. From the results of the analysis, it is obtained that the remaining capacity of the burial ground in Tuban District will be filled in 2021 and will require an additional land area of 617,945 m2 (61 Ha) in 2030. Semanding and Merakurak Districts are projected to be full in 2025 with a land area requirement of 81,589 m2 (8.1 Ha) and 113,875 m2 (11 Ha) in 2030 Palang District will be full in 2026 and Jenu District will be full in 2028.

Catala: a programming language for the law

Law at large underpins modern society, codifying and governing many aspects of citizens' daily lives. Oftentimes, law is subject to interpretation, debate and challenges throughout various courts and jurisdictions. But in some other areas, law leaves little room for interpretation, and essentially aims to rigorously describe a computation, a decision procedure or, simply said, an algorithm. Unfortunately, prose remains a woefully inadequate tool for the job. The lack of formalism leaves room for ambiguities; the structure of legal statutes, with many paragraphs and sub-sections spread across multiple pages, makes it hard to compute the intended outcome of the algorithm underlying a given text; and, as with any other piece of poorly-specified critical software, the use of informal, natural language leaves corner cases unaddressed. We introduce Catala, a new programming language that we specifically designed to allow a straightforward and systematic translation of statutory law into an executable implementation. Notably, Catala makes it natural and easy to express the general case / exceptions logic that permeates statutory law. Catala aims to bring together lawyers and programmers through a shared medium, which together they can understand, edit and evolve, bridging a gap that too often results in dramatically incorrect implementations of the law. We have implemented a compiler for Catala, and have proven the correctness of its core compilation steps using the F* proof assistant. We evaluate Catala on several legal texts that are algorithms in disguise, notably section 121 of the US federal income tax and the byzantine French family benefits; in doing so, we uncover a bug in the official implementation of the French benefits. We observe as a consequence of the formalization process that using Catala enables rich interactions between lawyers and programmers, leading to a greater understanding of the original legislative intent, while producing a correct-by-construction executable specification reusable by the greater software ecosystem. Doing so, Catala increases trust in legal institutions, and mitigates the risk of societal damage due to incorrect implementations of the law.

Consciousness and inference to the best explanation: Compiling empirical evidence supporting the access-phenomenal distinction and the overflow hypothesis

A tacit assumption in the field of consciousness studies is that the more empirical evidence a theory can explain, the better it fares when weighed against competitors. If one wants to take seriously the potential for empirical evidence to move forward debates in consciousness studies, there is a need to gather, organize, validate, and compare evidence. We present an inference to the best explanation (IBE) process on the basis of empirical support that is applicable in debates between competing theories of consciousness. Our proposed IBE process consists in four steps: Assimilate, Compile, Validate, and Compare. Until now, the vast majority of the work in the field has consisted in gathering empirical evidence for theories i.e., the assimilation step. To illustrate the feasibility of our proposed IBE process, and what it may look like when applied in practice, we deliver a complete collection (the compilation step) of empirical support for the distinction between A-Consciousness and P-Consciousness and the overflow hypothesis. Finally, we offer an example of the validation step, by scrutinizing the interpretation of aphantasics’ performance on retro-cue paradigms offered in the literature in support of the overflow hypothesis. The compilation we deliver here is the first effort in the IBE process, the end result of which — hopefully — will be the ability of the research community to carry out side-by-side comparisons of theories and the empirical phenomena they claim to explain, i.e., the comparison step.

A compositional approach to probabilistic knowledge compilation

Bayesian networks (BN) are a popular representation for reasoning under uncertainty. The analysis of many real-world use cases, that in principle can be modeled by BNs, suffers however from the computational complexity of inference. Inference methods based on Weighted Model Counting (WMC) reduce the cost of inference by exploiting patterns exhibited by the probabilities associated with BN nodes. However, these methods require a computationally intensive compilation step in search of these patterns, which effectively prohibits the handling of larger BNs. In this paper, we propose a solution to this problem by extending WMC methods with a framework called Compositional Weighted Model Counting (CWMC). CWMC reduces compilation cost by partitioning a BN into a set of subproblems, thereby scaling the application of state-of-the-art innovations in WMC to scenarios where inference cost could previously not be amortized over compilation cost. The framework supports various target representations that are less or equally succinct as decision-DNNF. At the same time, its inference time complexity O(nexp⁡(w)), where n is the number of variables and w is the tree-width, is comparable to mainstream algorithms based on variable elimination, clustering and conditioning.

Constructing quantum circuits with global gates

There are various gate sets that can be used to describe a quantum computation. A particularly popular gate set in the literature on quantum computing consists of arbitrary single-qubit gates and two-qubit CNOT gates. A CNOT gate is however not always the natural multi-qubit interaction that can be implemented on a given physical quantum computer, necessitating a compilation step that transforms these CNOT gates to the native gate set. An especially interesting case where compilation is necessary is for ion trap quantum computers, where the natural entangling operation can act on more than two qubits and can even act globally on all qubits at once. This calls for an entirely different approach to constructing efficient circuits. In this paper we study the problem of converting a given circuit that uses two-qubit gates to one that uses global gates. Our three main contributions are as follows. First, we find an efficient algorithm for transforming an arbitrary circuit consisting of Clifford gates and arbitrary phase gates into a circuit consisting of single-qubit gates and a number of global interactions proportional to the number of non-Clifford phases present in the original circuit. Second, we find a general strategy to transform a global gate that targets all qubits into one that targets only a subset of the qubits. This approach scales linearly with the number of qubits that are not targeted, in contrast to the exponential scaling reported in (Maslov and Nam 2018 New J. Phys. 20 033018). Third, we improve on the number of global gates required to synthesise an arbitrary n-qubit Clifford circuit from the 12n − 18 reported in (Maslov and Nam 2018 New J. Phys. 20 033018) to 6n − 8.

KEPEMIMPINAN KEPALA DESA DALAM MEWUJUDKAN DESA MANDIRI DI DESA BOJONGMALAKA KECAMATAN BALEENDAH KABUPATEN BANDUNG

The research entitled "Village Head Leadership in Creating Independent Villages in Bojongmalaka Village, Baleendah District, Bandung Regency" This research is motivated by looking at the condition of Bojongmalaka Village which was chosen as the best in Baleendah District, Bandung Regency so that this village will create an independent village.The research methodology used is descriptive research method with a qualitative approach, with the intention of focusing on the phenomena and problems that occur at the time the research was conducted. Data obtained from observations, documentation and interviews with key informants as primary data. Key informants were determined based on several criteria, at least 3 sources were used as research objects, namely the Village Head, Village Secretary, and the Head of the Village Consultative Body (BPD). The data is processed by means of data reduction, data categorization, synthesization and formulation of working hypotheses as the last step in the data compilation process.The results showed that the leadership of the village head in realizing an independent village in the village of Bojongmalaka, Baleendah District, Bandung Regency has been achieved well and optimally. However, the program being carried out is still in the process of turning the village into an independent village. The village head and village officials are working on the concept and program of the village in order to get maximum results so that this village can be said to be an independent village.
 Keywords: leadership, village head, independent village

Improving FPGA-Based Logic Emulation Systems through Machine Learning

We present a machine learning (ML) framework to improve the use of computing resources in the FPGA compilation step of a commercial FPGA-based logic emulation flow. Our ML models enable highly accurate predictability of the final place and route design qualities, runtime, and optimal mapping parameters. We identify key compilation features that may require aggressive compilation efforts using our ML models. Experiments based on our large-scale database from an industry’s emulation system show that our ML models help reduce the total number of jobs required for a given netlist by 33%. Moreover, our job scheduling algorithm based on our ML model reduces the overall time to completion of concurrent compilation runs by 24%. In addition, we propose a new method to compute “recommendations” from our ML model to perform re-partitioning of difficult partitions. Tested on a large-scale industry system on chip design, our recommendation flow provides additional 15% compile time savings for the entire system on chip. To exploit our ML model inside the time-critical multi-FPGA partitioning step, we implement it in an optimized multi-threaded representation.

Massively Parallel Rule-Based Interpreter Execution on GPUs Using Thread Compaction

Interpreters are well researched in the field of compiler construction and program generation. They are typically used to realize program execution of different programming languages without a compilation step. However, they can also be used to model complex rule-based simulations: The interpreter applies all rules one after another. These can be iteratively applied on a globally updated state in order to get the final simulation result. Many simulations for domain-specific problems already leverage the parallel processing capabilities of Graphics Processing Units (GPUs). They use hardware-specific tuned rule implementations to achieve maximum performance. However, every interpreter-based system requires a high-level algorithm that detects active rules and determines when they are evaluated. A common approach in this context is the use of different interpreter routines for every problem domain. Executing such functions in an efficient way mainly involves dealing with hardware peculiarities like thread divergences, ALU computations and memory operations. Furthermore, the interpreter is often executed on multiple states in parallel these days. This is particularly important for heuristic search or what-if analyses, for instance. In this paper, we present a novel and easy-to-implement method based on thread compaction to realize generic rule-based interpreters in an efficient way on GPUs. It is optimized for many states using a specially designed memory layout. Benchmarks on our evaluation scenarios show that the performance can be significantly increased in comparison to existing commonly-used implementations.

Using ZDDs in the Mapping of Quantum Circuits

A critical step in quantum compilation is the transformation of a technology-independent quantum circuit into a technology-dependent form for a targeted device. In addition to mapping quantum gates into the supported gate set, it is necessary to map pseudo qubits in the technology-independent circuit into physical qubits of the technology-dependent circuit such that coupling constraints among qubits acting in multiple-qubit gates are satisfied. It is usually not possible to find such a mapping without adding SWAP gates into the circuit. To cope with the technical limitations of NISQ-era quantum devices, it is advantageous to find a mapping that requires as few additional gates as possible. The large search space of possible mappings makes this task a difficult combinatorial optimization problem. In this work, we demonstrate how zero-suppressed decision diagrams (ZDDs) can be used for typical implementation tasks in quantum mapping algorithms. We show how to maximally partition a quantum circuit into blocks of adjacent gates, and if adjacent gates within a circuit do not share common mapping permutations, we attempt to combine them using parallelized SWAP operations represented in a ZDD. Boundaries for the partitions are formed where adjacent gates are unable to be combined. Within each partition block, ZDDs represent all possible mappings of pseudo qubits to physical qubits.

Constructing Hybrid Incremental Compilers for Cross-Module Extensibility with an Internal Build System

Context: Compilation time is an important factor in the adaptability of a software project. Fast recompilation enables cheap experimentation with changes to a project, as those changes can be tested quickly. Separate and incremental compilation has been a topic of interest for a long time to facilitate fast recompilation. Inquiry: Despite the benefits of an incremental compiler, such compilers are usually not the default. This is because incrementalization requires cross-cutting, complicated, and error-prone techniques such as dependency tracking, caching, cache invalidation, and change detection. Especially in compilers for languages with cross-module definitions and integration, correctly and efficiently implementing an incremental compiler can be a challenge. Retrofitting incrementality into a compiler is even harder. We address this problem by developing a compiler design approach that reuses parts of an existing non-incremental compiler to lower the cost of building an incremental compiler. It also gives an intuition into compiling difficult-to-incrementalize language features through staging. Approach: We use the compiler design approach presented in this paper to develop an incremental compiler for the Stratego term-rewriting language. This language has a set of features that at first glance look incompatible with incremental compilation. Therefore, we treat Stratego as our critical case to demonstrate the approach on. We show how this approach decomposes the original compiler and has a solution to compile Stratego incrementally. The key idea on which we build our incremental compiler is to internally use an incremental build system to wire together the components we extract from the original compiler. Knowledge: The resulting compiler is already in use as a replacement of the original whole-program compiler. We find that the incremental build system inside the compiler is a crucial component of our approach. This allows a compiler writer to think in multiple steps of compilation, and combine that into a incremental compiler almost effortlessly. Normally, separate compilation \`a la C is facilitated by an external build system, where the programmer is responsible for managing dependencies between files. We reuse an existing sound and optimal incremental build system, and integrate its dependency tracking into the compiler. Grounding: The incremental compiler for Stratego is available as an artefact along with this article. We evaluate it on a large Stratego project to test its performance. The benchmark replays edits to the Stratego project from version control. These benchmarks are part of the artefact, packaged as a virtual machine image for easy reproducibility. Importance: Although we demonstrate our design approach on the Stratego programming language, we also describe it generally throughout this paper. Many currently used programming languages have a compiler that is much slower than necessary. Our design provides an approach to change this, by reusing an existing compiler and making it incremental within a reasonable amount of time.

Compilation of static and evolving conditional knowledge bases for computing induced nonmonotonic inference relations

Several different semantics have been proposed for conditional knowledge bases \(\mathcal {R}\) containing qualitative conditionals of the form “If A, then usually B”, leading to different nonmonotonic inference relations induced by \(\mathcal {R}\). For the notion of c-representations which are a subclass of all ranking functions accepting \(\mathcal {R}\), a skeptical inference relation, called c-inference and taking all c-representations of \(\mathcal {R}\) into account, has been suggested. In this article, we develop a 3-phase compilation scheme for both knowledge bases and skeptical queries to constraint satisfaction problems. In addition to skeptical c-inference, we show how also credulous and weakly skeptical c-inference can be modelled as constraint satisfaction problems, and that the compilation scheme can be extended to such queries. We further extend the compilation approach to knowledge bases evolving over time. The compiled form of \(\mathcal {R}\) is reused for incrementally compiling extensions, contractions, and updates of \(\mathcal {R}\). For each compilation step, we prove its soundness and completeness, and demonstrate significant efficiency benefits when querying the compiled version of \(\mathcal {R}\). These findings are also supported by experiments with the software system InfOCF that employs the proposed compilation scheme.

Building a Hybrid Systems Modeler on Synchronous Languages Principles

Hybrid systems modeling languages that mix discrete and continuous time signals and systems are widely used to develop cyber-physical systems where control software interacts with physical devices. Compilers play a central role, statically checking source models, generating intermediate representations for testing and verification, and producing sequential code for simulation and execution on target platforms. This paper presents a novel approach to the design and implementation of a hybrid systems language, built on synchronous language principles and their proven compilation techniques. The result is a hybrid systems modeling language in which synchronous programming constructs can be mixed with ordinary differential equations (ODEs) and zero-crossing events, and a runtime that delegates their approximation to an off-the-shelf numerical solver. We propose an ideal semantics based on nonstandard analysis, which defines the execution of a hybrid model as an infinite sequence of infinitesimally small time steps. It is used to specify and prove correct three essential compilation steps: 1) a type system that guarantees that a continuous-time signal is never used where a discrete-time one is expected and conversely; 2) a type system that ensures the absence of combinatorial loops; and 3) the generation of statically scheduled code for efficient execution. Our approach has been evaluated in two implementations: the academic language Zelus, which extends a language reminiscent of Lustre with ODEs and zero-crossing events, and the industrial prototype Scade Hybrid, a conservative extension of Scade 6.

Verifying efficient function calls in CakeML

We have designed an intermediate language (IL) for the CakeML compiler that supports the verified, efficient compilation of functions and calls. Verified compilation steps include batching of multiple curried arguments, detecting calls to statically known functions, and specialising calls to known functions with no free variables. Finally, we verify the translation to a lower-level IL that only supports closed, first-order functions. These compilation steps resemble those found in other compilers (especially OCaml). Our contribution here is the design of the semantics of the IL, and the demonstration that our verification techniques over this semantics work well in practice at this scale. The entire development was carried out in the HOL4 theorem prover.