Language Compiler Research Articles

Formally verified speculation and deoptimization in a JIT compiler

Just-in-time compilers for dynamic languages routinely generate code under assumptions that may be invalidated at run-time, this allows for specialization of program code to the common case in order to avoid unnecessary overheads due to uncommon cases. This form of software speculation requires support for deoptimization when some of the assumptions fail to hold. This paper presents a model just-in-time compiler with an intermediate representation that explicits the synchronization points used for deoptimization and the assumptions made by the compiler's speculation. We also present several common compiler optimizations that can leverage speculation to generate improved code. The optimizations are proved correct with the help of a proof assistant. While our work stops short of proving native code generation, we demonstrate how one could use the verified optimization to obtain significant speed ups in an end-to-end setting.

Active Machine Learning Adversarial Attack Detection in the User Feedback Process

Modern Information and Communication Technology (ICT)-based applications utilize current technological advancements for purposes of streaming data, as a way of adapting to the ever-changing technological landscape. Such efforts require providing accurate, meaningful, and trustworthy output from the streaming sensors particularly during dynamic virtual sensing. However, to ensure that the sensing ecosystem is devoid of any sensor threats or active attacks, it is paramount to implement secure real-time strategies. Fundamentally, real-time detection of adversarial attacks/instances during the User Feedback Process (UFP) is the key to forecasting potential attacks in active learning. Also, according to existing literature, there lacks a comprehensive study that has a focus on adversarial detection from an active machine learning perspective at the time of writing this paper. Therefore, the authors posit the importance of detecting adversarial attacks in active learning strategy. Attack in the context of this paper through a UFP-Threat driven model has been presented as any action that exerts an alteration to the learning system or data. To achieve this, the study employed ambient data collected from a smart environment human activity recognition from (Continuous Ambient Sensors Dataset, CASA) with fully labeled connections, where we intentionally subject the Dataset to wrong labels as a targeted/manipulative attack (by a malevolent labeler) in the UFP, with an assumption that the user-labels were connected to unique identities. While the dataset's focus is to classify tasks and predict activities, our study gives a focus on active adversarial strategies from an information security point of view. Furthermore, the strategies for modeling threats have been presented using the Meta Attack Language (MAL) compiler for purposes adversarial detection. The findings from the experiments conducted have shown that real-time adversarial identification and profiling during the UFP could significantly increase the accuracy during the learning process with a high degree of certainty and paves the way towards an automated adversarial detection and profiling approaches on the Internet of Cognitive Things (ICoT).

Fast simulation of Time-of-Flight detectors at the LHC

The modelling of Cherenkov based detectors is traditionally done using Geant4 toolkit. In this work, we present another method based on Python programming language and Numba high performance compiler to speed up the simulation. As an example we take one of the Forward Proton Detectors at the CERN LHC - ATLAS Forward Proton (AFP) Time-of-Flight, which is used to reduce the background from multiple proton-proton collisions in soft and hard diffiractive events. We describe the technical details of the fast Cherenkov model of photon generation and transportation through the optical part of the ToF detector. The fast simulation is revealed to be about 200 times faster than the corresponding Geant4 simulation, and provides similar results concerning length and time distributions of photons. The study is meant as the first step in a construction of a building kit allowing creation of a fast simulation of an arbitrary shaped optical part of detectors.

Contextual dispatch for function specialization

In order to generate efficient code, dynamic language compilers often need information, such as dynamic types, not readily available in the program source. Leveraging a mixture of static and dynamic information, these compilers speculate on the missing information. Within one compilation unit, they specialize the generated code to the previously observed behaviors, betting that past is prologue. When speculation fails, the execution must jump back to unoptimized code. In this paper, we propose an approach to further the specialization, by disentangling classes of behaviors into separate optimization units. With contextual dispatch, functions are versioned and each version is compiled under different assumptions. When a function is invoked, the implementation dispatches to a version optimized under assumptions matching the dynamic context of the call. As a proof-of-concept, we describe a compiler for the R language which uses this approach. Our implementation is, on average, 1.7× faster than the GNU R reference implementation. We evaluate contextual dispatch on a set of benchmarks and measure additional speedup, on top of traditional speculation with deoptimization techniques. In this setting contextual dispatch improves the performance of 18 out of 46 programs in our benchmark suite.

An Effective Fusion and Tile Size Model for PolyMage

Effective models for fusion of loop nests continue to remain a challenge in both general-purpose and domain-specific language (DSL) compilers. The difficulty often arises from the combinatorial explosion of grouping choices and their interaction with parallelism and locality. This article presents a new fusion algorithm for high-performance domain-specific compilers for image processing pipelines. The fusion algorithm is driven by dynamic programming and explores spaces of fusion possibilities not covered by previous approaches, and it is also driven by a cost function more concrete and precise in capturing optimization criteria than prior approaches. The fusion model is particularly tailored to the transformation and optimization sequence applied by PolyMage and Halide, two recent DSLs for image processing pipelines. Our model-driven technique when implemented in PolyMage provides significant improvements (up to 4.32×) over PolyMage’s approach (which uses auto-tuning to aid its model) and over Halide’s automatic approach (by up to 2.46×) on two state-of-the-art shared-memory multicore architectures.

Universal parameter language for the programming of numerical controlled machines

This work aimed to develop a universal parameterized language for programming numerically controlled machines. For proposed language interpretation and compilation, a computational application called parameterized programming module (PPM) was developed, based on Pascal programming fundamentals and incremented with the G-code. The proposed parameterized language has a different structure from those provided by the command manufacturers, constituting a complementary tool for parameterization in numerical programming. In order to validate the proposed system, angular, transversal, and longitudinal turning thinning operation through single and multiple cycles were programmed, which proved the algorithm’s operability. Additionally, the performed test results show that the developed algorithm proved to be reliable in the numerical code interworking and compilation.

Exploiting Errors for Efficiency

When a computational task tolerates a relaxation of its specification or when an algorithm tolerates the effects of noise in its execution, hardware, system software, and programming language compilers or their runtime systems can trade deviations from correct behavior for lower resource usage. We present, for the first time, a synthesis of research results on computing systems that only make as many errors as their end-to-end applications can tolerate. The results span the disciplines of computer-aided design of circuits, digital system design, computer architecture, programming languages, operating systems, and information theory. Rather than over-provisioning the resources controlled by each of these layers of abstraction to avoid errors, it can be more efficient to exploit the masking of errors occurring at one layer and thereby prevent those errors from propagating to a higher layer. We demonstrate the potential benefits of end-to-end approaches using two illustrative examples. We introduce a formalization of terminology that allows us to present a coherent view across the techniques traditionally used by different research communities in their individual layer of focus. Using this formalization, we survey tradeoffs for individual layers of computing systems at the circuit, architecture, operating system, and programming language levels as well as fundamental information-theoretic limits to tradeoffs between resource usage and correctness.

Spatial Analysis of 3D Space using 2D Images

For a human being, the process of perceiving any object or scene in three dimensions, i.e., its length, breadth and height, seems to be a very simple and obvious task. But this same task of perceiving any object in three dimensions is a very complicated and taxing process for a machine. The objective of the project is the creation of a linked 3D model of two rooms, with the training and testing inputs to the neural network being real-life 2D images of various rooms, taken from different points of view or panoramic images. This aim is an extension of the previously published technical papers (GQN, U-Net, ResNet, RoomNet, LayoutNet and HorizonNet) that deal with 3D model creation of only one room (without any room linking) using only virtual images available on the Internet (no real-life images used for training or testing the neural network). The programming language used is Python, utilizing the Jupyter Notebook (a programming language editor and compiler) in Anaconda Integrated Development Environment (Anaconda I.D.E.).

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.

The mathematical foundations of physical systems modeling languages

Modern modeling languages for general physical systems, such as Modelica, Amesim, or Simscape, rely on Differential Algebraic Equations (DAEs), i.e., constraints of the form f(x′,x,u)=0. This drastically facilitates modeling from first principles of the physics, as well as the reuse of models. In this paper, we develop the mathematical theory needed to establish the development of compilers and tools for DAE-based physical modeling languages on solid mathematical bases.Unlike Ordinary Differential Equations (ODEs, of the form x′=g(x,u)), DAEs exhibit subtle issues because of the notion of differentiation index and related latent equations—ODEs are DAEs of index zero, for which no latent equation needs to be considered. Prior to generating execution code and calling solvers, the compilation of such languages requires a nontrivial structural analysis step that reduces the differentiation index to a level acceptable by DAE solvers.The models supported by tools of the Modelica class involve multiple modes, with mode-dependent DAE-based dynamics and state-dependent mode switching. However, multimode DAEs are much more difficult to handle than DAEs, especially because of the events of mode change. Unfortunately, the large literature devoted to the mathematical analysis of DAEs does not cover the multimode case, typically saying nothing about mode changes. This lack of foundations causes numerous difficulties to the existing modeling tools. Some models are well handled, others are not, with no clear boundary between the two classes.In this paper, we develop a comprehensive mathematical approach supporting compilation and code generation for this class of languages. Its core is the structural analysis of multimode DAE systems. As a byproduct of this structural analysis, we propose sound criteria for accepting or rejecting multimode models. Our mathematical development relies on nonstandard analysis, which allows us to cast hybrid system dynamics to discrete-time dynamics with infinitesimal step size, thus providing a uniform framework for handling both continuous dynamics and mode change events.

Bugis Language Interference with the Use of Indonesian Language in Communicating Students at SMP Negeri 1 Pammana

This research based on the processes that language learning must be carried out following the rules. The school which is a place of formal education in educating students to use Indonesian language is good and right, in the form of written and oral terms. However, in reality, the problem of Indonesian conversion is still often found in schools, at various levels starting from the higher level, which is the cause of language acquisition and mastery of more than one language (bilingual). This can be done error which is usually called interference. Interference in language is usually called "language disease" because it can damage language so it must be avoided. This interference is a result of mixing a second language rules that are mastered by someone. The purpose of this research is to describe the form of Bugis language interference with the use of Indonesian used by junior high school students in Pammana sub-district in conversation and explain the translation of Bugis language interference on the ability to support junior high school students in Pammana sub-district. The method used in this research is descriptive qualitative method. The techniques of collecting data in this research are, conducting direct dialogue with students, inviting students to communicate well in the learning process. SMP Negeri 1 Pammana to interrupt Bugis language compilation to communicate or speak in Indonesian, this is done during formal conversations, this helps deviate from the rules of the Indonesian language.

The weak call-by-value λ-calculus is reasonable for both time and space

We study the weak call-by-value λ-calculus as a model for computational complexity theory and establish the natural measures for time and space — the number of beta-reduction steps and the size of the largest term in a computation — as reasonable measures with respect to the invariance thesis of Slot and van Emde Boas from 1984. More precisely, we show that, using those measures, Turing machines and the weak call-by-value λ-calculus can simulate each other within a polynomial overhead in time and a constant factor overhead in space for all computations terminating in (encodings of) ”true” or ”false”. The simulation yields that standard complexity classes like P , NP , PSPACE , or EXP can be defined solely in terms of the λ-calculus, but does not cover sublinear time or space. Note that our measures still have the well-known size explosion property, where the space measure of a computation can be exponentially bigger than its time measure. However, our result implies that this exponential gap disappears once complexity classes are considered instead of concrete computations. We consider this result a first step towards a solution for the long-standing open problem of whether the natural measures for time and space of the λ-calculus are reasonable. Our proof for the weak call-by-value λ-calculus is the first proof of reasonability (including both time and space) for a functional language based on natural measures and enables the formal verification of complexity-theoretic proofs concerning complexity classes, both on paper and in proof assistants. The proof idea relies on a hybrid of two simulation strategies of reductions in the weak call-by-value λ-calculus by Turing machines, both of which are insufficient if taken alone. The first strategy is the most naive one in the sense that a reduction sequence is simulated precisely as given by the reduction rules; in particular, all substitutions are executed immediately. This simulation runs within a constant overhead in space, but the overhead in time might be exponential. The second strategy is heap-based and relies on structure sharing, similar to existing compilers of eager functional languages. This strategy only has a polynomial overhead in time, but the space consumption might require an additional factor of log n , which is essentially due to the size of the pointers required for this strategy. Our main contribution is the construction and verification of a space-aware interleaving of the two strategies, which is shown to yield both a constant overhead in space and a polynomial overhead in time.

FlowSpec: A declarative specification language for intra-procedural flow-Sensitive data-flow analysis

Abstract Data-flow analysis is the static analysis of programs to estimate their approximate run-time behavior or approximate intermediate run-time values. It is an integral part of modern language specifications and compilers. In the specification of static semantics of programming languages, the concept of data-flow allows the description of well-formedness such as definite assignment of a local variable before its first use. In the implementation of compiler back-ends, data-flow analyses inform optimizations. Data-flow analysis has an established theoretical foundation. What lags behind is implementations of data-flow analysis in compilers, which are usually ad-hoc. This makes such implementations difficult to extend and maintain. In previous work researchers have proposed higher-level formalisms suitable for whole-program analysis in a separate tool, incremental analysis within editors, or bound to a specific intermediate representation. In this paper, we present FlowSpec , an executable formalism for specification of data-flow analysis. FlowSpec is a domain-specific language that enables direct and concise specification of data-flow analysis for programming languages, designed to express flow-sensitive, intra-procedural analyses. We define the formal semantics of FlowSpec in terms of monotone frameworks. We describe the design of FlowSpec using examples of standard analyses. We also include a description of our implementation of FlowSpec . In a case study we evaluate FlowSpec with the static analyses for Green-Marl , a domain-specific programming language for graph analytics.

Precise reasoning with structured time, structured heaps, and collective operations

Despite decades of progress, static analysis tools still have great difficulty dealing with programs that combine arithmetic, loops, dynamic memory allocation, and linked data structures. In this paper we draw attention to two fundamental reasons for this difficulty: First, typical underlying program abstractions are low-level and inherently scalar, characterizing compound entities like data structures or results computed through iteration only indirectly. Second, to ensure termination, analyses typically project away the dimension of time, and merge information per program point, which incurs a loss in precision. As a remedy, we propose to make collective operations first-class in program analysis – inspired by Σ-notation in mathematics, and also by the success of high-level intermediate languages based on @map/reduce@ operations in program generators and aggressive optimizing compilers for domain-specific languages (DSLs). We further propose a novel structured heap abstraction that preserves a symbolic dimension of time, reflecting the program’s loop structure and thus unambiguously correlating multiple temporal points in the dynamic execution with a single point in the program text. This paper presents a formal model, based on a high-level intermediate analysis language, a practical realization in a prototype tool that analyzes C code, and an experimental evaluation that demonstrates competitive results on a series of benchmarks. Remarkably, our implementation achieves these results in a fully semantics-preserving strongest-postcondition model, which is a worst-case for analysis/verification. The underlying ideas, however, are not tied to this model and would equally apply in other settings, e.g., demand-driven invariant inference in a weakest-precondition model. Given its semantics-preserving nature, our implementation is not limited to analysis for verification, but can also check program equivalence, and translate legacy C code to high-performance DSLs.

Compiler-compiler of multi syntax programming languages for creating N-version software

Ensuring the reliability of the software has become increasingly complex and challenging. The most important problem is providing failure-free software operation to prevent financial losses or machinery breakdown. It can be solved with N-version programming which requires increased costs due to the use of redundant software components. In this paradigm, redundancy refers to diversity of software components. This paper discusses the implementation of software components in various languages with different syntax. We propose an efficient and time-reducing approach to the development of a multi-syntax programming language compiler. The technique of compiler parsing is based on the existing flex and bison specifications. The proposed approach makes it easier to detect errors in multi-syntax N-version software solutions, as well as reduce the likelihood of their occurrence due to the use of an automated tool, which is crucial for its implementation in an industrial setting.

An Energy-Efficient Programmable Mixed-Signal Accelerator for Machine Learning Algorithms

We propose PROMISE, the first end-to-end design of a PROgrammable MIxed-Signal accElerator from Instruction Set Architecture to high-level language compiler for acceleration of diverse machine learning algorithms by exploiting the advantage of the superior energy efficiency from analog/mixed-signal processing.

Code generator framework for smart TV platforms

In recent years, smart TVs have become more common, making them need to be included as targets for the software industry. In this study, the authors developed a code generator framework and demonstrated it in an architectural view. The proposed framework converts C# programming language based projects, in a Windows Forms or a Windows Phone Application project, into native smart TV Platform applications. The selected primary smart TV platforms assigned for application conversion were Android TV, Firefox OS, and Tizen OS. The authors enabled developers to generate native codes for all three platforms from a single code base using model to model conversion, as in the model driven architecture approach with the use of the open source Roslyn C# language compiler. The need for creating projects for every single platform to make them run on different platforms will thus be eliminated and development cycles shortened. By doing so, the time required to develop an application for each platform is reduced while keeping the generated applications’ quality as high as the original application. To show the functionality, the proposed approach is applied in three case studies. The success of the code conversion is satisfactory and converted applications are functional.

LINCE PLUS: Research Software for Behavior Video Analysis

For many years the free LINCE software has been used by many researchers needing a tool to tag behaviors using video recordings, coding behaviors and data register. However, as a research group we envisage new challenges with regards to technology novelties, designing a new tool for the future that can be used in any type of device and closely working on line. LINCE PLUS is a free systematic observational research software that will enable including new trends such as artificial intelligence, web management, collaborative work as well as complex statistical packages, such as integrating the same R language compiler inside the application. It’s time for LINCE PLUS

Introducing Certified Compilation in Education by a Functional Language Approach

Classes on compiler technology are commonly found in Computer Science curricula, covering aspects of parsing, semantic analysis, intermediate transformations and target code generation. This paper reports on introducing certified compilation techniques through a functional language approach in an introductory course on Compiler Construction. Targeting students with little or no experience in formal methods, the proof process is highly automated using the Why3 framework. Underlying logic, semantic modelling and proofs are introduced along with exercises and assignments leading up to a formally verified compiler for a simplistic imperative language. This paper covers the motivation, course design, tool selection, and teaching methods, together with evaluations and suggested improvements from the perspectives of both students and teachers.

A large-scale framework for symbolic implementations of seismic inversion algorithms in Julia

Writing software packages for seismic inversion is a very challenging task because problems such as full-waveform inversion or least-squares imaging are algorithmically and computationally demanding due to the large number of unknown parameters and the fact that waves are propagated over many wavelengths. Therefore, software frameworks need to combine versatility and performance to provide geophysicists with the means and flexibility to implement complex algorithms that scale to exceedingly large 3D problems. Following these principles, we have developed the Julia Devito Inversion framework, an open-source software package in Julia for large-scale seismic modeling and inversion based on Devito, a domain-specific language compiler for automatic code generation. The framework consists of matrix-free linear operators for implementing seismic inversion algorithms that closely resemble the mathematical notation, a flexible resilient parallelization, and an interface to Devito for generating optimized stencil code to solve the underlying wave equations. In comparison with many manually optimized industry codes written in low-level languages, our software is built on the idea of independent layers of abstractions and user interfaces with symbolic operators. Through a series of numerical examples, we determined that this allows users to implement a series of increasingly complex algorithms for waveform inversion and imaging as simple Julia scripts that scale to large-scale 3D problems. This illustrates that software based on the paradigms of abstract user interfaces and automatic code generation and makes it possible to manage the complexity of the algorithms and performance optimizations, thus providing a high-performance research and production framework.