Assembly Language Code Research Articles

A computer-aided teaching package for microprocessor systems education

A computer-aided teaching (CAT) package for use in a microprocessor systems course is described. It uses the Z80 CPU as the basis for describing how an eight-bit CPU functions internally and as the master of a microcomputer system. The package, which consists of an assembler and a graphics simulator, aids as a powerful teaching tool that enables the student to learn about the internal architecture of a microprocessor as applied to the Z80 CPU and its instruction set with a step-by-step graphics animation of the instruction execution and timing. The package allows the user to execute a program step by step and to test the operation of the internal registers, buses, and memory contents at every clock edge. It also simulates read/write cycles from/to memory and input-output devices. Finally, it allows the user to write and debug problems at the assembly language or machine code level. The package is menu driven, interactive, flexible, and user-friendly.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Further measurements of ( [formula omitted]) on the CRAY-1 and CRAY X-MP

Timing measurements on the CRAY-1 and the CRAY X-MP are used to estimate the values of the parameters introduced by Hockney and Jesshope to characterize a computer in terms of its maximum speed ( r ∞) and the vector length ( n 1 2 ) at which half that speed is reached. Values appropriate for both Cray Assembly Language (CAL) and FORTRAN code are presented and discussed. In particular, we obtain values of n 1 2 on the CRAY X-MP which are much smaller than those measured by Hockney under less favourable conditions.

C language functions for millisecond timing on the IBM PC

This article describes four C language functions for programming the IBM PC and compatibles for timing with millisecond precision. The technique, which is based on a reprogramming of the PC’s real time clock, requires no additional hardware, no assembly language code, and no programming of machine or software interrupts. One function restores the PC’s time-of-day clock.

Parsing and compiling using Prolog

This paper presents the material needed for exposing the reader to the advantages of using Prolog as a language for describing succinctly most of the algorithms needed in prototyping and implementing compilers or producing tools that facilitate this task. The available published material on the subject describes one particular approach in implementing compilers using Prolog. It consists of coupling actions to recursive descent parsers to produce syntax-trees which are subsequently utilized in guiding the generation of assembly language code. Although this remains a worthwhile approach, there is a host of possibilities for Prolog usage in compiler construction. The primary aim of this paper is to demonstrate the use of Prolog in parsing and compiling. A second, but equally important, goal of this paper is to show that Prolog is a labor-saving tool in prototyping and implementing many non-numerical algorithms which arise in compiling, and whose description using Prolog is not available in the literature. The paper discusses the use of unification and nondeterminism in compiler writing as well as means to bypass these (costly) features when they are deemed unnecessary. Topics covered include bottom-up and top-down parsers, syntax-directed translation, grammar properties, parser generation, code generation, and optimizations. Newly proposed features that are useful in compiler construction are also discussed. A knowledge of Prolog is assumed.

A simple virtual machine

Many computer science classes begin with a discussion of how a computer performs certain actions. In an introductory survey of computers, this frequently involves demonstrating some application program. A first course for majors in computer science is likely to discuss high-level programming languages and compare them to the assembly language of some mainframe. A course in system programming is likely to provide examples of assembly language code and relocatable object code before introducing assemblers, linkers, and loaders. The authors have observed certain drawbacks in some of the familiar approaches.

Synchronous data flow

Data flow is a natural paradigm for describing DSP applications for concurrent implementation on parallel hardware. Data flow programs for signal processing are directed graphs where each node represents a function and each arc represents a signal path. Synchronous data flow (SDF) is a special case of data flow (either atomic or large grain) in which the number of data samples produced or consumed by each node on each invocation is specified a priori. Nodes can be scheduled statically (at compile time) onto single or parallel programmable processors so the run-time overhead usually associated with data flow evaporates. Multiple sample rates within the same system are easily and naturally handled. Conditions for correctness of SDF graph are explained and scheduling algorithms are described for homogeneous parallel processors sharing memory. A preliminary SDF software system for automatically generating assembly language code for DSP microcomputers is described. Two new efficiency techniques are introduced, static buffering and an extension to SDF to efficiently implement conditionals.

Comments on “estimating the number of faults in code” and two corrections to published data

The subject paper <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">1</sup> concludes that number of faults per line of code is independent of whether Assembly language or a high order language (HOL) is used, contrary to previously published results by the author of this correspondence. However, the subject paper contains some technical errors and uses erroneous data. An explanation of the source of the erroneous data is given. Also, previously published information by the author of this correspondence on average number of operators plus operands per line of Assembly language code is corrected.

Validating Halstead's theory with system 3 data

Gaffney (ibid., vol.SE-10, no.7, pp.459-463, 1984) concludes that the number of faults per line of code is independent of whether Assembly language or a high order language is used. This is contrary to the results published by the commenter (ibid. vol.SE-8, pp.437-439, July 1982). It is contended that the paper by Gaffney contains some technical errors and uses erroneous data. An explanation of the source of the erroneous data is given. Also, previously published information by the commenter on the average number of operators plus operands per line of Assembly language code is corrected.

Fast analysis of DNA and protein sequence on Apple IIe: restriction sites search, alignment of short sequence and dot matrix analysis.

A fast restriction sites search algorithm using a quadruplet look-ahead feature has been written in 6502 assembly language code. The search time, tested on the sequence of pBR322, is 4.1 s/kilobase using a restriction site library including 112 specificities corresponding to a total site length of over 700 bases. The search for a short sequence (less than 36 bases) within a longer one (up to 9999 bases) with a given number of mismatches or gaps allowed has also been written in assembly language. Typical run time for the search of a 12 base sequence with 1, 2 or 3 gaps allowed are 6.2, 9.4 or 13.6 s/kilobase, respectively. The dot matrix analysis needs 7.5 minutes per square kilobase when using a stringency of 15 matched bases out of 25. A 7/21 matrix of two 500 amino acid proteins is obtained in 3 minutes. These three routines are included in DPSA, a general package of programs allowing manipulation and analysis of DNA and protein sequences.

An inexpensive chromatographic data system for the apple II

Abstract A chromatographic data system, which costs about $30 (U.S.) in hardware, is described. It accepts signals that are traditionally sent to strip-chart recorders, collects data, displays raw data and determines elution time and peak areas in real time and stores raw data and determined results on disk. The system also allows the operator to review data that have previously been stored on disk. Details in the circuit diagram, assembly language and machine code listing and the main BASIC program listing are provided and discussed.

An APL system for the IBM Personal Computer

This paper discusses the design and building of an APL interpreter for the IBM Personal Computer. Discussed is the writing of the interpreter itself, which required the use of an intermediate language designed by the authors. This machine-independent language also made possible the development of APL interpreters for two other systems--System/370 and Series/1. The particularizing of the interpreter required a compiler, which in the case of the Personal Computer produced Intel 8088 and 8087 assembly language code. The matching of the APL interpreter to the operating system (DOS) required an APL supervisor, which is also discussed in this paper. The provision of the APL character set presented problems, the solutions of which are also presented. Other topics discussed are the display, the keyboard, and the session manager.

Fixed point implementation of fast Kalman predictors

In this note we study scaling rules and roundoff noise variances in a fixed-point implementation of the Kalman predictor for an ARMA time series observed noise free. The Kalman predictor is realized in a fast form that uses the so-called fast Kalman gain algorithm. The algorithm for the gain is fixed point. Scaling rules and expressions for rounding error variances are derived. The numerical results show that the fixed-point realization performs very close to the floating point realization for relatively low-order ARMA time series that are not too narrow band. The predictor has been implemented in 16-bit fixed-point arithmetic on an INTEL 8086 microprocessor, and in 16-bit floating-point arithmetic on an INTEL 8080. Fixed-point code was written in Assembly language and floating-point code was written in Fortran. Experimental results were obtained by running the fixed- and floating-point filters on identical data sets. All experiments were carried out on an INTEL MIDS 230 development system.

Molecular mechanics with an array processor

AbstractComputer simulation of the mechanics of molecular systems is a popular and powerful method for understanding chemical processes. The complexity of modeled chemical systems has advanced from hard spheres and rare gases to liquid solutions and biomolecules. Such simulations are computationally intensive and thus are limited by the speed of available computers. This article describes the use of specialized hardware, a high‐speed floating‐point array processor (AP), to dramatically speed up molecular mechanics, in other words molecular dynamics, Monte Carlo, and energy‐minimization calculations. Although the array processor is a cost effective solution for computationally intensive problems in terms of hardware (full‐time AP usage is equivalent to 2–8 h/day of Cray‐1 time), its full speed comes at the expense of programming in a relatively difficult parallel assembly language. Since the architecture of the machine is dramatically different from conventional computers and utilizing its fast speed necessitates using this architecture on the assembly language level, the proper design and implementation of algorithms is critical. The molecular mechanics software design discussed here, consisting of 12,000 lines of C and 7000 lines of AP assembly language code, is quite general and has been used to study systems ranging from rare gases to biomolecules. This implementation yields effective speeds approximately 35 times faster than a dedicated DEC VAX 11/780 computer with floating‐point accelerator and optimized VMS FORTRAN, thus allowing simulations to be run in one and a half weeks on the AP which would require a year of dedicated VAX time. The flexibility of the UNIX operating system, whose source code is accessible and can be modified to optimize performance, combined with the modern features of the C language, have made this implementation much easier by providing a convenient and powerful environment in which to imbed the hand‐coded AP assembly language modules. Applications to date range from the molecular‐dynamic calculation of infrared, Raman, and electronic spectra in gas and liquid solutions to the calculation of thermodynamic quantities for water and the simulation of the molecular dynamics of solution reactions and polypeptides.

Optimization of assembly code generation in a compiler

A computer program for the determination of an optimal assembly language code is presented.

Compiling Three-Address Code for C Programs

This paper describes a post processor that improves the assembly-language code generated by the portable C compiler. The novel ability to change a sequence of two-address instructions into an equivalent three-address instruction distinguishes this particular code improver from other “peephole” improvers. The combined compiler-improver generates good three-address code for the Digital Equipment Corporation vax-11 <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">®</sup> computer without requiring extensive changes in the compiler itself, which was designed to accommodate machine architectures with at most two addresses per instruction. For typical programs the improver reduces the number of bytes in the instruction stream by 10 to 23 percent. This paper emphasizes the technique used to transform two-address code to three-address code.

Optimization of assembly code generation using Petri nets

This paper gives a Petri net approach to the determination of an optimal assembly language code and it appears to be useful for code optimization in the process of compilation. The proposed technique is novel in the sense that only vector addition on a matrix is needed. It is simple and requires little computation.

Unrolling loops in fortran

AbstractThe technique of ‘unrolling’ to improve the performance of short program loops without resorting to assembly language coding is discussed. A comparison of the benefits of loop ‘unrolling’ on a variety of computers using an assortment of FORTRAN compilers is presented.

The role of instruction sequencing in structured microprogramming

The current literature is filled with descriptions of various microprogrammed processors and discussions of the improvements in performance that can be realized through microprogramming. Thus, Tucker and Flynn [1] describe a dynamically microprogrammed processor and give several examples of problem-oriented programming in which the performance of the microcode was much better than that of assembly language code (System/360, normalized technology). Recently, Abd-alla and Karlgaard [2] have developed an algorithm for the synthesis of applications-oriented microcode for a dynamically microprogrammed computer. Their paper gives examples of problem-oriented architectures (realized through specialized instruction sets) which have much better performance than the corresponding general purpose architectures. This trend toward realizing specialized computer systems by means of writable control store probably means that more people will be writing microcode in the future. In particular, it seems worthwhile to consider the relation of the instruction sequencing functions of a given machine to both the ease of writing correct microcode and the size of control memory required for that machine. So far there seems to have been little or no discussion of this topic in the literature [3].

Dirac: An interactive retrieval language with computational interface

An interactive file-oriented language that allows the user to interface with a text-editor and with his own FORTRAN or assembly language code has been used to illustrate the flexibility of non-procedural techniques in the scientific field. The language is the first in a family of prototypes used to test alternative formulations of file organization problems connected with the storage and retrieval of scientific records, medical data or library documents in an interactive mode. The applications described here use files of research data in astronomical and medical fields. It operates exclusively in a time-sharing environment. The article describes the system and its applications from the point of view of language design, and it gives a detailed discussion of the file organization upon which it relies.