Path: utzoo!utgpu!watmath!clyde!att!rutgers!ucsd!sdcsvax!ucsdhub!esosun!seismo!uunet!pcrat!dry
From: dry2@pcrat.UUCP (Dhrystone)
Newsgroups: comp.arch
Subject: Dhrystone 2.1 (3 of 3)
Keywords: integer benchmark
Message-ID: <631@pcrat.UUCP>
Date: 4 Dec 88 07:12:47 GMT
Organization: PC Research, Inc., Tinton Falls, NJ
Lines: 858


#! /bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #! /bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh (not csh) to create:
#	dhry.p
# This archive created: Sun Dec  4 00:42:38 1988
export PATH; PATH=/bin:/usr/bin:$PATH
echo shar: "extracting 'dhry.p'" '(37108 characters)'
if test -f 'dhry.p'
then
	echo shar: "will not over-write existing file 'dhry.p'"
else
sed 's/^X//' << \SHAR_EOF > 'dhry.p'
X(*
X ****************************************************************************
X *
X *                   "DHRYSTONE" Benchmark Program
X *                   -----------------------------
X *                                                                            
X *  Version:    Pascal, Version 2.1
X *                                                                            
X *  File:       dhry.p
X *
X *  Date:       May 25, 1988
X *
X *  Author:     Reinhold P. Weicker
X *                      Siemens AG, E STE 35
X *                      Postfach 3240
X *                      8520 Erlangen
X *                      Germany (West)
X *                              Phone:  [xxx-49]-9131-7-20330
X *                                      (8-17 Central European Time)
X *                              Usenet: ..!mcvax!unido!estevax!weicker
X *
X *              Original Version (in Ada) published in
X *              "Communications of the ACM" vol. 27., no. 10 (Oct. 1984),
X *              pp. 1013 - 1030, together with the statistics
X *              on which the distribution of statements etc. is based,
X *
X *              This version uses calls to the Pascal runtime library of the
X *              Berkeley UNIX system (4.3 bsd) for time measurement.
X *              For measurements on other systems, these calls need to be
X *              modified.                                
X *                                                                           
X *  Collection of Results:
X *              Reinhold Weicker (address see above) and
X *              
X *              Rick Richardson
X *              PC Research. Inc.
X *              94 Apple Orchard Drive
X *              Tinton Falls, NJ 07724
X *                      Phone:  (201) 834-1378 (9-17 EST)               
X *                      Usenet: ...!seismo!uunet!pcrat!rick
X *
X *      Please send results to Rick Richardson and/or Reinhold Weicker.
X *      Complete information should be given on hardware and software used.
X *      Hardware information includes: Machine type, CPU, type and size
X *      of caches; for microprocessors: clock frequency, memory speed
X *      (number of wait states).
X *      Software information includes: Compiler (and runtime library)
X *      manufacturer and version, compilation switches, OS version.
X *      The Operating System version may give an indication about the
X *      compiler; Dhrystone itself performs no OS calls in the measurement loop.
X *
X *      The complete output generated by the program should be mailed
X *      such that at least some checks for correctness can be made.
X *
X ****************************************************************************
X *
X *  History:    This version Pascal/2.1 has been made for two reasons:
X *
X *              1) There is a need for a common Pascal version of
X *              Dhrystone. Although translation from the published (Ada)
X *              version to Pascal is straightforward in most aspects,
X *              there are cases where it may not be obvious to everyone.
X *              There should be, as far as possible, only one Pascal version
X *              of Dhrystone such that results can be compared without
X *              restrictions. Also, a Pascal version of Dhrystone has not yet
X *              found a network distribution comparable to the C version
X *              (version 1.1) distributed by Rick Richardson.
X *              
X *              2) As far as it is possible without changes to the Dhrystone
X *              statistics, optimizing compilers should be prevented from
X *              removing significant statements.
X *
X *              This Pascal version 2.1 has been made consistent with the
X *              C version 2.1; therefore the acknowledgments for the C version
X *              are due for the Pascal version as well: I thank
X *              Rick Richardson (Tinton Falls, NJ), Chaim Benedelac (Nat.
X *              Semi.), David Ditzel (SUN), Earl Killian and John Mashey (MIPS),
X *              Alan Smith and Rafael Saavedra-Barrera (UC at Berkeley)
X *              for their help with comments on earlier versions of the
X *              benchmark.
X *
X *  Changes:    In the initialization part, this version differs 
X *              from the Pascal version previously distributed by Reinhold
X *              Weicker, the number of runs through Dhrystone is obtained
X *              interactively from the terminal. Output of the result 
X *              has been changed to conform to the C version (2.1).
X *              The changes in the initialization part and in the printing
X *              of the result have no impact on performance measurement 
X *              since they are outside the measaurement loop.
X *              
X *              Inside the measurement loop, this version follows the
X *              version previously distributed by Reinhold Weicker.
X *              As a correction to the published version, a statement
X *              initializing Array2Glob [8,7] (outside the measurement
X *              loop) has been added. Otherwise, this array element would
X *              have an undefined value.
X *
X *              At several places in the benchmark, code has been added,
X *              but within the measurement loop only in branches that 
X *              are not executed. The intention is that optimizing compilers
X *              should be prevented from moving code out of the measurement
X *              loop, or from removing code altogether. Since the statements
X *              that are executed within the measurement loop have NOT been
X *              changed, all numbers defining the "Dhrystone distribution"
X *              (distribution of statements, operand types and locality)
X *              still hold. Except for sophisticated optimizing compilers,
X *              execution times for this version should be the same as
X *              for previous versions.
X *
X *              Since it has proven difficult to subtract the time for the
X *              measurement loop overhead in a correct way, the loop check
X *              has been made a part of the benchmark. This does have
X *              an impact - though a very minor one - on the distribution
X *              statistics which have been updated for this version.
X *
X *              All changes within the measurement loop are described
X *              and discussed in the companion paper "Rationale for
X *              Dhrystone version 2".
X *
X *              Because of the self-imposed limitation that the order and
X *              distribution of the executed statements should not be
X *              changed, there are still cases where optimizing compilers
X *              may not generate code for some statements. To a certain
X *              degree, this is unavoidable for small synthetic benchmarks.
X *              Users of the benchmark are advised to check code listings
X *              whether code is generated for all statements of Dhrystone.
X *
X *              Version 2.1 is identical to version 2.0 distributed via
X *              the UNIX network Usenet in March 1988 except that it corrects
X *              some minor deficiencies that were found by users of version 2.0.
X *              The only change within the measurement loop is that a
X *              non-executed "else" part was added to the "if" statement in
X *              Func3, and a non-executed "else" part removed from Proc3.
X *
X ***************************************************************************
X *
X *  Compilation model and measurement (IMPORTANT):
X *
X *  This program contains the Dhrystone program, including measurement setup,
X *  in one file. The original (Ada) program contained three packages,
X *  - a package with global type definitions,
X *  - Pack_1, containing the main program (Proc_0 in Ada) and procedures
X *            Proc_1, ... , Proc_5,
X *  - Pack_2, containing Proc_6, ... , Proc_8, Func_1, ..., Func_3.
X *  Since ISO/ANSI Standard Pascal provides no means to express separate
X *  compilation (although many Pascal implementations provide such a feature),
X *  it is not possible to formulate a portable Pascal version with the program
X *  in several modules, corresponding more closely to the Ada and C versions.
X *  Therefore, no attempt has been made to construct a Pascal version with
X *  the program consisting of several modules.
X *                                                                           
X *  This difference may impact execution time because the compiler can
X *  perform more data flow analysis for a single-module program;
X *  sophisticated compilers may be able to suppress code generation for
X *  some parts of the program.
X *  Users should check machine code listings generated by the compiler
X *  to ensure that code is generated for all parts of the program.
X *
X *  The following "ground rules" apply for measurements:
X *  - No procedure merging
X *  - Otherwise, compiler optimizations are allowed but should be indicated
X *  See the companion paper "Rationale for Dhrystone Version 2" for a more
X *  detailed discussion of these ground rules.
X *
X *  For 16-Bit processors (e.g. 80x86), times for all compilation models
X *  ("small", "medium", "large") should be given if possible, together
X *  with a definition of these models for the compiler system used.
X *
X **************************************************************************
X *
X *  Dhrystone (Pascal version) statistics:
X *
X *  [Comment from the first distribution by Reinhold Weicker,
X *   the distribution statistics have been updated for Version 2.1.
X *   Note that because of language differences, the numbers are different
X *   from the Ada version. The main difference is that the variables that
X *   are local variables of "Proc_0" (Ada) or "main" (C) are global
X *   variables in the Pascal version.]
X *                                                                           
X *  The following program contains statements of a high level programming    
X *  language (here: Pascal) in a distribution considered representative:     
X *                                                                           
X *    assignments                  58
X *    control statements           28
X *    procedure, function calls    15
X *                                                                           
X *  100 statements are dynamically executed. The program is balanced with    
X *  respect to the three aspects:                                            
X *                                                                           
X *    - statement type                                                       
X *    - operand type (for simple data types)                                 
X *    - operand access                                                       
X *         operand global, local, parameter, or constant.                    
X *           There is no static nesting of blocks or procedures,             
X *           therefore all variables are either global or local.             
X *                                                                           
X *  The combination of these three aspects is balanced only approximately.   
X *                                                                           
X *  1. Statement Type:                                                       
X *  -----------------             number
X *                                                                           
X *     V1 := V2                   15                                         
X *     V := Constant              12                                         
X *       (incl. V1 := F(..)                                                  
X *     Assignment,                 7                                         
X *       with array element                                                  
X *     Assignment,                 6                                         
X *       with record component                                               
X *                                --                                       
X *                                40       40                                
X *                                                                           
X *     X := Y +|-|and|or Z         5                                         
X *     X := Y +|-|"=" Constant     6                                         
X *     X := X +|- 1                3                                         
X *     X := Y *|/ Z                2                                         
X *     X := Expression,            1                                         
X *          two operators                                                    
X *     X := Expression,            1                                         
X *          three operators                                                  
X *                                --                                         
X *                                18       18                                
X *                                                                           
X *     if .... then ....          14                                         
X *       with "else"      7                                                  
X *       without "else"   7                                                  
X *           executed        3                                               
X *           not executed    4                                               
X *     for I in 1..N do ...        7  |  counted every time                  
X *     while ... do ...            4  |  the loop condition                  
X *     repeat ... until            1  |  is evaluated                        
X *     case ... end                1                                         
X *     with                        1                                         
X *                                --                                         
X *                                28       28                                
X *                                                                           
X *     P (...)  procedure call    10                                         
X *     X := F (...)                                                          
X *             function  call      5                                         
X *                                --                                         
X *                                15       15                                
X *                                        ---                              
X *                                        101                                
X *                                                                           
X *    22 of the 58 assignments have a variable of a constrained              
X *    (sub-)type as their destination. In general, discriminant checks       
X *    will be necessary in these cases; however, the compiler may            
X *    optimize out some of these checks.                                     
X *                                                                           
X *    The average number of parameters in procedure or function calls        
X *    is 1.80 (not counting the function values as implicit parameters).     
X *                                                                           
X *                                                                           
X *  2. Operators                                                             
X *  ------------                                                             
X *                          number    approximate                            
X *                                    percentage                             
X *                                                                           
X *    Arithmetic             27          52.9                                
X *                                                                           
X *       +                     16          31.4                              
X *       -                      7          13.7                              
X *       *                      3           5.9                              
X *       div                    1           2.0                              
X *                                                                           
X *    Comparison             20           39.2                               
X *                                                                           
X *       =                      9           17.6                             
X *       <>                     4            7.8                             
X *       >                      1            2.0                             
X *       <                      3            5.9                             
X *       >=                     1            2.0                             
X *       <=                     2            3.9                             
X *                                                                           
X *    Logic                   4            7.8                               
X *                                                                           
X *       AND                    1            2.0                             
X *       OR                     1            2.0                             
X *       NOT                    2            3.9                             
X *                                                                           
X *                           --          -----                               
X *                           51           99.9                               
X *                                                                           
X *                                                                           
X *  3. Operand Type (counted once per operand reference):                    
X *  ---------------                                                          
X *                          number    approximate                            
X *                                    percentage                             
X *                                                                           
X *     Integer               135        54.7 %                               
X *     Character              47        19.0 %                               
X *     Enumeration            31        12.6 %                               
X *     Boolean                13         5.3 %                               
X *     Pointer                11         4.5 %                               
X *     String30                6         2.4 %                               
X *     Array                   2         0.8 %                               
X *     Record                  2         0.8 %                               
X *                           ---       -------                               
X *                           247        100.1 %
X *                                                                           
X *  When there is an access path leading to the final operand (e.g. a record 
X *  component), only the final data type on the access path is counted.      
X *                                                                           
X *  There are 16 accesses to components of a record, 9 of them go to         
X *  a component in a variant part. For some of these accesses, the           
X *  compiler may suppress generation of code checking the tag field          
X *  during optimization.                                                     
X *                                                                           
X *                                                                           
X *  3. Operand Locality:                                                     
X *  -------------------                                                      
X *                                                                           
X *     local variable               84        34.0 %                         
X *     global variable              58        23.5 %                         
X *     parameter                    45        18.2 %                         
X *        value                        23         9.3 %                      
X *        reference                    22         8.9 %                      
X *     function result               5         2.0 %                         
X *     constant                     55        22.3 %                         
X *                                 ---       -------                         
X *                                 247       100.0 %                         
X *                                                                           
X *                                                                           
X *  The program does not compute anything meaningful, but it is syntactically
X *  and semantically correct. All variables have a value assigned to them    
X *  before they are used as a source operand.                                
X *                                                                           
X *  There may be cases where a highly optimizing compiler may recognize      
X *  unnecessary statements and may not generate code for them.               
X *                                                                           
X *  There has been no explicit effort to account for the effects of a        
X *  cache, or to balance the use of long or short displacements for code or  
X *  data.                                                                    
X *                                                                           
X ****************************************************************************
X *)
X
Xprogram Dhrystone (input, output);
X(***************)
X
Xconst (* for measurement *)
X
X  MicrosecondsPerClock  = 1000;
X  ClocksPerSecond       = 1000;
X        (* In Berkeley UNIX Pascal, the function "clock"        *)
X        (* returns milliseconds                                 *)
X  TooSmallTime          = 2000;
X        (* Measurements should last at least 2 seconds          *)
X
Xtype
X
X  (* Global type definitions *)
X
X  Enumeration           = (Ident1, Ident2, Ident3, Ident4, Ident5);
X
X  OneToThirty           = 1..30;
X  OneToFifty            = 1..50;
X  CapitalLetter         = 'A'..'Z';
X
X  String30              = packed array [OneToThirty] of char;
X
X  Array1DimInteger      = array [OneToFifty] of integer;
X  Array2DimInteger      = array [OneToFifty, OneToFifty] of integer;
X
X  RecordPointer         = ^RecordType;
X
X  RecordType            =
X      record
X        PointerComp:   RecordPointer;
X        case Discr:    Enumeration of
X          Ident1:         (* only this variant is used,           *)
X                          (* but in some cases discriminant       *)
X                          (* checks are necessary                 *)
X            (EnumComp:      Enumeration;
X             IntComp:       OneToFifty;
X             StringComp:    String30);
X          Ident2:
X            (Enum2Comp:    Enumeration;
X             String2Comp:  String30);
X          Ident3, Ident4, Ident5:
X            (Char1Comp,
X             Char2Comp:    char);
X      end; (* record *)
X
Xvar
X
X  (* Ada version: Variables local in Proc_0 *)
X
X  Int1Glob,
X  Int2Glob,
X  Int3Glob:       OneToFifty;
X  CharIndex:      char;
X  EnumGlob:       Enumeration;
X  String1Glob,
X  String2Glob:    String30;
X
X  (* Ada version: Variables global in Pack_1 *)
X
X  PointerGlob,
X  NextPointerGlob: RecordPointer;
X  IntGlob:         integer;
X
X  BoolGlob:        boolean;
X  Char1Glob,
X  Char2Glob:       char;
X  Array1Glob:      Array1DimInteger;
X  Array2Glob:      Array2DimInteger;
X
X  (* Variables for measurement *)
X
X  RunIndex,
X  NumberOfRuns,
X  BeginClock,
X  EndClock,
X  SumClocks:            integer;
X  Microseconds,         
X  DhrystonesPerSecond:  real;
X  I:                    integer;
X
X  (* end of variables for measurement *)
X
Xprocedure Proc1 (    PointerParVal: RecordPointer);     forward;
X
Xprocedure Proc2 (var IntParRef:     OneToFifty);        forward;
X
Xprocedure Proc3 (var PointerParRef: RecordPointer);     forward;
X
Xprocedure Proc4;                                        forward;
X  (* without parameters *)
X
Xprocedure Proc5;                                        forward;
X  (* without parameters *)
X
Xprocedure Proc6 (    EnumParVal:    Enumeration;
X                 var EnumParRef:    Enumeration);       forward;
X
Xprocedure Proc7 (    Int1ParVal,
X                     Int2ParVal:    OneToFifty;
X                 var IntParRef:     OneToFifty);        forward;
X
Xprocedure Proc8 (var Array1ParRef:  Array1DimInteger;
X                 var Array2ParRef:  Array2DimInteger;
X                     Int1ParVal,
X                     Int2ParVal:    integer);            forward;
X
Xfunction Func1  (    Char1ParVal,
X                     Char2ParVal:   CapitalLetter): 
X                                            Enumeration; forward;
X
Xfunction Func2  (var String1ParRef,
X                     String2ParRef: String30): 
X                                            boolean;      forward;
X
Xfunction Func3  (    EnumParVal:    Enumeration): 
X                                            boolean;      forward;
X
X
Xprocedure Proc1; (* (PointerParVal: RecordPointer) *)
X    (* executed once *)
Xbegin
X  with PointerParVal^.PointerComp^ (* = PointerGlobNext *) do
X  begin
X    PointerParVal^.PointerComp^ := PointerGlob^;
X    PointerParVal^.IntComp := 5;
X    IntComp := PointerParVal^.IntComp;
X    PointerComp := PointerParVal^.PointerComp;
X    Proc3 (PointerComp);
X      (* PointerParVal^.PointerComp^.PointerComp = PointerGlob^.PointerComp *)
X    if Discr = Ident1
X    then (* executed *)
X    begin
X      IntComp := 6;
X      Proc6 (PointerParVal^.EnumComp, EnumComp);
X      PointerComp := PointerGlob^.PointerComp;
X      Proc7 (IntComp, 10, IntComp);
X    end (* then *)
X    else (* not executed *)
X      PointerParVal^ := PointerParVal^.PointerComp^;
X  end; (* with *)
Xend; (* Proc1 *)
X
X
Xprocedure Proc2; (* (var IntParRef: OneToFifty) *)
X    (* executed once *)
X    (* InParRef = 3, becomes 7 *)
Xvar
X  IntLoc:  OneToFifty;
X  EnumLoc: Enumeration;
Xbegin
X  IntLoc := IntParRef + 10;
X  repeat (* executed once *)
X    if Char1Glob = 'A'
X    then (* executed *)
X    begin
X      IntLoc := IntLoc - 1;
X      IntParRef := IntLoc - IntGlob;
X      EnumLoc := Ident1;
X    end (* if *)
X  until EnumLoc = Ident1; (* true *)
Xend; (* Proc2 *)
X
X
Xprocedure Proc3; (* (var PointerParRef: RecordPointer) *)
X    (* executed once *)
X    (* PointerParRef becomes PointerGlob *)
Xbegin
X  if PointerGlob <> nil
X  then (* executed *)
X    PointerParRef := PointerGlob^.PointerComp;
X  Proc7 (10, IntGlob, PointerGlob^.IntComp);
Xend; (* Proc3 *)
X
X
Xprocedure Proc4; (* without parameters *)
X    (* executed once *)
Xvar
X  BoolLoc: boolean;
Xbegin
X  BoolLoc := Char1Glob = 'A';
X  BoolGlob := BoolLoc or BoolGlob;
X  Char2Glob := 'B';
Xend; (* Proc4 *)
X
X
Xprocedure Proc5; (* without parameters *)
X    (* executed once *)
Xbegin
X  Char1Glob := 'A';
X  BoolGlob := false;
Xend; (* Proc5 *)
X
X
Xprocedure Proc6; (* (    EnumParVal:     Enumeration;
X                     var EnumParRef:     Enumeration) *)
X    (* executed once *)
X    (* EnumParVal = Ident3, EnumParRef becomes Ident2 *)
Xbegin
X  EnumParRef := EnumParVal;
X  if not Func3 (EnumParVal)
X  then (* not executed *)
X    EnumParRef := Ident4;
X  case EnumParVal of
X    Ident1: EnumParRef := Ident1;
X    Ident2: if IntGlob > 100
X              then EnumParRef := Ident1
X              else EnumParRef := Ident4;
X    Ident3: EnumParRef := Ident2;    (* executed *)
X    Ident4: ;
X    Ident5: EnumParRef := Ident3;
X  end; (* case *)
Xend; (* Proc6 *)
X
X
Xprocedure Proc7; (* (    Int1ParVal,
X                         Int2ParVal:    OneToFifty;
X                     var IntParRef:     OneToFifty) *)
X    (* executed three times                               *)
X    (* first call:      Int1ParVal = 2, Int2ParVal = 3,   *)
X    (*                  IntParRef becomes 7               *)
X    (* second call:     Int1ParVal = 10, Int2ParVal = 5,  *)
X    (*                  IntParRef becomes 17              *)
X    (* third call:      Int1ParVal = 6, Int2ParVal = 10,  *)
X    (*                  IntParRef becomes 18              *)
Xvar
X  IntLoc: OneToFifty;
Xbegin
X  IntLoc := Int1ParVal + 2;
X  IntParRef := Int2ParVal + IntLoc;
Xend; (* Proc7 *)
X
X
Xprocedure Proc8; (* (var Array1ParRef: Array1DimInteger;
X                     var Array2ParRef: Array2DimInteger;
X                         Int1ParVal,
X                         Int2ParVal:    integer)          *)
X    (* executed once  *)
X    (* Int1ParVal = 3 *)
X    (* Int2ParVal = 7 *)
Xvar
X  IntIndex,
X  IntLoc:   OneToFifty;
Xbegin
X  IntLoc := Int1ParVal + 5;
X  Array1ParRef [IntLoc] := Int2ParVal;
X  Array1ParRef [IntLoc+1] := Array1ParRef [IntLoc];
X  Array1ParRef [IntLoc+30] := IntLoc;
X  for IntIndex := IntLoc to IntLoc+1 do
X    Array2ParRef [IntLoc, IntIndex] := IntLoc;
X  Array2ParRef [IntLoc, IntLoc-1] := Array2ParRef [IntLoc, IntLoc-1] + 1;
X  Array2ParRef [IntLoc+20, IntLoc] := Array1ParRef [IntLoc];
X  IntGlob := 5;
Xend; (* Proc8 *)
X
X
Xfunction Func1; (* (Char1ParVal,
X                    Char2ParVal: CapitalLetter): Enumeration *)
X    (* executed three times, returns always Ident1              *)
X    (* first call:      Char1ParVal = 'H', Char2ParVal = 'R'    *)
X    (* second call:     Char1ParVal = 'A', Char2ParVal = 'C'    *)
X    (* third call:      Char1ParVal = 'B', Char2ParVal = 'C'    *)
Xvar
X  Char1Loc, Char2Loc: CapitalLetter;
Xbegin
X  Char1Loc := Char1ParVal;
X  Char2Loc := Char1Loc;
X  if Char2Loc <> Char2ParVal
X  then  (* executed *)
X    Func1 := Ident1
X  else  (* not executed *)
X  begin
X    Char1Glob := Char1Loc;
X    Func1 := Ident2;
X  end;
Xend; (* Func1 *)
X
X
Xfunction Func2; (* (var String1ParRef,
X                        String2ParRef: String30): boolean *)
X    (* executed once, returns false              *)
X    (* String1ParRef = 'DHRYSTONE PROGRAM, 1''ST STRING' *)
X    (* String2ParRef = 'DHRYSTONE PROGRAM, 2''ND STRING' *)
Xvar
X  IntLoc:  OneToThirty;
X  CharLoc: CapitalLetter;
Xbegin
X  IntLoc := 2;
X  while IntLoc <= 2 do (* loop body executed once *)
X    if Func1 (String1ParRef[IntLoc],
X              String2ParRef[IntLoc+1]) = Ident1
X    then (* executed *)
X    begin
X      CharLoc := 'A';
X      IntLoc := IntLoc + 1;
X    end; (* if, while *)
X  if (CharLoc >= 'W') and (CharLoc < 'Z')
X  then (* not executed *)
X    IntLoc := 7;
X  if CharLoc = 'R'
X  then (* not executed *)
X    Func2 := true
X  else (* executed *)
X  begin
X    if String1ParRef > String2ParRef
X    then (* not executed *)
X    begin
X      IntLoc := IntLoc + 7;
X      IntGlob := IntLoc;
X      Func2 := true
X    end
X    else (* executed *)
X      Func2 := false;
X  end; (* if CharLoc *)
Xend; (* Func2 *)
X
X
Xfunction Func3; (* (EnumParVal: Enumeration): boolean *)
X    (* executed once, returns true      *)
X    (* EnumParVal = Ident3              *)
Xvar
X  EnumLoc:  Enumeration;
Xbegin
X  EnumLoc := EnumParVal;
X  if EnumLoc = Ident3
X  then (* executed *)
X    Func3 := true
X  else (* not executed *)
X    Func3 := false;
Xend; (* Func3 *)
X
X
Xbegin (* main program, corresponds to procedures        *)
X      (* Main and Proc_0 in the Ada version             *)
X
X  (* Initializations *)
X
X  new (NextPointerGlob);
X
X  new (PointerGlob);
X
X  PointerGlob^.PointerComp := NextPointerGlob;
X  PointerGlob^.Discr       := Ident1;
X  PointerGlob^.EnumComp    := Ident3;
X  PointerGlob^.IntComp     := 40;
X  PointerGlob^.StringComp  := 'DHRYSTONE PROGRAM, SOME STRING';
X
X  String1Glob := 'DHRYSTONE PROGRAM, 1''ST STRING';
X
X  Array2Glob [8,7] := 10;
X
X  writeln;
X  writeln ('Dhrystone Benchmark, Version 2.1 (Language: Pascal)');
X  writeln;
X  writeln ('Please give the number of runs through the benchmark: ');
X  readln (NumberOfRuns);
X  writeln;
X  writeln ('Execution starts, ', NumberOfRuns : 7, ' runs through Dhrystone');
X
X  BeginClock := clock;
X
X  (***************)
X  (* Start timer *)
X  (***************)
X  
X  for RunIndex := 1 to NumberOfRuns do
X  begin
X
X    Proc5;
X    Proc4;
X      (* Char1Glob = 'A', Char2Glob = 'B', BoolGlob = false *)
X    Int1Glob := 2;
X    Int2Glob := 3;
X    String2Glob := 'DHRYSTONE PROGRAM, 2''ND STRING';
X    EnumGlob := Ident2;
X    BoolGlob := not Func2 (String1Glob, String2Glob);
X      (* BoolGlob = true *)
X    while Int1Glob < Int2Glob do  (* loop body executed once *)
X    begin
X      Int3Glob := 5 * Int1Glob - Int2Glob;
X        (* Int3Glob = 7 *)
X      Proc7 (Int1Glob, Int2Glob, Int3Glob);
X        (* Int3Glob = 7 *)
X      Int1Glob := Int1Glob + 1;
X    end; (* while *)
X      (* Int1Glob = 3 *)
X    Proc8 (Array1Glob, Array2Glob, Int1Glob, Int3Glob);
X      (* IntGlob = 5 *)
X    Proc1 (PointerGlob);
X    for CharIndex := 'A' to Char2Glob do   (* loop body executed twice *)
X      if EnumGlob = Func1 (CharIndex, 'C')
X        then (* not executed *)
X        begin
X          Proc6 (Ident1, EnumGlob);
X          String2Glob := 'DHRYSTONE PROGRAM, 3''RD STRING';
X          Int2Glob := RunIndex;
X          IntGlob := RunIndex;
X        end;
X    (* Int1Glob = 3, Int2Glob = 3, Int3Glob = 7 *)
X    Int2Glob := Int2Glob * Int1Glob;
X    Int1Glob := Int2Glob div Int3Glob;
X    Int2Glob := 7 * (Int2Glob - Int3Glob) - Int1Glob;
X      (* Int1Glob = 1, Int2Glob = 13, Int3Glob = 7 *)
X    Proc2 (Int1Glob);
X      (* Int1Glob = 5 *)
X
X  end; (* for RunIndex *)
X
X  EndClock := clock;
X
X  (**************)
X  (* Stop timer *)
X  (**************)
X
X  writeln ('Execution ends');
X  writeln;
X  writeln ('Final values of the variables used in the benchmark:');
X  writeln;
X
X  writeln ('IntGlob:                      ', IntGlob : 5);
X  writeln ('        should be:                5');
X  write ('BoolGlob:                      ');
X  if BoolGlob = true
X  then
X    writeln ('TRUE')
X  else
X    writeln ('FALSE');
X  writeln ('        should be:             TRUE');
X  writeln ('Char1Glob:                        ', Char1Glob);
X  writeln ('        should be:                A');
X  writeln ('Char2Glob:                        ', Char2Glob);
X  writeln ('        should be:                B');
X  writeln ('Array1Glob [8]:               ', Array1Glob [8] : 5);
X  writeln ('        should be:                7');
X  writeln ('Array2Glob [8,7]:             ', Array2Glob [8,7] : 5);
X  writeln ('        should be:                NumberOfRuns + 10');
X  writeln ('PointerGlob^.Discr:           ', ord (PointerGlob^.Discr) : 5);
X  writeln ('        should be:                0');
X  writeln ('PointerGlob^.EnumComp:        ', ord (PointerGlob^.EnumComp) : 5);
X  writeln ('        should be:                2');
X  writeln ('PointerGlob^.IntComp  :       ', PointerGlob^.IntComp : 5);
X  writeln ('        should be:               17');
X  write   ('PointerGlob^.StringComp:     ');
X  for I := 1 to 30 do
X    write (PointerGlob^.StringComp [I]);
X  writeln;
X  writeln ('        should be:           DHRYSTONE PROGRAM, SOME STRING');
X  writeln ('NextPointerGlob^.Discr:       ', ord (NextPointerGlob^.Discr) : 5);
X  writeln ('        should be:                0');
X  writeln ('NextPointerGlob^.EnumComp:    ',
X                    ord (NextPointerGlob^.EnumComp) : 5);
X  writeln ('        should be:                1');
X  writeln ('NextPointerGlob^.IntComp:     ', NextPointerGlob^.IntComp : 5);
X  writeln ('        should be:               18');
X  write   ('NextPointerGlob^.StringComp: ');
X  for I := 1 to 30 do
X    write (NextPointerGlob^.StringComp [I]);
X  writeln;
X  writeln ('        should be:           DHRYSTONE PROGRAM, SOME STRING');
X  writeln ('Int1Glob:                     ', Int1Glob : 5);
X  writeln ('        should be:                5');
X  writeln ('Int2Glob:                     ', Int2Glob : 5);
X  writeln ('        should be:               13');
X  writeln ('Int3Glob:                     ', Int3Glob : 5);
X  writeln ('        should be:                7');
X  writeln ('EnumGlob:                     ', ord (EnumGlob) : 5);
X  writeln ('        should be:                1');
X  write   ('String1Glob:                 ');
X  for I := 1 to 30 do
X    write (String1Glob [I]);
X  writeln;
X  writeln ('        should be:           DHRYSTONE PROGRAM, 1''ST STRING');
X  write   ('String2Glob:                 ');
X  for I := 1 to 30 do
X    write (String2Glob [I]);
X  writeln;
X  writeln ('        should be:           DHRYSTONE PROGRAM, 2''ND STRING');
X  writeln;
X  writeln;
X
X  SumClocks := EndClock - BeginClock;
X
X  if SumClocks < TooSmallTime
X    then
X    begin
X      writeln ('Measured time too small to obtain meaningful results');
X      writeln ('Please increase number of runs');
X      writeln;
X    end
X    else
X    begin
X      Microseconds := SumClocks * (MicrosecondsPerClock / NumberOfRuns);
X                                (* Brackets to prevent integer overflow *)
X      DhrystonesPerSecond := NumberOfRuns * (ClocksPerSecond / SumClocks);
X      write ('Microseconds for one run through Dhrystone: ');
X      writeln (Microseconds : 8 : 1);
X      write ('Dhrystones per Second:                      ');
X      writeln (DhrystonesPerSecond : 8 : 1);
X      writeln;
X    end;
X  
Xend.
SHAR_EOF
fi
exit 0
#	End of shell archive