Changeset 598


Ignore:
Timestamp:
03/09/14 12:12:19 (7 years ago)
Author:
BegemoT
Message:
 
Location:
Tests/JAVA/test
Files:
4 added
1 deleted
10 edited
1 moved

Legend:

Unmodified
Added
Removed
  • Tests/JAVA/test/pom.xml

    r597 r598  
    8282            <groupId>org.openjdk.jmh</groupId> 
    8383            <artifactId>jmh-core</artifactId> 
    84             <version>0.2</version> 
     84            <version>0.5.2</version> 
     85        </dependency> 
     86        <dependency> 
     87            <groupId>org.openjdk.jmh</groupId> 
     88            <artifactId>jmh-generator-annprocess</artifactId> 
     89            <version>0.5.2</version> 
     90            <scope>provided</scope> 
    8591        </dependency> 
    8692        <!-- testing support --> 
     
    8894            <groupId>junit</groupId> 
    8995            <artifactId>junit</artifactId> 
    90             <version>4.8.1</version> 
     96            <version>4.11</version> 
    9197            <scope>compile</scope> 
    9298        </dependency> 
     
    234240            <classifier>sources</classifier> 
    235241        </dependency>--> 
     242 
     243        <dependency> 
     244            <groupId>org.openjdk.jmh</groupId> 
     245            <artifactId>jmh-core</artifactId> 
     246            <version>0.5.3</version> 
     247            <classifier>sources</classifier> 
     248        </dependency> 
    236249        <dependency> 
    237250            <groupId>net.sf.trove4j</groupId> 
     
    310323                <version>3.1</version> 
    311324                <configuration> 
    312                     <source>1.6</source> 
    313                     <target>1.6</target> 
     325                    <source>1.7</source> 
     326                    <target>1.7</target> 
    314327                    <encoding>UTF-8</encoding> 
    315328                </configuration> 
  • Tests/JAVA/test/src/main/java/test/hflabs/Alphabet.java

    r171 r598  
    2222 */ 
    2323public class Alphabet { 
    24     /** 
    25      * map index -> letter 
    26      */ 
    27     private final char[] letters; 
    28     /** 
    29      * map letter -> index. Неиспользованные слоты забиты -1 
    30      */ 
    31     private final int[] indexes; 
     24        /** map index -> letter */ 
     25        private final char[] letters; 
     26        /** map letter -> index. Неиспользованные слоты забиты -1 */ 
     27        private final int[] indexes; 
    3228 
    3329 
    34     private final int minIndex; 
    35     /** 
    36      * for debuging 
    37      */ 
    38     private final String lettersString; 
     30        private final int minIndex; 
     31        /** for debuging */ 
     32        private final String lettersString; 
    3933 
    40     public Alphabet( final String lettersStr ) { 
    41         if ( lettersStr == null ) { 
    42             throw new IllegalArgumentException( "LEtters can't be null" ); 
    43         } 
    44         if ( lettersStr.isEmpty() ) { 
    45             throw new IllegalArgumentException( "LEtters can't be empty" ); 
    46         } 
    47         this.lettersString = lettersStr; 
    48         this.letters = lettersString.toCharArray(); 
     34        public Alphabet( final String lettersStr ) { 
     35                if( lettersStr == null ) { 
     36                        throw new IllegalArgumentException( "Letters can't be null" ); 
     37                } 
     38                if( lettersStr.isEmpty() ) { 
     39                        throw new IllegalArgumentException( "Letters can't be empty" ); 
     40                } 
     41                this.lettersString = lettersStr; 
     42                this.letters = lettersString.toCharArray(); 
    4943 
    50         //filling char -> index map 
    51         int maxIndex = 0; 
    52         int minIndex = Character.MAX_VALUE; 
    53         for ( int i = 0; i < this.letters.length; i++ ) { 
    54             final int letter = this.letters[i]; 
    55             if ( maxIndex < letter ) { 
    56                 maxIndex = letter; 
    57             } 
    58             if ( minIndex > letter ) { 
    59                 minIndex = letter; 
    60             } 
    61         } 
    62         this.minIndex = minIndex; 
     44                //filling char -> index map 
     45                int maxIndex = 0; 
     46                int minIndex = Character.MAX_VALUE; 
     47                for( int i = 0; i < this.letters.length; i++ ) { 
     48                        final int letter = this.letters[i]; 
     49                        if( maxIndex < letter ) { 
     50                                maxIndex = letter; 
     51                        } 
     52                        if( minIndex > letter ) { 
     53                                minIndex = letter; 
     54                        } 
     55                } 
     56                this.minIndex = minIndex; 
    6357 
    64         final int length = maxIndex - minIndex + 1; 
    65         indexes = new int[length]; 
    66         Arrays.fill( indexes, -1 ); 
     58                final int length = maxIndex - minIndex + 1; 
     59                indexes = new int[length]; 
     60                Arrays.fill( indexes, -1 ); 
    6761 
    68         for ( int i = 0; i < this.letters.length; i++ ) { 
    69             final char letter = this.letters[i]; 
    70             indexes[letter - minIndex] = i; 
    71         } 
    72     } 
     62                for( int i = 0; i < this.letters.length; i++ ) { 
     63                        final char letter = this.letters[i]; 
     64                        indexes[letter - minIndex] = i; 
     65                } 
     66        } 
    7367 
    7468 
    75     public int index( final char letter ) { 
    76         assert ( lettersString.indexOf( letter ) >= 0 ) : "Character [" + letter + "] (" + ( ( int )letter ) + ") is not in alphabet"; 
    77         final int index = indexes[letter - minIndex]; 
    78         if ( index < 0 ) { 
    79             throw new IllegalArgumentException( "Index for [" + letter + "] (" + ( ( int )letter ) + ") is -1" ); 
    80         } 
    81         return index; 
    82     } 
     69        public int index( final char letter ) { 
     70                assert ( lettersString.indexOf( letter ) >= 0 ) : "Character [" + letter + "] (" + ( ( int ) letter ) + ") is not in alphabet"; 
     71                final int index = indexes[letter - minIndex]; 
     72                if( index < 0 ) { 
     73                        throw new IllegalArgumentException( "Index for [" + letter + "] (" + ( ( int ) letter ) + ") is -1" ); 
     74                } 
     75                return index; 
     76        } 
    8377 
    84     /** 
    85      * @param index индекс буквы в алфавите. [0, length()] 
    86      * @return символ с заданным индексом 
    87      */ 
    88     public char letter( final int index ) { 
    89         assert ( index >= 0 && index < length() ) : "Index " + index + " must be >=0 && <" + length(); 
    90         return letters[index]; 
    91     } 
     78        /** 
     79         * @param index индекс буквы в алфавите. [0, length()] 
     80         * 
     81         * @return символ с заданным индексом 
     82         */ 
     83        public char letter( final int index ) { 
     84                assert ( index >= 0 && index < length() ) : "Index " + index + " must be >=0 && <" + length(); 
     85                return letters[index]; 
     86        } 
    9287 
    93     /** 
    94      * @return размер алфавита 
    95      */ 
    96     public int length() { 
    97         return letters.length; 
    98     } 
     88        /** @return размер алфавита */ 
     89        public int length() { 
     90                return letters.length; 
     91        } 
    9992 
    100     /** 
    101      * @return список всех букв в алфавите (безопасная копия) 
    102      */ 
    103     public char[] letters() { 
    104         return letters.clone(); 
    105     } 
     93        /** @return список всех букв в алфавите (безопасная копия) */ 
     94        public char[] letters() { 
     95                return letters.clone(); 
     96        } 
    10697 
    107     /** 
    108     * @return строку случайной длины от minLen до maxLen, 
    109     *         заполненную случайными символами алфавита 
    110     */ 
    111     public String randomString( final Random rnd, 
    112                                 final int minLen, 
    113                                 final int maxLen ) { 
    114         final int length = minLen + rnd.nextInt( maxLen - minLen + 1 ); 
    115         final char[] chars = new char[length]; 
    116         for ( int i = 0; i < chars.length; i++ ) { 
    117             final char ch = letter( rnd.nextInt( length() ) ); 
    118             assert ( Character.isUpperCase( ch ) ); 
    119             chars[i] = ch; 
    120         } 
    121         return new String( chars ); 
    122     } 
     98        /** 
     99        * @return строку случайной длины от minLen до maxLen, 
     100        *         заполненную случайными символами алфавита 
     101        */ 
     102        public String randomString( final Random rnd, 
     103                                    final int minLen, 
     104                                    final int maxLen ) { 
     105                final int length = minLen + rnd.nextInt( maxLen - minLen + 1 ); 
     106                final char[] chars = new char[length]; 
     107                for( int i = 0; i < chars.length; i++ ) { 
     108                        final char ch = letter( rnd.nextInt( length() ) ); 
     109                        assert ( Character.isUpperCase( ch ) ); 
     110                        chars[i] = ch; 
     111                } 
     112                return new String( chars ); 
     113        } 
    123114 
    124115 
    125     /** 
    126     * Вызывает proc.execute(...) для каждого возможного набора символов (из алфавита) 
    127     * длиной sequenceLength. 
    128     * <p/> 
    129     * Другими словами -- перебирает все возможные N-символьные комбинации, коих будет, 
    130     * очевидно, length() ^ sequenceLength 
    131     */ 
    132     public void forEachSequence( final int sequenceLength, 
    133                                  final IProcedure<CharSequence> proc ) { 
    134         final int abcLen = length(); 
     116        /** 
     117        * Вызывает proc.execute(...) для каждого возможного набора символов (из алфавита) 
     118        * длиной sequenceLength. 
     119        * <p/> 
     120        * Другими словами -- перебирает все возможные N-символьные комбинации, коих будет, 
     121        * очевидно, length() ^ sequenceLength 
     122        */ 
     123        public void forEachSequence( final int sequenceLength, 
     124                                     final IProcedure<CharSequence> proc ) { 
     125                final int abcLen = length(); 
    135126 
    136         final int[] indexes = new int[sequenceLength]; 
    137         //Arrays.fill( indexes, letters[0] ); 
     127                final int[] indexes = new int[sequenceLength]; 
     128                //Arrays.fill( indexes, letters[0] ); 
    138129 
    139         //buffer 
    140         final StringBuilder sequence = new StringBuilder( sequenceLength ); 
    141         sequence.setLength( sequenceLength ); 
     130                //buffer 
     131                final StringBuilder sequence = new StringBuilder( sequenceLength ); 
     132                sequence.setLength( sequenceLength ); 
    142133 
    143         for ( int i = 0; true/*i < sequenceLength * abcLen*/; i++ ) { 
    144             for ( int j = 0; j < indexes.length; j++ ) { 
    145                 final char ch = letter( indexes[j] ); 
    146                 sequence.setCharAt( j, ch ); 
    147             } 
    148             proc.execute( sequence ); 
     134                for( int i = 0; true/*i < sequenceLength * abcLen*/; i++ ) { 
     135                        for( int j = 0; j < indexes.length; j++ ) { 
     136                                final char ch = letter( indexes[j] ); 
     137                                sequence.setCharAt( j, ch ); 
     138                        } 
     139                        proc.execute( sequence ); 
    149140 
    150             //next sequence 
    151             boolean overflow = true; 
    152             for ( int j = 0; j < indexes.length; j++ ) { 
    153                 indexes[j]++; 
    154                 if ( indexes[j] < abcLen ) { 
    155                     overflow = false; 
    156                     break; 
    157                 } else { 
    158                     indexes[j] = 0;//и переходим к следующему разряду 
    159                 } 
    160             } 
    161             if ( overflow ) { 
    162                 break; 
    163             } 
    164         } 
    165     } 
     141                        //next sequence 
     142                        boolean overflow = true; 
     143                        for( int j = 0; j < indexes.length; j++ ) { 
     144                                indexes[j]++; 
     145                                if( indexes[j] < abcLen ) { 
     146                                        overflow = false; 
     147                                        break; 
     148                                } else { 
     149                                        indexes[j] = 0;//и переходим к следующему разряду 
     150                                } 
     151                        } 
     152                        if( overflow ) { 
     153                                break; 
     154                        } 
     155                } 
     156        } 
    166157 
    167     public interface IProcedure<T> { 
    168         public void execute( final T arg ); 
    169     } 
     158        public interface IProcedure<T> { 
     159                public void execute( final T arg ); 
     160        } 
    170161} 
  • Tests/JAVA/test/src/main/java/test/waitingstrategies/Blocking.java

    r597 r598  
    1 package test.jmh; 
     1package test.waitingstrategies; 
    22 
    33/** 
  • Tests/JAVA/test/src/main/java/test/waitingstrategies/Parking.java

    r597 r598  
    1 package test.jmh; 
     1package test.waitingstrategies; 
    22 
    33import java.util.concurrent.locks.LockSupport; 
  • Tests/JAVA/test/src/main/java/test/waitingstrategies/ParkingUnparking.java

    r597 r598  
    1 package test.jmh; 
     1package test.waitingstrategies; 
    22 
    33import java.util.concurrent.locks.LockSupport; 
  • Tests/JAVA/test/src/main/java/test/waitingstrategies/Sleeping.java

    r597 r598  
    1 package test.jmh; 
     1package test.waitingstrategies; 
    22 
    33/** 
  • Tests/JAVA/test/src/main/java/test/waitingstrategies/Spinning.java

    r597 r598  
    1 package test.jmh; 
     1package test.waitingstrategies; 
    22 
    33import org.openjdk.jmh.logic.BlackHole; 
  • Tests/JAVA/test/src/main/java/test/waitingstrategies/WaitStrategyBenchmark.java

    r597 r598  
    1 package test.jmh; 
     1package test.waitingstrategies; 
    22 
    33import java.util.concurrent.TimeUnit; 
  • Tests/JAVA/test/src/main/java/test/waitingstrategies/WaitingStrategy.java

    r597 r598  
    1 package test.jmh; 
     1package test.waitingstrategies; 
    22 
    33/** 
  • Tests/JAVA/test/src/main/java/test/waitingstrategies/Yielding.java

    r597 r598  
    1 package test.jmh; 
     1package test.waitingstrategies; 
    22 
    33/** 
Note: See TracChangeset for help on using the changeset viewer.