C-like Language Research Articles

A formal model of Checked C1

We present a formal model of Checked C, a dialect of C that aims to enforce spatial memory safety. Our model pays particular attention to the semantics of dynamically sized, potentially null-terminated arrays. We formalize this model in Coq, and prove that any spatial memory safety errors can be blamed on portions of the program labeled unchecked; this is a Checked C feature that supports incremental porting and backward compatibility. While our model’s operational semantics uses annotated (“fat”) pointers to enforce spatial safety, we show that such annotations can be safely erased. Using PLT Redex we formalize an executable version of our model and a compilation procedure to an untyped C-like language, as well as use randomized testing to validate that generated code faithfully simulates the original. Finally, we develop a custom random generator for well-typed and almost-well-typed terms in our Redex model, and use it to search for inconsistencies between our model and the Clang Checked C implementation. We find these steps to be a useful way to co-develop a language (Checked C is still in development) and a core model of it.

Armada: Automated Verification of Concurrent Code with Sound Semantic Extensibility

Safely writing high-performance concurrent programs is notoriously difficult. To aid developers, we introduce Armada, a language and tool designed to formally verify such programs with relatively little effort. Via a C-like language and a small-step, state-machine-based semantics, Armadagives developers the flexibility to choose arbitrary memory layout and synchronization primitives so that they are never constrained in their pursuit of performance. To reduce developer effort, Armadaleverages SMT-powered automation and a library of powerful reasoning techniques, including rely-guarantee, TSO elimination, reduction, and pointer analysis. All of these techniques are proven sound, and Armadacan be soundly extended with additional strategies over time. Using Armada, we verify five concurrent case studies and show that we can achieve performance equivalent to that of unverified code.

IMPROVING ECONOMIC AND TECHNICAL EFFICIENCY OF PROCEDURAL PROGRAMMING IN COMPILABLE, STATICALLY TYPED C-LIKE LANGUAGES ACCORDING TO THE SPEED OF THE PROCESS AND THE STABILITY OF THE PROGRAM IMPLEMENTATION

In the modern IT industry, there is a trend towards languages with high performance. The products implemented through them become more efficient and energy-saving. However, these languages have a number of disadvantages based on their technical implementation. These defects create side problems over time and increase the cost of implementing, securing, configuring, and extending the functionality of the product. Thus, the product becomes more expensive from a financial point of view, but more competitive. In order to further increase the competitiveness of products, to neutralize side problems, to reduce the cost, companies listed in international indexes and universities with global scientific qualifications either develop a new language, or update and add new functionality to the already existing language. The article presents recommendations for compilable, statically typed, C-like languages to make their procedural programming safer. They will ensure readability and increase the speed of the process. These changes will make IT products more competitive in the free market. The advantage of recommendations is that the most time-consuming checks and decisions will be made at compile time. There are some examples of the changes in the article.

Copy-and-patch compilation: a fast compilation algorithm for high-level languages and bytecode

Fast compilation is important when compilation occurs at runtime, such as query compilers in modern database systems and WebAssembly virtual machines in modern browsers. We present copy-and-patch, an extremely fast compilation technique that also produces good quality code. It is capable of lowering both high-level languages and low-level bytecode programs to binary code, by stitching together code from a large library of binary implementation variants. We call these binary implementations stencils because they have holes where missing values must be inserted during code generation. We show how to construct a stencil library and describe the copy-and-patch algorithm that generates optimized binary code. We demonstrate two use cases of copy-and-patch: a compiler for a high-level C-like language intended for metaprogramming and a compiler for WebAssembly. Our high-level language compiler has negligible compilation cost: it produces code from an AST in less time than it takes to construct the AST. We have implemented an SQL database query compiler on top of this metaprogramming system and show that on TPC-H database benchmarks, copy-and-patch generates code two orders of magnitude faster than LLVM -O0 and three orders of magnitude faster than higher optimization levels. The generated code runs an order of magnitude faster than interpretation and 14% faster than LLVM -O0. Our WebAssembly compiler generates code 4.9X-6.5X faster than Liftoff, the WebAssembly baseline compiler in Google Chrome. The generated code also outperforms Liftoff's by 39%-63% on the Coremark and PolyBenchC WebAssembly benchmarks.

Selected tools for Java class and bytecode inspection in the educational environment

Abstract Java is not only a modern, powerful, and frequently used programming language, but together with Java Virtual Machine it represents a novel dynamic approach of writing and executing computer programs. The fact that Java programs are executed in a controlled environment has several important implications that define the nature of the language and makes it different from the traditional C-like languages. Knowing the detailed differences between the two types of languages and execution environments is a part of the holistic education of a computer engineer. In this paper, we present some behind-the-scene details about the Java Virtual Machine and we show how these details could be used in the educational process to demonstrate the differences and to emphasise the advantages of the dynamic programming approach when compared to the static one. After presenting some information about class files and about the internal structure and operation of the Java Virtual Machine we demonstrate the usage of public domain programs that could be used in the educational process to put these theoretical concepts into practice.

TinyLink

Rapid development is essential for IoT (Internet of Things) application developers to obtain first-mover advantages and reduce the development cost. In this article, we present TinyLink, a holistic system for rapid development of IoT applications. The key idea of TinyLink is to use a top-down approach for designing both the hardware and the software of IoT applications. Developers write the application code in a C-like language to specify the key logic of their applications, without dealing with the details of the specific hardware components. Taking the application code as input, TinyLink automatically generates the hardware configuration as well as the binary program executable on the target hardware platform. TinyLink provides unified APIs for applications to interact with the underlying hardware components. We implement TinyLink and evaluate its performance using real-world IoT applications. Results show that (1) TinyLink achieves rapid development of IoT applications, reducing 52.58% of lines of code on average compared with traditional approaches; (2) TinyLink searches a much larger design space and thus can generate a superior solution for the hardware configuration, compared with the state-of-the-art approach; (3) TinyLink incurs acceptable overhead in terms of execution time and program memory.

Clone detection in student programs based on lexical analysis of source codes

This article presents the development of automatic clone detection for verification students programs - the Detector of Clones. The Levenshtein Distance is used for the initial assessment of the similarity of the two token sequences which is calculated by the Wagner-Fisher algorithm. Verification of two programs is carried out by the fingerprint method and by the winnowing method. To improve the results of plagiarism assessment, an additional calculation was added to the implementation of the winnowing method: the detector compares not only the labels themselves, but also the sequences near the matching labels. The detector of clones is formed for the cycle of disciplines Object Oriented Programming, Object Oriented Analysis and Design on the Moodle platform. These tools support C-like languages (C++ and C#). In general, the work of the detector undoubtedly made it possible to increase the consistency in verification of student programs.

Automatically generating features for learning program analysis heuristics for C-like languages

We present a technique for automatically generating features for data-driven program analyses. Recently data-driven approaches for building a program analysis have been developed, which mine existing codebases and automatically learn heuristics for finding a cost-effective abstraction for a given analysis task. Such approaches reduce the burden of the analysis designers, but they do not remove it completely; they still leave the nontrivial task of designing so called features to the hands of the designers. Our technique aims at automating this feature design process. The idea is to use programs as features after reducing and abstracting them. Our technique goes through selected program-query pairs in codebases, and it reduces and abstracts the program in each pair to a few lines of code, while ensuring that the analysis behaves similarly for the original and the new programs with respect to the query. Each reduced program serves as a boolean feature for program-query pairs. This feature evaluates to true for a given program-query pair when (as a program) it is included in the program part of the pair. We have implemented our approach for three real-world static analyses. The experimental results show that these analyses with automatically-generated features are cost-effective and consistently perform well on a wide range of programs.

High-level synthesis for FPGAs: code optimization strategies for real-time image processing

High-level synthesis (HLS) is a potential solution to increase the productivity of FPGA-based real-time image processing development. It allows designers to reap the benefits of hardware implementation directly from the algorithm behaviors specified using C-like languages with high abstraction level. In order to close the performance gap between the manual and HLS-based FPGA designs, various code optimization forms are made available in today’s HLS tools. This paper proposes a HLS source code and directive manipulation strategy for real-time image processing by taking into account the applying order of different optimization forms. Experiment results demonstrate that our approach can improve more effectively the test implementations comparing to the other optimization strategies.

Students’ perspective on the first programming language: C-like or Pascal-like languages?

The choice of the first programming language (FPL) has been a controversial issue for several decades. Nearly everyone agrees that the FPL is important and affects students’ subsequent education on programming. The study presented in this article investigates the suitability of various C-like and Pascal-like programming languages as a FPL. Students from three Universities express their perceptions on the FPL through a specially designed questionnaire. The students had been introduced to programming using different FPLs and having experience on more than one language and formulated two distinct groups: a group introduced to programming with a C-like and another with a Pascal-like language. The statistical analysis of the data collected showed that the choice of the FPL does not have a deep impact on difficulties that novices may experience when learning the basics of programming. However, this result was recorded in the context of three distinct programming courses that were positively evaluated by students in relation to their content, organization and quality. Consequently, this study indicates that the overall quality of the course and the instructors have a great impact on a smooth introduction to programming no matter what the FPL is.

Does Python Smell Like Java? Tool Support for Design Defect Discovery in Python

The context of this work is specification, detection and ultimately removal of detectable harmful patterns in source code that are associated with defects in design and implementation of software. In particular, we investigate five code smells and four antipatterns previously defined in papers and books. Our inquiry is about detecting those in source code written in Python programming language, which is substantially different from all prior research, most of which concerns Java or C-like languages. Our approach was that of software engineers: we have processed existing research literature on the topic, extracted both the abstract definitions of nine design defects and their concrete implementation specifications, implemented them all in a tool we have programmed and let it loose on a huge test set obtained from open source code from thousands of GitHub projects. When it comes to knowledge, we have found that more than twice as many methods in Python can be considered too long (statistically extremely longer than their neighbours within the same project) than in Java, but long parameter lists are seven times less likely to be found in Python code than in Java code. We have also found that Functional Decomposition, the way it was defined for Java, is not found in the Python code at all, and Spaghetti Code and God Classes are extremely rare there as well. The grounding and the confidence in these results comes from the fact that we have performed our experiments on 32'058'823 lines of Python code, which is by far the largest test set for a freely available Python parser. We have also designed the experiment in such a way that it aligned with prior research on design defect detection in Java in order to ease the comparison if we treat our own actions as a replication. Thus, the importance of the work is both in the unique open Python grammar of highest quality, tested on millions of lines of code, and in the design defect detection tool which works on something else than Java.

Design and Implementation of Concurrent C0

We describe Concurrent C0, a type-safe C-like language with contracts and session-typed communication over channels. Concurrent C0 supports an operation called forwarding which allows channels to be combined in a well-defined way. The language's type system enables elegant expression of session types and message-passing concurrent programs. We provide a Go-based implementation with language based optimizations that outperforms traditional message passing techniques.

Towards a Semantics-Aware Code Transformation Toolchain for Heterogeneous Systems

Obtaining good performance when programming heterogeneous computing platforms poses significant challenges. We present a program transformation environment, implemented in Haskell, where architecture-agnostic scientific C code with semantic annotations is transformed into functionally equivalent code better suited for a given platform. The transformation steps are represented as rules that can be fired when certain syntactic and semantic conditions are fulfilled. These rules are not hard-wired into the rewriting engine: they are written in a C-like language and are automatically processed and incorporated into the rewriting engine. That makes it possible for end-users to add their own rules or to provide sets of rules that are adapted to certain specific domains or purposes.

Lightweight, generative variant exploration for high-performance graphics Applications

Rendering performance is an everlasting goal of computer graphics and significant driver for advances in both, hardware architecture and algorithms. Thereby, it has become possible to apply advanced computer graphics technology even in low-cost embedded appliances, such as car instruments. Yet, to come up with an efficient implementation, developers have to put enormous efforts into hardware/problem-specific tailoring, fine-tuning, and domain exploration, which requires profound expert knowledge. If a good solution has been found, there is a high probability that it does not work as well with other architectures or even the next hardware generation. Generative DSL-based approaches could mitigate these efforts and provide for an efficient exploration of algorithmic variants and hardware-specific tuning ideas. However, in vertically organized industries, such as automotive, suppliers are reluctant to introduce these techniques as they fear loss of control, high introduction costs, and additional constraints imposed by the OEM with respect to software and tool-chain certification. Moreover, suppliers do not want to share their generic solutions with the OEM, but only concrete instances. To this end, we propose a light-weight and incremental approach for meta programming of graphics applications. Our approach relies on an existing formulation of C-like languages that is amenable to meta programming, which we extend to become a lightweight language to combine algorithmic features. Our method provides a concise notation for meta programs and generates easily sharable output in the appropriate C-style target language.

Rewriting Semantics and Analysis of Concurrency Features for a C-like Language

This paper shows how one can easily transform K definitions of programming languages into runtime verification tools. To increase the confidence that these runtime verification tools can be used for testing real-world programs, the paper uses KernelC, a subset of the C programming language containing functions, memory allocation, pointer arithmetic, and input/output, which can be used to execute and test real C programs. KernelC is extended with threads and synchronization constructs, and two concurrent semantics are derived from its sequential semantics. The first semantics, defining a sequentially consistent memory model, can be easily transformed into a runtime verification tool for checking datarace and deadlock freeness. The second semantics defines in a relatively minimal fashion a relaxed memory model based on the x86-TSO memory model. By exploring the executions of an implementation of Peterson's mutual exclusion algorithm for both definitions, it is shown that the algorithm guarantees mutual exclusion for the sequentially consistent model, but cannot guarantee it for the relaxed model, but also that by allowing fence operations in the language, the algorithm can be fixed and proven correct for the TSO model, too.

The bedrock structured programming system

We report on the design and implementation of an extensible programming language and its intrinsic support for formal verification. Our language is targeted at low-level programming of infrastructure like operating systems and runtime systems. It is based on a cross-platform core combining characteristics of assembly languages and compiler intermediate languages. From this foundation, we take literally the saying that C is a "macro assembly language": we introduce an expressive notion of certified low-level macros, sufficient to build up the usual features of C and beyond as macros with no special support in the core. Furthermore, our macros have integrated support for strongest postcondition calculation and verification condition generation, so that we can provide a high-productivity formal verification environment within Coq for programs composed from any combination of macros. Our macro interface is expressive enough to support features that low-level programs usually only access through external tools with no formal guarantees, such as declarative parsing or SQL-inspired querying. The abstraction level of these macros only imposes a compile-time cost, via the execution of functional Coq programs that compute programs in our intermediate language; but the run-time cost is not substantially greater than for more conventional C code. We describe our experiences constructing a full C-like language stack using macros, with some experiments on the verifiability and performance of individual programs running on that stack.

A novel reconfigurable data-flow architecture for real time video processing

This paper describes a dynamically reconfigurable data-flow hardware architecture optimized for the computation of image and video. It is a scalable hierarchically organized parallel architecture that consists of data-flow clusters and finite-state machine (FSM) controllers. Each cluster contains various kinds of cells that are optimized for video processing. Furthermore, to facilitate the design process, we provide a C-like language for design specification and associated design tools. Some video applications have been implemented in the architecture to demonstrate the applicability and flexibility of the architecture. Experimental results show that the architecture, along with its video applications, can be used in many real-time video processing.

Design and implementation of sparse global analyses for C-like languages

In this article we present a general method for achieving global static analyzers that are precise, sound, yet also scalable. Our method generalizes the sparse analysis techniques on top of the abstract interpretation framework to support relational as well as non-relational semantics properties for C-like languages. We first use the abstract interpretation framework to have a global static analyzer whose scalability is unattended. Upon this underlying sound static analyzer, we add our generalized sparse analysis techniques to improve its scalability while preserving the precision of the underlying analysis. Our framework determines what to prove to guarantee that the resulting sparse version should preserve the precision of the underlying analyzer. We formally present our framework; we present that existing sparse analyses are all restricted instances of our framework; we show more semantically elaborate design examples of sparse non-relational and relational static analyses; we present their implemen- tation results that scale to analyze up to one million lines of C programs. We also show a set of implementation techniques that turn out to be critical to economically support the sparse analysis process.

Extending a C-like language for portable SIMD programming

SIMD instructions are common in CPUs for years now. Using these instructions effectively requires not only vectorization of code , but also modifications to the data layout . However, automatic vectorization techniques are often not powerful enough and suffer from restricted scope of applicability; hence, programmers often vectorize their programs manually by using intrinsics: compiler-known functions that directly expand to machine instructions. They significantly decrease programmer productivity by enforcing a very error-prone and hard-to-read assembly-like programming style. Furthermore, intrinsics are not portable because they are tied to a specific instruction set. In this paper, we show how a C-like language can be extended to allow for portable and efficient SIMD programming. Our extension puts the programmer in total control over where and how control-flow vectorization is triggered. We present a type system and a formal semantics of our extension and prove the soundness of the type system. Using our prototype implementation IVL that targets Intel's MIC architecture and SSE instruction set, we show that the generated code is roughly on par with handwritten intrinsic code.

Study on an Integrated Development Environment for PAC with Complete Intellectual Property

PAC(programmable automation controller) is a new trend of the industrial controller, but for now, most IDEs(integrated development environment) are still providing the PLC mode for users, which can not take full advantage of the PAC. Further more, in China, there is still not such IDE with complete intellectual properties for PACs designed by Chinese companies. For above purposes, the CHD-PACIDE was implemented which supported the ARM cortex-Mx series microcontrollers. This IDE consists of three layers, interface layer, data management layer and kernel layer, which managed functional modules respectively. Based on a C-like language Engineer C defined by our research team, the interface layer provided the structural graphical input mode and the text input mode for users to edit their code. The data management layer used the XML with specified format manage the flow of data. The kernel layer had two parts which were implemented in the IDE and the debug microcontroller stm8s, this layer can be used to debug user’s code through the Jtag port under the Coresight debugging structure of ARM. This IDE could be updated easily by adding the specific XML file for the new microcontroller used by the specific PAC.