DIB on the Xerox workstation

Theses

Thesis/Dissertation Collections

1986

DIB on the Xerox workstation

Chien-Kuo Chuang

Follow this and additional works at:

http://scholarworks.rit.edu/theses

This Thesis is brought to you for free and open access by the Thesis/Dissertation Collections at RIT Scholar Works. It has been accepted for inclusion in Theses by an authorized administrator of RIT Scholar Works. For more information, please contactritscholarworks@rit.edu.

Recommended Citation

by

Chien-Kuo Eric Chuang

A thesis, Submitted to

The Faculty ofthe School of Computer Science and Technology,

in partial fulfillment of the requirements for the degree of

Master of Science in Computer Science

Approved by: _

Professor John L.Ellis

Professor Andrew T.Kitchen

Professor Margaret M.Reek

I

hereby grant permission to the

Wallace Memorial Lib

rary,

of RIT

,

to reproduce my thes

is

in

whole or in part

.

Any reproduction will not be for commercial use or prof

it.

criticisms.

I am _extremely grateful to Professor Raphael Finkel for his guidance

during the implementation of this project. Without his _help, this thesis would have been impossible.

Most of all I would like to thank _{my family,} for their support and

purpose package which allows applicationsthatusetree-traversal algorithms

such as backtrack and _{branch-and-bound} to be _{easily implemented} on a multicomputer.Theapplication program needsto_{specify only}the rootofthe

recursion _tree, the computation to be performed at each _node, and how to

generate children at each node. _{In addition, the} application program _may

optionallyspecify howto synthesizevaluesoftreenodesfromtheirchildren's

valuesand howtodisseminateinformation in thetree. DIB usesa distributed

algorithm, transparent to the application _programmer, that can divide the

problem into subproblems and _dynamically allocate them to _any number of

machines. Itcan also recoverfrom failures of machines. DIB can now run on

the Xerox workstation network at Rochester Institute of Technology.

Speedup is achievable for exhaustive traversal and _{branch-and-bound,} with

1. INTRODUCTIONANDBACKGROUND 1

1.1 General Description 1

1.2 Description Of The General Class OfProblems 2

1.3 DIB AndTheOperating System 3

2. RELATED WORK 4

3. THE UNDERLYING ALGORITHM 6

3.1 Algorithm For Distribution 6

3.2 Algorithm For Fault Tolerance 8

4. IMPLEMENTATION 10

4.1 HostImplementation 10

4.2 Node Implementation 16

4.3Communication Interface Implementation 24

5. USER INTERFACE 27

6. EXPERIMENTS 30

6.1 Description Of TheApplications 30

6.2 Results 36

7. IMPLEMENTATION EXPERIENCES 41

8. FURTHER RESEARCH ANDCONCLUSIONS -44

BIBLIOGRAPHY 45

APPENDIX A: USERMANUAL 47

APPENDIX B: SAMPLE APPLICATION PROGRAMS 52

APPENDIX C: EXECUTION RESULTS 64

advanced workstations connected

by

networks. A network ofworkstations

is composed of machines that each can act _{independently} but also can

cooperatewith othersthrough messages. Algorithms that take advantage of

these architectures are of great importance. Such algorithms can _employ

workstationsthatare

frequently

idle to _help solve _{computationally} intensive

problems.

It is apparent from experience that _writing distributed programs is

significantly more difficult than _writing sequential programs. Programmers

have to deal with a _variety of new _issues, such as synchronization,

concurrency, communication _protocols, and fault tolerance. In the current

environment,distributed _{programming is left mostly}toexperts.

One _{way to} make distributed _programming easier is to _{develop library}

packages in specific areas. These packages will be suitable _only to specific

applications and will lack the _generality of a _programming language.

Because these packages are _{relatively easy} to use, the distributed part of a

program can betransparentto the user, and programmerswho are unable or

unwilling to master the techniques of distributed programming can still use

the full poweroftheworkstation network.

DIB A Distributed Implementation of _Backtracking is a

general-purpose package which allows applicationsthatusetree-traversal algorithms

such as backtrack and branch-and-bound to be implemented on a

multicomputer. Itwas presented by ProfessorFinkel and Professor Manber in

the "Proceedings of the 5th International Conference on Distributed

Computing

Systems"

and _currently runs on the Crystal multicomputer atthe

University ofWisconsin-Madison. It is easy to use. The application program

information in the tree. DIB uses a _{distributed algorithm, transparent to the}

application _{programmer, that} can divide the problem into subproblems and

dynamically

allocate them to _any number of machines. It can also recover

from failures of machines. This thesis will implement DIB on the Xerox

workstation network at_{Rochester Institute}ofTechnology.

1.2Description Of The General Class Of Problems

The problems that can be supported _by DIB are those for which the

computation is performed _{by traversing} a tree. The tree _{is usually} built

dynamically during the traversal and eachtree node gets initial data from its

parent. The node _may decide to "generate" several children and pass more

datato_them, or it maydecide that it isa _leaf, inwhich case it performssome

computation and passesthe outcome to its parent. Information flows down

the tree asit isbuiltand flows_{up the tree} as subtreescomplete. _{In addition,}a

node can accept new information from its parent after it is generated and

can pass information to its live children. DIB _may expand the frontier ofthe

tree in an _arbitrary order and _may expand the same node twice (to recover

from failures). _However, it ensuresthat the information reported back to a

node from its children represents _exactly one instance of _every descendant.

The onlyrequirement oftheapplication for using DIB isthateachsubtree can be _correctly searched without _any knowledge of the outcome of _any other

search. The outcome of other searches _may affect the _efficiency of

computation, butitmust not affectthe correctness.

There are basicallytwodifferenttypesor classes ofapplicationsthatcan

use DIB. The firstclass ofDIB applications includes exhaustivesearch of atree

ofcombinations. In theseapplicationsthe outcomes of all the leaves haveto

be collected. Each node is either a solution, a dead _end, or an intermediate

situation. In the later case, its children represent alternative ways to

continue.Theoutcomes ofthecomputation ofall the children ofa particular

A second class of applications involves global knowledge that is

improved when a search reaches a leaf. This is the situation in applications

which use branch and _bound, where the global bound is used to prune

further development of unsuccessful branches. The _traveling salesman

problem belongs to this class. In the application program, each node v

computesa _function, called the objective _function, which depends on values

computed _alongthe path fromthe root_{to v,} andthe program intends tofind

the leaf with the minimum value of this function. If a lower bound on the

value ofthe objective function in a subtree rooted at a given internal node v

exceeds the value _already attained _by a _leaf, there is no need to explore

further. A good heuristic is to explore those children with smaller objective

functionvaluesfirstin the hopethat the other children can be pruned.

1.3 DIB And The_Operating System

DIB's requirements from the _operating system are minimal: the

machines must be connected _by a network thatsupports a _{message-passing}

mechanism and each machine must be able to communicate with all other

machinesdirectly; each machine _mayrun ata differentspeed.

There is no need for a clock or a timeout mechanism for DIB. DIB does

not require that _incoming messages generate interrupts. Instead, incoming

messages are buffered; DIB will _periodically check to see if new messages

implementations of specific algorithms and general methods have been

reported. Decompositions of alpha-beta search have been the subject of mucheffort.

Parallel-aspiration search, Baudet _[2], gives the entire problem to each

machine, with each one constrained to find a solution within a different window. Narrowwindows speed _{up the}search.

Mandatory-work-first search, Akl and Barnard _[4], distinguishes between those parts of a subtree that must be searched and those parts

whose needto be searched iscontingent upon search results in otherpartsof

the tree. _{By searching mandatory} nodes _first, the algorithm attempts to

achieve as_manyofthecutoffsseen intheserialcase as possible.

The _{tree-splitting} algorithm was described _by Finkel and Fishburn [3].

The root processor evaluates the root position. Each interior processor

evaluates its assigned position _{by generating} the successors and _queuing

them for parallel assignmentto itsslave processors. Thus a processor at level

N in the processortree alwaysevaluates positions at level N in the lookahead

tree. Asan interior processor receives responsesfrom its slaves, it narrows its

window and tells _working slaves about the improved window. When all

successors have been evaluated (or a cutoff has _{occurred), the} interior

processor is able to compute the value of its position. Each leaf processor

evaluatesits assigned position with the serial alpha-beta algorithm. When a processorfinishes, itreportsthe value computedto itsmaster.

These _{tree-splitting} methods require a fixed machine tree. _They suffer from machines _sitting idle while work is still _{pending in} other parts of the

tree. _They also allocate identical amounts of _processing power to large

regions of the tree, even though the left-most region is most _likely to yield

compute one node of the search tree and then reassign work based on the

current boundsand costfunctions. The amountof communication needed is

very high.

All ofthese approaches require that a logical problem structure (a tree

structure) is mapped in some _way onto the physical machines. Under the

tree-splitting, the _{map is dynamic,} but the machines must be arranged as a

tree and the _map respects tree level. In _DIB, the work is _initially divided

arbitrarily among machines. When machine _Mj finishes the work it was

given, itsendsa "request for

work"

to another machine Mj. If

Mj

is _currently

working, itdivides itswork and sends part ofit to _{Mj; otherwise,} it forwards the request. _So, the DIB program allows a _highly dynamic _{mapping between}

The algorithm is based on a depth-first search of the tree. If there is

only one machine then the computation is straightforward. Suppose there aren work machines _{Mi, M2#} .... Mn, n >1. Each machine Mj maintainstwo

tables, WorkGiven and WorkGotten. WorkGotten records problems that

were received from other machines. _Mj is said to be responsible for these

problems. Finished work is reported to its originator and is removed from

WorkGotten. Thistable therefore allows DIB to pass results back _{up the tree.}

WorkGiven records problems that _Mj has given to other machines. It can

distinguish problemsgiven to other work _machines, and problemsthat have

been generated (or received from elsewhere) but unassigned. When an answer to one ofthese problems is reported, its parent is notified and the entry is removed from WorkGiven. This table allows DIB to determinewhich workit isresponsible forisstill _outstanding andto redoit in case offailure.

In the simple case of _only one work _machine, each table will contain

onlyone entry: the root ofthe tree. The nodes generated _during the search will be stored _temporarily in a stack, not in the tables. The tables are _only used to _keeptrackof parts ofthe tree thatcross machine boundaries.

When machine _Mj hasfinisheda problem and reported itsresult, itpicks

the next problem to attackfrom WorkGiven. Ifthere are several unassigned problems _there, it picks the earliest _{one, the} one that appears first in a symmetric-order traversal of the tree. Unless it needs to subdivide this problem to give some _away to another work _{machine, Mj} uses its stack to

record the progress of the search. If WorkGiven has no available _{work, Mj} sends requests for work to other machines, which are selected _by an algorithmthatwill bedescribed later. WorkGiven might contain unavailable

child _{currently being} searched _by

Mj

is marked as assigned to Mj: its later

siblings are marked as unassigned. Some ofthese later are then sent to Mj.

This subdivision is repeated until at least one unassigned problem is

generated tosend to Mj. _However, ifsubdivision reachesa_{trivial problem,} or

if it reaches the depth at which

Mj

_{is currently working,} the request is not

granted. _Instead, it isforwarded to some otherwork machine. After_dealing with Mj's _request,

Mj

returnsto its own search. Because the time needed to perform a piece of work and the relative speeds of the machines are not

known in advance, they are not used in _determining howmuch workto give away or which machine to ask for work. If _Mj receives what turns out to be the bulk of Mj's work or _suddenly becomes _slow, other machines will finish

their work and get Mj's part. _Thus, DIB contains an

"automatic" load

balancing mechanism.

The strategy used to select work to perform or to give _away tends to work on the earlier parts of the search tree first. However, it does not

guarantee _any particular order of search because of the nondeterministic

nature of workdistribution.

The algorithm for _sending request messages is that each machine _Mj

sends requests for work to k other machines selected at random. The

constant k> = 1 _{may depend} on machine numbers and on the application. If the selected machine

Mj

can not grant the request then it forwards the requestto other machine, if it is forwardable. If the request has already got

3.2 Algorithmfor FaultTolerance

Fault tolerance is a crucial area in distributed computing. In an

environment of personal _{workstations, hardware}orsoftwarefailuresare not the _only types of failures. _{For example,} when an application _{is running} on other _{machines, the} machine's owner _may decide at one point to _stop all

"guest"

processes. Asa _{result, the likelihood} offailures _may be independent

ofthe_hardware,andtheirdistribution maybe unpredictable.

The fault-tolerance algorithm works as follows. When a machine _Mj

finishes itsworkand its WorkGiven table is not _empty, some other machine

still hasworktodo orit is_likelythat thework_Mj gave_awaywentto a _failing

machine. Because _Mj can notdistinguish between these two possibilities and since _Mj hasto wait in any case for another machine to grant its request, it

can use the _waiting time to redo some _outstanding work in its WorkGiven

table. Redundant work has _{low priority} and is discarded if Mj's request is granted with non-redundantwork. If _Mj is asked forworkwhile _computing

redundant _work, it grantsthe request as before, _labelling the work it grants

as redundant. Even thiswork _may be redone by _{Mj later,} at a higher level of redundancy.

Whenever_Mj needsto select work from WorkGiven to perform orgive away, itchooses available work atthe _{lowest redundancy level.} If there is no

availablework, itchoosesworkgiven _awayatthe _{lowest redundancy level} to redo, raising its redundancy in the process. Within a _{redundancy level,} work

earlier inthe tree is chosen. Since the same work _may be performed _by two machines, its result _may be received twice. The first result removes the _entry

from WorkGiven, and the second result is discarded. As long as machine 1 survives,which is responsibleforthe root, thetreewill _eventually besearched

completely.

One problem called theancestral-chain problem _{may happen} in a chain

of processes ancestral to a _failing process. Assume that _Mi gave some work

One methodwhich can be used to reducethis_unnecessary computation

iscalled "tell child". When _mi starts _{redoing work,} it informs 1TI2 ofthis_fact, 1T12 treats this information as a request for work and grants some of its

redundant(but_necessary)workto itsparent mi. This method often curesthe

ancestral-chain _problem, but it still does not ensure that redundant work is

welldistributed.

Thebenefitsofthefaulttolerance algorithm arethatstricttimeoutsare

4. IMPLEMENTATION

The DIB package produces two executable _programs, DIBHost.bcd and DIBNode.bcd. The first program DIBHost.bcd resides on the Host_(supervisor)

workstation and runs _{interactively, asking for} Node _(work) workstation

numbers, _setting up the working environment, asking for problem sizes,

collecting and _printing out the execution results. The second program is

placed on _{every Node} workstation. It communicates _infrequently with the Host program, principally for debugging and statistics collection, and regularly with other Node workstations. Refer to Figure 4.0 DIB's _Working Environment.

4.1 Host Implementation

The data structure for a

"message"

transmitted between machines is shown on Figure 4.1 and the flow chart for the Host program is shown on

Figure 4.2. The Hostprogram works asfollow.

1. Setupenvironment

a. HostgetsNodeworkstation numbersfrom user input.

b. Asks user to input each workstation's name _{(including Host),} and uses

the nametofind eachworkstation's network address.

c. _According to the workstation input order, storesthe network address

in an array.

d. Sends the network address _array and workstation's _number, which is

theirlocation in the array,to every Nodeworkstation.

e. After the set _up step, each Node knows his number, Host's network

DIBHost

DIBNode

1. DIBHost runs interactively.

2. DIBNodecommunicates

infrequently

with the Host

and _regularlywith other Node workstations.

StatusSpecification: TYPE =

{BatchDone,AnAnswer,Quitting,

Reporting, PleaseStop};

MessageType: TYPE =

{

Request,Work,Globallnfo,Result,

Terminate,Synch,RepeatingfUpdating};

Message: TYPE = _RECORD[

specifics: SELECTtype: _MessageClassFROM

AnswerMessage = > _[ Status: _{StatusSpecification,} Prob:_{ApplicDfs.ProblemType,} Times: _TimeType,

Sequence: LONG _INTEGER,

AnswerDewey: DeweyDfs._Dewey],

ProblemMessage = _> [

Kind: _INTEGER,-- 0_meansno

work; 1 meanshere isa problem

Answer: _{AnswerSpecification,} --Full,Count

Prob:_{ApplicDfs.ProblemType,} PartSize: _INTEGER,-- _partition

size

WorkFraction: _INTEGER, < <howmuch togive_awaywhen asked;

0 means give _awaynone; 10means give_away all_work; negative means give_awayone problem(if_possible) > >

NumHelp: _INTEGER,

--how manytoaskwhen outof work

DebugLevel: _INTEGER], < <highernumbers aremore_verbose; 0is

silent >>

InterNodeMessage = > _[

Kind: _MessageType,

Asker: _INTEGER, --node # for Requestand Repeating,

-ownerforWork

Child: ApplicDfs.ProblemType,

ChildDewey: DeweyDfs.Dewey,

Count: INTEGER, --size ofwork,forWork

-numberofhopsfor Request

Somelnfo: ApplicDfs.lnfoType,

Redundancy: INTEGER],

ENDCASE];

Select

Execution Choices

w

Initialize

M^

Get Root Problem And

Send Message

^_

^<^

Quit

^>

Exit

n

Process Messagefrom Nodes And

Waitfor Job done (Ref Figure

4.3)

N/

Print Statistics

After "Set _{up environment",} a menu will be shown on the screen. The

possible execution choices are "

c, f, d, h, n, q ", representing the

following

:

c: _{count, only}thefinal resultwill be reported to Host. The defaultvalue isc.

f: _full,each possible answerwill be reported to Host.

d:

debug

_level; trace the execution of the application program. The

possible value are _1,2,3, and 6. The bigger the number _is, the more detailsofthe executionwill beshown onthescreen. Thedefaultvalue

isO.

h: _helpers, number of helperswhen out of work. Due to the number of

workstationsthatcan be _used, helpersissetto 1 _bydefault. n: new problem (runtheapplication programwithdifferentsizes).

q: quit.

3. After _initializing the variables in the Host program and application

program, the Hostasksthe userto inputapplication problem sizes. _Using

the problem sizes as a _parameter, Host calls application program to

generatethe "RootProblem",theproblemto besolved.

Then Host puts the root _problem, the selected execution choices into a

problem message package,and sendsittoeach Nodeworkstation.

4. After _sending the problem message package, the Host processes each

message transmitted back _by the _Nodes, and waits for the job done message from Node 1. The flow chart for Host waitjob done is shown on Figure4.3. The messagetransmitted back _byeach Node hasthe

following

meaning.

a. Please Stop: Node 1 tellsthe Host to stop.

b. Batch Done: The whole problem has been finished, Node 1 tells the

updated roottothe Host.

c. Reporting: One Node has finished a subproblem; tells the _Dewey

Exit

A

3 Please_Stop

Batch Done

-> Reporting

An Answer

^ Quitting

M

k-^_

Free Message

Finally, the Host prints out the statistics results of the execution in each

Node,and goesback forthe next execution.

4.2 Node Implementation

The data structures for the WorkGotten and WorkGiven Tables is shown

on Figure 4.4 and the flow chart for the Node program is shown on Figure 4.5. The Nodeprogram works asfollow.

1. Node workstations will wait forthe set

up message from Host. After the

message is received, each Node knows his number and each other

workstations'

number and network address. _{Until now,} workstations

could communicatewith each otherdirectly.

2. _Next, Nodeworkstations waitforthe problem messagefrom Host.

3. _Using the execution choices part in the problem _message. Node

workstationsinitializetheirglobal variables.

4. In order to let Node workstations start the execution at _nearly the same

time, the Node workstation with the biggest number sends start _up

messageto theother Nodeworkstations.

5. After synchronizing between Node workstations, Node 1 begins to work

on the problem given _by Host. Other Node workstations will send a

"request forwork"

messageto Node 1 to helpsolvethe problem.

6. The algorithms forwork distribution and faulttolerance have been given

on previoussection. The flowchartsforthe main procedures in the Node

programareshown on Figure 4.6BackTrack, Figure4.7AskForHelp,Figure 4.8 Checklncoming, Figure 4.9 HandleRequest. The _following is the

ID: DeweyDfs.

Dewey,

Owner: _INTEGER, -who is waiting for the results

UnsolvedCount:

INTEGER,

<<how manysubproblems

arestill under computation. > >

Value:

ApplicDfs.ProblemType,

Next:

WorkGottenPtr];

WorkGivenType: TYPE =

RECORD[

ID: DeweyDfs._Dewey,

Value: _{ApplicDfs.ProblemType,}

Worker: _INTEGER, --who is _working on this problem for

--us

Available: _BOOLEAN, <

<may

we work on it?

If not given to anyone,Worker = -1

(Open),

Available=TRUE

If given to machine m,Worker = _m.

Available= FALSE

If given but readyto redo. Worker = _m,

Available=TRUE

If given and I am _redoing, Worker = _m,

Available = FALSE >>

Parent: WorkGottenPtr,

Redundancy: INTEGER,

Next: WorkGivenPtr];

Figure 4.4 Data

Structure

For

WorkGotten

WaitingSet_Up Message

Waiting Problem Message

Initialize

JL

Synchronize

V

Store P InWorkGotten Table AskForHelp (Ref_Fig4.7)

L

Store P In WorkGivenTable

A

"\k"

Checklncoming

(Ref _Fig4.8)

BackTrack

(Ref_Fig4.6) K

A

n

DropOut

n AskForHelp

o

AL

Checklncoming

J

table. It uses an explicit _stack, called _{CurrentProblem,} to store

unfinished work. BackTrack usesthe Depth-Firstsearch to find a child

or a_sibling of current child. Referto Figure4.6.1 Search in BackTrack

fordetail.

b. AskForHelp: PROC[FirstTime: _{BOOLEAN, Begger,}Hops: _INTEGER]

If FirstTime then ask Node 1 for work; afterwards, send a request to

other Nodes (equal to the number of helpers) chosen _by random. If

Begger # _MyName,then forward the request. Alsotell the numberof

hopsto the helpers.

c. Checklncoming: PROC[BusyWait: BOOLEAN]

RETURNS[Abort: BOOLEAN]

Called _periodically to see if other Nodes have asked or forwarded a

requestforsome worktodo. Ifit has,call procedure HandleRequestto

deal with the request. If BusyWait is set, don't return if nothing has

come _in; keep checking. Set Abort totrue ifwork just came in that is

less redundant than the current level. The incoming message hasthe

followingmeaning.

a. Synch: Wait for this message before continuing and set the Start

time.

b. Request: Someone is asking me for work. Call HandleRequest to dealwith the request.

c. Work: Incoming message was a response to my request, or to my

noticethatI am _repeating work.

d. Repeating: Someone is redoing theworkthathe gaveto me. Tryto

granthimsome useful work.

e. Result: Someone hasfinished a problem; I needtotell each parent.

f. Updating: The problem in the incoming message has changed, I

needtoupdatethe problem.

g. Globallnfo: Incoming messagewas newglobal information.

h. Terminate: The whole problem has been finished, Node 1 tells me

SelectJob From WorkGiven Table

A

A

/\

AL

GenerateChild And PutIn Stack

(Ref_Fig4.6.1)

Combine Child Result To Parent

m^_

Generate Next_Sibling Of Current Job

(Ref_{Fig 4.6.1)}

ChecklnComing

Report To Job's Owner

Return

Typical Depth-First Search

CurrentProblem[0]

A Leaf

Pass Result_Up

CurrentProblem[1]

DeweyDelta[Length] = ₁

Combine Result

And_TryGenerate

bliru

DeweyDelta[3] = 2

DecideThe Helper Numbers

)L

Randomly

Chose Helpers

If First_Time,Then First

Helper is Node 1

XL-Send Request ForWork

Message

v

Return

\/

Exit

\/

ReDo

N/

Exit

Terminate

Request Ref_Fig4.9

Work

Result

Globallnfo

Repeating

Updating

Synch

o

JL

Update _LoopCount

\/

>

^ AskForHelp

A

6

d. HandleRequest: PROC[Who: _INTEGER,Hops: _INTEGER]

Called _{from Checklncoming. Who has just asked us for}

work, or we

have decide to pass some work to Who. If there _{is any} work _{to spare,}

send _{it; otherwise, forward the request, if it is forwardable. If it has}

already got Hops = Node _Machines, don't forward _{it. Refer to Figure}

4.9.1 SubdivideWork In HandleRequest about howto subdivide work

from CurrentProblem.

4.3 Communication Interface Implementation

Thecommunication betweenworkstationsisbased onthecommunication

package, NetworkStream. A Networkstream isthe principal means _by which

clients of Pilot communicate between machines. NetworkStream provides

access to the implementation ofthe Sequenced Packet Protocol

--a level 2

Internet Transport Protocol which is defined in Xerox Internet Transport

Protocols. It is supposed to provide _{sequenced, duplicate-suppressed,}

error-free, flow-controlled communication over _{arbitrarily interconnected}

communication networks.

A close protocol which is provided _by Network streams is also used to

implementthe communication interface. This method of_{terminating dialog}

on a stream issuggested in the NS Internet Protocol Specification. But use of

\/

TryTo Subdivide

CurrentProblem

(Ref_Fig4.9.1)

o

_ik_

Select WorkFrom WorkGiven Table

M^

Forward The Request

ik_

Send WorkTo Requester

V

O

Return

GiveAwayDepth = 0

HandleRequestwill _{happen here}

1._Trytosubdivide atGiveAwayDepth_(Root)

2. IfRootis_dividable. Child 1 and hissiblings(ifany)will store in

WorkGiven. All Siblingswill be marked available.

3. IfRootcan not be_divided, itwill increase _{GiveAwayDepth,}

trytosubdivide atChild 1.

To Write an _{application, the} user hasto _supply the

following

procedures:

ApplicFinish, AcceptRoot, AcceptAnswer, FirstProb, Generate, UseNewlnfo, NonTrivial, Combine, Update, Appliclnit, PrintProblem, PrintAnswer. These

procedures are similarto what one would need in a sequential program for

thisapplication.

The _primary procedure is _Generate, which DIB calls whenever it needsthe

nextchild of a node. DIB indicates whether it is _looking for a first child or a

laterone. Theapplication _may respond with a new child or indicate that the

node is a _leaf, and has no children, orthat it has no more children. To start

the entire _calculation, DIB calls FirstProb to generate the root of the search

tree. To printthe result of_{the calculation, DIB} calls PrintAnswer on the root

node oron the host. The _following declarations define DIB's interface to the

application program. Appendix B shows two application _{programs, the}

eight-queensproblem andthetraveling-salseman problem.

**

Typeand Variable

ProblemType: ...theapplication one wishestostore in a node InfoType: ... global informationformat, ifany

**

The _following routines _{specify initial setup} and what to do with results;

they areexecuted on the Hostmachine(supervisor)

FirstProb: PROCEDURE[Size: INTEGER] RETURNS[P: ProblemType];

Generate the root P ofthe problem _tree, where Size is a parameter

selecting which problem of a class is intended. For example, the

eight-queens problem can let Size indicate the dimensions of the

chessboard.

AcceptAnswer: PROCEDURE^: ProblemType];

AcceptRoot: PROCEDURE^: _{ProblemType];}

Pcontainsthe result oftheentire search.

ApplicFinish:_PROCEDURES;

Used to printfinal messageordo housekeeping.

**

DIB callsthe

following

routineson node machines _(work)

Generate: _PROCEDURE!

First: _BOOLEAN,

Parent: LONG POINTER TO_ProblemType, Child: LONGPOINTERTO _ProblemType] RETURNS[Done:_BOOLEAN];

If _First, set Child to first child of Parent. _Otherwise, set Child to the

nextchild ofParent. If thereare no more children, set Done instead.

Generating a child _{may modify local} datawithin Parent.

UseNewlnfo: PROCEDURE[lnfo: _InfoType];

Make use of _Info, which was broadcast _by a different machine. This

information is_typicallyusedto improvea bound.

NonTrivial: PROCEDURE^: ProblemType] RETURNS[BOOLEAN];

Return true if P will take significant computation to complete. DIB

will notdistribute a problem thattheapplication considerstrivial.

Combine: PROCEDURE!

Child: LONG POINTERTO ProblemType,

Parent: LONG POINTERTO ProblemType]

RETURNSfUpdate: BOOLEAN];

Child hasjust finished; record _any information to be passed _{up the}

tree in Parent. If Parent's live children need to be notified

asynchronouslyofParent'snew_situation,set Update to true.

Update: PROCEDURE!

Child: LONG POINTER TO ProblemType,

Parent: LONG POINTERTOProblemType]

its_change, setAgain to true.

**

The

following

routines are used for _{initialization,debugging,} and _printing results. _Theyare invoked both onthe Hostandwork(Node) Machine.

Appliclnit: _PROCEDURE^;

Initialize _{any data}structures.

PrintProblem: PROCEDURE^: _{ProblemType];}

Print P'sproblem description.

PrintAnswer: PROCEDURE^: _{ProblemType];}

PrintP'sanswervalues.

**

The_following routines are provided _by DIBon work machinesand _may be

called _{by the application,}forexample, _during GenerateorCombine.

Broadcastlnfo: PROCEDURE[lnfo: _InfoType];

Lets the application in all machines know about this new information. This_facilityis used in branch and bound.

ReportResult: PROCEDURE^: ProblemType];

6. EXPERIMENTS

Three applications have been implemented and used to test the DIB

package. Their execution _{results are given on Appendix C. The application}

programsforthe eight queens problem and the _traveling salesman problem

aregiven on Appendix B. Statistics data for each application is shown in this

section and the eight-queens problem is also used as an example to show howtowrite an application program.

6.1 Description Of The Applications

1. Theeight queensproblem

Find all possible arrangementsofN_(chess) queens on anN x N boardsuch

that no queen can capture another queen. A count of solutions is passed

up the tree.

Example Result

(QueensProblem)

N = 4

Q2 Q3

Q1 Q4

Q1 Q4

Q2 Q3

The most important part in an application program is how to generate

children at each node. The comments shown in the _step (3) describe the

algorithmto attack this problem. Towrite the application _{program, the} user

MaxProbSize: INTEGER = _{20;-nomorethan this}

manyqueens

QueenArray:TYPE = _ARRAY[1..

MaxProbSize] OF_INTEGER;

<<store the solution, the number represents the queen's position in

each column>>

ProblemType: TYPE = _RECORD[

LeafCount: LONG _INTEGER,

< <ltisa synthesized value generated atthe leavesofthe treeand

ispassed _upas a result of calls to combine. Itcounts thenumber of

arrangementsthat thequeenscan beput on theboard.>>

ProbSize: INTEGER, -dimensionsofthechessboard

Length: _INTEGER,-how_manyqueenshave beenplaced

Queens: QueenArray];

-store queen's position

lnfoType:TYPE =

PACKED_ARRAY[0..1] OFCHARACTER; -pseudodata < KlnfoType isnot neededin queens_application, but it isneeded_by DIBprogram.>>

Title: LONG STRING

<-"Queens"

L;

(2) Code theroot problem

FirstProb: PUBLIC PROCEDURE[Size: _INTEGER]

RETURNS[P: _ProblemType] =

BEGIN

P.LeafCount<-0;

P.ProbSize<-Size;

P.Length<-0; END;

(3) How togenerate children ateach node

Generate: PUBLIC PROCEDURE!

First: BOOLEAN,

Parent: LONG POINTERTO ProblemType,

Child: LONG POINTERTO ProblemType]

RETURNS[Done: BOOLEAN] =

BEGIN

Bad: _BOOLEAN;

-whattododuring thesearch

IF First AND (Parent

f

.Length = ParentT

.ProbSize)THEN

{

- find_a leaf

Done

<-TRUE;

Parent

f

.LeafCount

<-1;

-setleafcount

ReportResultparentf]}

-reportto Host

ELSE {-nota leaf

IF FirstTHEN -- _expectto find

achild

{Child _f

<-Parent_f;

-copyparentdatato child

{OPENChild _f;

Length <-_Length

+ 1_; --_{update child's}length

Queens[Length] <-0}; -initialize

First*-FALSE};

- _searchfor_areasonable

placeforcurrent queen

{OPEN Child |; LeafCount<

0; - initialize

DO

Queens[Length] <-Queens[Length] + _1; ThisQueen _{<-Queens[Length];}

IFThisQueen > ProbSize THEN

{Done

<-TRUE; EXIT};

Seq<-1;

Bad <-_FALSE;

WHILE_Seq < Length

-checkifQueenslSeq]conflicts with Queens[Length]

DO

ThatQueen <-Queens[Seq];

IFfThatQueen = ThisQueen) OR -checkrow

-checkdiagonalposition

(ThatQueen + _Seq Length = ThisQueen) OR

(ThatQueen-Seq + Length = ThisQueen)THEN

{Bad

<-TRUE;

EXIT};

Seq

<-Seq + _1;

ENDLOOP;

IF NOT Bad THEN

{Done*-_FALSE;

EXIT};

Parent: LONG POINTER TO ProblemType]

RETURNS[Update: _BOOLEAN] =

BEGIN

Parent_| .LeafCount

<-_Parent

f.LeafCount + Child f .LeafCount;

Update*-FALSE; END;

(5) How to printtheanswer

PrintProblem: PUBLIC PROCEDURE^: ProblemType] =

BEGIN

Seq: INTEGER <-1;

{OPEN _P; - _printthe

queens'

position

WHILE _Seq < = Length

DO

WriteCharf ];

WriteDecimal[Queens[Seq]];

Seq <-Seq + _1;

ENDLOOP; NewLine[]};

END;

PrintAnswer: PUBLICPROCEDURE^: _ProblemType] =

BEGIN - _print

how manyarrangements

WriteLongDecimalfP.LeafCount];

WriteString["

Leaves _"L];

END;

(6) Otheruseful procedures

Appliclnit: PUBLICPROCEDURE[] =

BEGIN

WriteString[Title];

WriteString["

"];

NewLine[];

END;

NonTrivial: PUBLICPROCEDURE[P: ProblemType]

RETURNS[BOOLEAN] =

BEGIN

, .

RETURN[P.Length < P.ProbSize-2];

BEGIN

PrintProblem[P]; PrintAnswer[P]; END;

AcceptAnswer: PUBLIC PROCEDURE^: _ProblemType] =

BEGIN

PrintProblem[P]; END;

(7) Refer to Appendix _B, put them in Definition and Implementation

module.

2. Knightstour

Find all possible toursa _(chess) knight can take _covering the whole board

except k squares without _repeating a square. (This is _basically a

Hamiltonian path problem.)

Example Result

(KnightsTour)

k = 3

K10 K5 K12 K3

K2 K9 K6

K8 K11 K4 K13

K1 K7

3. Thetraveling-salesman problem

Find a minimal-cost tour of cities. _Inter-city costs are initialized from a

uniform distribution in [0..1]. The application uses a branch and bound

algorithm, broadcasts each _{newly discovered} minimum path cost, and

generateschildren ofa node inclosest-firstorder. Thebestsolutionfound

The Costs Between _Inter-city

0 1 2 3 4 5 6

0 0.51387 0.17574 0.30865 0.53453 0.94763 0.17174 0.70223

1 0.82295 0.15193 0.62548 0.31468 0.34690 0.91720 0.51976

2 0.41450 0.46352 0.97916 0.12644 0.21264 0.95845 0.73746

3 0.44188 0.91502 0.57225 0.11884 0.56977 0.25205 0.49586

4 0.77343 0.24483 0.34282 0.22999 0.29788 0.30455 0.88721

5 0.15877 0.27990 0.13532 0.86419 0.75018 0.20800 0.13996

6 0.39541 0.43220 0.12714 0.45767 0.23783 0.98603 0.65283

Exainple Result (Traveling-Salesman)

7 Cities Visited

New Path 0 5 2 3 6 4 10 (2.23497)

New Path 0 5 2 3 4 16 0(2.16327)

New Path 0 5 2 4 13 6 0(1.97048)

New Path 0 5 6 2 4 13 0(1.65287)

Bestpath 0 5 6 2 4 1 3(1.65287)

6.2 Results

Table 6.1 collects _{the running} times for the queens problem (queen's

number is changed from 8 to 12) for 1 to 5 workstations. The times were

measured by the Host machine. From the table, we can know that if the

problem size is small (if queen's number is lessthan 10), it is notworth to use

more than one machine to run the queens problem. Because the time is

machines, the running

forsmall problemsize.

Figure 6.1 shows timings (in seconds) for the twelve-queens problem.

Thetime curve is measured in seconds. The figure also shows the efficiency,

which isdefined as

{timefori _machine}over{n x (timeforn_machines)}

The efficiency is generally above _90%, and seems to degrade quite _slowly as

extra machinesareadded.

Table 6.2 and Figure 6.2 show the statistics data gathered from the

knights tours problem and Table 6.3 and Figure 6.3 show the statistics data

Queen #

1 2 3 4 5

8 0:2.39 0:5.05 0:5.04 0:6.27 0:7.41

9 0:12.89 0:9.95 0:10.26 0:11.18 0:10.27

10 1:3.7 0:40.5 0:31.4 0:23.9 0:21.5

11 5:45.6 2:57.5 2:3.4 1:35.2 1:23.0

12 33:51.8 16:59.9 11:27.5 8:36.5 7:0.0

Table 6. 1 QueensProblem _Testing Result

1800

-1200

-600

-(Sees)

For12 Queens

Efficiency

2 3 4

NumberofWorkstations

Figure6.1 TheQueens Problem

-100

-98

-96

- 94

-90

-88

Board Dimension

RunningTimesfor 1 to 5workstations

1 2 3 4 5

3 0:0:0.534 0:0:2.15 0:0:2.98 0:0:4.927 0:0:4.335

4 0:0:6.034 0:0:5.471 0:0:8.036 0:0:9.016 0:0:11.065

5 1:11:1.0 0:35:38.9 0:24:30.3 0:18:28.5 0:15:18.2

Table 6.2 Knights Tour_Testing Result

4000

-3000 "

2000 "

1000 "

(Sees)

For Knighton 5x5 Board

Time

Efficiency

-i 1 ₁

2 3 4

NumbersofWorkstations

100

I- 98

96

- 94

- 92

%

Visited

1 2 3 4 5

9 0:0:38.18 0:0:21.91 0:0:20.78 0:0:15.74

10 0:2:43.37 0:1:30.64 0:1:27.21 0:0:53.67 Machines

11 0:14:13.91 0:7:16.25 0:5:0.18 0:3:57.76 Are

12 0:19:51.24 0:10:7.55 0:7:4.57 0:5:35.63 Not

13 0:44:21.37 0:22:27.95 0:15:54.98 0:11:53.13 Available

14 2:14:1.0 1:9:19.0 0:48:2.464 0:37:9.33

Table6.3 _Traveling Salesman_Testing Result

3000 -i

2000-1000

-(Sees

Time

For13citiesvisited

Efficiency

i 1 r

2 3 4

NumberofWorkstations

Figure 6.3 Traveling Salesman Problem

- ₁₀₀

-98

- 96

- 94

-92

During the execution, each Nodeworkstation measures elapsed time in

several categories: time spent in communication

(generating

_messages,

Processing requests), time spent _{idly waiting for} another work machine to

grant a requestforwork, time spent_idly before

discovering

_termination, and

time spent computing. The

following

tables present the _computing and

communication timings for 5 Node workstations _{jointly solving} a 12-queen

problem andfor4Nodeworkstations_{jointlysolving} a _14-citysorted_traveling

salesman problem. The tables show how equally work is _{distributed among}

the workstations and _only a small fraction of the time is spent in

communication

Node Communication time Computation time

1 0:9.887 6:53.212

2 0:10.306 6:48.917

3 0:7.557 6:50.653

4 0:16.595 6:49.524

5 0:8.845 6:50.334

Table 6.4 Distribution of workfor 12 queens

Node Communication time Computation time

1 0:5.878 36:55.63

2 0:9.736 36:45.882

3 0:9.157 36:45.373

4 0:11.812 36:40.635

There are several issues that are worth _{mentioning in using} the Mesa

programming language to implement this project. _They are described as

follows.

7.1 The Size Of Variables

The maximum size of a variable is around 4000 words; the user _may

declare a variableas

"

test: ARRAY[1..4000] OF INTEGER "

andwill not get

anyerror message fromthe compiler. If the variable sizedoesexceed this

limit,thecompiler will printout "variable orfieldtoo big" messageto the

user.

The user _may use the _Heap which is the _primary storage allocator in Mesa toallocate and free blocks ofstorageof _arbitrarysize. _{For example,}

theusercan dothefollowto letthevariablesize exceed4000words.

testType:TYPE = ARRAY [1..8000] OFINTEGER; --declaration

test: LONGPOINTER TOtestType; -declaration

test

<-zone.NEW[testType]; -in program

zone.Free[@test]; -in program

7.2 HowTo Deal With Real Numbers

Users _maywantto use real numbersin theirapplication programs. The

real number operations and functions such as _{FAdd, FSub, FMul, FDiv,}

FRem, FComp, Exp, Log, Ln, SqRt, Root and Power can be found in the

Real.mesa and RealFns.mesa underthe Fiat/XDE/ComSoft/Publicdirectory.

The procedure

"InitReals"

must be called before _any floating point

7.3 How To Use Variant Records

Users often find it convenient to combine information of different

types. The user can use the

following

steps to declare variant RECORD

types, to assign values to variant _RECORDS, and to access the fields of

variantRECORDS.

1. _Declaring variantRECORDS

Thedeclaration forMessage isa variant RECORD:

Message: TYPE= _{RECORD[ -declaration}

specifics: SELECTtype: MessageClassFROM

-no common part

ProblemMessage = _> [

PartSize: _INTEGER,

DebugLevel: _INTEGER],

InterNodeMessage = _> [

Asker: _INTEGER,

Redundancy:_INTEGER],

ENDCASE];

2. Allocation of variantRECORDS

MsgBuffer: RECORD[

source: _INTEGER,

dest: INTEGER,

message: Message];

3. Assignmentto variantRECORD variables

a: ProblemMessage Message; -declaration

- It _nowisa boundvariant

a.PartSize<-5;

4. _Accessingthefieldsof a variant RECORDvariable

WITHa: _{MsgBuffer.message SELECT FROM}

ProblemMessage = >

{

x*-a.PartSize;

-processthedata

y-a._DebugLevel};

< < OR InterNodeMessage = >

{

***}; >>

ENDCASE;

7.4 AboutProcess.Yield

The Mesa process mechanism does not attempt to allocate processor

time_fairlyamong processesof equal priority. Aprocess itselfwill yieldthe

processorto other processesofequal _prioritywhenever itfaults, Pausesor

WAITs. In the Node program, the Receiver and the main program run

concurrently. When the problemsize is_large, asin queen sizesequal 12 or

larger, other Nodes could not connect to Node 1 until Node 1 _nearly

finished all the computation. It looks like the Receiver has the problem

gettingto the processor.

Process.Yield places the _calling process at the rear of the queue of

ready-to-run processes of the same priority. _Thus, all other _ready

processes ofthe same _prioritywill run beforethe_calling process next runs.

After _{using it in} the main program toforce thescheduling, itdid solvethe

8. FURTHERRESEARCHANDCONCLUSIONS

There areseveral directionsfor_advancingthissoftware package.

1. _Adapting DIB to similar application areas. These applications _may be an

alpha-beta search _problem,ora _{Petri-net reachability} problem.

2. _Distributingwork not_{solely by} request from underloaded nodes, but also

by initiative of overloaded nodes. This _facility will help shed load from "hot spots", which occur near the end of computation and when

machineshave failed.

3. _Adapting DIB to be used as an instructional tool in _networking and

distributed _computing courses.

DIB is an attempt at _providing an _easily used _facility for _writing

distributed programs _involving backtracking. The distributed part of DIB is

completely hidden from the user, making it especially suitable for

programmers withoutexpertise in distributed or parallel programming. The

distribution of work in DIB is _{dynamic, making} it suitable for _any

environments. DIB requires minimal support from the distributed _operating

system and _{it is relatively}portable.

The experimental results indicate that for simple programs DIB is an

efficient and _easily used tool for automaticallydistributing work. Exhaustive

search is distributed uniformly with _very little performance penalty.

Application that uses branch and bound should generate more _worthy

children first to take advantage of DIB's search order. The feature of fault

1. R. A. Finkel and U. _{Manber, DIB A Distributed}

Implementation of

backtracking,

Proceedings of _{the 5th International}

Conference on

Distributed

Computing

_{Systems, 1985}

2. G. M. Baudet. The Design and Analysis of _{Algorithms for Asynchronous}

Multiprocessors. _Department of _{Computer Science. Carnegie-Mellon}

University (April ₁₉₇₈₎

3. R.A. Finkel and J. P. Fishbum. "Parallelism in Alpha-Beta Search."

Journal

ofArtificial Intelligence _{19(1) (September 1982)}

4. S. G. _{Akl, D. T. Barnard} and R. J. Doran. _"Simulation and analysis in

deriving

time and storage requirements for a parallel alpha-beta

algorithm."

Proc. 1980 _{international Conference on Parallel Processing.}

(August 1980)

5. P Moller-Nielsen and J. Staunstrup. _"Experimentswith a Multiprocessor."

Technical Report _PB-185, Computer Science Department. AArhus

University (November ₁₉₈₄₎

6. G. B. Adams _III, H. J. _Siegel, M. _{Imai, I, Fukumura,} and Y. _Yoshida, "A

Parallelized branch-and-bound algorithm: implementation and

efficiency."

Systems, Computers,Controls ₁₀₍₃₎ pp. 270-2277 ₍₁₉₇₉₎

7. E. L. Lawer and D. _Wood, "Branch and Bound methods: a _survey",

Operations_Research, 1966

8. J. A. Fishburn and R. A. _Finkel, "QuotientNetworks", IEEETransactionson

Computers,April 1981

9. N. _Wirth, Modula: a language for modular _{multiprogramming, Software}

Practice and _Experience, 1977

10.N. Wirth, Design and Implementation of _{Modula, Software Practice} and

11.Mesa LanguageManual,Xerox_Corporation, 1984

12.Mesa Programmer's _Manual, Xerox_Corporation, 1985

13.Pilot Programmer's _Manual,Xerox_Corporation, 1985

14.Raphael Finkel. Robert Cook. David DeWitt. _Nacy Hall, and Lawrence

Landweber, "Wisconsin Modula: Part III ofthe First Report on the crystal

project."

Technical Report 501. _University of Wisconsin-Madison

Thereare certainstepsto befollowed

by

the userofthispackage.

Step 1: Write application program

1. Application program should use

"ApplicDfs.mesa"

as the name of

Definition module, and use

"Appliclmpl.mesa"

for Implementation

module.

2. Follow the description of each procedure in "USER _INTERFACE", and

usethesame procedure nametowrite each procedure.

3. Refertothe application program examples in Appendix B to get more

information.

Step 2: Compile the application program and Bind it with DIB package:

retrieve DIB from

"Audi/Projects/DIB/Programs"

directory

DIB package containsthe_following Definition modules

1. lO.mesa

2.TimeMeasureDfs.mesa

3. ApplicDfs.mesa (Supplied _by user)

4. DeweyDfs.mesa

5. HostDfs.mesa

6. InterfaceDfs.mesa

7. HlnterfaceDfs.mesa

8. NodeDfs.mesa

9. NlnterfaceDfs.mesa

DIB package containsthefollowing Implementation modules

1. Hlnterfacelmpl.mesa

2. lOlmpl.mesa

3. _DeweyImpi. mesa

4.Appliclmpl.mesa (Supplied byuser)

7. Nlnterfacelmpl.mesa 8. NIOImpl.mesa

9. Nodelmpl.mesa

DIB package containstwoconfiguration modules

1. DIBHost.config 2.

DIBNode.config

DIB package needs the _following tool modules: find and retrieve them fromthe "Fiat/XDE/5.0/..."directory.

1.String.bed

2. Stream.bed

3. NetworkStream.bed

4. Heap.bed

5. Tool.bed

6.TTYSW.bcd

7. Process.bcd 8.TTY.bcd

9. System.bed 10. Put.bcd

11. Exec.bcd

12.FormSW.bcd

13. AddressTranslation.bcd

14. Format.bcd

15. Time.bed

16. RandomDefs.bcd

17.RandomProg.bcd

18. Real.bed

19. Reallmpl.bcd

20. Ascii.bcd

21. Window.bcd

22. Environment.bcd

23. UserTerminal.bcd

1. Active window if it is in _tiny or inactive state.

Otherwise,getitfrom "Executive" window.

2. Enter those Definition modules in the

following

order to the

"compile:"

field on the CommandCentral _window; IO

TimeMeasureDfs ApplicDfs DeweyDfs HostDfs InterfaceDfs

HlnterfaceDfs NodeDfs _{NlnterfaceDfs,} and invoke "Compile!"

command.

3. Enter those Implementation modules to the "Compile:" _field, the

orderis not_important,and invoke "Compile!" command.

4. Enter DIBHost and DIBNode to the "Bind:" _field, and invoke "Bind!"

command. Ignore if the Binder gives the message "Broadcastlnfo or ReportResult"

are not bindable when Binder tried to bind DIBHost.config.

5. If_{everything isOK,}the Binderwill generate two executable _programs,

DIBHost.bcd and DIBNode.bed.

6. If there are_compiling errorsfrom ApplicDfs.mesa,then redosteps2-4. 7. If there are _compiling errors from Appliclmpl.mesa, then _only

Appliclmpl.mesa needsto berecompile and redo_step4.

Step 3: Runapplication program

1. Load DIBHost.bcd or DIBNode.bed (via FileTool) onto those

workstations whichare_{going to} beused.

2. Enter DIBHost to the

"Run:"

field of CommandCentral window, and

invoke "Run!"command at_onlyoneworkstation.

3. Enter DIBNode to the

"Run:"

field of CommandCentral window, and

invoke "Run!"command atotherworkstations.

4. Set Node _(work)workstations

Enter the workstation'sname shown on the monitor upper left corner

to the "I am:"

field and invoke

"Assert!"

(1) Enter the workstation's name shown on the monitor upper left

cornertothe "I

am:"

field and invoke "Assert!" command.

(2) Follow the instructionson the monitor screen to input dataorto

make a selection. For_example,

a. _{"Please input Node} Number"

Enter the number of node _(work) workstations (exclude the

host).

b. "Please inputthe nameof each node- _{First is}Host"

Enter the Host name first, then enter each node

workstation's name.

c. Selection

c: _count,onlythefinal resultwill be reported to Host.

f: _full, each possibleanswer will be reported to Host.

d: _{debug level;} trace the execution of the application

program. The possible value is 1,2,3, and 6. The bigger

the number _is, the more details of the execution will be

shown onthe screen.

h: helpers, number of helperswhen out of work. Due to the

numberofworkstationsthatcan be used, helpers is setto

1 _bydefault.

n: new problem, run the application program with different

problem sizes.

q: quit

Step4: Back to Copilot

1. From _Host, enter

'q'

then deactivate the window and pressthe

SHIFT-STOP keys.

1. DIB can _only use these workstations: _{ALVIS, LIT, GALAR, FJALAR,}

ANDVARI, EITRI, BROKK, MODSOGNIR, DURIN.

2. These workstations use fixed network addresses to communicate with

each other. These addresses are set in the Hlnterfacelmpl.mesa and

Nlnterfacelmpl.mesa programs.

Ifworkstations are moved to another place or are connected to other

sockets, users need to find the new network addresses and to revise

them inthe Hlnterfacelmpl.mesa and Nlnterfacelmpl.mesaprograms.

3. If the "Sender ConnectionFail"

message occurs during the "Set _up

environment"

AppendixB: _{Sample Application Programs}

B.1 _{Application Example} 1 _{(Eight-QueensProblem)}

Parti Definition Part

-Filename: ApplicDfs.mesa

ApplicDfs: DEFINITIONS =

BEGIN

MaxProbSize: INTEGER = 20;

QueenArray:TYPE = _ARRAY[1..

MaxProbSize]OF _INTEGER;

ProblemType: TYPE = _RECORD[

LeafCount: LONG _INTEGER,

ProbSize: INTEGER, Length: _INTEGER, Queens: _QueenArray];

lnfoType:TYPE = PACKED _{ARRAY[0..1] OF}

CHARACTER;

-pseudo data

ApplicFinish: _PROCEDURE!];

AcceptRoot: PROCEDURE^: _{ProblemType];}

AcceptAnswer: PROCEDURE^: _{ProblemType];}

FirstProb: PROCEDURE[Size: _INTEGER] RETURNS[P: _{ProblemType];}

Generate: PROCEDURE[First: _BOOLEAN,

Parent: LONG POINTERTO ProblemType,

Child: LONG POINTERTO_ProblemType]

RETURNS[Done: _BOOLEAN];

UseNewlnfo: PROCEDURE[lnfo: InfoType];

NonTrivial: PROCEDURE[P: ProblemType] RETURNS[BOOLEAN];

Combine: PROCEDURE[Child: LONG POINTER TO _ProblemType, Parent: LONG POINTER TO ProblemType]

RETURNS[Update: _BOOLEAN];

Update: PROCEDURE[Child: LONG POINTERTO _ProblemType,

Parent: LONG POINTERTO _ProblemType]

RETURNS[Again: BOOLEAN];

Appliclnit: PROCEDURES;

PrintProblem: PROCEDURE[P: ProblemType];

Part2 _{Implementation Part}-File name: _{Appliclmpl.mesa}

DIRECTORY

ApplicDfs, NodeDfs,

10;

Appliclmpl: PROGRAM

IMPORTS_NodeDfs, 10

EXPORTSApplicDfs =

BEGIN

OPEN _{NodeDfs,ApplicDfs, 10;} Title: _{LONG STRING}*- "Queens"

L;

PrintProblem: PUBLIC PROCEDURE^: _ProblemType] =

BEGIN

Seq: INTEGER *-1;

{OPEN P;

WHILE _Seq <= _Length DO

WriteCharf ];

WriteDecimal[Queens[Seq]]; Seq

*-Seq + 1_; ENDLOOP; NewLinef]}; END;

PrintAnswer: PUBLIC PROCEDURE^: _ProblemType] = BEGIN

WriteLongDecimalfP._LeafCount];

WriteString["

Leaves _"L];

END;

Generate: PUBLIC PROCEDUREfFirst: _BOOLEAN,

Parent: LONGPOINTERTO _ProblemType, Child: LONG POINTER TO _ProblemType] RETURNS[Done: _BOOLEAN] =

BEGIN

Seq: _INTEGER;

ThisQueen,ThatQueen: _INTEGER; Bad: _BOOLEAN;

IF First AND (Parentf.Length = Parentf

.ProbSize)THEN

{Done*-TRUE;

Parent_f.LeafCount

*-₁ ;

{Child _f ParentT; {OPEN Child _f;

Length *-_{Length +}

1;

Queens[Length] *-0};

First*-FALSE};

{OPEN Child

f;

LeafCount*-0;

DO

Queens[Length]*-Queens[Length]

+ _1;

ThisQueen *-Queens[Length]; IFThisQueen > _ProbSizeTHEN

{Done*-TRUE;

EXIT}; Seq*-1;

Bad*-FALSE;

WHILE _Seq < Length DO

ThatQueen _{*-Queens[Seq];}

IF(ThatQueen = _ThisQueen) OR

(ThatQueen + _Seq Length = _ThisQueen)OR (ThatQueen

-Seq + Length = _{ThisQueen) THEN}

{Bad*-TRUE; EXIT};

Seq

*-Seq + 1;

ENDLOOP;

IF NOTBadTHEN

{Done*- _FALSE;

EXIT}; ENDLOOP}}; END;

FirstProb: PUBLIC PROCEDURE[Size: _INTEGER] RETURNS[P: _ProblemType] BEGIN

P.LeafCount*-0; P.ProbSize*-Size; P.Length*-0; END;

Combine: PUBLIC PROCEDURE[Child: LONG POINTER TO _ProblemType, Parent: LONG POINTERTO _ProblemType]

RETURNS[Update: _BOOLEAN] =

BEGIN Parent_f .

LeafCount*-_{Parentf.LeafCount} + Child _f.LeafCount;

Update*-_FALSE;

END;

NonTrivial: PUBLICPROCEDURE[P: ProblemType] RETURNS[BOOLEAN] = BEGIN

NewLine[];

END;

ApplicFinish: PUBLIC_PROCEDURES =

BEGIN

END;

UseNewlnfo: PUBLIC PROCEDURE^: _InfoType] =

BEGIN

END;

AcceptRoot: PUBLIC PROCEDURE^: _ProblemType] =

BEGIN

PrintProblem[P]; PrintAnswer[P]; END;

AcceptAnswer: PUBLICPROCEDURE^: _ProblemType] =

BEGIN

PrintProblem[P]; END;

Update: PUBLIC PROCEDURE[Child: LONG POINTER TO ProblemType,

Parent: LONG POINTERTO ProblemType]

RETURNS[Again: _BOOLEAN] =

BEGIN Again

*-FALSE; END;

Parti Definition Part-_File

name: _{ApplicDfs.mesa}

ApplicDfs: DEFINITIONS =

BEGIN

MaxProbSize: INTEGER = _20; Infinity: REAL =

1.0e30;

PermArray: TYPE = _{ARRAY[0.. MaxProbSize}

1] OF INTEGER-ProblemType: TYPE =

RECORD[ ProbSize: _INTEGER,

Length: _INTEGER,

Perm: _PermArray,

Children: _PermArray,

Cost: _REAL,

LeafCount: LONG _INTEGER, BestCost: _REAL,

BestPerm: _PermArray];

lnfoType:TYPE = RECORD[Estimate:

REAL];

ApplicFinish: _PROCEDURES;

AcceptRoot: PROCEDURE^: _{ProblemType];}

AcceptAnswer: PROCEDURE^: _{ProblemType];}

FirstProb: PROCEDURE[Size: INTEGER] RETURNSfP: _{ProblemType];}

Generate: PROCEDURE[First: _BOOLEAN,

Parent: LONGPOINTERTO _ProblemType,

Child: LONG POINTER TO _ProblemType] RETURNS[Done: _BOOLEAN];

UseNewlnfo: PROCEDURE[lnfo: InfoType];

NonTrivial: PROCEDURE[P: _{ProblemType] RETURNSfBOOLEAN];}

Combine: PROCEDUREfChild: LONG POINTERTO _ProblemType,

Parent: LONG POINTER TO _ProblemType]

RETURNS[Update: _BOOLEAN];

Update: PROCEDURE[Child: LONG POINTER TO _ProblemType,

Parent: LONG POINTERTO _ProblemType]

RETURNS[Again: _BOOLEAN];

Appliclnit: _PROCEDURES;

PrintProblem: PROCEDUREfP: ProblemType];

PrintAnswer: PROCEDURE[P: ProblemType];

NodeDfs,

10, Real;

Appliclmpl: PROGRAM IMPORTS NodeDfs,IO,Real EXPORTSApplicDfs =

BEGIN

OPEN _{NodeDfs,ApplicDfs,IO,Real;}

lnitialDataType:TYPE = _{ARRAY[0..MaxProbSize 1]0F} ARRAY[0..MaxProbSize

-1]OF _REAL;

Bestlnfo: InfoType

*-[Infinity];

Title: LONG STRING *- _"Sorted

Travel_"L;

InitialData:

InitialDataType*-[[0.51387,0.17574,0.30865,0.53453,0.94763,0.17174,0.70223,0.22643,0.49477,

0.12472,0.08390,0.38965,0.27723,0.36807,0.98344,0.53540,0.76568,0.64647,

0.76714,0.78024],

[0.82295,0.15193,0.62548,0.31468,0.34690,0.91720,0.51976,0.40115,0.60676,

0.78540,0.93152,0.86992,0.86652,0.67452,0.75840,0.58189,0.38925,0.35563, 0.20023,0.82693],

[0.41450,0.46352,0.97916,0.12644,0.21264,0.95845,0.73746,0.40906,0.78011,

0.75790,0.9