Changeset 559 for Tests


Ignore:
Timestamp:
07/28/12 11:51:26 (10 years ago)
Author:
BegemoT
Message:
 
Location:
Tests/JAVA/test
Files:
4 added
3 edited

Legend:

Unmodified
Added
Removed

  • Tests/JAVA/test/src/main/java/test/threads/FalseSharingExample.java

    r556 r559  
    22 
    33import java.util.*; 
     4import java.util.concurrent.atomic.AtomicLongArray; 
    45 
    56/** 
    … …  
    910public class FalseSharingExample { 
    1011        public static final int THREADS_COUNT = Runtime.getRuntime().availableProcessors(); 
     12 
     13        public interface Arena { 
     14                public void write( final int cellIndex, 
     15                                   final long value ); 
     16        } 
     17 
     18        public static class PlainArrayArena implements Arena { 
     19                private final long[] array; 
     20 
     21                public PlainArrayArena( final int size ) { 
     22                        array = new long[size]; 
     23                } 
     24 
     25                @Override 
     26                public void write( final int cellIndex, 
     27                                   final long value ) { 
     28                        array[cellIndex] = value; 
     29                } 
     30        } 
     31 
     32        public static class VolatileArrayArena implements Arena { 
     33                private final AtomicLongArray array; 
     34 
     35                public VolatileArrayArena( final int size ) { 
     36                        array = new AtomicLongArray( size ); 
     37                } 
     38 
     39                @Override 
     40                public void write( final int cellIndex, 
     41                                   final long value ) { 
     42                        array.set( cellIndex, value ); 
     43                } 
     44        } 
     45 
     46        public static class LazySetArrayArena implements Arena { 
     47                private final AtomicLongArray array; 
     48 
     49                public LazySetArrayArena( final int size ) { 
     50                        array = new AtomicLongArray( size ); 
     51                } 
     52 
     53                @Override 
     54                public void write( final int cellIndex, 
     55                                   final long value ) { 
     56                        array.lazySet( cellIndex, value ); 
     57                } 
     58        } 
    1159 
    1260        private static class WriterThread extends Thread { 
    … …  
    2270                } 
    2371 
    24                 private final long[] sharedArea; 
     72                private final Arena sharedArea; 
    2573                private final int cellIndex; 
    2674 
    … …  
    2876 
    2977                private WriterThread( final int number, 
    30                                       final long[] sharedArea, 
     78                                      final Arena sharedArea, 
    3179                                      final int cellIndex ) { 
    3280                        super( "WriterThread[" + number + "]" ); 
    … …  
    4795                                //actual write 
    4896                                for( int j = 0; j < BATCH_SIZE; j++ ) { 
    49                                         sharedArea[cellIndex] = i; 
     97                                        sharedArea.write( cellIndex, i ); 
    5098                                } 
    5199 
    … …  
    115163        public static void main( final String[] args ) throws Exception { 
    116164 
    117                 final int distance = Integer.parseInt( args[0] ); 
     165                final int distance = Integer.getInteger( "distance", 1 ); 
    118166                System.out.printf( "Distance: %d, threads %d\n", distance, THREADS_COUNT ); 
    119167 
    120168                final WriterThread[] threads = new WriterThread[THREADS_COUNT]; 
    121169 
    122                 final long[] sharedArea = new long[THREADS_COUNT * distance]; 
     170                final Arena sharedArea = createArena( THREADS_COUNT * distance ); 
    123171                for( int i = 0; i < threads.length; i++ ) { 
    124172                        final int cellToWrite = i * distance; 
    … …  
    146194                for( final WriterThread writerThread : threads ) { 
    147195                        final BenchmarkResult result = writerThread.stopAndWaitForResults(); 
    148                         System.out.println( result.print() ); 
    149                 } 
    150  
     196                        System.out.printf( 
     197                                        "%d writes takes %d ns (%.1f ns/write)\n", 
     198                                        result.turnsCompleted, 
     199                                        result.timeEllapsedNs, 
     200                                        result.timeEllapsedNs * 1.0 / result.turnsCompleted 
     201                        ); 
     202                } 
     203 
     204        } 
     205 
     206        private static Arena createArena( final int size ) { 
     207                return new PlainArrayArena( size ); 
    151208        } 
    152209} 

  • Tests/JAVA/test/src/main/java/test/threads/queue/unstressed/impl/CABSESDUnrolledQueue.java

    r529 r559  
    1313 */ 
    1414public class CABSESDUnrolledQueue<T> implements IQueue<T> { 
    15     private static final boolean USE_BIT_MASK = true 
    16             ; 
    17     /* Elements range: [headCursor, tailCursor) 
    18     * 
    19     * (tailCursor - headCursor) == elements count 
    20     * 
    21     * 0 <= (tailCursor - headCursor) <= length  => state invariant 
    22     * 
    23     * tailCursor - headCursor == length         => queue is full 
    24     * tailCursor - headCursor == 0              => queue is empty 
    25     * 
    26     * (headCursor % size ) is the index of first item in queue 
    27     * (tailCursor % size ) is the index of _cell_ for _next last item_ 
    28     */ 
     15        private static final boolean USE_BIT_MASK = true; 
     16        /* Elements range: [headCursor, tailCursor) 
     17                * 
     18                * (tailCursor - headCursor) == elements count 
     19                * 
     20                * 0 <= (tailCursor - headCursor) <= length  => state invariant 
     21                * 
     22                * tailCursor - headCursor == length         => queue is full 
     23                * tailCursor - headCursor == 0              => queue is empty 
     24                * 
     25                * (headCursor % size ) is the index of first item in queue 
     26                * (tailCursor % size ) is the index of _cell_ for _next last item_ 
     27                */ 
    2928 
    30     private final int length; 
    31     private volatile long headCursor = 0; 
    32     //    private volatile long p11, p12, p13, p14, p15, p16, p17, p18 = 7; 
    33     private volatile long tailCursor = 0; 
    34 //    private volatile long p21, p22, p23, p24, p25, p26, p27, p28 = 8; 
     29        private final int length; 
     30        private volatile long headCursor = 0; 
     31        private volatile long p11, p12, p13, p14, p15, p16, p17, p18 = 7; 
     32        private volatile long tailCursor = 0; 
     33        private volatile long p21, p22, p23, p24, p25, p26, p27, p28 = 8; 
    3534 
    36     public long sumPaddingToPreventOptimisation() { 
    37 //        return p11 + p12 + p13 + p14 + p15 + p16 + p17 + p18 
    38 //                + p21 + p22 + p23 + p24 + p25 + p26 + p27 + p28; 
    39         return 0; 
    40     } 
     35        public long sumPaddingToPreventOptimisation() { 
     36                return p11 + p12 + p13 + p14 + p15 + p16 + p17 + p18 
     37                                + p21 + p22 + p23 + p24 + p25 + p26 + p27 + p28; 
     38//        return 0; 
     39        } 
    4140 
    42     private final T[] elements; 
     41        private final T[] elements; 
    4342 
    4443 
    45     public CABSESDUnrolledQueue( final int length ) { 
    46         checkArgument( length > 0, "length(%s) must be >0", length ); 
    47         if ( USE_BIT_MASK ) { 
    48             checkArgument( Integer.bitCount( length ) == 1, "length(%s) must be a power of 2", length ); 
    49         } 
    50         this.length = length; 
    51         elements = ( T[] ) new Object[length]; 
    52         sumPaddingToPreventOptimisation(); 
    53     } 
     44        public CABSESDUnrolledQueue( final int length ) { 
     45                checkArgument( length > 0, "length(%s) must be >0", length ); 
     46                if( USE_BIT_MASK ) { 
     47                        checkArgument( Integer.bitCount( length ) == 1, "length(%s) must be a power of 2", length ); 
     48                } 
     49                this.length = length; 
     50                elements = ( T[] ) new Object[length]; 
     51                sumPaddingToPreventOptimisation(); 
     52        } 
    5453 
    55     private long nextTail() { 
    56         final long tail = tailCursor; 
    57         waitWhileNotFull( tail ); 
     54        private long nextTail() { 
     55                final long tail = tailCursor; 
     56                waitWhileNotFull( tail ); 
    5857 
    59         assert ( tail == tailCursor ) : "tail=" + tail + " <> tailCursor=" + tailCursor + " -- seems like multi-threaded enqueue() detected!"; 
    60         return tail + 1; 
    61     } 
     58                assert ( tail == tailCursor ) : "tail=" + tail + " <> tailCursor=" + tailCursor + " -- seems like multi-threaded enqueue() detected!"; 
     59                return tail + 1; 
     60        } 
    6261 
    63     private long nextHead() { 
    64         final long head = headCursor; 
    65         waitWhileNotEmpty( head ); 
    66         assert ( head == headCursor ) : "head=" + head + " <> headCursor=" + headCursor + " -- seems like multi-threaded dequeue() detected!"; 
    67         return head + 1; 
    68     } 
     62        private long nextHead() { 
     63                final long head = headCursor; 
     64                waitWhileNotEmpty( head ); 
     65                assert ( head == headCursor ) : "head=" + head + " <> headCursor=" + headCursor + " -- seems like multi-threaded dequeue() detected!"; 
     66                return head + 1; 
     67        } 
    6968 
    7069 
    71     private void publishTail( final long newTail ) { 
    72         assert ( newTail >= headCursor ) : "newTail(" + newTail + ") < headCursor(" + headCursor + ")"; 
    73         tailCursor = newTail; 
    74     } 
     70        private void publishTail( final long newTail ) { 
     71                assert ( newTail >= headCursor ) : "newTail(" + newTail + ") < headCursor(" + headCursor + ")"; 
     72                tailCursor = newTail; 
     73        } 
    7574 
    76     private void publishHead( final long newHead ) { 
    77         assert ( newHead <= tailCursor ) : "newHead(" + newHead + ") > tailCursor(" + tailCursor + ")"; 
    78         headCursor = newHead; 
    79     } 
     75        private void publishHead( final long newHead ) { 
     76                assert ( newHead <= tailCursor ) : "newHead(" + newHead + ") > tailCursor(" + tailCursor + ")"; 
     77                headCursor = newHead; 
     78        } 
    8079 
    8180 
    82     private void waitWhileNotFull( final long tail ) { 
    83         //spin-wait: "while not full" 
    84         final long target = tail - length; 
    85         while ( target == headCursor ) { 
     81        private void waitWhileNotFull( final long tail ) { 
     82                //spin-wait: "while not full" 
     83                final long target = tail - length; 
     84                while( target == headCursor ) { 
    8685//            Thread.yield(); 
    87         } 
    88     } 
     86                } 
     87        } 
    8988 
    90     private void waitWhileNotEmpty( final long head ) { 
    91         //spin-wait: "while not empty" 
    92         while ( head == tailCursor ) { 
     89        private void waitWhileNotEmpty( final long head ) { 
     90                //spin-wait: "while not empty" 
     91                while( head == tailCursor ) { 
    9392//            Thread.yield(); 
    94         } 
    95     } 
     93                } 
     94        } 
    9695 
    97     public void enqueue( final T item ) { 
    98         final long newTail = nextTail(); 
     96        public void enqueue( final T item ) { 
     97                final long newTail = nextTail(); 
    9998 
    100         final int index = index( newTail ); 
    101         elements[index] = item; 
     99                final int index = index( newTail ); 
     100                elements[index] = item; 
    102101 
    103         publishTail( newTail ); 
    104     } 
     102                publishTail( newTail ); 
     103        } 
    105104 
    106     public T dequeue() { 
    107         final long newHead = nextHead(); 
     105        public T dequeue() { 
     106                final long newHead = nextHead(); 
    108107 
    109         final int index = index( newHead ); 
    110         final T item = elements[index]; 
    111         elements[index] = null;//for GC 
     108                final int index = index( newHead ); 
     109                final T item = elements[index]; 
     110                elements[index] = null;//for GC 
    112111 
    113         publishHead( newHead ); 
    114         return item; 
    115     } 
     112                publishHead( newHead ); 
     113                return item; 
     114        } 
    116115 
    117     private int index( final long sequence ) { 
    118         if ( USE_BIT_MASK ) { 
    119             return ( int ) ( ( sequence - 1 ) & ( length - 1 ) ); 
    120         } else { 
    121             return ( int ) ( ( sequence - 1 ) % length ); 
    122         } 
    123     } 
     116        private int index( final long sequence ) { 
     117                if( USE_BIT_MASK ) { 
     118                        return ( int ) ( ( sequence - 1 ) & ( length - 1 ) ); 
     119                } else { 
     120                        return ( int ) ( ( sequence - 1 ) % length ); 
     121                } 
     122        } 
    124123 
    125     public int size() { 
    126         return ( int ) ( tailCursor - headCursor ); 
    127     } 
     124        public int size() { 
     125                return ( int ) ( tailCursor - headCursor ); 
     126        } 
    128127 
    129     @SuppressWarnings( "unchecked" ) 
    130     public static <T> IBoundedQueueFactory<T, CABSESDUnrolledQueue<T>> factory() { 
    131         return FACTORY; 
    132     } 
     128        @SuppressWarnings( "unchecked" ) 
     129        public static <T> IBoundedQueueFactory<T, CABSESDUnrolledQueue<T>> factory() { 
     130                return FACTORY; 
     131        } 
    133132 
    134     public static final IBoundedQueueFactory FACTORY = new IBoundedQueueFactory<Object, CABSESDUnrolledQueue<Object>>() { 
    135         @Override 
    136         public CABSESDUnrolledQueue<Object> create( final int size ) { 
    137             return new CABSESDUnrolledQueue<Object>( size ); 
    138         } 
     133        public static final IBoundedQueueFactory FACTORY = new IBoundedQueueFactory<Object, CABSESDUnrolledQueue<Object>>() { 
     134                @Override 
     135                public CABSESDUnrolledQueue<Object> create( final int size ) { 
     136                        return new CABSESDUnrolledQueue<Object>( size ); 
     137                } 
    139138 
    140         @Override 
    141         public String toString() { 
    142             return "SESDUnrolledQueue[" + ( USE_BIT_MASK ? "&" : "%" ) + "]"; 
    143         } 
    144     }; 
     139                @Override 
     140                public String toString() { 
     141                        return "SESDUnrolledQueue[" + ( USE_BIT_MASK ? "&" : "%" ) + "]"; 
     142                } 
     143        }; 
    145144} 

  • Tests/JAVA/test/unstressed_task_benchmark_statistics.sh

    r516 r559  
    11#!/bin/sh 
    22 
    3 export JAVA_HOME="/Library/Java/JavaVirtualMachines/JDK 1.7.0 Developer Preview.jdk/Contents/Home" 
    4 MAVEN_OPTS="-Xms512M -Xmx1024M -server -XX:+AggressiveOpts -XX:+UseCondCardMark -da" 
     3#JAVA_HOME="/Library/Java/JavaVirtualMachines/JDK 1.7.0 Developer Preview.jdk/Contents/Home" 
     4#MAVEN_OPTS="-Xms512M -Xmx1024M -server -XX:+AggressiveOpts -XX:+UseCondCardMark -da" 
     5MAVEN_OPTS="-Xms512M -Xmx1024M -server -XX:+AggressiveOpts -da" 
    56 
    67#echo $JAVA_HOME 
Note: See TracChangeset for help on using the changeset viewer.