home *** CD-ROM | disk | FTP | other *** search
/ C!T ROM 2 / ctrom_ii_b.zip / ctrom_ii_b / PROGRAM / PASCAL / PERFORM / SETEST.PAS < prev    next >
Pascal/Delphi Source File  |  1993-07-10  |  8KB  |  216 lines
  1. {$IFDEF VER70}
  2. {$A+,B-,D-,E-,F-,G-,I-,L-,N-,O-,P-,Q-,R-,S+,T-,V-,X+}
  3. {$ELSE}
  4. {$A+,B-,D-,E-,F-,G-,I-,L-,N-,O-,R-,S+,V-,X+}
  5. {$ENDIF}
  6. {$M 16384,0,655360}
  7. {
  8.     Borland Pascal (Objects) 7.0.
  9.     Copyright (c) 10-7-1993 DwarFools & Consultancy by drs. Robert E. Swart.
  10.                             P.O. box 799
  11.                             5702 NP  Helmond
  12.                             The Netherlands
  13.     Code size: 6528 bytes
  14.     Data size:  714 bytes
  15.     .EXE size: 6992 bytes
  16.     -------------------------------------------------------------------------
  17.     This program provides four routines to speed up the 'in', '+', '-', and a
  18.     new inverse operation on sets. The routines are named InSet23, Include21,
  19.     Exclude23 and Inverse21.  The numbers indicate the number of inline bytes
  20.     that are expanded each time the macro is called.
  21.  
  22.     The speed results are as follows:
  23.  
  24.     reps    Bob Swart  Borland  speed
  25.     Include:    18192     1400  1299%
  26.     InSet:      17978    13341   135%
  27.     Exclude:    18191     1365  1333%
  28.     Inverse:    18192     1284  1416%
  29.  
  30.     Note that the include and exclude macros are about 13-14 times as fast as
  31.     the regular pascal operators.
  32. }
  33.  
  34.  function InSet25(var _Set; OrdElement: Byte): Boolean;
  35.  InLine(
  36.    $58/         {   pop   AX                   }
  37.    $30/$E4/     {   xor   AH,AH                }
  38.    $5F/         {   pop   DI                   }
  39.    $07/         {   pop   ES                   }
  40.    $89/$C3/     {   mov   BX,AX                }
  41.    $B1/$03/     {   mov   CL,3                 }
  42.    $D3/$EB/     {   shr   BX,CL                }
  43.    $88/$C1/     {   mov   CL,AL                }
  44.    $80/$E1/$07/ {   and   CL,$07               }
  45.    $B0/$01/     {   mov   AL,1                 }
  46.    $D2/$E0/     {   shl   AL,CL                }
  47.    $26/         {   ES:                        }
  48.    $22/$01/     {   and   AL,BYTE PTR [DI+BX]  }
  49.    $D2/$E8);    {   shr   AL,CL                }
  50.  
  51.  function InSet23(var _Set; OrdL: Byte): Boolean;
  52.  InLine(
  53.    $58/          {   pop   AX                   }
  54.    $31/$DB/      {   xor   BX,BX                }
  55.    $B1/$03/      {   mov   CL,3                 }
  56.    $88/$C3/      {   mov   BL,AL                }
  57.    $5F/          {   pop   DI                   }
  58.    $D3/$EB/      {   shr   BX,CL                }
  59.    $24/$07/      {   and   AL,$07               }
  60.    $B1/$01/      {   mov   CL,1                 }
  61.    $07/          {   pop   ES                   }
  62.    $91/          {   xchg  AX,CX                }
  63.    $D2/$E0/      {   shl   AL,CL                }
  64.    $26/          {   ES:                        }
  65.    $22/$01/      {   and   AL,BYTE PTR [DI+BX]  }
  66.    $D2/$E8);     {   shr   AL,CL                }
  67.  
  68.  procedure Include21(var _Set; OrdElement: Byte);
  69.  InLine(
  70.    $58/            {  pop   AX                  }
  71.    $31/$DB/        {  xor   BX,BX               }
  72.    $B1/$03/        {  mov   CL,3                }
  73.    $88/$C3/        {  mov   BL,AL               }
  74.    $5F/            {  pop   DI                  }
  75.    $D3/$EB/        {  shr   BX,CL               }
  76.    $24/$07/        {  and   AL,$07              }
  77.    $B1/$01/        {  mov   CL,1                }
  78.    $07/            {  pop   ES                  }
  79.    $91/            {  xchg  AX,CX               }
  80.    $D2/$E0/        {  shl   AL,CL               }
  81.    $26/            {  ES:                       }
  82.    $08/$01);       {  or    BYTE PTR [DI+BX],AL }
  83.  
  84.  procedure Exclude23(var _Set; OrdElement: Byte);
  85.  InLine(
  86.    $58/            {  pop   AX                  }
  87.    $31/$DB/        {  xor   BX,BX               }
  88.    $B1/$03/        {  mov   CL,3                }
  89.    $88/$C3/        {  mov   BL,AL               }
  90.    $5F/            {  pop   DI                  }
  91.    $D3/$EB/        {  shr   BX,CL               }
  92.    $24/$07/        {  and   AL,$07              }
  93.    $B1/$01/        {  mov   CL,1                }
  94.    $07/            {  pop   ES                  }
  95.    $91/            {  xchg  AX,CX               }
  96.    $D2/$E0/        {  shl   AL,CL               }
  97.    $F6/$D0/        {  not   AL                  }
  98.    $26/            {  ES:                       }
  99.    $20/$01);       {  and   BYTE PTR [DI+BX],AL }
  100.  
  101.  procedure Inverse21(var _Set; OrdElement: Byte);
  102.  InLine(
  103.    $58/            {  pop   AX                  }
  104.    $31/$DB/        {  xor   BX,BX               }
  105.    $B1/$03/        {  mov   CL,3                }
  106.    $88/$C3/        {  mov   BL,AL               }
  107.    $5F/            {  pop   DI                  }
  108.    $D3/$EB/        {  shr   BX,CL               }
  109.    $24/$07/        {  and   AL,$07              }
  110.    $B1/$01/        {  mov   CL,1                }
  111.    $07/            {  pop   ES                  }
  112.    $91/            {  xchg  AX,CX               }
  113.    $D2/$E0/        {  shl   AL,CL               }
  114.    $26/            {  ES:                       }
  115.    $30/$01);       {  xor   BYTE PTR [DI+BX],AL }
  116.  
  117. var TimerTick: Word absolute $0040:$006C;
  118.     StartTick: Word;
  119.     BobSwart,Reps: LongInt;
  120.  
  121. var S: Set of Char;
  122.     t: Char;
  123.  
  124. begin
  125.   writeln('reps    Bob Swart  Borland  speed');
  126.   S := [];
  127.   t := '@';
  128.   write('Include: ');
  129.   Reps := 0;
  130.   StartTick := TimerTick;
  131.   while StartTick = TimerTick do {wait for end of TimerTick};
  132.   StartTick := TimerTick;
  133.   repeat
  134.     Include21(S,60+Ord(t));
  135.     { call function }
  136.     Inc(Reps);
  137.   until StartTick <> TimerTick;
  138.   write(Reps:8);
  139.   BobSwart := Reps;
  140.   Reps := 0;
  141.   StartTick := TimerTick;
  142.   while StartTick = TimerTick do {wait for end of TimerTick};
  143.   StartTick := TimerTick;
  144.   repeat
  145.     S := S + [t];
  146.     { call function }
  147.     Inc(Reps);
  148.   until StartTick <> TimerTick;
  149.   writeln(Reps:9,100.0*BobSwart/Reps:6:0,'%');
  150.  
  151.   write('InSet:   ');
  152.   Reps := 0;
  153.   StartTick := TimerTick;
  154.   while StartTick = TimerTick do {wait for end of TimerTick};
  155.   StartTick := TimerTick;
  156.   repeat
  157.     if InSet23(S,Ord(t)) then
  158.     { call function }
  159.     Inc(Reps);
  160.   until StartTick <> TimerTick;
  161.   write(Reps:8);
  162.   BobSwart := Reps;
  163.   Reps := 0;
  164.   StartTick := TimerTick;
  165.   while StartTick = TimerTick do {wait for end of TimerTick};
  166.   StartTick := TimerTick;
  167.   repeat
  168.     if t in S then { call function }
  169.     Inc(Reps);
  170.   until StartTick <> TimerTick;
  171.   writeln(Reps:9,100.0*BobSwart/Reps:6:0,'%');
  172.  
  173.   write('Exclude: ');
  174.   Reps := 0;
  175.   StartTick := TimerTick;
  176.   while StartTick = TimerTick do {wait for end of TimerTick};
  177.   StartTick := TimerTick;
  178.   repeat
  179.     Exclude23(S,Ord(t));
  180.     Inc(Reps);
  181.   until StartTick <> TimerTick;
  182.   write(Reps:8);
  183.   BobSwart := Reps;
  184.   Reps := 0;
  185.   StartTick := TimerTick;
  186.   while StartTick = TimerTick do {wait for end of TimerTick};
  187.   StartTick := TimerTick;
  188.   repeat
  189.     S := S - [t];
  190.     Inc(Reps);
  191.   until StartTick <> TimerTick;
  192.   writeln(Reps:9,100.0*BobSwart/Reps:6:0,'%');
  193.  
  194.   write('Inverse: ');
  195.   Reps := 0;
  196.   StartTick := TimerTick;
  197.   while StartTick = TimerTick do {wait for end of TimerTick};
  198.   StartTick := TimerTick;
  199.   repeat
  200.     Inverse21(S,Ord(t));
  201.     Inc(Reps);
  202.   until StartTick <> TimerTick;
  203.   write(Reps:8);
  204.   BobSwart := Reps;
  205.   Reps := 0;
  206.   StartTick := TimerTick;
  207.   while StartTick = TimerTick do {wait for end of TimerTick};
  208.   StartTick := TimerTick;
  209.   repeat
  210.     if t in S then S := S - [t]
  211.               else S := S + [t];
  212.     Inc(Reps);
  213.   until StartTick <> TimerTick;
  214.   writeln(Reps:9,100.0*BobSwart/Reps:6:0,'%');
  215. end.
  216.