# a_ algorithm 1 three points in x_ x and x

Document Sample

```					                                                                   1

A DISTRIBUTED PARALLEL ARCHITECTURE
USING CLIENT SERVER MODEL FOR
PARAMETER TRACKING ALGORITHMS
David Al-Dabass*
David Evans *
Siva Sivayoganathan**

* Department of Computing and Mathematics
** Department of Mechanical & Manufacturing Engineering
Nottingham Trent University, Nottingham NG1 4B, England.
Email: david.al-dabass@ntu.ac.uk
Tel: (0044)-115-848-6015 Fax: (0044)-115-848-6518

1. Parameter Tracking Algorithms

1.1 Multi point algorithms
1.2 Single point algorithms

2. Simulation Model
3. Distributed Parallel Architecture

3.1. Shared memory
3.2 Global Bus
3.3 Client Server

4. Quality of Parameter Tracking Algorithms
5. Speedup Factor

5.1 Client/Server Speed Ratio

5.2 Far & Fast vs. Near but Slow Clients
2

WHY TRACK PARAMETERS?

- Reduced order models of complex physical, financial, biological,
societal systems need

- Time varying parameters for accurate emulation of behaviour

- Static, off-line, estimates of these parameters are no good

- Need online estimation algorithms that can work

- Continuously in real time to track the parameters as they change

- Give indication of cyclic patterns and stability to predict

- Maximum or minimum values and WHEN they are likely to occur

EXAMPLES:

HIGH PERFORMANCE MAN-MACHINE SYSTEMS:

E.g. pilot/driver-aircraft/submarine/spacecraft/tank
Control engineer-industrial/chemical/nuclear plant

- machine monitors man's behaviour to detect signs of deteriorating
performance

- formulate a dynamical model of man's behaviour

PATTERN RECOGNITION, data compression

DATA MINING FOR PREDICTION

Sales figures, FTSE 100 index,

Stability and cyclic analysis
3

A Algorithm 1: Three-Points in x, x' and x''

Consider estimating ,  and u using three sets of x, x' and x'':

 x1'' + 2. x1' + x1 = u                  (1)
 x2'' + 2. x2' + x2 = u                  (2)
 x3'' + 2. x3' + x3 = u                  (3)

Subtracting (2) from (1) and (3) from (1) to give:

.( x1'' - x2'' ) + 2.  x1' - x2' ) + ( x1-x2 ) = 0 (4)
.( x1'' - x3'' ) + 2.  x1' - x3' ) + ( x1 - x3 ) = 0 (5)

Divide (4) by  x1' - x2' ) and (5) by  x1' - x3' ) to give:

.( x1'' - x2'' ) /  x1' - x2' ) + 2. + ( x1 - x2 ) / x1' - x2' ) = 0
(6)

.( x1'' - x3'' ) /  x1' - x3' ) + 2. + ( x1 - x3 ) / x1' - x3' ) = 0
(7)

and subtracting gives:

.[( x1'' - x2'') /  x1' - x2') -(x1'' - x3'') / x1' - x3')] +
[(x1 - x2) /  x1' - x2') - (x1 - x3) / x1' - x3')=0               (7-a)

Using the following notations:

(x1- x2), ' x1' - x2'), ''( x1'' - x2'')
(x1 - x3), ' x1' - x3'), ''( x1'' - x3'')

we get expressions for estimated  estimated using (4), and
estimated u:

4

''''''''
 = [-E.'''
Eu = E. x1'' + 2...E . x1' + x1

B Algorithm 2: Two-Points and One Extra Derivative

Consider using two sets of x, x', x'' and x'''.

 x1'' + 2. x1' + x1 = u                    (8)
 x2'' + 2. x2' + x2 = u                    (9)

Subtracting (9) from (8) and dividing by x1' - x2'):

.( x1'' - x2'' ) /  x1' - x2' ) + 2. + ( x1 - x2 ) / x1' - x2' ) = 0
(10)

Differentiating (10) with respect to t gives:
 x1' - x2' ). ( x1''' - x2''' )]- ( x1'' - x2'' )2]/ x1' - x2` )2 + 0 + [
x1' - x2' )2 - ( x1 - x2 ).( x1'' - x2')] / x1' - x2' ) = 0
(11)

Using the following notations:

(x1 - x2), ' x1' - x2'),
''( x1'' - x2'') and '''( x1''' - x2''')

We get expressions for estimated , estimated  using (10), and
estimated u:

2 = '). (''' ) - ('' )2]/ [' )2 -  .'']
 = [-E.''' -  /'] / [2.E ]
Eu = E. x1'' + 2...E . x1' + x1
5

SINGLE POINT ALGORITHMS

a) Constant Parameters

Consider using the 1st to 4th time derivatives at a single point. Given
the second order system:

 x'' + 2. x' + x = u                 (12)

Differentiate with respect to t and divide by x'':

 x'''/ x'' + 2.  + x'/ x'' = 0                     (14)

and differentiate with respect to t again to give:

.[(x''. x'''' - x'''2) / x''2] + 0 + [(x''2 – x'. x''') / x''2] =0   (15)

We get expressions for estimated , estimated  using (14), and
estimated u:

2 = [x''. x'''' - x'''2] / [x'. x''' - x''2]
 = -[E x''' + x'] / [2. Ex'']
Eu = E. x'' + 2..E . x' + x

b) First Order Parameters:

Let the first time derivative of u to be non zero. For simplicity
assume that both a and b (the coefficients of x'' and x' to make
symbol manipulation easier) to be constant and hence disappear on
first differentiation. The extra information needed for u' to be non
zero is extracted from the 5th time derivative of the trajectory.
6

a.x'' + b.x' + x = u                       (16)

Differentiate wrt to t and assume u' is non zero to give:

a.x''' + b.x'' + x' = u'                   (17)

Differentiate again and set u'' = 0 gives:

a.x'''' + b.x''' + x'' = 0                 (18)

Divide Equation 4 by x''' to isolate b:

a.x''''/x''' + b + x''/x''' = 0            (19)

Differentiate again to eliminate b:

a.(x'''''.x'' - x''''2 )/x'''2 + (x'''2 - x'' . x'''')/x'''2 = 0          (20)

Re-arranging for a gives:

a = (x'' . x'''' - x'''2 )/(x''''' . x''' - x''''2 )               (21)

Solve for b by substituting a from equation 21 into equation 19:

b = -x''/x''' - a.x''''/x'''

Substituting for a and manipulating gives:

b = (x''.x''''' - x'''.x'''')/(x'''''2 - x''' . x''''')            (22)

We can now substitute these values for a and b into equation 16 to
solve for u,

u = a.x'' + b.x' + x
7

x2

w  w  x4    2  z w  x2        w  w  x1

0
x5

( wu  wu  uu )     2  zu  wu  x5          wu  wu  x4

D( t  x)                                    G x1      x6

G1  G x1          x6          x7

G2  G1  G x1           x6          x7         x8

G3  G2  G1  G x1            x6          x7         x8        x9

G4  G3  G2  G1  G x1         x6          x7        x8        x9        x10

G5  G4  G3  G2  G1  G x1        x6          x7         x8        x9        x10   x11

Figure 1: rows 1 and 2 from the top show the 2nd order system; row
3 is not used; rows 4 and 5 simulate the input parameter as a
second order subsystem; rows 6 to 11 produce estimated x and its
time derivatives x', x'', x''', x'''', x'''''
8

Distributed Parallel Architecture Model

Master
Proc-1    Proc-2    Proc-i   Proc-n
Processor   Request
Shared
Queue
Memory
SMAM       SMAM     SMAM     SMAM
Monitor-

Switch
with
SGB       SGB      SGB       SGB
Global
Bus

GLOBAL BUS
Shared
Memory
9

Server: holds current values of all state
Client Threads                   variables and parameters, full derivative
vector of N arithmetic operation + full
|     |    |   |                     arithmetic operations to update parameters:
|     |    |   |
Shared
Initialise
|     |    |   |                     send to each client: initial values of state
Data       variables, program to execute arithmetic
C1    C2 C3    CNC                   operations for a derivative vector segment
File       (N/NC arithmetic operations unique to each
client).
Iterate:
1. clients execute their programs on their
allotted part of the derivative vector.
2. clients produce their individual results
and send back to server.
3. Server puts results together to form the
updated state variables x, x', x'', x''', x'''' etc.
5. update the parameter values.

Initialise:            Initialise:        Initialise:                    Initialise:
- Program to           - Program to       - Program to                   - Program to
compute next           compute next          compute                     compute next
value.                 value.                next value.                 value.

Iterate:               Iterate:           Iterate:                       Iterate:
- Current state        - Current state    - Current state                - Current state
vector value           vector value       vector value                   vector value
- compute              - compute          - compute                      - compute next
next value.            next value.        next value.                    value.
- send results         - send results     - send results                 - send results
to server.             to server.         to server.                     to server.

Client C3                          Client CNC
Client C1              Client C2
10

1.854

1.8

u
n1            1.6
1

u1
n1
1.4
1

Z
n1  5
1.2
a
n1
10
1
a1
n1

b
n1            0.8
100

b1
n1              0.6
10

Ew
n1
0.4
10000

Ew1
n1
10000             0.2

0

0.037         0.2
0    50   100   150   200   250   300   350    400
10                      n1                      400

Results of the fourth algorithm for half second integration time.

1.854

1.8

u
n1         1.6
1

u1
n1
1.4
1

Z
n1  5
1.2
a
n1
10
1
a1
n1

b
n1         0.8
100

b1
n1           0.6
10

Ew
n1
0.4
10000

Ew1
n1
10000          0.2

0

0.023      0.2
0   50   100   150   200   250   300   350   400
10                     n1                     400

Results of the fourth algorithm for one second integration time.
11

Expected Speedup

Speedup Model: S = 1/(1/(1 + R*N) + a + b*N)
R is Client/Server speed ratio
Slow Clients: client processor 1/2 speed of server
Fast Client: Client processor is 2x speed of server

80
70 .46 1

60

SlowClients ( N)
40
FastClients( N)

20

1.5     0

1
1        10   NN     10 0      103
1 1103
12

Fast Distant clients vs. Near Slow clients

Near but Slow clients: 1/2 speed of server, a = b = 10^-5

Far but Fast clients: 2x speed of server, but
comm's take 10x longer, a = b = 10^-4

15 0
11 1.92 9

10 0
NearSlow Clients( N)
FarFastClients( N)
50

1.5       0

NN          1 103
11                               3
10         10 0     1 10

```
DOCUMENT INFO
Shared By:
Categories:
Stats:
 views: 3 posted: 2/3/2010 language: English pages: 12