Date post: | 19-Dec-2015 |
Category: |
Documents |
View: | 213 times |
Download: | 0 times |
1
(BOCA)Bijzondere Onderwerpen
Computer Architectuur
Block A
Introduction
2
The aims of the course
• Show the relation between the algorithm and the architecture.
• Derive the architecture from the algorithm.• Explaining and formalizing the design
process.• Explain the distinction between structure and
behavior.• Explain some architectures.
3
The design process
• Behavior: Expresses the relation between the input and the output value-streams of the system
• Structure: Describes how the system is decomposed into subsystems and how these subsystems are connected
• Geometry: Describes where the different parts are located.
Pure behavioral, structural or geometrical descriptions do not exist in practice.
A design description may express:
4
Abstraction levels
Behavior Structure Geometry
Application
Algorithm
Basic operator
Boolean logic
Physical level
Block level
Processing element
Basic block
Transistor
Board level
Layout
Cell
5
The Design Process
Spec 0
Idea
Spec 1
Spec N
verification:
by simulation only
by simulation formal verification
by simulation formal verification
For practical reasons
a specification must
be executable
The implementation i is the specification for the implementation i+1
6
Descriptions
• Predicate logic
• Algebra (language Z, SDL (VDM) )
• Process algebras CCS, CSP, Lotos
• VHDL, Verilog
• Silage, ......
7
Specification overloading
Specification overloading means that the specification gives a possibly unwanted implementation suggestion,
i.e. the behavioral specification expresses structure
In practice:
A behavioral specification always contains structure.
8
same function same behavior, different expressions different structure different designs
Example:
2 baz
+ xb
2z
a
2 abaz
suggests:
andx
+
b
2
zax
suggests:
9
Architecture
Definition:
Architecture is the way in which hardware and software is structured;
the structure is usually based on grandiose design philosophies.
Architecture deals with fundamental elements that affect the way a system operates and thus its capabilities and its limitations.
The New American Computer Dictionary
10
Our focus
• Array processors.
• Systolic arrays.
• Wave-front array processors.
• Architectures for embedded algorithms
s.a. digital signal processing algorithms.
11
Array processor
An array processor is a
structure in which
identical processing
elements are arranged
regularly
PE PE PE PE
PEPE PE PE
PEPE PE PE
PEPE PE PE
PEPE PE PE
1 dimension
2 dimensions
12
PE
PE
PE
PE
PE
PE
PE
PE
PE
PE
PE
PE
PE
PE
PE
PE
PE
PE
Array processor 3 dimensions
13
Systolic array
In a systolic array
processor all
communication path
contain at least one
unit delay (register).
is register or delay
Delay constraints are local. Therefore unlimited extension without changing the cells
PEPE PE PE
PEPE PE PE
PEPE PE PE
PEPE PE PE
PEPE PE PE
14
Wave-front array
PEPE PE PE
PEPE PE PE
PEPE PE PE
PEPE PE PE
15
Array Processors
Can be approached from:
• Application • Algorithm• Architecture•Technology
We will focus on
Algorithm Architecture
Derive the architecture from the algorithm
16
General purpose processors do not provide sufficient processing power
Array processors: Application areas
• Speech processing • Image processing (video, medical ,.....)• Radar• Weather• Medical signal processing• Geology• . . . . . . . . . . .
Many simple calculations on a lot of datain a short time
17
Example video processing
1000 operations per pixel (is not that much) 1024 x 1024 pixels per frame (high density TV) 50 frames per second (100 Hz TV)
50 G operations per second < 1 Watt available
Pentium 2Ghz: 2G operations per second> 30 Watt
required 25 Pentiums 750 Watt
18
Description of the algorithms
In practice the algorithms are described (specified) in:
• some programming language.
In our (toy) examples we use:• programming languages • algebraic descriptions
19
Examples of algorithms we will use:
Filter:
1
0 ,
N
j jjii xcy
xCy
1
0.
N
i itit xhy
Matrix algebra:
Transformations like Fourier transformZ transform
Sorting
. . . .
20
Graphs
Graphs are applicable for describing• behavior• structure
Dependency graphsconsist of:
• nodes expressing operations or functions • edges expressing data dependencies or the flow of data
So, graphs are suitable to describe the design flow from
Algorithm to architecture
21
Design flow example: Sorting
idea
program (imperative)
single assignment code (functional)
dependency graph
recurrent relations
22
Sorting: the idea
12 10 9
8
8 5 3 2 1
>
12 10 9
8
8 5 3 2 1
>
shiftedone position
empty placeneeded
23
9 9
8
6 3 3 1
9 9 8 6 3 3 1
8
9 9 8 6 3 3 1
8
8
9 9 8 6 3 3 1
8
y := mj
mj-1 mj mj+1
x
y
x
x
x
y
y
y
mj:= x
x := y
?mx j
mj-1 mj mj+1
mj-1 mj mj+1
mj-1 mj mj+1
24
if (x>= m[j])
{ y = m[j];
m[j] = x;
x = y;
}
if (x>= m[j]) swap(m[j],x);
m[j],x = MaxMin(m[j],x);
Identical descriptions of swapping
Inserting an element into a sorted array of i elements such that the order is preserved:
m[i] = -infinite
for(j = 0; j < i+1; j++)
{ m[j],x = MaxMin(m[j],x);
}
Sorting: inserting one element
25
Sorting N elements in an array is composed from N times inserting an element into a sorted array of N elements such that the order is preserved. An empty array is ordered.
for(int i = 0; i < N; i++)
{ for(j = 0; j < i+1; j++)
{ m[j],x[i] = MaxMin(m[j],x[i]);}
}
Sorting: The program
int in[0:N-1], x[0:N-1], m[0:N-1];
for(int i = 0; i < N; i++)
{ x[i] = in[i]; m[i] = - infinite; }
for(int j = 0; j < N; j++)
{ out[j] = m[j];}
input
body
output
26
Single assignment:
Each scalar variable is assigned only once
Why?
Goal is a data dependency graph
- nodes expressing operations or functions
- edges expressing data dependencies or
the flow of data
Sorting: Towards ‘Single assignment’
27
Single assignment:
Each scalar variable is assigned only once
Why?
Code Nodes Graph
x=a+b;
x=c*d;
Sorting: Towards ‘Single assignment’
+
*
a
bc
d
x
x
How do you connect these?
28
Single assignment:
Each scalar variable is assigned only once
Why?
Code
x=a+b;
x=c*d;
Sorting: Towards ‘Single assignment’
Description already optimized towards
implementation: memory optimization.
But, fundamentally you produce two
different values, e.g. x1 an x2
29
for(int i = 0; i < N; i++)
{ for(j = 0; j < i+1; i++)
{ m[j],x[i] = MaxMin(m[j],x[i]);}
}
Single assignment:
Each scalar variable is assigned only once
Sorting: Towards ‘Single assignment’
Start with m[j]:
m[j] at loop index i depends on the value at loop index i-1
for(int i = 0; i < N; i++)
{ for(j = 0; j < i+1; j++)
{ m[i,j],x[i] = MaxMin(m[i-1,j],x[i]);}
}
hence,
30
Sorting: Towards ‘Single assignment’
x[i] at loop index j depends on the value at loop index j-1
for(int i = 0; i < N; i++)
{ for(j = 0; j < i+1; i++)
{ m[i,j],x[i] = MaxMin(m[i-1,j],x[i]);}
}
hence, for(int i = 0; i < N; i++)
{ for(j = 0; j < i+1; i++)
{ m[i,j],x[i,j] = MaxMin(m[i-1,j],x[i,j-1]);}
}
31
All scalar variables are assigned only once.
The algorithm satisfies the single assignment property
for(int i = 0; i < N; i++)
{ for(j = 0; j < i+1; j++)
{ m[i,j],x[i,j] = MaxMin(m[i-1,j],x[i,j-1]);}
}
Sorting: The algorithm in ‘single assignment’
int in[0:N-1], x[0:N-1,-1:N-1], m[-1:N-1,0:N-1];
for(int i = 0; i < N; i++)
{ x[i,-1] = in[i]; m[i-1,i] = - infinite; }
for(int j = 0; j < N; j++)
{ out[j] = m[N-1,j];}
input
body
output
32
Sorting: The algorithm in ‘single assignment’
-∞
-∞
-∞
-∞
-1
n-1
0 n-1
x0
x1
x2
x3
x0
x1
x2
x3
-1 n-1
n-1
0
in x
m
out
MaxMin
int in[0:N-1], x[0:N-1,-1:N-1], m[-1:N-1,0:N-1];
for(int i = 0; i < N; i++)
{ x[i,-1] = in[i]; m[i-1,i] = - infinite; }
for(int i = 0; i < N; i++)
{ for(j = 0; j < i+1; j++)
{ m[i,j],x[i,j] = MaxMin(m[i-1,j],x[i,j-1]);}
}
i = 1
j = 0
33
Sorting: The algorithm in ‘single assignment’
-∞
-∞
-∞
-∞
-1
n-1
0 n-1
5
7
4
6
5
7
4
6
-1 n-1
n-1
0
mMM
for(int i = 0; i < N; i++)
{ for(j = 0; j < i+1; j++)
{ m[i,j],x[i,j] = MaxMin(m[i-1,j],x[i,j-1]);}
}
i
j
34
Sorting: The algorithm in ‘single assignment’
-∞
5 -∞
-∞
-∞
-1
n-1
0 n-1
5 -∞
7
4
6
5
7
4
6
-1 n-1
n-1
0
mMM
for(int i = 0; i < N; i++)
{ for(j = 0; j < i+1; j++)
{ m[i,j],x[i,j] = MaxMin(m[i-1,j],x[i,j-1]);}
}
i
j
35
Sorting: The algorithm in ‘single assignment’
-∞
5 -∞
7 -∞
-∞
-1
n-1
0 n-1
5 -∞
7 5
4
6
5
7
4
6
-1 n-1
n-1
0
m
for(int i = 0; i < N; i++)
{ for(j = 0; j < i+1; j++)
{ m[i,j],x[i,j] = MaxMin(m[i-1,j],x[i,j-1]);}
}
i
j
36
Sorting: The algorithm in ‘single assignment’
-∞
5 -∞
7 -∞
-∞
-1
n-1
0 n-1
5 -∞
7 5
4
6
5
7
4
6
-1 n-1
n-1
0
mMM
for(int i = 0; i < N; i++)
{ for(j = 0; j < i+1; j++)
{ m[i,j],x[i,j] = MaxMin(m[i-1,j],x[i,j-1]);}
}
i
j
37
Sorting: The algorithm in ‘single assignment’
-∞
5 -∞
7 5 -∞
-∞
-1
n-1
0 n-1
5 -∞
7 5 -∞
4
6
5
7
4
6
-1 n-1
n-1
0
m
for(int i = 0; i < N; i++)
{ for(j = 0; j < i+1; j++)
{ m[i,j],x[i,j] = MaxMin(m[i-1,j],x[i,j-1]);}
}
i
j
38Notice that the order of these relations is arbitrary
m[i,j],x[i,j] = MaxMin(m[i-1,j],x[i,j-1])
Sorting: Recurrent relation
x[i,-1] = in[i]
m[i-1,i] = - infinite
out[j] = m[N-1,j]
input
output
A description in single assignment can be directly translated into a recurrent relation
in[0:N-1], out[0:N-1], x[0:N-1, -1:N-1], m[-1:N-1, 0:N-1];
0 <= i < N;
0 <= j < i+1 }
declaration
body
area
39
m[i,j],x[i,j] = MaxMin(m[i-1,j],x[i,j-1])
Sorting: Body in two dimensions
The body is executed for all i and j. Hence two dimensions
body
MaxMin
m[i-1,j]
x[i,j-1]
m[i,j]
x[i,j]
j
i
40
m[i,j],x[i,j] = MaxMin(m[i-1,j],x[i,j-i])
Sorting: Body implementation
body
if( m[i-1,j] <= x[i,j-1]) { m[i,j] = x[i,j-1]; x[i,j] = m[i-1,j]; }else { m[i,j] = m[i-1,j]; x[i,j] = x[i,j-1]); }
m[i-1,j]
x[i,j-1]
m[i,j]
x[i,j]
j
i
1
0
0
1
41
Sorting: Implementation N = 4
j
i
PEPE
PEPE PE
PEPE PE PE
PE
PE = MaxMin
m[3,0]
x[0,-1]
x[1,-1]
x[2,-1]
x[3,-1]
-1
m[3,1] m[3,2] m[3,3]
m[-1,0]=
m[0,1]=
m[1,2]=
m[2,3]=
3
2
1
0
-1 3210
42
Sorting: Example N = 4
5
3
1
5
2
3 2 1
43
Something on functions
Tuple : BbAaba ,
Cartesian product: set of all tuples
The number of tuples in the set
BAba ,
BAba is,
BABA
If Q is a set and P is a subset of Q,
then the set of all subsets of Q is
The number of subsets of Q is
Hence, the set of all subsets of
and the number of subsets of
QP Q2
QQ 22 BABA 2is
BABABA 22is
44
Something on functions
Function F YXF
YX is the set of all functions with domain X and co-domain Y
F is a function in if and only if YX
Each element of the domain of X is mapped by F on a single element of the codomain Y
Hence YaFXaa :
and cbcaFbaFXacba :,,
F can be represented as a set of tuples
Hence,
YbXaba andwith,
YXYX 2
45
Functions, Arrays, Tuples, Sequences, ....
Arrays, tuples and sequences are all representations of the same set of functions
VD ul ,
in which Dl,u is a closed subset of the set of integers Z
uzlZzzD ul |,
and V is some value co-domain
corresponds to
,,.....,,, 1210 NyyyyySo
VDy N 1,0
Hence, yi, y(i) and y[i] are syntactically different notations for the function value in i.
46
Functions on more than one variableCurrying
A function on two variables can be represented in three different ways:
abFbaFbaF ,
baFvvba F ,,
VBAF
VvBAbavbaF ,|,,
:,baF
47
Functions on more than one variableCurrying
abFbaFbaF ,
VBAF *
VBpAapaF |,
:baF baFvvba aFF
VABF **
VAqBbqbF |,
:abF abFvvab bFF
48
Functions on more than one variableCurrying (Example)
3,2,1,02,1,02 babav
86422
75311
64200
3210
a
bv
73
52
31
10
1F
62
51
40
2F
12212,1 FFF
49
Linear Time Invariant Systems
Fx y
x and y are streams.
ztime
ztime
VZx VZy
VZVZF
Time is represented by the set of integers Z, so F maps functions on functions
Obviously, this class of functions also models systems that cannot exist in reality. For example non-causal systems
50
Adding functions
x and y are streams modeled by functions on Z.
z
time
VZxi
+
=
Zzallforzxzxzxxxx 213213
51
Linear functions, linear systems
Definition:
A system F is called linear if 2121 .... xFbxFaxbxaF
2121
22
11 ...
.xbxaFyy
xFby
xFay
or
x1
x1+x2
x2
y1
y1+y2
y2
52
Time invariant systems
Definition:
A system F is called time invariant if
tyty
xFy
txtx
xFy
12
22
12
11
)(
x1
x2
y1
y2
53
Linear time-invariant systems
Why?
Linear: Because they can easily be described
Time-invariant: Because electrical systems like transistors resistors capacitance and induction satisfy this property.
54
The convolution algorithm
The behavior of a linear time-invariant system can be fully described by its impulse response h, i.e. the response on the output to a single unit pulse on the input.
The response y on the output to an input stream x then follows from:
i
izhixzy .
hxy or
We will derive this convolution operation for time discrete signals
55
The convolution algorithm
Let the unit sample sequence be defined by
otherwise0
if1 zizi In which
z represents time,
i represents the location of the unit pulse
Zzi ,
VZi
VZZ
zi
z
1
i
56
The convolution algorithm
• Step 1: express x using a delta function
57
The convolution algorithm
Then
2.2 x
i
iixx .
3.3 x
4.4 x
5.5 x
zx1 2 3 4 5 6 7
in which (i) is a function on Z and x(i) is a scalar
58
The convolution algorithm
• Step 1: express x using a delta function• Step 2: rewrite time-shifted delta function
59
The convolution algorithm
Shifting over
z0
zx
10-1 2 3 10-1 2 3
zy
zz Hence zxzy
z2
izzi 0Hence zz
60
The convolution algorithm
• Step 1: express x using a delta function• Step 2: rewrite time-shifted delta function• Step 3: rewrite impulse response using time
invariance property
61
The convolution algorithm
Consider a linear time-invariant system F
z
Let h*(i) be the response of this system to the unit sample sequence (i).
F(i) h*(i)
z
F is time-invariant, so
izhzih 0**
(i)(z) h*(i)(z)
62
The convolution algorithm
• Step 1: express x using a delta function• Step 2: rewrite time-shifted delta function• Step 3: rewrite impulse response using time
invariance property• Step 4: rewrite impulse response using linearity
property
63
The convolution algorithm
Example
z
F(i) h*(i)
(0)(z) h*(0)(z)
10-1 2 3 10-1 2 3
z
-(1)(z) -h*(1)(z)
10-1 2 3 10-1 2 3
½.(2)(z) ½. h*(2)(z)
10-1 2 3 10-1 2 3
izazia 0.. izhaziha 0*.*.
4
64
The convolution algorithm
• Step 1: express x using a delta function• Step 2: rewrite time-shifted delta function• Step 3: rewrite impulse response using time
invariance property• Step 4: rewrite impulse response using linearity
property• Step 5: rewrite general expression by means of
algebraic manipulation using result from step 4.
65
The convolution algorithm
in which h is called the impulse response of the system F
Fx y
xFy
iFih *
hh 0*
66
The convolution algorithm
F is linear and x(i) is a scalar, hence
From the preceding we derive:
i
iixx .
i
iixFy .
i
iFixy .
i
ihixy *.
scalar
function on Z
iFih *
67
The convolution algorithm
continue
i
ihixy *.
recall
zihixzyi
*.
Zzallforzhzhzhhhh 213213
zihixzyi
*.
izhzih 0**
izhixzyi
0*.
recall
68
The convolution algorithm
continue izhixzyi
0*.
izhixzyi
.
This is called the convolution operation, denoted by
hxy
hh 0*recall
We will apply this formula several times
69
The convolution algorithm
izhixzyi
.
and if the impulse response h is finite (bounded), i.e.
continue
jhjzxzyj
.
with j = z – i, we obtain:
Nzor0if0 zzh
we get jhjzxzy
N
j
1
0
.
70
Dependency Graphs and Signal Flow Graphs
The array processor described: • the way in which the processors are
arranged and• the way in which the data is communicated
between the processing elements.
PEPE PE PE
PEPE PE PE
PEPE PE PE
So we may consider it as a Dependency Graph or
a Signal Flow Graph
Hence, the graph describes the dependencies of the data that is communicated, or said differently:
The graph describes the way in which the data values at the outputs of a processing element depend on the data at the outputs of the other processing elements.
71
Dependency graphs and Signal Flow Graphs
Dependency Graph:All communicated values are scalars and the processing elements are functions on scalars. Each arrow carries only one value. Time does not play a role.
PEPE PE PE
PEPE PE PE
PEPE PE PE
Signal Flow Graph:The communicated values are streams, i.e. functions on time and the processing elements are functions on steams.
NN VVPE
NN VZVZPE
V is the value domain, number of inputs = number of outputs = N
Z represents time
72
Recurrent relations
For simple algorithms the transformation from single assignment code to a recurrent relation is simple.
Questions to answer:
• How do recurrent relations influence the dependency graph
• How can recurrent relations be manipulated such that the behavior remains the same and the structure of the dependency graph is changed
We will answer these questions by means of an example: Matrix-Vector multiplication bAc
.
73
Matrix Vector multiplication
Recurrent relations:
bAc
. j
N
j jii bac
1
0 , .
jjijiji bass .,1,,
01, is 1, Nii sc
1,,0 Ki
Alternative (because is associative)
jjijiji bass .,1,,
0, Nis 0,ii sc
1,,0 Nj
1,,0 Ki 1,,0 Nj
74
Matrix Vector multiplication
The basic cell is described by: jjijiji bass .,1,,
We have two indices i and j, so the dependency graph can be described as a two-dimensional array
PEsi,j-1 si,j
bj
i
j
+si,j-1
bj
x
ai,j
si,j
75
DG-1 of the Matrix Vector multiplication
b0, b1 and b2 are global dependencies.
Therefore this graph is called a
Globally recursive Graph
j
i
s0,2=c0
b0
PEPE PE
PEPE PE
PEPE PE
PEPE PE0
0
0
0
s1,2=c1
s2,2=c2
s3,2=c3
b1 b2
S0,0 s0,1
s1,0
s2,0
s3,0
s0,-1
s3,-1
01, is
2,ii sc
3,2,1,0i
2,1,0j
jjijiji bass .,1,,
(K = 4)
(N = 3)
76
DG-2 of the Matrix Vector multiplication
j
i
b0
PEPE PE
PEPE PE
PEPE PE
PEPE PE 0
0
0
0
b1 b2
s0,1 s0,2
s1,1
s2,1
s3,1
s0,3
s3,3
3,2,1,0i
2,1,0j
c0=s0,0
c1=s1,0
c2=s2,0
c3=s3,0
0, Nis
0,ii sc
jjijiji bass .,1,,
(K = 4)
(N = 3)
77
Variable naming and index assignment
A variable associated to an arrow gets the indices of the processing element that delivers its value.
j
i PEi,j
ai,j-1
bi-1,j-1
bi,j
ai,j
ci,j
ci-1,j
( i , j )
Local constants get the indices of the processing element that they are in
PEi,j
vi,j
78
Recurrent relations: Conclusion
The associative operations and result in two different recurrent relations and thus in two different dependency graphs.
11
Ni ixyEquation results in
111 ,0, Niii sysxss
01 0 sy,s,xss Niii
1
0Ni ixyEquation results in
1,,1,0with Ni
1,,1,0with Ni
111 ,1,. Niii sysxss
01 ,1,. sysxss Niii
Other associative operations are for example ‘AND’ and ‘OR’.
79
Changing global data dependencies into local data dependencies
Global data dependencies resist manipulating the dependency graph
jijijiji dass ,1,1,, .
01, is 1, Nii sc
Local data dependencies
j
N
j jii bac
1
0 , .
Global data dependencies
01, is 1, Nii sc
jjijiji bass .,1,,
jj bd .1 jiji dd ,1,
ci
ci
bj
bj
di-1,j
si,j
j
i
80
Changing global data dependencies into local data dependencies
So the matrix-vector multiplications becomes:
jijijiji dass ,1,1,, .
j
N
j jii bac
1
0 , .
01, is
1, Nii sc
jj bd .1
jiji dd ,1,
s0,2=c0
b0=d-1,0
PEPE PE
PEPE PE
PEPE PE
PEPE PE0
0
0
0
s1,2=c1
s2,2=c2
s3,2=c3
b1=d-1,1 b2=d-1,2
s0,0 s0,1
s1,0
s2,0
s3,0
s0,-1
s3,-1
d0,0
d1,0
d0,1
Relations:
Locally recursive graph
3,2,1,0i 2,1,0j
(K = 4)
(N = 3)
81
Alternative transformation from global data dependencies to local data dependencies
jijijiji dass ,1,1,, .
01, is 1, Nii sc
Local data dependencies
j
N
j jii bac
1
0 , .
Global data dependencies
01, is 1, Nii sc
jjijiji bass .,1,,
jjN bd , jiji dd ,1,
ci
bi
bi
ci
di,j
si,j
82
Changing global data dependencies into local data dependencies
So the alternative locally recursive graph becomes:
j1,iji,1ji,ji, .dass
j
N
j jii bac
1
0 , .
01, is
1, Nii sc
jjK, bd
jiji dd ,1,
s0,2=c0
b0=d4,0
PEPE PE
PEPE PE
PEPE PE
PEPE PE0
0
0
0
s1,2=c1
s2,2=c2
s3,2=c3
b1=d4,1 b2=d4,2
s0,0 s0,1
s1,0
s2,0
s3,0
s0,-1
s3,-1
d1,0
d2,0
d1,1Relations:
3,2,1,0i 2,1,0j
(K = 4)
(N = 3)
83
Shift-invariant graph
Consider an N-dimensional dependency graph with processing elements PE at locations (i,j,k, ...) .
Base (1,0,0,..), (0,1,0,..), (0,0,1,...), ... .
If for any (i,j,k, ...) and for any input x of the PE at (i,j,k, ...) that is delivered by the output x of PE at (p,q,r,... ), holds that the input x of the PE at (i,j+1,k,...) is delivered by the output x of the PE at (p,q+1,r,... ), then the graph is called shift-invariant in the direction (0,1,0,..).
j
iSh-Inv in direction i and jSh-Inv in direction i
84
Shift-invariant graphs (Examples)j
i
Sh-Inv in direction i and j
Sh-Inv in no direction
Sh-Inv in no direction
Sh-Inv in direction j
85
Shift-invariant graphs
Because the inputs and outputs often negatively influence the shift-invariance property, the inputs and outputs are treated separately.
Hence, we always distinguish between
• Input edges,
• Output edges and
• Intermediate edges
86
Dependeny Graphs
Conclusions:
Associative operations give two alternative DG’s.
Input, output and intermediate edges will be treated separately.
Transformation from global to local dependencies gives two alternative DG’s.