scholarly journals In Praise of the Disassembler

Queue ◽  
2021 ◽  
Vol 19 (2) ◽  
pp. 21-28
Author(s):  
George V. Neville-Neil

When you're starting out you want to be able to hold the entire program in your head if at all possible. Once you're conversant with your first, simple assembly language and the machine architecture you're working with, it will be completely possible to look at a page or two of your assembly and know not only what it is supposed to do but also what the machine will do for you step by step. When you look at a high-level language, you should be able to understand what you mean it to do, but often you have no idea just how your intent will be translated into action. Assembly and machine code is where the action is.

2004 ◽  
Vol 14 (2) ◽  
pp. 273-288 ◽  
Author(s):  
Vladan Vuckovic

This paper presents details of the chess mate solver application, which is a part of the author?s Geniss general chess application. The problem chess is an important domain connected with solving of the chess problems. The Geniss Mate Solver (G.M.S.) application solves Mate-in-N-move problems. Main techniques used for the implementation of the application are full-width searching with Alpha-Beta pruning technique and zero evaluation function. The application is written in Delphi for Windows programming environment and the searching engine is completely coded in assembly language (about 10000 lines). This hybrid software structure enables efficient program development by using high-level programming environment and the realization of a very fast searching engine at the same time. The machine code is manually coded and could achieve above 7 million generated positions per second on the 1Ghz Celeron PC.


2016 ◽  
Vol 13 (06) ◽  
pp. 1750027
Author(s):  
Dawid Barnaś ◽  
Lesław K. Bieniasz

Streaming SIMD Extensions (SSE) and Advanced Vector Extensions (AVX) are additional processor instruction sets available in contemporary personal computers, designed for vectorized floating point calculations. Unfortunately, in order to utilize the advantages of these instructions, one cannot rely on automatic options of high level language compilers. Instead, handwritten assembly language or intrinsic function call insertions are necessary. By using this idea an accelerated C[Formula: see text] code is devised, for solving (quasi-) block-tridiagonal linear algebraic equation systems by means of an extended Thomas algorithm. Speedups reaching 3.5 and 3 (relative to C[Formula: see text] without using SSE/AVX) are demonstrated for single and double precision calculations, respectively.


2012 ◽  
Vol 47 (6) ◽  
pp. 1-12 ◽  
Author(s):  
Christophe Dubach ◽  
Perry Cheng ◽  
Rodric Rabbah ◽  
David F. Bacon ◽  
Stephen J. Fink

1978 ◽  
Vol 6 (8) ◽  
pp. 20-22
Author(s):  
Lyle A. Cox ◽  
James R. McGraw ◽  
Charles S. Wetherell

2021 ◽  
Vol 43 (1) ◽  
pp. 1-46
Author(s):  
David Sanan ◽  
Yongwang Zhao ◽  
Shang-Wei Lin ◽  
Liu Yang

To make feasible and scalable the verification of large and complex concurrent systems, it is necessary the use of compositional techniques even at the highest abstraction layers. When focusing on the lowest software abstraction layers, such as the implementation or the machine code, the high level of detail of those layers makes the direct verification of properties very difficult and expensive. It is therefore essential to use techniques allowing to simplify the verification on these layers. One technique to tackle this challenge is top-down verification where by means of simulation properties verified on top layers (representing abstract specifications of a system) are propagated down to the lowest layers (that are an implementation of the top layers). There is no need to say that simulation of concurrent systems implies a greater level of complexity, and having compositional techniques to check simulation between layers is also desirable when seeking for both feasibility and scalability of the refinement verification. In this article, we present CSim 2 a (compositional) rely-guarantee-based framework for the top-down verification of complex concurrent systems in the Isabelle/HOL theorem prover. CSim 2 uses CSimpl, a language with a high degree of expressiveness designed for the specification of concurrent programs. Thanks to its expressibility, CSimpl is able to model many of the features found in real world programming languages like exceptions, assertions, and procedures. CSim 2 provides a framework for the verification of rely-guarantee properties to compositionally reason on CSimpl specifications. Focusing on top-down verification, CSim 2 provides a simulation-based framework for the preservation of CSimpl rely-guarantee properties from specifications to implementations. By using the simulation framework, properties proven on the top layers (abstract specifications) are compositionally propagated down to the lowest layers (source or machine code) in each concurrent component of the system. Finally, we show the usability of CSim 2 by running a case study over two CSimpl specifications of an Arinc-653 communication service. In this case study, we prove a complex property on a specification, and we use CSim 2 to preserve the property on lower abstraction layers.


Sign in / Sign up

Export Citation Format

Share Document