Programmer's ROM - The Computer Language Library

home *** CD-ROM | disk | FTP | other *** search

/ Programmer's ROM - The Computer Language Library / programmersrom.iso / ada / test / piwgb.src < prev next >

Wrap

Text File | 1988-05-03 | 144.5 KB | 5,198 lines

:::::::::: piwgb831.inc :::::::::: -- -- PIWG TAPE_8_31_86, Part B -- D000001.ADA D000002.ADA D000003.ADA D000004.ADA E000001.ADA E000002.ADA E000004.ADA F000001.ADA F000002.ADA G000001.ADA G000002.ADA G000003.ADA G000004.ADA G000005.ADA G000006.ADA G000007.ADA GETPIWG.SUB L000001.ADA L000002.ADA L000003.ADA P000001.ADA P000002.ADA P000003.ADA P000004.ADA P000005.ADA P000006.ADA P000007.ADA P000010.ADA P000011.ADA P000012.ADA P000013.ADA READ.ME T000001.ADA T000002.ADA T000003.ADA T000004.ADA T000005.ADA T000006.ADA T000007.ADA TAPE.LOG TAPEDIST.LTR WCOMPILE.COM :::::::::: D000001.ADA :::::::::: -- PERFORMANCE MEASUREMENT : Elaboration, allocation and freeing of -- a dynamic array package DYNAMIC_ARRAY_PACKAGE_1 is DYNAMIC_SIZE : INTEGER ; type DYNAMIC_ARRAY is array ( INTEGER range <> ) of INTEGER ; LOCAL_ARRAY : DYNAMIC_ARRAY ( 1..1000 ) ; procedure PROC_CONTROL ; procedure PROC_TEST ; end DYNAMIC_ARRAY_PACKAGE_1 ; with DYNAMIC_ARRAY_PACKAGE_1 ; use DYNAMIC_ARRAY_PACKAGE_1 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure D000001 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable begin DYNAMIC_SIZE := 1000 ; ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PROC_CONTROL ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PROC_TEST ; -- this has control global increment and call inside end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "D000001" , "Allocation" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Dynamic array allocation, use and deallocation time measurement " , " Dynamic array elaboration , 1000 integers in a procedure" , " get space and free it in the procedure on each call" ) ; end D000001 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; package body DYNAMIC_ARRAY_PACKAGE_1 is procedure PROC_CONTROL is begin GLOBAL := GLOBAL + A_ONE ; LOCAL_ARRAY ( GLOBAL ) := GLOBAL ; REMOTE ; GLOBAL := LOCAL_ARRAY ( GLOBAL ) ; end ; procedure PROC_TEST is PROC_ARRAY : DYNAMIC_ARRAY ( 1..DYNAMIC_SIZE ) ; begin GLOBAL := GLOBAL + A_ONE ; PROC_ARRAY ( GLOBAL ) := GLOBAL ; REMOTE ; GLOBAL := PROC_ARRAY ( GLOBAL ) ; end PROC_TEST ; end DYNAMIC_ARRAY_PACKAGE_1 ; :::::::::: D000002.ADA :::::::::: -- PERFORMANCE MEASUREMENT : Elaboration, allocation and freeing of -- a dynamic array initialized with others package DYNAMIC_ARRAY_PACKAGE_2 is DYNAMIC_SIZE : INTEGER ; type DYNAMIC_ARRAY is array ( INTEGER range <> ) of INTEGER ; LOCAL_ARRAY : DYNAMIC_ARRAY ( 1..1000 ) := (OTHERS=>1); procedure PROC_CONTROL ; procedure PROC_TEST ; end DYNAMIC_ARRAY_PACKAGE_2 ; with DYNAMIC_ARRAY_PACKAGE_2 ; use DYNAMIC_ARRAY_PACKAGE_2 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure D000002 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable begin DYNAMIC_SIZE := 1000 ; ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PROC_CONTROL ; -- control call end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PROC_TEST ; -- this has control global increment and call inside end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "D000002" , "Allocation" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Dynamic array elaboration and initialization time measurement " , " allocation, initialization, use and deallocation " , " 1000 integers initialized by others=>1 " ) ; end D000002 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; package body DYNAMIC_ARRAY_PACKAGE_2 is procedure PROC_CONTROL is begin GLOBAL := GLOBAL + A_ONE ; LOCAL_ARRAY ( GLOBAL ) := GLOBAL ; REMOTE ; GLOBAL := LOCAL_ARRAY ( GLOBAL ) ; end ; procedure PROC_TEST is PROC_ARRAY : DYNAMIC_ARRAY ( 1..DYNAMIC_SIZE ) := ( others => 1 ) ; begin GLOBAL := GLOBAL + A_ONE ; PROC_ARRAY ( GLOBAL ) := GLOBAL ; REMOTE ; GLOBAL := PROC_ARRAY ( GLOBAL ) ; end PROC_TEST ; end DYNAMIC_ARRAY_PACKAGE_2 ; :::::::::: D000003.ADA :::::::::: -- PERFORMANCE MEASUREMENT : Elaboration, allocation and freeing of -- record containing a dynamic array package DYNAMIC_ARRAY_PACKAGE_3 is DYNAMIC_SIZE : INTEGER ; type DYNAMIC_ARRAY is array ( INTEGER range <> ) of INTEGER ; type DYNAMIC_RECORD ( SIZE : INTEGER ) is record INSIDE_ARRAY : DYNAMIC_ARRAY ( 1..SIZE ) ; end record ; LOCAL_ARRAY : DYNAMIC_RECORD ( 1000 ) ; procedure PROC_CONTROL ; procedure PROC_TEST ; end DYNAMIC_ARRAY_PACKAGE_3 ; with DYNAMIC_ARRAY_PACKAGE_3 ; use DYNAMIC_ARRAY_PACKAGE_3 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure D000003 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable begin DYNAMIC_SIZE := 1000 ; ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PROC_CONTROL ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PROC_TEST ; -- this has control global increment and call inside end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "D000003" , "Allocation" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Dynamic record allocation and deallocation time measurement " , " elaborating, allocating and deallocating " , " record containing a dynamic array of 1000 integers " ) ; end D000003 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; package body DYNAMIC_ARRAY_PACKAGE_3 is procedure PROC_CONTROL is begin GLOBAL := GLOBAL + A_ONE ; LOCAL_ARRAY.INSIDE_ARRAY ( GLOBAL ) := GLOBAL ; REMOTE ; GLOBAL := LOCAL_ARRAY.INSIDE_ARRAY ( GLOBAL ) ; end ; procedure PROC_TEST is PROC_ARRAY : DYNAMIC_RECORD ( DYNAMIC_SIZE ) ; begin GLOBAL := GLOBAL + A_ONE ; PROC_ARRAY.INSIDE_ARRAY ( GLOBAL ) := GLOBAL ; REMOTE ; GLOBAL := PROC_ARRAY.INSIDE_ARRAY ( GLOBAL ) ; end PROC_TEST ; end DYNAMIC_ARRAY_PACKAGE_3 ; :::::::::: D000004.ADA :::::::::: -- PERFORMANCE MEASUREMENT : Elaboration, allocation and freeing of -- record containing a dynamic array package DYNAMIC_ARRAY_PACKAGE_4 is DYNAMIC_SIZE : INTEGER ; type DYNAMIC_ARRAY is array ( INTEGER range <> ) of INTEGER ; type DYNAMIC_RECORD ( SIZE : INTEGER ) is record INSIDE_ARRAY : DYNAMIC_ARRAY ( 1..SIZE ) ; end record ; LOCAL_ARRAY : DYNAMIC_RECORD ( 1000 ) := ( 1000 , ( others => 1 ) ) ; procedure PROC_CONTROL ; procedure PROC_TEST ; end DYNAMIC_ARRAY_PACKAGE_4 ; with DYNAMIC_ARRAY_PACKAGE_4 ; use DYNAMIC_ARRAY_PACKAGE_4 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure D000004 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable begin DYNAMIC_SIZE := 1000 ; ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PROC_CONTROL ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PROC_TEST ; -- this has control global increment and call inside end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "D000004" , "Allocation" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Dynamic record allocation and deallocation time measurement " , " elaborating, initializing by ( DYNAMIC_SIZE,(others=>1)) " , " record containing a dynamic array of 1000 integers " ) ; end D000004 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; package body DYNAMIC_ARRAY_PACKAGE_4 is procedure PROC_CONTROL is begin GLOBAL := GLOBAL + A_ONE ; LOCAL_ARRAY.INSIDE_ARRAY ( GLOBAL ) := GLOBAL ; REMOTE ; GLOBAL := LOCAL_ARRAY.INSIDE_ARRAY ( GLOBAL ) ; end ; procedure PROC_TEST is PROC_ARRAY : DYNAMIC_RECORD ( DYNAMIC_SIZE ) := ( DYNAMIC_SIZE , ( others => 1 ) ) ; begin GLOBAL := GLOBAL + A_ONE ; PROC_ARRAY.INSIDE_ARRAY ( GLOBAL ) := GLOBAL ; REMOTE ; GLOBAL := PROC_ARRAY.INSIDE_ARRAY ( GLOBAL ) ; end PROC_TEST ; end DYNAMIC_ARRAY_PACKAGE_4 ; :::::::::: E000001.ADA :::::::::: -- PERFORMANCE MEASUREMENT : exception raise and handle time -- exception in loop with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure E000001 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable MY_EXCEPTION : exception ; -- begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop begin if A_ONE = 1 then GLOBAL := GLOBAL + A_ONE ; REMOTE ; else GLOBAL := GLOBAL + A_ONE ; REMOTE ; raise MY_EXCEPTION ; end if ; exception when MY_EXCEPTION => null ; end ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- -- establish exception raise and handle time ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop begin if A_ONE = 2 then GLOBAL := GLOBAL + A_ONE ; REMOTE ; else GLOBAL := GLOBAL + A_ONE ; REMOTE ; raise MY_EXCEPTION ; end if ; exception when MY_EXCEPTION => null ; end ; end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "E000001" , "Exception" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Time to raise and handle an exception " , " Exception defined locally and handled locally " , " " ) ; end E000001 ; :::::::::: E000002.ADA :::::::::: -- PERFORMANCE MEASUREMENT : exception raise and handle time -- exception in procedure package EXCEPT_PACK_2 is MY_EXCEPTION : exception ; SWITCH : BOOLEAN ; -- controls return or raise exception procedure PROC_1 ( SWITCH : BOOLEAN ) ; -- either returns or raises exception end EXCEPT_PACK_2 ; with EXCEPT_PACK_2 ; use EXCEPT_PACK_2 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure E000002 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- if A_ONE = 2 then SWITCH := TRUE ; else SWITCH := FALSE ; end if ; ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop -- this has control global increment and call inside begin PROC_1 ( SWITCH ) ; -- FALSE no exception raised exception when MY_EXCEPTION => null ; end ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- -- establish exception raise and handle time if A_ONE = 1 then SWITCH := TRUE ; else SWITCH := FALSE ; end if ; ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop -- this has control global increment and call inside begin PROC_1 ( SWITCH ) ; -- TRUE exception will be raised exception when MY_EXCEPTION => null ; end ; end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "E000002" , "Exception" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Exception raise and handle timing measurement" , " when exception is in a procedure in a package" , " " ) ; end E000002 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; package body EXCEPT_PACK_2 is -- compare to E000001, diff is propegation procedure PROC_1 ( SWITCH : BOOLEAN ) is begin if SWITCH then GLOBAL := GLOBAL + 1 ; REMOTE ; raise MY_EXCEPTION ; else GLOBAL := GLOBAL + 1 ; REMOTE ; return ; end if ; exception when PROGRAM_ERROR => PROC_1 ( SWITCH ) ; end PROC_1 ; end EXCEPT_PACK_2 ; :::::::::: E000004.ADA :::::::::: -- PERFORMANCE MEASUREMENT : exception raise and handle time -- exception in procedure 4 deep package EXCEPT_PACK_4 is MY_EXCEPTION : exception ; SWITCH : BOOLEAN ; -- controls return or raise exception procedure PROC_1 ( SWITCH : BOOLEAN ) ; -- either returns or raises exception procedure PROC_2 ( SWITCH : BOOLEAN ) ; -- calls PROC_1 procedure PROC_3 ( SWITCH : BOOLEAN ) ; -- calls PROC_2 procedure PROC_4 ( SWITCH : BOOLEAN ) ; -- calls PROC_3 end EXCEPT_PACK_4 ; with EXCEPT_PACK_4 ; use EXCEPT_PACK_4 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure E000004 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- if A_ONE = 2 then SWITCH := TRUE ; else SWITCH := FALSE ; end if ; ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop -- this has control global increment and call inside begin PROC_4 ( SWITCH ) ; exception when MY_EXCEPTION => null ; end ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- -- establish exception raise and handle time if A_ONE = 1 then SWITCH := TRUE ; else SWITCH := FALSE ; end if ; ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop -- this has control global increment and call inside begin PROC_4 ( SWITCH ) ; exception when MY_EXCEPTION => null ; end ; end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "E000004" , "Procedure" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Exception raise and handle timing measurement " , " when exception is in a package, 4 deep " , " " ) ; end E000004 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; package body EXCEPT_PACK_4 is -- compare to E000002, diff is propegation procedure PROC_4 ( SWITCH : BOOLEAN ) is begin PROC_3 ( SWITCH ) ; end PROC_4 ; procedure PROC_3 ( SWITCH : BOOLEAN ) is begin PROC_2 ( SWITCH ) ; end PROC_3 ; procedure PROC_2 ( SWITCH : BOOLEAN ) is begin PROC_1 ( SWITCH ) ; end PROC_2 ; procedure PROC_1 ( SWITCH : BOOLEAN ) is begin GLOBAL := GLOBAL + 1 ; REMOTE ; if SWITCH then raise MY_EXCEPTION ; else return ; end if ; end PROC_1 ; end EXCEPT_PACK_4 ; :::::::::: F000001.ADA :::::::::: -- PERFORMANCE MEASUREMENT : Coding Style Feature -- Logical equation vs if test with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; with ITERATION ; with PIWG_IO ; procedure F000001 is -- main procedure to execute CPU_TIME : DURATION ; WALL_TIME : DURATION ; CHECK_TIMES : constant := 100 ; ITERATION_COUNT : INTEGER ; ITS_OK : BOOLEAN ; FLAG : BOOLEAN ; VALUE : INTEGER ; -- begin VALUE := 50 ; FLAG := TRUE ; ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; -- FLAG := VALUE < GLOBAL ; -- feature being measured REMOTE ; FLAG := not FLAG ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; if FLAG then -- be sure FLAG computed GLOBAL := 1 ; REMOTE ; end if ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; FLAG := VALUE < GLOBAL ; -- feature being measured REMOTE ; FLAG := not FLAG ; end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; if FLAG then -- be sure FLAG computed GLOBAL := 1 ; REMOTE ; end if ; ITERATION.TEST_STABLE ( ITERATION_COUNT , ITS_OK ) ; exit when ITS_OK ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "F000001" , "Style" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Time to set a boolean flag using a logical equation" , " a local and a global integer are compared " , " compare this test with F000002" ) ; end F000001 ; :::::::::: F000002.ADA :::::::::: -- PERFORMANCE MEASUREMENT : Coding Style Feature -- Logical equation vs if test -- F000001 and F000002 are a pair with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; with ITERATION ; with PIWG_IO ; procedure F000002 is -- main procedure to execute CPU_TIME : DURATION ; WALL_TIME : DURATION ; CHECK_TIMES : constant := 100 ; ITERATION_COUNT : INTEGER ; ITS_OK : BOOLEAN ; FLAG : BOOLEAN ; VALUE : INTEGER ; -- begin VALUE := 50 ; FLAG := TRUE ; ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; FLAG := not FLAG ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; if FLAG then -- be sure FLAG computed GLOBAL := 1 ; REMOTE ; end if ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; if VALUE < GLOBAL then -- feature being measured FLAG := TRUE ; else FLAG := FALSE ; end if ; -- FLAG := VALUE < GLOBAL ; -- equivalent computation REMOTE ; FLAG := not FLAG ; end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; if FLAG then -- be sure FLAG computed GLOBAL := 1 ; REMOTE ; end if ; ITERATION.TEST_STABLE ( ITERATION_COUNT , ITS_OK ) ; exit when ITS_OK ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "F000002" , "Style" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Time to set a boolean flag using an 'if' test" , " a local and a global integer are compared " , " compare this test with F000001" ) ; end F000002 ; :::::::::: G000001.ADA :::::::::: -- PERFORMANCE MEASUREMENT : function GET_LINE timing with TEXT_IO ; use TEXT_IO ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure G000001 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable SCRATCH_FILE : FILE_TYPE ; SCRATCH_STRING : STRING ( 1..20 ) := "abcdefghijklmnopqrst"; SCRATCH_LENGTH : NATURAL ; begin -- -- Build file for " GET_LINE " test -- CREATE ( SCRATCH_FILE , OUT_FILE , "SCRATCH1" ) ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PUT_LINE ( SCRATCH_FILE , SCRATCH_STRING ) ; end loop ; CLOSE ( SCRATCH_FILE ) ; OPEN ( SCRATCH_FILE , IN_FILE , "SCRATCH1" ) ; ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; end loop ; RESET ( SCRATCH_FILE ) ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- -- establish the time for the GET_LINE pocdedure on 20 character strings ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; GET_LINE ( SCRATCH_FILE , SCRATCH_STRING , SCRATCH_LENGTH ) ; end loop ; RESET ( SCRATCH_FILE ) ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; CLOSE ( SCRATCH_FILE ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "G000001" , "Input/Output" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " TEXT_IO.GET_LINE reading 20 characters, time measured " , " A scratch file is written, then read and reset " , " " ) ; end G000001 ; :::::::::: G000002.ADA :::::::::: -- PERFORMANCE MEASUREMENT : function GET timing with TEXT_IO ; use TEXT_IO ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure G000002 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable SCRATCH_FILE : FILE_TYPE ; SCRATCH_STRING : STRING ( 1..20 ) := "abcdefghijklmnopqrst"; SCRATCH_LENGTH : NATURAL ; SCRATCH_CHAR : CHARACTER := 'a' ; -- begin -- -- Build file for "GET" test -- CREATE ( SCRATCH_FILE , OUT_FILE , "SCRATCH2" ) ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PUT_LINE ( SCRATCH_FILE , SCRATCH_STRING ) ; end loop ; CLOSE ( SCRATCH_FILE ) ; OPEN ( SCRATCH_FILE , IN_FILE , "SCRATCH2" ) ; ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; -- GET ( SCRATCH_FILE , SCRATCH_CHAR ) ; -- measured for I in 1..20 loop SCRATCH_STRING ( I ) := SCRATCH_CHAR ; end loop ; end loop ; RESET ( SCRATCH_FILE ) ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- -- establish the time for the GET pocdedure on 20 character strings ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; for I in 1..20 loop GET ( SCRATCH_FILE , SCRATCH_CHAR ) ; SCRATCH_STRING ( I ) := SCRATCH_CHAR ; end loop ; end loop ; RESET ( SCRATCH_FILE ) ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; CLOSE ( SCRATCH_FILE ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "G000002" , "Input/Output" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " TEXT_IO.GET called 20 times per line, time measured " , " a scratch file is written, then read and reset " , " Compare to G000001 for about same number of characters " ) ; end G000002 ; :::::::::: G000003.ADA :::::::::: -- PERFORMANCE MEASUREMENT : function PUT_LINE timing with TEXT_IO ; use TEXT_IO ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure G000003 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable SCRATCH_FILE : FILE_TYPE ; SCRATCH_STRING : STRING ( 1..20 ) := "abcdefghijklmnopqrst"; SCRATCH_LENGTH : NATURAL ; begin -- -- Open file for " PUT_LINE " test -- CREATE ( SCRATCH_FILE , OUT_FILE , "SCRATCH3" ) ; ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; end loop ; RESET ( SCRATCH_FILE ) ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- -- establish the time for the PUT_LINE pocdedure on 20 character strings ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; PUT_LINE ( SCRATCH_FILE , SCRATCH_STRING ) ; end loop ; RESET ( SCRATCH_FILE ) ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; CLOSE ( SCRATCH_FILE ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "G000003" , "Input/Output" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " TEXT_IO.PUT_LINE for 20 characters, timing measurment" , " a scratch file is opened, written and reset" , " " ) ; end G000003 ; :::::::::: G000004.ADA :::::::::: -- PERFORMANCE MEASUREMENT : function PUT timing with TEXT_IO ; use TEXT_IO ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure G000004 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable SCRATCH_FILE : FILE_TYPE ; SCRATCH_STRING : STRING ( 1..20 ) := "abcdefghijklmnopqrst"; SCRATCH_LENGTH : NATURAL ; SCRATCH_CHAR : CHARACTER := 'a'; -- begin -- -- Build file for "PUT" test -- CREATE ( SCRATCH_FILE , OUT_FILE , "SCRATCH4" ) ; ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; for I in 1..20 loop -- PUT ( SCRATCH_FILE , SCRATCH_CHAR ) ; -- measured SCRATCH_STRING ( I ) := SCRATCH_CHAR ; end loop ; end loop ; RESET ( SCRATCH_FILE ) ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- -- establish the time for the PUT pocdedure on 20 character strings ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; for I in 1..20 loop PUT ( SCRATCH_FILE , SCRATCH_CHAR ) ; SCRATCH_STRING ( I ) := SCRATCH_CHAR ; end loop ; end loop ; RESET ( SCRATCH_FILE ) ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; CLOSE ( SCRATCH_FILE ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "G000004" , "Input/Output" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " TEXT_IO.PUT 20 times with one character, time measurement" , " a scratch file is written, reset and rewritten " , " compare, approximately, to G000003" ) ; end G000004 ; :::::::::: G000005.ADA :::::::::: -- PERFORMANCE MEASUREMENT : function GET timing ( INTERNAL ) with TEXT_IO ; use TEXT_IO ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure G000005 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable SCRATCH_STRING : STRING ( 1..6 ) := "100 "; SCRATCH_LENGTH : NATURAL ; SCRATCH_VALUE : INTEGER ; package INT_IO is new INTEGER_IO ( INTEGER ) ; use INT_IO ; begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; PUT ( SCRATCH_STRING , INSIDE_LOOP ) ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- -- establish the time for the GET pocdedure on an integer ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; PUT ( SCRATCH_STRING , INSIDE_LOOP ) ; GET ( SCRATCH_STRING , SCRATCH_VALUE , SCRATCH_LENGTH ) ; end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "G000005" , "Input/Output" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " TEXT_IO.GET an integer from a local string, timing measurement" , " use TEXT_IO.PUT to convert 1..100 to a string " , " then use TEXT_IO.GET to get the number back" ) ; end G000005 ; :::::::::: G000006.ADA :::::::::: -- PERFORMANCE MEASUREMENT : function GET timing ( INTERNAL FLOAT) with TEXT_IO ; use TEXT_IO ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure G000006 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable SCRATCH_STRING : STRING ( 1..20 ) := "0.010 "; SCRATCH_LENGTH : NATURAL ; SCRATCH_VALUE : FLOAT ; package FLT_IO is new FLOAT_IO ( FLOAT ) ; use FLT_IO ; -- begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; SCRATCH_VALUE := FLOAT ( INSIDE_LOOP ) / 1000.0 ; PUT ( SCRATCH_STRING , SCRATCH_VALUE ) ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- -- establish the time for the GET pocdedure on a FLOAT number ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; SCRATCH_VALUE := FLOAT ( INSIDE_LOOP ) / 1000.0 ; PUT ( SCRATCH_STRING , SCRATCH_VALUE ) ; GET ( SCRATCH_STRING , SCRATCH_VALUE , SCRATCH_LENGTH ) ; end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "G000006" , "Input/Output" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " TEXT_IO.GET getting a floating point fraction from a local string" , " Timing measurement on 0.001 to 0.01 range of numbers" , " compare, approximately, to G000005 for integer vs float" ) ; end G000006 ; :::::::::: G000007.ADA :::::::::: -- PERFORMANCE MEASUREMENT : opening files with TEXT_IO ; use TEXT_IO ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure G000007 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable SCRATCH : FILE_TYPE ; begin CREATE ( SCRATCH , OUT_FILE , "SCRATCH7" ); PUT_LINE ( SCRATCH , " just stuff " ) ; CLOSE ( SCRATCH ) ; ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- -- establish the time to open a file ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; OPEN ( SCRATCH , IN_FILE , "SCRATCH7" ) ; CLOSE ( SCRATCH ) ; end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "G000007" , "Input/Output" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Open and close an existing file, time measurement" , " A scratch file is created and closed " , " The scratch file is opened IN_FILE and closed in a loop" ) ; end G000007 ; :::::::::: GETPIWG.SUB :::::::::: @ftp ada20.isi.edu login anonymous a cd <info-ada.piwg> get A000001.ADA * get A000002.ADA * get A000011.ADA * get A000012.ADA * get A000013.ADA * get A000014.ADA * get A000015.ADA * get A000016.ADA * get A000021.ADA * get A000022.ADA * get A000031.ADA * get A000032.ADA * get A000033.ADA * get A000041.ADA * get A000042.ADA * get A000043.ADA * get A000044.ADA * get A000049.ADA * get A000051.ADA * get A000052.ADA * get A000053.ADA * get A000054.ADA * get A000055.ADA * get A000091.ADA * get A000092.ADA * get A000093.ADA * get A000094.ADA * get A000098.ADA * get A000099.ADA * get A000100.ADA * get A000101.ADA * get A000102.ADA * get A000103.ADA * get A000104.ADA * get A000105.ADA * get A000106.ADA * get A000107.ADA * get ACOMPILE.CLI * get ACOMPILE.COM * get ACOMPILE.LR1 * get C000001.ADA * get C000002.ADA * get C000003.ADA * get COMPILE.CLI * get COMPILE.COM * get COMPILE.L78 * get COMPILE.L86 * get COPY.COM * get COPY.R10 * get D000001.ADA * get D000002.ADA * get D000003.ADA * get D000004.ADA * get E000001.ADA * get E000002.ADA * get E000004.ADA * get F000001.ADA * get F000002.ADA * get G000001.ADA * get G000002.ADA * get G000003.ADA * get G000004.ADA * get G000005.ADA * get G000006.ADA * get G000007.ADA * get L000001.ADA * get L000002.ADA * get L000003.ADA * get P000001.ADA * get P000002.ADA * get P000003.ADA * get P000004.ADA * get P000005.ADA * get P000006.ADA * get P000007.ADA * get P000010.ADA * get P000011.ADA * get P000012.ADA * get P000013.ADA * get READ.ME * get T000001.ADA * get T000002.ADA * get T000003.ADA * get T000004.ADA * get T000005.ADA * get T000006.ADA * get T000007.ADA * get TAPE.LOG * get TAPEDIST.LTR * get WCOMPILE.COM * get Z000001.ADA * get Z000002.ADA * get Z000003.ADA * get Z000004.ADA * get Z000005.ADA * get Z000006.ADA * get Z000007.ADA * get Z000008.ADA * get Z000009.ADA * get Z000010.ADA * get Z000011.ADA * get Z000012.ADA * get Z000013.ADA * get Z000014.ADA * get Z000015.ADA * get Z000016.ADA * get Z000016A.ADA * get Z000017.ADA * get Z000017A.ADA * get Z000018.ADA * get Z000020.ADA * get Z000021.ADA * get Z000022.ADA * get Z000023.ADA * get Z000110.ADA * get Z000111.ADA * get Z000111.COM * get Z000111D.CLI * get Z000111D.COM * get Z000112.ADA * get Z000113.ADA * get Z000114.ADA * get Z00011D.L86 * get Z000121.ADA * get Z000122.ADA * get Z000123.ADA * get Z000124.ADA * get Z000131.ADA * get Z000132.ADA * get Z000133.ADA * get Z000134.ADA * get Z000141.ADA * get Z000142.ADA * get Z000143.ADA * get Z000151.ADA * get Z000152.ADA * get Z000153.ADA * get Z000161.ADA * get Z000162.ADA * get Z000171.ADA * get Z000172.ADA * get Z000173.ADA * get Z000181.ADA * get Z000182.ADA * get Z000183.ADA * get Z000184.ADA * get Z000191.ADA * get Z000192.ADA * get Z000193.ADA * get Z000201.ADA * get Z000202.ADA * get Z000203.ADA * get Z000211.ADA * get Z000212.ADA * get Z000213.ADA * get Z000221.ADA * get Z000222.ADA * get Z000223.ADA * get Z000224.ADA * get Z000231.ADA * get Z000232.ADA * get Z000233.ADA * get Z000234.ADA * get Z000241.ADA * get Z000242.ADA * get Z000243.ADA * get Z000244.ADA * get Z000254.ADA * get Z000264.ADA * get Z000274.ADA * get Z000281.ADA * get Z000282.ADA * get Z000283.ADA * get Z000284.ADA * get Z000291.ADA * get Z000292.ADA * get Z000293.ADA * get Z000294.ADA * get Z000295.ADA * get Z000301.ADA * get Z000302.ADA * get Z000303.ADA * get Z000304.ADA * get Z000311.ADA * get Z000312.ADA * get Z000313.ADA * get Z000314.ADA * get Z000315.ADA * get ZCOMPILE.CLI * get ZCOMPILE.COM * get ZCOMPILE.ICC * get ZCOMPILE.L86 * quit :::::::::: L000001.ADA :::::::::: -- PERFORMANCE MEASUREMENT : Measure simple "for" loop time -- loop is run 100 times -- time reported is for once through with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure L000001 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable CASE_COUNT : constant := 100 ; begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; -- something to do REMOTE ; -- that can not be pulled out of loop GLOBAL := GLOBAL + A_ONE ; -- repeated here 100 times REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; end loop ; end loop ; GLOBAL := GLOBAL / CASE_COUNT ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop for I in 1 .. 100 loop GLOBAL := GLOBAL + A_ONE ; -- same computation as above REMOTE ; -- now in loop end loop ; end loop ; end loop ; GLOBAL := GLOBAL / CASE_COUNT ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; CPU_TIME := DURATION ( CPU_TIME / CASE_COUNT ) ; WALL_TIME := DURATION ( WALL_TIME / CASE_COUNT ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "L000001" , "Iteration" , CPU_TIME , WALL_TIME , ITERATION_COUNT , "Simple ""for"" loop time " , "for I in 1 .. 100 loop " , "time reported is for once through loop " ) ; end L000001 ; :::::::::: L000002.ADA :::::::::: -- PERFORMANCE MEASUREMENT : Measure simple "while" loop time -- loop is run 100 times -- time reported is for once through with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure L000002 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable CASE_COUNT : constant := 100 ; I : INTEGER ; begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; -- something to do REMOTE ; -- that can not be pulled out of loop GLOBAL := GLOBAL + A_ONE ; -- repeated here 100 times REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; end loop ; end loop ; GLOBAL := GLOBAL / CASE_COUNT ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop I := 1 ; while I <= 100 loop GLOBAL := GLOBAL + A_ONE ; -- same computation as above REMOTE ; -- now in loop I := I + 1 ; end loop ; end loop ; end loop ; GLOBAL := GLOBAL / CASE_COUNT ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; CPU_TIME := DURATION ( CPU_TIME / CASE_COUNT ) ; WALL_TIME := DURATION ( WALL_TIME / CASE_COUNT ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "L000002" , "Iteration" , CPU_TIME , WALL_TIME , ITERATION_COUNT , "Simple ""while"" loop time " , "while I <= 100 loop " , "time reported is for once through loop " ) ; end L000002 ; :::::::::: L000003.ADA :::::::::: -- PERFORMANCE MEASUREMENT : Measure simple loop with "exit" -- loop is run 100 times -- time reported is for once through with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure L000003 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable CASE_COUNT : constant := 100 ; I : INTEGER ; begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; -- something to do REMOTE ; -- that can not be pulled out of loop GLOBAL := GLOBAL + A_ONE ; -- repeated here 100 times REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; end loop ; end loop ; GLOBAL := GLOBAL / CASE_COUNT ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop I := 1 ; loop GLOBAL := GLOBAL + A_ONE ; -- same computation as above REMOTE ; -- now in loop I := I + 1 ; exit when I > 100 ; end loop ; end loop ; end loop ; GLOBAL := GLOBAL / CASE_COUNT ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; CPU_TIME := DURATION ( CPU_TIME / CASE_COUNT ) ; WALL_TIME := DURATION ( WALL_TIME / CASE_COUNT ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "L000003" , "Iteration" , CPU_TIME , WALL_TIME , ITERATION_COUNT , "Simple ""exit"" loop time " , " loop I:=I+1; exit when I>100; end loop;" , "time reported is for once through loop " ) ; end L000003 ; :::::::::: P000001.ADA :::::::::: -- PERFORMANCE MEASUREMENT : Minimum procedure call and return time -- procedure local -- no parameters with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; with ITERATION ; with PIWG_IO ; procedure P000001 is -- main procedure to execute CPU_TIME : DURATION ; WALL_TIME : DURATION ; CHECK_TIMES : constant := 100 ; ITERATION_COUNT : INTEGER ; ITS_OK : BOOLEAN ; -- procedure PROC_0 is -- may be inlined thus zero time begin GLOBAL := GLOBAL + A_ONE ; REMOTE ; end ; begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PROC_0 ; -- this has control global increment and call inside end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , ITS_OK ) ; exit when ITS_OK ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "P000001" , "Procedure" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Procedure call and return time ( may be zero if automatic inlining ) " , " procedure is local " , " no parameters " ) ; end P000001 ; :::::::::: P000002.ADA :::::::::: -- PERFORMANCE MEASUREMENT : procedure call and return time -- no parameters -- procedure local ( not inlinable) with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure P000002 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable -- procedure PROC_0 is begin GLOBAL := GLOBAL + A_ONE ; REMOTE ; exception when NUMERIC_ERROR => -- prevent inlining PROC_0 ; -- can not be called if test working end ; begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 5.0 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PROC_0 ; -- this has control global increment and call inside end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "P000002", "Procedure", CPU_TIME , WALL_TIME , ITERATION_COUNT , " Procedure call and return time" , " Procedure is local, no parameters " , " when procedure is not inlinable" ) ; end P000002 ; :::::::::: P000003.ADA :::::::::: -- PERFORMANCE MEASUREMENT : procedure call and return time -- procedure in package -- no parameters package PROC_PACKAGE_3 is procedure PROC_0 ; end PROC_PACKAGE_3 ; with PROC_PACKAGE_3 ; use PROC_PACKAGE_3 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure P000003 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PROC_0 ; -- this has control global increment and call inside end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "P000003" , "Procedure" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Procedure call and return time measurement" , " The procedure is in a separately compiled package " , " Compare to P000002 " ) ; end P000003 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; package body PROC_PACKAGE_3 is -- compare to P000002 ( local procedure ) procedure PROC_0 is begin GLOBAL := GLOBAL + A_ONE ; REMOTE ; end ; end PROC_PACKAGE_3 ; :::::::::: P000004.ADA :::::::::: -- PERFORMANCE MEASUREMENT : procedure call and return time -- procedure in package -- pragma INLINE used -- no parameters package PROC_PACKAGE_4 is procedure PROC_0 ; pragma INLINE ( PROC_0 ) ; end PROC_PACKAGE_4 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; package body PROC_PACKAGE_4 is -- compare to P000001 ( local procedure ) procedure PROC_0 is begin GLOBAL := GLOBAL + A_ONE ; REMOTE ; end ; end PROC_PACKAGE_4 ; with PROC_PACKAGE_4 ; use PROC_PACKAGE_4 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure P000004 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PROC_0 ; -- this has control global increment and call inside end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "P000004" , "Procedure" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Procedure call and return time measurement" , " The procedure is in a separately compiled package " , " pragma INLINE used. Compare to P000001 " ) ; end P000004 ; :::::::::: P000005.ADA :::::::::: -- PERFORMANCE MEASUREMENT : procedure call and return time -- procedure in package -- one "in" parameter package PROC_PACKAGE_5 is procedure PROC_0 ( A : in INTEGER ) ; end PROC_PACKAGE_5 ; with PROC_PACKAGE_5 ; use PROC_PACKAGE_5 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure P000005 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PROC_0 ( A_ONE ) ; -- this has control global increment and call inside end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "P000005" , "Procedure" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Procedure call and return time measurement" , " The procedure is in a separately compiled package " , " One parameter, in INTEGER " ) ; end P000005 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; package body PROC_PACKAGE_5 is -- compare to P000003 procedure PROC_0 ( A : in INTEGER ) is begin GLOBAL := GLOBAL + A ; REMOTE ; end ; end PROC_PACKAGE_5 ; :::::::::: P000006.ADA :::::::::: -- PERFORMANCE MEASUREMENT : procedure call and return time -- procedure in package -- one "out" parameter package PROC_PACKAGE_6 is procedure PROC_0 ( A : out INTEGER ) ; end PROC_PACKAGE_6 ; with PROC_PACKAGE_6 ; use PROC_PACKAGE_6 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure P000006 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable A : INTEGER ; begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop A := A_ONE ; GLOBAL := GLOBAL + A ; REMOTE ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PROC_0 ( A ) ; -- this has REMOTE call inside GLOBAL := GLOBAL + A ; end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "P000006" , "Procedure" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Procedure call and return time measurement" , " The procedure is in a separately compiled package " , " One parameter, out INTEGER " ) ; end P000006 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; package body PROC_PACKAGE_6 is -- compare to P000005 procedure PROC_0 ( A : out INTEGER ) is begin A := A_ONE ; REMOTE ; end ; end PROC_PACKAGE_6 ; :::::::::: P000007.ADA :::::::::: -- PERFORMANCE MEASUREMENT : procedure call and return time -- procedure in package -- one "in out" parameter package PROC_PACKAGE_7 is procedure PROC_0 ( A : in out INTEGER ) ; end PROC_PACKAGE_7 ; with PROC_PACKAGE_7 ; use PROC_PACKAGE_7 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure P000007 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable A : INTEGER ; begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PROC_0 ( GLOBAL ) ; -- this has control global increment and call inside end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "P000007" , "Procedure" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Procedure call and return time measurement" , " The procedure is in a separately compiled package " , " One parameter, in out INTEGER " ) ; end P000007 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; package body PROC_PACKAGE_7 is -- compare to P000005 & 6 procedure PROC_0 ( A : in out INTEGER ) is begin A := A + A_ONE ; REMOTE ; end ; end PROC_PACKAGE_7 ; :::::::::: P000010.ADA :::::::::: -- PERFORMANCE MEASUREMENT : procedure call and return time -- procedure in package -- ten discrete "in" parameters package PROC_PACKAGE_10 is procedure PROC_0 ( A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 : in INTEGER ) ; end PROC_PACKAGE_10 ; with PROC_PACKAGE_10 ; use PROC_PACKAGE_10 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure P000010 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable A1 : INTEGER := A_ONE ; A2 : INTEGER := A1 + A_ONE ; A3 : INTEGER := A2 + A_ONE ; A4 : INTEGER := A3 + A_ONE ; A5 : INTEGER := A4 + A_ONE ; A6 : INTEGER := A5 + A_ONE ; A7 : INTEGER := A6 + A_ONE ; A8 : INTEGER := A7 + A_ONE ; A9 : INTEGER := A8 + A_ONE ; A10 : INTEGER := A9 + A_ONE ; begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A1+A2+A3+A4+A5+A6+A7-A8-A9-A10 ; REMOTE ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PROC_0 ( A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 ) ; -- this has control global increment and call inside end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "P000010" , "Procedure" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Procedure call and return time measurement" , " Compare to P000005 " , " 10 parameters, in INTEGER " ) ; end P000010 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; package body PROC_PACKAGE_10 is -- compare to P000005 procedure PROC_0 ( A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 : in INTEGER ) is begin GLOBAL := GLOBAL + A1+A2+A3+A4+A5+A6+A7-A8-A9-A10 ; REMOTE ; end ; end PROC_PACKAGE_10 ; :::::::::: P000011.ADA :::::::::: -- PERFORMANCE MEASUREMENT : procedure call and return time -- procedure in package -- twenty discrete "in" parameters package PROC_PACKAGE_11 is procedure PROC_0 ( A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,A12,A13,A14,A15,A16,A17,A18,A19,A20 : in INTEGER ) ; end PROC_PACKAGE_11 ; with PROC_PACKAGE_11 ; use PROC_PACKAGE_11 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure P000011 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable A1 : INTEGER := A_ONE ; A2 : INTEGER := A1 + A_ONE ; A3 : INTEGER := A2 + A_ONE ; A4 : INTEGER := A3 + A_ONE ; A5 : INTEGER := A4 + A_ONE ; A6 : INTEGER := A5 + A_ONE ; A7 : INTEGER := A6 + A_ONE ; A8 : INTEGER := A7 + A_ONE ; A9 : INTEGER := A8 + A_ONE ; A10 : INTEGER := A9 + A_ONE ; A11 : INTEGER := A10 + A_ONE ; A12 : INTEGER := A11 + A_ONE ; A13 : INTEGER := A12 + A_ONE ; A14 : INTEGER := A13 + A_ONE ; A15 : INTEGER := A14 + A_ONE ; A16 : INTEGER := A15 + A_ONE ; A17 : INTEGER := A16 + A_ONE ; A18 : INTEGER := A17 + A_ONE ; A19 : INTEGER := A18 + A_ONE ; A20 : INTEGER := A19 + A_ONE ; begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A1+A2+A3+A4+A5+A6+A7-A8-A9-A10 +A20-A19-A18+A17+A16-A15-A14+A13-A12+A11+A_ONE ; REMOTE ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PROC_0 ( A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,A12,A13,A14,A15,A16,A17,A18,A19,A20 ) ; -- this has control global increment and call inside end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "P000011" , "Procedure" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Procedure call and return time measurement" , " Compare to P000005, P000010 " , " 20 parameters, in INTEGER " ) ; end P000011 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; package body PROC_PACKAGE_11 is -- compare to P000005 & 10 procedure PROC_0 ( A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,A12,A13,A14,A15,A16,A17,A18,A19,A20 : in INTEGER ) is begin GLOBAL := GLOBAL + A1+A2+A3+A4+A5+A6+A7-A8-A9-A10 +A20-A19-A18+A17+A16-A15-A14+A13-A12+A11+A_ONE ; REMOTE ; end ; end PROC_PACKAGE_11 ; :::::::::: P000012.ADA :::::::::: -- PERFORMANCE MEASUREMENT : procedure call and return time -- procedure in package -- ten composite "in" parameters package PROC_PACKAGE_12 is type MY_RECORD is record R1 : INTEGER ; R2 : INTEGER ; R3 : INTEGER ; end record ; procedure PROC_0 ( A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 : in MY_RECORD ) ; end PROC_PACKAGE_12 ; with PROC_PACKAGE_12 ; use PROC_PACKAGE_12 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure P000012 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable A : MY_RECORD := ( A_ONE , A_ONE + A_ONE , A_ONE + A_ONE + A_ONE ) ; begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A.R1+A.R2+A.R3-A.R1-A.R2-A.R3+A.R1+A.R2 -A.R3+A.R1 ; REMOTE ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PROC_0 ( A, A, A, A, A, A, A, A, A, A ) ; -- this has control global increment and call inside end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "P000012" , "Procedure" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Procedure call and return time measurement" , " Compare with P000010 ( discrete vs composite parameters ) " , " 10 paramaters, in MY_RECORD a three component record" ) ; end P000012 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; package body PROC_PACKAGE_12 is -- compare to P00000 procedure PROC_0 ( A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 : in MY_RECORD ) is begin GLOBAL := GLOBAL + A1.R1+A2.R2+A3.R3-A4.R1-A5.R2-A6.R3+A7.R1+A8.R2 -A9.R3+A10.R1 ; REMOTE ; end ; end PROC_PACKAGE_12 ; :::::::::: P000013.ADA :::::::::: -- PERFORMANCE MEASUREMENT : procedure call and return time -- procedure in package -- twenty composite "in" parameters package PROC_PACKAGE_13 is type MY_RECORD is record R1 : INTEGER ; R2 : INTEGER ; R3 : INTEGER ; end record ; procedure PROC_0 ( A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,A12,A13,A14,A15,A16,A17,A18,A19,A20 : in MY_RECORD ) ; end PROC_PACKAGE_13 ; with PROC_PACKAGE_13 ; use PROC_PACKAGE_13 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure P000013 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable A : MY_RECORD := ( A_ONE , A_ONE + A_ONE , A_ONE + A_ONE + A_ONE ) ; begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A.R1+A.R2+A.R3-A.R1-A.R2-A.R3+A.R1+A.R2 -A.R3+A.R1+A.R1+A.R2-A.R3+A.R1+A.R2-A.R3 +A.R1+A.R2-A.R3-A.R1+A_ONE ; REMOTE ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop PROC_0 ( A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A ) ; -- this has control global increment and call inside end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "P000013" , "Procedure" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Procedure call and return time measurement" , " twenty composite 'in' parameters " , " The package body is compiled after the spec is used" ) ; end P000013 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; package body PROC_PACKAGE_13 is -- compare to P00000 procedure PROC_0 ( A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,A12,A13,A14,A15,A16,A17,A18,A19,A20 : in MY_RECORD ) is begin GLOBAL := GLOBAL + A1.R1+A2.R2+A3.R3-A4.R1-A5.R2-A6.R3+A7.R1+A8.R2 -A9.R3+A10.R1+A11.R1+A12.R2-A13.R3+A14.R1+A15.R2-A16.R3 +A17.R1+A18.R2-A19.R3-A20.R1+A_ONE ; REMOTE ; end ; end PROC_PACKAGE_13 ; :::::::::: READ.ME :::::::::: READ.ME There are three (3) complete runs to be made on each computer/compiler combination: 1) The first run is typified by ACOMPILE.COM (VAX) or ACOMPILE.CLI ( ROLM/Data General ). Build the necessary script from one of these for your computer/compiler. This first script compiles the feature measurement tests, links them into one executable program, and then executes the tests and prints a report. The minimum times are desired. Runs tests individually if times differ significantly form the combined tests. An alternate form is shown in WCOMPILE.COM and COMPILE.COM ( VAX ) These tests may be run one at a time, starting with C000001 and continuing through T000006, with A000091, A000093, A000094 also. For embedded computers, this run must be executed on real hardware. This run is not suitable for simulators. ( COPY.R1000 may help selecting the files for the RATIONAL R1000 and see ACOMPILE.LOGR1000 for an example run ) The files with an extension or type with the word LOG in it are random samples of output. 2) The second run is typified by ZCOMPILE.COM ( VAX ) or ZCOMPILE.CLI ( ROLM/Data General ) or ZCOMPILE.ICC for the ICC compiler on the GOULD computer. Build the necessary script from one of these for your computer/compiler. This script provides one compilation time measurement for the time to compile, link and execute two programs. The execution time is very small compared to compile time. The "execution" for this run can be performed on a simulator ( the simulation time is not counted as part of the total time ) 3) The third run is typified by Z000111D.COM ( VAX ) or Z000111D.CLI ( ROLM/Data General ). Build the necessary script from one of these for your computer/compiler. This script provides many compilation time measurements. There are sets of increasingly larger compilations in order to get a feature verses time plot for compilation. There is no linking or execution in this run. Even for embedded computers it is strictly a host computer run. Z000111.COM just prints wall time between each run. Please do the subtractions if Z000111D.COM will not run. Generally, compilation order is alphabetical. There are a number of choices to be made depending on computer/compiler. 1. Choose either A000001 or A000002 for DURATION_IO. A000001 is preferred. 2. Choose one of A000011 through A000016 for CPU_TIME_CLOCK. This is computer/operating system dependent. 3. Choose one of A000042 through A000044 for PIWG_IO body. A000042 produces printout as it runs ( only one sample per run) A000043 writes times to disk and then A000049 is used to average and print the results. A000044 saves the time values in memory ( only for embedded computers that have no TEXT_IO, some editing will be required ) 4. Choose from making each procedure C000001 through T000006 a main program or using A000100 as a single main program with A000042 or using A000101 and A000102 as a pair of smaller main programs or using A000103 ( like A000100 as a single main program ) with A000049, and A000043 in place of A000042, PIWG_IO. or using appropriate versions of A000104, A000105, A000106 and A000107 main programs The first group of files establishes the basic routines in the program library. The complete test suite can be compiled, linked and run from one library. All files are of the form NAME.TYP with TYP being ADA for all Ada source files ADA A000001 DURATION_IO instantiation PICK ONE of these two ADA A000002 DURATION_IO using FLOAT_IO for incomplete compilers ADA A000011 CPU_TIME_CLOCK.ADA PICK ONE from this set or do your own ADA A000012 CPU_TIME_CLOCK.VAX -------- ADA A000013 CPU_TIME_CLOCK.DG ( manufacturers should help ) ADA A000014 CPU_TIME_CLOCK.UNIX ADA A000015 CPU_TIME_CLOCK.R1000 ADA A000016 CPU_TIME_CLOCK.ULTRIX ADA A000021 REMOTE_GLOBAL_ optimization control package spec ADA A000022 REMOTE_GLOBAL optimization control package body ADA A000031 ITERATION_ Iteration control package spec ADA A000032 ITERATION Iteration control package body ADA A000041 PIWG_IO_ output package spec ( universal ) PICK ONE from group below: ADA A000042 PIWG_IO package body for screen/printer output ADA A000043 PIWG_IO package body for writing to disk ADA A000044 PIWG_IO package body for save in memory, no TEXT_IO ADA A000049 A000049 Report printer if A000043 is used. ADA A000051 A000051 executable procedure to print WALL and CPU ADA A000052 A000052 A set of 4 executable procedures that ADA A000053 A000053 can be used to measure CPU and Wall time ADA A000054 A000054 without instrumenting the run begin ADA A000055 A000055 measured. Place optional control between A000052 and A000053. Place test being measured between A000054 and A000055. ADA A000091 DHRYSTONE ADA A000092 WHETSTONE using manufacturers math routines ( must edit ) ADA A000093 WHETSTONE using standard Ada math routines ADA A000094 HENNESY benchmarks ADA A000098 This is a skeleton procedure that can be copied and edited to construct more tests that have multiple parts. ADA A000099 This is a skeleton procedure that can be copied and edited to construct more tests. ADA A000100 A000100 This is a top level procedure that calls all the other executable timing tests. It is useful if there is a "MAKE" facility available. ( This may be too big to execute on many computers. Tests may be run individually or this may be split into smaller sets ) ADA A000101 This and A000102 are A000100 split in two pieces. A000091 .. L000003 ADA A000102 P000001 .. T000006 ADA A000103 All test, similar to A000100, with 10 iterations on tests that can be executed in a loop.A000043 PIWG_IO must be chosen to use this test. ADA A000104 This is the composite benchmark part of A000100 ADA A000105 This is the non-I/O non-tasking part of A000100 ADA A000106 This is the I/O part of A000100 ADA A000107 This is the tasking part of A000100 This group of tests measures task creation related timing. ADA C000001 ADA C000002 ADA C000003 This group of tests measures dynamic elaboration related timing. ADA D000001 ADA D000002 ADA D000003 ADA D000004 This group of tests measures exception related timing. ADA E000001 ADA E000002 ADA E000004 This group of tests measures coding style related timing. ADA F000001 ADA F000002 This group of tests measures TEXT_IO related timing. ADA G000001 ADA G000002 ADA G000003 ADA G000004 ADA G000005 ADA G000006 ADA G000007 This group of tests measures loop overhead related timing. ADA L000001 ADA L000002 ADA L000003 This group of tests measures procedure call related timing. ADA P000001 ADA P000002 ADA P000003 ADA P000004 ADA P000005 ADA P000006 ADA P000007 ADA P000010 ADA P000011 ADA P000012 ADA P000013 This group of tests measures task related timing. ADA T000001 ADA T000002 ADA T000003 ADA T000004 ADA T000005 ADA T000006 ADA T000007 this is a check on T000001 that only works on some machines The file ACOMPILE.COM is a sample script that runs the above tests. The file ACOMPILE.CLI is a sample script for Data General MV series for above The file COMPILE.COM is another sample script for the VAX The file COMPILE.CLI is a sample script for Data General MV series for above The file WCOMPILE.COM is another sample script for an embedded compiler running on a VAX. More on Run 2 The "Z" tests are for measuring compilation time Z000001 through Z000023 are all part of one test, see sample script ZCOMPILE see ZCOMPILE.COM for compilation speed test ( the historic Z tests one set ) see ZCOMPILE.CLI for another sample script. ZCOMPILE.LOG is a sample output More on Run 3 Z000110 through Z000315 are each measured for compile time. ( no link or execute ) see ZOOO111D.COM for compilation speed test ( individually timed ) see Z000111D.CLI for another sample script. Z000111D.LOG is a sample output :::::::::: T000001.ADA :::::::::: -- PERFORMANCE MEASUREMENT : Minimum entry call and return time -- task inside procedure -- 1 task 1 entry -- no select, do..end with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure T000001 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable -- task T1 is entry E1 ; end T1 ; task body T1 is begin loop accept E1 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E1 ; end loop ; end ; begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 00.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop T1.E1 ; -- this has control global increment and call inside end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "T000001" , "Tasking" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Minimum rendezvous, entry call and return time " , " 1 task 1 entry , task inside procedure " , " no select " ) ; abort T1 ; end T000001 ; :::::::::: T000002.ADA :::::::::: -- PERFORMANCE MEASUREMENT : task entry call and return time, 1 task 1 entry -- task in package, no select with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; package TASK_PACK_2 is task T1 is entry E1 ; end T1 ; end TASK_PACK_2 ; with TASK_PACK_2 ; use TASK_PACK_2 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure T000002 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop T1.E1 ; -- this has control global increment and call inside end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "T000002" , "Tasking" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Task entry call and return time measured" , " One task active, one entry in task, task in a package " , " no select statement " ) ; abort T1 ; end T000002 ; package body TASK_PACK_2 is task body T1 is begin loop accept E1 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E1 ; end loop ; end ; end TASK_PACK_2 ; :::::::::: T000003.ADA :::::::::: -- PERFORMANCE MEASUREMENT : Task entry call and return time measured -- Two tasks active, one entry per task -- tasks in a package -- no select statement with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; package TASK_PACK_3 is task T1 is entry E1 ; end T1 ; task T2 is entry E2 ; end T2 ; end TASK_PACK_3 ; with TASK_PACK_3 ; use TASK_PACK_3 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure T000003 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable CASE_COUNT : constant := 2 ; begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop T1.E1 ; -- this has control global increment and call inside T2.E2 ; -- this has control global increment and call inside end loop ; end loop ; GLOBAL := GLOBAL / CASE_COUNT ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; CPU_TIME := DURATION ( CPU_TIME / CASE_COUNT ) ; WALL_TIME := DURATION ( WALL_TIME / CASE_COUNT ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "T000003" , "Tasking" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Task entry call and return time measured" , " Two tasks active, one entry per task, tasks in a package " , " no select statement " ) ; abort T1 ; abort T2 ; end T000003 ; package body TASK_PACK_3 is task body T1 is begin loop accept E1 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E1 ; end loop ; end T1 ; task body T2 is begin loop accept E2 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E2 ; end loop ; end T2 ; end TASK_PACK_3 ; :::::::::: T000004.ADA :::::::::: -- PERFORMANCE MEASUREMENT : tasks entry call and return time -- 1 task 2 entries -- one select statement with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; package TASK_PACK_4 is task T1 is entry E1 ; entry E2 ; end T1 ; end TASK_PACK_4 ; with TASK_PACK_4 ; use TASK_PACK_4 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure T000004 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable CASE_COUNT : constant := 2 ; begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop T1.E1 ; -- this has control global increment and call inside T1.E2 ; -- this has control global increment and call inside end loop ; end loop ; GLOBAL := GLOBAL / CASE_COUNT ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; CPU_TIME := DURATION ( CPU_TIME / CASE_COUNT ) ; WALL_TIME := DURATION ( WALL_TIME / CASE_COUNT ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "T000004" , "Tasking" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Task entry call and return time measured" , " One tasks active, two entries, tasks in a package " , " using select statement " ) ; abort T1 ; end T000004 ; package body TASK_PACK_4 is task body T1 is begin loop select accept E1 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E1 ; or accept E2 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E2 ; end select ; end loop ; end T1 ; end TASK_PACK_4 ; :::::::::: T000005.ADA :::::::::: -- PERFORMANCE MEASUREMENT : active entry call and return time -- 10 tasks 1 entry each -- no select statement with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; package TASK_PACK_5 is task T1 is entry E1 ; end T1 ; task T2 is entry E2 ; end T2 ; task T3 is entry E3 ; end T3 ; task T4 is entry E4 ; end T4 ; task T5 is entry E5 ; end T5 ; task T6 is entry E6 ; end T6 ; task T7 is entry E7 ; end T7 ; task T8 is entry E8 ; end T8 ; task T9 is entry E9 ; end T9 ; task T10 is entry E10 ; end T10 ; end TASK_PACK_5 ; with TASK_PACK_5 ; use TASK_PACK_5 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure T000005 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable CASE_COUNT : constant := 10 ; begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. INTEGER ( CHECK_TIMES * CASE_COUNT ) loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES * CASE_COUNT ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop -- each entry has control global increment and call inside T5.E5 ; T7.E7 ; T2.E2 ; T1.E1 ; T10.E10 ; T3.E3 ; T9.E9 ; T8.E8 ; T4.E4 ; T6.E6 ; end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES * CASE_COUNT ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "T000005" , "Tasking" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Task entry call and return time measured" , " Ten tasks active, one entry per task, tasks in a package " , " no select statement " ) ; abort T1 ; abort T2 ; abort T3 ; abort T4 ; abort T5 ; abort T6 ; abort T7 ; abort T8 ; abort T9 ; abort T10 ; end T000005 ; package body TASK_PACK_5 is task body T1 is begin loop accept E1 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E1; end loop ; end T1 ; task body T2 is begin loop accept E2 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E2; end loop ; end T2 ; task body T3 is begin loop accept E3 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E3; end loop ; end T3 ; task body T4 is begin loop accept E4 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E4; end loop ; end T4 ; task body T5 is begin loop accept E5 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E5; end loop ; end T5 ; task body T6 is begin loop accept E6 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E6; end loop ; end T6 ; task body T7 is begin loop accept E7 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E7; end loop ; end T7 ; task body T8 is begin loop accept E8 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E8; end loop ; end T8 ; task body T9 is begin loop accept E9 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E9; end loop ; end T9 ; task body T10 is begin loop accept E10 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E10; end loop ; end T10 ; end TASK_PACK_5 ; :::::::::: T000006.ADA :::::::::: -- PERFORMANCE MEASUREMENT : tasks entry call and return time -- 1 task 10 entries -- one select statement package TASK_PACK_6 is task T1 is entry E1 ; entry E2 ; entry E3 ; entry E4 ; entry E5 ; entry E6 ; entry E7 ; entry E8 ; entry E9 ; entry E10 ; end T1 ; end TASK_PACK_6 ; with TASK_PACK_6 ; use TASK_PACK_6 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure T000006 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable CASE_COUNT : constant := 10 ; begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. INTEGER ( CHECK_TIMES * CASE_COUNT ) loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES * CASE_COUNT ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop T1.E5 ; T1.E7 ; T1.E2 ; T1.E1 ; T1.E10 ; T1.E3 ; T1.E9 ; T1.E8 ; T1.E4 ; T1.E6 ; end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES * CASE_COUNT ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "T000006" , "TASKING" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Task entry call and return time measurement" , " One task with ten entries , task in a package " , " one select statement, compare to T000005 " ) ; abort T1 ; end T000006 ; with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; package body TASK_PACK_6 is task body T1 is begin loop select accept E1 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E1; or accept E2 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E2; or accept E3 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E3; or accept E4 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E4; or accept E5 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E5; or accept E6 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E6; or accept E7 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E7; or accept E8 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E8; or accept E9 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E9; or accept E10 do GLOBAL := GLOBAL + A_ONE ; REMOTE ; end E10; or terminate ; end select ; end loop ; end T1 ; end TASK_PACK_6 ; :::::::::: T000007.ADA :::::::::: -- PERFORMANCE MEASUREMENT : Minimum entry call and return time -- 1 task 1 entry -- no select -- -- This ia a version on T000001 without the " do .. end ; " -- This will not work in most implementations because the checking -- to be sure the task executions have completed fails. -- If this test does run, please report it if the times differ -- from T000001. with REMOTE_GLOBAL ; use REMOTE_GLOBAL ; -- control optimization with ITERATION ; -- obtain stable measurement with PIWG_IO ; -- output results procedure T000007 is -- main procedure to execute CPU_TIME : DURATION ; -- CPU time for one feature execution WALL_TIME : DURATION ; -- WALL time for one feature execution CHECK_TIMES : constant := 100 ; -- inside loop count and check ITERATION_COUNT : INTEGER ; -- set and varied by ITERATION package STABLE : BOOLEAN ; -- true when measurement stable -- task T1 is entry E1 ; end T1 ; task body T1 is begin loop accept E1 ; GLOBAL := GLOBAL + A_ONE ; REMOTE ; end loop ; end ; begin ITERATION.START_CONTROL ; -- dummy to bring in pages on some machines delay 0.5 ; -- wait for stable enviornment on some machines ITERATION.INITIALIZE ( ITERATION_COUNT ) ; loop -- until stable measurement, ITERATION_COUNT increases each time -- -- Control loop -- ITERATION.START_CONTROL ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop GLOBAL := GLOBAL + A_ONE ; REMOTE ; end loop ; end loop ; ITERATION.STOP_CONTROL ( GLOBAL , CHECK_TIMES ) ; -- -- Test loop -- ITERATION.START_TEST ; for J in 1 .. ITERATION_COUNT loop GLOBAL := 0 ; for INSIDE_LOOP in 1 .. CHECK_TIMES loop T1.E1 ; -- this has control global increment and call inside end loop ; end loop ; ITERATION.STOP_TEST ( GLOBAL , CHECK_TIMES ) ; ITERATION.TEST_STABLE ( ITERATION_COUNT , STABLE ) ; exit when STABLE ; end loop ; -- ITERATION.FEATURE_TIMES ( CPU_TIME , WALL_TIME ) ; -- -- Printout -- PIWG_IO.PIWG_OUTPUT ( "T000007" , "Tasking" , CPU_TIME , WALL_TIME , ITERATION_COUNT , " Minimum rendezvous, entry call and return time " , " 1 task 1 entry " , " no select " ) ; abort T1 ; end T000007 ; :::::::::: TAPE.LOG :::::::::: Volume label: Label: VOL1 Serial: PIWG Access: Owner: Standard: 3 x A000001.ADA 1 blocks 81 bytes x A000002.ADA 1 blocks 1455 bytes x A000011.ADA 1 blocks 359 bytes x A000012.ADA 1 blocks 815 bytes x A000013.ADA 2 blocks 2552 bytes x A000014.ADA 1 blocks 703 bytes x A000015.ADA 1 blocks 200 bytes x A000016.ADA 2 blocks 2207 bytes x A000021.ADA 1 blocks 851 bytes x A000022.ADA 1 blocks 932 bytes x A000031.ADA 1 blocks 953 bytes x A000032.ADA 4 blocks 5553 bytes x A000033.ADA 3 blocks 5116 bytes x A000041.ADA 1 blocks 1386 bytes x A000042.ADA 1 blocks 1337 bytes x A000043.ADA 2 blocks 2907 bytes x A000044.ADA 1 blocks 843 bytes x A000049.ADA 3 blocks 5437 bytes x A000051.ADA 1 blocks 1109 bytes x A000052.ADA 1 blocks 1419 bytes x A000053.ADA 1 blocks 1795 bytes x A000054.ADA 1 blocks 1840 bytes x A000055.ADA 3 blocks 4034 bytes x A000091.ADA 8 blocks 14184 bytes x A000092.ADA 7 blocks 12949 bytes x A000093.ADA 11 blocks 18814 bytes x A000094.ADA 15 blocks 27462 bytes x A000098.ADA 2 blocks 2792 bytes x A000099.ADA 2 blocks 2581 bytes x A000100.ADA 1 blocks 1512 bytes x A000101.ADA 1 blocks 714 bytes x A000102.ADA 1 blocks 664 bytes x A000103.ADA 1 blocks 1735 bytes x A000104.ADA 1 blocks 273 bytes x A000105.ADA 1 blocks 743 bytes x A000106.ADA 1 blocks 301 bytes x A000107.ADA 1 blocks 436 bytes x ACOMPILE.CLI 1 blocks 928 bytes x ACOMPILE.COM 1 blocks 1347 bytes x ACOMPILE.LR1 25 blocks 46085 bytes x C000001.ADA 2 blocks 2583 bytes x C000002.ADA 2 blocks 2628 bytes x C000003.ADA 2 blocks 2307 bytes x COMPILE.CLI 1 blocks 759 bytes x COMPILE.COM 1 blocks 1165 bytes x COMPILE.L78 9 blocks 15565 bytes x COMPILE.L86 13 blocks 22354 bytes x COPY.COM 4 blocks 6256 bytes x COPY.R10 2 blocks 1988 bytes x D000001.ADA 2 blocks 2811 bytes x D000002.ADA 2 blocks 2865 bytes x D000003.ADA 2 blocks 2981 bytes x D000004.ADA 2 blocks 3098 bytes x E000001.ADA 2 blocks 2487 bytes x E000002.ADA 2 blocks 3178 bytes x E000004.ADA 2 blocks 3453 bytes x F000001.ADA 2 blocks 2103 bytes x F000002.ADA 2 blocks 2243 bytes x G000001.ADA 2 blocks 2551 bytes x G000002.ADA 2 blocks 2857 bytes x G000003.ADA 2 blocks 2346 bytes x G000004.ADA 2 blocks 2642 bytes x G000005.ADA 2 blocks 2367 bytes x G000006.ADA 2 blocks 2510 bytes x G000007.ADA 2 blocks 2184 bytes x L000001.ADA 5 blocks 7528 bytes x L000002.ADA 5 blocks 7582 bytes x L000003.ADA 5 blocks 7616 bytes x P000001.ADA 2 blocks 1842 bytes x P000002.ADA 2 blocks 2187 bytes x P000003.ADA 2 blocks 2327 bytes x P000004.ADA 2 blocks 2423 bytes x P000005.ADA 2 blocks 2364 bytes x P000006.ADA 2 blocks 2397 bytes x P000007.ADA 2 blocks 2395 bytes x P000010.ADA 2 blocks 2826 bytes x P000011.ADA 2 blocks 3477 bytes x P000012.ADA 2 blocks 2860 bytes x P000013.ADA 2 blocks 3181 bytes x READ.ME 5 blocks 8774 bytes x T000001.ADA 2 blocks 2237 bytes x T000002.ADA 2 blocks 2339 bytes x T000003.ADA 2 blocks 2888 bytes x T000004.ADA 2 blocks 2764 bytes x T000005.ADA 3 blocks 4437 bytes x T000006.ADA 3 blocks 3707 bytes x T000007.ADA 2 blocks 2418 bytes x TAPEDIST.LTR 3 blocks 5013 bytes x WCOMPILE.COM 2 blocks 2431 bytes x Z000001.ADA 1 blocks 72 bytes x Z000002.ADA 2 blocks 3033 bytes x Z000003.ADA 3 blocks 5108 bytes x Z000004.ADA 7 blocks 12709 bytes x Z000005.ADA 7 blocks 11466 bytes x Z000006.ADA 4 blocks 6032 bytes x Z000007.ADA 1 blocks 1458 bytes x Z000008.ADA 8 blocks 13133 bytes x Z000009.ADA 7 blocks 12573 bytes x Z000010.ADA 4 blocks 5944 bytes x Z000011.ADA 8 blocks 14070 bytes x Z000012.ADA 12 blocks 20086 bytes x Z000013.ADA 5 blocks 7752 bytes x Z000014.ADA 6 blocks 10876 bytes x Z000015.ADA 2 blocks 2289 bytes x Z000016.ADA 5 blocks 7625 bytes x Z000016A.ADA 8 blocks 13147 bytes x Z000017.ADA 5 blocks 7795 bytes x Z000017A.ADA 8 blocks 12780 bytes x Z000018.ADA 2 blocks 2032 bytes x Z000020.ADA 4 blocks 6106 bytes x Z000021.ADA 7 blocks 12174 bytes x Z000022.ADA 1 blocks 1555 bytes x Z000023.ADA 2 blocks 2698 bytes x Z000110.ADA 1 blocks 116 bytes x Z000111.ADA 1 blocks 1287 bytes x Z000111.COM 2 blocks 2385 bytes x Z000111D.CLI 2 blocks 2009 bytes x Z000111D.COM 3 blocks 4072 bytes x Z00011D.L86 6 blocks 10140 bytes x Z000112.ADA 2 blocks 2607 bytes x Z000113.ADA 4 blocks 6567 bytes x Z000114.ADA 7 blocks 13168 bytes x Z000121.ADA 2 blocks 2839 bytes x Z000122.ADA 4 blocks 5839 bytes x Z000123.ADA 9 blocks 14839 bytes x Z000124.ADA 17 blocks 29841 bytes x Z000131.ADA 1 blocks 1113 bytes x Z000132.ADA 2 blocks 2354 bytes x Z000133.ADA 4 blocks 6074 bytes x Z000134.ADA 7 blocks 12276 bytes x Z000141.ADA 3 blocks 4828 bytes x Z000142.ADA 6 blocks 9928 bytes x Z000143.ADA 14 blocks 25228 bytes x Z000151.ADA 4 blocks 5921 bytes x Z000152.ADA 7 blocks 12121 bytes x Z000153.ADA 17 blocks 30721 bytes x Z000161.ADA 3 blocks 5735 bytes x Z000162.ADA 6 blocks 11635 bytes x Z000171.ADA 3 blocks 4976 bytes x Z000172.ADA 6 blocks 9976 bytes x Z000173.ADA 14 blocks 24976 bytes x Z000181.ADA 1 blocks 1120 bytes x Z000182.ADA 2 blocks 2240 bytes x Z000183.ADA 4 blocks 5600 bytes x Z000184.ADA 7 blocks 11204 bytes x Z000191.ADA 3 blocks 4699 bytes x Z000192.ADA 5 blocks 9499 bytes x Z000193.ADA 13 blocks 23899 bytes x Z000201.ADA 2 blocks 2047 bytes x Z000202.ADA 3 blocks 4147 bytes x Z000203.ADA 6 blocks 10447 bytes x Z000211.ADA 2 blocks 3347 bytes x Z000212.ADA 4 blocks 6747 bytes x Z000213.ADA 10 blocks 16947 bytes x Z000221.ADA 1 blocks 678 bytes x Z000222.ADA 1 blocks 1638 bytes x Z000223.ADA 2 blocks 3240 bytes x Z000224.ADA 4 blocks 6640 bytes x Z000231.ADA 1 blocks 1382 bytes x Z000232.ADA 2 blocks 2762 bytes x Z000233.ADA 4 blocks 6902 bytes x Z000234.ADA 8 blocks 13808 bytes x Z000241.ADA 1 blocks 718 bytes x Z000242.ADA 1 blocks 1418 bytes x Z000243.ADA 2 blocks 3518 bytes x Z000244.ADA 4 blocks 7021 bytes x Z000254.ADA 5 blocks 8261 bytes x Z000264.ADA 4 blocks 6461 bytes x Z000274.ADA 12 blocks 21462 bytes x Z000281.ADA 1 blocks 231 bytes x Z000282.ADA 1 blocks 471 bytes x Z000283.ADA 1 blocks 1191 bytes x Z000284.ADA 2 blocks 2392 bytes x Z000291.ADA 1 blocks 532 bytes x Z000292.ADA 1 blocks 1082 bytes x Z000293.ADA 2 blocks 2732 bytes x Z000294.ADA 3 blocks 5484 bytes x Z000295.ADA 6 blocks 11184 bytes x Z000301.ADA 1 blocks 1117 bytes x Z000302.ADA 2 blocks 2287 bytes x Z000303.ADA 4 blocks 5797 bytes x Z000304.ADA 7 blocks 11650 bytes x Z000311.ADA 1 blocks 311 bytes x Z000312.ADA 1 blocks 631 bytes x Z000313.ADA 1 blocks 1591 bytes x Z000314.ADA 2 blocks 3192 bytes x Z000315.ADA 4 blocks 6492 bytes x ZCOMPILE.CLI 1 blocks 557 bytes x ZCOMPILE.COM 1 blocks 1139 bytes x ZCOMPILE.ICC 1 blocks 482 bytes x ZCOMPILE.L86 2 blocks 2380 bytes :::::::::: TAPEDIST.LTR :::::::::: November 17, 1986 Dear PIWG Tape Distribution, Enclosed is the tape distribution tree. The root nodes were mailed this letter and a tape at the same time everyone was sent the letter. If you did not get a tape, use the attached tree and mail a tape to your parent node. "Tape" may be disk or other media. The root nodes should make copies of the enclosed tape on the child nodes tape and mail the copies to their child nodes. The tape designation is TAPE_8_31_86. Older tapes are on file and this will not be the last tape. Please submit corrections and suggestions. More tests and improvements will be made as a result of the next PIWG workshop. Another, more complete tape will follow in six months to a year. 96 copies of this benchmark suite are being distributed. The purpose of PIWG is to develop the benchmarks and collect and disseminate results. Please send a copy of computer printout or a copy of the output or fill in the form below and on the back of this letter. It is important to get two sites to run the measurements on each target. To Jon S. Squire Westinghouse Electric Corp. P.O. Box 746 MS 4760 Baltimore, MD 21203 Call me or call in results if you wish. (301)765-3748 Jon S. Squire, PIWG Chair Results of PIWG TAPE_8_31_86 benchmark runs Date _______________ Submitted by: name _______________________________________________________ addr _______________________________________________________ _______________________________________________________ phone _______________________________________________________ Please use FULL nomenclature and versions Host _______________________________________________________ Target _______________________________________________________ Op System _______________________________________________________ Compiler _______________________________________________________ PLEASE send at least one measurement. If you can, make a second and third run to determine stability. If more than one run is made, supply the average and the number of run averaged. Throw out anomalous large or small runs. We want the best repeatable time that can be achieved without changing the test suite. Test time number of runs(if averaged) ---------- --------- ----------- A000091 Dhrystone _________ milliseconds ___ A000092 manufacturers math routines Whetstone _________ Average Whetstone rating KWIPS A000093 Whetstone _________ Average Whetstone rating KWIPS A000094 Hennesy Perm Towers Queens Intmm Mm Puzzle Quick Bubble Tree FFT Ack _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ Just the CPU time from each test C000001 _________ microseconds ___ C000002 _________ microseconds ___ C000003 _________ microseconds ___ D000001 _________ microseconds ___ D000002 _________ microseconds ___ D000003 _________ microseconds ___ D000004 _________ microseconds ___ E000001 _________ microseconds ___ E000002 _________ microseconds ___ E000004 _________ microseconds ___ F000001 _________ microseconds ___ F000002 _________ microseconds ___ G000001 _________ microseconds ___ G000002 _________ microseconds ___ G000003 _________ microseconds ___ G000004 _________ microseconds ___ G000005 _________ microseconds ___ G000006 _________ microseconds ___ G000007 _________ microseconds ___ L000001 _________ microseconds ___ L000002 _________ microseconds ___ L000003 _________ microseconds ___ P000001 _________ microseconds ___ P000002 _________ microseconds ___ P000003 _________ microseconds ___ P000004 _________ microseconds ___ P000005 _________ microseconds ___ P000006 _________ microseconds ___ P000007 _________ microseconds ___ P000010 _________ microseconds ___ P000011 _________ microseconds ___ P000012 _________ microseconds ___ P000013 _________ microseconds ___ T000001 _________ microseconds ___ T000002 _________ microseconds ___ T000003 _________ microseconds ___ T000004 _________ microseconds ___ T000005 _________ microseconds ___ T000006 _________ microseconds ___ T000007 _________ microseconds ___ Z000000 CPU TIME ______________________ ( Historic comparison ) WALL TIME ______________________ Other "Z" Tests ( Printout is the only practical way ) :::::::::: WCOMPILE.COM :::::::::: $! 1750A files to compile ( makes 2 down load images ) $ SET VERIFY $ SET NOON $ SET DEF [.SIGADA.TAPE_8_31_86.WADALIB] $ WADA [-]A000001 $ WADA [-]A000011 $ WADA [-]A000021 $ WADA [-]A000022 $ WADA [-]A000031 $ WADA [-]A000032 $ WADA [-]A000041 $ WADA [-]A000042 $ WADA [-]A000091 $ WADA [-]A000093 $ WADA/BIG [-]A000094 $ WADA [-]C000001 $ WADA [-]C000002 $ WADA [-]C000003 $ WADA [-]D000001 $ WADA [-]D000002 $ WADA [-]D000003 $ WADA [-]D000004 $ WADA [-]E000001 $ WADA [-]E000002 $ WADA [-]E000004 $ WADA [-]F000001 $ WADA [-]F000002 $ WADA [-]G000001 $ WADA [-]G000002 $ WADA [-]G000003 $ WADA [-]G000004 $ WADA [-]G000005 $ WADA [-]G000006 $ WADA [-]G000007 $ WADA [-]L000001 $ WADA [-]L000002 $ WADA [-]L000003 $ WADA [-]P000001 $ WADA [-]P000002 $ WADA [-]P000003 $ WADA [-]P000004 $ WADA [-]P000005 $ WADA [-]P000006 $ WADA [-]P000007 $ WADA [-]P000010 $ WADA [-]P000011 $ WADA [-]P000012 $ WADA [-]P000013 $ WADA [-]T000001 $ WADA [-]T000002 $ WADA [-]T000003 $ WADA [-]T000004 $ WADA [-]T000005 $ WADA [-]T000006 $ WADA [-]T000007 $ WADA/BIG [-]A000104 $ WLINKADA/MAP=A000104/SYM/EXE=A000104/SYS=CAS$LIB:ADARTPSBC- /LOAD=16#1000# A000104 $ TOSBC50 A000104 $ WADA [-]A000105 $ WLINKADA/MAP=A000105/SYM/EXE=A000105/SYS=CAS$LIB:ADARTPSBC- /LOAD=16#1000# A000105 $ TOSBC50 A000105 $ WADA [-]A000106 $ WLINKADA/MAP=A000106/SYM/EXE=A000106/SYS=CAS$LIB:ADARTPSBC- /LOAD=16#1000# A000106 $ TOSBC50 A000106 $ WADA [-]A000107 $ WLINKADA/MAP=A000107/SYM/EXE=A000107/SYS=CAS$LIB:ADARTPSBC- /LOAD=16#1000# A000107 $ TOSBC50 A000107 $ ! link the tasking tests individually to check for different timing $ WLINKADA/MAP=T000001/SYM/EXE=T000001/SYS=CAS$LIB:ADARTPSBC- /LOAD=16#1000# T000001 $ TOSBC50 T000001 $ WLINKADA/MAP=T000002/SYM/EXE=T000002/SYS=CAS$LIB:ADARTPSBC- /LOAD=16#1000# T000002 $ TOSBC50 T000002 $ WLINKADA/MAP=T000003/SYM/EXE=T000003/SYS=CAS$LIB:ADARTPSBC- /LOAD=16#1000# T000003 $ TOSBC50 T000003 $ WLINKADA/MAP=T000004/SYM/EXE=T000004/SYS=CAS$LIB:ADARTPSBC- /LOAD=16#1000# T000004 $ TOSBC50 T000004 $ WLINKADA/MAP=T000005/SYM/EXE=T000005/SYS=CAS$LIB:ADARTPSBC- /LOAD=16#1000# T000005 $ TOSBC50 T000005 $ WLINKADA/MAP=T000006/SYM/EXE=T000006/SYS=CAS$LIB:ADARTPSBC- /LOAD=16#1000# T000006 $ TOSBC50 T000006 $ WLINKADA/MAP=T000007/SYM/EXE=T000007/SYS=CAS$LIB:ADARTPSBC- /LOAD=16#1000# T000007 $ TOSBC50 T000007