Concept of Computational Model

The computer architecture and language classes must have a common foundation or paradigm
called a Computational Model. The concept of a computational model represents a higher level
of abstraction than either the computer architecture or the programming language alone, and
covers both, as show below -

Fig: Interpretation of the computational model concept as a high-level abstraction

Interpretation of Computation Model

The concept of computational model comprises the set of the following three abstractions –
1. The basic items of computations
2. The problem description model
3. The execution model
Contrary to initial thoughts, the set of abstractions that should be chosen to specify
computational models is far from obvious. A smaller number of criteria would define fewer but
more basic computational models, while a larger number of criteria would result in a relatively
large number of distinct models.

Fig: Interpretation of the computational model concept as covering three abstraction

The first abstraction identifies the basic items of computation. This is a specification of the
items the computation refers to and the kind of computations (operations) that can be performed
on them.
For instance, in the von Neumann computational model the basic items of computation are data.
This data will typically be represented by named (that is, identifiable) entities in order to be able
to distinguish between a number of different data items in the course of a computation. These
named entities are commonly called variables in programming languages and are implemented
by memory or register addresses in architectures.
all the best known computational models, namely –
• The Turing model.
• The von Neumann model
• The dataflow model are based on the concept of data.
In contrast, there are a number of models which are not data based. In these models the basic
items of computation are:
• Objects or messages sent to them requiring an associated manipulation (as in the object-based
model)
• Arguments and the functions applied on them (applicative model)
• Elements of sets and the predicates declared on them (predicate-logic-based model)
The problem description model refers to both the style and method of problem description, as
shown

The problem description style specified how problems in a particular computational model are
described. The style is either procedural or declarative, as shown –
In a procedural style the algorithm for solving the problem is stated. A particular solution is
then declared in the form of an algorithm.
In a declarative style all the facts and relationships relevant to the given problem have to be
stated. There are two methods for expressing these relationships and facts. The first uses
functions, as in the applicative model of computation, while the second states the relationships
and facts in the form of predicates, as in the predicate-logic-based computational model.
The other component of the problem description model is the problem description method. It is
interpreted differently for the procedural and the declarative style. When using the procedural
style the problem description model states how a solution of the given problem has to be
described. In contrast, while using the declarative style, it specifies how the problem itself has to
be described.
The third and the last element of computational model outlines the execution model. It consists
of three components as shown –

The first component declares the interpretation of the computation, which is strongly related
to the problem description method. The choice of problem description method and the
interpretation of the computation mutually determine and presume each other.
The next component of the execution model specifies the execution semantics. This can be
interpreted as a rule that prescribes how a single execution step is to be performed. This rule is,
of course, associated with the chosen problem description method and how the execution of the
computation is interpreted. The different kinds of execution semantics applied by the
computational models are summarized below –
The last component of the model specifies the control of the execution sequences. In the basic
models, execution is either control driven or data driven or demand driven as shown –

For Control-driven execution it is assumed that there exists a program consisting of a sequence
of instructions. The execution sequence is then implicitly given by the order of the instructions.
However, explicit control instructions can also be used to specify a departure from the implied
execution sequence.
Data-driven execution is characterized by the rule that an operation is activated as soon as all
the needed input data is available. Data-driven execution control is characteristic of the dataflow
model of computation.
In Demand-driven execution the operations will be activated only when their execution is
needed to achieve the final result. Demand-driven execution control is typically used in the
applicative computational model.
Relationships between the concepts of computational model, programming language and
architecture
The concept of a computational model is a higher level abstraction than the concepts of
programming language and computer architecture. A programming language can be thought of
as a specification tool making possible the formulation of a computational task whereby a
particular computational model is presumed. A computer architecture may be looked upon as a
tool to implement a computational model, or to execute a given computational task expressed by
means of a programming language, whereby a particular computational model is given.
In order to illustrate these relationships we will examine the basic features of the programming
languages and computer architectures that correspond to the von Neumann computational model.
A programming language corresponding to this model should allow variables to be declared and
their values to be manipulated by means of a proper set of instructions as many times as required
during computation. Furthermore, the language should provide control instructions to allow
explicit control of the execution sequence. Languages fulfilling these requirements are called
imperative languages. The most widely used languages, such as C, PASCAL, FORTRAN and
soon, are all imperative languages.

Basic Computational Model

Here, we identify the following six computational models, as –
• Turing
•von Neumann
• Dataflow
•applicative
•object based
•predicate logic based.
These models are called basic models because they may be declared using a minimal set of
abstractions. For each model we specify
• The basic items of computation
• The problem description model
• The execution model

The von Neumann computational model

Description of Model
We designate the underlying model of von Neumann computers and the corresponding languages
as the von Neumann computational model. The key features of this oldest and most widely
used data-based model may be summarized as follows –
Computational Model Von Neumann
The basic Item of Computation • Data assigned to named data entities
(variables)
• Operations performed on data, where
multiple assignments are allowed
Problem description Type Procedural
mode

Description

Assumed
Execution
model

Evolution of computer architecture

As far as the evolution of the concept of computer architecture is concerned, there are four major
steps to be emphasized, which will be overviewed as follows –
The term ‘computer architecture’ was coined in 1964 by the ‘chief architects’ of the IBM
System/360 in a paper announcing the most successful family of computers ever built. They
interpreted computer architecture as ‘the structure of a computer that a machine language
programmer must understand to write a correct program for a machine’. Essentially, their
interpretation comprises the definition of registers and memory as well as of the instruction set,
instruction formats, addressing modes and the actual coding of the instructions excluding
implementation and realization. By implementation they understood the actual hardware
structure and by realization the logic technology, packaging and interconnections.
Bell and Newell made an important contribution to the concept of computer architecture by
introducing a hierarchical, multilevel description (Bell and Newell, 1970). They identify four
levels that can be used for describing a computer. These are the electronic circuit level, the logic
design level, the programming level and the processor-memory-switch level. The third level
refers to the concept of architecture mentioned above. The fourth level is a top-level description
of a computer system based on the specification of the basic units like the processor, memory
and so on, as well as their interconnections.
The next step in refining the concept of computer architecture was to extend the concept of
architecture equally to both the functional specification and the hardware implementation (Sima
1977, Dasgupta 1981).
Since the authors’ just quote also made use of the multilevel description approach, they
introduced a ‘two dimensional’ interpretation. Here, one of the ‘dimensions’ is the level of
abstraction, in much the same way as introduced by Bell and Newell (1970). The other,
orthogonal ‘dimension’ is the scope of interest. Here, they differentiate at each level between a
black-box-like functional specification and the description of the implementation.
Correspondingly, they distinguish between ‘logical’ and ‘physical’ architecture (Sima 1977) and
endo-and exo- architecture (Dasgupta 1981), respectively.
As pointed out later in this section, the two dimensions considered by these authors, constitute
(cuk ysuk] cuk gksuk) single, hierarchical description framework with increasing levels of
abstraction.
Although this interpretation of the architecture concept is quite useful for abroad range of
computers, it assumes the use of the von Neumann model of computation. Therefore, in order to
generalize the concept of computer architecture, we shall include in its definition a ‘third
dimension’, the model of computation.

Recent (Latest) interpretation of computer architecture

We interpret the concept of computer architecture at a number of levels of increasing abstraction.

At each level the architecture will be described by stating the underlying computational model,
the functional specification as well as the actual implementation. Thus, our interpretation covers
three aspects; the underlying computational model, the level of consideration and the scope of
interest, as shown-
First, we briefly overview the underlying computational model. A couple of years ago the term
‘computer architecture’ was inherently interpreted as a von Neumann architecture. Subsequently,
when novel architectures based on a model of computation other than the von Neumann model
were introduced, these architectures were properly labeled, for example dataflow architecture,
reduction architecture and so on. However, at present it is evident that the concept of computer
architecture should include the specification of the underlying computational model as well.
Here, we recalls the most important models relating to architectures

Concerning the level of consideration, there are mainly three levels of interest (in increasing
degree of abstraction):
• The micro - machine level (in micro - programmed processors),
•the processor level, and
•the computer-system level
The term ‘architecture’ can be used at each level of consideration with two distinct scopes of
interest. If we are interested in the functional specification of a computer, we are dealing with its
abstract architecture. Or, if we are interested in its implementation, we are concerned with its
concrete architecture. Evidently, the abstract architecture reflects the black-box view whereas
the concrete architecture covers the description of the internal structure and operation.
The abstract architecture is also referred to as an exo-architecture, an external or logical
architecture, a black-box description, or in certain contexts as a programming model and
behavioral description

The abstract architecture is a black-box specification

•either from the programmer’s point of view, or
•from the hardware designer’s point of view.
In the first case we are dealing with the programming model, in the second with the hardware
model. While the programming model is a black-box specification from the programmer’s
point of view, the hardware model is viewed as a black-box description for a hardware
designer.
Concrete architecture
Concrete architecture is designed by different authors as an endo-architecture, or sometimes as
an internal or physical architecture or a structural description. It specifies how a computer is
implemented at a particular level of abstraction, whereby a particular computational model is
taken for granted. By implementation we mean the internal structure and operation, which may
be given by specifying a set of components and their interconnections as well as the possible
data- and control- flows.
The concrete architecture can also be considered from two different points of view: logic design
or physical design.
The logic design is an abstraction of the physical design and precedes it. Its specification
requires:
• The declaration of the logical components used, such as registers, execution units and so on.
• The specification of their interconnections, and
• The specification of the sequence of information transfers, which are initiated by each of the
declared function.
The physical design is based on concrete circuit elements. The specification of a physical design
covers:
• The declaration of the circuit elements used, which also includes the specification of signals,
• The specification of their interconnections, and
• The declaration of the initiated signal sequences.
Usually, both the logic and physical design are described in terms of the next lower level of
components. For example, the concrete architecture of a processor would be best described in
terms of functional units such as register files, execution units, buses and so on.

Description of computer architecture

Particular computer architectures are usually described informally, for example in processor
handbooks, using a convenient method of presentation. An informal description is also used in
most papers introducing a new architecture or in papers comparing existing architectures.
However, a formal description is required if a precise, unambiguous representation is needed,
such as for inputting architecture specifications into a CAD package. This may be required in
order to perform a verification, simulation or analysis based on the given structural or behavioral
description. The usual method of formally describing an architecture is by using an architecture
description language (ADL). Sometimes ADLs are also called hardware description languages
(HDLs), or computer hardware description languages (CHDLs). A further concept, which is also
used, is register-transfer languages (RTLs). RTL designates a particular type of ADL, which is
confined to the processor level. Occasionally, ADLs and HDLs will be distinguished on the basis
of the level of abstraction they cover. HDLs are considered as low-level and ADLs as higher-
level description languages.