DIRECTORY BasicTime, Commander, IO, Rope;

ForkPerfTest2: CEDAR MONITOR
LOCKS lock USING lock: REF Lock
IMPORTS BasicTime, Commander, IO =
BEGIN 

Lock: TYPE = MONITORED RECORD [unused: BOOL м FALSE];

constantSeed: INT = 123456;
seed: INT м constantSeed;

Value: TYPE = INT;
maxSize: INT = 100290; --of the array allocation for the array to be sorted
defaultSize: INT = 100290;
size: INT м defaultSize;

Array: TYPE = REF ArrayRep;
ArrayRep: TYPE = ARRAY [0..maxSize) OF Value;
array1: Array м NIL;
array2: Array м NIL;

simpleSizeLimit: INT м 8; --at least 3

startPulses: BasicTime.Pulses;

SetUp: PROC [doArray: BOOL м TRUE, secondArray: BOOL м FALSE] = {
IF array1=NIL THEN array1 м NEW[ArrayRep];
IF doArray THEN {
FOR i: INT IN [0..size) DO
array1[i] м size-i;
ENDLOOP;
IF secondArray THEN {
IF array2=NIL THEN array2 м NEW[ArrayRep];
FOR i: [0..maxSize) IN [0..maxSize) DO 
array2[i] м array1[i];
ENDLOOP;
};
};
startPulses м BasicTime.GetClockPulses[];
};

Report: PROC [s: IO.STREAM, what: Rope.ROPE, dontTestOrder: BOOL м FALSE] = {
elapsedPulses: BasicTime.Pulses м BasicTime.GetClockPulses[] - startPulses;
time: REAL м BasicTime.PulsesToSeconds[elapsedPulses];
IO.PutF[s, "%g time: %g seconds", IO.rope[what], IO.real[BasicTime.PulsesToSeconds[elapsedPulses]]];
IO.PutRope[s, "\n"];
}; 

SimpleSort: PROC [array: Array, low, high: INT] = {
FOR i: INT IN [low..high) DO
FOR j: INT IN (i..high] DO
IF array[i] > array[j] THEN {
x: Value м array[i]; array[i] м array[j]; array[j] м x
};
ENDLOOP
ENDLOOP
};

Partition: PROC [array: Array, low, high: INT] RETURNS [INT, INT] = {
m: INT м (low+high)/2;
x, bval: Value;
IF high-low<3 THEN ERROR; --bith, the simple sort and the main loop could bounds fail
SimpleSort[array, m-1, m+1];  --not for real; just gives a better average bval
bval м array[m]; --quite random
DO 
WHILE array[low] < bval DO low м low+1 ENDLOOP;
WHILE bval < array[high] DO high м high-1 ENDLOOP;
IF low > high THEN RETURN [high, low];
x м array[high]; array[high] м array[low]; array[low] м x;
low м low+1; high м high-1
ENDLOOP;
};

QuickSort1: PROC [array: Array, low, high: INT, extraAllocations: BOOL] = {
IF extraAllocations THEN {
ri: REF REF ANY м NIL;
ri м NEW[REF ANY];
riн м ri --hope this fools the optimizer
}; 
IF high-low<simpleSizeLimit THEN SimpleSort[array, low, high]
ELSE {
lBound, hBound: Value;
[lBound, hBound] м Partition[array, low, high];
IF low<lBound THEN QuickSort1[array, low, lBound, extraAllocations];
IF hBound<high THEN QuickSort1[array, hBound, high, extraAllocations];
};
};

Sort2SCommand: Commander.CommandProc = {
SetUp[TRUE, TRUE];	
QuickSort1[array1, 0, size-1, FALSE];
QuickSort1[array2, 0, size-1, FALSE];
Report[cmd.out, "Sort2 Sequential"];
}; 

Sort2PCommand: Commander.CommandProc = {
process: PROCESS м NIL;
SetUp[TRUE, TRUE];
process м FORK QuickSort1[array1, 0, size-1, FALSE];
QuickSort1[array2, 0, size-1, FALSE];
TRUSTED {[] м JOIN process};
Report[cmd.out, "Sort2 Parallel"];
}; 

Sort2SACommand: Commander.CommandProc = {
SetUp[TRUE, TRUE];
QuickSort1[array1, 0, size-1, TRUE];
QuickSort1[array2, 0, size-1, TRUE];
Report[cmd.out, "Sort2 Sequential with allocations"];
}; 

Sort2PACommand: Commander.CommandProc = {
process: PROCESS м NIL;
SetUp[TRUE, TRUE];
process м FORK QuickSort1[array1, 0, size-1, TRUE];
QuickSort1[array2, 0, size-1, TRUE];
TRUSTED {[] м JOIN process};
Report[cmd.out, "Sort2 Parallel with allocations"];
}; 

FreeCommand: Commander.CommandProc = {
array1 м NIL;
array2 м NIL;
}; 

DeepCall: PROC [i: INT] = {
IF i>0 THEN DeepCall[i-1];
};
DeepCalls: PROC [cnt: INT, depth: INT м 150] = {
FOR i: INT IN [0..cnt) DO
DeepCall[depth];
ENDLOOP
};

DeepCallSCommand: Commander.CommandProc = {
SetUp[FALSE, FALSE];	
DeepCalls[1000];
DeepCalls[1000];
Report[cmd.out, "DeepCalls Sequential"];
}; 

DeepCallPCommand: Commander.CommandProc = {
process: PROCESS м NIL;
SetUp[FALSE, FALSE];	
process м FORK DeepCalls[1000];
DeepCalls[1000];
TRUSTED {[] м JOIN process};
Report[cmd.out, "DeepCalls Parallel"];
}; 

Locked: ENTRY PROC [lock: REF Lock] = {
lock.unused м FALSE
};

lock1: REF Lock м NEW[Lock];
lock2: REF Lock м NEW[Lock];

ManyLocks: PROC [cnt: INT м 150000, lock: REF Lock] = {
FOR i: INT IN [0..cnt) DO
Locked[lock];
ENDLOOP
};

LockingSCommand: Commander.CommandProc = {
SetUp[FALSE, FALSE];	
ManyLocks[450000, lock1];
ManyLocks[450000, lock2];
Report[cmd.out, "Locking Sequential"];
}; 

LockingPNCommand: Commander.CommandProc = {
process: PROCESS м NIL;
SetUp[FALSE, FALSE];	
process м FORK ManyLocks[450000, lock1];
ManyLocks[450000, lock2];
TRUSTED {[] м JOIN process};
Report[cmd.out, "Locking Parallel, NO conflicts"];
}; 

LockingPCCommand: Commander.CommandProc = {
process: PROCESS м NIL;
SetUp[FALSE, FALSE];	
process м FORK ManyLocks[450000, lock1];
ManyLocks[450000, lock1];
TRUSTED {[] м JOIN process};
Report[cmd.out, "Locking Parallel, WITH conflicts"];
}; 

DoSome: PROC [onlyReads: BOOL, a: Array] = {
x, y, z: Value;
x м a[1]*2;
y м a[2]+1;
z м a[3]-4;
IF ~onlyReads THEN {
a[1] м y;
a[2] м z;
a[3] м x;
};
};

DoSomes: PROC [cnt: INT, onlyReads: BOOL, a: Array] = {
FOR i: INT IN [0..cnt) DO
DoSome[onlyReads, a];
ENDLOOP;
};

ReadsSCommand: Commander.CommandProc = {
SetUp[TRUE, TRUE];	
DoSomes[600000, TRUE, array1];
DoSomes[600000, TRUE, array2];
Report[cmd.out, "Sequential reads"];
}; 

WritesSCommand: Commander.CommandProc = {
SetUp[TRUE, TRUE];	
DoSomes[600000, FALSE, array1];
DoSomes[600000, FALSE, array2];
Report[cmd.out, "Sequential Read/Writes"];
}; 

ReadsPNCommand: Commander.CommandProc = {
process: PROCESS м NIL;
SetUp[TRUE, TRUE];	
process м FORK DoSomes[600000, TRUE, array1];
DoSomes[600000, TRUE, array2];
TRUSTED {[] м JOIN process};
Report[cmd.out, "Parallel reads, NO conflicts"];
}; 

ReadsPCCommand: Commander.CommandProc = {
process: PROCESS м NIL;
SetUp[TRUE, TRUE];	
process м FORK DoSomes[600000, TRUE, array1];
DoSomes[600000, TRUE, array1];
TRUSTED {[] м JOIN process};
Report[cmd.out, "Parallel reads, WITH conflicts"];
}; 

WritesPNCommand: Commander.CommandProc = {
process: PROCESS м NIL;
SetUp[TRUE, TRUE];	
process м FORK DoSomes[600000, FALSE, array1];
DoSomes[600000, TRUE, array2];
TRUSTED {[] м JOIN process};
Report[cmd.out, "Parallel writes, NO conflicts"];
}; 

WritesPCCommand: Commander.CommandProc = {
process: PROCESS м NIL;
SetUp[TRUE, TRUE];	
process м FORK DoSomes[600000, FALSE, array1];
DoSomes[600000, TRUE, array1];
TRUSTED {[] м JOIN process};
Report[cmd.out, "Parallel writes, WITH conflicts"];
}; 

Commander.Register["ForkPerfTest2-Sort2S", Sort2SCommand, "Two sorts Sequential"];
Commander.Register["ForkPerfTest2-Sort2P", Sort2PCommand, "Two sorts Parallel"];
Commander.Register["ForkPerfTest2-Sort2SA", Sort2SACommand, "Two sorts Sequential with Allocations"];
Commander.Register["ForkPerfTest2-Sort2PA", Sort2PACommand, "Two sorts Parallel with Allocations"];
Commander.Register["ForkPerfTest2-DeepCallS", DeepCallSCommand, "Deep calls Sequential"];
Commander.Register["ForkPerfTest2-DeepCallP", DeepCallPCommand, "Deep calls Parallel"];
Commander.Register["ForkPerfTest2-LockingS", LockingSCommand, "Locking Sequential"];
Commander.Register["ForkPerfTest2-LockingPN", LockingPNCommand, "Locking Parallel, NO conflicts"];
Commander.Register["ForkPerfTest2-LockingPC", LockingPCCommand, "Locking Parallel, WITH conflicts"];
Commander.Register["ForkPerfTest2-ReadsS", ReadsSCommand, "Sequential reads"];
Commander.Register["ForkPerfTest2-WritesS", WritesSCommand, "Sequential Read/Writes"];
Commander.Register["ForkPerfTest2-ReadsPN", ReadsPNCommand, "Parallel reads, NO conflicts"];
Commander.Register["ForkPerfTest2-ReadsPC", ReadsPCCommand, "Parallel reads, WITH conflicts"];
Commander.Register["ForkPerfTest2-WritesPN", WritesPNCommand, "Parallel writes, NO conflicts"];
Commander.Register["ForkPerfTest2-WritePC", WritesPCCommand, "Parallel writes, WITH conflicts"];
Commander.Register["ForkPerfTest2-Free", FreeCommand, "Free arrays"];
END.
 
  
  М  
ForkPerfTest2.mesa 
Copyright ╙ 1993 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi, May 13, 1993 
Christian Jacobi, June 8, 1993 11:20 am PDT

Test program to measure speed of forks, parallel processing and similar operations.  

For measuring, a quicksort algorithm is used.  Quicksort is a good thing to measure because it is neither specially well suited to parallelism nor does it need lots of communication.

While this is about parallelism, the individual test are not re-entrant and only one at a time should run.

Usefull to free array before running another instance of this program

Actual Measurements
Setup
Э╩	ч  ХNewlineDelimiter
Щ codeЩKЪЬ
╧eЬ1Щ<KЩ*KЩ+KЩ ЩUKЩ KЩ╢KЩ KЩjЧKЩ ЧЪ╧k	ЬЮЬШ)KШ ЧЪ╧nЬЮЬЮШKЪ
ЮЬЮЬЮЬЬЬЬЬШKЪЮЬЮЬШ"ЧKЪЮЬШKШ KЪЬЮЬЮ	ЬЮЬ
ЮЬЮЬШ5KШ KЪЬЮЬ
ШKЪЬЮЬШKШ KЪЬЮЬЮЬШKЪЬ	ЮЬ╧c4ШKKЪЬЮЬ
ШKЪЬЮЬШKШ KЪЬЮЬЮЬ
ШKЪЬ
ЮЬЮЬЮЬШ-KЪЬЮЬШKЪЬЮЬШKШ KЪЬЮЬаШ&KШ KШKШ ЪЯЬЮЬЮЬЮЬЮЬЮЬШAKЪ	ЮЬЮЬЮЬ
ЮЬЬ
Ш*ЪЮЬ	ЮЬШЪЮЬЮЬЮЬЮШKШKЪЮШЧЪЮЬЮЬШKЪ	ЮЬЮЬЮЬ
ЮЬЬ
Ш*ЪЮЬЮЬЮЬШ'KШKЪЮЬШЧKШЧKШЧKШ)KШKШ ЧЪЯЬЮЬЮЬЮЬЮЬЮЬЮЬШMKШKKЪЬЮЬ,Ш6KЪЮЬ ЮЬЮЬ1ШdKЪЮЬШKШKШ ЧЪЯ
ЬЮЬЮЬШ3ЪЮЬЮЬЮЬЮШЪЮЬЮЬЮЬЮШЪЮЬЮЬШKШ6KШЧKЪЮШЧKЪЮШЧKШKШ ЧЪЯ	ЬЮЬЮЬЮЬЮЬЮЬШEKЪЬЮЬШKШKЪЮЬЮЬЮЬа;ШUKЪЬа0ШNKЪЬаШЪЮЬШKЪЮЬЮЬЮЬШ/KЪЮЬЮЬЮЬШ2KЪЮЬЮЬЮЬШ&KШ:KШKЪЮЬШЧKШKШ ЧЪЯ
ЬЮЬЮЬЮЬШKЪЮЬЮЬШKЪ	ЬЮЬЮЬЮЬЮЬШKЪЬЮЬЮЬЮЬШKЪЬ	аШ(KШЧKЪЮЬЮЬШ=ЪЮЬШKШKШ/KЪЮЬЮЬ2ШDKЪЮЬЮЬ3ШFKШЧKШЧKШ ЪЯЬШ(KЪЬЮЬЮЬШKШ%KШ%KШ$KШKШ ЧЪЯЬШ(KЪЬ	ЮЬЮЬШKЪЬЮЬЮЬШKЪЬ
ЮЬ&Ш4KШ%KЪЮЬЮЬ
ШKШ"KШKШ ЧЪЯЬШ)KЪЬЮЬЮЬШKЪЬЮЬШ$KЪЬЮЬШ$KШ5KШKШ ЧЪЯЬШ)KЪЬ	ЮЬЮЬШKЪЬЮЬЮЬШKЪЬ
ЮЬЮЬШ3KЪЬЮЬШ$KЪЮЬЮЬ
ШKШ3KШKШ ЧЪЯЬШ&KЩEKЪЬ	ЮЬШKЪЬ	ЮЬШKШKШ ЧЪЯЬЮЬЮЬШKЪЮЬЮЬШKШЧKЩ ЪЯ	ЬЮЬЮЬ	ЮЬШ0ЪЮЬЮЬЮЬ
ЮШKШKЪЮШЧKШЧЪЯЬШ+KЪЬЮЬЮЬШKШKШKШ(KШKШ ЧЪЯЬШ+KЪЬ	ЮЬЮЬШKЪЬЮЬЮЬШKЪЬ
ЮЬШKШKЪЮЬЮЬ
ШKШ&KШKШ ЧЪЯЬЮЬЮЬЮЬ
Ш'JЪЬЮШKШЧKЪЬЮЬЮЬШKЪЬЮЬЮЬШKШ ЪЯ	ЬЮЬЮЬЮЬ
Ш7ЪЮЬЮЬЮЬ
ЮШKШKЪЮШЧKШЧЪЯЬШ*KЪЬЮЬЮЬШKШKШKШ&KШKШ ЧЪЯЬШ+KЪЬ	ЮЬЮЬШKЪЬЮЬЮЬШKЪЬ
ЮЬШ(KШKЪЮЬЮЬ
ШKШ2KШKШ ЧЪЯЬШ+KЪЬ	ЮЬЮЬШKЪЬЮЬЮЬШKЪЬ
ЮЬШ(KШKЪЮЬЮЬ
ШKШ4KШKШ ЧЪЯЬЮЬЮЬШ,KШJШJШJШЪЮЬЮЬШJШ	JШ	JШ	JШЧKШЧKШ ЪЯЬЮЬЮЬЮЬШ7ЪЮЬЮЬЮЬ
ЮШKШKЪЮЬШЧKШЧKШ ЪЯЬШ(KЪЬЮЬЮЬШKЪЬЮЬ
ШKЪЬЮЬ
ШKШ$KШKШ ЧЪЯЬШ)KЪЬЮЬЮЬШKЪЬЮЬ
ШKЪЬЮЬ
ШKШ*KШKШ ЧЪЯЬШ)KЪЬ	ЮЬЮЬШKЪЬЮЬЮЬШKЪЬ
ЮЬЮЬ
Ш-KЪЬЮЬ
ШKЪЮЬЮЬ
ШKШ0KШKШ ЧЪЯЬШ)KЪЬ	ЮЬЮЬШKЪЬЮЬЮЬШKЪЬ
ЮЬЮЬ
Ш-KЪЬЮЬ
ШKЪЮЬЮЬ
ШKШ2KШЧKШ ЪЯЬШ*KЪЬ	ЮЬЮЬШKЪЬЮЬЮЬШKЪЬ
ЮЬЮЬ
Ш.KЪЬЮЬ
ШKЪЮЬЮЬ
ШKШ1KШKШ ЧЪЯЬШ*KЪЬ	ЮЬЮЬШKЪЬЮЬЮЬШKЪЬ
ЮЬЮЬ
Ш.KЪЬЮЬ
ШKЪЮЬЮЬ
ШKШ3KШKШ ЧKЪ╧bЩKШRKШPKШeKШcKШYKШWKШTKШbKШdKШNKШVKШ\KШ^KШ_KШ`KЪбЩKШEKЪЮЬШKЪЬШJШЧ ЕЧ      +Б  