m Robot-assisted disambiguation (you can help!): Interpreter |
|||
(One intermediate revision by one other user not shown) | |||
Line 9: | Line 9: | ||
Through the use of abstract machines it is possible to compute the amount of resources (time, memory, etc.) necessary to perform a particular operation without having to construct an actual system to do it. |
Through the use of abstract machines it is possible to compute the amount of resources (time, memory, etc.) necessary to perform a particular operation without having to construct an actual system to do it. |
||
== |
==Organization within Wikipedia of Turing Complete abstract machines== |
||
An approach is to take a somewhat formal taxonimic approach: |
|||
Fundamental |
|||
Class: Fundamentally there are '''two''' ''classes'' (genera) of abstract machine models currently in use (cf van Emde Boas, for example): |
|||
:Genus (1) the tape-based [[Turing machine]] model''' |
|||
:Genus (2) the [[register machine]] |
|||
'''Genus (1) the tape-based [[Turing machine]] model''': This ''class'' includes the following: |
|||
:: = { single tape, multi-tape, [[deterministic Turing machine]], [[Non-deterministic Turing machine]], [[Wang B-machine]] model, [[Post-Turing machine]], [[oracle machine]], [[Universal Turing machine]] etc. } |
|||
'''Genus 2) the [[register machine]] model''': This is a '''''class''''' of machines that includes (at least) the following four "species": |
|||
:: = { 2.1 counter machine, 2.2 [[random access machine]] RAM, 2.3 [[Random access stored program machine]] RASP, 2.4 [[pointer machine]] } |
|||
:Species 2.1) '''counter machine''' model includes: |
|||
::= { abacus machine, Lambek machine, Melzak model, Minsky machine, Shepherdson-Sturgis machine, pointer-machine, program machine etc. } |
|||
:Species 2.2) '''Random access machine''' (RAM) model includes: |
|||
::= { any counter-machine model with ''indirect addressing'' but instructions in the state machine in the Harvard architecture, any model with an "accumulator" and with indirect addressing but instructions in the state machine in the [[Harvard architecture]] } |
|||
:Species 2.3) '''Random access stored program machine''' (RASP) model |
|||
::= { any RAM with program stored in the registers similar to the [[Universal Turing machine]], i.e. in the [[von Neumann architecture]] } |
|||
:Species 2.4) '''Pointer machine''' model includes the following: |
|||
::= { Schonhage SMM, KU-machine, Knuth linking automaton } |
|||
Within each of the model-species there are varieties. |
|||
They can be classified e.g. depending on the number of parameters used. The way to figure this out formally is to actually build the models (e.g. in an Excel spreadsheet) and see how many operands (i.e. Excel cells) are required to specify an instruction. In the following the "jump-to" address as an additional operand. So for instance the Schönhage model has no operands excepting the jump-to address in an extra goto instruction: |
|||
*0- & 1- operand: Schonage model |
|||
*1- & 2- operand: Minsky (1967) model |
|||
*2- & 3- operand: Minsky (1961), Lambek (1961) |
|||
*3- & 4- operand: Malzek (1961) |
|||
There are models with "convenience instructions" (e.g. unconditional-J xxx, CLR h; CPY a,b ) including in particular: |
|||
* 2-operand: Shepherdson-Sturgis (1963), Minsky (1967) |
|||
==Other abstract machines== |
|||
*[[ABC programming language]] |
*[[ABC programming language]] |
||
*[[Abstract Machine Notation]] |
*[[Abstract Machine Notation]] |
||
Line 17: | Line 52: | ||
*[[Context-free grammar]] |
*[[Context-free grammar]] |
||
*[[Finite automata]] |
*[[Finite automata]] |
||
*[[Lambda calculus]] |
|||
*[[Specification and Design Language]] |
*[[Specification and Design Language]] |
||
*[[Warren Abstract Machine]] |
*[[Warren Abstract Machine]] |
Revision as of 19:17, 24 October 2006
An abstract machine, also called an abstract computer, is a theoretical model of a computer hardware or software system used in Automata theory. Abstraction of computing processes is used in both the computer science and computer engineering disciplines and usually assumes discrete time paradigm.
In the theory of computation, abstract machines are often used in thought experiments regarding computability or to analyze the complexity of algorithms (see computational complexity theory). A typical abstract machine consists of a definition in terms of input, output, and the set of allowable operations used to turn the former into the latter. The best-known example is the Turing machine.
More complex definitions create abstract machines with full instruction sets, registers and models of memory. One popular model more similar to real modern machines is the RAM model, which allows random access to indexed memory locations. As the performance difference between different levels of cache memory grows, cache-sensitive models such as the external-memory model and cache-oblivious model are growing in importance.
An abstract machine can also refer to a microprocessor design which has yet to be (or is not intended to be) implemented as hardware. An abstract machine implemented as a software simulation, or for which an interpreter exists, is called a virtual machine.
Through the use of abstract machines it is possible to compute the amount of resources (time, memory, etc.) necessary to perform a particular operation without having to construct an actual system to do it.
Organization within Wikipedia of Turing Complete abstract machines
An approach is to take a somewhat formal taxonimic approach:
Fundamental
Class: Fundamentally there are two classes (genera) of abstract machine models currently in use (cf van Emde Boas, for example):
- Genus (1) the tape-based Turing machine model
- Genus (2) the register machine
Genus (1) the tape-based Turing machine model: This class includes the following:
- = { single tape, multi-tape, deterministic Turing machine, Non-deterministic Turing machine, Wang B-machine model, Post-Turing machine, oracle machine, Universal Turing machine etc. }
Genus 2) the register machine model: This is a class of machines that includes (at least) the following four "species":
- = { 2.1 counter machine, 2.2 random access machine RAM, 2.3 Random access stored program machine RASP, 2.4 pointer machine }
- Species 2.1) counter machine model includes:
- = { abacus machine, Lambek machine, Melzak model, Minsky machine, Shepherdson-Sturgis machine, pointer-machine, program machine etc. }
- Species 2.2) Random access machine (RAM) model includes:
- = { any counter-machine model with indirect addressing but instructions in the state machine in the Harvard architecture, any model with an "accumulator" and with indirect addressing but instructions in the state machine in the Harvard architecture }
- Species 2.3) Random access stored program machine (RASP) model
- = { any RAM with program stored in the registers similar to the Universal Turing machine, i.e. in the von Neumann architecture }
- Species 2.4) Pointer machine model includes the following:
- = { Schonhage SMM, KU-machine, Knuth linking automaton }
Within each of the model-species there are varieties.
They can be classified e.g. depending on the number of parameters used. The way to figure this out formally is to actually build the models (e.g. in an Excel spreadsheet) and see how many operands (i.e. Excel cells) are required to specify an instruction. In the following the "jump-to" address as an additional operand. So for instance the Schönhage model has no operands excepting the jump-to address in an extra goto instruction:
- 0- & 1- operand: Schonage model
- 1- & 2- operand: Minsky (1967) model
- 2- & 3- operand: Minsky (1961), Lambek (1961)
- 3- & 4- operand: Malzek (1961)
There are models with "convenience instructions" (e.g. unconditional-J xxx, CLR h; CPY a,b ) including in particular:
- 2-operand: Shepherdson-Sturgis (1963), Minsky (1967)
Other abstract machines
- ABC programming language
- Abstract Machine Notation
- ALF programming language
- Categorical Abstract Machine Language
- Context-free grammar
- Finite automata
- Specification and Design Language
- Warren Abstract Machine
- MMIX
- TenDRA Distribution Format
See also
This article is based on material taken from the Free On-line Dictionary of Computing prior to 1 November 2008 and incorporated under the "relicensing" terms of the GFDL, version 1.3 or later.