Search

Compiler diagnostic warnings help developers identify potential programming mistakes during program compilation. However, these warnings could be erroneous due to the defects of compiler warning diagnostics. Although many techniques have been proposed to automatically generate test programs for compiler warning defect detection, the effectiveness of these techniques on defect-nding is still limited, due to their ability at generating warning-sensitive test program structures. Therefore, in this paper, we propose a DIversity-guided PROgram Mutation approach, called DIPROM, to construct diverse warning-sensitive programs for effective compiler warning defect detection. Given a seed test program, DIPROM rst removes its dead code to reduce false positive warning defects. Then, the abstract syntax tree (AST) of the test program is constructed; DIPROM iteratively mutates the structures of the AST to generate warning-sensitive program variants. To improve the diversity of program variants, DIPROM applies a novel diversity function to guide the selection of the best program variants in each iteration. With the selected program variants, differential testing is conducted to effectively detect warning defects in different compilers. In the experiments, we evaluate DIPROM with two popular C compilers (i.e., GCC and Clang). Experimental results show that DIPROM can detect 75.36% and 218.42% more warning defects than two state-of-the-art approaches (i.e., Epiphron and Csmith), respectively. Meanwhile, DIPROM is efcient, which only spends 61.14% of the time of comparative approaches on average in nding the same number of warning defects. We at last applied DIPROM on the latest development versions of GCC and Clang. After two months running, DIPROM reported 12 new warning defects; nine of them have been conrmed/xed by developers.

Educational data mining can be used in mining student’s opinion for the enhancement of learning outcomes, instruction and learning effectiveness. Based on these reasons, this study investigated the opinions of 146 first-year student of School of Computing, Universiti Teknologi Malaysia. on learning C++ programming based on skilled-based test using an online survey. The study will also investigate some issues on the zero-score awarded to students for unsuccessfully compiled program for the skilled-based. An online survey was used to collect student opinions as data because it is simple, subject-based and easy access to the students with the help of WhatsApp groups commonly used by the students for social interaction among them and their course lecturers. The result of mining students’ opinions on learning C++ programming shows that both skill-based test 1 and 2 is found to difficult or complicated. Students’ emotions on both skill-based test 1 and 2 is found to be scary. In terms of performance, the result is slightly different with respect to program compilation. The number of students with successfully compiled programs regarding skilled-based test 1 is higher than those with otherwise. So also, the number of students with successfully compiled program regarding skilled-based test 2 is higher than those with uncompiled program. In both cases, the percentage pass is greater than 50% and failure is lower than 37%. The overall result shows that Skill-based test is difficult and it, therefore, gives scary emotions to the first-year undergraduate students of School of Computing, Universiti Teknologi, Malaysia.

If the traditional deep learning framework needs to support a new operator, it usually needs to be highly optimized by experts or hardware vendors to be usable in practice, which is inefficient. The deep learning compiler has proved to be an effective solution to this problem, but it still suffers from unbearably long overall optimization time. In this paper, aiming at the XGBoost cost model in Ansor, we train a cost model based on LightGBM algorithm, which accelerates the optimization time without compromising the accuracy. Experimentation with real hardware shows that our algorithm provides 1.8× speed up in optimization over XGBoost, while also improving inference time of the deep networks by 6.1 %.

The description of the system intended for genetic programming and consisting of a large number of elementary computers is given. Commands and data are placed in a cell consisting of four fields – the first address field, the second address field, the arithmetic field and the result field. This architecture made it possible to place a software binary tree formed by commands and addresses into sequentially located cells of an elementary computer. This technique made it possible to simplify the crossover and mutation operators, as well as the coding of the problem without involving complex programming systems and supercomputers. In the future, it is planned to use table processors tested on complex problems of genetic programming to significantly reduce power consumption in on-board computers of aviation and space technology.

When a person decides to inspect or modify a third-party software project, the first necessary step is its successful compilation from source code using a build system. However, such attempts often end in failure. In this data descriptor paper, we provide a dataset of build results of open source Java software systems. We tried to automatically build a large number of Java projects from GitHub using their Maven, Gradle, and Ant build scripts in a Docker container simulating a standard programmer’s environment. The dataset consists of the output of two executions: 7264 build logs from a study executed in 2016 and 7233 logs from the 2020 execution. In addition to the logs, we collected exit codes, file counts, and various project metadata. The proportion of failed builds in our dataset is 38% in the 2016 execution and 59% in the 2020 execution. The published data can be helpful for multiple purposes, such as correlation analysis of factors affecting build success, build failure prediction, and research in the area of build breakage repair.

Program compilation is a complicated process. A compiler is a software program that translates a high-level source language program into a form ready to execute on a computer. Early in the evolution of compilers, designers introduced IRs (intermediate representations, also commonly called intermediate languages) to manage the complexity of the compilation process. The use of an IR as the compiler’s internal representation of the program enables the compiler to be broken up into multiple phases and components, thus benefiting from modularity.

The architecture of interactive systems does not match the procedural decomposition mechanisms available in most programming languages, leading to architectural mismatch. Constraint systems have been used only as black boxes for computing with primitive values of a specific type and for specific domains such as user interface layouts or program compilation. We propose constraints as a general purpose architectural connector for both describing the large-scale structure of interactive systems and matching that description with the actual implementation.

In statically-typed object-oriented languages optimization plays an important role to make program compilation faster. A number of methods have been used, and a variety of algorithms have been suggested and designed for optimization of statically typed object-oriented languages like C++ and Java. One of the important considerations inoptimization of statically typed object-oriented language is function de-virtualization. Function de-virtualization converts virtual function calls to direct calls, i.e. a virtual function call is replaced by a call to the method of some class. The direct calls can be further inlined to enhance the performance. Class hierarchy Analysis (CHA) (3) is the well-known technique used to identify the virtual calls in a program that can be converted into direct calls. The class hierarchy Analysis starts with a building a Class Hierarchy Graph (CHG) that represents the relation between the various classes of program and the visible methods within these classes. In fact the most basic data structure for developing optimization algorithms is the CHG, which abstracts the Base-derived class relationship that use virtual functions. A number of algorithms have been designed for constructingClass Hierarchy Graph (CHG) like the one designed by Bacon, D.F (1) that uses the source level information to build CHG. Several alternatives have been presented to this approach as well. In this article we will present the method for construction of CHG by reusing the RTTI (RuntimeType Identification) generated by the complier. I. Introduction and Objectives

This document mainly outlines the procedures on implementation of control of S3C2440 based embedded Linux stepping motor. Such discussion is focused on hardware design method, driving program compilation and application program compilation. It also introduces the concept of stepping motor control and analyzes structure, compilation procedure and improvement of stepping motor driving program in embedded system. Application of S3C2440 and Linux 2.6.30 based driving program can realize various controls by ARM processor of stepping motor in embedded Linux system.

This chapter covers how to use the Keil ® MDK-ARM to develop simple programs for a number of development boards. The topics covered include how to create and customize a project, the program compilation flow, how to use the IDE, and how to use some of the debug features such as using MTB for instruction trace.

This chapter covers how to use the IAR Embedded Workbench for ARM® to develop simple programs for Cortex®-M0 and Cortex-M0+ microcontrollers. The topics covered include how to create and customize a project, program compilation flow, how to use the Integration Development Environment, and how to use some of the debug features such as using MTB for instruction trace.

This chapter covers how to use the IAR Embedded Workbench for ARM ® to develop simple programs for Cortex ® -M0 and Cortex-M0+ microcontrollers. The topics covered include how to create and customize a project, program compilation flow, how to use the Integration Development Environment, and how to use some of the debug features such as using MTB for instruction trace.

Physiologically based pharmacokinetic (PBPK) models are excellent tools to aid in the extrapolation of animal data to humans. When the fate of the chemical is the same among species being compared, animal data can appropriately be considered as a model for human exposure. For methylmercury exposure, sufficient data exist to allow comparison of numerous mammalian species to humans. PBPK model validation entails obtaining blood and tissue concentrations of the parent chemical and metabolite(s) at various times following a known exposure. From ethical and practical considerations, human tissue concentrations following a known exposure to an environmental toxicant are scarce. While animal-to-human extrapolation demands that sufficient human data exist to validate the model, the validation requirements are less stringent if multiple animal models are utilized within a single model template. A versatile PBPK model was used to analyze the distribution and elimination of methylmercury and its metabolite, inorganic mercury. Uniquely, the model is formed in a generic way from a single basic template during the initial program compilation. Basic parameters are defined for diffferent PBPK models for mammalian species that span a relatively large range of sizes. In this article, the analyses include 12 species (mouse, hamster, rat, guinea pig, cat, rabbit, monkey, sheep, pig, goat, cow, and human). Allometric (weight-based) correlations of tissue binding coefficients, metabolism rate constants, and elimination parameters for both methylmercury and inorganic mercury are presented for species for which sufficient data are available. The resulting human model, in accord with the animal models, predicts relatively high inorganic mercury levels in the kidneys long after the disappearance of methylmercury from the blood.

Programmers’ mental representations of programs do not obey the order and immediate content of program texts. Multiple visible representations, or views, of programs help programmers to construct mental representations needed in, e.g., maintenance tasks. We have implemented VinEd, a language-independent editor framework that supports an unlimited number of user-definable and editable views. Views are defined by transformation programs that construct views from the original representation. VinEd extends the notion of views to any activity that can be based on the original program, e.g., program compilation. Thus VinEd can be extended to include a complete set of programming tools.

This paper describes Collabode, a web-based Java integrated development environment designed to support close, synchronous collaboration between programmers. We examine the problem of collaborative coding in the face of program compilation errors introduced by other users which make collaboration more difficult, and describe an algorithm for error-mediated integration of program code. Concurrent editors see the text of changes made by collaborators, but the errors reported in their view are based only on their own changes. Editors may run the program at any time, using only error-free edits supplied so far, and ignoring incomplete or otherwise error-generating changes. We evaluate this algorithm and interface on recorded data from previous pilot experiments with Collabode, and via a user study with student and professional programmers. We conclude that it offers appreciable benefits over naive continuous synchronization without regard to errors and over manual version control., National Science Foundation (U.S.) (award IIS- 0447800)

In this paper, we are presenting a bionic approach towards real-time systems research. Observing that a cell is both real-time computing and real-time manufacturing system, the work presented here explores the analogy between the real-time computer systems (and their management) and the molecular biology control systems. This paper is a further elaboration of the idea that the cell is governed by a real-time operating system that resides in the DNA. It also gives insight into how knowledge obtained from the biological systems could lead to further evolution and improvement of the complex human-made real-time systems.

Data flow analysis is used widely in program compilation, understanding, design, and analysis tools. In data flow analysis, problem-specific information is associated with nodes and/or edges in the flow graph representation of a program or component and re-comp\-uted iteratively. A popular data flow analysis design relies on a worklist that stores all nodes and edges whose data flow information has to be re-computed. While this approach is straightforward, it has some drawbacks. First, the presence of the worklist makes data flow algorithms centralized, which may reduce effectiveness of parallel implementations of these algorithms. Second, the worklist approach is difficult to implement in a way that minimizes the amount of information passed between flow graph nodes.In this paper, we propose to use the well-known Observer pattern for implementation of data flow analyses. We argue that such implementations are more object-oriented in nature, as well as less centralized, than worklist-based ones. We argue that by adopting this Observer-based view, data flow analyses that minimize the amount of information passed between flow graph nodes can be implemented easier than by using the worklist view. We present experimental data indicating that for some types of data flow problems, even single-threaded implementations of Observer-based data flow analysis have better run times than comparable worklist-based implementations.

For the past 10 years the Advanced Industrial Materials (AIM) has supported development of new and improved materials to enable U.S. industry to improve energy efficiency, increase productivity, and reduce waste. It has been a National Laboratory based program, with work currently under way at Oak Ridge National Laboratory, Los Alamos National Laboratory, and Sandia National Laboratories, in collaboration with industrial and university partners. With the advent of the Industries of the Future (IOF) strategy within the Office of Industrial Technologies (OIT) and the scheduled completion of the Continuous Fiber Ceramic Composites (CFCC) Program in FY 2002, an integrated materials program is being developed in OIT. So this represents the last summary of AIM research and development. The new program, Industrial Materials for the Future (IMF), will be competitive in operation, with solicitations for proposals for development of materials in accordance with the IOF Technology Roadmaps, followed by merit review and funding of the best proposals. Industry will take the lead in ''industry-specific'' research and development, in cooperation with National Laboratories, as needed. National Laboratories and universities will take the lead in maintaining a base technology program, for the purpose of maintaining a continuing flow of new materials technologies. The AIM and CFCC Programs will be replaced by the IMF program over a three year period, so that in FY 2004, all research and development will be in response to industry solicitations and Laboratory/university calls. The Program Manager believes that AIM has been an extremely successful program, thanks to the Laboratory investigators and their partners. For 10 years, the program has increased industrial participation from very little to nearly 100 percent. The CFCC Program, similarly, has been successful in advancing the knowledge of processing and property development in these materials, though much still can be done in advancing their uses in industry. It is hoped that the Industrial Materials for the Future Program will be equally successful, not only in solving industry's short-term, immediate needs, but also in maintaining a materials technology base that will lead to longer-range materials and processing developments. The projects summarized here will be carried to successful conclusions over the next 3 years and the current Laboratories in AIM and CFCC will be joined by other Laboratories, universities, and new industrial partners. The Program Manager expresses his profound appreciation for the very fine work done for OIT during the last 10 years.

Analyzing program style may be properly considered an integral part of program compilation—as successfully implemented in two style-analysis tools for Fortran 77: AUTOMARK and ASSESS. The authors look forward to the day when all major language compilers routinely provide a standard style-analysis vector for users to interpret as they see fit.

To profile the changes made to programs during development and maintenance, the authors have instrumented the 'make' utility that is used to compile and link programs. With minor modifications, they have used 'make' to find out how much time programmers spend waiting for compiling and linking, how many modules are compiled each time a program is linked, and the change in size of the compiled modules. Measurements show that most programs are relinked after only one or two modules are recompiled, and that over 90% of all recompilations yield object code that is less than 100 bytes larger in size. The authors are using these results to guide the design of an incremental programming environment, particularly with respect to an incremental linker. >

International audience; The ever-growing number of cores in embedded chips emphasizes more than ever the complexity inherent to parallel programming. To solve these programmability issues, there is a renewed interest in the dataflow paradigm. In this context, we present a compilation toolchain for the Sigma-C language, which allows the hierarchical construction of stream applications and automatic mapping of this application to an embedded manycore target. As a demonstration of this toolchain, we present an implementation of a H.264 encoder and evaluate its performance on Kalray's embedded manycore MPPA chip.

Program compilation can be formally defined as a sequence of equivalence-preserving transformations, or refinements, from high-level language programs to assembler code. Recent models also incorporate timing properties, but the resulting formalisms are intimidatingly complex. Here we take advantage of a new, simple model of real-time refinement, based on predicate transformer semantics, to present a straightforward compilation formalism that incorporates real-time constraints.

This paper reports on the implementation of a powerful data manipulation language (DML) of a data base system for minicomputers. The technique of language preprocessing is employed: The preprocessor translates each DML-statement into an internal form; however, in addition to a mere translation of statements the preprocessor has the function of executing so called 'compile-time tasks', i.e. those subtasks of the evaluation of a DML-statement, which can be done at compile-time already. This processing takes place in the course of program compilation and thus the size of the run-time module as well as execution-times can be reduced. The data base system FADABS is used to illustrate this approach.

Distributed systems offer an attractive implementation architecture for many applications, particularly those environments where the application is itself physically distributed. For the last eight years the Distributed Systems Research Group at Imperial College has conducted research into the development of an environment to support the construction and operation of distributed software. The result has been the Conic Toolkit: a comprehensive set of language and run-time tools for program compilation, building, debugging and execution in a distributed environment. Programs may be run on a set of interconnected host computers running the Unix™ operating system and/or on target machines with no resident operating system.

The Conic environment is designed to support the construction and operation of software for distributed embedded systems. It employs a host/target approach, providing a comprehensive set of tools for program compilation, building, debugging and execution on the host, and supports distributed operation on the targets. In order to provide flexibility, the environment supports dynamic configuration, the ability to reconfigure parts of the system while the rest continues to operate.

For the last eight years the Distributed Systems Research Group at Imperial College has conducted research into the development of an environment to support the construction and operation of distributed software. The result has been the Conic Toolkit: a comprehensive set of language and run-time tools for program compilation, building, debugging and execution in a distributed environment. Programs may be run on a set of interconnected host computers running the Unix operating system and/or on target machines with no resident operating system.