a_ algorithm 1 three points in x_ x and x

Document Sample
a_ algorithm 1 three points in x_ x and x Powered By Docstoc
					                                                                   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
     3.4 Threads

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
Address                                           Arbiter
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