DataMuseum.dk

Presents historical artifacts from the history of:

RC4000/8000/9000

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about RC4000/8000/9000

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - metrics - download

⟦7ec1938a9⟧ TextFile

    Length: 31488 (0x7b00)
    Types: TextFile
    Names: »tsystest7   «

Derivation

└─⟦9ccaf6601⟧ Bits:30008165 Bånd med SW8000 kildetekst/release værktøjer
    └─⟦f546e193b⟧ 
        └─⟦this⟧ »tsystest7   « 

TextFile

  message de enkelte måleprocedurer part 3 (tsystest7);

  boolean procedure mål_proc (målno);
  value målno;
  integer målno;
  begin
    long an;
    integer bu, sh, se, gl_blocksread;
    long array di1, di2 (1 : 2);

    boolean procedure udfør_mål_proc (målno, antal, buflgd, shares, segm, disc1, disc2);
    value antal;
    long antal;
    integer målno, buflgd, shares, segm;
    long array disc1, disc2;
    begin
      long an;

      procedure find_segm (disc, segm, slice, perm);
      long array disc;
      integer segm, slice, perm;
      begin <* find segm *>
        integer s1, s2;

        s1 := segm;
        xbsclaim (0, s1, 1, slice, perm, disc);

        if perm <> 0 <* se om færre temp segm *>
        then xclaimproc (0, - 2, disc, 0, s2, 0)
        else s2 := s1;

        if s2 < s1 then s1 := s2; <* ellers kan der ikke oprettes segm nok *>

        if segm <= 0 or segm > s1 then segm := s1;
      end procedure find_segm;

      udfør_mål_proc := true; <* marker foreløbig ok *>

      if test or kl then wr_test (<:begin:>, målno);

      if not online then
      begin <* marker målno i tail (10) *>
        if monitor (42, out, 0, ia) = 0 then
        begin <* lookup ok *>
          ia (10) := målno;
          ia (6) := systime (7, 0, 0.0);
          monitor (44, out, 0, ia); <* changeentry *>
        end lookup ok;
      end marker målno;

      if segm >= 1 and buflgd >= 1
      then segm := segm // buflgd * buflgd; <* tilpas til buflgd *>

      if målno = 1 then
      begin <* for-løkke *>
        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 100 000 <* estimeret rc8000 *>
        else an := sek * 325 000; <* estimeret rc9000 *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:For løkke:>);
        if online then setposition (out, 0, 0);
        mål_for (an);
        skriv_tid (<:loop:>, an);
      end for
      else
      if målno = 2 then
      begin <* repeat *>
        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 50 000 <* estimeret rc8000 *>
        else an := sek * 150 000; <* estimeret rc9000 *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Repeat løkke:>);
        if online then setposition (out, 0, 0);
        mål_repeat (an);
        skriv_tid (<:loop:>, an);
      end repeat
      else
      if målno = 3 then
      begin <* while *>
        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 60 000 <* estimeret rc8000 *>
        else an := sek * 225 000; <* estimeret rc9000 *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:While løkke:>);
        if online then setposition (out, 0, 0);
        mål_while (an);
        skriv_tid (<:loop:>, an);
      end while
      else
      if målno = 11 then
      begin <* integer *>
        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Integer regning (+, -, *, //):>);
        if online then setposition (out, 0, 0);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 300 000 // 8 <* estimeret rc8000 *>
        else an := sek * 550 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Addition med positive integers:>);
        if online then setposition (out, 0, 0);
        mål_i_plus_pos (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 300 000 // 8<* estimeret rc8000 *>
        else an := sek * 550 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Addition med negative integers:>);
        if online then setposition (out, 0, 0);
        mål_i_plus_neg (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 300 000 // 8 <* estimeret rc8000 *>
        else an := sek * 550 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Subtraktion med positive integers:>);
        if online then setposition (out, 0, 0);
        mål_i_minus_pos (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 300 000 // 8 <* estimeret rc8000 *>
        else an := sek * 550 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Subtraktion med negative integers:>);
        if online then setposition (out, 0, 0);
        mål_i_minus_neg (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 100 000 // 8 <* estimeret rc8000 *>
        else an := sek * 550 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Multiplikation med positive integers:>);
        if online then setposition (out, 0, 0);
        mål_i_gange_pos (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 100 000 // 8 <* estimeret rc8000 *>
        else an := sek * 550 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Multiplikation med negative integers:>);
        if online then setposition (out, 0, 0);
        mål_i_gange_neg (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 85 000 // 8 <* estimeret rc8000 *>
        else an := sek * 200 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Division med positive integers:>);
        if online then setposition (out, 0, 0);
        mål_i_div_pos (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 85 000 // 8 <* estimeret rc8000 *>
        else an := sek * 200 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Division med negative integers:>);
        if online then setposition (out, 0, 0);
        mål_i_div_neg (an);
        skriv_tid (<:stk:>, an);
      end integer
      else
      if målno = 12 then
      begin <* long *>
        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Long regning (+, -, *, //):>);
        if online then setposition (out, 0, 0);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 175 000 // 8 <* estimeret rc8000 *>
        else an := sek * 300 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Addition med positive longs:>);
        if online then setposition (out, 0, 0);
        mål_l_plus_pos (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 175 000 // 8 <* estimeret rc8000 *>
        else an := sek * 300 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Addition med negative longs:>);
        if online then setposition (out, 0, 0);
        mål_l_plus_neg (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 110 000 // 8 <* estimeret rc8000 *>
        else an := sek * 300 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Subtraktion med positive longs:>);
        if online then setposition (out, 0, 0);
        mål_l_minus_pos (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 110 000 // 8 <* estimeret rc8000 *>
        else an := sek * 300 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Subtraktion med negative longs:>);
        if online then setposition (out, 0, 0);
        mål_l_minus_neg (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 12 000 // 8 <* estimeret rc8000 *>
        else an := sek * 50 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Multiplikation med positive longs:>);
        if online then setposition (out, 0, 0);
        mål_l_gange_pos (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 12 000 // 8 <* estimeret rc8000 *>
        else an := sek * 50 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Multiplikation med negative longs:>);
        if online then setposition (out, 0, 0);
        mål_l_gange_neg (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 12 000 // 8 <* estimeret rc8000 *>
        else an := sek * 35 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Division med positive longs:>);
        if online then setposition (out, 0, 0);
        mål_l_div_pos (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 12 000 // 8 <* estimeret rc8000 *>
        else an := sek * 35 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Division med negative longs:>);
        if online then setposition (out, 0, 0);
        mål_l_div_neg (an);
        skriv_tid (<:stk:>, an);
      end long
      else
      if målno = 13 then
      begin <* real *>
        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Real regning (+, -, *, /):>);
        if online then setposition (out, 0, 0);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 55 000 // 8 <* estimeret rc8000 *>
        else an := sek * 100 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Addition med positive reals:>);
        if online then setposition (out, 0, 0);
        mål_r_plus_pos (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 55 000 // 8 <* estimeret rc8000 *>
        else an := sek * 100 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Addition med negative reals:>);
        if online then setposition (out, 0, 0);
        mål_r_plus_neg (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 55 000 // 8 <* estimeret rc8000 *>
        else an := sek * 100 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Subtraktion med positive reals:>);
        if online then setposition (out, 0, 0);
        mål_r_minus_pos (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 55 000 // 8 <* estimeret rc8000 *>
        else an := sek * 100 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Subtraktion med negative reals:>);
        if online then setposition (out, 0, 0);
        mål_r_minus_neg (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 30 000 // 8 <* estimeret rc8000 *>
        else an := sek * 125 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Multiplikation med positive reals:>);
        if online then setposition (out, 0, 0);
        mål_r_gange_pos (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 30 000 // 8 <* estimeret rc8000 *>
        else an := sek * 125 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Multiplikation med negative reals:>);
        if online then setposition (out, 0, 0);
        mål_r_gange_neg (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 30 000 // 8 <* estimeret rc8000 *>
        else an := sek * 90 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Division med positive reals:>);
        if online then setposition (out, 0, 0);
        mål_r_div_pos (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 30 000 // 8 <* estimeret rc8000 *>
        else an := sek * 90 000 // 8; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Division med negative reals:>);
        if online then setposition (out, 0, 0);
        mål_r_div_neg (an);
        skriv_tid (<:stk:>, an);
      end real
      else
      if målno = 14 then
      begin <* exponentiation *>
        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Exponentiationsberegninger (x ** y):>);
        if online then setposition (out, 0, 0);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 3 500 // 3 <* estimeret rc8000 *>
        else an := sek * 15 000 // 3; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Integer:>);
        if online then setposition (out, 0, 0);
        mål_i_exp (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 3 000 // 3 <* estimeret rc8000 *>
        else an := sek * 10 000 // 3; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Long:>);
        if online then setposition (out, 0, 0);
        mål_l_exp (an);
        skriv_tid (<:stk:>, an);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 1 500 // 3 <* estimeret rc8000 *>
        else an := sek * 4 500 // 3; <* estimeret rc9000 *>

        writeint (out, "nl", 1, <<d>, <:Real:>);
        if online then setposition (out, 0, 0);
        mål_r_exp (an);
        skriv_tid (<:stk:>, an);
      end exponentiation
      else
      if målno = 21 then
      begin <* tofrom *>
        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 800 <* estimeret rc8000 *>
        else an := sek * 2 500; <* estimeret rc9000 *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Tofrom lagerflytninger:>);
        if online then setposition (out, 0, 0);
        mål_tofrom ((an + 2) // 3); <* der arbejdes på 3 k af gangen *>
        skriv_tid (<:kbyte:>, (an + 2) // 3 * 3);
      end tofrom
      else
      if målno = 22 then
      begin <* system-5 *>
        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 200 <* estimeret rc8000 *>
        else an := sek * 1 000; <* estimeret rc9000 *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:System-5 lagerflytninger:>);
        if online then setposition (out, 0, 0);
        mål_system5 ((an + 2) // 3); <* der arbejdes på 3 k af gangen *>
        skriv_tid (<:kbyte:>, (an + 2) // 3 * 3);
      end system5
      else
      if målno = 23 then
      begin <* gettime *>
        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 3 250 <* estimeret rc8000 *>
        else an := sek * 10 000; <* estimeret rc9000 *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Systime-1 gettime:>);
        if online then setposition (out, 0, 0);
        mål_systime1 (an);
        skriv_tid (<:stk:>, an);
      end gettime
      else
      if målno = 31 then
      begin <* sieve *>
        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 1 <* estimeret rc8000 *>
        else an := sek * 6; <* estimeret rc9000 *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Sieve-benchmark (8190):>);
        if online then setposition (out, 0, 0);
        mål_sieve (an, 8190);
        skriv_tid (<:stk:>, an);
      end sieve
      else
      if målno = 32 then
      begin <* quicksort *>
        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := (sek + 9) // 10 * 2 <* estimeret rc8000 *>
        else an := (sek + 9) // 10 * 7; <* estimeret rc9000 *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Quicksort (10000 words):>);
        if online then setposition (out, 0, 0);
        mål_qsort (an, 10 000);
        skriv_tid (<:stk:>, an);
      end qsort
      else
      if målno = 33 then
      begin <* shellsort *>
        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := (sek + 38) // 39 * 1 <* estimeret rc8000 *>
        else an := (sek + 8) // 9 * 1; <* estimeret rc9000 *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Shellsort (10000 words):>);
        if online then setposition (out, 0, 0);
        mål_ssort (an, 10 000);
        skriv_tid (<:stk:>, an);
      end ssort
      else
      if målno = 34 then
      begin <* heapsort *>
        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := (sek + 14) // 15 * 1 <* estimeret rc8000 *>
        else an := (sek + 2) // 3 * 1; <* estimeret rc9000 *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Heapsort (10000 words):>);
        if online then setposition (out, 0, 0);
        mål_hsort (an, 10 000);
        skriv_tid (<:stk:>, an);
      end hsort
      else
      if målno = 35 then
      begin <* matrix *>
        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := (sek + 9) // 10 * 4 <* estimeret rc8000 *>
        else an := (sek + 9) // 10 * 20; <* estimeret rc9000 *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Matrixberegning (32x32 words):>);
        if online then setposition (out, 0, 0);
        mål_matrix (an, 32);
        skriv_tid (<:stk:>, an);
      end matrix
      else
      if målno = 36 then
      begin <* fmatrix *>
        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := (sek + 9) // 10 * 3 <* estimeret rc8000 *>
        else an := (sek + 9) // 10 * 13; <* estimeret rc9000 *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Matrixberegning med flydende tal (32x32 reals):>);
        if online then setposition (out, 0, 0);
        mål_fmatrix (an, 32);
        skriv_tid (<:stk:>, an);
      end fmatrix
      else
      if målno = 41 then
      begin <* create *>
        find_segm (disc1, segm, 0, 2);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 5 <* estimeret rc8000 *>
        else an := sek * 5; <* estimeret rc9000 *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Create file (opret, permanent, clear):>,
          <: på :>, disc1, <:, :>, segm, <: segm/fil :>);
        if online then setposition (out, 0, 0);
        mål_create (an, buflgd, shares, segm, disc1, disc2);
        skriv_tid (<:stk:>, an);
      end create
      else
      if målno = 42 then
      begin <* change size *>
        find_segm (disc1, segm, buflgd, 2);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 10 <* estimeret rc8000 *>
        else an := sek * 10; <* estimeret rc9000 *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Ret fil, fillængde:>,
          <: på :>, disc1, <:, :>, segm, <: segm/fil :>);
        if online then setposition (out, 0, 0);
        mål_changesize (an, buflgd, shares, segm, disc1, disc2);
        skriv_tid (<:stk:>, an);
      end changesize
      else
      if målno = 43 then
      begin <* change tail *>
        find_segm (disc1, segm, 0, 2);

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 10 <* estimeret rc8000 *>
        else an := sek * 10; <* estimeret rc9000 *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Ret fil, tail (10):>,
          <: på :>, disc1, <:, :>, segm, <: segm/fil :>);
        if online then setposition (out, 0, 0);
        mål_changetail (an, buflgd, shares, segm, disc1, disc2);
        skriv_tid (<:stk:>, an);
      end changetail
      else
      if målno = 51 then
      begin <* write seq *>
        if segm > 0 then antal := antal * segm; <* antal som segmenter *>

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 50 * ((buflgd + 2) // 3) <* estimeret rc8000 *>
        else an := sek * 50 * ((buflgd + 2) // 3); <* estimeret rc9000 *>

        find_segm (disc1, segm, 0, 0);
        if segm > an then segm := an; <* max antal segmenter *>
        segm := segm // buflgd * buflgd; <* helt antal buffere *>
        an := (an + segm - 1) // segm; <* antal som hele filer *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Seq-write:>,
          <: på :>, disc1, <:, :>, segm, <: segm/fil, :>,
          shares, <:'bufret, :>, buflgd, <: segm/blok :>);
        if online then setposition (out, 0, 0);
        mål_wseq (an, buflgd, shares, segm, disc1, disc2);
        skriv_tid (<:segm:>, an * segm);
      end wseq
      else
      if målno = 52 then
      begin <* read seq *>
        if segm > 0 then antal := antal * segm; <* antal som segmenter *>

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 50 * ((buflgd + 2) // 3) <* estimeret rc8000 *>
        else an := sek * 50 * ((buflgd + 2) // 3); <* estimeret rc9000 *>

        find_segm (disc1, segm, 0, 0);
        if segm > an then segm := an; <* max antal segmenter *>
        segm := segm // buflgd * buflgd; <* helt antal buffere *>
        an := (an + segm - 1) // segm; <* antal som hele filer *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Seq-read:>,
          <: på :>, disc1, <:, :>, segm, <: segm/fil, :>,
          shares, <:'bufret, :>, buflgd, <: segm/blok :>);
        if online then setposition (out, 0, 0);
        mål_rseq (an, buflgd, shares, segm, disc1, disc2);
        skriv_tid (<:segm:>, an * segm);
      end rseq
      else
      if målno = 53 then
      begin <* write random *>
        if segm > 0 then antal := antal * segm; <* antal som segmenter *>

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 50 * ((buflgd + 2) // 3) <* estimeret rc8000 *>
        else an := sek * 50 * ((buflgd + 2) // 3); <* estimeret rc9000 *>

        find_segm (disc1, segm, 0, 0);
        if segm > an then segm := an; <* max antal segmenter *>
        segm := segm // buflgd * buflgd; <* helt antal buffere *>
        an := (an + segm - 1) // segm; <* antal som hele filer *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Rand-write:>,
          <: på :>, disc1, <:, :>, segm, <: segm/fil, :>,
          shares, <:'bufret, :>, buflgd, <: segm/blok :>);
        if online then setposition (out, 0, 0);
        mål_wrand (an, buflgd, shares, segm, disc1, disc2);
        skriv_tid (<:segm:>, an * segm);
      end wrand
      else
      if målno = 54 then
      begin <* read random *>
        if segm > 0 then antal := antal * segm; <* antal som segmenter *>

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 50 * ((buflgd + 2) // 3) <* estimeret rc8000 *>
        else an := sek * 50 * ((buflgd + 2) // 3); <* estimeret rc9000 *>

        find_segm (disc1, segm, 0, 0);
        if segm > an then segm := an; <* max antal segmenter *>
        segm := segm // buflgd * buflgd; <* helt antal buffere *>
        an := (an + segm - 1) // segm; <* antal som hele filer *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Rand-read:>,
          <: på :>, disc1, <:, :>, segm, <: segm/fil, :>,
          shares, <:'bufret, :>, buflgd, <: segm/blok :>);
        if online then setposition (out, 0, 0);
        mål_rrand (an, buflgd, shares, segm, disc1, disc2);
        skriv_tid (<:segm:>, an * segm);
      end rrand
      else
      if målno = 55 then
      begin <* opdat random *>
        if segm > 0 then antal := antal * segm; <* antal som segmenter *>

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 25 * ((buflgd + 2) // 3) <* estimeret rc8000 *>
        else an := sek * 25 * ((buflgd + 2) // 3); <* estimeret rc9000 *>

        find_segm (disc1, segm, 0, 0);
        if segm > an then segm := an; <* max antal segmenter *>
        segm := segm // buflgd * buflgd; <* helt antal buffere *>
        an := (an + segm - 1) // segm; <* antal som hele filer *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Rand-opdat (read/rewrite):>,
          <: på :>, disc1, <:, :>, segm, <: segm/fil, :>,
          shares, <:'bufret, :>, buflgd, <: segm/blok :>);
        if online then setposition (out, 0, 0);
        mål_orand (an, buflgd, shares, segm, disc1, disc2);
        skriv_tid (<:segm:>, an * segm);
      end rrand
      else
      if målno = 56 then
      begin <* write cross *>
        if segm > 0 then antal := antal * segm; <* antal som segmenter *>

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 50 * ((buflgd + 2) // 3) <* estimeret rc8000 *>
        else an := sek * 50 * ((buflgd + 2) // 3); <* estimeret rc9000 *>

        find_segm (disc1, segm, 0, 0);
        if segm > an then segm := an; <* max antal segmenter *>
        segm := segm // buflgd * buflgd; <* helt antal buffere *>
        an := (an + segm - 1) // segm; <* antal som hele filer *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Kryds-write:>,
          <: på :>, disc1, <:, :>, segm, <: segm/fil, :>,
          shares, <:'bufret, :>, buflgd, <: segm/blok :>);
        if online then setposition (out, 0, 0);
        mål_wcross (an, buflgd, shares, segm, disc1, disc2);
        skriv_tid (<:segm:>, an * segm);
      end wcross
      else
      if målno = 57 then
      begin <* read cross *>
        if segm > 0 then antal := antal * segm; <* antal som segmenter *>

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 50 * ((buflgd + 2) // 3) <* estimeret rc8000 *>
        else an := sek * 50 * ((buflgd + 2) // 3); <* estimeret rc9000 *>

        find_segm (disc1, segm, 0, 0);
        if segm > an then segm := an; <* max antal segmenter *>
        segm := segm // buflgd * buflgd; <* helt antal buffere *>
        an := (an + segm - 1) // segm; <* antal som hele filer *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Kryds-read:>,
          <: på :>, disc1, <:, :>, segm, <: segm/fil, :>,
          shares, <:'bufret, :>, buflgd, <: segm/blok :>);
        if online then setposition (out, 0, 0);
        mål_rcross (an, buflgd, shares, segm, disc1, disc2);
        skriv_tid (<:segm:>, an * segm);
      end rcross
      else
      if målno = 58 then
      begin <* opdat cross *>
        if segm > 0 then antal := antal * segm; <* antal som segmenter *>

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 25 * ((buflgd + 2) // 3) <* estimeret rc8000 *>
        else an := sek * 25 * ((buflgd + 2) // 3); <* estimeret rc9000 *>

        find_segm (disc1, segm, 0, 0);
        if segm > an then segm := an; <* max antal segmenter *>
        segm := segm // buflgd * buflgd; <* helt antal buffere *>
        an := (an + segm - 1) // segm; <* antal som hele filer *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Kryds-opdat:>,
          <: på :>, disc1, <:, :>, segm, <: segm/fil, :>,
          shares, <:'bufret, :>, buflgd, <: segm/blok :>);
        if online then setposition (out, 0, 0);
        mål_ocross (an, buflgd, shares, segm, disc1, disc2);
        skriv_tid (<:segm:>, an * segm);
      end ocross
      else
      if målno = 59 then
      begin <* disckopiering *>
        integer s1, s2, sl, se;

        if segm > 0 then antal := antal * segm; <* antal som segmenter *>

        if antal > 0 then an := antal <* antal som parameter *> else
        if rc8000 then an := sek * 35 * ((buflgd + 2) // 3) <* estimeret rc8000 *>
        else an := sek * 35 * ((buflgd + 2) // 3); <* estimeret rc9000 *>

        s1 := s2 := segm;

        find_segm (disc1, s1, sl, 0);

        if disc1 (1) = disc2 (1)
        and (disc1 (1) extract 8 = 'nul' or disc1 (2) = disc2 (2))
        then s1 := s2 := (s1 + sl - 1) // sl // 2 * sl <* samme disk *>
        else find_segm (disc2, s2, sl, 0);

        segm := if s1 <= s2 then s1 else s2;

        if segm > an then segm := an; <* max antal segmenter *>
        segm := segm // buflgd * buflgd; <* helt antal buffere *>
        an := (an + segm - 1) // segm; <* antal som hele filer *>

        writeint (out, "nl", 2, <<zddd.dd>, xkl, ":", 1, <<d>, <:Filkopiering:>,
          <: :>, disc1, <:->:>, disc2, <:, :>, segm, <: segm/fil, :>,
          shares * 2, <:'bufret, :>, buflgd, <: segm/blok :>);
        if online then setposition (out, 0, 0);
        mål_dcopy (an, buflgd, shares, segm, disc1, disc2);
        skriv_tid (<:segm:>, an * segm);
      end dcopy
      else
      udfør_mål_proc := false; <* ukendt test *>

      if test or kl then wr_test (<:end  :>, målno);

      if online then setposition (out, 0, 0);
    end procedure udfør_mål_proc;

    if not trapstop then trap (trap_ud);

    an := antal;
    bu := buflgd;
    se := maxsegm;
    tofrom (di1, disc1, 8);
    tofrom (di2, disc2, 8);
    gl_blocksread := blocksread;

    if målno >= 50 and målno <= 59 then
    begin <* disk io *>
      sh := 0;
      repeat
        sh := if shares > 0 then shares else sh + 1;

        bu := 0;
        repeat
          if buflgd > 0 then bu := buflgd else
          if bu <= 0 then bu := 1 else
          if bu = 1 then bu := 32 else
          if bu = 32 then bu := 46 else
          if målno = 59 then
          begin
            bu := xmaxbuflgd (1, if corelock then 4000 else 10000, true) // (sh * 2) // 512;
            if bu > 736 then bu := 736;
          end;

          if bu >= 1 then
          mål_proc := udfør_mål_proc (målno, an, bu, sh, se, di1, di2);
        until buflgd > 0
        or bu < 1
        or bu >= 46 and målno <> 59
        or bu > 46 and målno = 59;
      until shares > 0 or målno >= 53 or sh >= 2;
    end
    else mål_proc := udfør_mål_proc (målno, an, bu, sh, se, di1, di2);

    if not datatest and blocksread <> gl_blocksread
    then write (out, "nl", 1, <<d>,
      <:*** Segmentering under ovenstående måling, antal segm.:>,
      blocksread - gl_blocksread);

    if false then
trap_ud:
    begin
      xwritealarm;
      xtrapbreak;
      fejl (<:programnedgang:>, - 1);
    end;
  end procedure mål_proc;

▶EOF◀