Miri: Practical Undefined Behavior Detection for Rust

The SYMBOL 2R Computing System represents an attempt to bridge the gap between machine languages and higher level programming languages. This gap has always limited the users' ability to communicate with the machine, thus creating a communication problem. Early attempts at solving this communication problem consisted of developing a series of user-oriented programming languages, i.e., assembler languages and higher level languages, supplemented with a host of translator programs that would transform the higher level languages into machine language. For several years it seemed that this approach represented the only economically feasible solution. In 1965, W. H. Burkhardt (2) suggested the development of high-level language computers Burkhardt did suggest that the availability of low cost components would make high-level language computers an economically feasible solution. In fact, the recent decline in the cost of components as compared with the steady, if not increasing cost of the software needed to develop and maintain compilers for high-level languages, has made the high-level language computer solution seem even more attractive.

The Fortran (FORmula TRANslating) computer language was the result of a project begun by John Backus at IBM in 1954. The goal of this project was to provide a way for programmers to express mathematical formulas through a formalism that computers could translate into machine instructions. Initially there was a great deal of skepticism about the efficacy of such a scheme. “How,’’ the scientists asked, “would anyone be able to tolerate the inefficiencies that would result from compiled code?’’ But, as it turned out, the first compilers were surprisingly good, and programmers were able, for the first time, to express mathematics in a high-level computer language. Fortran has evolved continually over the years in response to the needs of users, particularly in the areas of mathematical expressivity, program maintainability, hardware control (such as I/O), and, of course, code optimizations. In the meantime, other languages such as C and C11 have been designed to better meet the nonmathematical aspects of software design, such as graphical interfaces and complex logical layouts. These languages have caught on and have gradually begun to erode the scientific/engineering Fortran code base. By the 1980s, pronouncements of the “death of Fortran” prompted language designers to propose extensions to Fortran that would incorporate the best features of other high-level languages and, in addition, provide new levels of mathematical expressivity popular on supercomputers such as the CYBER 205 and the CRAY systems. This language became standardized as Fortran 90 (ISO/IEC 1539: 1991; ANSI X3.1981992). At the present time, Fortran 95, which includes many of the parallelization features of High Performance Fortran discussed later in this paper, is in the final stages of standardization. It is not yet clear whether the modernization of Fortran can, of itself, stem the C tide. However, I will demonstrate in this paper that modern Fortran is a viable mainstream language for parallelism. It is true that parallelism is not yet part of the scientific programming mainstream. However, it seems likely that, with the scientists’ never-ending thirst for affordable performance, parallelism will become much more common—especially

High-level-language (HLL) computer architecture refers to those architecture which can accept one or more high-level languages (such as Fortran, Alogl, Snobol, etc.). This paper classifies the HLL computer architecture into four types (von Neumann architecture, syntax-oriented architecture, indirect execution architecture, and direct execution architecture) based on the criterion of proximity in lexicality, syntax and semantics between the high-level language and the machine language. It then introduce es concepts of these high-level-language architecture. A simple example is employed to illustrate the differences among these four types of architecture.

Machine language decompilation is the translation of machine (assembly) language instruction sequences into statements in a high-level algebraic language such as PL/1. This process can be viewed as the inverse of compilation. Decompilation can be used as an aid for program conversion and program documentation. A general methodology for decompilation that is independent of a particular source and target language is presented. The basic approach is to map the source machine language to a high-level representation, which is relatively machine and language independent, and then translate to the chosen target language. An experimental decompiler was implemented to translate Knuth's MIXAL assembly language into PL/1.

Despite significant achievements in the artificial narrow intelligence sphere, the mechanisms of human-like (general) intelligence are still undeveloped. There is a theory stating that the human brain extracts the meaning of information rather than recognizes the features of a phenomenon. Extracting the meaning is finding a set of transformation rules (context) and applying them to the incoming information, producing an interpretation. Then, the interpretation is compared to something already seen and is stored in memory. Information can have different meanings in different contexts. A mathematical model of a context processor and a differential contextual space which can perform the interpretation is discussed and developed in this paper. This study examines whether the basic principles of differential contextual spaces work in practice. The model is developed with Rust programming language and trained on black and white images which are rotated and shifted both horizontally and vertically according to the saccades and torsion movements of a human eye. Then, a picture that has never been seen in the particular transformation, but has been seen in another one, is exposed to the model. The model considers the image in all known contexts and extracts the meaning. The results show that the program can successfully process black and white images which are transformed by shifts and rotations. This research prepares the grounding for further investigations of the contextual model principles with which general intelligence might operate.

A wide range of astrophysical sources exhibit extreme and rapidly varying electromagnetic emission indicative of efficient nonthermal particle acceleration. Understanding these sources often involves comparing data with a broad range of theoretical scenarios. To this end, it is beneficial to have tools that enable not only fast and efficient parametric investigation of the predictions of a specific scenario but also the flexibility to explore different theoretical ideas. In this paper, we introduce Tleco, a versatile and lightweight toolkit for developing numerical models of relativistic outflows, including their particle acceleration mechanisms and resultant electromagnetic signature. Built on the Rust programming language and wrapped into a Python library, Tleco offers efficient algorithms for evolving relativistic particle distributions and for solving the resulting emissions in a customizable fashion. Tleco uses a fully implicit discretization algorithm to solve the Fokker–Planck equation with user-defined diffusion, advection, cooling, injection, and escape and offers prescriptions for radiative emission and cooling. These include, but are not limited to, synchrotron, inverse-Compton, and self-synchrotron absorption. Tleco is designed to be user friendly and adaptable to model particle acceleration and the resulting electromagnetic spectrum and temporal variability in a wide variety of astrophysical scenarios, including, but not limited to, gamma-ray bursts, pulsar wind nebulae, and jets from active galactic nuclei. In this work, we outline the core algorithms and proceed to evaluate and demonstrate their effectiveness. The code is open source and available in the GitHub repository: https://github.com/zkdavis/Tleco.

The paper presents a compiler, named Rasti, developed witth the Rustemo library. Compiler name Rasti was chosen, because it is implemented in the Rust programming language. This work provides the theoretical foundation for all phases of compilation realized in Rasti, namely lexical, syntax and semantic analysis, with the greatest focus on syntax analysis. Rasti consists of a lexical analyzer (implemented manually and generated with Rustemo), a syntax analyzer (also implemented manually and generated with Rustemo), a semantic analyzer and an evaluator.

A Wireless Sensor and Actor Network (WSAN) is a group of wireless devices with the ability to sense physical events (sensors) or/and to perform relatively complicated actions (actors), based on the sensed data shared by sensors. This paper presents design and implementation of a simulation system based on Deep Q-Network (DQN) for actor node mobility control in WSANs. DQN is a deep neural network structure used for estimation of Q-value of the Q-learning method. We implemented the proposed simulating system by Rust programming language. We evaluated the performance of proposed system for normal and uniform distributions of events considering three-dimensional environment. For this scenario, the simulation results show that for normal distribution of events and the best episode all actor nodes are connected.

Prediction and convergence are techniques used to reduce the network traffic between multiple distributed simulation applications that individually maintain a representation of a virtual "world" that includes moving entities. Prediction (often using dead reckoning algorithms) is an approach to estimate the position and orientation of "remote" entities hosted and/or managed by other simulation applications executing within the distributed system. Estimates are made (i.e., calculated) using previously received data, such as velocity and acceleration. As new data is received, a convergence algorithm is often used to update the remote entity’s position and orientation within the represented world. The term "convergence" is often times referred to as "blending" or "smoothing" as its goal is to avoid visually obvious disjointed "jumps" in movement as updates are received.This work implements the dead reckoning estimation algorithms defined in the IEEE standard for Distributed Interactive Simulation (DIS) in software using the Rust programming language and the NAlgebra GLM package (i.e., crate/library). It also implements a simple convergence algorithm to move entities to their correct locations and orientations. This work is part of a larger design effort to prototype a DIS-compatible interoperability network interface, organized using an Entity-Component-System (ECS).

To aid in computer architecture education, this paper introduces a new Intel 8085 processor simulator built in the Rust programming language. The project’s primary motivation is to leverage a new accumulator-based simulator to compose a set of educational tools based on different architectures. Our simulator offers a high-delity emulation of the 8085 architecture, featuring both a terminal and a graphical user interface to cater to diverse learning styles. It includes an integrated assembler and powerful debugging capabilities, most notably a time-travel function that allows users to step both forwards and backwards through their program’s execution. The result is a modern, cross-platform, and open-source simulator designed to provide a comprehensive and safe environment for learning low-level computing concepts.

Zero Trust Architecture requirements are of increasing importance in critical systems development. Zero trust tenets hold that no implicit trust be granted to assets based on their physical or network location. Zero Trust development focuses on authentication, authorization, and shrinking implicit trust zones to the most granular level possible, while maintaining availability and minimizing authentication latency. Performant, high-assurance cryptographic primitives are thus central to successfully realizing a Zero Trust Architecture. The Rust programming language has garnered significant interest and use as a modern, type-safe, memory-safe, and potentially formally analyzable programming language. Our interest in Rust particularly stems from its potential as a hardware/software co-assurance language for developing Zero Trust Architectures. We describe a novel environment enabling Rust to be used as a High-Level Synthesis (HLS) language, suitable for secure and performant Zero Trust application development. Many incumbent HLS languages are a subset of C, and inherit many of the well-known security shortcomings of that language. A Rust-based HLS brings a single modern, type-safe, memory-safe, high-assurance development language for both hardware and software. To study the benefits of this approach, we crafted a Rust HLS subset, and developed a frontend to the hardware/software co-assurance toolchain due to Russinoff and colleagues at Arm, used primarily for floating-point hardware formal verification. This allows us to leverage a number of existing hardware/software co-assurance tools with a minimum investment of time and effort. In this paper, we describe our Rust subset, detail our prototype toolchain, and describe the implementation, performance analysis, formal verification and validation of representative Zero Trust algorithms and data structures written in Rust, emphasizing cryptographic primitives and common data structures.

In this work, we investigate the performance impact of using the Rust programming language instead of the C++ one to implement two basic parallel patterns as provided by the FASTFLOW parallel library. The rationale of using Rust is that it is a modern system-level language capable to statically guarantee that if a data reference is sent over a communication channel, the ownership of the reference is transferred from the producer to the consumer. Such reference-passing semantics is at the base of the FASTFLOW programming model. However, the FASTFLOW library does not enforce nor checks its correct usage leaving this burden to the programmer. The results obtained comparing the FASTFLOW/C++, and the Rust implementations of the same implementation schema of the Task-Farm and Pipeline patterns show that Rust is a valid alternative to C++ for the FASTFLOW library with indubitable benefits in terms of programmability.

ABSTRACTEmbedded systems are applications used for specific tasks or as partof a general purpose, having constraints and design metrics. Thesesystems are implemented using microprocessors, with a favorableoption being the RISC (Reduced Instruction Set Computer), whichhas a reduced number of instructions and shorter execution time. Ahighlight within the RISC architecture is the RISC-V, an open andstable instruction set. Since the increase in reliability is essentialfor embedded systems operating in critical environments, thereis a need for fault tolerance provision in hardware and software.Thus, considering design options for operating systems aimed atembedded systems, the Rust programming language is a safe alternativedue to its efficient memory management. Therefore, thiswork proposes implementing a fault tolerance technique in a preexistingoperating system for the RISC-V architecture, aiming toincrease reliability in critical environments. The technique chosenfor implementation was the triple modular redundancy appliedto the operating system’s processes. After the implementation, anerror injection was performed through an emulator to validate theprovision of reliability. Finally, we evaluated the cost and performancemetrics, consolidating the implementation and the reliabilityimprovement with a justifiable increase in costs and performance.

MotivationLong-read sequencing technology is becoming an increasingly indispensable tool in genomic and transcriptomic analysis. In transcriptomics in particular, long reads offer the possibility of sequencing full-length isoforms, which can vastly simplify the identification of novel transcripts and transcript quantification. However, despite this promise, the focus of much long-read method development to date has been on transcript identification, with comparatively little attention paid to quantification. Yet, due to differences in the underlying protocols and technologies, lower throughput (i.e. fewer reads sequenced per sample compared to short-read technologies), as well as technical artifacts, long-read quantification remains a challenge, motivating the continued development and assessment of quantification methods tailored to this increasingly prevalent type of data.ResultsWe introduce a new method and corresponding user-friendly software tool for long-read transcript quantification called oarfish. Our model incorporates a novel coverage score, which affects the conditional probability of fragment assignment in the underlying probabilistic model. We demonstrate, in both simulated and experimental data, that by accounting for this coverage information, oarfish is able to produce more accurate quantification estimates than existing long-read quantification tools.Availability and Implementationoarfish is implemented in the Rust programming language and is made available as free and open-source software under the BSD 3-clause license. The source code is available at https://www.github.com/COMBINE-lab/oarfish.

S1: Status of Hardware and Software for Microcomputers