Changeset 577 for Tests


Ignore:
Timestamp:
02/03/13 20:29:16 (9 years ago)
Author:
BegemoT
Message:
 
File:
1 edited

Legend:

Unmodified
Added
Removed
  • Tests/JAVA/test/src/main/java/test/threads/experiment2/Main.java

    r576 r577  
    1010import com.lmax.disruptor.dsl.Disruptor; 
    1111 
    12 import static com.google.common.base.Preconditions.checkElementIndex; 
    1312import static test.threads.queue.stressed.ITask.BenchmarkResult; 
    1413 
     
    1817 */ 
    1918public class Main { 
     19        private static final boolean ASYNC = Boolean.getBoolean( "async" ); 
    2020        private static final boolean PREDICABLE_SCAN = Boolean.getBoolean( "predictable" ); 
    2121 
    22         private static final int RUNS = Integer.getInteger( "runs", 16 ); 
    23         private static final int TURNS = Integer.getInteger( "turns", 512 ); 
    24  
    25         private static final int MESSAGES = 1 << 8; 
    26  
    27         private static final int REPOSITORY_SIZE = Integer.getInteger( "repository-size", 1 << 16 ); 
     22        private static final int RUNS = Integer.getInteger( "runs", 32 ); 
     23        private static final int TURNS = Integer.getInteger( "turns", 1 << 20 ); 
     24 
     25        private static final int REPOSITORY_SIZE_EXP = Integer.getInteger( "repository-size-exp", 15 ); 
     26        private static final int REPOSITORY_SIZE = 1 << REPOSITORY_SIZE_EXP; 
    2827        private static final int READ_PER_MESSAGE = 128; 
    2928        private static final int READ_STEP = 1025; 
     
    3433        public static void main( final String[] args ) { 
    3534                System.out.printf( 
    36                                 "Repo: %d, reads: %d/msg, step: %d %s\n" + 
    37                                                 "%d runs by %d turns by %d messages each\n", 
    38                                 REPOSITORY_SIZE, READ_PER_MESSAGE, READ_STEP, 
    39                                 PREDICABLE_SCAN ? "predictable" : "random", 
    40                                 RUNS, TURNS, MESSAGES 
    41                 ); 
    42  
    43  
    44                 final Message[] messages = messages( MESSAGES, REPOSITORY_SIZE ); 
     35                                "%s, Repo: double[%d], %d reads/msg, %s\n" + 
     36                                                "\t%d runs by %d messages each\n", 
     37                                ( ASYNC ? "ASYNC" : "SYNC" ), 
     38                                REPOSITORY_SIZE, READ_PER_MESSAGE, 
     39                                PREDICABLE_SCAN ? "step: " + READ_STEP : "random", 
     40                                RUNS, TURNS 
     41                ); 
     42 
     43 
    4544                final double[] repositoryA = new double[REPOSITORY_SIZE]; 
    4645                Arrays.fill( repositoryA, 1.0 ); 
     
    5251                final Phase b = new Phase( repositoryB ); 
    5352 
    54                 final Function<Message, Message> function = composeSync( a, b ); 
     53                final Function<Message, Message> function; 
     54                if( ASYNC ) { 
     55                        function = composeAsync( a, b ); 
     56                } else { 
     57                        function = composeSync( a, b ); 
     58                } 
    5559 
    5660                final BenchmarkResult[] results = benchmark( 
    5761                                function, 
    58                                 messages, 
    5962                                TURNS, 
    6063                                RUNS 
    6164                ); 
    6265 
     66                double sum = 0; 
     67                double sum2 = 0; 
    6368                for( final BenchmarkResult result : results ) { 
     69                        final double pps = 1.0 * result.timeElapsedNanoseconds / result.packetsCompleted; 
     70                        sum += pps; 
     71                        sum2 += pps * pps; 
    6472                        System.out.printf( 
    6573                                        "%d ns/%d packets -> %.1f ns/packet\n", 
    6674                                        result.timeElapsedNanoseconds, 
    6775                                        result.packetsCompleted, 
    68                                         1.0 * result.timeElapsedNanoseconds / result.packetsCompleted 
     76                                        pps 
    6977                        ); 
    7078                } 
    71         } 
    72  
    73         private static Message[] messages( final int size, 
    74                                            final int repositorySize ) { 
    75                 final Message[] messages = new Message[size]; 
    76                 final int step = REPOSITORY_SIZE / size; 
    77                 for( int i = 0; i < messages.length; i++ ) { 
    78                         final Message message = new Message(); 
    79  
    80                         final int index = i * step % repositorySize; 
    81                         message.index = index; 
    82  
    83                         checkElementIndex( message.index, repositorySize ); 
    84  
    85                         message.amount = i / 2 - size; 
    86  
    87                         messages[i] = message; 
    88                 } 
    89                 return messages; 
     79                final double avg = sum / results.length; 
     80                final double std = Math.sqrt( sum2 / results.length - avg * avg ); 
     81                System.out.printf( 
     82                                "\t\t\taverage \t\t %.1f ns/packet (+/- %.0f%%)\n", 
     83                                avg, 
     84                                std / avg * 100 
     85                ); 
    9086        } 
    9187 
     
    9591                if( PREDICABLE_SCAN ) { 
    9692                        for( int i = 0; i < READ_PER_MESSAGE; i++ ) { 
    97                                 final int index = ( i * READ_STEP + offset ) % repository.length; 
     93                                final int index = ( i * READ_STEP + offset ) % REPOSITORY_SIZE; 
    9894                                repository[index] += amount; 
    9995                        } 
     
    10197                        int index = offset; 
    10298                        for( int i = 0; i < READ_PER_MESSAGE; i++ ) { 
    103                                 index = Math.abs( index * offset ) % repository.length; 
     99                                index = Math.abs( index * offset ) % REPOSITORY_SIZE; 
    104100                                repository[index] += amount; 
    105101                        } 
     
    109105 
    110106        private static BenchmarkResult[] benchmark( final Function<Message, Message> function, 
    111                                                     final Message[] messages, 
    112107                                                    final int turns, 
    113108                                                    final int runs ) { 
    114109                final BenchmarkResult[] results = new BenchmarkResult[runs]; 
     110                final Message message = new Message(); 
    115111                for( int run = 0; run < runs; run++ ) { 
    116112                        final long startedAt = System.nanoTime(); 
    117                         for( int turn = 0; turn < turns; turn++ ) { 
    118                                 benchmarkTurn( messages, function ); 
    119                         } 
     113                        benchmarkTurn( message, function, turns ); 
    120114                        final long finishedAt = System.nanoTime(); 
    121115 
     
    123117                                        -1, 
    124118                                        finishedAt - startedAt, 
    125                                         messages.length * turns 
     119                                        turns 
    126120                        ); 
    127121                } 
     
    129123        } 
    130124 
    131         private static void benchmarkTurn( final Message[] messages, 
    132                                            final Function<Message, Message> f ) { 
    133                 for( final Message message : messages ) { 
    134                         message.index++; 
     125        private static void benchmarkTurn( final Message message, 
     126                                           final Function<Message, Message> f, 
     127                                           final int turns ) { 
     128                final double amountStep = 1.0 / turns; 
     129                for( int turn = 0; turn < turns; turn++ ) { 
     130                        message.index = ( message.index + 1 ) / REPOSITORY_SIZE; 
     131                        message.amount += amountStep; 
    135132                        f.apply( message ); 
    136133                } 
Note: See TracChangeset for help on using the changeset viewer.