This is a comparison of Ada 83 "standard tasks" = T000008 vs
                        Ada 95 "protected"      = T000009
on various machines.
Note vast differences in ratio with the only difference in the code
being "task" vs "protected" definition of the buffer task, shown below.


          Bullet - Alpha 4000 OpenVMS 7.1
          0.020000002 = clock resolution used for iteration stability 

Test Name:   T000008                         Class Name:  Tasking
CPU Time:       46.78  MICROSECONDS          plus or minus      2.339
Wall/CPU:        1.00  ratio.                Iteration Count:   102400
Test Description:
 Measure the average time to pass an integer 
 from a producer task through a buffer task 
 to a consumer task 

Test Name:   T000009                         Class Name:  Tasking
CPU Time:       22.51  MICROSECONDS          plus or minus      1.125
Wall/CPU:        1.00  ratio.                Iteration Count:   204800
Test Description:
 Measure the average time to pass an integer 
 from a producer task through a buffer task 
 to a consumer task, using protected buffer 



          Rocket - Alpha 2100  OpenVMS 6.2
          0.0201 = clock resolution used for iteration stability 

Test Name:   T000008                         Class Name:  Tasking
CPU Time:       52.93  MICROSECONDS          plus or minus      2.646
Wall/CPU:        1.00  ratio.                Iteration Count:   102400
Test Description:
 Measure the average time to pass an integer 
 from a producer task through a buffer task 
 to a consumer task 

no T000009


          Sigpro - sparc 75MHz  SunOS 4.1.3
          0.006466002 = clock resolution used for iteration stability 

Test Name:   T000008                         Class Name:  Tasking
CPU Time:      332.15  MICROSECONDS          plus or minus     16.607
Wall/CPU:        1.00  ratio.                Iteration Count:   6400
Test Description:
 Measure the average time to pass an integer 
 from a producer task through a buffer task 
 to a consumer task 

Test Name:   T000009                         Class Name:  Tasking
CPU Time:      140.85  MICROSECONDS          plus or minus      7.042
Wall/CPU:        1.00  ratio.                Iteration Count:   12800
Test Description:
 Measure the average time to pass an integer 
 from a producer task through a buffer task 
 to a consumer task, using protected buffer 



          LTA001 - sparc 200Mhz  Solaris 2.5.1
          0.001629762 = clock resolution used for iteration stability 

Test Name:   T000008                         Class Name:  Tasking
CPU Time:      309.94  MICROSECONDS          plus or minus     15.497
Wall/CPU:        1.00  ratio.                Iteration Count:   6400
Test Description:
 Measure the average time to pass an integer 
 from a producer task through a buffer task 
 to a consumer task 

Test Name:   T000009                         Class Name:  Tasking
CPU Time:       42.29  MICROSECONDS          plus or minus      2.114
Wall/CPU:        1.00  ratio.                Iteration Count:   25600
Test Description:
 Measure the average time to pass an integer 
 from a producer task through a buffer task 
 to a consumer task, using protected buffer 



          Pentium 166MHz  Windows 95
          0.100000002 = clock resolution used for iteration stability 

Test Name:   T000008                         Class Name:  Tasking
CPU Time:      336.91  MICROSECONDS          plus or minus     16.846
Wall/CPU:        1.00  ratio.                Iteration Count:   102400
Test Description:
 Measure the average time to pass an integer 
 from a producer task through a buffer task 
 to a consumer task 

Test Name:   T000009                         Class Name:  Tasking
CPU Time:       82.62  MICROSECONDS          plus or minus      4.131
Wall/CPU:        1.00  ratio.                Iteration Count:   409600
Test Description:
 Measure the average time to pass an integer 
 from a producer task through a buffer task 
 to a consumer task, using protected buffer 



package TASK_PACK_8 is                             -- T000008
  task type BUFFER_TYPE is
    entry TAKE_ITEM ( ITEM : in  INTEGER ) ;
    entry GIVE_ITEM ( ITEM : out INTEGER ) ;
  end BUFFER_TYPE ;

  BUFFER_TASK : BUFFER_TYPE ;
  ...
end TASK_PACK_8 ;

package body TASK_PACK_8 is
  task body BUFFER_TYPE is
    type BUFFER_RANGE is range 0..20 ;
    subtype BUFFER_INDEX is BUFFER_RANGE range 1..BUFFER_RANGE'LAST ;
    BUFFER : array ( BUFFER_INDEX ) of INTEGER ;
    HEAD, TAIL : BUFFER_INDEX := BUFFER_INDEX'FIRST ;
    BUFFER_COUNT : BUFFER_RANGE := 0 ;
  begin
    loop
      select
        when BUFFER_COUNT < BUFFER_RANGE'LAST =>
          accept TAKE_ITEM ( ITEM : in  INTEGER ) do
            BUFFER ( HEAD ) := ITEM ;
            HEAD := ( HEAD mod BUFFER_RANGE'LAST ) + 1 ;
            BUFFER_COUNT := BUFFER_COUNT + 1 ;
          end TAKE_ITEM ;
      or
        when BUFFER_COUNT > 0 =>
          accept GIVE_ITEM ( ITEM : out INTEGER ) do
            ITEM := BUFFER ( TAIL ) ;
            TAIL := ( TAIL mod BUFFER_RANGE'LAST ) + 1 ;
            BUFFER_COUNT := BUFFER_COUNT - 1 ;
          end GIVE_ITEM ;
      end select ;
    end loop ;
  end BUFFER_TYPE ;
  ...
end TASK_PACK_8 ;



package TASK_PACK_9 is                     -- T000009
  type BUFFER_RANGE is range 0..20 ;
  subtype BUFFER_INDEX is BUFFER_RANGE range 1..BUFFER_RANGE'LAST ;
  type BUFFER_ARRAY is array ( BUFFER_INDEX ) of INTEGER ;

  protected TASK_BUFF_9 is
    entry TAKE_ITEM ( ITEM : in  INTEGER ) ;
    entry GIVE_ITEM ( ITEM : out INTEGER ) ;
  private
    BUFFER : BUFFER_ARRAY ;
    HEAD, TAIL : BUFFER_INDEX := BUFFER_INDEX'FIRST ;
    BUFFER_COUNT : BUFFER_RANGE := 0 ;
  end TASK_BUFF_9 ;
  ...
end TASK_PACK_9 ;

package body TASK_PACK_9 is
  protected body TASK_BUFF_9 is
    entry TAKE_ITEM ( ITEM : in  INTEGER )
      when BUFFER_COUNT < BUFFER_RANGE'LAST is
    begin
      BUFFER ( HEAD ) := ITEM ;
      HEAD := ( HEAD mod BUFFER_RANGE'LAST ) + 1 ;
      BUFFER_COUNT := BUFFER_COUNT + 1 ;
    end TAKE_ITEM ;

    entry GIVE_ITEM ( ITEM : out INTEGER )
      when BUFFER_COUNT > 0 is
    begin
      ITEM := BUFFER ( TAIL ) ;
      TAIL := ( TAIL mod BUFFER_RANGE'LAST ) + 1 ;
      BUFFER_COUNT := BUFFER_COUNT - 1 ;
    end GIVE_ITEM ;
  end TASK_BUFF_9 ;
  ...
end TASK_PACK_9 ;