Changeset 574 for Tests


Ignore:
Timestamp:
01/30/13 21:08:08 (9 years ago)
Author:
BegemoT
Message:
 
File:
1 edited

Legend:

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

    r573 r574  
    1212 
    1313/** 
     14 * IDEA: 
     15 * use common cyclic buffer with small capacity 
     16 * in single-threaded case just go around, 
     17 * in multithreaded use lzaySet cursors 
     18 * 
    1419 * @author ruslan 
    1520 *         created 27.01.13 at 23:00 
     
    2126        private static final int TURNS = 1000; 
    2227        private static final int MESSAGES = 1 << 16; 
    23         private static final int REPOSITORY_SIZE = 1 << 20; 
     28        private static final int REPOSITORY_SIZE = 1 << 16; 
    2429 
    2530        public static void main( String[] args ) { 
     
    3035                Arrays.fill( repositoryB, 1.0 ); 
    3136 
    32                 final BenchmarkResult[] results = benchmarkSync( 
    33                                 messages, 
    34                                 repositoryA, 
    35                                 repositoryB, 
    36                                 TURNS, 
    37                                 RUNS 
    38                 ); 
     37                final TaskA a = new TaskA( repositoryA ); 
     38                final TaskB b = new TaskB( repositoryB ); 
     39 
     40                final Function<Message, Message> syncF = composeSync( a, b ); 
     41 
     42                final BenchmarkResult[] results = benchmark( syncF, messages, TURNS, RUNS ); 
     43 
    3944                for( final BenchmarkResult result : results ) { 
    4045                        System.out.printf( 
     
    4550                        ); 
    4651                } 
     52        } 
     53 
     54        private static Function<Message, Message> composeSync( final TaskA a, 
     55                                                               final TaskB b ) { 
     56                return Functions.compose( b, a ); 
    4757        } 
    4858 
     
    5969        } 
    6070 
    61         private static BenchmarkResult[] benchmarkSync( final Message[] messages, 
    62                                                         final double[] repositoryA, 
    63                                                         final double[] repositoryB, 
    64                                                         final int turns, 
    65                                                         final int runs ) { 
    66                 final TaskA a = new TaskA( repositoryA ); 
    67                 final TaskB b = new TaskB( repositoryB ); 
    68                 final Function<Message, Message> ba = Functions.compose( b, a ); 
     71 
     72        private static BenchmarkResult[] benchmark( final Function<Message, Message> function, 
     73                                                    final Message[] messages, 
     74                                                    final int turns, 
     75                                                    final int runs ) { 
    6976                final BenchmarkResult[] results = new BenchmarkResult[runs]; 
    7077                for( int j = 0; j < runs; j++ ) { 
    7178                        final long startedAt = System.nanoTime(); 
    7279                        for( int i = 0; i < turns; i++ ) { 
    73                                 benchmarkSyncTurn( messages, ba ); 
     80                                benchmarkTurn( messages, function ); 
    7481                        } 
    7582                        final long finishedAt = System.nanoTime(); 
     
    8491        } 
    8592 
    86         private static void benchmarkSyncTurn( final Message[] messages, 
    87                                                final Function<Message, Message> f ) { 
     93        private static void benchmarkTurn( final Message[] messages, 
     94                                           final Function<Message, Message> f ) { 
    8895                for( final Message message : messages ) { 
    8996                        f.apply( message ); 
    9097                } 
    91         } 
    92  
    93         private static BenchmarkResult[] benchmarkAsync( final Message[] messages, 
    94                                                          final double[] repositoryA, 
    95                                                          final double[] repositoryB, 
    96                                                          final int turns, 
    97                                                          final int runs ) { 
    98                 final TaskA a = new TaskA( repositoryA ); 
    99                 final TaskB b = new TaskB( repositoryB ); 
    100                 final Function<Message, Message> ba = composeAsync( b, a ); 
    101                 final BenchmarkResult[] results = new BenchmarkResult[runs]; 
    102                 for( int j = 0; j < runs; j++ ) { 
    103                         final long startedAt = System.nanoTime(); 
    104                         for( int i = 0; i < turns; i++ ) { 
    105                                 benchmarkSyncTurn( messages, ba ); 
    106                         } 
    107                         final long finishedAt = System.nanoTime(); 
    108  
    109                         results[j] = new BenchmarkResult( 
    110                                         -1, 
    111                                         finishedAt - startedAt, 
    112                                         messages.length * turns 
    113                         ); 
    114                 } 
    115                 return results; 
    11698        } 
    11799 
     
    127109                                }, 
    128110                                Executors.newSingleThreadExecutor(), 
    129                                 new SingleThreadedClaimStrategy( 128 ), 
     111                                new SingleThreadedClaimStrategy( 32 ), 
    130112                                new BusySpinWaitStrategy() 
    131113                ); 
     
    141123 
    142124                return new Function<Message, Message>() { 
     125                        private final Translator translator = new Translator(); 
     126 
    143127                        @Override 
    144128                        public Message apply( final Message in ) { 
    145                                 final Message inA = a.apply( in ); 
    146                                 disruptor.publishEvent( new EventTranslator<Message>() { 
    147                                         @Override 
    148                                         public Message translateTo( final Message event, 
    149                                                                     final long sequence ) { 
    150                                                 event.from = inA.from; 
    151                                                 event.to = inA.to; 
    152                                                 event.amount = inA.amount; 
    153                                                 return event; 
    154                                         } 
    155                                 } ); 
     129                                a.apply( in ); 
     130                                translator.with( in ); 
     131                                disruptor.publishEvent( translator ); 
    156132                                return null; 
    157133                        } 
     
    194170        } 
    195171 
     172        private static class Translator implements EventTranslator<Message> { 
     173                private Message message; 
     174 
     175                public void with( final Message message ) { 
     176                        this.message = message; 
     177                } 
     178 
     179                @Override 
     180                public Message translateTo( final Message event, 
     181                                            final long sequence ) { 
     182                        event.from = message.from; 
     183                        event.to = message.to; 
     184                        event.amount = message.amount; 
     185                        return event; 
     186                } 
     187        } 
    196188} 
Note: See TracChangeset for help on using the changeset viewer.