Changeset 589 for Tests


Ignore:
Timestamp:
12/06/13 05:48:28 (8 years ago)
Author:
BegemoT
Message:
 
Location:
Tests/JAVA/logger/src/main/java/com/db/logger
Files:
4 added
9 edited
17 moved

Legend:

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

    r581 r589  
    77public interface FastLogger { 
    88 
    9         public MessageFormatter formatter( final String formatMessage ); 
     9        public LogMessage message( final String messageFormat ); 
    1010 
    1111} 
  • Tests/JAVA/logger/src/main/java/com/db/logger/api/FluentLogBuilder.java

    r586 r589  
    1 package com.db.logger.api.impl; 
     1package com.db.logger.api; 
    22 
    33 
     
    66 *         created 20.11.13 at 23:51 
    77 */ 
    8 public interface FluentFormatter { 
    9         public FluentFormatter with( double value ); 
     8public interface FluentLogBuilder { 
     9        public FluentLogBuilder with( final double value ); 
    1010 
    11         public FluentFormatter with( long value ); 
     11        public FluentLogBuilder with( final long value ); 
    1212 
    13         void submit(); 
    14  
    15         //      public MessageFormatter with(final float value); 
    16 //      public MessageFormatter with(final int value); 
    17 //      public MessageFormatter with(final String value); 
    18  
     13        public void log(); 
    1914} 
  • Tests/JAVA/logger/src/main/java/com/db/logger/api/LogMessage.java

    r586 r589  
    11package com.db.logger.api; 
    2  
    3 import com.db.logger.api.impl.FluentFormatter; 
    42 
    53/** 
     
    75 *         created 20.11.13 at 23:05 
    86 */ 
    9 public interface MessageFormatter extends FluentFormatter{ 
     7public interface LogMessage { 
    108        public String format(); 
    119 
    1210        public int argumentsCount(); 
    1311 
     12        public FluentLogBuilder with( final double value ); 
     13 
     14        public FluentLogBuilder with( final long value ); 
     15 
     16        public void log(); 
     17 
    1418} 
  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/PlaygroundMain.java

    r586 r589  
    77import com.db.logger.api.impl.logger.CircularBuffer; 
    88import com.db.logger.api.impl.logger.DemultiplexingSequencer; 
    9 import com.db.logger.api.impl.logger.SimpleMessageFormatter; 
     9import com.db.logger.api.impl.logger.formatters.SimpleLogMessage; 
    1010import com.db.logger.api.impl.logger.buffer.PlainLongsBuffer; 
    1111import com.db.logger.timesource.impl.JDKCombinedTimestampSource; 
     
    5454                for( int i = 0; i < workers; i++ ) { 
    5555                        final int formatId = i; 
    56                         final SimpleMessageFormatter formatter = new SimpleMessageFormatter( 
     56                        final SimpleLogMessage formatter = new SimpleLogMessage( 
    5757                                        "%d %f", 
    5858                                        formatId, 
     
    6868                                                                        formatter.with( 25.98 + formatId ) 
    6969                                                                                        .with( 100 + formatId ) 
    70                                                                                         .submit(); 
     70                                                                                        .log(); 
    7171                                                                } 
    7272                                                        } catch( Exception e ) { 
  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/logger/DemultiplexingSequencer.java

    r586 r589  
    3232 
    3333        static { 
    34  
    3534                try { 
    3635                        final Field headCursorField = DemultiplexingSequencer.class.getDeclaredField( "headCursor" ); 
     
    3837                        HEAD_OFFSET = UNSAFE.objectFieldOffset( headCursorField ); 
    3938                        TAIL_OFFSET = UNSAFE.objectFieldOffset( tailCursorField ); 
     39                        final long padding = TAIL_OFFSET - HEAD_OFFSET; 
     40                        if( padding < 64 ) { 
     41                                System.out.println( "Padding is optimized out: " + padding ); 
     42                        } 
    4043                } catch( NoSuchFieldException e ) { 
    4144                        throw new RuntimeException( e ); 
     
    5861         * (tailCursor % size ) is the index of _cell_ for _next last item_ 
    5962         */ 
     63        public volatile long r0, r1, r2, r3, r4, r5, r6, r7; 
    6064        private volatile long headCursor = 0; 
    61  
     65        public volatile long p0, p1, p2, p3, p4, p5, p6, p7; 
     66        public volatile long q0, q1, q2, q3, q4, q5, q6, q7; 
    6267        private volatile long tailCursor = 0; 
     68        public volatile long z0, z1, z2, z3, z4, z5, z6, z7; 
    6369 
    6470        public DemultiplexingSequencer( final int length ) { 
     
    137143} 
    138144 
    139  
    140 class RightPad { 
    141         public volatile long p0, p1, p2, p3, p4, p5, p6, p7; 
    142 } 
  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/logger/SimpleFastLogger.java

    r587 r589  
    88import com.db.logger.api.FastLogger; 
    99import com.db.logger.api.impl.logger.buffer.ILongsBuffer; 
     10import com.db.logger.api.impl.logger.formatters.SimpleLogMessage; 
    1011import com.db.logger.io.storage.RawWriter; 
    1112import com.google.common.base.Throwables; 
     
    6263//      }; 
    6364 
    64         private final HashMap<String, SimpleMessageFormatter> formatters = new HashMap<String, SimpleMessageFormatter>(); 
     65        private final HashMap<String, SimpleLogMessage> formatters = new HashMap<String, SimpleLogMessage>(); 
    6566        private final TObjectIntHashMap<String> formatsToID = new TObjectIntHashMap<String>( 128, 0.5f, NOT_FOUND ); 
    6667 
    6768 
    6869        @Override 
    69         public synchronized SimpleMessageFormatter formatter( final String formatMessage ) { 
    70                 int formatId = formatsToID.get( formatMessage ); 
     70        public synchronized SimpleLogMessage message( final String messageFormat ) { 
     71                int formatId = formatsToID.get( messageFormat ); 
    7172                if( formatId == NOT_FOUND ) { 
    7273                        formatId = formatsToID.size() + 1; 
    73                         formatsToID.put( formatMessage, formatId ); 
    74                 } 
    75                 final int argumentsCount = calculateArgumentsCount( formatMessage ); 
    76                 return new SimpleMessageFormatter( 
    77                                 formatMessage, 
     74                        formatsToID.put( messageFormat, formatId ); 
     75                } 
     76                final int argumentsCount = calculateArgumentsCount( messageFormat ); 
     77                return new SimpleLogMessage( 
     78                                messageFormat, 
    7879                                formatId, 
    7980                                argumentsCount, 
     
    234235                                        for( int i = 0; i <= argumentsCount; i++ ) { 
    235236                                                final long arg = buffer.get( pos + i ); 
    236                                                 //TODO RC: it is not required since Sequencer protect us 
     237                                                //TODO RC: it is not required since Sequencer protect us? 
    237238                                                buffer.put( pos + i, NOT_SET );//need to reclaim each cell! 
    238239                                                output.putLong( arg ); 
  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/logger/ThreadLocalFastLogger.java

    r587 r589  
    44 
    55import com.db.logger.api.FastLogger; 
    6 import com.db.logger.api.MessageFormatter; 
    7 import com.db.logger.api.impl.FluentFormatter; 
     6import com.db.logger.api.LogMessage; 
     7import com.db.logger.api.FluentLogBuilder; 
    88import com.db.logger.api.impl.logger.buffer.ILongsBuffer; 
     9import com.db.logger.api.impl.logger.formatters.FlyweightLogMessage; 
     10import com.db.logger.api.impl.logger.formatters.SimpleLogMessage; 
    911import com.db.logger.io.storage.RawWriter; 
    1012 
     
    2325        } 
    2426 
    25         private final ThreadLocal<FlyweightMessageFormatter> holder = new ThreadLocal<FlyweightMessageFormatter>() { 
     27        private final ThreadLocal<FlyweightLogMessage> holder = new ThreadLocal<FlyweightLogMessage>() { 
    2628                @Override 
    27                 protected FlyweightMessageFormatter initialValue() { 
    28                         return new FlyweightMessageFormatter( logger.getCircularBuffer() ); 
     29                protected FlyweightLogMessage initialValue() { 
     30                        return new FlyweightLogMessage( logger.getCircularBuffer() ); 
    2931                } 
    3032        }; 
    3133 
    3234        @Override 
    33         public synchronized MessageFormatter formatter( final String formatMessage ) { 
    34                 final SimpleMessageFormatter formatter = logger.formatter( formatMessage ); 
     35        public synchronized LogMessage message( final String messageFormat ) { 
     36                final SimpleLogMessage formatter = logger.message( messageFormat ); 
    3537                final int formatId = formatter.formatId(); 
    3638                final String format = formatter.format(); 
    3739                final int argumentsCount = formatter.argumentsCount(); 
    3840 
    39                 return new ThreadLocalFormatter( 
     41                return new ThreadLocalLog( 
    4042                                format, 
    4143                                formatId, 
     
    5355 
    5456 
    55         private final class ThreadLocalFormatter implements MessageFormatter { 
     57        private final class ThreadLocalLog implements LogMessage { 
    5658 
    5759                private final String format; 
     
    5961                private final int argumentsCount; 
    6062 
    61                 private ThreadLocalFormatter( final String format, 
    62                                               final int formatId, 
    63                                               final int argumentsCount ) { 
     63                private ThreadLocalLog( final String format, 
     64                                        final int formatId, 
     65                                        final int argumentsCount ) { 
    6466                        this.formatId = formatId; 
    6567                        this.format = format; 
     
    6870 
    6971                @Override 
    70                 public FluentFormatter with( final double value ) { 
     72                public FluentLogBuilder with( final double value ) { 
    7173                        return setupLocal().with( value ); 
    7274                } 
    7375 
    7476                @Override 
    75                 public FluentFormatter with( final long value ) { 
     77                public FluentLogBuilder with( final long value ) { 
    7678                        return setupLocal().with( value ); 
    7779                } 
    7880 
    7981                @Override 
    80                 public void submit() { 
    81                         setupLocal().submit(); 
     82                public void log() { 
     83                        setupLocal().log(); 
    8284                } 
    8385 
    84                 private FlyweightMessageFormatter setupLocal() { 
    85                         final FlyweightMessageFormatter formatter = holder.get(); 
     86                private FlyweightLogMessage setupLocal() { 
     87                        final FlyweightLogMessage formatter = holder.get(); 
    8688                        formatter.setup( format, formatId, argumentsCount ); 
    8789                        return formatter; 
  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/logger/formatters/AbstractLogBuilder.java

    r587 r589  
    1 package com.db.logger.api.impl.logger; 
     1package com.db.logger.api.impl.logger.formatters; 
    22 
    3 import com.db.logger.api.MessageFormatter; 
    4 import com.google.common.base.Preconditions; 
     3import com.db.logger.api.FluentLogBuilder; 
     4import com.db.logger.api.LogMessage; 
     5import com.db.logger.api.impl.logger.CircularBuffer; 
     6import com.db.logger.api.impl.logger.RecordHelper; 
     7import net.jcip.annotations.NotThreadSafe; 
    58 
    69import static com.db.logger.api.impl.logger.DemultiplexingSequencer.INVALID_INDEX; 
    710import static com.db.logger.api.impl.logger.RecordHelper.RecordType.LOG_RECORD; 
     11import static com.google.common.base.Preconditions.checkArgument; 
    812import static com.google.common.base.Preconditions.checkState; 
    913 
     
    1216 *         created 05.12.13 at 0:52 
    1317 */ 
    14 public abstract class BaseMessageFormatter implements MessageFormatter { 
     18@NotThreadSafe 
     19public abstract class AbstractLogBuilder implements FluentLogBuilder { 
    1520        public static final int NOT_SET = -1; 
    1621 
    1722        private final CircularBuffer buffer; 
    1823 
    19         private int argumentIndex = 0; 
    20         private long position = 0; 
     24        protected int argumentIndex = NOT_SET; 
     25        protected long position = INVALID_INDEX; 
    2126 
    22         public BaseMessageFormatter( final CircularBuffer circularBuffer ) { 
    23                 this.buffer = circularBuffer; 
     27        public AbstractLogBuilder( final CircularBuffer buffer ) { 
     28                checkArgument( buffer != null, "buffer can't be null" ); 
     29                this.buffer = buffer; 
    2430        } 
    2531 
    2632        @Override 
    27         public BaseMessageFormatter with( final long value ) { 
    28                 //TODO conditions are costy! 
    29                 ensureStarted(); 
    30                 if( position == INVALID_INDEX ) { 
    31                         return this; 
    32                 } 
     33        public FluentLogBuilder with( final double value ) { 
     34                return with( Double.doubleToLongBits( value ) ); 
     35        } 
     36 
     37        @Override 
     38        public FluentLogBuilder with( final long value ) { 
     39                checkState( position != INVALID_INDEX, "Not started" ); 
    3340//              checkState( 
    3441//                              argumentIndex < argumentsCount(), 
     
    4754 
    4855        @Override 
    49         public BaseMessageFormatter with( final double value ) { 
    50                 return with( Double.doubleToLongBits( value ) ); 
    51         } 
    52  
    53         @Override 
    54         public void submit() { 
    55                 //TODO conditions are costy! 
    56                 ensureStarted(); 
    57                 if( position == INVALID_INDEX ) { 
    58                         return; 
    59                 } 
     56        public void log() { 
     57                checkState( position != INVALID_INDEX, "Not started" ); 
    6058                try { 
    6159//                      checkState( 
     
    7775        } 
    7876 
    79         private void ensureStarted() { 
    80                 if( argumentIndex == NOT_SET ) { 
    81                         position = buffer.claim( 
    82                                         argumentsCount() + 1 //1 for header 
    83                         ); 
    84                         argumentIndex = 0; 
    85                 } 
     77        protected void start() { 
     78                checkState( argumentIndex == NOT_SET, "Can't start -- not submitted yet" ); 
     79 
     80                position = buffer.claim( argumentsCount() + 1 );//1 for header 
     81 
     82                argumentIndex = 0; 
    8683        } 
    8784 
    88         public abstract int formatId(); 
     85        protected abstract int formatId(); 
     86 
     87        protected abstract int argumentsCount(); 
    8988} 
  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/logger/formatters/FlyweightLogMessage.java

    r587 r589  
    1 package com.db.logger.api.impl.logger; 
     1package com.db.logger.api.impl.logger.formatters; 
     2 
     3import com.db.logger.api.LogMessage; 
     4import com.db.logger.api.impl.logger.CircularBuffer; 
    25 
    36/** 
     
    58 *         created 20.11.13 at 23:48 
    69 */ 
    7 public class FlyweightMessageFormatter extends BaseMessageFormatter { 
     10public class FlyweightLogMessage extends AbstractLogBuilder implements LogMessage { 
    811 
    912        private String format; 
     
    1215        private int argumentsCount; 
    1316 
    14         public FlyweightMessageFormatter( final CircularBuffer circularBuffer ) { 
     17        public FlyweightLogMessage( final CircularBuffer circularBuffer ) { 
    1518                super( circularBuffer ); 
    1619        } 
  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/logger/formatters/RawLogMessage.java

    r587 r589  
    1 package com.db.logger.api.impl.logger; 
     1package com.db.logger.api.impl.logger.formatters; 
    22 
    3 import com.db.logger.api.MessageFormatter; 
    4 import com.db.logger.api.impl.FluentFormatter; 
    5 import com.google.common.base.Preconditions; 
     3import com.db.logger.api.LogMessage; 
     4import com.db.logger.api.FluentLogBuilder; 
     5import com.db.logger.api.impl.logger.CircularBuffer; 
     6import com.db.logger.api.impl.logger.RecordHelper; 
    67 
    7 import static com.db.logger.api.impl.logger.BaseMessageFormatter.NOT_SET; 
     8import static com.db.logger.api.impl.logger.formatters.AbstractLogBuilder.NOT_SET; 
    89import static com.db.logger.api.impl.logger.DemultiplexingSequencer.INVALID_INDEX; 
    910import static com.db.logger.api.impl.logger.RecordHelper.RecordType.LOG_RECORD; 
     
    1415 *         created 20.11.13 at 23:48 
    1516 */ 
    16 public final class FastMessageFormatter implements MessageFormatter { 
     17public final class RawLogMessage implements LogMessage, FluentLogBuilder { 
    1718 
    1819        private final CircularBuffer buffer; 
     
    2627        private final int argumentsCount; 
    2728 
    28         public FastMessageFormatter( final String format, 
    29                                      final int formatId, 
    30                                      final int argumentsCount, 
    31                                      final CircularBuffer circularBuffer ) { 
     29        public RawLogMessage( final String format, 
     30                              final int formatId, 
     31                              final int argumentsCount, 
     32                              final CircularBuffer circularBuffer ) { 
    3233                this.buffer = circularBuffer; 
    3334                this.format = format; 
     
    5152        } 
    5253 
    53         public FluentFormatter start() { 
    54                 checkState( argumentIndex == NOT_SET, 
    55                             "Submit first!" ); 
     54        public FluentLogBuilder start() { 
     55                checkState( argumentIndex == NOT_SET, "Submit first!" ); 
    5656                position = buffer.claim( argumentsCount + 1 );//1 for header 
     57                checkState( position != INVALID_INDEX, "Can't claim position" ); 
    5758                argumentIndex = 0; 
    5859                return this; 
     
    6162 
    6263        @Override 
    63         public FluentFormatter with( final long value ) { 
    64                 if( position == INVALID_INDEX ) { 
    65                         return this; 
    66                 } 
     64        public FluentLogBuilder with( final long value ) { 
     65                checkState( position != INVALID_INDEX, "Not started" ); 
    6766                //              checkState( 
    6867                //                              argumentIndex < argumentsCount(), 
     
    8180 
    8281        @Override 
    83         public FluentFormatter with( final double value ) { 
     82        public FluentLogBuilder with( final double value ) { 
    8483                return with( Double.doubleToLongBits( value ) ); 
    8584        } 
    8685 
    8786        @Override 
    88         public void submit() { 
    89                 if( position == INVALID_INDEX ) { 
    90                         return; 
    91                 } 
     87        public void log() { 
     88                checkState( position != INVALID_INDEX, "Not started" ); 
    9289                try { 
    9390                        //                      checkState( 
  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/logger/formatters/SimpleLogMessage.java

    r586 r589  
    1 package com.db.logger.api.impl.logger; 
     1package com.db.logger.api.impl.logger.formatters; 
    22 
    3 import com.db.logger.api.MessageFormatter; 
     3import com.db.logger.api.FluentLogBuilder; 
     4import com.db.logger.api.LogMessage; 
     5import com.db.logger.api.impl.logger.CircularBuffer; 
     6import net.jcip.annotations.NotThreadSafe; 
    47 
    5 import static com.db.logger.api.impl.logger.DemultiplexingSequencer.INVALID_INDEX; 
    6 import static com.db.logger.api.impl.logger.RecordHelper.RecordType.LOG_RECORD; 
    78import static com.google.common.base.Preconditions.checkState; 
    89 
     
    1112 *         created 20.11.13 at 23:48 
    1213 */ 
    13 public final class SimpleMessageFormatter extends BaseMessageFormatter { 
     14@NotThreadSafe 
     15public final class SimpleLogMessage implements LogMessage { 
    1416 
    1517        private final String format; 
     
    1820        private final int argumentsCount; 
    1921 
    20         public SimpleMessageFormatter( final String format, 
    21                                        final int formatId, 
    22                                        final int argumentsCount, 
    23                                        final CircularBuffer circularBuffer ) { 
    24                 super( circularBuffer ); 
     22        private final AbstractLogBuilder builder; 
     23 
     24 
     25        public SimpleLogMessage( final String format, 
     26                                 final int formatId, 
     27                                 final int argumentsCount, 
     28                                 final CircularBuffer circularBuffer ) { 
     29                builder = new AbstractLogBuilder( circularBuffer ) { 
     30                        @Override 
     31                        protected int formatId() { 
     32                                return formatId; 
     33                        } 
     34 
     35                        @Override 
     36                        protected int argumentsCount() { 
     37                                return argumentsCount; 
     38                        } 
     39                }; 
    2540                this.format = format; 
    2641 
    2742                this.formatId = formatId; 
    2843                this.argumentsCount = argumentsCount; 
     44        } 
     45 
     46        @Override 
     47        public FluentLogBuilder with( final double value ) { 
     48                builder.start(); 
     49                return builder.with( value ); 
     50        } 
     51 
     52        @Override 
     53        public FluentLogBuilder with( final long value ) { 
     54                builder.start(); 
     55                return builder.with( value ); 
     56        } 
     57 
     58        @Override 
     59        public void log() { 
     60                builder.start(); 
     61                builder.log(); 
    2962        } 
    3063 
     
    4275                return argumentsCount; 
    4376        } 
    44  
    4577} 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/BufferWriteAndDrainBenchmark.java

    r586 r589  
    1212import org.openjdk.jmh.logic.BlackHole; 
    1313 
     14import static com.db.logger.api.impl.logger.RecordHelper.NOT_SET; 
     15 
    1416/** 
    1517 * @author ruslan 
     
    2426        public static final int WRITER_BACKOFF = Integer.getInteger( "writer-backoff", 20 ); 
    2527 
    26         public static final WaitingStrategy WAITING_STRATEGY = new WaitingStrategy.LimitedSpinning( 1024*128 ); 
     28        public static final WaitingStrategy WAITING_STRATEGY = new WaitingStrategy.LimitedSpinning( 1024 * 128 ); 
    2729 
    2830        public static final AtomicInteger ID_GENERATOR = new AtomicInteger( 1 ); 
     
    6163                                                        final long header = buffer.getVolatile( pos ); 
    6264                                                        if( header > 0 ) { 
    63                                                                 buffer.put( pos, -1 ); 
     65                                                                buffer.put( pos, NOT_SET ); 
    6466                                                                break; 
    6567                                                        } 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/FastLoggerWithSimpleLogMessageBenchmark.java

    r587 r589  
    55import java.util.concurrent.atomic.AtomicInteger; 
    66 
    7 import com.db.logger.api.impl.FluentFormatter; 
     7import com.db.logger.api.FluentLogBuilder; 
     8import com.db.logger.api.LogMessage; 
    89import com.db.logger.api.impl.logger.*; 
    910import com.db.logger.api.impl.logger.buffer.DirectAccessLongBuffer; 
    1011import com.db.logger.api.impl.logger.buffer.ILongsBuffer; 
     12import com.db.logger.api.impl.logger.formatters.SimpleLogMessage; 
    1113import org.apache.log4j.BasicConfigurator; 
    1214import org.apache.log4j.Logger; 
     
    2527@OutputTimeUnit( TimeUnit.NANOSECONDS ) 
    2628@State( Scope.Group ) 
    27 public class SimpleFastLoggerBenchmark { 
    28         private static final Logger log = Logger.getLogger( SimpleFastLoggerBenchmark.class ); 
     29public class FastLoggerWithSimpleLogMessageBenchmark { 
     30        private static final Logger log = Logger.getLogger( FastLoggerWithSimpleLogMessageBenchmark.class ); 
    2931        public static final int LENGTH = Integer.getInteger( "length", 1 << 14 ); 
    3032        public static final int CELLS_PER_RECORD = Integer.getInteger( "cells-per-record", 8 );//8longs = 1 cache line 
     
    8284        /*=============================================================================*/ 
    8385        @GenerateMicroBenchmark 
     86        @Threads( 3 ) 
    8487        @Group( "loggingAndPayload" ) 
    8588        public void writeFormatted( final ThreadState ts ) { 
    86                 if( ts.formatter == null ) { 
     89                if( ts.logMessage == null ) { 
    8790                        ts.setup( this ); 
    8891                } 
    89                 FluentFormatter formatter = ts.formatter; 
    9092                final int count = CELLS_PER_RECORD; 
    91                 for( int i = 0; i < count; i++ ) { 
    92                         formatter = formatter.with( ( long ) i ); 
     93                FluentLogBuilder logBuilder = ts.logMessage.with( 4d ); 
     94                for( int i = 1; i < count; i++ ) { 
     95                        logBuilder = logBuilder.with( ( long ) i ); 
    9396                } 
    94                 formatter.submit(); 
     97                logBuilder.log(); 
    9598 
    9699                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     
    101104                public final int id = ID_GENERATOR.incrementAndGet(); 
    102105 
    103                 public SimpleMessageFormatter formatter; 
     106                public LogMessage logMessage; 
    104107 
    105                 public void setup( final SimpleFastLoggerBenchmark b ) { 
    106                         formatter = b.logger.formatter( id + " %d %f %d %f %d %f %f %f" ); 
     108                public void setup( final FastLoggerWithSimpleLogMessageBenchmark b ) { 
     109                        logMessage = b.logger.message( id + " %d %f %d %f %d %f %f %f" ); 
    107110                } 
    108111        } 
    109112 
    110113        public static void main( final String[] args ) throws Exception { 
    111                 final SimpleFastLoggerBenchmark benchmark = new SimpleFastLoggerBenchmark(); 
     114                final FastLoggerWithSimpleLogMessageBenchmark benchmark = new FastLoggerWithSimpleLogMessageBenchmark(); 
    112115 
    113116                benchmark.setup(); 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/FastLoggerWithThreadLocalLogMessageBenchmark.java

    r587 r589  
    55import java.util.concurrent.atomic.AtomicInteger; 
    66 
    7 import com.db.logger.api.MessageFormatter; 
    8 import com.db.logger.api.impl.FluentFormatter; 
     7import com.db.logger.api.LogMessage; 
     8import com.db.logger.api.FluentLogBuilder; 
    99import com.db.logger.api.impl.logger.*; 
    1010import com.db.logger.api.impl.logger.buffer.DirectAccessLongBuffer; 
     
    2626@OutputTimeUnit( TimeUnit.NANOSECONDS ) 
    2727@State( Scope.Group ) 
    28 public class ThreadLocalFastLoggerBenchmark { 
    29         private static final Logger log = Logger.getLogger( ThreadLocalFastLoggerBenchmark.class ); 
     28public class FastLoggerWithThreadLocalLogMessageBenchmark { 
     29        private static final Logger log = Logger.getLogger( FastLoggerWithThreadLocalLogMessageBenchmark.class ); 
    3030        public static final int LENGTH = Integer.getInteger( "length", 1 << 14 ); 
    3131        public static final int CELLS_PER_RECORD = Integer.getInteger( "cells-per-record", 8 );//8longs = 1 cache line 
     
    8888                        ts.setup( this ); 
    8989                } 
    90                 FluentFormatter formatter = ts.formatter; 
     90                FluentLogBuilder logBuilder = ts.formatter.with( 5d ); 
    9191                final int count = CELLS_PER_RECORD; 
    92                 for( int i = 0; i < count; i++ ) { 
    93                         formatter = formatter.with( ( long ) i ); 
     92                for( int i = 1; i < count; i++ ) { 
     93                        logBuilder = logBuilder.with( ( long ) i ); 
    9494                } 
    95                 formatter.submit(); 
     95                logBuilder.log(); 
    9696 
    9797                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     
    102102                public final int id = ID_GENERATOR.incrementAndGet(); 
    103103 
    104                 public MessageFormatter formatter; 
     104                public LogMessage formatter; 
    105105 
    106                 public void setup( final ThreadLocalFastLoggerBenchmark b ) { 
    107                         formatter = b.logger.formatter( id + " %d %f %d %f %d %f %f %f" ); 
     106                public void setup( final FastLoggerWithThreadLocalLogMessageBenchmark b ) { 
     107                        formatter = b.logger.message( id + " %d %f %d %f %d %f %f %f" ); 
    108108                } 
    109109        } 
    110110 
    111111        public static void main( final String[] args ) throws Exception { 
    112                 final ThreadLocalFastLoggerBenchmark benchmark = new ThreadLocalFastLoggerBenchmark(); 
     112                final FastLoggerWithThreadLocalLogMessageBenchmark benchmark = new FastLoggerWithThreadLocalLogMessageBenchmark(); 
    113113 
    114114                benchmark.setup(); 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/Log4j20Benchmark.java

    r586 r589  
    7575                final Object[] arguments = new Object[CELLS_PER_RECORD - 1]; 
    7676                logger.info( "", arguments ); 
    77 //              final int count = formatter.argumentsCount(); 
     77//              final int count = logMessage.argumentsCount(); 
    7878//              for( int i = 0; i < count; i++ ) { 
    79 //                      formatter = formatter.with( ( long ) i ); 
     79//                      logMessage = logMessage.with( ( long ) i ); 
    8080//              } 
    81 //              formatter.submit(); 
     81//              logMessage.submit(); 
    8282 
    8383                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     
    8989        public void readingDrainer() { 
    9090                try { 
    91 //                      sequencer.drainTo( DRAIN_AND_READ ); 
     91//                      sequencer.drainTo( readingConsumer ); 
    9292//                      BlackHole.consumeCPU( 100 ); 
    9393                } catch( Throwable e ) { 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/RawLogMessageWriteAndDrainBenchmark.java

    r587 r589  
    44import java.util.concurrent.atomic.AtomicInteger; 
    55 
    6 import com.db.logger.api.impl.FluentFormatter; 
     6import com.db.logger.api.FluentLogBuilder; 
    77import com.db.logger.api.impl.logger.*; 
    88import com.db.logger.api.impl.logger.buffer.DirectAccessLongBuffer; 
    99import com.db.logger.api.impl.logger.buffer.ILongsBuffer; 
     10import com.db.logger.api.impl.logger.formatters.RawLogMessage; 
    1011import org.openjdk.jmh.annotations.*; 
    1112import org.openjdk.jmh.logic.BlackHole; 
    1213 
    13 import static com.db.logger.api.impl.logger.RecordHelper.*; 
    14  
    1514/** 
     15 * RawLogMessage -- with explicit .start() method 
     16 * 
    1617 * @author ruslan 
    1718 *         created 22.11.13 at 20:04 
     
    2021@OutputTimeUnit( TimeUnit.NANOSECONDS ) 
    2122@State( Scope.Group ) 
    22 public class FastFormatterWriteAndDrainBenchmark { 
     23public class RawLogMessageWriteAndDrainBenchmark { 
    2324        public static final int LENGTH = Integer.getInteger( "length", 1 << 14 ); 
    2425        public static final int CELLS_PER_RECORD = Integer.getInteger( "cells-per-record", 8 );//8longs = 1 cache line 
     
    3637        public DemultiplexingSequencer sequencer; 
    3738 
    38         public DemultiplexingSequencer.Drainer DRAIN_AND_READ; 
     39        public DemultiplexingSequencer.Drainer readingConsumer; 
    3940 
    4041        @Setup 
     
    4344                sequencer = new DemultiplexingSequencer( LENGTH ); 
    4445 
    45                 DRAIN_AND_READ = new ConsumingDrainer(); 
     46                readingConsumer = new ConsumingDrainer( buffer ); 
    4647        } 
    4748 
     
    7273                } 
    7374                final int count = ts.formatter.argumentsCount(); 
    74                 FluentFormatter formatter = ts.formatter.start(); 
    75                 for( int i = 0; i < count; i++ ) { 
    76                         formatter = formatter.with( ( long ) i ); 
     75                FluentLogBuilder logBuilder = ts.formatter.start(); 
     76                logBuilder = logBuilder.with( 5d ); 
     77                for( int i = 1; i < count; i++ ) { 
     78                        logBuilder = logBuilder.with( ( long ) i ); 
    7779                } 
    78                 formatter.submit(); 
     80                logBuilder.log(); 
    7981 
    8082                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     
    8688        public void readingDrainer() { 
    8789                try { 
    88                         sequencer.drainTo( DRAIN_AND_READ ); 
     90                        sequencer.drainTo( readingConsumer ); 
    8991//                      BlackHole.consumeCPU( 100 ); 
    9092                } catch( Throwable e ) { 
     
    9799                public final int id = ID_GENERATOR.incrementAndGet(); 
    98100 
    99                 public FastMessageFormatter formatter; 
     101                public RawLogMessage formatter; 
    100102 
    101                 public void setup( final FastFormatterWriteAndDrainBenchmark b ) { 
    102                         formatter = new FastMessageFormatter( 
     103                public void setup( final RawLogMessageWriteAndDrainBenchmark b ) { 
     104                        formatter = new RawLogMessage( 
    103105                                        "", 
    104106                                        id, 
     
    110112 
    111113        public static void main( final String[] args ) throws Exception { 
    112                 final FastFormatterWriteAndDrainBenchmark benchmark = new FastFormatterWriteAndDrainBenchmark(); 
     114                final RawLogMessageWriteAndDrainBenchmark benchmark = new RawLogMessageWriteAndDrainBenchmark(); 
    113115 
    114116                benchmark.setup(); 
     
    140142        } 
    141143 
    142         private class ConsumingDrainer implements DemultiplexingSequencer.Drainer { 
    143                 private static final int SPINS_PER_TURN = 256; 
    144  
    145                 private int spinsAvailable; 
    146                 private final BlackHole hole = new BlackHole(); 
    147  
    148                 @Override 
    149                 public int available( final long startSequence, 
    150                                       final long sentinelSequence ) { 
    151                         spinsAvailable = SPINS_PER_TURN; 
    152                         for( long pos = startSequence; pos < sentinelSequence; pos++ ) { 
    153                                 final long header = readHeader( pos ); 
    154                                 if( !isValidHeader( header ) ) { 
    155                                         return ( int ) ( pos - startSequence ); 
    156                                 } 
    157                                 final RecordType type = type( header ); 
    158                                 final int formatId = formatId( header ); 
    159                                 final int argumentsCount = argumentsCount( header ); 
    160                                 for( int i = 1; i <= argumentsCount; i++ ) { 
    161                                         hole.consume( buffer.get( pos + i ) ); 
    162                                         buffer.put( pos + i, -1 );//needs to reclaim all! 
    163                                 } 
    164                                 buffer.put( pos, -1 ); 
    165                                 pos += argumentsCount; 
    166                         } 
    167                         return ( int ) ( sentinelSequence - startSequence ); 
    168                 } 
    169  
    170                 private long readHeader( final long pos ) { 
    171                         for(; spinsAvailable >= 0; spinsAvailable-- ) { 
    172                                 final long header = buffer.getVolatile( pos ); 
    173                                 if( isValidHeader( header ) ) { 
    174                                         return header; 
    175                                 } 
    176                         } 
    177                         return -1; 
    178                 } 
    179         } 
    180144} 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/SimpleLogMessageWriteAndDrainBenchmark.java

    r587 r589  
    44import java.util.concurrent.atomic.AtomicInteger; 
    55 
    6 import com.db.logger.api.impl.FluentFormatter; 
     6import com.db.logger.api.FluentLogBuilder; 
    77import com.db.logger.api.impl.logger.*; 
    88import com.db.logger.api.impl.logger.buffer.DirectAccessLongBuffer; 
    99import com.db.logger.api.impl.logger.buffer.ILongsBuffer; 
     10import com.db.logger.api.impl.logger.formatters.SimpleLogMessage; 
    1011import org.openjdk.jmh.annotations.*; 
    1112import org.openjdk.jmh.logic.BlackHole; 
     
    2021@OutputTimeUnit( TimeUnit.NANOSECONDS ) 
    2122@State( Scope.Group ) 
    22 public class SimpleFormatterWriteAndDrainBenchmark { 
     23public class SimpleLogMessageWriteAndDrainBenchmark { 
    2324        public static final int LENGTH = Integer.getInteger( "length", 1 << 14 ); 
    2425        public static final int CELLS_PER_RECORD = Integer.getInteger( "cells-per-record", 8 );//8longs = 1 cache line 
     
    3637        public DemultiplexingSequencer sequencer; 
    3738 
    38         public DemultiplexingSequencer.Drainer DRAIN_AND_READ; 
     39        public DemultiplexingSequencer.Drainer readingConsumer; 
    3940 
    4041        @Setup 
     
    4344                sequencer = new DemultiplexingSequencer( LENGTH ); 
    4445 
    45                 DRAIN_AND_READ = new ConsumingDrainer(); 
     46                readingConsumer = new ConsumingDrainer( buffer ); 
    4647        } 
    4748 
     
    7273                } 
    7374                final int count = ts.formatter.argumentsCount(); 
    74                 FluentFormatter formatter = ts.formatter; 
    75                 for( int i = 0; i < count; i++ ) { 
    76                         formatter = formatter.with( ( long ) i ); 
     75                FluentLogBuilder logBuilder = ts.formatter.with( 5d ); 
     76                for( int i = 1; i < count; i++ ) { 
     77                        logBuilder = logBuilder.with( ( long ) i ); 
    7778                } 
    78                 formatter.submit(); 
     79                logBuilder.log(); 
    7980 
    8081                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     
    8687        public void readingDrainer() { 
    8788                try { 
    88                         sequencer.drainTo( DRAIN_AND_READ ); 
     89                        sequencer.drainTo( readingConsumer ); 
    8990//                      BlackHole.consumeCPU( 100 ); 
    9091                } catch( Throwable e ) { 
     
    9798                public final int id = ID_GENERATOR.incrementAndGet(); 
    9899 
    99                 public SimpleMessageFormatter formatter; 
     100                public SimpleLogMessage formatter; 
    100101 
    101                 public void setup( final SimpleFormatterWriteAndDrainBenchmark b ) { 
    102                         formatter = new SimpleMessageFormatter( 
     102                public void setup( final SimpleLogMessageWriteAndDrainBenchmark b ) { 
     103                        formatter = new SimpleLogMessage( 
    103104                                        "", 
    104105                                        id, 
     
    110111 
    111112        public static void main( final String[] args ) throws Exception { 
    112                 final SimpleFormatterWriteAndDrainBenchmark benchmark = new SimpleFormatterWriteAndDrainBenchmark(); 
     113                final SimpleLogMessageWriteAndDrainBenchmark benchmark = new SimpleLogMessageWriteAndDrainBenchmark(); 
    113114 
    114115                benchmark.setup(); 
     
    139140                Thread.sleep( 300000 ); 
    140141        } 
    141  
    142         private class ConsumingDrainer implements DemultiplexingSequencer.Drainer { 
    143                 private static final int SPINS_PER_TURN = 256; 
    144  
    145                 private int spinsAvailable; 
    146                 private final BlackHole hole = new BlackHole(); 
    147  
    148                 @Override 
    149                 public int available( final long startSequence, 
    150                                       final long sentinelSequence ) { 
    151                         spinsAvailable = SPINS_PER_TURN; 
    152                         for( long pos = startSequence; pos < sentinelSequence; pos++ ) { 
    153                                 final long header = readHeader( pos ); 
    154                                 if( !isValidHeader( header ) ) { 
    155                                         return ( int ) ( pos - startSequence ); 
    156                                 } 
    157                                 final RecordHelper.RecordType type = type( header ); 
    158                                 final int formatId = formatId( header ); 
    159                                 final int argumentsCount = argumentsCount( header ); 
    160                                 for( int i = 1; i <= argumentsCount; i++ ) { 
    161                                         hole.consume( buffer.get( pos + i ) ); 
    162                                         buffer.put( pos + i, -1 );//needs to reclaim all! 
    163                                 } 
    164                                 buffer.put( pos, -1 ); 
    165                                 pos += argumentsCount; 
    166                         } 
    167                         return ( int ) ( sentinelSequence - startSequence ); 
    168                 } 
    169  
    170                 private long readHeader( final long pos ) { 
    171                         for(; spinsAvailable >= 0; spinsAvailable-- ) { 
    172                                 final long header = buffer.getVolatile( pos ); 
    173                                 if( isValidHeader( header ) ) { 
    174                                         return header; 
    175                                 } 
    176                         } 
    177                         return -1; 
    178                 } 
    179         } 
    180142} 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/helpers/AtomicBenchmark.java

    r586 r589  
    1 package com.db.logger.benchmarks; 
     1package com.db.logger.benchmarks.helpers; 
    22 
    33import java.util.concurrent.TimeUnit; 
    44import java.util.concurrent.atomic.AtomicInteger; 
    55 
    6 import com.db.logger.api.impl.logger.DemultiplexingSequencer; 
    7 import com.db.logger.api.impl.logger.WaitingStrategy; 
    86import org.openjdk.jmh.annotations.*; 
    97import org.openjdk.jmh.logic.BlackHole; 
    10 import sun.misc.Unsafe; 
    118 
    129/** 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/helpers/IOBenchmark.java

    r586 r589  
    1 package com.db.logger.benchmarks; 
     1package com.db.logger.benchmarks.helpers; 
    22 
    33import java.io.*; 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/helpers/SequencerBenchmark.java

    r586 r589  
    1 package com.db.logger.benchmarks; 
     1package com.db.logger.benchmarks.helpers; 
    22 
    33import java.util.concurrent.TimeUnit; 
     
    66import com.db.logger.api.impl.logger.DemultiplexingSequencer; 
    77import com.db.logger.api.impl.logger.WaitingStrategy; 
     8import org.apache.log4j.BasicConfigurator; 
     9import org.apache.log4j.Logger; 
    810import org.openjdk.jmh.annotations.*; 
    911import org.openjdk.jmh.logic.BlackHole; 
     
    1113/** 
    1214 * Here we measure raw sequencer performance: just position claiming/reclaiming 
     15 * <p/> 
     16 * TODO: sometimes hangs! why? 
    1317 * 
    1418 * @author ruslan 
     
    1923@State( Scope.Group ) 
    2024public class SequencerBenchmark { 
     25        private static final Logger log = Logger.getLogger( SequencerBenchmark.class ); 
     26 
    2127        public static final int LENGTH = Integer.getInteger( "length", 1 << 14 ); 
    2228        public static final int CELLS_PER_RECORD = Integer.getInteger( "record-size", 8 );//8longs = 1 cache line 
     
    2632 
    2733        static { 
     34                BasicConfigurator.configure(); 
    2835                System.out.printf( "len=%d, record=%d, payload=%d\n", LENGTH, CELLS_PER_RECORD, WRITER_BACKOFF ); 
    2936        } 
     
    6673        /*=============================================================================*/ 
    6774        @GenerateMicroBenchmark 
    68         @Group( "write3AndDummyDrainAndPayload" ) 
     75        @Group( "claim3AndPayloadAndDrain1Dummy" ) 
    6976        @Threads( 3 )//actually it's (CORES-1) 
    70         public void writer( final ThreadState ts ) { 
    71                 writeEntry( ts.id, ts.count ); 
     77        public void claimer( final ThreadState ts ) { 
     78                claimEntry( ts.id, ts.count ); 
    7279                BlackHole.consumeCPU( WRITER_BACKOFF ); 
    7380        } 
    7481 
    7582        @GenerateMicroBenchmark 
    76         @Group( "write3AndDummyDrainAndPayload" ) 
     83        @Group( "claim3AndPayloadAndDrain1Dummy" ) 
    7784        @Threads( 1 ) 
    78         public void dummyDrainer() { 
     85        public void drainer() { 
    7986                try { 
    8087                        sequencer.drainTo( DRAIN_DUMMY ); 
     
    8794        /*=============================================================================*/ 
    8895 
    89         private long writeEntry( final int writerId, 
     96        private long claimEntry( final int writerId, 
    9097                                 final int cellsCount ) { 
    9198                return sequencer.claim( cellsCount, WAITING_STRATEGY ); 
     
    103110                benchmark.setup(); 
    104111 
     112                final int BATCH = 1000000; 
    105113                final ThreadState[] states = new ThreadState[3]; 
    106114                for( int i = 0; i < states.length; i++ ) { 
     
    110118                                @Override 
    111119                                public void run() { 
    112                                         for(; ; ) { 
    113                                                 benchmark.writer( state ); 
     120                                        for( int turn = 0; ; turn += BATCH ) { 
     121                                                for( int i = 0; i < BATCH; i++ ) { 
     122                                                        benchmark.claimer( state ); 
     123                                                } 
     124                                                log.info( "Thread " + state.id + ": " + turn ); 
    114125                                        } 
    115126                                } 
     
    120131                        @Override 
    121132                        public void run() { 
     133 
    122134                                for(; ; ) { 
    123                                         benchmark.dummyDrainer(); 
     135                                        benchmark.drainer(); 
    124136                                } 
    125137                        } 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/helpers/ThreadLocalBenchmark.java

    r586 r589  
    1 package com.db.logger.benchmarks; 
     1package com.db.logger.benchmarks.helpers; 
    22 
    33import java.util.concurrent.TimeUnit; 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/helpers/TimestampersBenchmark.java

    r586 r589  
    1 package com.db.logger.benchmarks; 
     1package com.db.logger.benchmarks.helpers; 
    22 
    33import java.util.concurrent.TimeUnit; 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/helpers/UnsafeAtomicBenchmark.java

    r587 r589  
    1 package com.db.logger.benchmarks; 
     1package com.db.logger.benchmarks.helpers; 
    22 
    33import java.lang.reflect.Field; 
    44import java.util.concurrent.TimeUnit; 
    5 import java.util.concurrent.atomic.AtomicInteger; 
    65 
    76import com.db.logger.api.impl.logger.UnsafeHelper; 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/helpers/VolatileBenchmark.java

    r586 r589  
    1 package com.db.logger.benchmarks; 
     1package com.db.logger.benchmarks.helpers; 
    22 
    33import java.util.concurrent.TimeUnit; 
    4 import java.util.concurrent.atomic.AtomicInteger; 
    54 
    65import org.openjdk.jmh.annotations.*; 
  • Tests/JAVA/logger/src/main/java/com/db/logger/io/storage/RawWriter.java

    r581 r589  
    2424 *         created 11/14/13 at 10:16 AM 
    2525 */ 
    26 public interface RawWriter extends Flushable, Closeable, AutoCloseable { 
     26public interface RawWriter extends Flushable, Closeable/*, AutoCloseable*/ { 
    2727 
    2828    public ByteBuffer buffer(); 
  • Tests/JAVA/logger/src/main/java/com/db/logger/io/storage/RecordWriter.java

    r581 r589  
    99 *         created 11/14/13 at 10:17 AM 
    1010 */ 
    11 public interface RecordWriter<T> extends Closeable, Flushable, AutoCloseable { 
     11public interface RecordWriter<T> extends Closeable, Flushable/*, AutoCloseable*/ { 
    1212    /** @return metadata stored alongside the storage. Can't be modified */ 
    1313    public RecordStorage.Metadata metadata(); 
Note: See TracChangeset for help on using the changeset viewer.