Changeset 595 for Tests


Ignore:
Timestamp:
12/11/13 22:14:29 (8 years ago)
Author:
BegemoT
Message:
 
Location:
Tests/JAVA/logger
Files:
3 added
2 deleted
23 edited
2 copied
2 moved

Legend:

Unmodified
Added
Removed

  • Tests/JAVA/logger/data/fastlogger.gp

    r594 r595  
    3320        42.255  1.162  215.663 46.158 196.558 16.781  196.767 37.289 
    4440        92.913  6.329  253.847 32.929 226.350 10.907  265.738 65.212 
    5 60        136.054 7.684  310.251 31.304 283.729 7.236   319.147 12.502 
    6 80        182.154 5.383  341.193 14.609 311.826 16.462  353.109 4.913 
    7 120       271.064 1.241  436.285 71.450 407.997 29.112  441.341 7.325 
     560        136.054 7.684  277.956 33.280 273.613 24.717  305.827 39.635 
     680        182.154 5.383  313.551 31.005 319.657 41.473  339.366 62.172 
     7120       271.064 1.241  396.511 48.478 385.620 35.202  422.444 33.591 
    88200       441.316 7.130  578.085 9.334  573.498 15.924  593.476 4.326 

  • Tests/JAVA/logger/logger.iml

    r590 r595  
    1313    <orderEntry type="inheritedJdk" /> 
    1414    <orderEntry type="sourceFolder" forTests="false" /> 
     15    <orderEntry type="module-library"> 
     16      <library> 
     17        <CLASSES> 
     18          <root url="jar://$MODULE_DIR$/libs/gflogger-20131211.jar!/" /> 
     19        </CLASSES> 
     20        <JAVADOC /> 
     21        <SOURCES /> 
     22      </library> 
     23    </orderEntry> 
    1524    <orderEntry type="library" name="Maven: org.openjdk.jmh:jmh-core:0.2" level="project" /> 
    1625    <orderEntry type="library" name="Maven: args4j:args4j:2.0.16" level="project" /> 
    … …  
    2534    <orderEntry type="library" name="Maven: org.apache.logging.log4j:log4j-api:2.0-beta9" level="project" /> 
    2635    <orderEntry type="library" name="Maven: org.apache.logging.log4j:log4j-core:2.0-beta9" level="project" /> 
     36    <orderEntry type="library" name="Maven: org.gflogger:gflogger:0.9" level="project" /> 
    2737    <orderEntry type="library" name="Maven: com.google.guava:guava:15.0" level="project" /> 
    2838    <orderEntry type="library" name="Maven: org.springframework:spring-core:3.0.5.RELEASE" level="project" /> 

  • Tests/JAVA/logger/pom.xml

    r590 r595  
    117117            <artifactId>log4j-core</artifactId> 
    118118            <version>2.0-beta9</version> 
     119        </dependency> 
     120 
     121        <dependency> 
     122            <groupId>org.gflogger</groupId> 
     123            <artifactId>gflogger</artifactId> 
     124            <version>0.9</version> 
     125            <scope>system</scope> 
     126            <systemPath>${project.basedir}/libs/gflogger-20131211.jar</systemPath> 
    119127        </dependency> 
    120128 

  • Tests/JAVA/logger/scripts/batch.sh

    r594 r595  
    11#!/bin/bash 
    22 
    3 for PAYLOAD in 0 20 40 60 80 120 200 
     3for PAYLOAD in 400 800 1200 
     4#for PAYLOAD in 0 20 40 60 80 120 200 
    45do 
    5         java -server -Xmx512M -da -Dwriter-backoff=$PAYLOAD -Dcells-per-record=8 -jar target/benchmarks.jar ".*$1.*" -f -w 2 -wi 5 -i 5 -r 10 -gc true >> "data/$1.results" 
     6        java -server -Xmx512M -da -Dlength-pow=22 -Dwriter-backoff=$PAYLOAD -Dcells-per-record=8 -jar target/benchmarks.jar ".*$1.*" -f -w 2 -wi 5 -i 5 -r 10 -gc true >> "data/$1.results" 
    67done 
    78 

  • Tests/JAVA/logger/scripts/fastlogger.gnuplot

    r594 r595  
    1717set style line 2 lt 1 lc rgb "blue"   lw 4  pt 7 ps 1 
    1818set style line 3 lt 1 lc rgb "green"  lw 4  pt 7 ps 1 
    19 set style line 4 lt 1 lc rgb "red"    lw 4  pt 7 ps 1 
     19set style line 4 lt 1 lc rgb "red"    lw 8  pt 7 ps 1.5 
    2020 
    2121set xlabel "payload, ns"  font "Verdana,18" 
    … …  
    2525set output "fastlogger-wp.ps" 
    2626plot "data/fastlogger.gp" \ 
    27                 using 2:($4-$2)                     title "log('%...') x3"  with lp ls 2,\ 
    28      "" using 2:($4-$2):(sqrt($5**2+$3**2)) notitle with yerrorbars ls 2,\ 
    29      "" using 2:($6-$2)                     title "cache TL x3" with lp ls 3,\ 
    30      "" using 2:($6-$2):(sqrt($7**2+$3**2)) notitle with yerrorbars ls 3,\ 
    31      "" using 2:($8-$2)                     title "cache per thread x3"   with lp ls 4,\ 
    32      "" using 2:($8-$2):(sqrt($9**2+$3**2)) notitle with yerrorbars ls 4 
     27                using 2:($4-$2)                     title "log('%...') x3"  with lp ls 4,\ 
     28     "" using 2:($4-$2):(sqrt($5**2+$3**2)) notitle with yerrorbars ls 4,\ 
     29     "" using 2:($6-$2)                     title "cached TL x3" with lp ls 2,\ 
     30     "" using 2:($6-$2):(sqrt($7**2+$3**2)) notitle with yerrorbars ls 2 
     31#     "" using 2:($8-$2)                     title "cache per thread x3"   with lp ls 4,\ 
     32#     "" using 2:($8-$2):(sqrt($9**2+$3**2)) notitle with yerrorbars ls 4 
    3333 
    3434 
     35set key right top font "Verdana, 18" spacing 1.5 nobox 
     36set xrange [0:460] 
     37set output "fastlogger-all.ps" 
     38plot "data/fastlogger.gp" \ 
     39                using 2:($4-$2)                     title "log('%...') x3"  with lp ls 4,\ 
     40     "" using 2:($4-$2):(sqrt($5**2+$3**2)) notitle with yerrorbars ls 4,\ 
     41     "data/writebuffer.gp" \ 
     42                index 0 using 2:($4-$2)                     title "write(64b) x3, drain x1"  with lp ls 3,\ 
     43     "" index 0 using 2:($4-$2):(sqrt($5**2+$3**2)) notitle with yerrorbars ls 3,\ 
     44         "data/mcsdsequencer.gp" \ 
     45           using 2:($3-$2) title ".claim() x3" with lp ls 2,\ 
     46        "" using 2:($3-$2):4 notitle with yerrorbars ls 2,\ 
     47     "data/atomics.gp" \ 
     48        using 2:($8-$2)                     title ".incAndGet() x3 .get() x1"   with lp ls 1,\ 
     49        "" using 2:($8-$2):(sqrt($9**2+$3**2)) notitle with yerrorbars ls 1 
     50 

  • Tests/JAVA/logger/scripts/multiwritebuffer.gnuplot

    r594 r595  
    1515 
    1616set style line 1 lt 3 lc rgb "black"  lw 4  pt 1 ps 1 
    17 set style line 2 lt 1 lc rgb "blue"   lw 4  pt 7 ps 1 
    18 set style line 3 lt 1 lc rgb "green"  lw 4  pt 7 ps 1 
    19 set style line 4 lt 1 lc rgb "red"    lw 4  pt 7 ps 1 
     17set style line 2 lt 1 lc rgb "red"   lw 7  pt 7 ps 1 
    2018 
    2119set xlabel "payload, ns"  font "Verdana,18" 
    … …  
    2523set output "multiwritebuffer.ps" 
    2624plot "data/multiwritebuffer.gp" \ 
    27                 index 0 using 2:($4-$2)                     title "Write(64b) x3, Drain x1"  with lp ls 2,\ 
     25                index 0 using 2:($4-$2)                     title "*Write(64b) x3, Drain x1"  with lp ls 2,\ 
    2826     "" index 0 using 2:($4-$2):(sqrt($5**2+$3**2)) notitle with yerrorbars ls 2,\ 
     27         "data/writebuffer.gp" \ 
     28                index 0 using 2:($4-$2)                     title "Write(64b) x3, Drain x1"  with lp ls 1,\ 
     29     "" index 0 using 2:($4-$2):(sqrt($5**2+$3**2)) notitle with yerrorbars ls 1,\ 
    2930 
    3031 
    31 #set xlabel "size, bytes"  font "Verdana,18" 
    32 #set ylabel "ns/iteration" font "Verdana,18" 
    33 #set xtics 32 
    34 #set xrange [0:] 
    35 #set output "writebuffer-size.ps" 
    36 #plot "data/writebuffer.gp" \ 
    37 #               index 1 using ($2*8):($3-$1)   title "Write(size) x3"  with lp ls 2,\ 
    38 #     "" index 1 using ($2*8):($3-$1):4 notitle with yerrorbars ls 2 
    3932 
    40  

  • Tests/JAVA/logger/src/main/java/com/db/logger/api/FastLogger.java

    r590 r595  
    1111        public LogMessage messageThreadLocal( final String messageFormat ); 
    1212 
    13         public LogMessage message( final String messageFormat ); 
     13        public LogMessage log( final String messageFormat ); 
    1414 
    1515} 

  • Tests/JAVA/logger/src/main/java/com/db/logger/api/FluentLogBuilder.java

    r589 r595  
    1111        public FluentLogBuilder with( final long value ); 
    1212 
    13         public void log(); 
     13        public void submit(); 
    1414} 

  • Tests/JAVA/logger/src/main/java/com/db/logger/api/LogMessage.java

    r589 r595  
    1414        public FluentLogBuilder with( final long value ); 
    1515 
    16         public void log(); 
     16        public void submit(); 
    1717 
    1818} 

  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/PlaygroundMain.java

    r594 r595  
    11package com.db.logger.api.impl; 
    22 
    3 import java.util.concurrent.ExecutorService; 
    4 import java.util.concurrent.Executors; 
    5 import java.util.concurrent.TimeUnit; 
     3import java.io.*; 
     4import java.nio.ByteBuffer; 
     5import java.nio.channels.FileChannel; 
     6import java.util.concurrent.*; 
    67 
    7 import com.db.logger.api.impl.logger.RingBuffer; 
    8 import com.db.logger.api.impl.logger.MCSDSequencer; 
    9 import com.db.logger.api.impl.logger.formatters.SimpleLogMessage; 
    10 import com.db.logger.api.impl.logger.buffer.PlainLongsBuffer; 
     8import com.db.logger.api.impl.logger.*; 
     9import com.db.logger.api.impl.logger.buffer.UnsafeLongsBuffer; 
     10import com.db.logger.api.impl.logger.buffer.ILongsBuffer; 
     11import com.db.logger.io.storage.RawWriter; 
    1112import com.db.logger.timesource.impl.JDKCombinedTimestampSource; 
    1213import com.db.logger.timesource.impl.SynchronousJDKOffsetCalculator; 
    1314import org.apache.commons.logging.Log; 
    1415import org.apache.commons.logging.LogFactory; 
    15  
    16 import static com.db.logger.api.impl.logger.WaitingStrategy.SPINNING; 
     16import org.apache.log4j.BasicConfigurator; 
    1717 
    1818/** 
    … …  
    2424 
    2525        static { 
     26                BasicConfigurator.configure(); 
    2627        } 
    2728 
    … …  
    3132 
    3233                final int length = ( 1 << 14 ); 
    33                 final PlainLongsBuffer buffer = new PlainLongsBuffer( length ); 
    34                 final MCSDSequencer sequencer = new MCSDSequencer( length ); 
     34                final ILongsBuffer buffer = new UnsafeLongsBuffer( length ); 
     35 
     36                final File file = new File( "output.log" ); 
     37                log.info( "File " + file ); 
     38                file.delete(); 
     39//              file.deleteOnExit(); 
     40                final FastLoggerImpl logger = new FastLoggerImpl( 
     41                                new ThreadFactory() { 
     42                                        @Override 
     43                                        public Thread newThread( final Runnable r ) { 
     44                                                return new Thread( r ); 
     45                                        } 
     46                                }, 
     47                                buffer, 
     48                                WaitingStrategy.SPINNING, 
     49                                new RawFileWriter( file ) 
     50                ); 
     51 
     52                logger.startDraining(); 
    3553 
    3654                final int workers = Runtime.getRuntime().availableProcessors() - 1; 
    3755                final ExecutorService workersPool = Executors.newFixedThreadPool( workers ); 
    3856 
    39                 new Thread( new Runnable() { 
    40                         @Override 
    41                         public void run() { 
    42                                 for(; ; ) { 
    43                                         sequencer.drainTo( new MCSDSequencer.Drainer() { 
    44                                                 @Override 
    45                                                 public int available( final long startSequence, 
    46                                                                       final long sentinelSequence ) { 
    47                                                         return ( int ) ( sentinelSequence - startSequence ); 
    48                                                 } 
    49                                         } ); 
    50                                 } 
    51                         } 
    52                 } ).start(); 
    53  
    5457                for( int i = 0; i < workers; i++ ) { 
    55                         final int formatId = i; 
    56                         final SimpleLogMessage formatter = new SimpleLogMessage( 
    57                                         "%d %f", 
    58                                         formatId, 
    59                                         2, 
    60                                         new RingBuffer( sequencer, buffer, SPINNING ) 
    61                         ); 
    6258                        workersPool.submit( 
    6359                                        new Runnable() { 
    … …  
    6561                                                public void run() { 
    6662                                                        try { 
    67                                                                 for( int i = 0; i < 10000000; i++ ) { 
    68                                                                         formatter.with( 25.98 + formatId ) 
    69                                                                                         .with( 100 + formatId ) 
    70                                                                                         .log(); 
     63                                                                for( int i = 0; i < 100000000; i++ ) { 
     64                                                                        logger.log( "Message %f -- %d " ) 
     65                                                                                        .with( 25.98 + i ) 
     66                                                                                        .with( 100 - i ).submit(); 
    7167                                                                } 
    7268                                                        } catch( Exception e ) { 
    … …  
    7874                } 
    7975 
     76 
    8077                workersPool.shutdown(); 
    8178                workersPool.awaitTermination( 1000, TimeUnit.SECONDS ); 
    … …  
    8481        } 
    8582 
     83        private static class RawFileWriter implements RawWriter { 
     84                private final ByteBuffer buffer; 
     85                private final FileChannel channel; 
     86 
     87                public RawFileWriter( final File file ) throws IOException { 
     88                        this( new FileOutputStream( file ).getChannel() ); 
     89                } 
     90 
     91                public RawFileWriter( final FileChannel channel ) { 
     92                        this.channel = channel; 
     93                        buffer = ByteBuffer.allocateDirect( 1 << 16 ); 
     94                } 
     95 
     96                @Override 
     97                public ByteBuffer buffer() { 
     98                        return buffer; 
     99                } 
     100 
     101                @Override 
     102                public void flush() throws IOException { 
     103                        buffer.flip(); 
     104                        channel.write( buffer ); 
     105                        buffer.clear(); 
     106                } 
     107 
     108                @Override 
     109                public void close() throws IOException { 
     110                        flush(); 
     111                        channel.close(); 
     112                } 
     113        } 
    86114} 

  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/logger/FastLoggerImpl.java

    r594 r595  
    1313import com.db.logger.io.storage.RawWriter; 
    1414import com.google.common.base.Throwables; 
    15 import gnu.trove.map.hash.THashMap; 
    1615import org.apache.commons.logging.Log; 
    1716import org.apache.commons.logging.LogFactory; 
    … …  
    9695        } 
    9796 
    98         public LogMessage message( final String messageFormat ) { 
     97        public LogMessage log( final String messageFormat ) { 
    9998                final MessageInfo messageInfo = lookupMessageInfo( messageFormat ); 
    10099                final RawLogMessage message = holder.get(); 
    … …  
    285284 
    286285                @Override 
    287                 public void log() { 
    288                         setupLocal().log(); 
     286                public void submit() { 
     287                        setupLocal().submit(); 
    289288                } 
    290289 

  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/logger/MessagesCatalog.java

    r594 r595  
    2828 
    2929                final int length = entries.length; 
    30                 final int index = hash & ( length - 1 ); 
     30                final int mask = length - 1; 
     31                final int startIndex = hash; 
    3132 
    32                 MessageInfo cur = entries[index]; 
     33                for( int i = 0; i < length; i++ ) { 
     34                        final int index = ( startIndex + i ) & mask; 
     35                        final MessageInfo cur = entries[index]; 
     36                        if( cur == FREE ) { 
     37                                //cache miss 
     38                                return recheckAndStore( messageFormat, hash ); 
     39                        } else if( cur.format.equals( messageFormat ) ) { 
     40                                //cache hit 
     41                                return cur; 
     42                        } 
     43                } 
    3344 
    34                 if( cur == FREE ) { 
    35                         //cache miss 
    36                         return recheckAndStore( messageFormat, hash ); 
    37                 } else if( cur.format.equals( messageFormat ) ) { 
    38                         //cache hit 
    39                         return cur; 
    40                 } else {// already FULL, must probe 
    41  
    42                         // compute the double hash 
    43                         final int probe = 1 + ( hash % ( length - 2 ) ); 
    44                         int probedIndex = index; 
    45                         for( int i = 0; i < entries.length; i++ ) { 
    46                                 probedIndex -= probe; 
    47                                 if( probedIndex < 0 ) { 
    48                                         probedIndex += length; 
    49                                 } 
    50                                 cur = entries[probedIndex]; 
    51                                 if( cur == FREE ) { 
    52                                         //cache miss 
    53                                         return recheckAndStore( messageFormat, hash ); 
    54                                 } else if( cur.format.equals( messageFormat ) ) { 
    55                                         //cache hit 
    56                                         return cur; 
    57                                 } 
    58                         } 
    59                         //cache miss, and cache is full -- overwrite main slot 
    60                         throw new IllegalStateException( "Cache is full" ); 
    61                 } 
     45                throw new IllegalStateException( "Table overloaded" ); 
    6246        } 
    6347 
    … …  
    6650                //we restart search from start since anybody could race with us 
    6751                final int length = entries.length; 
    68                 final int index = hash % length; 
     52                final int mask = length - 1; 
     53                final int startIndex = hash; 
    6954 
    70                 MessageInfo cur = entries[index]; 
    71  
    72                 if( cur == FREE ) { 
    73                         //cache miss 
    74                         return createAndStore( format, index ); 
    75                 } else if( cur.format.equals( format ) ) { 
    76                         //cache hit 
    77                         return cur; 
    78                 } else {// already FULL, must probe 
    79  
    80                         // compute the double hash 
    81                         final int probe = 1 + ( hash % ( length - 2 ) ); 
    82                         int probedIndex = index; 
    83                         for( int i = 0; i < entries.length; i++ ) { 
    84                                 probedIndex -= probe; 
    85                                 if( probedIndex < 0 ) { 
    86                                         probedIndex += length; 
    87                                 } 
    88                                 cur = entries[probedIndex]; 
    89                                 if( cur == FREE ) { 
    90                                         //cache miss 
    91                                         return createAndStore( format, probedIndex ); 
    92                                 } else if( cur.format.equals( format ) ) { 
    93                                         //cache hit 
    94                                         return cur; 
    95                                 } 
     55                for( int i = 0; i < length; i++ ) { 
     56                        final int index = ( startIndex + i ) & mask; 
     57                        final MessageInfo cur = entries[index]; 
     58                        if( cur == FREE ) { 
     59                                //cache miss 
     60                                return createAndStore( format, index ); 
     61                        } else if( cur.format.equals( format ) ) { 
     62                                //cache hit 
     63                                return cur; 
    9664                        } 
    97                         //cache miss, and cache is full -- overwrite main slot 
    98                         throw new IllegalStateException( "Cache is full" ); 
    9965                } 
     66                throw new IllegalStateException( "Table overloaded" ); 
    10067        } 
    10168 

  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/logger/buffer/UnsafeLongsBuffer.java

    r594 r595  
    99 
    1010/** 
     11 * Same as {@linkplain PlainLongsBuffer}, but uses Unsafe for all accesses, 
     12 * not only synchronization, so bypass bounds checking 
     13 * 
    1114 * @author cherrus 
    1215 *         created 11/12/13 at 4:43 PM 
    1316 */ 
    14 public class DirectAccessLongBuffer implements ILongsBuffer { 
     17public class UnsafeLongsBuffer implements ILongsBuffer { 
    1518 
    1619        private final long[] array; 
    1720        private final transient int mask; 
    1821 
    19         public DirectAccessLongBuffer( final int length ) { 
     22        public UnsafeLongsBuffer( final int length ) { 
    2023                checkArgument( 
    2124                                ( length & ( length - 1 ) ) == 0, 
    … …  
    2629        } 
    2730 
    28         public DirectAccessLongBuffer( final int length, 
    29                                        final long fillWithValue ) { 
     31        public UnsafeLongsBuffer( final int length, 
     32                                  final long fillWithValue ) { 
    3033                this( length ); 
    3134                Arrays.fill( array, fillWithValue ); 

  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/logger/formatters/AbstractLogBuilder.java

    r594 r595  
    5353 
    5454        @Override 
    55         public void log() { 
     55        public void submit() { 
    5656                ensureStarted(); 
    5757                try { 

  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/logger/formatters/DummyLogBuilder.java

    r589 r595  
    2626 
    2727        @Override 
    28         public void log() { 
     28        public void submit() { 
    2929 
    3030        } 

  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/logger/formatters/RawLogMessage.java

    r594 r595  
    8888 
    8989        @Override 
    90         public void log() { 
     90        public void submit() { 
    9191                checkState( position != INVALID_INDEX, "Not started" ); 
    9292                try { 

  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/logger/formatters/SimpleLogMessageExpanded.java

    r594 r595  
    1212 
    1313/** 
     14 * TODO Unsafe! 
     15 * 
    1416 * @author ruslan 
    1517 *         created 20.11.13 at 23:48 
    … …  
    8789 
    8890        @Override 
    89         public void log() { 
     91        public void submit() { 
    9092//              ensureStarted(); 
    9193                try { 

  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/BufferWriteAndDrainBenchmark.java

    r594 r595  
    55 
    66import com.db.logger.api.impl.logger.*; 
    7 import com.db.logger.api.impl.logger.buffer.DirectAccessLongBuffer; 
     7import com.db.logger.api.impl.logger.buffer.UnsafeLongsBuffer; 
    88import com.db.logger.api.impl.logger.buffer.ILongsBuffer; 
    99import org.openjdk.jmh.annotations.*; 
    … …  
    5050        public void setup() { 
    5151                final int length = 1 << LENGTH_POW; 
    52                 buffer = new DirectAccessLongBuffer( length, NOT_SET ); 
     52                buffer = new UnsafeLongsBuffer( length, NOT_SET ); 
    5353                sequencer = new MCSDSequencer( length ); 
    5454 

  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/FastLoggerWithoutWriteBenchmark.java

    r594 r595  
    88import com.db.logger.api.LogMessage; 
    99import com.db.logger.api.impl.logger.*; 
    10 import com.db.logger.api.impl.logger.buffer.DirectAccessLongBuffer; 
     10import com.db.logger.api.impl.logger.buffer.UnsafeLongsBuffer; 
    1111import com.db.logger.api.impl.logger.buffer.ILongsBuffer; 
    12 import com.db.logger.api.impl.logger.formatters.DummyLogBuilder; 
    1312import org.apache.log4j.BasicConfigurator; 
    1413import org.apache.log4j.Logger; 
    … …  
    2928public class FastLoggerWithoutWriteBenchmark { 
    3029        private static final Logger log = Logger.getLogger( FastLoggerWithoutWriteBenchmark.class ); 
    31         public static final int LENGTH = Integer.getInteger( "length", 1 << 14 ); 
     30        public static final int LENGTH_POW = Integer.getInteger( "length-pow", 14 ); 
     31        public static final int LENGTH = 1 << LENGTH_POW; 
    3232        /** 
    3333         * It's CELLS-1 arguments + 1 cell for header -- to be consistent with previous 
    … …  
    3535         */ 
    3636        public static final int CELLS_PER_RECORD = Integer.getInteger( "cells-per-record", 8 );//8longs = 1 cache line 
    37         public static final int WRITER_BACKOFF = Integer.getInteger( "writer-backoff", 20 ); 
     37        public static final int PAYLOAD = Integer.getInteger( "writer-backoff", 20 ); 
    3838 
    3939        public static final WaitingStrategy WAITING_STRATEGY = new WaitingStrategy.LimitedSpinning( 1024 * 128 ); 
    … …  
    4343        static { 
    4444                BasicConfigurator.configure(); 
    45                 System.out.printf( "len=%d, record=%d, backoff=%d\n", LENGTH, CELLS_PER_RECORD, WRITER_BACKOFF ); 
     45                System.out.printf( "len=%d, record=%d, payload=%d\n", LENGTH, CELLS_PER_RECORD, PAYLOAD ); 
    4646        } 
    4747 
    … …  
    5353        @Setup 
    5454        public void setup() { 
    55                 buffer = new DirectAccessLongBuffer( LENGTH, RecordHelper.NOT_SET ); 
     55                buffer = new UnsafeLongsBuffer( LENGTH, RecordHelper.NOT_SET ); 
    5656                sequencer = new MCSDSequencer( LENGTH ); 
    5757                logger = new FastLoggerImpl( 
    … …  
    8080 
    8181        /*=============================================================================*/ 
    82         @GenerateMicroBenchmark 
    83         @Group( "payload" ) 
    84         @GroupThreads( 3 )//to be consistent with others 
    85         public void payloadAlone() { 
    86                 FluentLogBuilder logBuilder = DummyLogBuilder.INSTANCE.with( 5d ); 
    87                 final int count = CELLS_PER_RECORD; 
    88                 for( int i = 1; i < count; i++ ) { 
    89                         logBuilder = logBuilder.with( ( long ) i ); 
    90                 } 
    91                 logBuilder.log(); 
    92                 BlackHole.consumeCPU( WRITER_BACKOFF ); 
    93         } 
     82//      @GenerateMicroBenchmark 
     83//      @Group( "payload" ) 
     84//      @GroupThreads( 3 )//to be consistent with others 
     85//      public void payloadAlone() { 
     86//              FluentLogBuilder logBuilder = DummyLogBuilder.INSTANCE.with( 5d ); 
     87//              final int count = CELLS_PER_RECORD; 
     88//              for( int i = 1; i < count; i++ ) { 
     89//                      logBuilder = logBuilder.with( ( long ) i ); 
     90//              } 
     91//              logBuilder.log(); 
     92//              BlackHole.consumeCPU( PAYLOAD ); 
     93//      } 
    9494 
    9595        @GenerateMicroBenchmark 
    … …  
    105105                        logBuilder = logBuilder.with( ( long ) i ); 
    106106                } 
    107                 logBuilder.log(); 
    108  
    109                 BlackHole.consumeCPU( WRITER_BACKOFF ); 
     107                logBuilder.submit(); 
     108 
     109                BlackHole.consumeCPU( PAYLOAD ); 
    110110        } 
    111111 
    … …  
    123123                        logBuilder = logBuilder.with( ( long ) i ); 
    124124                } 
    125                 logBuilder.log(); 
    126  
    127                 BlackHole.consumeCPU( WRITER_BACKOFF ); 
     125                logBuilder.submit(); 
     126 
     127                BlackHole.consumeCPU( PAYLOAD ); 
    128128        } 
    129129 
    … …  
    133133        @GroupThreads( 3 ) 
    134134        public void writeRawMessage( final ThreadState ts ) { 
    135                 FluentLogBuilder logBuilder = logger.message( ts.messageFormat ) 
     135                FluentLogBuilder logBuilder = logger.log( ts.message ) 
    136136                                .with( 5d ); 
    137137                final int count = CELLS_PER_RECORD - 1; 
    … …  
    139139                        logBuilder = logBuilder.with( ( long ) i ); 
    140140                } 
    141                 logBuilder.log(); 
    142  
    143                 BlackHole.consumeCPU( WRITER_BACKOFF ); 
    144         } 
    145  
    146         @GenerateMicroBenchmark 
    147         @Group( "lookupMessageInfo" ) 
    148         @GroupThreads( 3 ) 
    149         public Object lookupMessageInfo( final ThreadState ts ) { 
    150                 return logger.lookupMessageInfo( ts.messageFormat ); 
    151         } 
     141                logBuilder.submit(); 
     142 
     143                BlackHole.consumeCPU( PAYLOAD ); 
     144        } 
     145 
     146//      @GenerateMicroBenchmark 
     147//      @Group( "lookupMessageInfo" ) 
     148//      @GroupThreads( 3 ) 
     149//      public Object lookupMessageInfo( final ThreadState ts ) { 
     150//              return logger.lookupMessageInfo( ts.message ); 
     151//      } 
    152152 
    153153        @State( Scope.Thread ) 
    … …  
    155155                public final int id = ID_GENERATOR.incrementAndGet(); 
    156156 
    157                 public final String messageFormat; 
     157                public final String message; 
    158158 
    159159                public ThreadState() { 
    … …  
    165165                                sb.append( " %d" ); 
    166166                        } 
    167                         messageFormat = sb.toString(); 
     167                        message = sb.toString(); 
    168168                } 
    169169        } 
    … …  
    175175 
    176176                public void setup( final FastLoggerWithoutWriteBenchmark b ) { 
    177                         simpleMessage = b.logger.messageSimple( messageFormat ); 
     177                        simpleMessage = b.logger.messageSimple( message ); 
    178178                } 
    179179        } 
    … …  
    185185 
    186186                public void setup( final FastLoggerWithoutWriteBenchmark b ) { 
    187                         threadLocalMessage = b.logger.messageThreadLocal( messageFormat ); 
     187                        threadLocalMessage = b.logger.messageThreadLocal( message ); 
    188188                } 
    189189        } 

  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/GFLoggerBenchmark.java

    r594 r595  
    11package com.db.logger.benchmarks; 
    22 
    3 import java.util.concurrent.ThreadFactory; 
    43import java.util.concurrent.TimeUnit; 
    54import java.util.concurrent.atomic.AtomicInteger; 
    … …  
    87import com.db.logger.api.LogMessage; 
    98import com.db.logger.api.impl.logger.*; 
    10 import com.db.logger.api.impl.logger.buffer.DirectAccessLongBuffer; 
    11 import com.db.logger.api.impl.logger.buffer.ILongsBuffer; 
    12 import com.db.logger.api.impl.logger.formatters.DummyLogBuilder; 
    139import org.apache.log4j.BasicConfigurator; 
    1410import org.apache.log4j.Logger; 
     11import org.gflogger.*; 
     12import org.gflogger.appender.AppenderFactory; 
     13import org.gflogger.appender.FileAppenderFactory; 
     14import org.gflogger.disruptor.LoggerServiceImpl; 
    1515import org.openjdk.jmh.annotations.*; 
    1616import org.openjdk.jmh.logic.BlackHole; 
     17 
     18import static org.gflogger.helpers.OptionConverter.getIntProperty; 
    1719 
    1820/** 
    … …  
    2729@OutputTimeUnit( TimeUnit.NANOSECONDS ) 
    2830@State( Scope.Group ) 
    29 public class FastLoggerWithoutWriteBenchmark { 
    30         private static final Logger log = Logger.getLogger( FastLoggerWithoutWriteBenchmark.class ); 
    31         public static final int LENGTH = Integer.getInteger( "length", 1 << 14 ); 
     31public class GFLoggerBenchmark { 
     32        private static final Logger log = Logger.getLogger( GFLoggerBenchmark.class ); 
     33        public static final int LENGTH_POW = Integer.getInteger( "length-pow", 14 ); 
     34        public static final int LENGTH = 1 << LENGTH_POW; 
    3235        /** 
    3336         * It's CELLS-1 arguments + 1 cell for header -- to be consistent with previous 
    … …  
    3538         */ 
    3639        public static final int CELLS_PER_RECORD = Integer.getInteger( "cells-per-record", 8 );//8longs = 1 cache line 
    37         public static final int WRITER_BACKOFF = Integer.getInteger( "writer-backoff", 20 ); 
    3840 
    39         public static final WaitingStrategy WAITING_STRATEGY = new WaitingStrategy.LimitedSpinning( 1024 * 128 ); 
     41        public static final int MAX_MESSAGE_SIZE = getIntProperty( "gflogger.service.maxMessageSize", 1 << 8 ); 
     42 
     43        public static final int PAYLOAD = Integer.getInteger( "writer-backoff", 20 ); 
    4044 
    4145        public static final AtomicInteger ID_GENERATOR = new AtomicInteger( 1 ); 
    … …  
    4347        static { 
    4448                BasicConfigurator.configure(); 
    45                 System.out.printf( "len=%d, record=%d, backoff=%d\n", LENGTH, CELLS_PER_RECORD, WRITER_BACKOFF ); 
     49                System.out.printf( "len=%d, record=%d, payload=%d\n", LENGTH, CELLS_PER_RECORD, PAYLOAD ); 
    4650        } 
    4751 
    48         public ILongsBuffer buffer; 
    49         public MCSDSequencer sequencer; 
    5052 
    51         public FastLoggerImpl logger; 
     53        public LoggerService gfloggerService; 
     54        public GFLog gflog; 
    5255 
    5356        @Setup 
    5457        public void setup() { 
    55                 buffer = new DirectAccessLongBuffer( LENGTH, RecordHelper.NOT_SET ); 
    56                 sequencer = new MCSDSequencer( LENGTH ); 
    57                 logger = new FastLoggerImpl( 
    58                                 new ThreadFactory() { 
    59                                         @Override 
    60                                         public Thread newThread( final Runnable r ) { 
    61                                                 return new Thread( r ); 
    62                                         } 
    63                                 }, 
    64                                 buffer, 
    65                                 WAITING_STRATEGY, 
    66                                 new FakeRawWriter() 
    67                 ); 
    68                 logger.startDraining(); 
     58                gfloggerService = createLoggerImpl(); 
     59 
     60                GFLogFactory.init( gfloggerService ); 
     61 
     62                this.gflog = GFLogFactory.getLog( "com.db.fxpricing.Logger" ); 
    6963        } 
    7064 
    7165        @TearDown 
    7266        public void tearDown() throws Exception { 
    73                 logger.stopDraining(); 
     67                GFLogFactory.stop(); 
    7468        } 
    7569 
    … …  
    8478        @GroupThreads( 3 )//to be consistent with others 
    8579        public void payloadAlone() { 
    86                 FluentLogBuilder logBuilder = DummyLogBuilder.INSTANCE.with( 5d ); 
    87                 final int count = CELLS_PER_RECORD; 
    88                 for( int i = 1; i < count; i++ ) { 
    89                         logBuilder = logBuilder.with( ( long ) i ); 
    90                 } 
    91                 logBuilder.log(); 
    92                 BlackHole.consumeCPU( WRITER_BACKOFF ); 
     80                BlackHole.consumeCPU( PAYLOAD ); 
    9381        } 
    9482 
     83 
     84        /*=============================================================================*/ 
    9585        @GenerateMicroBenchmark 
    96         @Group( "logSimpleAndPayload" ) 
     86        @Group( "logAppendingAndPayload" ) 
    9787        @GroupThreads( 3 ) 
    98         public void writeSimpleMessage( final ThreadStateSimple ts ) { 
    99                 if( ts.simpleMessage == null ) { 
    100                         ts.setup( this ); 
    101                 } 
    102                 FluentLogBuilder logBuilder = ts.simpleMessage.with( 5d ); 
     88        public void writeLogAppending( final ThreadState ts ) { 
     89                final GFLogEntry entry = gflog.info(); 
     90 
     91                entry.append( ' ' ).append( 5d ); 
    10392                final int count = CELLS_PER_RECORD - 1; 
    10493                for( int i = 1; i < count; i++ ) { 
    105                         logBuilder = logBuilder.with( ( long ) i ); 
     94                        entry.append( ' ' ).append( ( long ) i ); 
    10695                } 
    107                 logBuilder.log(); 
     96                entry.commit(); 
    10897 
    109                 BlackHole.consumeCPU( WRITER_BACKOFF ); 
     98                BlackHole.consumeCPU( PAYLOAD ); 
    11099        } 
    111100 
    112101        /*=============================================================================*/ 
    113102        @GenerateMicroBenchmark 
    114         @Group( "logTLAndPayload" ) 
     103        @Group( "logFormattingAndPayload" ) 
    115104        @GroupThreads( 3 ) 
    116         public void writeTLMessage( final ThreadStateTL ts ) { 
    117                 if( ts.threadLocalMessage == null ) { 
    118                         ts.setup( this ); 
    119                 } 
    120                 FluentLogBuilder logBuilder = ts.threadLocalMessage.with( 5d ); 
     105        public void writeRawMessage( final ThreadState ts ) { 
     106                final FormattedGFLogEntry entry = gflog.info( ts.message ).with( 5d ); 
    121107                final int count = CELLS_PER_RECORD - 1; 
    122108                for( int i = 1; i < count; i++ ) { 
    123                         logBuilder = logBuilder.with( ( long ) i ); 
     109                        entry.with( ( long ) i ); 
    124110                } 
    125                 logBuilder.log(); 
    126111 
    127                 BlackHole.consumeCPU( WRITER_BACKOFF ); 
    128         } 
    129  
    130         /*=============================================================================*/ 
    131         @GenerateMicroBenchmark 
    132         @Group( "logAndPayload" ) 
    133         @GroupThreads( 3 ) 
    134         public void writeRawMessage( final ThreadState ts ) { 
    135                 FluentLogBuilder logBuilder = logger.message( ts.messageFormat ) 
    136                                 .with( 5d ); 
    137                 final int count = CELLS_PER_RECORD - 1; 
    138                 for( int i = 1; i < count; i++ ) { 
    139                         logBuilder = logBuilder.with( ( long ) i ); 
    140                 } 
    141                 logBuilder.log(); 
    142  
    143                 BlackHole.consumeCPU( WRITER_BACKOFF ); 
    144         } 
    145  
    146         @GenerateMicroBenchmark 
    147         @Group( "lookupMessageInfo" ) 
    148         @GroupThreads( 3 ) 
    149         public Object lookupMessageInfo( final ThreadState ts ) { 
    150                 return logger.lookupMessageInfo( ts.messageFormat ); 
     112                BlackHole.consumeCPU( PAYLOAD ); 
    151113        } 
    152114 
    … …  
    155117                public final int id = ID_GENERATOR.incrementAndGet(); 
    156118 
    157                 public final String messageFormat; 
     119                public final String message; 
    158120 
    159121                public ThreadState() { 
    … …  
    165127                                sb.append( " %d" ); 
    166128                        } 
    167                         messageFormat = sb.toString(); 
     129                        message = sb.toString(); 
    168130                } 
    169131        } 
    170132 
    171         @State( Scope.Thread ) 
    172         public static class ThreadStateSimple extends ThreadState { 
    173133 
    174                 public LogMessage simpleMessage; 
     134        protected AppenderFactory[] createAppenderFactories() { 
     135                final FileAppenderFactory fileAppender = new FileAppenderFactory(); 
     136                fileAppender.setLogLevel( LogLevel.INFO ); 
     137                fileAppender.setFileName( "log.log" ); 
     138                fileAppender.setAppend( false ); 
     139                fileAppender.setImmediateFlush( false ); 
     140                fileAppender.setLayout( new PatternLayout( "%d{HH:mm:ss,SSS zzz} %p %m [%c{2}] [%t]%n" ) ); 
    175141 
    176                 public void setup( final FastLoggerWithoutWriteBenchmark b ) { 
    177                         simpleMessage = b.logger.messageSimple( messageFormat ); 
    178                 } 
     142                return new AppenderFactory[] { fileAppender }; 
    179143        } 
    180144 
    181         @State( Scope.Thread ) 
    182         public static class ThreadStateTL extends ThreadState { 
     145        protected LoggerService createLoggerImpl() { 
     146                final AppenderFactory[] factories = createAppenderFactories(); 
     147                final GFLoggerBuilder[] loggers = { 
     148                                new GFLoggerBuilder( 
     149                                                LogLevel.INFO, 
     150                                                "com.db", 
     151                                                factories 
     152                                ) 
     153                }; 
    183154 
    184                 public LogMessage threadLocalMessage; 
    185  
    186                 public void setup( final FastLoggerWithoutWriteBenchmark b ) { 
    187                         threadLocalMessage = b.logger.messageThreadLocal( messageFormat ); 
    188                 } 
     155                final int count = LENGTH / MAX_MESSAGE_SIZE; 
     156                final LoggerService impl = new LoggerServiceImpl( 
     157                                count, 
     158                                MAX_MESSAGE_SIZE, 
     159                                loggers, 
     160                                factories 
     161                ); 
     162                return impl; 
    189163        } 
    190164 

  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/MultiBuffersWriteAndDrainBenchmark.java

    r594 r595  
    77 
    88import com.db.logger.api.impl.logger.*; 
    9 import com.db.logger.api.impl.logger.buffer.DirectAccessLongBuffer; 
     9import com.db.logger.api.impl.logger.buffer.UnsafeLongsBuffer; 
    1010import com.db.logger.api.impl.logger.buffer.ILongsBuffer; 
    1111import org.openjdk.jmh.annotations.*; 
    … …  
    158158                public ThreadState() { 
    159159                        final int length = 1 << LENGTH_POW; 
    160                         final DirectAccessLongBuffer longBuffer = new DirectAccessLongBuffer( 
     160                        final UnsafeLongsBuffer longBuffer = new UnsafeLongsBuffer( 
    161161                                        length, 
    162162                                        RecordHelper.NOT_SET 

  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/PerThreadMappedFileBenchmark.java

    r594 r595  
    11package com.db.logger.benchmarks; 
    22 
     3import java.io.File; 
     4import java.io.FileOutputStream; 
     5import java.nio.ByteBuffer; 
     6import java.nio.channels.FileChannel; 
    37import java.util.*; 
    48import java.util.concurrent.CopyOnWriteArrayList; 
    … …  
    711 
    812import com.db.logger.api.impl.logger.*; 
    9 import com.db.logger.api.impl.logger.buffer.DirectAccessLongBuffer; 
    1013import com.db.logger.api.impl.logger.buffer.ILongsBuffer; 
     14import com.db.logger.api.impl.logger.buffer.UnsafeLongsBuffer; 
    1115import org.openjdk.jmh.annotations.*; 
    1216import org.openjdk.jmh.logic.BlackHole; 
    … …  
    2630@OutputTimeUnit( TimeUnit.NANOSECONDS ) 
    2731@State( Scope.Group ) 
    28 public class MultiBuffersWriteAndDrainBenchmark { 
     32public class PerThreadMappedFileBenchmark { 
    2933        public static final int LENGTH_POW = Integer.getInteger( "length-pow", 14 ); 
    3034        public static final int CELLS_PER_RECORD = Integer.getInteger( "cells-per-record", 8 );//8longs = 1 cache line 
    … …  
    8892                try { 
    8993                        for( final ThreadState ts : states ) { 
    90                                 ts.ringBuffer.drainTo( DRAIN_DUMMY ); 
     94                                ts.sequencer.drainTo( DRAIN_DUMMY ); 
    9195                        } 
    9296                        BlackHole.consumeCPU( 10 ); 
    … …  
    99103 
    100104        /*=============================================================================*/ 
    101         @GenerateMicroBenchmark 
    102         @Group( "writeAndPayloadAndDrainAndRead" ) 
    103         @GroupThreads( 3 ) //actually it's (CORES-1) 
    104         public void writer2( final ThreadState ts ) { 
    105                 writeEntry( ts, ts.id, ts.count ); 
    106                 BlackHole.consumeCPU( WRITER_BACKOFF ); 
    107         } 
    108  
    109         @GenerateMicroBenchmark 
    110         @Group( "writeAndPayloadAndDrainAndRead" ) 
    111         @GroupThreads( 1 ) 
    112         public void readingDrainer() { 
    113                 //mostly we do not care about drain latency here, measure just to be aware of it 
    114                 try { 
    115                         for( final ThreadState ts : states ) { 
    116                                 ts.ringBuffer.drainTo( ts.consumingDrainer ); 
    117                         } 
    118 //                      BlackHole.consumeCPU( 100 ); 
    119                 } catch( Throwable e ) { 
    120                         e.printStackTrace(); 
    121                 } 
    122         } 
    123  
    124         /*=============================================================================*/ 
    125105 
    126106        private void writeEntry( final ThreadState ts, 
    127107                                 final int writerId, 
    128108                                 final int cellsCount ) { 
    129                 final long position = ts.ringBuffer.claim( cellsCount ); 
     109                final long position = ts.sequencer.claim( cellsCount ); 
    130110                if( position < 0 ) { 
    131111                        System.err.println( "Timeout" ); 
    … …  
    133113                } 
    134114                //reserve 0-th cell for header 
    135                 final ILongsBuffer data = ts.ringBuffer.buffer(); 
    136                 for( int i = 1; i < cellsCount; i++ ) { 
    137                         data.put( position + i, i ); 
    138                 } 
    139                 //write header with SA 
    140                 data.putOrdered( 
    141                                 position, 
    142                                 header( 
    143                                                 LOG_RECORD, 
    144                                                 writerId, 
    145                                                 cellsCount - 1 
    146                                 ) 
    147                 ); 
     115                final ByteBuffer data = ts.buffer; 
     116//              for( int i = 1; i < cellsCount; i++ ) { 
     117//                      data.put( position + i, i ); 
     118//              } 
     119//              //write header with SA 
     120//              data.put( 
     121//                              position, 
     122//                              header( 
     123//                                              LOG_RECORD, 
     124//                                              writerId, 
     125//                                              cellsCount - 1 
     126//                              ) 
     127//              ); 
    148128        } 
    149129 
    … …  
    153133                public final int count = CELLS_PER_RECORD;//but 1 for header 
    154134 
    155                 public RingBuffer ringBuffer; 
     135                public SCSDSequencer sequencer; 
    156136                public Sequencer.Drainer consumingDrainer; 
     137                public ByteBuffer buffer; 
    157138 
    158                 public ThreadState() { 
    159                         final int length = 1 << LENGTH_POW; 
    160                         final DirectAccessLongBuffer longBuffer = new DirectAccessLongBuffer( 
    161                                         length, 
    162                                         RecordHelper.NOT_SET 
     139                public ThreadState() throws Exception { 
     140                        final int length = ( 1 << LENGTH_POW ); 
     141 
     142                        this.sequencer = new SCSDSequencer( length ); 
     143                        final File file = new File( "" ); 
     144                        final FileChannel channel = new FileOutputStream( file ).getChannel(); 
     145                        this.buffer = channel.map( 
     146                                        FileChannel.MapMode.READ_WRITE, 
     147                                        0, 
     148                                        length << 3 
    163149                        ); 
    164  
    165                         ringBuffer = new RingBuffer( 
    166                                         new SCSDSequencer( length ), 
    167                                         longBuffer, 
    168                                         WAITING_STRATEGY 
    169                         ); 
    170  
    171                         consumingDrainer = new ConsumingDrainer( longBuffer ); 
    172150                } 
    173151 
    … …  
    184162 
    185163        public static void main( final String[] args ) throws Exception { 
    186                 final MultiBuffersWriteAndDrainBenchmark benchmark = new MultiBuffersWriteAndDrainBenchmark(); 
    187  
    188                 benchmark.setup(); 
    189  
    190                 final ThreadState[] states = new ThreadState[3]; 
    191                 for( int i = 0; i < states.length; i++ ) { 
    192                         final ThreadState state = new ThreadState(); 
    193                         states[i] = state; 
    194                         new Thread() { 
    195                                 @Override 
    196                                 public void run() { 
    197                                         for(; ; ) { 
    198                                                 benchmark.writer2( state ); 
    199                                         } 
    200                                 } 
    201                         }.start(); 
    202                 } 
    203  
    204                 new Thread() { 
    205                         @Override 
    206                         public void run() { 
    207                                 for(; ; ) { 
    208                                         benchmark.readingDrainer(); 
    209                                 } 
    210                         } 
    211                 }.start(); 
    212  
    213                 Thread.sleep( 300000 ); 
     164//              final PerThreadMappedFileBenchmark benchmark = new PerThreadMappedFileBenchmark(); 
     165// 
     166//              benchmark.setup(); 
     167// 
     168//              final ThreadState[] states = new ThreadState[3]; 
     169//              for( int i = 0; i < states.length; i++ ) { 
     170//                      final ThreadState state = new ThreadState(); 
     171//                      states[i] = state; 
     172//                      new Thread() { 
     173//                              @Override 
     174//                              public void run() { 
     175//                                      for(; ; ) { 
     176//                                              benchmark.writer2( state ); 
     177//                                      } 
     178//                              } 
     179//                      }.start(); 
     180//              } 
     181// 
     182//              new Thread() { 
     183//                      @Override 
     184//                      public void run() { 
     185//                              for(; ; ) { 
     186//                                      benchmark.readingDrainer(); 
     187//                              } 
     188//                      } 
     189//              }.start(); 
     190// 
     191//              Thread.sleep( 300000 ); 
    214192        } 
    215193 

  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/RawLogMessageWriteAndDrainBenchmark.java

    r594 r595  
    66import com.db.logger.api.FluentLogBuilder; 
    77import com.db.logger.api.impl.logger.*; 
    8 import com.db.logger.api.impl.logger.buffer.DirectAccessLongBuffer; 
     8import com.db.logger.api.impl.logger.buffer.UnsafeLongsBuffer; 
    99import com.db.logger.api.impl.logger.buffer.ILongsBuffer; 
    1010import com.db.logger.api.impl.logger.formatters.RawLogMessage; 
    … …  
    4141        @Setup 
    4242        public void setup() { 
    43                 buffer = new DirectAccessLongBuffer( LENGTH, RecordHelper.NOT_SET ); 
     43                buffer = new UnsafeLongsBuffer( LENGTH, RecordHelper.NOT_SET ); 
    4444                sequencer = new MCSDSequencer( LENGTH ); 
    4545 
    … …  
    7878                        logBuilder = logBuilder.with( ( long ) i ); 
    7979                } 
    80                 logBuilder.log(); 
     80                logBuilder.submit(); 
    8181 
    8282                BlackHole.consumeCPU( WRITER_BACKOFF ); 

  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/SimpleLogMessageWriteAndDrainBenchmark.java

    r594 r595  
    66import com.db.logger.api.FluentLogBuilder; 
    77import com.db.logger.api.impl.logger.*; 
    8 import com.db.logger.api.impl.logger.buffer.DirectAccessLongBuffer; 
     8import com.db.logger.api.impl.logger.buffer.UnsafeLongsBuffer; 
    99import com.db.logger.api.impl.logger.buffer.ILongsBuffer; 
    1010import com.db.logger.api.impl.logger.formatters.SimpleLogMessageExpanded; 
    … …  
    3939        @Setup 
    4040        public void setup() { 
    41                 buffer = new DirectAccessLongBuffer( LENGTH, RecordHelper.NOT_SET ); 
     41                buffer = new UnsafeLongsBuffer( LENGTH, RecordHelper.NOT_SET ); 
    4242                sequencer = new MCSDSequencer( LENGTH ); 
    4343 
    … …  
    7575                        logBuilder = logBuilder.with( ( long ) i ); 
    7676                } 
    77                 logBuilder.log(); 
     77                logBuilder.submit(); 
    7878 
    7979                BlackHole.consumeCPU( WRITER_BACKOFF ); 

  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/helpers/SCSDSequencerBenchmark.java

    r594 r595  
    2828        private static final Logger log = Logger.getLogger( SCSDSequencerBenchmark.class ); 
    2929 
    30         public static final int LENGTH = Integer.getInteger( "length", 1 << 14 ); 
     30        public static final int LENGTH_POW = Integer.getInteger( "length-pow", 14 ); 
     31        public static final int LENGTH = 1 << LENGTH_POW; 
    3132        public static final int CELLS_PER_RECORD = Integer.getInteger( "record-size", 8 );//8longs = 1 cache line 
    32         public static final int WRITER_BACKOFF = Integer.getInteger( "writer-backoff", 7 ); 
     33        public static final int PAYLOAD = Integer.getInteger( "writer-backoff", 0 ); 
    3334 
    3435        public static final WaitingStrategy WAITING_STRATEGY = new WaitingStrategy.LimitedSpinning( 1024 * 128 ); 
    … …  
    3637        static { 
    3738                BasicConfigurator.configure(); 
    38                 System.out.printf( "len=%d, record=%d, payload=%d\n", LENGTH, CELLS_PER_RECORD, WRITER_BACKOFF ); 
     39                System.out.printf( "len=%d, record=%d, payload=%d\n", LENGTH, CELLS_PER_RECORD, PAYLOAD ); 
    3940        } 
    4041 
    … …  
    7273        @GroupThreads( 4 ) 
    7374        public void backoffAlone() { 
    74                 BlackHole.consumeCPU( WRITER_BACKOFF ); 
     75                BlackHole.consumeCPU( PAYLOAD ); 
    7576        } 
    7677 
    … …  
    8182        public void claimer3( final ThreadState ts ) { 
    8283                claimEntry( ts.sequencer, ts.id, ts.count ); 
    83                 BlackHole.consumeCPU( WRITER_BACKOFF ); 
     84                BlackHole.consumeCPU( PAYLOAD ); 
    8485        } 
    8586 
    … …  
    9192                        ts.sequencer.drainTo( DRAIN_DUMMY ); 
    9293                } 
    93 //              BlackHole.consumeCPU( WRITER_BACKOFF ); 
     94//              BlackHole.consumeCPU( 0 ); 
    9495        } 
    9596 
    … …  
    126127                benchmark.setup(); 
    127128 
    128                 final int BATCH = 1000000; 
     129                final int BATCH = 10000000; 
    129130                final ThreadState[] states = new ThreadState[3]; 
    130131                for( int i = 0; i < states.length; i++ ) { 
    … …  
    134135                                @Override 
    135136                                public void run() { 
     137                                        state.setup(); 
    136138                                        for( int turn = 0; ; turn += BATCH ) { 
    137139                                                for( int i = 0; i < BATCH; i++ ) { 
    … …  
    140142                                                log.info( "Thread " + state.id + ": " + turn ); 
    141143                                        } 
     144//                                      state.destroy(); 
    142145                                } 
    143146                        }.start(); 

  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/helpers/ThreadLocalBenchmark.java

    r590 r595  
    1414@State( Scope.Benchmark ) 
    1515public class ThreadLocalBenchmark { 
    16 //      public static final int WRITER_BACKOFF = Integer.getInteger( "writer-backoff", 0 ); 
     16//      public static final int PAYLOAD = Integer.getInteger( "writer-backoff", 0 ); 
    1717 
    1818        public ThreadLocal<Long> counter = new ThreadLocal<Long>(){ 

  • Tests/JAVA/logger/src/test/java/com/db/logger/api/impl/logger/UnsafeLongBufferTest.java

    r594 r595  
    11package com.db.logger.api.impl.logger; 
    22 
    3 import com.db.logger.api.impl.logger.buffer.DirectAccessLongBuffer; 
     3import com.db.logger.api.impl.logger.buffer.UnsafeLongsBuffer; 
    44import com.db.logger.api.impl.logger.buffer.ILongsBuffer; 
    55 
    … …  
    88 *         created 22.11.13 at 23:24 
    99 */ 
    10 public class DirectAccessLongBufferTest extends LongBufferTestBase { 
     10public class UnsafeLongBufferTest extends LongBufferTestBase { 
    1111        @Override 
    1212        protected ILongsBuffer buffer( final int length ) { 
    13                 return new DirectAccessLongBuffer( length ); 
     13                return new UnsafeLongsBuffer( length ); 
    1414        } 
    1515 
    16         public DirectAccessLongBufferTest( final int length ) { 
     16        public UnsafeLongBufferTest( final int length ) { 
    1717                super( length ); 
    1818        } 
Note: See TracChangeset for help on using the changeset viewer.