


                   VHDL Benchmark Test Objectives



INTRODUCTION

This document outlines the test objectives and corresponding test file
names for those tests comprising the "benchmark" portion of the test
suite.  These tests were provided by Wright Research and Development Center
at Wright-Patterson AFB, and are intended to be stress/capacity tests for
VHDL tool sets.

Each benchmark test is designed to test one or more specified features of
the language in terms of system architecture/operating system/VHDL toolset
limitations.  These limitations include amount of  memory and CPU time
required for analyzing, model generating, building, and simulating a model.
Most tests have one or more parameters that can be varied to observe their
effect on timing and memory usage.  Although the tests are referred to as a
benchmark suite, they differ from the computer science definition of benchmarks
in that they are designed to explore the robustness of a system's architecture,
operating system, and VHDL environment, not to try to equalize these factors
before comparing results between systems.  They attempt to test limitations of
VHDL features of interest to design engineers.

VHDL vendors each have their own set of validation tests to use on their
product, but no standard suite exists for comparing capabilities and
limitations between toolsets.  This VHDL Benchmark Suite is an attempt to
provide a standard set of tests and make it available to vendors and users.

Test objectives are numbered sequentially from 1 to 320 and consist an
objective description and a pathname to the "shell" representing the
corresponding test.

The test files are organized into subdirectories by the VHDL features they 
test.  Each feature category has its own subdirectory.  The file "bench_matrix"
in the document directory lists all the feature categories in column format, 
along with each test number in row format.  The categories tested in each 
benchmark are then "X"-ed off in the appropriate column and rows.  


TEST OBJECTIVES


TEST NUMBER :  1

PATHNAME :  [.BENCH.A.C.F3.I1]shell0.sh, shell1.sh
            (UNIX equivalent : bench/a/c/f3/i1/shell0.sh, shell1.sh)

PURPOSE :  Determine the number of signals allowed in the generic clause of
           a component; determine the number of such components allowed in
           an architecture with a recursive function in its entity declaration.



TEST NUMBER : 2

PATHNAME :  [.BENCH.A.C.F3.I2]shell0.sh, shell1.sh
            (UNIX equivalent : bench/a/c/f3/i2/shell0.sh, shell1.sh)

PURPOSE :  Determine the number of signals allowed in the generic clause of
           a component; determine the number of such components allowed in
           an architecture with a recursive function in its architecture body.



TEST NUMBER :  3

PATHNAME :  [.BENCH.A.C.D]shell.sh
            (UNIX equivalent : bench/a/c/d/shell.sh)

PURPOSE :  Determine the maximum number of blocks allowed in an architecture;
           determine the maximum number of signal declarations/signal 
           assignment statements allowed per block; determine the CPU time
           required per block for analysis, model generation, build, and
           simulation.



TEST NUMBER :  4

PATHNAME :  [.BENCH.A.C.D.G4]shell.sh
            (UNIX equivalent : bench/a/c/d/g4/shell.sh)

PURPOSE :  Determine the maximum number of blocks allowed in an architecture;
           determine the maximum number of signal declarations/signal 
           assignment statements/assertions (one per signal) allowed per block; 
           determine the CPU time required per block for analysis, model 
           generation, build, and simulation.



TEST NUMBER :  5

PATHNAME :  [.BENCH.B.C.K.L1.M]shell.sh
            (UNIX equivalent : bench/b/c/k/l1/m/shell.sh)

PURPOSE :  Determine the effect on simulation CPU time when the following 
           factors are varied in an architecture consisting of a number of 
           processes and the same number of bit_vector signal declarations; 
           each process consists of a variable declaration of a bit_vector the
           same size as the signals above, a signal assignment statement, and 
           an if-then-else construct with for-loops in the 'if' and 'else' 
           sections; the number of iterations of each for-loop is equal to the 
           size of the bit_vectors, and a variable assignment is made at each 
           iteration :  number of processes/number of bit_vector signal 
           declarations, bit_vector size of the signals, and length of time 
           (in ns) to simulate the model.



TEST NUMBER :  6

PATHNAME :  [.BENCH.B.C.K.M]shell.sh
            (UNIX equivalent : bench/b/c/k/m/shell.sh)

PURPOSE :  Determine the effect on simulation CPU time when the following 
           factors are varied in an architecture consisting of a number of 
           processes and the same number of bit_vector signal declarations; 
           each process consists of a variable declaration of a bit_vector the
           same size as the signals above and an if-then-else construct with 
           a signal assignment statement in the 'if' section and a for-loop in 
           the 'else' section; the number of iterations of the for-loop is 
           equal to the size of the bit_vectors, and a variable assignment is 
           made at each iteration :  number of processes/number of bit_vector 
           signal declarations, bit_vector size of the signals, and length of 
           time (in ns) to simulate the model.



TEST NUMBER :  7

PATHNAME :  [.BENCH.A.C]shell.sh
            (UNIX equivalent : bench/a/c/shell.sh)

PURPOSE :  Determine the maximum number of signal declarations/signal assignment
           statements allowed in an architecture;  determine the CPU time 
           required for simulating the model, varying the time before reaching
           a quiescent state inside the description; determine the CPU time
           required per signal for analysis, model generation, build, and 
           simulation.



TEST NUMBER :  8

PATHNAME :  [.BENCH.B.K.M]shell.sh
            (UNIX equivalent : bench/b/k/m/shell.sh)

PURPOSE :  Determine the effect on simulation CPU time when the following 
           factors are varied in an architecture consisting of one bit_vector
           signal declaration and a number of processes equal to the bit_vector
           size of the signal;  each process consists of an if-then-else
           construct, where the 'if' and 'else' sections each contain a signal
           assignment statement : bit_vector size/number of processes and length
           of time (in ns) to simulate model.



TEST NUMBER :  9

PATHNAME :  [.BENCH.B.G6.H3.I3.M.Q]shell.sh
            (UNIX equivalent : bench/b/g6/h3/i3/m/q/shell.sh)

PURPOSE :  Determine the effect on CPU time when analyzing, model generating,
           building, and simulating the following model :  an architecture
           consisting of a number of unaliased signal declarations, a number
           of aliased signal declarations, and three types of processes.  The 
           first type of process has two signal assignment statements.  The
           architecture contains one of this type, and a number of the other 
           two types of processes.  The second process type has three variable 
           declarations, a procedure declaration, an if-then-else statement 
           where the "if" and "else" sections each have two variable assignment 
           statements, a procedure call, and an aliased signal assignment 
           statement.  The procedure consists of one variable declaration, a 
           function declaration, a function call via a variable assignment 
           statement, and an if-then-else statement, where the "if" and "else" 
           sections each have a function call via a variable assignment 
           statement.  The function has one variable declaration, an if-then-
           else statement, where the "if" and "else" sections each have two 
           variable assignment statements, a return statement, and an assert
           statement.  The third process type has three variable declarations, a
           procedure declaration, an if-then-else statement, where the "if" and
           "else" sections each have a variable assignment statement, a 
           procedure call, and an unaliased signal assignment statement.  The
           procedure is identical to the one in the second type of process.  
           The function is identical to the one in the second type of process, 
           except it has one assert statement instead of two.  The factors to 
           be varied are the number of unaliased signal declarations/number of
           type two processes, the number of aliased signal declarations/number 
           of type three processes, and the length of time (in ns) to simulate
           the model.



TEST NUMBER :  10

PATHNAME :  [.BENCH.A.C.U]shell.sh
            (UNIX equivalent : bench/a/c/u/shell.sh)

PURPOSE :  Determine the maximum number of values allowed in a waveform of a 
           signal assignment statement; determine the CPU time required for 
           analysis, model generation, build, and simulation of the model.



TEST NUMBER :  11

PATHNAME :  [.BENCH.A.C.H2.L1.M.S2]shell.sh
            (UNIX equivalent : bench/a/c/h2/l1/m/s2/shell.sh)

PURPOSE :  Determine the simulation CPU time required to write characters to
           an output file.  The model simulated is an architecture 
           consisting of a procedure declaration and a procedure call.  The 
           procedure consists of a for-loop containing a write statement
           (one character) and an if-then construct containing a write
           statement (one character).  The factor to be varied is the number
           of characters to write to the file during one simulation.



TEST NUMBER :  12

PATHNAME :  [.BENCH.B.C.S2]shell.sh
            (UNIX equivalent : bench/b/c/s2/shell.sh)

PURPOSE :  Determine the simulation CPU time required for writing characters
           to an output file.  The model simulated is an architecture consisting
           of a process containing a number of write character/write linefeed
           combinations.  The factor to be varied is the number of write
           character/write linefeed pairs.



TEST NUMBER :  13

PATHNAME :  [.BENCH.A.C.H2.L3.S2]shell.sh
            (UNIX equivalent : bench/a/c/h2/l3/s2/shell.sh)

PURPOSE :  Determine the simulation CPU time required to write characters to
           an output file.  The model simulated is an architecture consisting of
           a procedure declaration and a procedure call.  The procedure consists
           of a while-loop construct, where a write character/write linefeed
           combination is executed at each iteration.  The factor to be varied
           is the number of iterations the while-loop will be executed.



TEST NUMBER :  14

PATHNAME :  [.BENCH.A.C.H2.S2]shell.sh
            (UNIX equivalent : bench/a/c/h2/s2/shell.sh)

PURPOSE :  Determine the simulation CPU time required to write characters
           to an output file.  The model simulated is an architecture consisting
           of a procedure declaration and a procedure call.  The procedure
           consists of a number of write character/write linefeed combinations.
           The factor to be varied is the number of write character/write
           linefeed pairs in the procedure.



TEST NUMBER :  15

PATHNAME :  [.BENCH.A.C.H2R.M.S2]shell.sh
            (UNIX equivalent : bench/a/c/h2r/m/s2/shell.sh)

PURPOSE :  Determine the simulation CPU time required for writing characters
           to an output file.  The model simulated is an architecture consisting
           of a procedure declaration and a procedure call.  The procedure
           consists of a write character/write linefeed combination and a
           recursive call to itself.  The factor to be varied is the number of 
           times the procedure will recursively call itself.



TEST NUMBER :  16

PATHNAME :  [.BENCH.B.P1]shell0.sh
            (UNIX equivalent : bench/b/p1/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           addition statements.  The model simulated is an architecture
           consisting of a process.  The process contains a number of
           integer variable declarations and an addition statement for each
           variable.  The factor to be varied is the number of variable
           declarations/addition statements in the process.



TEST NUMBER :  17

PATHNAME :  [.BENCH.A.C.H2.P1]shell0.sh
            (UNIX equivalent : bench/a/c/h2/p1/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           addition statements.  The model simulated is an architecture
           consisting of a procedure declaration and a procedure call.  The 
           procedure consists of a number of integer variable declarations
           and an addition statement for each variable.  The factor to be varied
           is the number of variable declarations/addition statements in the
           procedure.



TEST NUMBER :  18

PATHNAME :  [.BENCH.A.C.I2.P1]shell0.sh
            (UNIX equivalent : bench/a/c/i2/p1/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           addition statements.  The model simulated is an architecture
           consisting of a function declaration and a function call.  The 
           function consists of a number of integer variable declarations
           and an addition statement for each variable.  The factor to be varied
           is the number of variable declarations/addition statements in the
           function.



TEST NUMBER :  19

PATHNAME :  [.BENCH.A.C.I2.P2]shell0.sh
            (UNIX equivalent : bench/a/c/i2/p2/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           subtraction statements.  The model simulated is an architecture
           consisting of a function declaration and a function call.  The 
           function consists of a number of integer variable declarations
           and a subtraction statement for each variable.  The factor to be 
           varied is the number of variable declarations/subtraction statements 
           in the function.



TEST NUMBER :  20

PATHNAME :  [.BENCH.A.C.H2.P2]shell0.sh
            (UNIX equivalent : bench/a/c/h2/p2/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           subtraction statements.  The model simulated is an architecture
           consisting of a procedure declaration and a procedure call.  The 
           procedure consists of a number of integer variable declarations
           and a subtraction statement for each variable.  The factor to be 
           varied is the number of variable declarations/subtraction statements 
           in the procedure.



TEST NUMBER :  21

PATHNAME :  [.BENCH.B.P2]shell0.sh
            (UNIX equivalent : bench/b/p2/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           subtraction statements.  The model simulated is an architecture
           consisting of a process.  The process contains a number of
           integer variable declarations and a subtraction statement for each
           variable.  The factor to be varied is the number of variable
           declarations/subtraction statements in the process.



TEST NUMBER :  22

PATHNAME :  [.BENCH.B.P3]shell0.sh
            (UNIX equivalent : bench/b/p3/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           multiplication statements.  The model simulated is an architecture
           consisting of a process.  The process contains a number of
           integer variable declarations and a multiplication statement for 
           each variable.  The factor to be varied is the number of variable
           declarations/multiplication statements in the process.



TEST NUMBER :  23

PATHNAME :  [.BENCH.A.C.H2.P3]shell0.sh
            (UNIX equivalent : bench/a/c/h2/p3/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           multiplication statements.  The model simulated is an architecture
           consisting of a procedure declaration and a procedure call.  The 
           procedure consists of a number of integer variable declarations
           and a multiplication statement for each variable.  The factor to be 
           varied is the number of variable declarations/multiplication 
           statements in the procedure.



TEST NUMBER :  24

PATHNAME :  [.BENCH.A.C.I2.P3]shell0.sh
            (UNIX equivalent : bench/a/c/i2/p3/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           multiplication statements.  The model simulated is an architecture
           consisting of a function declaration and a function call.  The 
           function consists of a number of integer variable declarations
           and a multiplication statement for each variable.  The factor to be 
           varied is the number of variable declarations/multiplication 
           statements in the function.



TEST NUMBER :  25

PATHNAME :  [.BENCH.B.P4]shell0.sh
            (UNIX equivalent : bench/b/p4/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           division statements.  The model simulated is an architecture
           consisting of a process.  The process contains a number of
           integer variable declarations and a division statement for 
           each variable.  The factor to be varied is the number of variable
           declarations/division statements in the process.



TEST NUMBER :  26

PATHNAME :  [.BENCH.A.C.H2.P4]shell0.sh
            (UNIX equivalent : bench/a/c/h2/p4/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           division statements.  The model simulated is an architecture
           consisting of a procedure declaration and a procedure call.  The 
           procedure consists of a number of integer variable declarations
           and a division statement for each variable.  The factor to be 
           varied is the number of variable declarations/division 
           statements in the procedure.



TEST NUMBER :  27

PATHNAME :  [.BENCH.A.C.I2.P4]shell0.sh
            (UNIX equivalent : bench/a/c/i2/p4/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           division statements.  The model simulated is an architecture
           consisting of a function declaration and a function call.  The 
           function consists of a number of integer variable declarations
           and a division statement for each variable.  The factor to be 
           varied is the number of variable declarations/division 
           statements in the function.



TEST NUMBER :  28

PATHNAME :  [.BENCH.B.C.K.L1.P6]shell0.sh
            (UNIX equivalent : bench/b/c/k/l1/p6/shell0.sh)

PURPOSE :  Determine the effect on simulation CPU time when the following
           factors are varied in an architecture consisting of a number of
           processes; each process consists of a variable bit_vector
           declaration and a for-loop; the for-loop contains a logical AND
           statement, and the number of iterations of the loop is equal to
           the size of the variable bit_vector : number of processes, bit_vector
           size/number of iterations of for-loop.



TEST NUMBER :  29

PATHNAME :  [.BENCH.A.C.P6]shell0.sh
            (UNIX equivalent : bench/a/c/p6/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical AND
           operations on signals.  The model simulated consists of a number of
           signal declarations and one logical AND signal assignment statement
           for each signal.  The factor to be varied is the number of signal
           declarations/number of logical AND signal assignment statements.



TEST NUMBER :  30

PATHNAME :  [.BENCH.B.C.P6]shell0.sh
            (UNIX equivalent : bench/b/c/p6/shell0.sh)

PURPOSE :  Determine the simulation CPU time required for executing logical
           AND operations on variables.  The model simulated is an architecture
           consisting of a number of processes; each process consists of a 
           number of variable declarations and one logical AND variable 
           assignment statement for each variable.  The factors to be varied
           are the number of processes and the number of variable declarations/
           number of logical AND variable assignment statements.



TEST NUMBER :  31

PATHNAME :  [.BENCH.B.P1]shell1.sh
            (UNIX equivalent : bench/b/p1/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to perform addition
           operations on a variable; determine the number of addition 
           operations allowed in one variable assignment statement.  The model 
           simulated is an architecture consisting of a process.  The process 
           consists of an integer variable declaration and a variable 
           assignment statement containing a number of addition operations.  
           The factor to be varied is the number of addition operations 
           contained in the variable assignment statement.



TEST NUMBER :  32

PATHNAME :  [.BENCH.B.P2]shell1.sh
            (UNIX equivalent : bench/b/p2/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to perform subtraction
           operations on a variable; determine the number of subtraction
           operations allowed in one variable assignment statement.  The model 
           simulated is an architecture consisting of a process.  The process 
           consists of an integer variable declaration and a variable 
           assignment statement containing a number of subtraction operations.  
           The factor to be varied is the number of subtraction operations 
           contained in the variable assignment statement.



TEST NUMBER :  33

PATHNAME :  [.BENCH.B.P3]shell1.sh
            (UNIX equivalent : bench/b/p3/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to perform multiplication
           operations on a variable; determine the number of multiplication
           operations allowed in one variable assignment statement.  The model 
           simulated is an architecture consisting of a process.  The process 
           consists of an integer variable declaration and a variable 
           assignment statement containing a number of multiplication 
           operations.  The factor to be varied is the number of 
           multiplication operations contained in the variable assignment 
           statement.



TEST NUMBER :  34

PATHNAME :  [.BENCH.B.P4]shell1.sh
            (UNIX equivalent : bench/b/p4/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to perform division
           operations on a variable; determine the number of division
           operations allowed in one variable assignment statement.  The model 
           simulated is an architecture consisting of a process.  The process 
           consists of an integer variable declaration and a variable 
           assignment statement containing a number of division operations.  
           The factor to be varied is the number of division operations 
           contained in the variable assignment statement.



TEST NUMBER :  35

PATHNAME :  [.BENCH.A.C.P1]shell0.sh
            (UNIX equivalent : bench/a/c/p1/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition
           operations on signals.  The model simulated consists of a number of
           signal declarations and one addition signal assignment statement
           for each signal.  The factor to be varied is the number of signal
           declarations/number of addition signal assignment statements.



TEST NUMBER :  36

PATHNAME :  [.BENCH.A.C.P1]shell1.sh
            (UNIX equivalent : bench/a/c/p1/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to perform addition
           operations on a signal; determine the number of addition operations
           allowed in one signal assignment statement.  The model simulated is 
           an architecture consisting of an integer signal declaration and a 
           signal assignment statement containing a number of addition 
           operations.  The factor to be varied is the number of addition 
           operations contained in the signal assignment statement.



TEST NUMBER :  37

PATHNAME :  [.BENCH.A.C.P2]shell0.sh
            (UNIX equivalent : bench/a/c/p2/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute subtraction
           operations on signals.  The model simulated consists of a number of
           signal declarations and one subtraction signal assignment statement
           for each signal.  The factor to be varied is the number of signal
           declarations/number of subtraction signal assignment statements.



TEST NUMBER :  38

PATHNAME :  [.BENCH.A.C.P2]shell1.sh
            (UNIX equivalent : bench/a/c/p2/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to perform subtraction
           operations on a signal; determine the number of subtraction
           operations allowed in one signal assignment statement.  The model 
           simulated is an architecture consisting of an integer signal 
           declaration and a signal assignment statement containing a number of 
           subtraction operations.  The factor to be varied is the number of 
           subtraction operations contained in the signal assignment statement.



TEST NUMBER :  39

PATHNAME :  [.BENCH.A.C.P3]shell0.sh
            (UNIX equivalent : bench/a/c/p3/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute multiplication
           operations on signals.  The model simulated consists of a number of
           signal declarations and one multiplication signal assignment 
           statement for each signal.  The factor to be varied is the number of 
           signal declarations/number of multiplication signal assignment 
           statements.



TEST NUMBER :  40

PATHNAME :  [.BENCH.A.C.P3]shell1.sh
            (UNIX equivalent : bench/a/c/p3/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to perform multiplication
           operations on a signal; determine the number of multiplication
           statements allowed in one signal assignment statement.  The model 
           simulated is an architecture consisting of an integer signal 
           declaration and a signal assignment statement containing a number of 
           multiplication operations.  The factor to be varied is the number of 
           multiplication operations contained in the signal assignment
           statement.



TEST NUMBER :  41

PATHNAME :  [.BENCH.A.C.P4]shell0.sh
            (UNIX equivalent : bench/a/c/p4/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute division
           operations on signals.  The model simulated consists of a number of
           signal declarations and one division signal assignment statement for 
           each signal.  The factor to be varied is the number of signal 
           declarations/number of division signal assignment statements.



TEST NUMBER :  42

PATHNAME :  [.BENCH.A.C.P4]shell1.sh
            (UNIX equivalent : bench/a/c/p4/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to perform division
           operations on a signal; determine the number of division operations 
           allowed in one signal assignment statement.  The model simulated is 
           an architecture consisting of an integer signal declaration and a 
           signal assignment statement containing a number of division 
           operations.  The factor to be varied is the number of division 
           operations contained in the signal assignment statement.



TEST NUMBER :  43

PATHNAME :  [.BENCH.A.C.P6]shell1.sh
            (UNIX equivalent : bench/a/c/p6/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to perform logical AND
           operations on a signal; determine the number  of logical AND
           operations allowed in one signal assignment statement.  The model 
           simulated is an architecture consisting of a signal declaration and 
           a signal assignment statement containing a number of logical AND 
           operations.  The factor to be varied is the number of logical AND 
           operations contained in the signal assignment statement.



TEST NUMBER :  44

PATHNAME :  [.BENCH.B.C.P6]shell1.sh
            (UNIX equivalent : bench/b/c/p6/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical AND
           operations on variables;  determine the number of logical AND
           operations allowed in one variable assignment statement.  The model 
           simulated is an architecture consisting of a number of processes; 
           each process consists of a variable declaration and a variable 
           assignment statement containing a number of logical AND operations.  
           The factors to be varied are the number of processes and the number 
           of logical AND operations in the variable assignment statement.



TEST NUMBER :  45

PATHNAME :  [.BENCH.A.C.I2.P4]shell1.sh
            (UNIX equivalent : bench/a/c/i2/p4/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           division operations in a function; determine the number of division
           operations allowed in one variable assignment statement of a 
           function.  The model simulated is an architecture consisting of a
           function declaration and a function call; the function consists of
           an integer variable declaration and a variable assignment statement
           containing a number of addition operations.  The factor to be varied 
           is the number of division operations contained in the variable 
           assignment statement.



TEST NUMBER :  46

PATHNAME :  [.BENCH.A.C.H2.P4]shell1.sh
            (UNIX equivalent : bench/a/c/h2/p4/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           division operations in a procedure; determine the number of division
           operations allowed in one variable assignment statement of a 
           procedure.  The model simulated is an architecture consisting of a
           procedure declaration and a procedure call; the procedure consists of
           an integer variable declaration and a variable assignment statement
           containing a number of addition operations.  The factor to be varied 
           is the number of division operations contained in the variable 
           assignment statement.



TEST NUMBER :  47

PATHNAME :  [.BENCH.A.C.I2.P3]shell1.sh
            (UNIX equivalent : bench/a/c/i2/p3/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           multiplication operations in a function; determine the number of 
           multiplication operations allowed in one variable assignment 
           statement of a function.  The model simulated is an architecture 
           consisting of a function declaration and a function call; the 
           function consists of an integer variable declaration and a variable 
           assignment statement containing a number of addition operations.  
           The factor to be varied is the number of multiplication operations 
           contained in the variable assignment statement.



TEST NUMBER :  48

PATHNAME :  [.BENCH.A.C.H2.P3]shell1.sh
            (UNIX equivalent : bench/a/c/h2/p3/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           multiplication operations in a procedure; determine the number of 
           multiplication operations allowed in one variable assignment 
           statement of a procedure.  The model simulated is an architecture 
           consisting of a procedure declaration and a procedure call; the 
           procedure consists of an integer variable declaration and a variable 
           assignment statement containing a number of addition operations.  
           The factor to be varied is the number of multiplication operations 
           contained in the variable assignment statement.



TEST NUMBER :  49

PATHNAME :  [.BENCH.A.C.H2.P2]shell1.sh
            (UNIX equivalent : bench/a/c/h2/p2/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           subtraction operations in a procedure; determine the number of 
           subtraction operations allowed in one variable assignment 
           statement of a procedure.  The model simulated is an architecture 
           consisting of a procedure declaration and a procedure call; the 
           procedure consists of an integer variable declaration and a variable 
           assignment statement containing a number of addition operations.  
           The factor to be varied is the number of subtraction operations 
           contained in the variable assignment statement.



TEST NUMBER :  50

PATHNAME :  [.BENCH.A.C.I2.P2]shell1.sh
            (UNIX equivalent : bench/a/c/i2/p2/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           subtraction operations in a function; determine the number of 
           subtraction operations allowed in one variable assignment 
           statement of a function.  The model simulated is an architecture 
           consisting of a function declaration and a function call; the 
           function consists of an integer variable declaration and a variable 
           assignment statement containing a number of addition operations.  
           The factor to be varied is the number of subtraction operations 
           contained in the variable assignment statement.



TEST NUMBER :  51

PATHNAME :  [.BENCH.A.C.I2.P1]shell1.sh
            (UNIX equivalent : bench/a/c/i2/p1/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           addition operations in a function; determine the number of 
           addition operations allowed in one variable assignment 
           statement of a function.  The model simulated is an architecture 
           consisting of a function declaration and a function call; the 
           function consists of an integer variable declaration and a variable 
           assignment statement containing a number of addition operations.  
           The factor to be varied is the number of addition operations 
           contained in the variable assignment statement.



TEST NUMBER :  52

PATHNAME :  [.BENCH.A.C.H2.P1]shell1.sh
            (UNIX equivalent : bench/a/c/h2/p1/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           addition operations in a procedure; determine the number of 
           addition operations allowed in one variable assignment statement of 
           a procedure.  The model simulated is an architecture consisting of a 
           procedure declaration and a procedure call; the procedure consists 
           of an integer variable declaration and a variable assignment 
           statement containing a number of addition operations.  The factor to 
           be varied is the number of addition operations contained in the 
           variable assignment statement.



TEST NUMBER :  53

PATHNAME :  [.BENCH.B.C.P7]shell0.sh
            (UNIX equivalent : bench/b/c/p7/shell0.sh)

PURPOSE :  Determine the simulation CPU time required for executing logical
           OR operations on variables.  The model simulated is an architecture
           consisting of a number of processes; each process consists of a 
           number of variable declarations and one logical OR variable 
           assignment statement for each variable.  The factors to be varied
           are the number of processes and the number of variable declarations/
           number of logical OR variable assignment statements.



TEST NUMBER :  54

PATHNAME :  [.BENCH.B.C.K.L1.P7]shell0.sh
            (UNIX equivalent : bench/b/c/k/l1/p7/shell0.sh)

PURPOSE :  Determine the effect on simulation CPU time when the following
           factors are varied in an architecture consisting of a number of
           processes; each process consists of a variable bit_vector
           declaration and a for-loop; the for-loop contains a logical OR
           statement, and the number of iterations of the loop is equal to
           the size of the variable bit_vector : number of processes, bit_vector
           size/number of iterations of for-loop.



TEST NUMBER :  55

PATHNAME :  [.BENCH.A.C.P7]shell0.sh
            (UNIX equivalent : bench/a/c/p7/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical OR
           operations on signals.  The model simulated consists of a number of
           signal declarations and one logical OR signal assignment statement
           for each signal.  The factor to be varied is the number of signal
           declarations/number of logical OR signal assignment statements.



TEST NUMBER :  56

PATHNAME :  [.BENCH.A.C.P7]shell1.sh
            (UNIX equivalent : bench/a/c/p7/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to perform logical OR
           operations on a signal; determine the number  of logical OR
           operations allowed in one signal assignment statement.  The model 
           simulated is an architecture consisting of a signal declaration and 
           a signal assignment statement containing a number of logical OR 
           operations.  The factor to be varied is the number of logical OR 
           operations contained in the signal assignment statement.



TEST NUMBER :  57

PATHNAME :  [.BENCH.B.C.P7]shell1.sh
            (UNIX equivalent : bench/b/c/p7/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical OR
           operations on variables;  determine the number of logical OR
           operations allowed in one variable assignment statement.  The model 
           simulated is an architecture consisting of a number of processes; 
           each process consists of a variable declaration and a variable 
           assignment statement containing a number of logical OR operations.  
           The factors to be varied are the number of processes and the number 
           of logical OR operations in the variable assignment statement.



TEST NUMBER :  58

PATHNAME :  [.BENCH.B.C.P8]shell0.sh
            (UNIX equivalent : bench/b/c/p8/shell0.sh)

PURPOSE :  Determine the simulation CPU time required for executing logical
           NAND operations on variables.  The model simulated is an architecture
           consisting of a number of processes; each process consists of a 
           number of variable declarations and one logical NAND variable 
           assignment statement for each variable.  The factors to be varied
           are the number of processes and the number of variable declarations/
           number of logical NAND variable assignment statements.



TEST NUMBER :  59

PATHNAME :  [.BENCH.B.C.K.L1.P8]shell0.sh
            (UNIX equivalent : bench/b/c/k/l1/p8/shell0.sh)

PURPOSE :  Determine the effect on simulation CPU time when the following
           factors are varied in an architecture consisting of a number of
           processes; each process consists of a variable bit_vector
           declaration and a for-loop; the for-loop contains a logical NAND
           statement, and the number of iterations of the loop is equal to
           the size of the variable bit_vector : number of processes, bit_vector
           size/number of iterations of for-loop.



TEST NUMBER :  60

PATHNAME :  [.BENCH.A.C.P8]shell0.sh
            (UNIX equivalent : bench/a/c/p8/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical NAND
           operations on signals.  The model simulated consists of a number of
           signal declarations and one logical NAND signal assignment statement
           for each signal.  The factor to be varied is the number of signal
           declarations/number of logical NAND signal assignment statements.



TEST NUMBER :  61

PATHNAME :  [.BENCH.A.C.P8]shell1.sh
            (UNIX equivalent : bench/a/c/p8/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to perform logical NAND
           operations on a signal; determine the number  of logical NAND
           operations allowed in one signal assignment statement.  The model 
           simulated is an architecture consisting of a signal declaration and 
           a signal assignment statement containing a number of logical NAND 
           operations.  The factor to be varied is the number of logical NAND 
           operations contained in the signal assignment statement.



TEST NUMBER :  62

PATHNAME :  [.BENCH.B.C.P8]shell1.sh
            (UNIX equivalent : bench/b/c/p8/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical NAND
           operations on variables;  determine the number of logical NAND
           operations allowed in one variable assignment statement.  The model 
           simulated is an architecture consisting of a number of processes; 
           each process consists of a variable declaration and a variable 
           assignment statement containing a number of logical NAND operations. 
           The factors to be varied are the number of processes and the number 
           of logical NAND operations in the variable assignment statement.



TEST NUMBER :  63

PATHNAME :  [.BENCH.B.C.P9]shell0.sh
            (UNIX equivalent : bench/b/c/p9/shell0.sh)

PURPOSE :  Determine the simulation CPU time required for executing logical
           NOR operations on variables.  The model simulated is an architecture
           consisting of a number of processes; each process consists of a 
           number of variable declarations and one logical NOR variable 
           assignment statement for each variable.  The factors to be varied
           are the number of processes and the number of variable declarations/
           number of logical NOR variable assignment statements.



TEST NUMBER :  64

PATHNAME :  [.BENCH.B.C.K.L1.P9]shell0.sh
            (UNIX equivalent : bench/b/c/k/l1/p9/shell0.sh)

PURPOSE :  Determine the effect on simulation CPU time when the following
           factors are varied in an architecture consisting of a number of
           processes; each process consists of a variable bit_vector
           declaration and a for-loop; the for-loop contains a logical NOR
           statement, and the number of iterations of the loop is equal to
           the size of the variable bit_vector : number of processes, bit_vector
           size/number of iterations of for-loop.



TEST NUMBER :  65

PATHNAME :  [.BENCH.A.C.P9]shell0.sh
            (UNIX equivalent : bench/a/c/p9/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical NOR
           operations on signals.  The model simulated consists of a number of
           signal declarations and one logical NOR signal assignment statement
           for each signal.  The factor to be varied is the number of signal
           declarations/number of logical NOR signal assignment statements.



TEST NUMBER :  66

PATHNAME :  [.BENCH.A.C.P9]shell1.sh
            (UNIX equivalent : bench/a/c/p9/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to perform logical NOR
           operations on a signal; determine the number  of logical NOR
           operations allowed in one signal assignment statement.  The model 
           simulated is an architecture consisting of a signal declaration and 
           a signal assignment statement containing a number of logical NOR 
           operations.  The factor to be varied is the number of logical NOR 
           operations contained in the signal assignment statement.



TEST NUMBER :  67

PATHNAME :  [.BENCH.B.C.P9]shell1.sh
            (UNIX equivalent : bench/b/c/p9/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical NOR
           operations on variables;  determine the number of logical NOR
           operations allowed in one variable assignment statement.  The model 
           simulated is an architecture consisting of a number of processes; 
           each process consists of a variable declaration and a variable 
           assignment statement containing a number of logical NOR operations. 
           The factors to be varied are the number of processes and the number 
           of logical NOR operations in the variable assignment statement.



TEST NUMBER :  68

PATHNAME :  [.BENCH.B.C.P10]shell0.sh
            (UNIX equivalent : bench/b/c/p10/shell0.sh)

PURPOSE :  Determine the simulation CPU time required for executing logical
           XOR operations on variables.  The model simulated is an architecture
           consisting of a number of processes; each process consists of a 
           number of variable declarations and one logical XOR variable 
           assignment statement for each variable.  The factors to be varied
           are the number of processes and the number of variable declarations/
           number of logical XOR variable assignment statements.



TEST NUMBER :  69

PATHNAME :  [.BENCH.B.C.K.L1.P10]shell0.sh
            (UNIX equivalent : bench/b/c/k/l1/p10/shell0.sh)

PURPOSE :  Determine the effect on simulation CPU time when the following
           factors are varied in an architecture consisting of a number of
           processes; each process consists of a variable bit_vector
           declaration and a for-loop; the for-loop contains a logical XOR
           statement, and the number of iterations of the loop is equal to
           the size of the variable bit_vector : number of processes, bit_vector
           size/number of iterations of for-loop.



TEST NUMBER :  70

PATHNAME :  [.BENCH.A.C.P10]shell0.sh
            (UNIX equivalent : bench/a/c/p10/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical XOR
           operations on signals.  The model simulated consists of a number of
           signal declarations and one logical XOR signal assignment statement
           for each signal.  The factor to be varied is the number of signal
           declarations/number of logical XOR signal assignment statements.



TEST NUMBER :  71

PATHNAME :  [.BENCH.A.C.P10]shell1.sh
            (UNIX equivalent : bench/a/c/p10/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to perform logical XOR
           operations on a signal; determine the number  of logical XOR
           operations allowed in one signal assignment statement.  The model 
           simulated is an architecture consisting of a signal declaration and 
           a signal assignment statement containing a number of logical XOR 
           operations.  The factor to be varied is the number of logical XOR 
           operations contained in the signal assignment statement.



TEST NUMBER :  72

PATHNAME :  [.BENCH.B.C.P10]shell1.sh
            (UNIX equivalent : bench/b/c/p10/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical XOR
           operations on variables;  determine the number of logical XOR
           operations allowed in one variable assignment statement.  The model 
           simulated is an architecture consisting of a number of processes; 
           each process consists of a variable declaration and a variable 
           assignment statement containing a number of logical XOR operations. 
           The factors to be varied are the number of processes and the number 
           of logical XOR operations in the variable assignment statement.



TEST NUMBER :  73

PATHNAME :  [.BENCH.B.C.P11]shell0.sh
            (UNIX equivalent : bench/b/c/p11/shell0.sh)

PURPOSE :  Determine the simulation CPU time required for executing logical
           NOT operations on variables.  The model simulated is an architecture
           consisting of a number of processes; each process consists of a 
           number of variable declarations and one logical NOT variable 
           assignment statement for each variable.  The factors to be varied
           are the number of processes and the number of variable declarations/
           number of logical NOT variable assignment statements.



TEST NUMBER :  74

PATHNAME :  [.BENCH.B.C.K.L1.P11]shell0.sh
            (UNIX equivalent : bench/b/c/k/l1/p11/shell0.sh)

PURPOSE :  Determine the effect on simulation CPU time when the following
           factors are varied in an architecture consisting of a number of
           processes; each process consists of a variable bit_vector
           declaration and a for-loop; the for-loop contains a logical NOT
           statement, and the number of iterations of the loop is equal to
           the size of the variable bit_vector : number of processes, bit_vector
           size/number of iterations of for-loop.



TEST NUMBER :  75

PATHNAME :  [.BENCH.A.C.P11]shell0.sh
            (UNIX equivalent : bench/a/c/p11/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical NOT
           operations on signals.  The model simulated consists of a number of
           signal declarations and one logical NOT signal assignment statement
           for each signal.  The factor to be varied is the number of signal
           declarations/number of logical NOT signal assignment statements.



TEST NUMBER :  76

PATHNAME :  [.BENCH.A.C.P11]shell1.sh
            (UNIX equivalent : bench/a/c/p11/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to perform logical NOT
           operations on a signal; determine the number  of logical NOT
           operations allowed in one signal assignment statement.  The model 
           simulated is an architecture consisting of a signal declaration and 
           a signal assignment statement containing a number of logical NOT 
           operations.  The factor to be varied is the number of logical NOT 
           operations contained in the signal assignment statement.



TEST NUMBER :  77

PATHNAME :  [.BENCH.B.C.P11]shell1.sh
            (UNIX equivalent : bench/b/c/p11/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical NOT
           operations on variables;  determine the number of logical NOT
           operations allowed in one variable assignment statement.  The model 
           simulated is an architecture consisting of a number of processes; 
           each process consists of a variable declaration and a variable 
           assignment statement containing a number of logical NOT operations. 
           The factors to be varied are the number of processes and the number 
           of logical NOT operations in the variable assignment statement.



TEST NUMBER :  78

PATHNAME :  [.BENCH.A.C.P5]shell0.sh
            (UNIX equivalent : bench/a/c/p5/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute concatenation
           operations on string signals.  The model simulated consists of a 
           number of string signal declarations and one concatenation signal 
           assignment statement for each signal.  The factors to be varied are 
           the number of signal declarations/number of concatenation signal 
           assignment statements and the lengths of the strings to be 
           concatenated.



TEST NUMBER :  79

PATHNAME :  [.BENCH.A.C.P5]shell1.sh
            (UNIX equivalent : bench/a/c/p5/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to perform concatenation
           operations on a signal; determine the number  of concatenation
           operations allowed in one signal assignment statement.  The model 
           simulated is an architecture consisting of a string signal 
           declaration and a signal assignment statement containing a number of 
           concatenation operations.  The factors to be varied are the number 
           of concatenation operations contained in the signal assignment 
           statement and the length of the string used in the concatenations.



TEST NUMBER :  80

PATHNAME :  [.BENCH.B.C.P5]shell0.sh
            (UNIX equivalent : bench/b/c/p5/shell0.sh)

PURPOSE :  Determine the simulation CPU time required for executing 
           concatenation operations on variables.  The model simulated is an 
           architecture consisting of a number of processes; each process 
           consists of a number of string variable declarations and one 
           concatenation variable assignment statement for each variable.  The 
           factors to be varied are the number of processes, the number of 
           variable declarations/number of concatenation variable assignment 
           statements, and the length of the string used in the concatenations.



TEST NUMBER :  81

PATHNAME :  [.BENCH.B.C.P5]shell1.sh
            (UNIX equivalent : bench/b/c/p5/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute concatenation
           operations on variables;  determine the number of concatenation
           operations allowed in one variable assignment statement.  The model 
           simulated is an architecture consisting of a number of processes; 
           each process consists of two string variable declarations and a 
           variable assignment statement containing a number of concatenation 
           operations.  The factors to be varied are the number of processes,
           the number of concatenation operations in the variable assignment 
           statement, and the length of the string used in the concatenations.



TEST NUMBER :  82

PATHNAME :  [.BENCH.A.C.H2.P5]shell0.sh
            (UNIX equivalent : bench/a/c/h2/p5/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           concatenation statements.  The model simulated is an architecture
           consisting of a procedure declaration and a procedure call.  The 
           procedure consists of a number of string variable declarations
           and a concatenation statement for each variable.  The factors to be 
           varied are the number of variable declarations/concatenation 
           statements in the procedure and the length of the strings used in
           the concatenations.



TEST NUMBER :  83

PATHNAME :  [.BENCH.A.C.H2.P5]shell1.sh
            (UNIX equivalent : bench/a/c/h2/p5/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           concatenation operations in a procedure; determine the number of 
           concatenation operations allowed in one variable assignment 
           statement of a procedure.  The model simulated is an architecture 
           consisting of a procedure declaration and a procedure call; the 
           procedure consists of a string variable declaration and a variable 
           assignment statement containing a number of concatenation operations.
           The factors to be varied are the number of concatenation operations 
           contained in the variable assignment statement and the length of the
           string used in the concatenations.



TEST NUMBER :  84

PATHNAME :  [.BENCH.A.C.I2.P5]shell0.sh
            (UNIX equivalent : bench/a/c/i2/p5/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           concatenation statements.  The model simulated is an architecture
           consisting of a function declaration and a function call.  The 
           function consists of a number of string variable declarations
           and a concatenation statement for each variable.  The factors to be 
           varied are the number of variable declarations/concatenation 
           statements in the function and the length of the string used in the
           concatenations.



TEST NUMBER :  85

PATHNAME :  [.BENCH.A.C.I2.P5]shell1.sh
            (UNIX equivalent : bench/a/c/i2/p5/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           concatenation operations in a function; determine the number of 
           concatenation operations allowed in one variable assignment 
           statement of a function.  The model simulated is an architecture 
           consisting of a function declaration and a function call; the 
           function consists of two string variable declarations and a variable 
           assignment statement containing a number of concatenation operations.
           The factors to be varied are the number of concatenation operations 
           contained in the variable assignment statement and the length of the
           string used in the concatenations.



TEST NUMBER :  86

PATHNAME :  [.BENCH.A.C.H1.L1.M.S2]shell.sh
            (UNIX equivalent : bench/a/c/h1/l1/m/s2/shell.sh)

PURPOSE :  Determine the simulation CPU time required for writing characters
           to an output file.  The model simulated is an entity consisting of a
           procedure declaration and an architecture consisting of a procedure 
           call.  The procedure consists of a for-loop whose number of 
           iterations is equal to the number of characters to write (excluding
           linefeeds).  The for-loop contains a write character statement and
           an if-then construct containing a write linefeed statement.  The 
           factor to be varied is the number of non-linefeed characters to 
           write.



TEST NUMBER :  87

PATHNAME :  [.BENCH.A.C.H1.L3.S2]shell.sh
            (UNIX equivalent : bench/a/c/h1/l3/s2/shell.sh)

PURPOSE :  Determine the simulation CPU time required for writing characters
           to an output file.  The model simulated is an entity consisting of
           a procedure declaration and an architecture consisting of a 
           procedure call.  The procedure consists of a while-loop whose number
           of iterations is equal to the number of non-linefeed characters to
           write.  The while-loop contains a write character/write linefeed 
           combination and a subtraction statement to decrement the loop-
           counter.  The factor to be varied is the number of non-linefeed
           characters to write.



TEST NUMBER :  88

PATHNAME :  [.BENCH.A.C.H1.S2]shell.sh
            (UNIX equivalent : bench/a/c/h1/s2/shell.sh)

PURPOSE :  Determine the simulation CPU time required to write characters
           to an output file.  The model simulated is an entity consisting of
           a procedure declaration and an architecture consisting of a 
           a procedure call.  The procedure consists of a number of write 
           character/write linefeed combinations.  The factor to be varied is 
           the number of write character/write linefeed pairs in the procedure.



TEST NUMBER :  89

PATHNAME :  [.BENCH.A.C.H1R.M.S2]shell.sh
            (UNIX equivalent : bench/a/c/h1r/m/s2/shell.sh)

PURPOSE :  Determine the simulation CPU time required for writing characters
           to an output file.  The model simulated is an entity consisting of
           a procedure declaration and an architecture consisting of a 
           procedure call.  The procedure consists of a write character/write 
           linefeed combination and a recursive call to itself.  The factor to 
           be varied is the number of times the procedure will recursively call 
           itself.



TEST NUMBER :  90

PATHNAME :  [.BENCH.A.C.H1.P1]shell0.sh
            (UNIX equivalent : bench/a/c/h1/p1/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           addition statements.  The model simulated is an entity consisting
           of a procedure declaration and an architecture consisting of a 
           procedure call.  The procedure consists of a number of integer 
           variable declarations and an addition statement for each variable.  
           The factor to be varied is the number of variable declarations/
           addition statements in the procedure.



TEST NUMBER :  91

PATHNAME :  [.BENCH.A.C.H1.P1]shell1.sh
            (UNIX equivalent : bench/a/c/h1/p1/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           addition operations in a procedure; determine the number of 
           addition operations allowed in one variable assignment statement of 
           a procedure.  The model simulated is an entity consisting of a
           procedure declaration and an architecture consisting of a procedure 
           call; the procedure consists of an integer variable declaration and 
           a variable assignment statement containing a number of addition 
           operations.  The factor to be varied is the number of addition 
           operations contained in the variable assignment statement.



TEST NUMBER :  92

PATHNAME :  [.BENCH.A.C.I1.P1]shell0.sh
            (UNIX equivalent : bench/a/c/i1/p1/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           addition statements.  The model simulated is an entity consisting
           of a function declaration and an architecture consisting of a 
           function call.  The function consists of a number of integer 
           variable declarations and an addition statement for each variable.  
           The factor to be varied is the number of variable declarations/
           addition statements in the function.



TEST NUMBER :  93

PATHNAME :  [.BENCH.A.C.I1.P1]shell1.sh
            (UNIX equivalent : bench/a/c/i1/p1/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           addition operations in a function; determine the number of 
           addition operations allowed in one variable assignment 
           statement of a function.  The model simulated is an entity 
           consisting of a function declaration and an architecture consisting 
           of a function call; the function consists of an integer variable 
           declaration and a variable assignment statement containing a number 
           of addition operations.  The factor to be varied is the number of 
           addition operations contained in the variable assignment statement.



TEST NUMBER :  94

PATHNAME :  [.BENCH.A.C.I1.P2]shell0.sh
            (UNIX equivalent : bench/a/c/i1/p2/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           subtraction statements.  The model simulated is an entity consisting
           of a function declaration and an architecture consisting of a 
           function call.  The function consists of a number of integer 
           variable declarations and a subtraction statement for each variable.
           The factor to be varied is the number of variable declarations/
           subtraction statements in the function.



TEST NUMBER :  95

PATHNAME :  [.BENCH.A.C.I1.P2]shell1.sh
            (UNIX equivalent : bench/a/c/i1/p2/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           subtraction operations in a function; determine the number of 
           subtraction operations allowed in one variable assignment 
           statement of a function.  The model simulated is an entity
           consisting of a function declaration and an architecture consisting 
           of a function call; the function consists of an integer variable 
           declaration and a variable assignment statement containing a number 
           of subtraction operations.  The factor to be varied is the number of 
           subtraction operations contained in the variable assignment 
           statement.



TEST NUMBER :  96

PATHNAME :  [.BENCH.A.C.H1.P2]shell0.sh
            (UNIX equivalent : bench/a/c/h1/p2/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           subtraction statements.  The model simulated is an entity consisting
           of a procedure declaration and an architecture consisting of a 
           procedure call.  The procedure consists of a number of integer 
           variable declarations and a subtraction statement for each variable.
           The factor to be varied is the number of variable declarations/
           subtraction statements in the procedure.



TEST NUMBER :  97

PATHNAME :  [.BENCH.A.C.H1.P2]shell1.sh
            (UNIX equivalent : bench/a/c/h1/p2/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           subtraction operations in a procedure; determine the number of 
           subtraction operations allowed in one variable assignment statement 
           of a procedure.  The model simulated is an entity consisting of a
           procedure declaration and an architecture consisting of a procedure 
           call; the procedure consists of an integer variable declaration and 
           a variable assignment statement containing a number of subtraction 
           operations.  The factor to be varied is the number of subtraction 
           operations contained in the variable assignment statement.



TEST NUMBER :  98

PATHNAME :  [.BENCH.A.C.H1.P3]shell0.sh
            (UNIX equivalent : bench/a/c/h1/p3/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           multiplication statements.  The model simulated is an entity 
           consisting of a procedure declaration and an architecture consisting 
           of a procedure call.  The procedure consists of a number of integer 
           variable declarations and a multiplication statement for each 
           variable.  The factor to be varied is the number of variable 
           declarations/multiplication statements in the procedure.



TEST NUMBER :  99

PATHNAME :  [.BENCH.A.C.H1.P3]shell1.sh
            (UNIX equivalent : bench/a/c/h1/p3/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           multiplication operations in a procedure; determine the number of 
           multiplication operations allowed in one variable assignment 
           statement of a procedure.  The model simulated is an entity 
           consisting of a procedure declaration and an architecture consisting 
           of a procedure call; the procedure consists of an integer variable 
           declaration and a variable assignment statement containing a number 
           of multiplication operations.  The factor to be varied is the number 
           of multiplication operations contained in the variable assignment 
           statement.



TEST NUMBER :  100

PATHNAME :  [.BENCH.A.C.I1.P3]shell0.sh
            (UNIX equivalent : bench/a/c/i1/p3/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           multiplication statements.  The model simulated is an entity 
           consisting of a function declaration and an architecture consisting 
           of a function call.  The function consists of a number of integer 
           variable declarations and a multiplication statement for each 
           variable.  The factor to be varied is the number of variable 
           declarations/multiplication statements in the function.



TEST NUMBER :  101

PATHNAME :  [.BENCH.A.C.I1.P3]shell1.sh
            (UNIX equivalent : bench/a/c/i1/p3/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           multiplication operations in a function; determine the number of 
           multiplication operations allowed in one variable assignment 
           statement of a function.  The model simulated is an entity
           consisting of a function declaration and an architecture consisting 
           of a function call; the function consists of an integer variable 
           declaration and a variable assignment statement containing a number 
           of multiplication operations.  The factor to be varied is the number 
           of multiplication operations contained in the variable assignment 
           statement.



TEST NUMBER :  102

PATHNAME :  [.BENCH.A.C.H1.P4]shell0.sh
            (UNIX equivalent : bench/a/c/h1/p4/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           division statements.  The model simulated is an entity consisting of 
           a procedure declaration and an architecture consisting of a 
           procedure call.  The procedure consists of a number of integer 
           variable declarations and a division statement for each variable.  
           The factor to be varied is the number of variable declarations/
           division statements in the procedure.



TEST NUMBER :  103

PATHNAME :  [.BENCH.A.C.H1.P4]shell1.sh
            (UNIX equivalent : bench/a/c/h1/p4/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           division operations in a procedure; determine the number of 
           division operations allowed in one variable assignment 
           statement of a procedure.  The model simulated is an entity 
           consisting of a procedure declaration and an architecture consisting 
           of a procedure call; the procedure consists of an integer variable 
           declaration and a variable assignment statement containing a number 
           of division operations.  The factor to be varied is the number 
           of division operations contained in the variable assignment 
           statement.



TEST NUMBER :  104

PATHNAME :  [.BENCH.A.C.I1.P4]shell0.sh
            (UNIX equivalent : bench/a/c/i1/p4/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           division statements.  The model simulated is an entity consisting of 
           a function declaration and an architecture consisting of a function 
           call.  The function consists of a number of integer variable 
           declarations and a division statement for each variable.  The 
           factor to be varied is the number of variable declarations/division 
           statements in the function.



TEST NUMBER :  105

PATHNAME :  [.BENCH.A.C.I1.P4]shell1.sh
            (UNIX equivalent : bench/a/c/i1/p4/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           division operations in a function; determine the number of 
           division operations allowed in one variable assignment statement of 
           a function.  The model simulated is an entity consisting of a 
           function declaration and an architecture consisting of a function 
           call; the function consists of an integer variable declaration and 
           a variable assignment statement containing a number of division 
           operations.  The factor to be varied is the number of division 
           operations contained in the variable assignment statement.



TEST NUMBER :  106

PATHNAME :  [.BENCH.A.C.I1.P5]shell0.sh
            (UNIX equivalent : bench/a/c/i1/p5/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           concatenation statements.  The model simulated is an entity
           consisting of a function declaration and an architecture consisting 
           of a function call.  The function consists of a number of string 
           variable declarations and a concatenation statement for each 
           variable.  The factors to be varied are the number of variable 
           declarations/concatenation statements in the function and the length 
           of the string used in the concatenations.



TEST NUMBER :  107

PATHNAME :  [.BENCH.A.C.I1.P5]shell1.sh
            (UNIX equivalent : bench/a/c/i1/p5/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           concatenation operations in a function; determine the number of 
           concatenation operations allowed in one variable assignment 
           statement of a function.  The model simulated is an entity 
           consisting of a function declaration and an architecture consisting 
           of a function call; the function consists of two string variable 
           declarations and a variable assignment statement containing a number 
           of concatenation operations.  The factors to be varied are the 
           number of concatenation operations contained in the variable 
           assignment statement and the length of the string used in the 
           concatenations.



TEST NUMBER :  108

PATHNAME :  [.BENCH.A.C.H1.P5]shell0.sh
            (UNIX equivalent : bench/a/c/h1/p5/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           concatenation statements.  The model simulated is an entity
           consisting of a procedure declaration and an architecture consisting 
           of a procedure call.  The procedure consists of a number of string 
           variable declarations and a concatenation statement for each 
           variable.  The factors to be varied are the number of variable 
           declarations/concatenation statements in the procedure and the 
           length of the strings used in the concatenations.



TEST NUMBER :  109

PATHNAME :  [.BENCH.A.C.H1.P5]shell1.sh
            (UNIX equivalent : bench/a/c/h1/p5/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           concatenation operations in a procedure; determine the number of 
           concatenation operations allowed in one variable assignment 
           statement of a procedure.  The model simulated is an entity 
           consisting of a procedure declaration and an architecture consisting 
           of a procedure call; the procedure consists of a string variable 
           declaration and a variable assignment statement containing a number 
           of concatenation operations.  The factors to be varied are the 
           number of concatenation operations contained in the variable 
           assignment statement and the length of the string used in the 
           concatenations.



TEST NUMBER :  110

PATHNAME :  [.BENCH.A.C.H1.P6]shell0.sh
            (UNIX equivalent : bench/a/c/h1/p6/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical AND statements.  The model simulated is an entity consisting 
           of a procedure declaration and an architecture consisting of a 
           procedure call.  The procedure consists of a number of variable 
           declarations and a logical AND statement for each variable.  The 
           factor to be varied is the number of variable declarations/logical 
           AND statements in the procedure.



TEST NUMBER :  111

PATHNAME :  [.BENCH.A.C.H1.P6]shell1.sh
            (UNIX equivalent : bench/a/c/h1/p6/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical AND operations in a procedure; determine the number of 
           logical AND operations allowed in one variable assignment 
           statement of a procedure.  The model simulated is an entity 
           consisting of a procedure declaration and an architecture consisting 
           of a procedure call; the procedure consists of a variable 
           declaration and a variable assignment statement containing a number 
           of logical AND operations.  The factor to be varied is the number 
           of logical AND operations contained in the variable assignment 
           statement.



TEST NUMBER :  112

PATHNAME :  [.BENCH.A.C.H2.P6]shell0.sh
            (UNIX equivalent : bench/a/c/h2/p6/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical AND statements.  The model simulated is an architecture
           consisting of a procedure declaration and a procedure call.  The 
           procedure consists of a number of variable declarations and a 
           logical AND statement for each variable.  The factor to be varied is 
           the number of variable declarations/logical AND statements in the 
           procedure.



TEST NUMBER :  113

PATHNAME :  [.BENCH.A.C.H2.P6]shell1.sh
            (UNIX equivalent : bench/a/c/h2/p6/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical AND operations in a procedure; determine the number of 
           logical AND operations allowed in one variable assignment statement 
           of a procedure.  The model simulated is an architecture consisting 
           of a procedure declaration and a procedure call; the procedure 
           consists of a variable declaration and a variable assignment 
           statement containing a number of addition operations.  The factor to 
           be varied is the number of logical AND operations contained in the 
           variable assignment statement.



TEST NUMBER :  114

PATHNAME :  [.BENCH.A.C.I1.P6]shell0.sh
            (UNIX equivalent : bench/a/c/i1/p6/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical AND statements.  The model simulated is an entity consisting 
           of a function declaration and an architecture consisting of a 
           function call.  The function consists of a number of variable 
           declarations and a logical AND statement for each variable.  The 
           factor to be varied is the number of variable declarations/logical 
           AND statements in the function.



TEST NUMBER :  115

PATHNAME :  [.BENCH.A.C.I1.P6]shell1.sh
            (UNIX equivalent : bench/a/c/i1/p6/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical AND operations in a function; determine the number of 
           logical AND operations allowed in one variable assignment statement 
           of a function.  The model simulated is an entity consisting of a 
           function declaration and an architecture consisting of a function 
           call; the function consists of a variable declaration and a variable 
           assignment statement containing a number of logical AND operations.
           The factor to be varied is the number of logical AND operations 
           contained in the variable assignment statement.



TEST NUMBER :  116

PATHNAME :  [.BENCH.A.C.I2.P6]shell0.sh
            (UNIX equivalent : bench/a/c/i2/p6/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical AND statements.  The model simulated is an architecture 
           consisting of a function declaration and a function call.  The 
           function consists of a number of variable declarations and a logical
           AND statement for each variable.  The factor to be varied is the 
           number of variable declarations/logical AND statements in the 
           function.



TEST NUMBER :  117

PATHNAME :  [.BENCH.A.C.I2.P6]shell1.sh
            (UNIX equivalent : bench/a/c/i2/p6/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical AND operations in a function; determine the number of 
           logical AND operations allowed in one variable assignment statement 
           of a function.  The model simulated is an architecture consisting of 
           a function declaration and a function call; the function consists of 
           a variable declaration and a variable assignment statement 
           containing a number of logical AND operations.  The factor to be 
           varied is the number of logical AND operations contained in the 
           variable assignment statement.



TEST NUMBER :  118

PATHNAME :  [.BENCH.A.C.H1.P7]shell0.sh
            (UNIX equivalent : bench/a/c/h1/p7/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical OR statements.  The model simulated is an entity consisting 
           of a procedure declaration and an architecture consisting of a 
           procedure call.  The procedure consists of a number of variable 
           declarations and a logical OR statement for each variable.  The 
           factor to be varied is the number of variable declarations/logical 
           OR statements in the procedure.



TEST NUMBER :  119

PATHNAME :  [.BENCH.A.C.H1.P7]shell1.sh
            (UNIX equivalent : bench/a/c/h1/p7/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical OR operations in a procedure; determine the number of 
           logical OR operations allowed in one variable assignment 
           statement of a procedure.  The model simulated is an entity 
           consisting of a procedure declaration and an architecture consisting 
           of a procedure call; the procedure consists of a variable 
           declaration and a variable assignment statement containing a number 
           of logical OR operations.  The factor to be varied is the number 
           of logical OR operations contained in the variable assignment 
           statement.



TEST NUMBER :  120

PATHNAME :  [.BENCH.A.C.H2.P7]shell0.sh
            (UNIX equivalent : bench/a/c/h2/p7/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical OR statements.  The model simulated is an architecture
           consisting of a procedure declaration and a procedure call.  The 
           procedure consists of a number of variable declarations and a 
           logical OR statement for each variable.  The factor to be varied is 
           the number of variable declarations/logical OR statements in the 
           procedure.



TEST NUMBER :  121

PATHNAME :  [.BENCH.A.C.H2.P7]shell1.sh
            (UNIX equivalent : bench/a/c/h2/p7/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical OR operations in a procedure; determine the number of 
           logical OR operations allowed in one variable assignment statement 
           of a procedure.  The model simulated is an architecture consisting 
           of a procedure declaration and a procedure call; the procedure 
           consists of a variable declaration and a variable assignment 
           statement containing a number of addition operations.  The factor to 
           be varied is the number of logical OR operations contained in the 
           variable assignment statement.



TEST NUMBER :  122

PATHNAME :  [.BENCH.A.C.I1.P7]shell0.sh
            (UNIX equivalent : bench/a/c/i1/p7/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical OR statements.  The model simulated is an entity consisting 
           of a function declaration and an architecture consisting of a 
           function call.  The function consists of a number of variable 
           declarations and a logical OR statement for each variable.  The 
           factor to be varied is the number of variable declarations/logical 
           OR statements in the function.



TEST NUMBER :  123

PATHNAME :  [.BENCH.A.C.I1.P7]shell1.sh
            (UNIX equivalent : bench/a/c/i1/p7/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical OR operations in a function; determine the number of 
           logical OR operations allowed in one variable assignment statement 
           of a function.  The model simulated is an entity consisting of a 
           function declaration and an architecture consisting of a function 
           call; the function consists of a variable declaration and a variable 
           assignment statement containing a number of logical OR operations.
           The factor to be varied is the number of logical OR operations 
           contained in the variable assignment statement.



TEST NUMBER :  124

PATHNAME :  [.BENCH.A.C.I2.P7]shell0.sh
            (UNIX equivalent : bench/a/c/i2/p7/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical OR statements.  The model simulated is an architecture 
           consisting of a function declaration and a function call.  The 
           function consists of a number of variable declarations and a logical
           OR statement for each variable.  The factor to be varied is the 
           number of variable declarations/logical OR statements in the 
           function.



TEST NUMBER :  125

PATHNAME :  [.BENCH.A.C.I2.P7]shell1.sh
            (UNIX equivalent : bench/a/c/i2/p7/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical OR operations in a function; determine the number of 
           logical OR operations allowed in one variable assignment statement 
           of a function.  The model simulated is an architecture consisting of 
           a function declaration and a function call; the function consists of 
           a variable declaration and a variable assignment statement 
           containing a number of logical OR operations.  The factor to be 
           varied is the number of logical OR operations contained in the 
           variable assignment statement.



TEST NUMBER :  126

PATHNAME :  [.BENCH.A.C.H1.P8]shell0.sh
            (UNIX equivalent : bench/a/c/h1/p8/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NAND statements.  The model simulated is an entity consisting 
           of a procedure declaration and an architecture consisting of a 
           procedure call.  The procedure consists of a number of variable 
           declarations and a logical NAND statement for each variable.  The 
           factor to be varied is the number of variable declarations/logical 
           NAND statements in the procedure.



TEST NUMBER :  127

PATHNAME :  [.BENCH.A.C.H1.P8]shell1.sh
            (UNIX equivalent : bench/a/c/h1/p8/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NAND operations in a procedure; determine the number of 
           logical NAND operations allowed in one variable assignment 
           statement of a procedure.  The model simulated is an entity 
           consisting of a procedure declaration and an architecture consisting 
           of a procedure call; the procedure consists of a variable 
           declaration and a variable assignment statement containing a number 
           of logical NAND operations.  The factor to be varied is the number 
           of logical NAND operations contained in the variable assignment 
           statement.



TEST NUMBER :  128

PATHNAME :  [.BENCH.A.C.H2.P8]shell0.sh
            (UNIX equivalent : bench/a/c/h2/p8/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NAND statements.  The model simulated is an architecture
           consisting of a procedure declaration and a procedure call.  The 
           procedure consists of a number of variable declarations and a 
           logical NAND statement for each variable.  The factor to be varied is 
           the number of variable declarations/logical NAND statements in the 
           procedure.



TEST NUMBER :  129

PATHNAME :  [.BENCH.A.C.H2.P8]shell1.sh
            (UNIX equivalent : bench/a/c/h2/p8/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NAND operations in a procedure; determine the number of 
           logical NAND operations allowed in one variable assignment statement 
           of a procedure.  The model simulated is an architecture consisting 
           of a procedure declaration and a procedure call; the procedure 
           consists of a variable declaration and a variable assignment 
           statement containing a number of addition operations.  The factor to 
           be varied is the number of logical NAND operations contained in the 
           variable assignment statement.



TEST NUMBER :  130

PATHNAME :  [.BENCH.A.C.I1.P8]shell0.sh
            (UNIX equivalent : bench/a/c/i1/p8/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NAND statements.  The model simulated is an entity 
           consisting of a function declaration and an architecture consisting 
           of a function call.  The function consists of a number of variable 
           declarations and a logical NAND statement for each variable.  The 
           factor to be varied is the number of variable declarations/logical 
           NAND statements in the function.



TEST NUMBER :  131

PATHNAME :  [.BENCH.A.C.I1.P8]shell1.sh
            (UNIX equivalent : bench/a/c/i1/p8/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NAND operations in a function; determine the number of 
           logical NAND operations allowed in one variable assignment statement 
           of a function.  The model simulated is an entity consisting of a 
           function declaration and an architecture consisting of a function 
           call; the function consists of a variable declaration and a variable 
           assignment statement containing a number of logical NAND operations.
           The factor to be varied is the number of logical NAND operations 
           contained in the variable assignment statement.



TEST NUMBER :  132

PATHNAME :  [.BENCH.A.C.I2.P8]shell0.sh
            (UNIX equivalent : bench/a/c/i2/p8/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NAND statements.  The model simulated is an architecture 
           consisting of a function declaration and a function call.  The 
           function consists of a number of variable declarations and a logical
           NAND statement for each variable.  The factor to be varied is the 
           number of variable declarations/logical NAND statements in the 
           function.



TEST NUMBER :  133

PATHNAME :  [.BENCH.A.C.I2.P8]shell1.sh
            (UNIX equivalent : bench/a/c/i2/p8/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NAND operations in a function; determine the number of 
           logical NAND operations allowed in one variable assignment statement 
           of a function.  The model simulated is an architecture consisting of 
           a function declaration and a function call; the function consists of 
           a variable declaration and a variable assignment statement 
           containing a number of logical NAND operations.  The factor to be 
           varied is the number of logical NAND operations contained in the 
           variable assignment statement.



TEST NUMBER :  134

PATHNAME :  [.BENCH.A.C.H1.P9]shell0.sh
            (UNIX equivalent : bench/a/c/h1/p9/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NOR statements.  The model simulated is an entity consisting 
           of a procedure declaration and an architecture consisting of a 
           procedure call.  The procedure consists of a number of variable 
           declarations and a logical NOR statement for each variable.  The 
           factor to be varied is the number of variable declarations/logical 
           NOR statements in the procedure.



TEST NUMBER :  135

PATHNAME :  [.BENCH.A.C.H1.P9]shell1.sh
            (UNIX equivalent : bench/a/c/h1/p9/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NOR operations in a procedure; determine the number of 
           logical NOR operations allowed in one variable assignment 
           statement of a procedure.  The model simulated is an entity 
           consisting of a procedure declaration and an architecture consisting 
           of a procedure call; the procedure consists of a variable 
           declaration and a variable assignment statement containing a number 
           of logical NOR operations.  The factor to be varied is the number 
           of logical NOR operations contained in the variable assignment 
           statement.



TEST NUMBER :  136

PATHNAME :  [.BENCH.A.C.H2.P9]shell0.sh
            (UNIX equivalent : bench/a/c/h2/p9/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NOR statements.  The model simulated is an architecture
           consisting of a procedure declaration and a procedure call.  The 
           procedure consists of a number of variable declarations and a 
           logical NOR statement for each variable.  The factor to be varied is 
           the number of variable declarations/logical NOR statements in the 
           procedure.



TEST NUMBER :  137

PATHNAME :  [.BENCH.A.C.H2.P9]shell1.sh
            (UNIX equivalent : bench/a/c/h2/p9/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NOR operations in a procedure; determine the number of 
           logical NOR operations allowed in one variable assignment statement 
           of a procedure.  The model simulated is an architecture consisting 
           of a procedure declaration and a procedure call; the procedure 
           consists of a variable declaration and a variable assignment 
           statement containing a number of addition operations.  The factor to 
           be varied is the number of logical NOR operations contained in the 
           variable assignment statement.



TEST NUMBER :  138

PATHNAME :  [.BENCH.A.C.I1.P9]shell0.sh
            (UNIX equivalent : bench/a/c/i1/p9/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NOR statements.  The model simulated is an entity 
           consisting of a function declaration and an architecture consisting 
           of a function call.  The function consists of a number of variable 
           declarations and a logical NOR statement for each variable.  The 
           factor to be varied is the number of variable declarations/logical 
           NOR statements in the function.



TEST NUMBER :  139

PATHNAME :  [.BENCH.A.C.I1.P9]shell1.sh
            (UNIX equivalent : bench/a/c/i1/p9/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NOR operations in a function; determine the number of 
           logical NOR operations allowed in one variable assignment statement 
           of a function.  The model simulated is an entity consisting of a 
           function declaration and an architecture consisting of a function 
           call; the function consists of a variable declaration and a variable 
           assignment statement containing a number of logical NOR operations.
           The factor to be varied is the number of logical NOR operations 
           contained in the variable assignment statement.



TEST NUMBER :  140

PATHNAME :  [.BENCH.A.C.I2.P9]shell0.sh
            (UNIX equivalent : bench/a/c/i2/p9/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NOR statements.  The model simulated is an architecture 
           consisting of a function declaration and a function call.  The 
           function consists of a number of variable declarations and a logical
           NOR statement for each variable.  The factor to be varied is the 
           number of variable declarations/logical NOR statements in the 
           function.



TEST NUMBER :  141

PATHNAME :  [.BENCH.A.C.I2.P9]shell1.sh
            (UNIX equivalent : bench/a/c/i2/p9/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NOR operations in a function; determine the number of 
           logical NOR operations allowed in one variable assignment statement 
           of a function.  The model simulated is an architecture consisting of 
           a function declaration and a function call; the function consists of 
           a variable declaration and a variable assignment statement 
           containing a number of logical NOR operations.  The factor to be 
           varied is the number of logical NOR operations contained in the 
           variable assignment statement.



TEST NUMBER :  142

PATHNAME :  [.BENCH.A.C.H1.P10]shell0.sh
            (UNIX equivalent : bench/a/c/h1/p10/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical XOR statements.  The model simulated is an entity consisting 
           of a procedure declaration and an architecture consisting of a 
           procedure call.  The procedure consists of a number of variable 
           declarations and a logical XOR statement for each variable.  The 
           factor to be varied is the number of variable declarations/logical 
           XOR statements in the procedure.



TEST NUMBER :  143

PATHNAME :  [.BENCH.A.C.H1.P10]shell1.sh
            (UNIX equivalent : bench/a/c/h1/p10/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical XOR operations in a procedure; determine the number of 
           logical XOR operations allowed in one variable assignment 
           statement of a procedure.  The model simulated is an entity 
           consisting of a procedure declaration and an architecture consisting 
           of a procedure call; the procedure consists of a variable 
           declaration and a variable assignment statement containing a number 
           of logical XOR operations.  The factor to be varied is the number 
           of logical XOR operations contained in the variable assignment 
           statement.



TEST NUMBER :  144

PATHNAME :  [.BENCH.A.C.H2.P10]shell0.sh
            (UNIX equivalent : bench/a/c/h2/p10/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical XOR statements.  The model simulated is an architecture
           consisting of a procedure declaration and a procedure call.  The 
           procedure consists of a number of variable declarations and a 
           logical XOR statement for each variable.  The factor to be varied is 
           the number of variable declarations/logical XOR statements in the 
           procedure.



TEST NUMBER :  145

PATHNAME :  [.BENCH.A.C.H2.P10]shell1.sh
            (UNIX equivalent : bench/a/c/h2/p10/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical XOR operations in a procedure; determine the number of 
           logical XOR operations allowed in one variable assignment statement 
           of a procedure.  The model simulated is an architecture consisting 
           of a procedure declaration and a procedure call; the procedure 
           consists of a variable declaration and a variable assignment 
           statement containing a number of addition operations.  The factor to 
           be varied is the number of logical XOR operations contained in the 
           variable assignment statement.



TEST NUMBER :  146

PATHNAME :  [.BENCH.A.C.I1.P10]shell0.sh
            (UNIX equivalent : bench/a/c/i1/p10/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical XOR statements.  The model simulated is an entity 
           consisting of a function declaration and an architecture consisting 
           of a function call.  The function consists of a number of variable 
           declarations and a logical XOR statement for each variable.  The 
           factor to be varied is the number of variable declarations/logical 
           XOR statements in the function.



TEST NUMBER :  147

PATHNAME :  [.BENCH.A.C.I1.P10]shell1.sh
            (UNIX equivalent : bench/a/c/i1/p10/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical XOR operations in a function; determine the number of 
           logical XOR operations allowed in one variable assignment statement 
           of a function.  The model simulated is an entity consisting of a 
           function declaration and an architecture consisting of a function 
           call; the function consists of a variable declaration and a variable 
           assignment statement containing a number of logical XOR operations.
           The factor to be varied is the number of logical XOR operations 
           contained in the variable assignment statement.



TEST NUMBER :  148

PATHNAME :  [.BENCH.A.C.I2.P10]shell0.sh
            (UNIX equivalent : bench/a/c/i2/p10/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical XOR statements.  The model simulated is an architecture 
           consisting of a function declaration and a function call.  The 
           function consists of a number of variable declarations and a logical
           XOR statement for each variable.  The factor to be varied is the 
           number of variable declarations/logical XOR statements in the 
           function.



TEST NUMBER :  149

PATHNAME :  [.BENCH.A.C.I2.P10]shell1.sh
            (UNIX equivalent : bench/a/c/i2/p10/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical XOR operations in a function; determine the number of 
           logical XOR operations allowed in one variable assignment statement 
           of a function.  The model simulated is an architecture consisting of 
           a function declaration and a function call; the function consists of 
           a variable declaration and a variable assignment statement 
           containing a number of logical XOR operations.  The factor to be 
           varied is the number of logical XOR operations contained in the 
           variable assignment statement.



TEST NUMBER :  150

PATHNAME :  [.BENCH.A.C.H1.P11]shell0.sh
            (UNIX equivalent : bench/a/c/h1/p11/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NOT statements.  The model simulated is an entity consisting 
           of a procedure declaration and an architecture consisting of a 
           procedure call.  The procedure consists of a number of variable 
           declarations and a logical NOT statement for each variable.  The 
           factor to be varied is the number of variable declarations/logical 
           NOT statements in the procedure.



TEST NUMBER :  151

PATHNAME :  [.BENCH.A.C.H1.P11]shell1.sh
            (UNIX equivalent : bench/a/c/h1/p11/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NOT operations in a procedure; determine the number of 
           logical NOT operations allowed in one variable assignment 
           statement of a procedure.  The model simulated is an entity 
           consisting of a procedure declaration and an architecture consisting 
           of a procedure call; the procedure consists of a variable 
           declaration and a variable assignment statement containing a number 
           of logical NOT operations.  The factor to be varied is the number 
           of logical NOT operations contained in the variable assignment 
           statement.



TEST NUMBER :  152

PATHNAME :  [.BENCH.A.C.H2.P11]shell0.sh
            (UNIX equivalent : bench/a/c/h2/p11/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NOT statements.  The model simulated is an architecture
           consisting of a procedure declaration and a procedure call.  The 
           procedure consists of a number of variable declarations and a 
           logical NOT statement for each variable.  The factor to be varied is 
           the number of variable declarations/logical NOT statements in the 
           procedure.



TEST NUMBER :  153

PATHNAME :  [.BENCH.A.C.H2.P11]shell1.sh
            (UNIX equivalent : bench/a/c/h2/p11/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NOT operations in a procedure; determine the number of 
           logical NOT operations allowed in one variable assignment statement 
           of a procedure.  The model simulated is an architecture consisting 
           of a procedure declaration and a procedure call; the procedure 
           consists of a variable declaration and a variable assignment 
           statement containing a number of addition operations.  The factor to 
           be varied is the number of logical NOT operations contained in the 
           variable assignment statement.



TEST NUMBER :  154

PATHNAME :  [.BENCH.A.C.I1.P11]shell0.sh
            (UNIX equivalent : bench/a/c/i1/p11/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NOT statements.  The model simulated is an entity 
           consisting of a function declaration and an architecture consisting 
           of a function call.  The function consists of a number of variable 
           declarations and a logical NOT statement for each variable.  The 
           factor to be varied is the number of variable declarations/logical 
           NOT statements in the function.



TEST NUMBER :  155

PATHNAME :  [.BENCH.A.C.I1.P11]shell1.sh
            (UNIX equivalent : bench/a/c/i1/p11/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NOT operations in a function; determine the number of 
           logical NOT operations allowed in one variable assignment statement 
           of a function.  The model simulated is an entity consisting of a 
           function declaration and an architecture consisting of a function 
           call; the function consists of a variable declaration and a variable 
           assignment statement containing a number of logical NOT operations.
           The factor to be varied is the number of logical NOT operations 
           contained in the variable assignment statement.



TEST NUMBER :  156

PATHNAME :  [.BENCH.A.C.I2.P11]shell0.sh
            (UNIX equivalent : bench/a/c/i2/p11/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NOT statements.  The model simulated is an architecture 
           consisting of a function declaration and a function call.  The 
           function consists of a number of variable declarations and a logical
           NOT statement for each variable.  The factor to be varied is the 
           number of variable declarations/logical NOT statements in the 
           function.



TEST NUMBER :  157

PATHNAME :  [.BENCH.A.C.I2.P11]shell1.sh
            (UNIX equivalent : bench/a/c/i2/p11/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           logical NOT operations in a function; determine the number of 
           logical NOT operations allowed in one variable assignment statement 
           of a function.  The model simulated is an architecture consisting of 
           a function declaration and a function call; the function consists of 
           a variable declaration and a variable assignment statement 
           containing a number of logical NOT operations.  The factor to be 
           varied is the number of logical NOT operations contained in the 
           variable assignment statement.



TEST NUMBER :  158

PATHNAME :  [.BENCH.A.C.P1]shell2.sh
            (UNIX equivalent : bench/a/c/p1/shell2.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition
           operations on signals.  The model simulated consists of a number of
           integer signal declarations and one addition signal assignment 
           statement for each signal, plus a signal declaration/signal 
           assignment statement/assertion that controls how long to simulate 
           the model.  The factors to be varied are the number of signal 
           declarations/number of addition signal assignment statements and the
           length of time (in ns) to simulate the model.



TEST NUMBER :  159

PATHNAME :  [.BENCH.A.C.P2]shell2.sh
            (UNIX equivalent : bench/a/c/p2/shell2.sh)

PURPOSE :  Determine the simulation CPU time required to execute subtraction
           operations on signals.  The model simulated consists of a number of
           integer signal declarations and one subtraction signal assignment 
           statement for each signal, plus a signal declaration/signal 
           assignment statement/assertion that controls how long to simulate 
           the model.  The factors to be varied are the number of signal 
           declarations/number of subtraction signal assignment statements and 
           the length of time (in ns) to simulate the model.



TEST NUMBER :  160

PATHNAME :  [.BENCH.A.C.P3]shell2.sh
            (UNIX equivalent : bench/a/c/p3/shell2.sh)

PURPOSE :  Determine the simulation CPU time required to execute multiplication
           operations on signals.  The model simulated consists of a number of
           integer signal declarations and one multiplication signal assignment 
           statement for each signal, plus a signal declaration/signal 
           assignment statement/assertion that controls how long to simulate 
           the model.  The factors to be varied are the number of signal 
           declarations/number of multiplication signal assignment statements 
           and the length of time (in ns) to simulate the model.



TEST NUMBER :  161

PATHNAME :  [.BENCH.A.C.P4]shell2.sh
            (UNIX equivalent : bench/a/c/p4/shell2.sh)

PURPOSE :  Determine the simulation CPU time required to execute division
           operations on signals.  The model simulated consists of a number of
           integer signal declarations and one division signal assignment 
           statement for each signal, plus a signal declaration/signal 
           assignment statement/assertion that controls how long to simulate 
           the model.  The factors to be varied are the number of signal 
           declarations/number of division signal assignment statements and the 
           length of time (in ns) to simulate the model.



TEST NUMBER :  162

PATHNAME :  [.BENCH.A.C.P6]shell2.sh
            (UNIX equivalent : bench/a/c/p6/shell2.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical AND
           operations on signals.  The model simulated consists of a number of
           signal declarations and one logical AND signal assignment statement
           for each signal, plus a signal declaration/signal assignment
           statement/assertion that controls how long to simulate the model.  
           The factors to be varied are the number of signal declarations/
           number of logical AND signal assignment statements and the length of
           time (in ns) to simulate the model.



TEST NUMBER :  163

PATHNAME :  [.BENCH.A.C.P7]shell2.sh
            (UNIX equivalent : bench/a/c/p7/shell2.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical OR
           operations on signals.  The model simulated consists of a number of
           signal declarations and one logical OR signal assignment statement
           for each signal, plus a signal declaration/signal assignment
           statement/assertion that controls how long to simulate the model.  
           The factors to be varied are the number of signal declarations/
           number of logical OR signal assignment statements and the length of
           time (in ns) to simulate the model.



TEST NUMBER :  164

PATHNAME :  [.BENCH.A.C.P8]shell2.sh
            (UNIX equivalent : bench/a/c/p8/shell2.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical NAND
           operations on signals.  The model simulated consists of a number of
           signal declarations and one logical NAND signal assignment statement
           for each signal, plus a signal declaration/signal assignment
           statement/assertion that controls how long to simulate the model.  
           The factors to be varied are the number of signal declarations/
           number of logical NAND signal assignment statements and the length of
           time (in ns) to simulate the model.



TEST NUMBER :  165

PATHNAME :  [.BENCH.A.C.P9]shell2.sh
            (UNIX equivalent : bench/a/c/p9/shell2.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical NOR
           operations on signals.  The model simulated consists of a number of
           signal declarations and one logical NOR signal assignment statement
           for each signal, plus a signal declaration/signal assignment
           statement/assertion that controls how long to simulate the model.  
           The factors to be varied are the number of signal declarations/
           number of logical NOR signal assignment statements and the length of
           time (in ns) to simulate the model.
PURPOSE :



TEST NUMBER :  166

PATHNAME :  [.BENCH.A.C.P10]shell2.sh
            (UNIX equivalent : bench/a/c/p10/shell2.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical XOR
           operations on signals.  The model simulated consists of a number of
           signal declarations and one logical XOR signal assignment statement
           for each signal, plus a signal declaration/signal assignment
           statement/assertion that controls how long to simulate the model.  
           The factors to be varied are the number of signal declarations/
           number of logical XOR signal assignment statements and the length of
           time (in ns) to simulate the model.
PURPOSE :



TEST NUMBER :  167

PATHNAME :  [.BENCH.A.C.P11]shell2.sh
            (UNIX equivalent : bench/a/c/p11/shell2.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical NOT
           operations on signals.  The model simulated consists of a number of
           signal declarations and one logical NOT signal assignment statement
           for each signal, plus a signal declaration/signal assignment
           statement/assertion that controls how long to simulate the model.  
           The factors to be varied are the number of signal declarations/
           number of logical NOT signal assignment statements and the length of
           time (in ns) to simulate the model.
PURPOSE :



TEST NUMBER :  168

PATHNAME :  [.BENCH.B.C.K.L1.P6]shell1.sh
            (UNIX equivalent : bench/b/c/k/l1/p6/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical AND
           operations on a signal.  The model simulated is an architecture 
           consisting of a process and two signal declarations, one bit_vector, 
           one bit; the process consists of a for-loop; the for-loop contains a 
           logical AND signal assignment statement, and the number of 
           iterations of the loop is equal to the size of the bit_vector 
           signal.  The factor to be varied is the bit_vector size/number of 
           iterations of the for-loop.



TEST NUMBER :  169

PATHNAME :  [.BENCH.B.C.K.L1.P7]shell1.sh
            (UNIX equivalent : bench/b/c/k/l1/p7/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical OR
           operations on a signal.  The model simulated is an architecture 
           consisting of a process and two signal declarations, one bit_vector, 
           one bit; the process consists of a for-loop; the for-loop contains a 
           logical OR signal assignment statement, and the number of 
           iterations of the loop is equal to the size of the bit_vector 
           signal.  The factor to be varied is the bit_vector size/number of 
           iterations of the for-loop.



TEST NUMBER :  170

PATHNAME :  [.BENCH.B.C.K.L1.P8]shell1.sh
            (UNIX equivalent : bench/b/c/k/l1/p8/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical NAND
           operations on a signal.  The model simulated is an architecture 
           consisting of a process and two signal declarations, one bit_vector, 
           one bit; the process consists of a for-loop; the for-loop contains a 
           logical NAND signal assignment statement, and the number of 
           iterations of the loop is equal to the size of the bit_vector 
           signal.  The factor to be varied is the bit_vector size/number of 
           iterations of the for-loop.



TEST NUMBER :  171

PATHNAME :  [.BENCH.B.C.K.L1.P9]shell1.sh
            (UNIX equivalent : bench/b/c/k/l1/p9/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical NOR
           operations on a signal.  The model simulated is an architecture 
           consisting of a process and two signal declarations, one bit_vector, 
           one bit; the process consists of a for-loop; the for-loop contains a 
           logical NOR signal assignment statement, and the number of 
           iterations of the loop is equal to the size of the bit_vector 
           signal.  The factor to be varied is the bit_vector size/number of 
           iterations of the for-loop.



TEST NUMBER :  172

PATHNAME :  [.BENCH.B.C.K.L1.P10]shell1.sh
            (UNIX equivalent : bench/b/c/k/l1/p10/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical XOR
           operations on a signal.  The model simulated is an architecture 
           consisting of a process and two signal declarations, one bit_vector, 
           one bit; the process consists of a for-loop; the for-loop contains a 
           logical XOR signal assignment statement, and the number of 
           iterations of the loop is equal to the size of the bit_vector 
           signal.  The factor to be varied is the bit_vector size/number of 
           iterations of the for-loop.



TEST NUMBER :  173

PATHNAME :  [.BENCH.B.C.K.L1.P11]shell1.sh
            (UNIX equivalent : bench/b/c/k/l1/p11/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute logical NOT
           operations on a signal.  The model simulated is an architecture 
           consisting of a process and two signal declarations, one bit_vector, 
           one bit; the process consists of a for-loop; the for-loop contains a 
           logical NOT signal assignment statement, and the number of 
           iterations of the loop is equal to the size of the bit_vector 
           signal.  The factor to be varied is the bit_vector size/number of 
           iterations of the for-loop.



TEST NUMBER :  174

PATHNAME :  [.BENCH.B.C.K.L3.P11]shell1.sh
            (UNIX equivalent : bench/b/c/k/l3/p11/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition and
           logical NOT signal assignment statements.  The model simulated is an 
           architecture consisting of a process and two signal declarations, 
           one bit_vector, one bit; the process consists of an integer 
           loop-counter variable declaration and a while-loop; the while-loop 
           contains a variable addition statement for incrementing the 
           loop-counter and a logical NOT signal assignment statement, and the 
           number of iterations of the loop is equal to the size of the 
           bit_vector signal.  The factor to be varied is the bit_vector size/
           number of iterations of the while-loop.



TEST NUMBER :  175

PATHNAME :  [.BENCH.B.C.K.L3.P10]shell1.sh
            (UNIX equivalent : bench/b/c/k/l3/p10/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition and
           logical XOR signal assignment statements.  The model simulated is an 
           architecture consisting of a process and two signal declarations, 
           one bit_vector, one bit; the process consists of an integer 
           loop-counter variable declaration and a while-loop; the while-loop 
           contains a variable addition statement for incrementing the 
           loop-counter and a logical XOR signal assignment statement, and the 
           number of iterations of the loop is equal to the size of the 
           bit_vector signal.  The factor to be varied is the bit_vector size/
           number of iterations of the while-loop.



TEST NUMBER :  176

PATHNAME :  [.BENCH.B.C.K.L3.P9]shell1.sh
            (UNIX equivalent : bench/b/c/k/l3/p9/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition and
           logical NOR signal assignment statements.  The model simulated is an 
           architecture consisting of a process and two signal declarations, 
           one bit_vector, one bit; the process consists of an integer 
           loop-counter variable declaration and a while-loop; the while-loop 
           contains a variable addition statement for incrementing the 
           loop-counter and a logical NOR signal assignment statement, and the 
           number of iterations of the loop is equal to the size of the 
           bit_vector signal.  The factor to be varied is the bit_vector size/
           number of iterations of the while-loop.



TEST NUMBER :  177

PATHNAME :  [.BENCH.B.C.K.L3.P8]shell1.sh
            (UNIX equivalent : bench/b/c/k/l3/p8/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition and
           logical NAND signal assignment statements.  The model simulated is 
           an architecture consisting of a process and two signal declarations, 
           one bit_vector, one bit; the process consists of an integer 
           loop-counter variable declaration and a while-loop; the while-loop 
           contains a variable addition statement for incrementing the 
           loop-counter and a logical NAND signal assignment statement, and the 
           number of iterations of the loop is equal to the size of the 
           bit_vector signal.  The factor to be varied is the bit_vector size/
           number of iterations of the while-loop.



TEST NUMBER :  178

PATHNAME :  [.BENCH.B.C.K.L3.P7]shell1.sh
            (UNIX equivalent : bench/b/c/k/l3/p7/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition and
           logical OR signal assignment statements.  The model simulated is an 
           architecture consisting of a process and two signal declarations, 
           one bit_vector, one bit; the process consists of an integer 
           loop-counter variable declaration and a while-loop; the while-loop 
           contains a variable addition statement for incrementing the 
           loop-counter and a logical OR signal assignment statement, and the 
           number of iterations of the loop is equal to the size of the 
           bit_vector signal.  The factor to be varied is the bit_vector size/
           number of iterations of the while-loop.



TEST NUMBER :  179

PATHNAME :  [.BENCH.B.C.K.L3.P6]shell1.sh
            (UNIX equivalent : bench/b/c/k/l3/p6/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition and
           logical AND signal assignment statements.  The model simulated is an 
           architecture consisting of a process and two signal declarations, 
           one bit_vector, one bit; the process consists of an integer 
           loop-counter variable declaration and a while-loop; the while-loop 
           contains a variable addition statement for incrementing the 
           loop-counter and a logical AND signal assignment statement, and the 
           number of iterations of the loop is equal to the size of the 
           bit_vector signal.  The factor to be varied is the bit_vector size/
           number of iterations of the while-loop.



TEST NUMBER :  180

PATHNAME :  [.BENCH.B.C.K.L3.P6]shell0.sh
            (UNIX equivalent : bench/b/c/k/l3/p6/shell0.sh)

PURPOSE :  Determine the simulation CPU time required for executing addition
           and logical AND variable assignment statements.  The model simulated 
           is an architecture consisting of a process.  The process consists of 
           a variable bit_vector declaration , an integer variable declaration 
           (loop-counter), and a while-loop; the while-loop contains a variable 
           addition assignment statement to increment the loop-counter and a 
           logical AND statement, and the number of iterations of the loop is 
           equal to the size of the variable bit_vector. The factor to be 
           varied is the bit_vector size/number of iterations of the while-loop.



TEST NUMBER :  181

PATHNAME :  [.BENCH.B.C.K.L3.P7]shell0.sh
            (UNIX equivalent : bench/b/c/k/l3/p7/shell0.sh)

PURPOSE :  Determine the simulation CPU time required for executing addition
           and logical OR variable assignment statements.  The model simulated 
           is an architecture consisting of a process.  The process consists of 
           a variable bit_vector declaration , an integer variable declaration 
           (loop-counter), and a while-loop; the while-loop contains a variable 
           addition assignment statement to increment the loop-counter and a 
           logical OR statement, and the number of iterations of the loop is 
           equal to the size of the variable bit_vector. The factor to be 
           varied is the bit_vector size/number of iterations of the while-loop.



TEST NUMBER :  182

PATHNAME :  [.BENCH.B.C.K.L3.P8]shell0.sh
            (UNIX equivalent : bench/b/c/k/l3/p8/shell0.sh)

PURPOSE :  Determine the simulation CPU time required for executing addition
           and logical NAND variable assignment statements.  The model 
           simulated is an architecture consisting of a process.  The process 
           consists of a variable bit_vector declaration , an integer variable 
           declaration (loop-counter), and a while-loop; the while-loop 
           contains a variable addition assignment statement to increment the 
           loop-counter and a logical NAND statement, and the number of 
           iterations of the loop is equal to the size of the variable 
           bit_vector. The factor to be varied is the bit_vector size/number of 
           iterations of the while-loop.



TEST NUMBER :  183

PATHNAME :  [.BENCH.B.C.K.L3.P9]shell0.sh
            (UNIX equivalent : bench/b/c/k/l3/p9/shell0.sh)

PURPOSE :  Determine the simulation CPU time required for executing addition
           and logical NOR variable assignment statements.  The model 
           simulated is an architecture consisting of a process.  The process 
           consists of a variable bit_vector declaration , an integer variable 
           declaration (loop-counter), and a while-loop; the while-loop 
           contains a variable addition assignment statement to increment the 
           loop-counter and a logical NOR statement, and the number of 
           iterations of the loop is equal to the size of the variable 
           bit_vector. The factor to be varied is the bit_vector size/number of 
           iterations of the while-loop.



TEST NUMBER :  184

PATHNAME :  [.BENCH.B.C.K.L3.P10]shell0.sh
            (UNIX equivalent : bench/b/c/k/l3/p10/shell0.sh)

PURPOSE :  Determine the simulation CPU time required for executing addition
           and logical XOR variable assignment statements.  The model 
           simulated is an architecture consisting of a process.  The process 
           consists of a variable bit_vector declaration , an integer variable 
           declaration (loop-counter), and a while-loop; the while-loop 
           contains a variable addition assignment statement to increment the 
           loop-counter and a logical XOR statement, and the number of 
           iterations of the loop is equal to the size of the variable 
           bit_vector. The factor to be varied is the bit_vector size/number of 
           iterations of the while-loop.
PURPOSE :



TEST NUMBER :  185

PATHNAME :  [.BENCH.B.C.K.L3.P11]shell0.sh
            (UNIX equivalent : bench/b/c/k/l3/p11/shell0.sh)

PURPOSE :  Determine the simulation CPU time required for executing addition
           and logical NOT variable assignment statements.  The model 
           simulated is an architecture consisting of a process.  The process 
           consists of a variable bit_vector declaration , an integer variable 
           declaration (loop-counter), and a while-loop; the while-loop 
           contains a variable addition assignment statement to increment the 
           loop-counter and a logical NOT statement, and the number of 
           iterations of the loop is equal to the size of the variable 
           bit_vector. The factor to be varied is the bit_vector size/number of 
           iterations of the while-loop.



TEST NUMBER :  186

PATHNAME :  [.BENCH.B.C.K.L1.P1]shell0.sh
            (UNIX equivalent : bench/b/c/k/l1/p1/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           addition assignment statements.  The model simulated is an 
           architecture consisting of a number of processes.  Each process
           consists of an integer array variable declaration and a for-loop.
           The number of iterations of the loop is equal to the size of the 
           array.  The for-loop contains a variable addition assignment 
           statement.  The factors to be varied are the number of processes and
           the array size/number of loop iterations.



TEST NUMBER :  187

PATHNAME :  [.BENCH.B.C.K.L1.P2]shell0.sh
            (UNIX equivalent : bench/b/c/k/l1/p2/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           subtraction assignment statements.  The model simulated is an 
           architecture consisting of a number of processes.  Each process
           consists of an integer array variable declaration and a for-loop.
           The number of iterations of the loop is equal to the size of the 
           array.  The for-loop contains a variable subtraction assignment 
           statement.  The factors to be varied are the number of processes and
           the array size/number of loop iterations.



TEST NUMBER :  188

PATHNAME :  [.BENCH.B.C.K.L1.P3]shell0.sh
            (UNIX equivalent : bench/b/c/k/l1/p3/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           multiplication assignment statements.  The model simulated is an 
           architecture consisting of a number of processes.  Each process
           consists of an integer array variable declaration and a for-loop.
           The number of iterations of the loop is equal to the size of the 
           array.  The for-loop contains a variable multiplication assignment 
           statement.  The factors to be varied are the number of processes and
           the array size/number of loop iterations.



TEST NUMBER :  189

PATHNAME :  [.BENCH.B.C.K.L1.P4]shell0.sh
            (UNIX equivalent : bench/b/c/k/l1/p4/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           division assignment statements.  The model simulated is an 
           architecture consisting of a number of processes.  Each process
           consists of an integer array variable declaration and a for-loop.
           The number of iterations of the loop is equal to the size of the 
           array.  The for-loop contains a variable division assignment 
           statement.  The factors to be varied are the number of processes and
           the array size/number of loop iterations.



TEST NUMBER :  190

PATHNAME :  [.BENCH.B.C.K.L1.P1]shell1.sh
            (UNIX equivalent : bench/b/c/k/l1/p1/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition
           signal assignment statements.  The model simulated is an 
           architecture consisting of a process and two signal declarations,
           one integer and one integer array.  The process consists of a 
           for-loop.  The number of iterations of the loop is equal to the 
           size of the array.  The for-loop contains an addition signal 
           assignment statement.  The factor to be varied is the array size/
           number of loop iterations.



TEST NUMBER :  191

PATHNAME :  [.BENCH.B.C.K.L1.P2]shell1.sh
            (UNIX equivalent : bench/b/c/k/l1/p2/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute subtraction
           signal assignment statements.  The model simulated is an 
           architecture consisting of a process and two signal declarations,
           one integer and one integer array.  The process consists of a 
           for-loop.  The number of iterations of the loop is equal to the 
           size of the array.  The for-loop contains a subtraction signal 
           assignment statement.  The factor to be varied is the array size/
           number of loop iterations.



TEST NUMBER :  192

PATHNAME :  [.BENCH.B.C.K.L1.P3]shell1.sh
            (UNIX equivalent : bench/b/c/k/l1/p3/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute multiplication
           signal assignment statements.  The model simulated is an 
           architecture consisting of a process and two signal declarations,
           one integer and one integer array.  The process consists of a 
           for-loop.  The number of iterations of the loop is equal to the 
           size of the array.  The for-loop contains a multiplication signal 
           assignment statement.  The factor to be varied is the array size/
           number of loop iterations.



TEST NUMBER :  193

PATHNAME :  [.BENCH.B.C.K.L1.P4]shell1.sh
            (UNIX equivalent : bench/b/c/k/l1/p4/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute division
           signal assignment statements.  The model simulated is an 
           architecture consisting of a process and two signal declarations,
           one integer and one integer array.  The process consists of a 
           for-loop.  The number of iterations of the loop is equal to the 
           size of the array.  The for-loop contains a division signal 
           assignment statement.  The factor to be varied is the array size/
           number of loop iterations.



TEST NUMBER :  194

PATHNAME :  [.BENCH.B.C.K.L3.P1]shell0.sh
            (UNIX equivalent : bench/b/c/k/l3/p1/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition
           variable assignment statements.  The model simulated is an 
           architecture consisting of a process.  The process consists of
           two integer variable declarations (one is a loop-counter), one
           integer array variable declaration, and a while-loop.  The number of
           iterations of the loop is equal to the size of the array.  The
           while-loop contains two addition variable assignment statements (one
           to increment the loop-counter).  The factor to be varied is the array
           size/number of loop iterations.



TEST NUMBER :  195

PATHNAME :  [.BENCH.B.C.K.L3.P2]shell0.sh
            (UNIX equivalent : bench/b/c/k/l3/p2/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition
           and subtraction variable assignment statements.  The model simulated 
           is an architecture consisting of a process.  The process consists of
           two integer variable declarations (one is a loop-counter), one
           integer array variable declaration, and a while-loop.  The number of
           iterations of the loop is equal to the size of the array.  The
           while-loop contains an addition variable assignment statement to 
           increment the loop-counter and a subtraction variable assignment
           statement.  The factor to be varied is the array size/number of loop 
           iterations.



TEST NUMBER :  196

PATHNAME :  [.BENCH.B.C.K.L3.P3]shell0.sh
            (UNIX equivalent : bench/b/c/k/l3/p3/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition
           and multiplication variable assignment statements.  The model 
           simulated is an architecture consisting of a process.  The process 
           consists of two integer variable declarations (one is a loop-
           counter), one integer array variable declaration, and a while-loop. 
           The number of iterations of the loop is equal to the size of the 
           array.  The while-loop contains an addition variable assignment 
           statement to increment the loop-counter and a multiplication 
           variable assignment statement.  The factor to be varied is the array 
           size/number of loop iterations.



TEST NUMBER :  197

PATHNAME :  [.BENCH.B.C.K.L3.P4]shell0.sh
            (UNIX equivalent : bench/b/c/k/l3/p4/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition
           and division variable assignment statements.  The model simulated is 
           an architecture consisting of a process.  The process consists of 
           two integer variable declarations (one is a loop-counter), one 
           integer array variable declaration, and a while-loop.  The number of 
           iterations of the loop is equal to the size of the array.  The 
           while-loop contains an addition variable assignment statement to 
           increment the loop-counter and a division variable assignment 
           statement.  The factor to be varied is the array size/number of loop 
           iterations.



TEST NUMBER :  198

PATHNAME :  [.BENCH.B.C.K.L3.P1]shell1.sh
            (UNIX equivalent : bench/b/c/k/l3/p1/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition
           signal assignment statements.  The model simulated is an 
           architecture consisting of a process and two signal declarations,
           one integer and one integer array.  The process consists of a 
           while-loop and an integer variable declaration (loop-counter).  The 
           number of iterations of the loop is equal to the size of the array.  
           The while-loop contains one addition signal assignment statement and 
           one addition variable assignment statement to increment the 
           loop-counter.  The factor to be varied is the array size/number of 
           loop iterations.



TEST NUMBER :  199

PATHNAME :  [.BENCH.B.C.K.L3.P2]shell1.sh
            (UNIX equivalent : bench/b/c/k/l3/p2/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute subtraction
           signal assignment statements.  The model simulated is an 
           architecture consisting of a process and two signal declarations,
           one integer and one integer array.  The process consists of a 
           while-loop and an integer variable declaration (loop-counter).  The 
           number of iterations of the loop is equal to the size of the array.  
           The while-loop contains one subtraction signal assignment statement 
           and one addition variable assignment statement to increment the 
           loop-counter.  The factor to be varied is the array size/number of 
           loop iterations.



TEST NUMBER :  200

PATHNAME :  [.BENCH.B.C.K.L3.P3]shell1.sh
            (UNIX equivalent : bench/b/c/k/l3/p3/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute multiplication
           signal assignment statements.  The model simulated is an 
           architecture consisting of a process and two signal declarations,
           one integer and one integer array.  The process consists of a 
           while-loop and an integer variable declaration (loop-counter).  The 
           number of iterations of the loop is equal to the size of the array.  
           The while-loop contains one multiplication signal assignment 
           statement and one addition variable assignment statement to 
           increment the loop-counter.  The factor to be varied is the array 
           size/number of loop iterations.



TEST NUMBER :  201

PATHNAME :  [.BENCH.B.C.K.L3.P4]shell1.sh
            (UNIX equivalent : bench/b/c/k/l3/p4/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute division
           signal assignment statements.  The model simulated is an 
           architecture consisting of a process and two signal declarations,
           one integer and one integer array.  The process consists of a 
           while-loop and an integer variable declaration (loop-counter).  The 
           number of iterations of the loop is equal to the size of the array.  
           The while-loop contains one division signal assignment statement and 
           one addition variable assignment statement to increment the 
           loop-counter.  The factor to be varied is the array size/number of 
           loop iterations.



TEST NUMBER :  202

PATHNAME :  [.BENCH.B.C.T10]shell.sh
            (UNIX equivalent : bench/b/c/t10/shell.sh)

PURPOSE :  Determine the maximum length (number of characters) allowed for 
           process labels.  The model simulated is an architecture consisting 
           of a signal declaration and a process.  The process consists of a 
           logical NOT signal assignment statement.  The factor to be varied is 
           the length of the process label.



TEST NUMBER :  203

PATHNAME :  [.BENCH.B.C.T3]shell.sh
            (UNIX equivalent : bench/b/c/t3/shell.sh)

PURPOSE :  Determine the maximum length (number of characters) allowed for 
           constant identifiers.  The model simulated is an architecture
           consisting of a constant declaration, a signal declaration, and a
           signal assignment statement.  The factor to be varied is the length
           of the constant identifier.



TEST NUMBER :  204

PATHNAME :  [.BENCH.B.C.T4]shell.sh
            (UNIX equivalent : bench/b/c/t4/shell.sh)

PURPOSE :  Determine the maximum length (number of characters) allowed for a
           type identifier.  The model simulated is an architecture consisting
           of a type declaration, a signal declaration, and a signal assignment 
           statement.  The factor to be varied is the length of the type 
           identifier.



TEST NUMBER :  205

PATHNAME :  [.BENCH.B.C.T5]shell.sh
            (UNIX equivalent : bench/b/c/t5/shell.sh)

PURPOSE :  Determine the maximum length (number of characters) allowed for a
           subtype identifier.  The model simulated is an architecture 
           consisting of a subtype declaration, a signal declaration, and a 
           signal assignment statement.  The factor to be varied is the length 
           of the subtype identifier.



TEST NUMBER :  206

PATHNAME :  [.BENCH.B.C.T1A]shell.sh
            (UNIX equivalent : bench/b/c/t1a/shell.sh)

PURPOSE :  Determine the maximum length (number of characters) allowed for a
           signal identifier for a signal declared in an architecture.  The 
           model simulated is an architecture consisting of a signal declaration
           and a signal assignment statement.  The factor to be varied is the
           length of the signal identifier.



TEST NUMBER :  207

PATHNAME :  [.BENCH.B.C.T1B]shell.sh
            (UNIX equivalent : bench/b/c/t1b/shell.sh)

PURPOSE :  Determine the maximum length (number of characters) allowed for a
           signal identifier for a signal declared in a block.  The model 
           simulated is an architecture consisting of a block.  The block
           consists of a signal declaration and a signal assignment statement.  
           The factor to be varied is the length of the signal identifier.



TEST NUMBER :  208

PATHNAME :  [.BENCH.B.C.T1C]shell.sh
            (UNIX equivalent : bench/b/c/t1c/shell.sh)

PURPOSE :  Determine the maximum length (number of characters) allowed for a
           signal identifier for a signal declared in a port clause.  The model 
           simulated is a two-level hierarchy of architectures.  The lower-
           level architecture is a component in the upper-level architecture.
           The component has a port clause with one interface-signal-
           declaration.  The factor to be varied is the length of the signal 
           identifier.



TEST NUMBER :  209

PATHNAME :  [.BENCH.B.C.T2A]shell.sh
            (UNIX equivalent : bench/b/c/t2a/shell.sh)

PURPOSE :  Determine the maximum length (number of characters) allowed for a
           variable identifier of a variable declared in a process.  The
           model simulated is an architecture consisting of a process.  The
           process consists of a variable declaration and a variable assignment
           statement.  The factor to be varied is the length of the variable
           identifier.



TEST NUMBER :  210

PATHNAME :  [.BENCH.B.C.T6]shell.sh
            (UNIX equivalent : bench/b/c/t6/shell.sh)

PURPOSE :  Determine the maximum length (number of characters) allowed for a
           component identifier.  The model simulated is a two-level hierarchy 
           of architectures.  The lower-level architecture is a component in 
           the upper-level architecture.  The factor to be varied is the length 
           of the component identifier.



TEST NUMBER :  211

PATHNAME :  [.BENCH.B.C.T9]shell.sh
            (UNIX equivalent : bench/b/c/t9/shell.sh)

PURPOSE :  Determine the maximum length (number of characters) allowed for a
           block label.  The model simulated is an architecture consisting of a 
           block.  The block consists of a signal declaration and a signal 
           assignment statement.  The factor to be varied is the length of the 
           block label.



TEST NUMBER :  212

PATHNAME :  [.BENCH.A.C.H1]shell.sh
            (UNIX equivalent : bench/a/c/h1/shell.sh)

PURPOSE :  Determine the maximum number of procedure declarations/calls allowed
           in one model; try to get an idea of the simulation CPU time required
           for executing procedure calls.  The model simulated is an entity 
           consisting of a number of procedure declarations and an architecture 
           consisting of a procedure call for each declaration.  The procedure 
           consists of a variable declaration and a variable assignment 
           statement.  The factor to be varied is the number of procedure 
           declarations/calls.



TEST NUMBER :  213

PATHNAME :  [.BENCH.A.C.H2]shell.sh
            (UNIX equivalent : bench/a/c/h2/shell.sh)

PURPOSE :  Determine the maximum number of procedure declarations/calls allowed
           in one model; try to get an idea of the simulation CPU time required
           for executing procedure calls.  The model simulated is an 
           architecture consisting of a number of procedure declarations and a
           procedure call for each declaration.  The procedure consists of a 
           variable declaration and a variable assignment statement.  The 
           factor to be varied is the number of procedure declarations/calls.



TEST NUMBER :  214

PATHNAME :  [.BENCH.A.C.H3]shell.sh
            (UNIX equivalent : bench/a/c/h3/shell.sh)

PURPOSE :  Determine the maximum number of procedure declarations/calls allowed
           in a process; try to get an idea of the simulation CPU time required
           for executing procedure calls.  The model simulated is an 
           architecture consisting of a process.  The process consists of a
           number of procedure declarations and a procedure call for each 
           declaration.  The procedure consists of a variable declaration and a 
           variable assignment statement.  The factor to be varied is the 
           number of procedure declarations/calls.



TEST NUMBER :  215

PATHNAME :  [.BENCH.A.C.I1]shell.sh
            (UNIX equivalent : bench/a/c/i1/shell.sh)

PURPOSE :  Determine the maximum number of function declarations/calls allowed
           in one model; try to get an idea of the simulation CPU time required
           for executing function calls.  The model simulated is an entity 
           consisting of a number of function declarations and an architecture 
           consisting of the same number of signal declarations and a function 
           call (via a signal assignment statement) for each declaration.  The 
           function consists of a return statement.  The factor to be varied is 
           the number of function declarations/calls.



TEST NUMBER :  216

PATHNAME :  [.BENCH.A.C.I2]shell.sh
            (UNIX equivalent : bench/a/c/i2/shell.sh)

PURPOSE :  Determine the maximum number of function declarations/calls allowed
           in one model; try to get an idea of the simulation CPU time required
           for executing function calls.  The model simulated is an 
           architecture consisting of a number of function declarations, the 
           same number of signal declarations, and a function call (via signal
           assignment statement) for each function declaration.  The function 
           consists of a return statement.  The factor to be varied is the 
           number of function declarations/calls.



TEST NUMBER :  217

PATHNAME :  [.BENCH.A.C.I3]shell.sh
            (UNIX equivalent : bench/a/c/i3/shell.sh)

PURPOSE :  Determine the maximum number of function declarations/calls allowed
           in a process; try to get an idea of the simulation CPU time required
           for executing function calls.  The model simulated is an 
           architecture consisting of a process.  The process consists of a
           a variable declaration, a number of function declarations and a 
           function call (via variable assignment statement) for each variable 
           declaration.  The function consists of a return statement.  The 
           factor to be varied is the number of function declarations/calls.



TEST NUMBER :  218

PATHNAME :  [.BENCH.B.C.N]shell.sh
            (UNIX equivalent : bench/b/c/n/shell.sh)

PURPOSE :  Determine the maximum number of choices allowed in a case statement.
           The model simulated is an architecture consisting of a signal 
           declaration and a process.  The process consists of a case statement
           with a number of choices, each containing a signal assignment
           statement.  The factor to be varied is the number of choices in the
           case statement.



TEST NUMBER :  219

PATHNAME :  [.BENCH.B.C.F1.K.L1.P10]shell.sh
            (UNIX equivalent : bench/b/c/f1/k/l1/p10/shell.sh)

PURPOSE :  Determine the effect on CPU time when analyzing, model generating,
           building, and simulating the following model :  two entities/
           architectures, where one architecture is a component in the other
           architecture.  The component-level entity's port clause contains
           one bit type signal (output) and one bit_vector type signal (input).
           The component-level architecture consists of a process.  The process
           has a variable declaration and a for-loop whose number of iterations
           is equal to the size of the bit_vector in the port clause.  The for-
           loop contains a logical XOR signal assignment statement.  The top-
           level architecture consists of a bit-vector signal declaration for
           output, a number of bit_vector signal declarations for input, a
           component declaration matching the component-level entity/
           architecture, and a number of component instantiations, where the
           input signal maps to the corresponding input bit_vector signal 
           declared above, and the output signal maps to one element of the 
           output bit_vector signal declared above.  The factors to be varied 
           are the size of the input bit_vector in the port clause, and the 
           number of components in the top-level architecture/size of output 
           bit_vector signal in the top-level architecture/number of input 
           bit_vector signal declarations in the top-level architecture.



TEST NUMBER :  220

PATHNAME :  [.BENCH.B.C.F1.K.L3.P10]shell.sh
            (UNIX equivalent : bench/b/c/f1/k/l3/p10/shell.sh)

PURPOSE :  Determine the effect on CPU time when analyzing, model generating,
           building, and simulating the following model :  two entities/
           architectures, where one architecture is a component in the other
           architecture.  The component-level entity's port clause contains
           one bit type signal (output) and one bit_vector type signal (input).
           The component-level architecture consists of a process.  The process
           has two variable declarations (one is a loop-counter) and a while-
           loop whose number of iterations is equal to the size of the 
           bit_vector in the port clause.  The while-loop contains a logical 
           XOR signal assignment statement and a variable assignment statement
           to increment the loop-counter.  The top-level architecture consists 
           of a bit-vector signal declaration for output, a number of 
           bit_vector signal declarations for input, a component declaration 
           matching the component-level entity/architecture, and a number of 
           component instantiations, where the input signal maps to the 
           corresponding input bit_vector signal declared above, and the output 
           signal maps to one element of the output bit_vector signal declared 
           above.  The factors to be varied are the size of the input 
           bit_vector in the port clause, and the number of components in the 
           top-level architecture/size of output bit_vector signal in the 
           top-level architecture/number of input bit_vector signal 
           declarations in the top-level architecture.



TEST NUMBER :  221

PATHNAME :  [.BENCH.B.C.F1.K.L4.P10]shell.sh
            (UNIX equivalent : bench/b/c/f1/k/l4/p10/shell.sh)

PURPOSE :  Determine the effect on CPU time when analyzing, model generating,
           building, and simulating the following model :  two entities/
           architectures, where one architecture is a component in the other
           architecture.  The component-level entity's port clause contains
           one bit type signal (output) and one bit_vector type signal (input).
           The component-level architecture consists of a process.  The process
           has two variable declarations (one is a loop-counter) and a while-
           loop whose iteration scheme is "true".  The while-loop contains a 
           logical XOR signal assignment statement, a variable assignment 
           statement to increment the loop-counter, and an exit statement that
           limits the number of iterations to the size of the bit_vector in the
           port clause.  The top-level architecture consists of a bit-vector 
           signal declaration for output, a number of bit_vector signal 
           declarations for input, a component declaration matching the 
           component-level entity/architecture, and a number of component 
           instantiations, where the input signal maps to the corresponding
           input bit_vector signal declared above, and the output signal maps 
           to one element of the output bit_vector signal declared above.  The 
           factors to be varied are the size of the input bit_vector in the 
           port clause, and the number of components in the top-level 
           architecture/size of output bit_vector signal in the top-level 
           architecture/number of input bit_vector signal declarations in the 
           top-level architecture.



TEST NUMBER :  222

PATHNAME :  [.BENCH.B.C.F1.K.L2.P10]shell.sh
            (UNIX equivalent : bench/b/c/f1/k/l2/p10/shell.sh)

PURPOSE :  Determine the effect on CPU time when analyzing, model generating,
           building, and simulating the following model :  two entities/
           architectures, where one architecture is a component in the other
           architecture.  The component-level entity's port clause contains
           one bit type signal (output) and one bit_vector type signal (input).
           The component-level architecture consists of a process.  The process
           has a variable declaration and a for-loop whose iteration scheme is
           "1 to integer'high".  The for-loop contains a logical XOR signal 
           assignment statement and an exit statement that limits the number of
           iterations to the size of the bit_vector in the port clause.  The 
           top-level architecture consists of a bit-vector signal declaration 
           for output, a number of bit_vector signal declarations for input, a
           component declaration matching the component-level entity/
           architecture, and a number of component instantiations, where the
           input signal maps to the corresponding input bit_vector signal 
           declared above, and the output signal maps to one element of the 
           output bit_vector signal declared above.  The factors to be varied 
           are the size of the input bit_vector in the port clause, and the 
           number of components in the top-level architecture/size of output 
           bit_vector signal in the top-level architecture/number of input 
           bit_vector signal declarations in the top-level architecture.



TEST NUMBER :  223

PATHNAME :  [.BENCH.B.C.M]shell.sh
            (UNIX equivalent : bench/b/c/m/shell.sh)

PURPOSE :  Determine the maximum number of "elsif" conditions allowed in an 
           if-statement.  The model simulated is an architecture consisting
           of a signal declaration and a process.  The process consists of
           an if-statement with a number of "elsif" conditions, each containing
           a signal assignment statement.  The factor to be varied is the number
           of "elsif" conditions.



TEST NUMBER :  224

PATHNAME :  [.BENCH.A.C.I2R]shell.sh
            (UNIX equivalent : bench/a/c/i2r/shell.sh)

PURPOSE :  Determine the effect of recursive function calls on simulation CPU
           time.  The model simulated is an architecture consisting of two
           signal declarations, a function declaration, and a function call
           via a signal assignment statement.  The function contains an if-
           statement where the "if" section has a return statement and the 
           "else" section has a function call (recursive) to itself.  The factor
           to be varied is the number of recursive function call to make in one
           simulation.



TEST NUMBER :  225

PATHNAME :  [.BENCH.A.C.I1R]shell.sh
            (UNIX equivalent : bench/a/c/i1r/shell.sh)

PURPOSE :  Determine the effect of recursive function calls on simulation CPU
           time.  The model simulated is an entity consisting of a function
           declaration and an architecture consisting of two signal 
           declarations and a function call via a signal assignment statement. 
           The function contains an if-statement where the "if" section has a 
           return statement and the "else" section has a function call 
           (recursive) to itself.  The factor to be varied is the number of 
           recursive function call to make in one simulation.



TEST NUMBER :  226

PATHNAME :  [.BENCH.B.C.H1R]shell.sh
            (UNIX equivalent : bench/b/c/h1r/shell.sh)

PURPOSE :  Determine the effect of recursive procedure calls on simulation
           CPU time.  The model simulated is an entity consisting of a
           procedure declaration and an architecture consisting of a signal
           declaration and a process.  The procedure has a variable declaration
           and an if-statement, where the "if" section has a return statement 
           and the "else" section has a recursive procedure call and a variable
           assignment statement.  The process has a variable declaration, a 
           procedure call, and a signal assignment statement.  The factor to be
           varied is the number of recursive procedure calls to make in one
           simulation.



TEST NUMBER :  227

PATHNAME :  [.BENCH.B.C.H2R]shell.sh
            (UNIX equivalent : bench/b/c/h2r/shell.sh)

PURPOSE :  Determine the effect of recursive procedure calls on simulation
           CPU time.  The model simulated is an architecture consisting of a 
           procedure declaration, a signal declaration and a process.  The 
           procedure has a variable declaration and an if-statement, where the 
           "if" section has a return statement and the "else" section has a 
           recursive procedure call and a variable assignment statement.  The 
           process has a variable declaration, a procedure call, and a signal 
           assignment statement.  The factor to be varied is the number of 
           recursive procedure calls to make in one simulation.



TEST NUMBER :  228

PATHNAME :  [.BENCH.B.C.I3R]shell.sh
            (UNIX equivalent : bench/b/c/i3r/shell.sh)

PURPOSE :  Determine the effect of recursive function calls on simulation CPU
           time.  The model simulated is an architecture consisting of a signal
           declaration and a process.  The process has a function declaration
           and a function call via a signal assignment statement.  The function
           has an if-statement, where the "if" section has a return statement
           and the "else" section has a recursive function call.  The factor to
           be varied is the number of recursive function calls to make in one
           simulation.



TEST NUMBER :  229

PATHNAME :  [.BENCH.B.C.H3R]shell.sh
            (UNIX equivalent : bench/b/c/h3r/shell.sh)

PURPOSE :  Determine the effect of recursive procedure calls on simulation
           CPU time.  The model simulated is an architecture consisting of
           a signal declaration and a process.  The process consists of a
           procedure declaration, a variable declaration, a procedure call,
           and a signal assignment statement.  The procedure has an if-
           statement where the "if" section has a variable assignment statement
           and the "else" section has a recursive procedure call and a
           variable assignment statement.  The factor to be varied is the number
           of recursive procedure calls to make in one simulation.



TEST NUMBER :  230

PATHNAME :  [.BENCH.B.C.I1R]shell.sh
            (UNIX equivalent : bench/b/c/i1r/shell.sh)

PURPOSE :  Determine the effect of recursive function calls on simulation CPU
           time.  The model simulated is an entity consisting of a function
           declaration and an architecture consisting of a signal declaration
           and a process.  The function has an if-statement where the "if"
           section has a return statement and the "else" section has a recursive
           function call.  The process has a function call via a signal
           assignment statement.  The factor to be varied is the number of
           recursive function calls to make in one simulation.



TEST NUMBER :  231

PATHNAME :  [.BENCH.B.C.I2R]shell.sh
            (UNIX equivalent : bench/b/c/i2r/shell.sh)

PURPOSE :  Determine the effect of recursive function calls on simulation CPU
           time.  The model simulated is an architecture consisting of a 
           function declaration, a signal declaration, and a process.  The 
           function has an if-statement where the "if" section has a return 
           statement and the "else" section has a recursive function call.  
           The process has a function call via a signal assignment statement.  
           The factor to be varied is the number of recursive function calls to 
           make in one simulation.



TEST NUMBER :  232

PATHNAME :  [.BENCH.A.C.H1.P12]shell0.sh
            (UNIX equivalent : bench/a/c/h1/p12/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           modulo statements.  The model simulated is an entity consisting
           of a procedure declaration and an architecture consisting of a 
           procedure call.  The procedure consists of a number of integer 
           variable declarations and a modulo statement for each variable.  
           The factors to be varied are the number of variable declarations/
           modulo statements in the procedure and the value of the right 
           operand of the modulo statements.



TEST NUMBER :  233

PATHNAME :  [.BENCH.A.C.H1.P12]shell1.sh
            (UNIX equivalent : bench/a/c/h1/p12/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           modulo operations in a procedure; determine the number of 
           modulo operations allowed in one variable assignment statement of 
           a procedure.  The model simulated is an entity consisting of a
           procedure declaration and an architecture consisting of a procedure 
           call; the procedure consists of an integer variable declaration and 
           a variable assignment statement containing a number of modulo 
           operations.  The factors to be varied are the number of modulo 
           operations contained in the variable assignment statement and the
           value of the left operand in the modulo statement.



TEST NUMBER :  234

PATHNAME :  [.BENCH.A.C.H2.P12]shell0.sh
            (UNIX equivalent : bench/a/c/h2/p12/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           modulo statements.  The model simulated is an architecture
           consisting of a procedure declaration and a procedure call.  The 
           procedure consists of a number of integer variable declarations
           and a modulo statement for each variable.  The factors to be varied
           are the number of variable declarations/modulo statements in the
           procedure and the value of the right operand in the modulo 
           statements.



TEST NUMBER :  235

PATHNAME :  [.BENCH.A.C.H2.P12]shell1.sh
            (UNIX equivalent : bench/a/c/h2/p12/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           modulo operations in a procedure; determine the number of 
           modulo operations allowed in one variable assignment statement of 
           a procedure.  The model simulated is an architecture consisting of a 
           procedure declaration and a procedure call; the procedure consists 
           of an integer variable declaration and a variable assignment 
           statement containing a number of modulo operations.  The factors to 
           be varied are the number of modulo operations contained in the 
           variable assignment statement and the value of the left operand of
           the modulo statement.



TEST NUMBER :  236

PATHNAME :  [.BENCH.A.C.I1.P12]shell0.sh
            (UNIX equivalent : bench/a/c/i1/p12/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           modulo statements.  The model simulated is an entity consisting
           of a function declaration and an architecture consisting of a 
           function call.  The function consists of a number of integer 
           variable declarations and a modulo statement for each variable.  
           The factors to be varied are the number of variable declarations/
           modulo statements in the function and the value of the right operand
           in the modulo statements.



TEST NUMBER :  237

PATHNAME :  [.BENCH.A.C.I1.P12]shell1.sh
            (UNIX equivalent : bench/a/c/i1/p12/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           modulo operations in a function; determine the number of 
           modulo operations allowed in one variable assignment 
           statement of a function.  The model simulated is an entity 
           consisting of a function declaration and an architecture consisting 
           of a function call; the function consists of an integer variable 
           declaration and a variable assignment statement containing a number 
           of modulo operations.  The factors to be varied are the number of 
           modulo operations contained in the variable assignment statement
           and the value of the left operand in the modulo statement.



TEST NUMBER :  238

PATHNAME :  [.BENCH.A.C.I2.P12]shell0.sh
            (UNIX equivalent : bench/a/c/i2/p12/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           modulo statements.  The model simulated is an architecture
           consisting of a function declaration and a function call.  The 
           function consists of a number of integer variable declarations
           and a modulo statement for each variable.  The factors to be varied
           are the number of variable declarations/modulo statements in the
           function and the value of the right operand in the modulo statement.



TEST NUMBER :  239

PATHNAME :  [.BENCH.A.C.I2.P12]shell1.sh
            (UNIX equivalent : bench/a/c/i2/p12/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           modulo operations in a function; determine the number of 
           modulo operations allowed in one variable assignment 
           statement of a function.  The model simulated is an architecture 
           consisting of a function declaration and a function call; the 
           function consists of an integer variable declaration and a variable 
           assignment statement containing a number of modulo operations.  
           The factors to be varied are the number of modulo operations 
           contained in the variable assignment statement and the value of the
           left operand in the modulo statement.



TEST NUMBER :  240

PATHNAME :  [.BENCH.A.C.P12]shell0.sh
            (UNIX equivalent : bench/a/c/p12/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute modulo
           operations on signals.  The model simulated consists of a number of
           signal declarations and one modulo signal assignment statement
           for each signal.  The factors to be varied are the number of signal
           declarations/number of modulo signal assignment statements, the
           value of the right operand in the modulo statement, and the length
           of time (in ns) to simulate the model.



TEST NUMBER :  241

PATHNAME :  [.BENCH.A.C.P12]shell1.sh
            (UNIX equivalent : bench/a/c/p12/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to perform modulo
           operations on a signal; determine the number of modulo operations
           allowed in one signal assignment statement.  The model simulated is 
           an architecture consisting of an integer signal declaration and a 
           signal assignment statement containing a number of modulo 
           operations.  The factors to be varied are the number of modulo 
           operations contained in the signal assignment statement, the value
           of the right operands in the modulo statement, and the length of time
           (in ns) to simulate the model.



TEST NUMBER :  242

PATHNAME :  [.BENCH.B.C.K.L1.P12]shell0.sh
            (UNIX equivalent : bench/b/c/k/l1/p12/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           modulo assignment statements.  The model simulated is an 
           architecture consisting of a number of processes.  Each process
           consists of an integer array variable declaration and a for-loop.
           The number of iterations of the loop is equal to the size of the 
           array.  The for-loop contains a variable modulo assignment 
           statement.  The factors to be varied are the number of processes,
           the array size/number of loop iterations, and the value of the left
           operand in the modulo statement.



TEST NUMBER :  243

PATHNAME :  [.BENCH.B.C.K.L1.P12]shell1.sh
            (UNIX equivalent : bench/b/c/k/l1/p12/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute modulo
           signal assignment statements.  The model simulated is an 
           architecture consisting of a process and two signal declarations,
           one integer and one integer array.  The process consists of a 
           for-loop.  The number of iterations of the loop is equal to the 
           size of the array.  The for-loop contains a modulo signal 
           assignment statement.  The factors to be varied are the array size/
           number of loop iterations and the value of the left operand in the
           modulo statement.



TEST NUMBER :  244

PATHNAME :  [.BENCH.B.C.K.L3.P12]shell0.sh
            (UNIX equivalent : bench/b/c/k/l3/p12/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition
           and modulo variable assignment statements.  The model simulated 
           is an architecture consisting of a process.  The process consists of
           two integer variable declarations (one is a loop-counter), one
           integer array variable declaration, and a while-loop.  The number of
           iterations of the loop is equal to the size of the array.  The
           while-loop contains an addition variable assignment statement to 
           increment the loop-counter and a modulo variable assignment
           statement.  The factors to be varied are the array size/number of 
           loop iterations and the value of the left operand in the modulo
           statement.



TEST NUMBER :  245

PATHNAME :  [.BENCH.B.C.K.L3.P12]shell1.sh
            (UNIX equivalent : bench/b/c/k/l3/p12/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute modulo
           signal assignment statements.  The model simulated is an 
           architecture consisting of a process and two signal declarations,
           one integer and one integer array.  The process consists of a 
           while-loop and an integer variable declaration (loop-counter).  The 
           number of iterations of the loop is equal to the size of the array.  
           The while-loop contains one modulo signal assignment statement 
           and one addition variable assignment statement to increment the 
           loop-counter.  The factors to be varied are the array size/number of 
           loop iterations and the value of the left operand in the modulo
           statement.



TEST NUMBER :  246

PATHNAME :  [.BENCH.B.C.P12]shell0.sh
            (UNIX equivalent : bench/b/c/p12/shell0.sh)

PURPOSE :  Determine the simulation CPU time required for executing modulo
           operations on variables.  The model simulated is an architecture
           consisting of a number of processes; each process consists of a 
           number of variable declarations and one modulo variable assignment 
           statement for each variable.  The factors to be varied are the 
           number of processes, the number of variable declarations/number of 
           modulo variable assignment statements, and the value of the left
           operand in the modulo statements.



TEST NUMBER :  247

PATHNAME :  [.BENCH.B.C.P12]shell1.sh
            (UNIX equivalent : bench/b/c/p12/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute modulo
           operations on variables;  determine the number of modulo
           operations allowed in one variable assignment statement.  The model 
           simulated is an architecture consisting of a number of processes; 
           each process consists of a variable declaration and a variable 
           assignment statement containing a number of modulo operations.  
           The factors to be varied are the number of processes, the number 
           of modulo operations in the variable assignment statement, and the
           value of the left operand in the modulo statement.



TEST NUMBER :  248

PATHNAME :  [.BENCH.A.C.H1.P13]shell0.sh
            (UNIX equivalent : bench/a/c/h1/p13/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           remainder statements.  The model simulated is an entity consisting
           of a procedure declaration and an architecture consisting of a 
           procedure call.  The procedure consists of a number of integer 
           variable declarations and a remainder statement for each variable.  
           The factors to be varied are the number of variable declarations/
           remainder statements in the procedure and the value of the right 
           operand of the remainder statements.



TEST NUMBER :  249

PATHNAME :  [.BENCH.A.C.H1.P13]shell1.sh
            (UNIX equivalent : bench/a/c/h1/p13/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           remainder operations in a procedure; determine the number of 
           remainder operations allowed in one variable assignment statement of 
           a procedure.  The model simulated is an entity consisting of a
           procedure declaration and an architecture consisting of a procedure 
           call; the procedure consists of an integer variable declaration and 
           a variable assignment statement containing a number of remainder 
           operations.  The factors to be varied are the number of remainder 
           operations contained in the variable assignment statement and the
           value of the left operand in the remainder statement.



TEST NUMBER :  250

PATHNAME :  [.BENCH.A.C.H2.P13]shell0.sh
            (UNIX equivalent : bench/a/c/h2/p13/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           remainder statements.  The model simulated is an architecture
           consisting of a procedure declaration and a procedure call.  The 
           procedure consists of a number of integer variable declarations
           and a remainder statement for each variable.  The factors to be 
           varied are the number of variable declarations/remainder statements 
           in the procedure and the value of the right operand in the remainder 
           statements.



TEST NUMBER :  251

PATHNAME :  [.BENCH.A.C.H2.P13]shell1.sh
            (UNIX equivalent : bench/a/c/h2/p13/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           remainder operations in a procedure; determine the number of 
           remainder operations allowed in one variable assignment statement of 
           a procedure.  The model simulated is an architecture consisting of a 
           procedure declaration and a procedure call; the procedure consists 
           of an integer variable declaration and a variable assignment 
           statement containing a number of remainder operations.  The factors 
           to be varied are the number of remainder operations contained in the 
           variable assignment statement and the value of the left operand of
           the remainder statement.



TEST NUMBER :  252

PATHNAME :  [.BENCH.A.C.I1.P13]shell0.sh
            (UNIX equivalent : bench/a/c/i1/p13/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           remainder statements.  The model simulated is an entity consisting
           of a function declaration and an architecture consisting of a 
           function call.  The function consists of a number of integer 
           variable declarations and a remainder statement for each variable.  
           The factors to be varied are the number of variable declarations/
           remainder statements in the function and the value of the right 
           operand in the remainder statements.



TEST NUMBER :  253

PATHNAME :  [.BENCH.A.C.I1.P13]shell1.sh
            (UNIX equivalent : bench/a/c/i1/p13/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           remainder operations in a function; determine the number of 
           remainder operations allowed in one variable assignment 
           statement of a function.  The model simulated is an entity 
           consisting of a function declaration and an architecture consisting 
           of a function call; the function consists of an integer variable 
           declaration and a variable assignment statement containing a number 
           of remainder operations.  The factors to be varied are the number of 
           remainder operations contained in the variable assignment statement
           and the value of the left operand in the remainder statement.



TEST NUMBER :  254

PATHNAME :  [.BENCH.A.C.I2.P13]shell0.sh
            (UNIX equivalent : bench/a/c/i2/p13/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           remainder statements.  The model simulated is an architecture
           consisting of a function declaration and a function call.  The 
           function consists of a number of integer variable declarations
           and a remainder statement for each variable.  The factors to be 
           varied are the number of variable declarations/remainder statements 
           in the function and the value of the right operand in the remainder 
           statement.



TEST NUMBER :  255

PATHNAME :  [.BENCH.A.C.I2.P13]shell1.sh
            (UNIX equivalent : bench/a/c/i2/p13/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           remainder operations in a function; determine the number of 
           remainder operations allowed in one variable assignment 
           statement of a function.  The model simulated is an architecture 
           consisting of a function declaration and a function call; the 
           function consists of an integer variable declaration and a variable 
           assignment statement containing a number of remainder operations.  
           The factors to be varied are the number of remainder operations 
           contained in the variable assignment statement and the value of the
           left operand in the remainder statement.



TEST NUMBER :  256

PATHNAME :  [.BENCH.A.C.P13]shell0.sh
            (UNIX equivalent : bench/a/c/p13/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute remainder
           operations on signals.  The model simulated consists of a number of
           signal declarations and one remainder signal assignment statement
           for each signal.  The factors to be varied are the number of signal
           declarations/number of remainder signal assignment statements, the
           value of the right operand in the remainder statement, and the length
           of time (in ns) to simulate the model.



TEST NUMBER :  257

PATHNAME :  [.BENCH.A.C.P13]shell1.sh
            (UNIX equivalent : bench/a/c/p13/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to perform remainder
           operations on a signal; determine the number of remainder operations
           allowed in one signal assignment statement.  The model simulated is 
           an architecture consisting of an integer signal declaration and a 
           signal assignment statement containing a number of remainder 
           operations.  The factors to be varied are the number of remainder 
           operations contained in the signal assignment statement, the value
           of the left operand in the remainder statement, and the length of 
           time (in ns) to simulate the model.



TEST NUMBER :  258

PATHNAME :  [.BENCH.B.C.K.L1.P13]shell0.sh
            (UNIX equivalent : bench/b/c/k/l1/p13/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           remainder assignment statements.  The model simulated is an 
           architecture consisting of a number of processes.  Each process
           consists of an integer array variable declaration and a for-loop.
           The number of iterations of the loop is equal to the size of the 
           array.  The for-loop contains a variable remainder assignment 
           statement.  The factors to be varied are the number of processes,
           the array size/number of loop iterations, and the value of the left
           operand in the remainder statement.



TEST NUMBER :  259

PATHNAME :  [.BENCH.B.C.K.L1.P13]shell1.sh
            (UNIX equivalent : bench/b/c/k/l1/p13/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute remainder
           signal assignment statements.  The model simulated is an 
           architecture consisting of a process and two signal declarations,
           one integer and one integer array.  The process consists of a 
           for-loop.  The number of iterations of the loop is equal to the 
           size of the array.  The for-loop contains a remainder signal 
           assignment statement.  The factors to be varied are the array size/
           number of loop iterations and the value of the left operand in the
           remainder statement.



TEST NUMBER :  260

PATHNAME :  [.BENCH.B.C.K.L3.P13]shell0.sh
            (UNIX equivalent : bench/b/c/k/l3/p13/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition
           and remainder variable assignment statements.  The model simulated 
           is an architecture consisting of a process.  The process consists of
           two integer variable declarations (one is a loop-counter), one
           integer array variable declaration, and a while-loop.  The number of
           iterations of the loop is equal to the size of the array.  The
           while-loop contains an addition variable assignment statement to 
           increment the loop-counter and a remainder variable assignment
           statement.  The factors to be varied are the array size/number of 
           loop iterations and the value of the left operand in the remainder
           statement.



TEST NUMBER :  261

PATHNAME :  [.BENCH.B.C.K.L3.P13]shell1.sh
            (UNIX equivalent : bench/b/c/k/l3/p13/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute remainder
           signal assignment statements.  The model simulated is an 
           architecture consisting of a process and two signal declarations,
           one integer and one integer array.  The process consists of a 
           while-loop and an integer variable declaration (loop-counter).  The 
           number of iterations of the loop is equal to the size of the array.  
           The while-loop contains one remainder signal assignment statement 
           and one addition variable assignment statement to increment the 
           loop-counter.  The factors to be varied are the array size/number of 
           loop iterations and the value of the left operand in the remainder
           statement.



TEST NUMBER :  262

PATHNAME :  [.BENCH.B.C.P13]shell0.sh
            (UNIX equivalent : bench/b/c/p13/shell0.sh)

PURPOSE :  Determine the simulation CPU time required for executing remainder
           operations on variables.  The model simulated is an architecture
           consisting of a number of processes; each process consists of a 
           number of variable declarations and one remainder variable 
           assignment statement for each variable.  The factors to be varied 
           are the number of processes, the number of variable declarations/
           number of remainder variable assignment statements, and the value of 
           the right operand in the remainder statements.



TEST NUMBER :  263

PATHNAME :  [.BENCH.B.C.P13]shell1.sh
            (UNIX equivalent : bench/b/c/p13/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute remainder
           operations on variables;  determine the number of remainder
           operations allowed in one variable assignment statement.  The model 
           simulated is an architecture consisting of a number of processes; 
           each process consists of a variable declaration and a variable 
           assignment statement containing a number of remainder operations.  
           The factors to be varied are the number of processes, the number 
           of remainder operations in the variable assignment statement, and the
           value of the left operand in the remainder statement.



TEST NUMBER :  264

PATHNAME :  [.BENCH.A.C.H1.P14]shell0.sh
            (UNIX equivalent : bench/a/c/h1/p14/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           absolute value statements.  The model simulated is an entity 
           consisting of a procedure declaration and an architecture consisting 
           of a procedure call.  The procedure consists of a number of integer 
           variable declarations and an absolute value statement for each 
           variable.  The factor to be varied is the number of variable 
           declarations/absolute value statements in the procedure.



TEST NUMBER :  265

PATHNAME :  [.BENCH.A.C.H1.P14]shell1.sh
            (UNIX equivalent : bench/a/c/h1/p14/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           absolute value statements.  The model simulated is an entity 
           consisting of a procedure declaration and an architecture consisting 
           of a procedure call.  The procedure consists of a number of 
           floating-point variable declarations and an absolute value statement 
           for each variable.  The factor to be varied is the number of 
           variable declarations/absolute value statements in the procedure.



TEST NUMBER :  266

PATHNAME :  [.BENCH.A.C.H2.P14]shell0.sh
            (UNIX equivalent : bench/a/c/h2/p14/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           absolute value statements.  The model simulated is an architecture
           consisting of a procedure declaration and a procedure call.  The 
           procedure consists of a number of integer variable declarations
           and an absolute value statement for each variable.  The factor to be 
           varied is the number of variable declarations/absolute value 
           statements in the procedure.



TEST NUMBER :  267

PATHNAME :  [.BENCH.A.C.H2.P14]shell1.sh
            (UNIX equivalent : bench/a/c/h2/p14/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           absolute value statements.  The model simulated is an architecture
           consisting of a procedure declaration and a procedure call.  The 
           procedure consists of a number of floating-point variable 
           declarations and an absolute value statement for each variable.  The 
           factor to be varied is the number of variable declarations/absolute 
           value statements in the procedure.



TEST NUMBER :  268

PATHNAME :  [.BENCH.A.C.I1.P14]shell0.sh
            (UNIX equivalent : bench/a/c/i1/p14/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           absolute value statements.  The model simulated is an entity 
           consisting of a function declaration and an architecture consisting 
           of a function call.  The function consists of a number of integer 
           variable declarations and an absolute value statement for each 
           variable.  The factor to be varied is the number of variable 
           declarations/absolute value statements in the function.



TEST NUMBER :  269

PATHNAME :  [.BENCH.A.C.I1.P14]shell1.sh
            (UNIX equivalent : bench/a/c/i1/p14/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           absolute value statements.  The model simulated is an entity 
           consisting of a function declaration and an architecture consisting 
           of a function call.  The function consists of a number of 
           floating-point variable declarations and an absolute value statement 
           for each variable.  The factor to be varied is the number of 
           variable declarations/absolute value statements in the function.



TEST NUMBER :  270

PATHNAME :  [.BENCH.A.C.I2.P14]shell0.sh
            (UNIX equivalent : bench/a/c/i2/p14/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           absolute value statements.  The model simulated is an architecture
           consisting of a function declaration and a function call.  The 
           function consists of a number of integer variable declarations
           and an absolute value statement for each variable.  The factor to be 
           varied is the number of variable declarations/absolute value 
           statements in the function.



TEST NUMBER :  271

PATHNAME :  [.BENCH.A.C.I2.P14]shell1.sh
            (UNIX equivalent : bench/a/c/i2/p14/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           absolute value statements.  The model simulated is an architecture
           consisting of a function declaration and a function call.  The 
           function consists of a number of floating-point variable declarations
           and an absolute value statement for each variable.  The factor to be 
           varied is the number of variable declarations/absolute value 
           statements in the function.



TEST NUMBER :  272

PATHNAME :  [.BENCH.A.C.P14]shell0.sh
            (UNIX equivalent : bench/a/c/p14/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute absolute value
           operations on signals.  The model simulated consists of a number of
           integer signal declarations and one absolute value signal assignment 
           statement for each signal.  The factor to be varied is the number of 
           signal declarations/number of absolute value signal assignment 
           statements.



TEST NUMBER :  273

PATHNAME :  [.BENCH.A.C.P14]shell1.sh
            (UNIX equivalent : bench/a/c/p14/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute absolute value
           operations on signals.  The model simulated consists of a number of
           floating-point signal declarations and one absolute value signal 
           assignment statement for each signal.  The factor to be varied is 
           the number of signal declarations/number of absolute value signal 
           assignment statements.



TEST NUMBER :  274

PATHNAME :  [.BENCH.B.C.K.L1.P14]shell0.sh
            (UNIX equivalent : bench/b/c/k/l1/p14/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           absolute value assignment statements.  The model simulated is an 
           architecture consisting of a number of processes.  Each process
           consists of an integer array variable declaration and a for-loop.
           The number of iterations of the loop is equal to the size of the 
           array.  The for-loop contains a variable absolute value assignment 
           statement.  The factors to be varied are the number of processes and
           the array size/number of loop iterations.



TEST NUMBER :  275

PATHNAME :  [.BENCH.B.C.K.L1.P14]shell1.sh
            (UNIX equivalent : bench/b/c/k/l1/p14/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           absolute value assignment statements.  The model simulated is an 
           architecture consisting of a number of processes.  Each process
           consists of an floating-point array variable declaration and a 
           for-loop.  The number of iterations of the loop is equal to the size 
           of the array.  The for-loop contains a variable absolute value 
           assignment statement.  The factors to be varied are the number of 
           processes and the array size/number of loop iterations.



TEST NUMBER :  276

PATHNAME :  [.BENCH.B.C.K.L1.P14]shell2.sh
            (UNIX equivalent : bench/b/c/k/l1/p14/shell2.sh)

PURPOSE :  Determine the simulation CPU time required to execute signal
           absolute value assignment statements.  The model simulated is an 
           architecture consisting of a number of integer array signal 
           declarations and the same number of processes.  Each process 
           consists of a for-loop.  The number of iterations of the loop is 
           equal to the size of the array.  The for-loop contains a signal 
           absolute value assignment statement.  The factors to be varied are 
           the number of processes/number of array declarations and the array 
           size/number of loop iterations.



TEST NUMBER :  277

PATHNAME :  [.BENCH.B.C.K.L1.P14]shell3.sh
            (UNIX equivalent : bench/b/c/k/l1/p14/shell3.sh)

PURPOSE :  Determine the simulation CPU time required to execute signal
           absolute value assignment statements.  The model simulated is an 
           architecture consisting of a number of floating-point array signal 
           declarations and the same number of processes.  Each process 
           consists of a for-loop.  The number of iterations of the loop is 
           equal to the size of the array.  The for-loop contains a signal 
           absolute value assignment statement.  The factors to be varied are 
           the number of processes/number of array declarations and the array 
           size/number of loop iterations.



TEST NUMBER :  278

PATHNAME :  [.BENCH.B.C.K.L3.P14]shell0.sh
            (UNIX equivalent : bench/b/c/k/l3/p14/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition
           and absolute value variable assignment statements.  The model 
           simulated is an architecture consisting of a process.  The process 
           consists of one integer variable declaration (loop-counter), one
           integer array variable declaration, and a while-loop.  The number of
           iterations of the loop is equal to the size of the array.  The
           while-loop contains an addition variable assignment statement to 
           increment the loop-counter and an absolute value variable assignment
           statement.  The factors to be varied are the array size/number of 
           loop iterations and the number of processes.



TEST NUMBER :  279

PATHNAME :  [.BENCH.B.C.K.L3.P14]shell1.sh
            (UNIX equivalent : bench/b/c/k/l3/p14/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition
           and absolute value variable assignment statements.  The model 
           simulated is an architecture consisting of a process.  The process 
           consists of one integer variable declaration (loop-counter), one
           floating-point array variable declaration, one floating-point 
           constant, and a while-loop.  The number of iterations of the loop is 
           equal to the size of the array.  The while-loop contains an addition 
           variable assignment statement to increment the loop-counter and an 
           absolute value variable assignment statement.  The factors to be 
           varied are the array size/number of loop iterations and the number 
           of processes.



TEST NUMBER :  280

PATHNAME :  [.BENCH.B.C.K.L3.P14]shell2.sh
            (UNIX equivalent : bench/b/c/k/l3/p14/shell2.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition
           variable assignment statements and absolute value signal assignment 
           statements.  The model simulated is an architecture consisting of a 
           number of processes and the same number of integer array signal 
           declarations.  Each process consists of one integer variable 
           declaration (loop-counter) and a while-loop.  The number of 
           iterations of the loop is equal to the size of the array.  The 
           while-loop contains an addition variable assignment statement to 
           increment the loop-counter and an absolute value signal assignment 
           statement.  The factors to be varied are the array size/number of 
           loop iterations and the number of processes/number of array 
           declarations.



TEST NUMBER :  281

PATHNAME :  [.BENCH.B.C.K.L3.P14]shell3.sh
            (UNIX equivalent : bench/b/c/k/l3/p14/shell3.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition
           variable assignment statements and absolute value signal assignment 
           statements.  The model simulated is an architecture consisting of a 
           number of processes and the same number of floating-point array 
           signal declarations.  Each process consists of one integer variable 
           declaration (loop-counter), a floating-point constant, and a 
           while-loop.  The number of iterations of the loop is equal to the 
           size of the array.  The while-loop contains an addition variable 
           assignment statement to increment the loop-counter and an absolute 
           value signal assignment statement.  The factors to be varied are the 
           array size/number of loop iterations and the number of processes/
           number of array declarations.



TEST NUMBER :  282

PATHNAME :  [.BENCH.B.C.P14]shell0.sh
            (UNIX equivalent : bench/b/c/p14/shell0.sh)

PURPOSE :  Determine the simulation CPU time required for executing absolute
           value operations on variables.  The model simulated is an 
           architecture consisting of a number of processes; each process 
           consists of a number of integer variable declarations and one 
           absolute value variable assignment statement for each variable.  The 
           factors to be varied are the number of processes and the number of 
           variable declarations/number of absolute value variable assignment 
           statements.



TEST NUMBER :  283

PATHNAME :  [.BENCH.B.C.P14]shell1.sh
            (UNIX equivalent : bench/b/c/p14/shell1.sh)

PURPOSE :  Determine the simulation CPU time required for executing absolute
           value operations on variables.  The model simulated is an 
           architecture consisting of a number of processes; each process 
           consists of a number of floating-point variable declarations and one 
           absolute value variable assignment statement for each variable.  The 
           factors to be varied are the number of processes and the number of 
           variable declarations/number of absolute value variable assignment 
           statements.



TEST NUMBER :  284

PATHNAME :  [.BENCH.B.C.P14]shell2.sh
            (UNIX equivalent : bench/b/c/p14/shell2.sh)

PURPOSE :  Determine the simulation CPU time required for executing absolute
           value operations on signals.  The model simulated is an architecture 
           consisting of a process and a number of integer signal declarations; 
           the process consists of one absolute value signal assignment 
           statement for each signal.  The factor to be varied is the number of 
           signal declarations/number of absolute value signal assignment 
           statements.



TEST NUMBER :  285

PATHNAME :  [.BENCH.B.C.P14]shell3.sh
            (UNIX equivalent : bench/b/c/p14/shell3.sh)

PURPOSE :  Determine the simulation CPU time required for executing absolute
           value operations on signals.  The model simulated is an architecture 
           consisting of a process and a number of floating-point signal 
           declarations; the process consists of one absolute value signal 
           assignment statement for each signal.  The factor to be varied is 
           the number of signal declarations/number of absolute value signal 
           assignment statements.



TEST NUMBER :  286

PATHNAME :  [.BENCH.A.C.H1.P15]shell0.sh
            (UNIX equivalent : bench/a/c/h1/p15/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           exponentiation statements.  The model simulated is an entity 
           consisting of a procedure declaration and an architecture consisting 
           of a procedure call.  The procedure consists of a number of integer 
           variable declarations and an exponentiation statement for each 
           variable.  The factors to be varied are the number of variable 
           declarations/exponentiation statements in the procedure and the
           value of the exponent.



TEST NUMBER :  287

PATHNAME :  [.BENCH.A.C.H1.P15]shell1.sh
            (UNIX equivalent : bench/a/c/h1/p15/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           exponentiation statements.  The model simulated is an entity 
           consisting of a procedure declaration and an architecture consisting 
           of a procedure call.  The procedure consists of a number of 
           floating-point variable declarations and an exponentiation statement 
           for each variable.  The factors to be varied are the number of 
           variable declarations/exponentiation statements in the procedure and
           the value of the exponent.



TEST NUMBER :  288

PATHNAME :  [.BENCH.A.C.H2.P15]shell0.sh
            (UNIX equivalent : bench/a/c/h2/p15/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           exponentiation statements.  The model simulated is an architecture
           consisting of a procedure declaration and a procedure call.  The 
           procedure consists of a number of integer variable declarations
           and an exponentiation statement for each variable.  The factors to 
           be varied are the number of variable declarations/exponentiation 
           statements in the procedure and the value of the exponent.



TEST NUMBER :  289

PATHNAME :  [.BENCH.A.C.H2.P15]shell1.sh
            (UNIX equivalent : bench/a/c/h2/p15/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           exponentiation statements.  The model simulated is an architecture
           consisting of a procedure declaration and a procedure call.  The 
           procedure consists of a number of floating-point variable 
           declarations and an exponentiation statement for each variable.  The 
           factors to be varied are the number of variable declarations/ 
           exponentiation statements in the procedure and the value of the
           exponent.



TEST NUMBER :  290

PATHNAME :  [.BENCH.A.C.I1.P15]shell0.sh
            (UNIX equivalent : bench/a/c/i1/p15/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           exponentiation statements.  The model simulated is an entity 
           consisting of a function declaration and an architecture consisting 
           of a function call.  The function consists of a number of integer 
           variable declarations and an exponentiation statement for each 
           variable.  The factors to be varied are the number of variable 
           declarations/exponentiation statements in the function and the value
           of the exponent.



TEST NUMBER :  291

PATHNAME :  [.BENCH.A.C.I1.P15]shell1.sh
            (UNIX equivalent : bench/a/c/i1/p15/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           exponentiation statements.  The model simulated is an entity 
           consisting of a function declaration and an architecture consisting 
           of a function call.  The function consists of a number of 
           floating-point variable declarations and an exponentiation statement 
           for each variable.  The factors to be varied are the number of 
           variable declarations/exponentiation statements in the function and
           the value of the exponent.



TEST NUMBER :  292

PATHNAME :  [.BENCH.A.C.I2.P15]shell0.sh
            (UNIX equivalent : bench/a/c/i2/p15/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           exponentiation statements.  The model simulated is an architecture
           consisting of a function declaration and a function call.  The 
           function consists of a number of integer variable declarations
           and an exponentiation statement for each variable.  The factors to 
           be varied are the number of variable declarations/exponentiation 
           statements in the function and the value of the exponent.



TEST NUMBER :  293

PATHNAME :  [.BENCH.A.C.I2.P15]shell1.sh
            (UNIX equivalent : bench/a/c/i2/p15/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           exponentiation statements.  The model simulated is an architecture
           consisting of a function declaration and a function call.  The 
           function consists of a number of floating-point variable declarations
           and an exponentiation statement for each variable.  The factors to 
           be varied are the number of variable declarations/exponentiation 
           statements in the function and the value of the exponent.



TEST NUMBER :  294

PATHNAME :  [.BENCH.A.C.P15]shell0.sh
            (UNIX equivalent : bench/a/c/p15/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute exponentiation
           operations on signals.  The model simulated consists of a number of
           integer signal declarations and one exponentiation signal assignment 
           statement for each signal.  The factors to be varied are the number 
           of signal declarations/number of exponentiation signal assignment 
           statements and the value of the exponent.



TEST NUMBER :  295

PATHNAME :  [.BENCH.A.C.P15]shell1.sh
            (UNIX equivalent : bench/a/c/p15/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute exponentiation
           operations on signals.  The model simulated consists of a number of
           floating-point signal declarations and one exponentiation signal 
           assignment statement for each signal.  The factors to be varied are 
           the number of signal declarations/number of exponentiation signal 
           assignment statements and the value of the exponent.



TEST NUMBER :  296

PATHNAME :  [.BENCH.B.C.K.L1.P15]shell0.sh
            (UNIX equivalent : bench/b/c/k/l1/p15/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           exponentiation assignment statements.  The model simulated is an 
           architecture consisting of a number of processes.  Each process
           consists of an integer array variable declaration and a for-loop.
           The number of iterations of the loop is equal to the size of the 
           array.  The for-loop contains a variable exponentiation assignment 
           statement.  The factors to be varied are the number of processes, 
           the value of the exponent, and the array size/number of loop 
           iterations.



TEST NUMBER :  297

PATHNAME :  [.BENCH.B.C.K.L1.P15]shell1.sh
            (UNIX equivalent : bench/b/c/k/l1/p15/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute variable
           exponentiation assignment statements.  The model simulated is an 
           architecture consisting of a number of processes.  Each process
           consists of an floating-point array variable declaration and a 
           for-loop.  The number of iterations of the loop is equal to the size 
           of the array.  The for-loop contains a variable exponentiation 
           assignment statement.  The factors to be varied are the number of 
           processes, the value of the exponent, and the array size/number of 
           loop iterations.



TEST NUMBER :  298

PATHNAME :  [.BENCH.B.C.K.L1.P15]shell2.sh
            (UNIX equivalent : bench/b/c/k/l1/p15/shell2.sh)

PURPOSE :  Determine the simulation CPU time required to execute signal
           exponentiation assignment statements.  The model simulated is an 
           architecture consisting of a number of integer array signal 
           declarations and the same number of processes.  Each process 
           consists of a for-loop.  The number of iterations of the loop is 
           equal to the size of the array.  The for-loop contains a signal 
           exponentiation assignment statement.  The factors to be varied are 
           the number of processes/number of array declarations, the value of
           the exponent, and the array size/number of loop iterations.



TEST NUMBER :  299

PATHNAME :  [.BENCH.B.C.K.L1.P15]shell3.sh
            (UNIX equivalent : bench/b/c/k/l1/p15/shell3.sh)

PURPOSE :  Determine the simulation CPU time required to execute signal
           exponentiation assignment statements.  The model simulated is an 
           architecture consisting of a number of floating-point array signal 
           declarations and the same number of processes.  Each process 
           consists of a for-loop.  The number of iterations of the loop is 
           equal to the size of the array.  The for-loop contains a signal 
           exponentiation assignment statement.  The factors to be varied are 
           the number of processes/number of array declarations, the value of 
           the exponent, and the array size/number of loop iterations.



TEST NUMBER :  300

PATHNAME :  [.BENCH.B.C.K.L3.P15]shell0.sh
            (UNIX equivalent : bench/b/c/k/l3/p15/shell0.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition
           and exponentiation variable assignment statements.  The model 
           simulated is an architecture consisting of a process.  The process 
           consists of one integer variable declaration (loop-counter), one
           integer array variable declaration, and a while-loop.  The number of
           iterations of the loop is equal to the size of the array.  The
           while-loop contains an addition variable assignment statement to 
           increment the loop-counter and an exponentiation variable assignment
           statement.  The factors to be varied are the array size/number of 
           loop iterations, the value of the exponent, and the number of 
           processes.



TEST NUMBER :  301

PATHNAME :  [.BENCH.B.C.K.L3.P15]shell1.sh
            (UNIX equivalent : bench/b/c/k/l3/p15/shell1.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition
           and exponentiation variable assignment statements.  The model 
           simulated is an architecture consisting of a process.  The process 
           consists of one integer variable declaration (loop-counter), one
           floating-point array variable declaration, one floating-point 
           constant, and a while-loop.  The number of iterations of the loop is 
           equal to the size of the array.  The while-loop contains an addition 
           variable assignment statement to increment the loop-counter and an 
           exponentiation variable assignment statement.  The factors to be 
           varied are the array size/number of loop iterations, the value of 
           the exponent, and the number of processes.



TEST NUMBER :  302

PATHNAME :  [.BENCH.B.C.K.L3.P15]shell2.sh
            (UNIX equivalent : bench/b/c/k/l3/p15/shell2.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition
           variable assignment statements and exponentiation signal assignment 
           statements.  The model simulated is an architecture consisting of a 
           number of process and the same number of integer array signal 
           declarations.  Each process consists of one integer variable 
           declaration (loop-counter) and a while-loop.  The number of 
           iterations of the loop is equal to the size of the array.  The 
           while-loop contains an addition variable assignment statement to 
           increment the loop-counter and an exponentiation signal assignment 
           statement.  The factors to be varied are the array size/number of 
           loop iterations, the value of the exponent, and the number of 
           processes/number of array declarations.



TEST NUMBER :  303

PATHNAME :  [.BENCH.B.C.K.L3.P15]shell3.sh
            (UNIX equivalent : bench/b/c/k/l3/p15/shell3.sh)

PURPOSE :  Determine the simulation CPU time required to execute addition
           variable assignment statements and exponentiation signal assignment 
           statements.  The model simulated is an architecture consisting of a 
           number of processes and the same number of floating-point array 
           signal declarations.  Each process consists of one integer variable 
           declaration (loop-counter) and a while-loop.  The number of 
           iterations of the loop is equal to the size of the array.  The 
           while-loop contains an addition variable assignment statement to 
           increment the loop-counter and an exponentiation signal assignment 
           statement.  The factors to be varied are the array size/number of 
           loop iterations, the value of the exponent, and the number of 
           processes/number of array declarations.



TEST NUMBER :  304

PATHNAME :  [.BENCH.B.C.P15]shell0.sh
            (UNIX equivalent : bench/b/c/p15/shell0.sh)

PURPOSE :  Determine the simulation CPU time required for executing 
           exponentiation operations on variables.  The model simulated is an 
           architecture consisting of a number of processes; each process 
           consists of a number of integer variable declarations and one 
           exponentiation variable assignment statement for each variable.  The 
           factors to be varied are the number of processes, the value of the 
           exponent, and the number of variable declarations/number of 
           exponentiation variable assignment statements.



TEST NUMBER :  305

PATHNAME :  [.BENCH.B.C.P15]shell1.sh
            (UNIX equivalent : bench/b/c/p15/shell1.sh)

PURPOSE :  Determine the simulation CPU time required for executing 
           exponentiation operations on variables.  The model simulated is an 
           architecture consisting of a number of processes; each process 
           consists of a number of floating-point variable declarations and one 
           exponentiation variable assignment statement for each variable.  The 
           factors to be varied are the number of processes, the value of the
           exponent, and the number of variable declarations/number of 
           exponentiation variable assignment statements.



TEST NUMBER :  306

PATHNAME :  [.BENCH.B.C.P15]shell2.sh
            (UNIX equivalent : bench/b/c/p15/shell2.sh)

PURPOSE :  Determine the simulation CPU time required for executing 
           exponentiation operations on signals.  The model simulated is an 
           architecture consisting of a process and a number of integer signal 
           declarations; the process consists of one exponentiation signal 
           assignment statement for each signal.  The factors to be varied are 
           the value of the exponent and the number of signal declarations/
           number of exponentiation signal assignment statements.



TEST NUMBER :  307

PATHNAME :  [.BENCH.B.C.P15]shell3.sh
            (UNIX equivalent : bench/b/c/p15/shell3.sh)

PURPOSE :  Determine the simulation CPU time required for executing 
           exponentiation operations on signals.  The model simulated is an 
           architecture consisting of a process and a number of floating-point 
           signal declarations; the process consists of one exponentiation 
           signal assignment statement for each signal.  The factors to be 
           varied are the value of the exponent and the number of signal 
           declarations/number of exponentiation signal assignment statements.



TEST NUMBER :  308

PATHNAME :  [.BENCH.B.C.L1.S1]shell1.sh, shell0.sh
            (UNIX equivalent : bench/b/c/l1/s1/shell1.sh, shell0.sh)

PURPOSE :  Determine the simulation CPU time required to perform variable
           character read operations from a file.  The model simulated is
           an architecture consisting of a process.  The process contains
           a variable declaration and a for-loop, whose number of iterations
           is equal to the number of characters to read.  The for-loop
           contains a read statement that reads one character from the input 
           file.  The factor to be varied is the number of characters to read.



TEST NUMBER :  309

PATHNAME :  [.BENCH.B.C.L2.S1]shell1.sh, shell0.sh
            (UNIX equivalent : bench/b/c/l2/s1/shell1.sh, shell0.sh)

PURPOSE :  Determine the simulation CPU time required to perform variable
           character read operations from a file.  The model simulated is
           an architecture consisting of a process.  The process contains
           a variable declaration and a for-loop, whose iteration scheme is
           integer'high.  The for-loop contains a read statement that reads 
           one character from the input file and an exit statement that limits
           the number of iterations to the number of characters desired to be 
           read.  The factor to be varied is the number of characters to read.



TEST NUMBER :  310

PATHNAME :  [.BENCH.B.C.L3.S1]shell1.sh, shell0.sh
            (UNIX equivalent : bench/b/c/l3/s1/shell1.sh, shell0.sh)

PURPOSE :  Determine the simulation CPU time required to perform variable
           character read operations from a file.  The model simulated is
           an architecture consisting of a process.  The process contains
           two variable declarations (one is a loop-counter) and a while-loop, 
           whose number of iterations is equal to the number of characters to 
           read.  The while-loop contains a variable addition statement to
           increment the loop-counter and a read statement that reads one 
           character from the input file.  The factor to be varied is the 
           number of characters to read.



TEST NUMBER :  311

PATHNAME :  [.BENCH.B.C.L4.S1]shell1.sh, shell0.sh
            (UNIX equivalent : bench/b/c/l4/s1/shell1.sh, shell0.sh)

PURPOSE :  Determine the simulation CPU time required to perform variable
           character read operations from a file.  The model simulated is
           an architecture consisting of a process.  The process contains
           two variable declarations (one is a loop-counter) and a while-loop, 
           whose iteration scheme is true.  The while-loop contains a variable
           addition statement to increment the loop-counter, a read statement 
           that reads one character from the input file and an exit statement 
           that limits the number of iterations to the number of characters 
           desired to be read.  The factor to be varied is the number of 
           characters to read.



TEST NUMBER :  312

PATHNAME :  [.BENCH.A.C.D1A]shell.sh
            (UNIX equivalent : bench/a/c/d1a/shell.sh)

PURPOSE :  Determine the effect of guarded blocks and resolved signals on CPU
           time.  The model simulated is a package declaration, a package body
           declaration, and an architecture.  The package declaration has two
           type declarations and a resolution function declaration.  The package
           body has the body of the resolution function.  The architecture 
           consists of a resolved signal declaration, a number of non-resolved 
           signal declarations (guards), a guarded block statement for each
           guard signal, and a signal assignment statement for each guard
           signal.  Each block contains a signal assignment statement for the 
           resolved signal.  The factors to be varied are the number of
           non-resolved signal declarations/number of blocks/number of signal
           assignment statements, and the length of time (in ns) to simulate
           the model.  This description is part of an example from Dr Jim
           Armstrong's book.



TEST NUMBER :  313

PATHNAME :  [.BENCH.A.C.D1C]shell.sh
            (UNIX equivalent : bench/a/c/d1c/shell.sh)

PURPOSE :  Determine the effect of guarded blocks and bus resolved signals on 
           CPU time.  The model simulated is a package declaration, a package 
           body declaration, and an architecture.  The package declaration has 
           two type declarations and a resolution function declaration.  The 
           package body has the body of the resolution function.  The 
           architecture consists of a bus resolved signal declaration, a number 
           of non-resolved signal declarations (guards), a guarded block 
           statement for each guard signal, and a signal assignment statement 
           for each guard signal.  Each block contains a signal assignment 
           statement for the bus resolved signal.  The factors to be varied are 
           the number of non-resolved signal declarations/number of blocks/
           number of signal assignment statements, and the length of time (in 
           ns) to simulate the model.  This description is part of an example
           from Dr Jim Armstrong's book.



TEST NUMBER :  314

PATHNAME :  [.BENCH.A.C.D1B]shell.sh
            (UNIX equivalent : bench/a/c/d1b/shell.sh)

PURPOSE :  Determine the effect of guarded blocks and register resolved signals 
           on CPU time.  The model simulated is a package declaration, a 
           package body declaration, and an architecture.  The package 
           declaration has two type declarations and a resolution function 
           declaration.  The package body has the body of the resolution 
           function.  The architecture consists of a register resolved signal 
           declaration, a number of non-resolved signal declarations (guards), 
           a guarded block statement for each guard signal, and a signal 
           assignment statement for each guard signal.  Each block contains a 
           signal assignment statement for the register resolved signal.  The 
           factors to be varied are the number of non-resolved signal 
           declarations/number of blocks/number of signal assignment statements,
           and the length of time (in ns) to simulate the model.  This 
           description is part of an example from Dr Jim Armstrong's book.



TEST NUMBER :  315

PATHNAME :  [.BENCH.A.C.G2]shell.sh
            (UNIX equivalent : bench/a/c/g2/shell.sh)

PURPOSE :  Determine the effect of assertion statements on CPU time.  The model
           simulated is an architecture consisting of a number of signal
           declarations and a number of assertion statements for each signal.
           The factors to be varied are the number of signal declarations, the
           number of assertion statements per signal, and the length of time
           (in ns) to simulate the model.



TEST NUMBER :  316

PATHNAME :  [.BENCH.A.C.G4]shell.sh
            (UNIX equivalent : bench/a/c/g4/shell.sh)

PURPOSE :  Determine the effect of block assertion statements on CPU time.  The 
           model simulated is an architecture consisting of a number of block
           declarations.  Each block contains a number of signal declarations 
           and a number of assertion statements for each signal.  The factors 
           to be varied are the number of block declarations, the number of 
           signal declarations per block, the number of assertion statements 
           per signal, and the length of time (in ns) to simulate the model.



TEST NUMBER :  317

PATHNAME :  [.BENCH.B.C.G6.I2.P10]shell.sh
            (UNIX equivalent : bench/b/c/g6/i2/p10/shell.sh)

PURPOSE :  Determine the effect of function assertion statements on CPU time.
           The model simulated is an architecture consisting of a number of
           function declarations and a process.  Each function has an assertion 
           statement for each input parameter and a return statement that 
           returns the output of an XOR assignment statement with all the input
           parameters as arguments.  The process has a number of bit variable
           declarations (the same number as the number of input parameters of
           each function) and a function call for each function declaration.
           The factors to be varied are the number of function declarations/
           function calls and the number of variable declarations in the 
           process/input parameters in each function/assertion statements in
           each function.



TEST NUMBER :  318

PATHNAME :  [.BENCH.B.C.G5.H2.P10]shell.sh
            (UNIX equivalent : bench/b/c/g5/h2/p10/shell.sh)

PURPOSE :  Determine the effect of procedure assertion statements on CPU time.
           The model simulated is an architecture consisting of a number of
           procedure declarations and a process.  Each procedure has an 
           assertion statement for each input parameter and an XOR assignment 
           statement with all the input parameters as arguments and the output
           parameter as the result.  The process has a number of bit variable
           declarations (the same number as the number of input parameters of
           each procedure) and a procedure call for each procedure declaration.
           The factors to be varied are the number of procedure declarations/
           procedure calls and the number of variable declarations in the 
           process/input parameters in each procedure/assertion statements in
           each procedure.



TEST NUMBER :  319

PATHNAME :  [.BENCH.B.C.K.L1.M.O]shell.sh
            (UNIX equivalent : bench/b/c/k/l1/m/o/shell.sh)

PURPOSE :  Determine the effect of arrayed variables and use of the " 'val "
           attribute on CPU time.  The odel simulated is an architecture
           consisting of a process.  The process has a variable character 
           array declaration and a for-loop, whose number of iterations is
           equal to the size of the array.  The for-loop contains an if-
           statement, a variable assignment statement using " 'val ", and 
           another variable assignment statement.  The if-statement contains
           two variable assignment statements.  The factor to be varied is the 
           size of the array/number of for-loop iterations.



TEST NUMBER :  320

PATHNAME :  [.BENCH.A.C.F1.K.Q]shell.sh
            (UNIX equivalent : bench/a/c/f1/k/q/shell.sh)

PURPOSE :  Determine the effect of arrayed, aliased signals, and component
           instantiations on CPU time.  The model simulated is a mos logic
           package (containing various type definitions and function
           declarations), a clock entity with two port signals (one arrayed)
           whose architecture has a signal assignment statement for each 
           element of the port signal array, and a top-level entity whose
           architecture has an arrayed signal declaration whose size is 
           equal to the number of elements in the clock entity's port signal
           multiplied by the number of aliased signals desired.  This 
           architecture also has a number of aliased signals; each one
           represents part of the arrayed signal declared earlier in the 
           architecture, and is the same size as the clock entity's port
           signal.  The architecture also contains one component instantiation
           (of the clock entity) for each aliased signal.  The factors to be
           varied are the size of the clock entity's arrayed port signal, the
           number of aliased signals/component instantiations in the top-level
           architecture, and the length of time (in ns) to simulate the model.



