-- File: AlpineTimingImpl.mesa
-- Last edited by:
-- MBrown on February 14, 1984 2:50:03 pm PST


DIRECTORY
AlpFile,
AlpineFile,
AlpineEnvironment,
AlpineInterimDirectory,
AlpInstance,
AlpTransaction,
Commander,
IO,
PerfStats,
PrincOpsUtils,
Process,
Random,
Rope,
VM;

AlpineTimingImpl: CEDAR PROGRAM
IMPORTS
AlpFile, AlpineInterimDirectory, AlpTransaction,
Commander, IO, PerfStats, PrincOpsUtils, Process, Random, Rope, VM
= BEGIN
ROPE: TYPE = Rope.ROPE;

delaySeconds: Process.Seconds ← 5;
fileStore: ROPE ← "Luther.alpine";
universalFile: AlpineEnvironment.UniversalFile;
instHandle: AlpInstance.Handle;

interval: VM.Interval ← VM.Allocate[count: 64];
page: LONG POINTER TO PACKED ARRAY [0 .. 0) OF WORD;
pageBuffer: AlpineFile.PageBuffer;

sequentialWrites: PerfStats.Timer;
sequentialReads: PerfStats.Timer;
randomWrites: PerfStats.Timer;
randomReads: PerfStats.Timer;
transactionFinish: PerfStats.Timer;
transactionCreate: PerfStats.Timer;

SetupTestFile: PROC [] =
BEGIN
refUniversalFile: REF AlpineEnvironment.UniversalFile;
[instHandle, refUniversalFile] ← AlpineInterimDirectory.Open[
fileName: Rope.Cat["[", fileStore, "]<MBrown.pa>AlpineTest$"],
createOptions: $none,
initialByteAllocation: 262144];
universalFile ← refUniversalFile^;
TRUSTED {
page ← VM.AddressForPageNumber[interval.page];
pageBuffer ← DESCRIPTOR [page, 16384];
PrincOpsUtils.LongZero[where: page, nwords: 16384];
};
sequentialWrites ← PerfStats.CreateTimer["SequentialWrites"];
sequentialReads ← PerfStats.CreateTimer["SequentialReads"];
randomWrites ← PerfStats.CreateTimer["RandomWrites"];
randomReads ← PerfStats.CreateTimer["RandomReads"];
transactionFinish ← PerfStats.CreateTimer["TransactionFinish"];
transactionCreate ← PerfStats.CreateTimer["TransactionCreate"];
Process.Pause[Process.SecondsToTicks[delaySeconds]];
END;

TransactionCreateFinish: PROC [] =
BEGIN transHandle: AlpTransaction.Handle;
{
transactionCreate.Start[];
transHandle ← AlpTransaction.Create[
instHandle: instHandle, createLocalWorker: TRUE];
transactionCreate.Stop[];
Process.Pause[Process.SecondsToTicks[delaySeconds]];
transactionFinish.Start[];
[] ← transHandle.Finish[requestedOutcome: $commit, continue: FALSE];
transactionFinish.Stop[];
};
Process.Pause[Process.SecondsToTicks[delaySeconds]];
END;

RandomReads: PROC [referencePattern: AlpineEnvironment.ReferencePattern] =
BEGIN
transHandle: AlpTransaction.Handle ← AlpTransaction.Create[
instHandle: instHandle, createLocalWorker: TRUE];
fileHandle: AlpFile.Handle ← AlpFile.Open[
transHandle: transHandle, universalFile: universalFile,
access: $readOnly, lock: [$read, $wait], recoveryOption: $log,
referencePattern: referencePattern].handle;
TRUSTED {
pageBuffer ← DESCRIPTOR [page, 1*256];
PrincOpsUtils.LongZero[where: page, nwords: 1*256];
};
{
THROUGH [0 .. 100) DO
p: AlpineEnvironment.PageNumber ← Random.Choose[0, 511];
randomReads.Start[];
TRUSTED {
fileHandle.ReadPages[pageRun: [p, 1], pageBuffer: pageBuffer, lock: [$read, $fail]];
};
randomReads.Stop[];
ENDLOOP
};
[] ← transHandle.Finish[requestedOutcome: $commit, continue: FALSE];
Process.Pause[Process.SecondsToTicks[delaySeconds]];
END;

RandomWrites: PROC [referencePattern: AlpineEnvironment.ReferencePattern] =
BEGIN
transHandle: AlpTransaction.Handle ← AlpTransaction.Create[
instHandle: instHandle, createLocalWorker: TRUE];
fileHandle: AlpFile.Handle ← AlpFile.Open[
transHandle: transHandle, universalFile: universalFile,
access: $readWrite, lock: [$write, $wait], recoveryOption: $log,
referencePattern: referencePattern].handle;
TRUSTED {
pageBuffer ← DESCRIPTOR [page, 1*256];
PrincOpsUtils.LongZero[where: page, nwords: 1*256];
};
{
THROUGH [0 .. 100) DO
p: AlpineEnvironment.PageNumber ← Random.Choose[0, 511];
randomWrites.Start[];
fileHandle.WritePages[pageRun: [p, 1], pageBuffer: pageBuffer, lock: [$write, $fail]];
randomWrites.Stop[];
ENDLOOP
};
[] ← transHandle.Finish[requestedOutcome: $commit, continue: FALSE];
Process.Pause[Process.SecondsToTicks[delaySeconds]];
END;

blockSizePages: CARDINAL ← 4;

SequentialReads: PROC [referencePattern: AlpineEnvironment.ReferencePattern] =
BEGIN
TRUSTED {
pageBuffer ← DESCRIPTOR [page, blockSizePages*256];
PrincOpsUtils.LongZero[where: page, nwords: blockSizePages*256];
};
sequentialReads.Start[];
{
transHandle: AlpTransaction.Handle ← AlpTransaction.Create[
instHandle: instHandle, createLocalWorker: TRUE];
fileHandle: AlpFile.Handle ← AlpFile.Open[
transHandle: transHandle, universalFile: universalFile,
access: $readOnly, lock: [$read, $fail], recoveryOption: $log,
referencePattern: referencePattern].handle;
FOR p: AlpineEnvironment.PageNumber ← 0, p+blockSizePages UNTIL p = 512 DO
TRUSTED {
fileHandle.ReadPages[
pageRun: [p, blockSizePages], pageBuffer: pageBuffer, lock: [$read, $fail]];
};
ENDLOOP;
[] ← transHandle.Finish[requestedOutcome: $commit, continue: FALSE];
};
sequentialReads.Stop[];
Process.Pause[Process.SecondsToTicks[delaySeconds]];
END;

SequentialWrites: PROC [referencePattern: AlpineEnvironment.ReferencePattern] =
BEGIN
TRUSTED {
pageBuffer ← DESCRIPTOR [page, blockSizePages*256];
PrincOpsUtils.LongZero[where: page, nwords: blockSizePages*256];
};
sequentialWrites.Start[];
{
transHandle: AlpTransaction.Handle ← AlpTransaction.Create[
instHandle: instHandle, createLocalWorker: TRUE];
fileHandle: AlpFile.Handle ← AlpFile.Open[
transHandle: transHandle, universalFile: universalFile,
access: $readWrite, lock: [$write, $fail], recoveryOption: $log,
referencePattern: referencePattern].handle;
FOR p: AlpineEnvironment.PageNumber ← 0, p+blockSizePages UNTIL p = 512 DO
TRUSTED {
fileHandle.WritePages[
pageRun: [p, blockSizePages], pageBuffer: pageBuffer, lock: [$write, $fail]];
};
ENDLOOP;
[] ← transHandle.Finish[requestedOutcome: $commit, continue: FALSE];
};
sequentialWrites.Stop[];
Process.Pause[Process.SecondsToTicks[delaySeconds]];
END;

DoAlpineTimingTests: Commander.CommandProc =
BEGIN
SetupTestFile[];
TransactionCreateFinish[];
RandomReads[referencePattern: $random];
RandomWrites[referencePattern: $random];
SequentialReads[referencePattern: $sequential];
SequentialWrites[referencePattern: $sequential];
PerfStats.Print[
heading: IO.PutFR["Alpine timing tests, blocksize %g", IO.card[blockSizePages]],
oStream: cmd.out];
sequentialWrites.DestroyTimer[];
sequentialReads.DestroyTimer[];
randomWrites.DestroyTimer[];
randomReads.DestroyTimer[];
transactionFinish.DestroyTimer[];
transactionCreate.DestroyTimer[];
END;

Commander.Register["DoAlpineTimingTests", DoAlpineTimingTests, NIL];

END.