Changeset 577 for Tests

Timestamp:

02/03/13 20:29:16 (9 years ago)

Author:

BegemoT

Message:

 

File:

• Tests/JAVA/test/src/main/java/test/threads/experiment2/Main.java (modified) (9 diffs)

Tests/JAVA/test/src/main/java/test/threads/experiment2/Main.java

@@ -10 +10 @@
 import com.lmax.disruptor.dsl.Disruptor;
 
-import static com.google.common.base.Preconditions.checkElementIndex;
 import static test.threads.queue.stressed.ITask.BenchmarkResult;
 
@@ -18 +17 @@
  */
 public class Main {
+        private static final boolean ASYNC = Boolean.getBoolean( "async" );
         private static final boolean PREDICABLE_SCAN = Boolean.getBoolean( "predictable" );
 
-        private static final int RUNS = Integer.getInteger( "runs", 16 );
-        private static final int TURNS = Integer.getInteger( "turns", 512 );
-
-        private static final int MESSAGES = 1 << 8;
-
-        private static final int REPOSITORY_SIZE = Integer.getInteger( "repository-size", 1 << 16 );
+        private static final int RUNS = Integer.getInteger( "runs", 32 );
+        private static final int TURNS = Integer.getInteger( "turns", 1 << 20 );
+
+        private static final int REPOSITORY_SIZE_EXP = Integer.getInteger( "repository-size-exp", 15 );
+        private static final int REPOSITORY_SIZE = 1 << REPOSITORY_SIZE_EXP;
         private static final int READ_PER_MESSAGE = 128;
         private static final int READ_STEP = 1025;
@@ -34 +33 @@
         public static void main( final String[] args ) {
                 System.out.printf(
-                                "Repo: %d, reads: %d/msg, step: %d %s\n" +
-                                                "%d runs by %d turns by %d messages each\n",
-                                REPOSITORY_SIZE, READ_PER_MESSAGE, READ_STEP,
-                                PREDICABLE_SCAN ? "predictable" : "random",
-                                RUNS, TURNS, MESSAGES
-                );
-
-
-                final Message[] messages = messages( MESSAGES, REPOSITORY_SIZE );
+                                "%s, Repo: double[%d], %d reads/msg, %s\n" +
+                                                "\t%d runs by %d messages each\n",
+                                ( ASYNC ? "ASYNC" : "SYNC" ),
+                                REPOSITORY_SIZE, READ_PER_MESSAGE,
+                                PREDICABLE_SCAN ? "step: " + READ_STEP : "random",
+                                RUNS, TURNS
+                );
+
+
                 final double[] repositoryA = new double[REPOSITORY_SIZE];
                 Arrays.fill( repositoryA, 1.0 );
@@ -52 +51 @@
                 final Phase b = new Phase( repositoryB );
 
-                final Function<Message, Message> function = composeSync( a, b );
+                final Function<Message, Message> function;
+                if( ASYNC ) {
+                        function = composeAsync( a, b );
+                } else {
+                        function = composeSync( a, b );
+                }
 
                 final BenchmarkResult[] results = benchmark(
                                 function,
-                                messages,
                                 TURNS,
                                 RUNS
                 );
 
+                double sum = 0;
+                double sum2 = 0;
                 for( final BenchmarkResult result : results ) {
+                        final double pps = 1.0 * result.timeElapsedNanoseconds / result.packetsCompleted;
+                        sum += pps;
+                        sum2 += pps * pps;
                         System.out.printf(
                                         "%d ns/%d packets -> %.1f ns/packet\n",
                                         result.timeElapsedNanoseconds,
                                         result.packetsCompleted,
-                                        1.0 * result.timeElapsedNanoseconds / result.packetsCompleted
+                                        pps
                         );
                 }
-        }
-
-        private static Message[] messages( final int size,
-                                           final int repositorySize ) {
-                final Message[] messages = new Message[size];
-                final int step = REPOSITORY_SIZE / size;
-                for( int i = 0; i < messages.length; i++ ) {
-                        final Message message = new Message();
-
-                        final int index = i * step % repositorySize;
-                        message.index = index;
-
-                        checkElementIndex( message.index, repositorySize );
-
-                        message.amount = i / 2 - size;
-
-                        messages[i] = message;
-                }
-                return messages;
+                final double avg = sum / results.length;
+                final double std = Math.sqrt( sum2 / results.length - avg * avg );
+                System.out.printf(
+                                "\t\t\taverage \t\t %.1f ns/packet (+/- %.0f%%)\n",
+                                avg,
+                                std / avg * 100
+                );
         }
 
@@ -95 +91 @@
                 if( PREDICABLE_SCAN ) {
                         for( int i = 0; i < READ_PER_MESSAGE; i++ ) {
-                                final int index = ( i * READ_STEP + offset ) % repository.length;
+                                final int index = ( i * READ_STEP + offset ) % REPOSITORY_SIZE;
                                 repository[index] += amount;
                         }
@@ -101 +97 @@
                         int index = offset;
                         for( int i = 0; i < READ_PER_MESSAGE; i++ ) {
-                                index = Math.abs( index * offset ) % repository.length;
+                                index = Math.abs( index * offset ) % REPOSITORY_SIZE;
                                 repository[index] += amount;
                         }
@@ -109 +105 @@
 
         private static BenchmarkResult[] benchmark( final Function<Message, Message> function,
-                                                    final Message[] messages,
                                                     final int turns,
                                                     final int runs ) {
                 final BenchmarkResult[] results = new BenchmarkResult[runs];
+                final Message message = new Message();
                 for( int run = 0; run < runs; run++ ) {
                         final long startedAt = System.nanoTime();
-                        for( int turn = 0; turn < turns; turn++ ) {
-                                benchmarkTurn( messages, function );
-                        }
+                        benchmarkTurn( message, function, turns );
                         final long finishedAt = System.nanoTime();
 
@@ -123 +117 @@
                                         -1,
                                         finishedAt - startedAt,
-                                        messages.length * turns
+                                        turns
                         );
                 }
@@ -129 +123 @@
         }
 
-        private static void benchmarkTurn( final Message[] messages,
-                                           final Function<Message, Message> f ) {
-                for( final Message message : messages ) {
-                        message.index++;
+        private static void benchmarkTurn( final Message message,
+                                           final Function<Message, Message> f,
+                                           final int turns ) {
+                final double amountStep = 1.0 / turns;
+                for( int turn = 0; turn < turns; turn++ ) {
+                        message.index = ( message.index + 1 ) / REPOSITORY_SIZE;
+                        message.amount += amountStep;
                         f.apply( message );
                 }