Format of the Lecture - PowerPoint PPT Presentation

Format of the lecture l.jpg
Download
1 / 71

  • 173 Views
  • Updated On :
  • Presentation posted in: Funny / Jokes

Format of the Lecture. Four programming problems; We will solve two problems in the morning and two in the afternoon; Question time after the presentation on each problem; Please ask questions. Programming Competition. Enduring Principles. Fundamental algorithms, Data flow analysis,

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

Download Presentation

Format of the Lecture

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Format of the lecture l.jpg

Format of the Lecture

  • Four programming problems;

  • We will solve two problems in the morning and two in the afternoon;

  • Question time after the presentation on each problem;

  • Please ask questions.


Programming competition l.jpg

Programming Competition


Enduring principles l.jpg

Enduring Principles

  • Fundamental algorithms,

  • Data flow analysis,

  • Entity-relationship analysis,

  • Pseudo-code,

  • Algorithmic transformations.


Traffic lights l.jpg

Traffic Lights


Three essential requirements l.jpg

Three Essential Requirements

  • The traffic lights had to execute a basic cycle, giving right-of-way to each of the North, East, South and West branches one after another.

  • If, during execution of the basic cycle, there were no vehicles waiting at the next branch, that branch should be skipped and right-of-way should be passed to the next branch with vehicles waiting.

  • If there were no vehicles waiting at any branch, the sequence should revert to the basic cycle, as if there were vehicles waiting at all the branches.


Operating system interface l.jpg

Operating System Interface

interface TrafficSystem {

static final intRED = 0;

static final intAMBER = 1;

static final intGREEN = 2;

// Traffic light colour codes

void display (int northColour, int eastColour,

int southColour, int westColour);

// Set the traffic light colours

}

abstract class TrafficApp {

abstract void initApp (TrafficSystem);

// Initiate application

abstract void tick ();

// Process clock tick

abstract void vehicleWaiting (int northWait,

int eastWait, int southWait, int westWait);

// Change in vehicle waiting inputs

}


Top to bottom pseudo code l.jpg

Top-to-Bottom Pseudo-Code

Wait for call to initApp; -- ‘UNINITIATED’ state

Branch = NORTH;

Loop:

Display green light combination (branch);

For green time (branch):

Wait for a clock tick; -- ‘GREEN’ state

Display amber light combination (branch);

For amber time (branch):

Wait for a clock tick; -- ‘AMBER’ state

Read waiting-data;

Branch = Next (branch, waiting-data);

End loop


State transition table l.jpg

State Transition Table


Data flow diagram l.jpg

Data Flow Diagram


Next branch function l.jpg

Next Branch Function

  • Symbolic constants can be defined to represent each of the branches. For example:

    static final intNORTH= 0;

    static final intEAST= 1;

    static final int SOUTH= 2;

    static final intWEST= 3;

  • A further symbolic constant can be defined to represent the number of branches. For example:

    static final intNBRANCES = 4;


Slide11 l.jpg

Basic Cycle Alternatives


Basiccycle l.jpg

basicCycle

int

basicCycle (

intbranch)// Branch number

{

branch ++ ;

if (branch >= NBRANCHES) branch = 0;

return branch;

}


Vehiclewaiting l.jpg

vehicleWaiting

boolean [] waitFlag;// Vehicle waiting flags

// allocated in constructor

void

vehicleWaiting (

intnorthWait,

inteastWait,

intsoutWait,

intwestWait)

{

waitFlag[NORTH] = northWait != 0;

waitFlag[EAST] = eastWait != 0;

waitFlag[SOUTH] = southWait != 0;

waitFlag[WEST] = westWait != 0;

}


Nextbranch version one l.jpg

nextBranch version One

int

nextBranch (

int branch, // Branch number

int [] waitFlag) // Wait flags

{

if (

waitFlag[NORTH] || waitFlag[EAST] ||

waitFlag[SOUTH] || waitFlag[WEST]

) {

do

branch = basicCycle(branch);

while ( ! waitFlag[branch] );

} else {

branch = basicCycle(branch);

}

return branch;

}


Nextbranch version two l.jpg

nextBranch version Two

int

nextBranch (

int branch, // Branch number

int [] waitFlag) // Wait flags

{

int oldBranch; // Old branch number

oldBranch = branch;

do

branch = basicCycle(branch)

while (!waitFlag[branch] && branch!=oldBranch);

if ( ! waitFlag[branch])

branch = basicCycle(oldBranch);

return branch;

}


Nextbranch version three l.jpg

nextBranch version Three

int

nextBranch (

int branch, // Branch number

int [] waitFlag) // Wait flags

{

int i; // General purpose index

i = 0;

do {

branch = basicCycle(branch);

i ++ ;

} while (i <= NBRANCHES && !waitFlag[branch]);

return branch;

}


Making use of tables l.jpg

Making Use of Tables

static final int RED= TrafficSystem.RED;

static final int AMBER= TrafficSystem.AMBER;

static final int GREEN= TrafficSystem.GREEN;

static final int greenComb[][] = {

{GREEN, RED, RED, RED},

{RED, GREEN, RED, RED},

{RED, RED, GREEN, RED},

{RED, RED, RED, GREEN}

};

/* Display green light combination */

os.display (

greenComb[branch][NORTH],

greenComb[branch][EAST],

greenComb[branch][SOUTH],

greenComb[branch][WEST]

);


The initapp and tick methods l.jpg

The initApp and tick Methods

class MyTrafficApp

extends TrafficApp

{

static final intgreenTime[] = {30, 60, 40, 50};

static final intamberTime[] = {5, 5, 5, 5};

intticksRemaining;

static final intGREEN_STATE = 0;

static final intAMBER_STATE = 1;

intstate;// State variable

TrafficSystemos; // Reference to OS

//-----------------------------------------------------------


Initiate application l.jpg

Initiate Application

void

initApp (

TrafficSystem ts) // Reference to OS

{

lightSys = ts;

branch = NORTH;

os.display (greenComb[branch][NORTH], /*…*/ );

state = GREEN_STATE;

ticksRemaining = greenTime[branch];

}


Clock tick green state l.jpg

Clock Tick, Green State

void

tick ()

{

switch (state) {

case GREEN_STATE:

ticksRemaining -- ;

if (ticksRemaining <= 0) {

os.display (amberComb[branch][NORTH], /*…*/);

state = AMBER_STATE;

ticksRemaining = amberTime[branch];

}

break;


Clock tick amber state l.jpg

Clock Tick, Amber State

case AMBER_STATE:

ticksRemaining -- ;

if (ticksRemaining <= 0) {

// waitFlag loaded by vehicleWaiting

branch = nextBranch (branch, waitFlag);

os.display (greenComb[branch][NORTH], /*…*/);

state = GREEN_STATE;

ticksRemaining = greenTime[branch];

}

break;

}

}

}


Summary of techniques l.jpg

Summary of Techniques

  • Conversion of a top-to-bottom sequence into an event-driven finite state machine.

  • Transferring data from one process to another using global or class-instance memory.

  • Programming a simple search in a modular domain.

  • The use of static data tables to drive an application program.


Data projection and sorting l.jpg

Data Projection and Sorting


Data format and field list l.jpg

Data Format and Field List

Example customer file:

custId name typeCode region address

Example field name string:

region, name, typeCode

Example output:

AUS Humphrey Bear Host

US Donald Duck Comic

US Goofy Comic

US Michael "Micky" Mouse Comic


Data flow diagram25 l.jpg

Data Flow Diagram


Selected columns table l.jpg

Selected Columns Table

If the string of field names was:

region, name, typeCode

Then the selected columns table should contain:

int [] selColArr; // Selected column array

int selColCnt; // Selected column count

selColArr = new int [5];

selColArr[0] = 3; // region

selColArr[1] = 1; // name

selColArr[2] = 2; // typeCode

selColCnt = 3; // number of columns


Field string bnf l.jpg

Field String BNF

fieldString : paddedName

| fieldString ',' paddedName

;

paddedName : spaces fieldName spaces

;

spaces : /* empty */

| spaces ' '

;

fieldName : fieldChar

| fieldName fieldChar

;

fieldChar : ['a'..'z', 'A'..'Z']

;


Field string railway diagram l.jpg

Field String Railway Diagram


String translator l.jpg

String Translator

sr = new StringReader (fieldString);

ch = sr.read();

for (;;) {

while (ch = ' ') ch = sr.read();

if ( ! fieldChar(ch))

reject ("invalid field identifier");

sw = new StringWriter ();

while (fieldChar(ch)) {

sw.write (ch);

ch = sr.read();

}

while (ch = ' ') ch = sr.read();

// append column sw.toString() to table

if (ch != ',') break;

ch = sr.read();

}

if (ch != -1) reject ("unexpected character");


Look up the column number l.jpg

Look up the Column Number

static final String [] colNames = {

"custId", "name", "typeCode",

"region", "address"

};

int i; // General purpose index

for (

i = 0;

i < colNames.length &&

! colNames[i].equals(sw.toString());

i ++

);

if (i >= colNames.length)

reject ("unrecognised field name");

selColArr[selColCnt++] = i;


Reading the customer file l.jpg

Reading the Customer File

static final intMAXCUSTROWS = 100000;

static final intNUMCOLS = 5;

String [] [] custArr;// Customer array

intcustCnt;// Customer count

custArr = new String [MAXCUSTROWS] [];

custArr[0] = new String [NUMCOLS];

// and so on as required


Sorting the customer table l.jpg

Sorting the Customer Table

Arrays.sort (

custArr, // reference to array

0, // beginning of sort range

custCnt, // end of sort range

new CustComp (selColArr, selColCnt)

// reference to an object that

// compares the array rows

);


Customer table comparator l.jpg

Customer Table Comparator

class CustComp

implements Comparator

{

int [] selColArr; // Selected columns table

int selColCnt; // Selected columns count

CustComp (

int [] sca, // Selected column array

int scc) // Selected column count

{

selColArr = sca;

selColCnt = scc;

}


The compare method l.jpg

The compare Method

public int

compare (

Object row1, // First customer row

Object row2) // Second customer row

{

int i; // General purpose index

int c; // Result of comparison

for (i = 0; i < selColCnt; i++) {

c = ((String[])row1)[selColArr[i]].compareTo (

((String[])row2)[selColArr[i]]

);

if (c != 0) return c;

}

return 0;

}


Summary of techniques35 l.jpg

Summary of Techniques

  • Data flow analysis of a straightforward application program.

  • Use of a table to map columns in the Customer File to the sort order and report layout.

  • Single look-ahead character data stream translation.

  • Using a table to convert an identifier to a column number.

  • Making use of polymorphism to implement a standard interface to support the sort system call.


The good ship lollypop l.jpg

The Good Ship Lollypop


Description of the problem l.jpg

Description of the Problem

  • Download time too long 20 to 30 minutes to download 1Mb daily.

  • Need to reduce this to 5 minutes to complete daily routine on time.

  • ISP proposes 256 kbps leased line to ground station for RM120,000.

  • Technician proposes multithreaded protocol (8 threads).


The programming task l.jpg

The Programming Task

  • Write a simulation program to estimate the transfer time for:

    • the single-threaded protocol at 42.6 kbps,

    • the single-threaded protocol at 256 kbps,

    • an 8-threaded protocol at 42.6 kbps.


Bandwidth and propagation time l.jpg

Bandwidth and Propagation Time


Asynchronous character frame l.jpg

Asynchronous Character Frame

data bits


Asynchronous transmission time l.jpg

Asynchronous Transmission Time

Transmission time formula:

B N

f

Where:

t

t

B

N

f

=

=

=

=

=

transmission time;

number of bits

per byte (10);

number of bytes in

the datagram;

bandwidth.


Generalisation of the problem l.jpg

Generalisation of the Problem

  • Two of the configurations are single-threaded protocols.

  • Single-threaded protocols can be analysed mathematically, though lost datagrams add an interesting twist.

  • The third protocol is multi-threaded. It resists a simple mathematical solution.

  • If we create a generalised model for the third analysis, it can be applied to the other two as well.


State transition diagram l.jpg

State Transition Diagram


Simulator data flows l.jpg

Simulator Data Flows


Thread state transitions 1 4 l.jpg

Thread State Transitions 1/4


Thread state transitions 2 4 l.jpg

Thread State Transitions 2/4


Thread state transitions 3 4 l.jpg

Thread State Transitions 3/4


Thread state transitions 4 4 l.jpg

Thread State Transitions 4/4


Serial transfer state transitions 1 2 l.jpg

Serial Transfer State Transitions 1/2


Serial transfer state transitions 2 2 l.jpg

Serial Transfer State Transitions 2/2


Simulator executive l.jpg

Simulator Executive

  • Current virtual time = 0;

  • Initiate threads;

  • While threads are not finished;

    • Search the threads and the serial transfer processes that are currently waiting for time to elapse and select the process ‘p’ with the earliest value of ‘next time’;

    • Current virtual time = p’s next time;

    • Trigger ‘next time reached’ in p;

  • End while;

  • Current virtual time is the file transfer time.


Summary of techniques52 l.jpg

Summary of Techniques

  • Analysis of datagram transfer times over long and short distances and at varying bandwidths.

  • Determining asynchronous character transfer rates.

  • Conversion of a description of a protocol into a state transition diagram.

  • Conversion of the protocol state transition diagram into a data flow diagram of the simulator.

  • Representing the processes on the data flow diagram as finite state machines.

  • Designing an executive to schedule the execution of the processes on the data flow diagram.


Old tape data recovery l.jpg

Old Tape Data Recovery


Tape format l.jpg

Tape Format


Directory format l.jpg

Directory Format


Objective l.jpg

Objective

  • Write a computer program to accept a file name as an input parameter, extract the file from the tape and write it to the local disk drive.


Complications l.jpg

Complications

  • No null terminator for 16-character file names.

  • Byte order is big-endian, computer is little-endian.

  • Tape can only be read sequentially and rewound. No random access.

  • File extraction program cannot use more than 500Kb of data RAM.

  • Read the tape in the minimum number of passes.


Entity relationship diagram l.jpg

Entity Relationship Diagram


Big to little endian conversion l.jpg

Big to Little-Endian Conversion

unsigned long

BigEndtoLong (

unsigned char b[4]) // Big endian number

{

unsigned long l; // Long value

l = b[0];

l = (l << 8) | b[1];

l = (l << 8) | b[2];

l = (l << 8) | b[3];

return l;

}


Basic strategy of the gatherers l.jpg

Basic Strategy of the Gatherers


Gathering data blocks l.jpg

Gathering Data Blocks

Gather data block 0

Gather Data Blocks

Gather data block 1

Gather data block 2

Gather data block ‘n-1’


How many data blocks l.jpg

How Many Data Blocks?

The number of data blocks can be calculated using the following formula:

Where:

Nd

Nd

Fs

Bs

=

=

=

=

(Fs + Bs – 1) / Bs

the number of data blocks;

the file size;

the block size.


Gather an individual data block l.jpg

Gather an Individual Data Block

  • Receive the data block number from either the Select Directory Entry or Gather Pointer Blocks process;

  • Repeat:

    • Receive a tape block;

  • Until the tape block number matches the data block number received earlier;

  • Write the data block to its correct position in the Recovered Disk file.


Gather an individual pointer block l.jpg

Gather an Individual Pointer Block

  • Receive the pointer block number from either the Select Directory Entry or Gather Pointer-Pointer Block process;

  • Repeat:

    • Receive a tape block;

  • Until the tape block number matches the pointer block number received earlier;

  • For each data block number in the pointer block:

    • Send the data block number to the appropriate Gather Data Block sub-process;

  • End for.


Main line l.jpg

Main Line

  • Open the tape device.

  • Read blocks 0 to 31 and pass them to the Select Directory Entry process;

  • Repeat:

    • For each remaining tape block:

      • Read the block from the tape;

      • Broadcast the block to the block gathering sub-processes;

    • End for;

    • Rewind the tape;

  • Until all the data blocks have been written to the disk file;

  • Close the tape device.


Client client standoff l.jpg

Client-Client Standoff


Gathering blocks in server mode l.jpg

Gathering Blocks in Server Mode


Programming practicalities l.jpg

Programming Practicalities

  • Data gathering sub-processes could be programmed as object-oriented classes.

  • Consider the data memory usage of the block gathering sub-processes.

  • 1 byte for state, 4 bytes for block number.

  • Up to 66,051 data and pointer blocks.

  • 5 x 66,051 = 330,255

  • Word alignment, 8 x 66,051 = 528,408 Oops!

  • Use separate arrays for state variables and block numbers.

  • In the example solution the data and pointer gathering state transitions were programmed in-line.

  • Last data, pointer and pointer-pointer blocks may all be only partly full.


How many passes l.jpg

How Many Passes?

  • The first pass can gather the directory entry and any pointer-pointer block, thus obtaining all the pointer block numbers.

  • A second pass can gather all the pointer blocks, thus obtaining all the data block numbers.

  • A third pass can gather all the data blocks.


Summary of techniques71 l.jpg

Summary of Techniques

  • Analysis of a simple predefined data structure (the organisation of blocks on the tape).

  • Byte order conversion.

  • Deciding between hunting and gathering.

  • Division of a large problem into manageable processes using data flow analysis.

  • Rounded-up integer arithmetic.

  • Representation of the processes on the data flow diagram in pseudo-code.

  • Resolution of a client-client standoff.

  • Conversion of pseudo-coded client-mode processes into server-mode finite state machines.

  • Dealing with an assortment of minor practicalities.


  • Login