-- 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.