12,004 research outputs found
Program algebra with unit instruction operators
AbstractIn the setting of program algebra (PGA), a projection from PGAu, i.e., PGA extended with a unit instruction operator, into PGA is defined. This is done via a composition that employs backward jumps and (labeled) goto's
On the behaviours produced by instruction sequences under execution
We study several aspects of the behaviours produced by instruction sequences
under execution in the setting of the algebraic theory of processes known as
ACP. We use ACP to describe the behaviours produced by instruction sequences
under execution and to describe two protocols implementing these behaviours in
the case where the processing of instructions takes place remotely. We also
show that all finite-state behaviours considered in ACP can be produced by
instruction sequences under execution.Comment: 36 pages, consolidates material from arXiv:0811.0436 [cs.PL],
arXiv:0902.2859 [cs.PL], and arXiv:0905.2257 [cs.PL]; abstract and
introduction rewritten, examples and proofs adde
Functional units for natural numbers
Interaction with services provided by an execution environment forms part of
the behaviours exhibited by instruction sequences under execution. Mechanisms
related to the kind of interaction in question have been proposed in the
setting of thread algebra. Like thread, service is an abstract behavioural
concept. The concept of a functional unit is similar to the concept of a
service, but more concrete. A state space is inherent in the concept of a
functional unit, whereas it is not inherent in the concept of a service. In
this paper, we establish the existence of a universal computable functional
unit for natural numbers and related results.Comment: 17 pages; notational mistakes in tables 5 and 6 corrected; erroneous
definition at bottom of page 9 correcte
Instruction sequence processing operators
Instruction sequence is a key concept in practice, but it has as yet not come
prominently into the picture in theoretical circles. This paper concerns
instruction sequences, the behaviours produced by them under execution, the
interaction between these behaviours and components of the execution
environment, and two issues relating to computability theory. Positioning
Turing's result regarding the undecidability of the halting problem as a result
about programs rather than machines, and taking instruction sequences as
programs, we analyse the autosolvability requirement that a program of a
certain kind must solve the halting problem for all programs of that kind. We
present novel results concerning this autosolvability requirement. The analysis
is streamlined by using the notion of a functional unit, which is an abstract
state-based model of a machine. In the case where the behaviours exhibited by a
component of an execution environment can be viewed as the behaviours of a
machine in its different states, the behaviours concerned are completely
determined by a functional unit. The above-mentioned analysis involves
functional units whose possible states represent the possible contents of the
tapes of Turing machines with a particular tape alphabet. We also investigate
functional units whose possible states are the natural numbers. This
investigation yields a novel computability result, viz. the existence of a
universal computable functional unit for natural numbers.Comment: 37 pages; missing equations in table 3 added; combined with
arXiv:0911.1851 [cs.PL] and arXiv:0911.5018 [cs.LO]; introduction and
concluding remarks rewritten; remarks and examples added; minor error in
proof of theorem 4 correcte
Turing Impossibility Properties for Stack Machine Programming
The strong, intermediate, and weak Turing impossibility properties are
introduced. Some facts concerning Turing impossibility for stack machine
programming are trivially adapted from previous work. Several intriguing
questions are raised about the Turing impossibility properties concerning
different method interfaces for stack machine programming.Comment: arXiv admin note: substantial text overlap with arXiv:0910.556
Instruction sequences with indirect jumps
We study sequential programs that are instruction sequences with direct and
indirect jump instructions. The intuition is that indirect jump instructions
are jump instructions where the position of the instruction to jump to is the
content of some memory cell. We consider several kinds of indirect jump
instructions. For each kind, we define the meaning of programs with indirect
jump instructions of that kind by means of a translation into programs without
indirect jump instructions. For each kind, the intended behaviour of a program
with indirect jump instructions of that kind under execution is the behaviour
of the translated program under execution on interaction with some memory
device.Comment: 23 pages; typos corrected, phrasing improved, reference replace
Mechanistic Behavior of Single-Pass Instruction Sequences
Earlier work on program and thread algebra detailed the functional,
observable behavior of programs under execution. In this article we add the
modeling of unobservable, mechanistic processing, in particular processing due
to jump instructions. We model mechanistic processing preceding some further
behavior as a delay of that behavior; we borrow a unary delay operator from
discrete time process algebra. We define a mechanistic improvement ordering on
threads and observe that some threads do not have an optimal implementation.Comment: 12 page
- …