Program Fragments Research Articles

Automated Verification of Parametric Channel-Based Process Communication

A challenge of writing concurrent message passing programs is ensuring the absence of partial deadlocks, which can cause severe memory leaks in long running systems. Several static analysis techniques have been proposed for automatically detecting partial deadlocks in Go programs. For a large enterprise code base, we found these tools too imprecise to reason about process communication that is parametric, i.e., where the number of channel communication operations or the channel capacities are determined at runtime. We present a novel approach to automatically verify the absence of partial deadlocks in Go program fragments with such parametric process communication. The key idea is to translate Go fragments to a core language that is sufficiently expressive to represent real-world parametric communication patterns and can be encoded into Dafny programs annotated with postconditions enforcing partial deadlock freedom. In situations where a fragment is partial deadlock free only when the concurrency parameters satisfy certain conditions, a suitable precondition can often be inferred. Experimental results on a real-world code base containing 583 program fragments that are beyond the reach of existing techniques have shown that the approach can verify the absence of partial deadlocks in 145 cases. For an additional 228 cases, a nontrivial precondition is inferred that the surrounding code must satisfy to ensure partial deadlock freedom.

On the computational completeness of generalized forbidding matrix grammars

Matrix grammars are one of the first approaches ever proposed in regulated rewriting, prescribing that rules have to be applied in a certain order. In traditional regulated rewriting, the most interesting case shows up when all rules are context-free. Typical descriptional complexity measures incorporate the number of nonterminals or the length, i.e., the number of rules per matrix. When viewing matrices as program fragments, it becomes natural to consider additional applicability conditions for such matrices. Here, we focus on forbidding sets, i.e., a matrix is applicable to a sentential form w only if none of the words in its forbidding set occurs as a subword in w. This gives rise to further natural descriptional complexity measures: How long could words in forbidding sets be? How many words could be in any forbidding set? How many matrices contain non-empty forbidding contexts? As context-free grammars with forbidding sets are known as generalized forbidding grammars, we call this variant of matrix grammars also generalized forbidding. In this paper, we attempt to answer the four questions above while studying the computational completeness of generalized forbidding matrix grammars. In the course of our studies, we also define several new normal forms for type-0 grammars that might be of independent interest.

Formation of students' skills and abilities using Formulas-type test tasks in Moodle

The means of countering academic fraud in computer testing are discussed in the article. Special attention is paid to the fight against students compiling a table of correct answers to a test assignment question. It is proposed to use the technology available in Moodle to automate the generation of test task variants. Tasks of the type "Calculated" and "Formulas" are considered. The method of creating a question in a form that allows its repeated use in various random versions of the formulation both at the learning stage in order to form skills and abilities, and in the process of intermediate control is described. Using an example related to programming training, the possibilities of creating program fragments with a random set of identifiers are demonstrated, which forces the student to understand the meaning of the analyzed fragment. An example of solving a physics problem is given, which allows us to show the possibility of controlling knowledge of standard formulas and the ability to perform calculations using them.

Modeling the Interplay between Loop Tiling and Fusion in Optimizing Compilers Using Affine Relations

Loop tiling and fusion are two essential transformations in optimizing compilers to enhance the data locality of programs. Existing heuristics either perform loop tiling and fusion in a particular order, missing some of their profitable compositions, or execute ad-hoc implementations for domain-specific applications, calling for a generalized and systematic solution in optimizing compilers. In this article, we present a so-called basteln (an abbreviation for backward slicing of tiled loop nests) strategy in polyhedral compilation to better model the interplay between loop tiling and fusion. The basteln strategy first groups loop nests by preserving their parallelism/tilability and next performs rectangular/parallelogram tiling to the output groups that produce data consumed outside the considered program fragment. The memory footprints required by each tile are then computed, from which the upward exposed data are extracted to determine the tile shapes of the remaining fusion groups. Such a tiling mechanism can construct complex tile shapes imposed by the dependences between these groups, which are further merged by a post-tiling fusion algorithm for enhancing data locality without losing the parallelism/tilability of the output groups. The basteln strategy also takes into account the amount of redundant computations and the fusion of independent groups, exhibiting a general applicability. We integrate the basteln strategy into two optimizing compilers, with one a general-purpose optimizer and the other a domain-specific compiler for deploying deep learning models. The experiments are conducted on CPU, GPU, and a deep learning accelerator to demonstrate the effectiveness of the approach for a wide class of application domains, including deep learning, image processing, sparse matrix computation, and linear algebra. In particular, the basteln strategy achieves a mean speedup of 1.8× over cuBLAS/cuDNN and 1.1× over TVM on GPU when used to optimize deep learning models; it also outperforms PPCG and TVM by 11% and 20%, respectively, when generating code for the deep learning accelerator.

With or Without You: Programming with Effect Exclusion

Type and effect systems have been successfully used to statically reason about effects in many different domains, including region-based memory management, exceptions, and algebraic effects and handlers. Such systems’ soundness is often stated in terms of the absence of effects. Yet, existing systems only admit indirect reasoning about the absence of effects. This is further complicated by effect polymorphism which allows function signatures to abstract over arbitrary, unknown sets of effects. We present a new type and effect system with effect polymorphism as well as union, intersection, and complement effects. The effect system allows us to express effect exclusion as a new class of effect polymorphic functions: those that permit any effects except those in a specific set. This way, we equip programmers with the means to directly reason about the absence of effects. Our type and effect system builds on the Hindley-Milner type system, supports effect polymorphism, and preserves principal types modulo Boolean equivalence. In addition, a suitable extension of Algorithm W with Boolean unification on the algebra of sets enables complete type and effect inference. We formalize these notions in the λ ∁ calculus. We prove the standard progress and preservation theorems as well as a non-standard effect safety theorem: no excluded effect is ever performed. We implement the type and effect system as an extension of the Flix programming language. We conduct a case study of open source projects identifying 59 program fragments that require effect exclusion for correctness. To demonstrate the usefulness of the proposed type and effect system, we recast these program fragments into our extension of Flix.

The Application of Wireless Network in the Process of Remote Data Collection

The use of wireless network for remote data collection can provide a fast and reliable wireless data transmission channel for those monitoring points involving a wide area and scattered equipment layout with the help of its large coverage and high communication quality. This article analyzes the characteristics and advantages of wireless networks, and then discusses the networking scheme for remote data collection using wireless networks, and analyzes the reliability of network transmission. Finally, some program fragments on the server side are given.

Label dependent lambda calculus and gradual typing

Dependently-typed programming languages are gaining importance, because they can guarantee a wide range of properties at compile time. Their use in practice is often hampered because programmers have to provide very precise types. Gradual typing is a means to vary the level of typing precision between program fragments and to transition smoothly towards more precisely typed programs. The combination of gradual typing and dependent types seems promising to promote the widespread use of dependent types. We investigate a gradual version of a minimalist value-dependent lambda calculus. Compile-time calculations and thus dependencies are restricted to labels, drawn from a generic enumeration type. The calculus supports the usual Pi and Sigma types as well as singleton types and subtyping. It is sufficiently powerful to provide flexible encodings of variant and record types with first-class labels. We provide type checking algorithms for the underlying label-dependent lambda calculus and its gradual extension. The gradual type checker drives the translation into a cast calculus, which extends the original language. The cast calculus comes with several innovations: refined typing for casts in the presence of singletons, type reduction in casts, and fully dependent Sigma types. Besides standard metatheoretical results, we establish the gradual guarantee for the gradual language.

Use of GPS at research of roads & a vehicle

The purpose of this work are consideration of use of GPS for a research of roads and modeling of the vehicle/wheel machines (WM).Implementation for this problem of the measuring registering complex on a basis the Raspberry Pi 3/4 minicomputer, the GN-803G sensor and creation of the software in the language C/C ++ is considered.The obtained information about GPS and approaches of selection of necessary data from the messages on the basis of the NMEA 0183 standard submitted in the text ASCII form with the fields divided by a comma is analyzed. An assessment of opportunities of use of the obtained information is given.The scheme of connection of the GN-803N module to Raspberry 3/4 through the GPIO protocol is developed and proved.Reduction of the obtained data to a constant step with use of a polynom of Lagrange of the 2-nd order on three points of a variable step is considered.It is recommended at further use of this corrected data array in process modeling of the car application of a method of interpolation CatMull-Rom on the 4-th points at the fixed step. Program fragments are given in C/C ++.It is offered in the territory of RB during the determining of relative distances and a binding to cards at conversion it is possible to use the simplified linear formula lat_m= 112297,6196∙ Ddec lat , lon_m= 63215,444 ∙ Ddec lon .The offered technique of application of GPS, software, received data are planned to be used for a research of influence of the driver and road conditions on the movement of the vehicle and the subsequent their application when modeling in Matlab/ Simulink, and also in problems of preliminary debugging of management systems by self-driving vehicles.

Adding Matrix Control: Insertion-Deletion Systems with Substitutions III

Insertion-deletion systems have been introduced as a formalism to model operations that find their counterparts in ideas of bio-computing, more specifically, when using DNA or RNA strings and biological mechanisms that work on these strings. So-called matrix control has been introduced to insertion-deletion systems in order to enable writing short program fragments. We discuss substitutions as a further type of operation, added to matrix insertion-deletion systems. For such systems, we additionally discuss the effect of appearance checking. This way, we obtain new characterizations of the family of context-sensitive and the family of recursively enumerable languages. Not much context is needed for systems with appearance checking to reach computational completeness. This also suggests that bio-computers may run rather traditionally written programs, as our simulations also show how Turing machines, like any other computational device, can be simulated by certain matrix insertion-deletion-substitution systems.

A separation logic for effect handlers

User-defined effects and effect handlers are advertised and advocated as a relatively easy-to-understand and modular approach to delimited control. They offer the ability of suspending and resuming a computation and allow information to be transmitted both ways between the computation, which requests a certain service, and the handler, which provides this service. Yet, a key question remains, to this day, largely unanswered: how does one modularly specify and verify programs in the presence of both user-defined effect handlers and primitive effects, such as heap-allocated mutable state? We answer this question by presenting a Separation Logic with built-in support for effect handlers, both shallow and deep. The specification of a program fragment includes a protocol that describes the effects that the program may perform as well as the replies that it can expect to receive. The logic allows local reasoning via a frame rule and a bind rule. It is based on Iris and inherits all of its advanced features, including support for higher-order functions, user-defined ghost state, and invariants. We illustrate its power via several case studies, including (1) a generic formulation of control inversion, which turns a producer that ``pushes'' elements towards a consumer into a producer from which one can ``pull'' elements on demand, and (2) a simple system for cooperative concurrency, where several threads execute concurrently, can spawn new threads, and communicate via promises.

A modular cost analysis for probabilistic programs

We present a novel methodology for the automated resource analysis of non-deterministic, probabilistic imperative programs, which gives rise to a modular approach . Program fragments are analysed in full independence. Moreover, the established results allow us to incorporate sampling from dynamic distributions , making our analysis applicable to a wider class of examples, for example the Coupon Collector’s problem . We have implemented our contributions in the tool , exploiting a constraint-solver over iterative refineable cost functions facilitated by off-the-shelf SMT solvers. We provide ample experimental evidence of the prototype’s algorithmic power. Our experiments show that our tool runs typically at least one order of magnitude faster than comparable tools. On more involved examples, it may even be the case that execution times of seconds become milliseconds. At the same time we retain the precision of existing tools. The extensions in applicability and the greater efficiency of our prototype, yield scalability of sorts. This effects into a wider class of examples, whose expected cost analysis can be thus be performed fully automatically.

Looking-Glass Space in “Pattern Recognition” by William Gibson

The paper deals with the poetics of the novel, based on the principles of literary cyberpunk. William Gibson, the founder of cyberpunk as a genre, in the novel “Pattern Recognition” used the looking-glass image of Lewis Carroll’s book “Through The Looking-Glass And What Alice Found There” as a leitmotif, reminiscently curved and shown only in the mind of the main character Case Pollard. The paper analyzes the semantics of the leitmotif of looking-glass and its functionality in the novel, as well as the conformity with the principles of transrealism and posthumanism. The state of the main character is not explained by some acts or periods of the day, but by hormonal disorder; the scientific awareness is intertwined with the metaphoric field. Thus William Gibson’s artistic style acquires obvious features of cyberpunk. If Alice was just a weird kid who invented the world of fairy-tale creatures, Gibson’s character Case lives in a transreal world, full of various man-made modifications of space and humans.
 The modern Case-Alice does not invent anything, because the fairy-tale situation of her life is already embedded in the nature of civilizational development. Case as a heroine of the novel fully complies with the requirements of transrealism: she is not ‘normal’, she has a diagnosis and medical history. Тhe ‘F: F: F’ program (fragments) is created by an autistic Russian girl. The neurotic characters that Case meets are atypical, all in their own way. That is why the world around modern Alice, who is Case at the same time, is distorted by the abnormality, which is not hidden by the heroes. The cyberspace of modern human existence transforms all the sores of society into customary artificial symbols of degradation – posthumanistic codes.

Zelio Logic Control System for Horizontal Hydraulic Press

Summary Modernization of control system of Horizontal hydraulic press of model 2240D with the usage of programmable logical controller, namely intellectual relay Zelio Logic is considered. The consequence of technological operations fulfillment such as pressing, non-formal control algorithm, choice motivation of PLC model SR3B261B, control program fragment in the FBD language is given.

Program algebra for quantitative information flow

Models for quantitative information flow traditionally assume that the secret, once set, never changes. More recently, however, Hidden Markov Models (HMM's) have been used to describe program features that include both state updates and information flow, thus supporting more realistic contexts where secrets can indeed be refreshed.In this paper we explore HMM's further, with the aim of bringing algebraic concepts to bear in the analysis of confidentiality properties of programs. Of particular importance is the idea that local reasoning about program fragments should remain sound even when those same fragments are executed within a larger system. We show how to extend the basic HMM model to incorporate this core idea within an algebraic setting and, in so doing, show how it is related to established notion about privacy and correlated data sets in statistical databases.Using our algebra for an HMM-style model we show how to describe and prove some foundational properties of quantitative information flow.

PLANNING OF DOWNLOAD PROCESSORS IN MULTIPROCESSOR SYSTEMS OF CRITICAL PURPOSE

At present, multiprocessor systems of a critical nature are widely used. Such systems are used for tracking, aiming, observing, etc. Such tasks, as a rule, require maximizing productivity and reducing the time to solve a problem. For these purposes, the initial selection of non-dependent linear, conditional and cyclic sections of sequential programs is used [1]. This is done to release fragments of programs that can be assigned to execution on processors in such a way that during execution they exchange data with neighboring processors as little as possible. Due to this, it is possible to partially improve the performance of a multiprocessor computing system, together with a decrease in the overall execution time of the entire task as a whole. For systems of the considered nature of the processor of the entire system, it is desirable to assign program fragments so that they are constantly loaded throughout the solution of the entire problem. This is another way to improve the performance of a multiprocessor system. It is obvious that the use of software for this purpose is not real due to the criticality of the time parameter. Therefore, it is relevant to use methods and corresponding hardwareoriented algorithms for scheduling processor loads, which is the subject of research in this article. The article shows the relevance of the constant loading of processors of multiprocessor systems with a high availability factor. The necessity of drawing up a plan for loading processors to support this coefficient is substantiated. An appropriate method and algorithm for multiprocessor systems for critical purposes (tracking systems, surveillance, aiming, etc.) are proposed.

TrABin: Trustworthy analyses of binaries

Verification of microkernels, device drivers, and crypto routines requires analyses at the binary level. In order to automate these analyses, in the last years several binary analysis platforms have been introduced. These platforms share a common design: the adoption of hardware-independent intermediate representations, a mechanism to translate architecture dependent code to this representation, and a set of architecture independent analyses that process the intermediate representation. The usage of these platforms to verify software introduces the need for trusting both the correctness of the translation from binary code to intermediate language (called transpilation) and the correctness of the analyses. Achieving a high degree of trust is challenging since the transpilation must handle (i) all the side effects of the instructions, (ii) multiple instruction encodings (e.g. ARM Thumb), and (iii) variable instruction length (e.g. Intel). Similarly, analyses can use complex transformations (e.g. loop unrolling) and simplifications (e.g. partial evaluation) of the artifacts, whose bugs can jeopardize correctness of the results. We overcome these problems by developing a binary analysis platform on top of the interactive theorem prover HOL4. First, we formally model a binary intermediate language and we prove correctness of several supporting tools (i.e. a type checker). Then, we implement two proof-producing transpilers, which respectively translate ARMv8 and CortexM0 programs to the intermediate language and generate a certificate. This certificate is a HOL4 proof demonstrating correctness of the translation. As demonstrating analysis, we implement a proof-producing weakest precondition generator, which can be used to verify that a given loop-free program fragment satisfies a contract. Finally, we use an AES encryption implementation to benchmark our platform.

Multi-trajectory Fitness Function-based Method of Automated Test Coverage for Code Using Evolutionary Algorithms

Testing is a time consuming and resource intensive task. Testing often takes about half of the total project development time.Hence, in recent times, a lot of studies have considered the issues of the process automation of creating and running tests. Recently, a lot of papers have been published in the field concerned. However, most of them use unit testing, in which the coverage of different program fragments occurs independently of each other. Therefore, the internal structure of the program was not taken into account.The article presents a method to build a test suite based on evolutionary algorithms that takes into account the features of the entire program, as a whole.Evolutionary algorithms are a class of optimization algorithms that has been widely developed lately, using the ideas of artificial intelligence and intended for conducting directed search. They allow successful solving the problems of software testing, such as testing embedded systems and automatic construction of unit tests.With implementing evolutionary approach the article has solved the following tasks. Proposed a method for determining the fitness function, which allows us to consider an approximation along all possible trajectories, which provides a solution to the problem of coverage in almost any case. However, the number of such trajectories can be quite large, which leads to a significant increase in test execution time. Proposed a method of approximation along all possible trajectories, allowing testing to be done in a reasonable time. Time costs to achieve the goal are reduced by selecting such a trajectory among all possible ones for which a distance value to the instruction is minimal.To study the proposed method, there were four different tasks each of which involved about 1000 runs. The presented research results have shown that the given method is more reliable than the commonly used approaches in which the reference trajectory is selected. In addition, an estimate of time costs has shown that the discussed method has higher efficiency.

Verified three-way program merge

Even though many programmers rely on 3-way merge tools to integrate changes from different branches, such tools can introduce subtle bugs in the integration process. This paper aims to mitigate this problem by defining a semantic notion of conflict-freedom, which ensures that the merged program does not introduce new unwanted behaviors. We also show how to verify this property using a novel, compositional algorithm that combines lightweight summarization for shared program fragments with precise relational reasoning for the modifications. Towards this goal, our method uses a 4-way differencing algorithm on abstract syntax trees to represent different program versions as edits applied to a shared program with holes. This representation allows our verification algorithm to reason about different edits in isolation and compose them to obtain an overall proof of conflict freedom. We have implemented the proposed technique in a new tool called SafeMerge for Java and evaluate it on 52 real-world merge scenarios obtained from Github. The experimental results demonstrate the benefits of our approach over syntactic conflict-freedom and indicate that SafeMerge is both precise and practical.

Cluster Programming using the OpenMP Accelerator Model

Computation offloading is a programming model in which program fragments (e.g., hot loops) are annotated so that their execution is performed in dedicated hardware or accelerator devices. Although offloading has been extensively used to move computation to GPUs, through directive-based annotation standards like OpenMP, offloading computation to very large computer clusters can become a complex and cumbersome task. It typically requires mixing programming models (e.g., OpenMP and MPI) and languages (e.g., C/C++ and Scala), dealing with various access control mechanisms from different cloud providers (e.g., AWS and Azure), and integrating all this into a single application. This article introduces computer cluster nodes as simple OpenMP offloading devices that can be used either from a local computer or from the cluster head-node. It proposes a methodology that transforms OpenMP directives to Spark runtime calls with fully integrated communication management, in a way that a cluster appears to the programmer as yet another accelerator device. Experiments using LLVM 3.8, OpenMP 4.5 on well known cloud infrastructures (Microsoft Azure and Amazon EC2) show the viability of the proposed approach, enable a thorough analysis of its performance, and make a comparison with an MPI implementation. The results show that although data transfers can impose overheads, cloud offloading from a local machine can still achieve promising speedups for larger granularity: up to 115× in 256 cores for the2MMbenchmark using 1GB sparse matrices. In addition, the parallel implementation of a complex and relevant scientific application reveals a 80× speedup on a 320 core machine when executed directly from the headnode of the cluster.

Finding root causes of floating point error

Floating-point arithmetic plays a central role in science, engineering, and finance by enabling developers to approximate real arithmetic. To address numerical issues in large floating-point applications, developers must identify root causes, which is difficult because floating-point errors are generally non-local, non-compositional, and non-uniform. This paper presents Herbgrind, a tool to help developers identify and address root causes in numerical code written in low-level languages like C/C++ and Fortran. Herbgrind dynamically tracks dependencies between operations and program outputs to avoid false positives and abstracts erroneous computations to simplified program fragments whose improvement can reduce output error. We perform several case studies applying Herbgrind to large, expert-crafted numerical programs and show that it scales to applications spanning hundreds of thousands of lines, correctly handling the low-level details of modern floating point hardware and mathematical libraries and tracking error across function boundaries and through the heap.