Changeset 590 for Tests


Ignore:
Timestamp:
12/08/13 14:12:21 (8 years ago)
Author:
BegemoT
Message:
 
Location:
Tests/JAVA/logger
Files:
1 added
2 deleted
18 edited
1 copied
2 moved

Legend:

Unmodified
Added
Removed
  • Tests/JAVA/logger/logger.iml

    r586 r590  
    11<?xml version="1.0" encoding="UTF-8"?> 
    22<module org.jetbrains.idea.maven.project.MavenProjectsManager.isMavenModule="true" type="JAVA_MODULE" version="4"> 
    3   <component name="NewModuleRootManager" inherit-compiler-output="false"> 
     3  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_6" inherit-compiler-output="false"> 
    44    <output url="file://$MODULE_DIR$/target/classes" /> 
    55    <output-test url="file://$MODULE_DIR$/target/test-classes" /> 
     
    77      <sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" /> 
    88      <sourceFolder url="file://$MODULE_DIR$/src/test/java" isTestSource="true" /> 
    9       <sourceFolder url="file://$MODULE_DIR$/target/generated-test-sources/test-annotations" isTestSource="true" /> 
    109      <sourceFolder url="file://$MODULE_DIR$/target/generated-sources/annotations" isTestSource="false" /> 
    1110      <excludeFolder url="file://$MODULE_DIR$/target/classes" /> 
    12       <excludeFolder url="file://$MODULE_DIR$/target/maven-archiver" /> 
    1311      <excludeFolder url="file://$MODULE_DIR$/target/maven-status" /> 
    14       <excludeFolder url="file://$MODULE_DIR$/target/test-classes" /> 
    1512    </content> 
    1613    <orderEntry type="inheritedJdk" /> 
    1714    <orderEntry type="sourceFolder" forTests="false" /> 
    18     <orderEntry type="library" name="Maven: org.openjdk.jmh:jmh-core:1.0-SNAPSHOT" level="project" /> 
     15    <orderEntry type="library" name="Maven: org.openjdk.jmh:jmh-core:0.2" level="project" /> 
    1916    <orderEntry type="library" name="Maven: args4j:args4j:2.0.16" level="project" /> 
    2017    <orderEntry type="library" scope="TEST" name="Maven: junit:junit:4.11" level="project" /> 
  • Tests/JAVA/logger/pom.xml

    r586 r590  
    6464            <groupId>org.openjdk.jmh</groupId> 
    6565            <artifactId>jmh-core</artifactId> 
    66             <version>1.0-SNAPSHOT</version> 
     66            <version>0.2</version> 
    6767        </dependency> 
    6868        <!-- testing support --> 
  • Tests/JAVA/logger/src/main/java/com/db/logger/api/FastLogger.java

    r589 r590  
    77public interface FastLogger { 
    88 
     9        public LogMessage messageSimple( final String messageFormat ); 
     10 
     11        public LogMessage messageThreadLocal( final String messageFormat ); 
     12 
    913        public LogMessage message( final String messageFormat ); 
    1014 
  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/logger/FastLoggerImpl.java

    r589 r590  
    33import java.io.IOException; 
    44import java.nio.ByteBuffer; 
    5 import java.util.*; 
    65import java.util.concurrent.ThreadFactory; 
    76 
    87import com.db.logger.api.FastLogger; 
     8import com.db.logger.api.FluentLogBuilder; 
     9import com.db.logger.api.LogMessage; 
    910import com.db.logger.api.impl.logger.buffer.ILongsBuffer; 
     11import com.db.logger.api.impl.logger.formatters.FlyweightLogMessage; 
     12import com.db.logger.api.impl.logger.formatters.RawLogMessage; 
    1013import com.db.logger.api.impl.logger.formatters.SimpleLogMessage; 
    1114import com.db.logger.io.storage.RawWriter; 
    1215import com.google.common.base.Throwables; 
    13 import gnu.trove.map.hash.TObjectIntHashMap; 
     16import gnu.trove.map.hash.THashMap; 
    1417import org.apache.commons.logging.Log; 
    1518import org.apache.commons.logging.LogFactory; 
     
    2326 *         created 24.08.13 at 15:14 
    2427 */ 
    25 public class SimpleFastLogger implements FastLogger { 
    26         private static final Log log = LogFactory.getLog( SimpleFastLogger.class ); 
    27         private static final int NOT_FOUND = -1; 
     28public class FastLoggerImpl implements FastLogger { 
     29        private static final Log log = LogFactory.getLog( FastLoggerImpl.class ); 
    2830 
    2931        private final ThreadFactory threadFactory; 
     
    3436 
    3537 
    36         public SimpleFastLogger( final ThreadFactory threadFactory, 
    37                                  final ILongsBuffer buffer, 
    38                                  final WaitingStrategy waitingStrategy, 
    39                                  final RawWriter writer ) { 
     38        public FastLoggerImpl( final ThreadFactory threadFactory, 
     39                               final ILongsBuffer buffer, 
     40                               final WaitingStrategy waitingStrategy, 
     41                               final RawWriter writer ) { 
    4042                checkArgument( threadFactory != null, "threadFactory can't be null" ); 
    4143                checkArgument( waitingStrategy != null, "waitingStrategy can't be null" ); 
     
    6365//      }; 
    6466 
    65         private final HashMap<String, SimpleLogMessage> formatters = new HashMap<String, SimpleLogMessage>(); 
    66         private final TObjectIntHashMap<String> formatsToID = new TObjectIntHashMap<String>( 128, 0.5f, NOT_FOUND ); 
    67  
    68  
    6967        @Override 
    70         public synchronized SimpleLogMessage message( final String messageFormat ) { 
    71                 int formatId = formatsToID.get( messageFormat ); 
    72                 if( formatId == NOT_FOUND ) { 
    73                         formatId = formatsToID.size() + 1; 
    74                         formatsToID.put( messageFormat, formatId ); 
    75                 } 
    76                 final int argumentsCount = calculateArgumentsCount( messageFormat ); 
     68        public synchronized SimpleLogMessage messageSimple( final String messageFormat ) { 
     69                final MessageInfo messageInfo = lookupMessageInfo( messageFormat ); 
    7770                return new SimpleLogMessage( 
    7871                                messageFormat, 
    79                                 formatId, 
    80                                 argumentsCount, 
     72                                messageInfo.formatId, 
     73                                messageInfo.argumentsCount, 
    8174                                circularBuffer 
    8275                ); 
     76        } 
     77 
     78        private final ThreadLocal<RawLogMessage> holder = new ThreadLocal<RawLogMessage>() { 
     79                @Override 
     80                protected RawLogMessage initialValue() { 
     81                        return new RawLogMessage( circularBuffer ); 
     82                } 
     83        }; 
     84 
     85 
     86        @Override 
     87        public synchronized LogMessage messageThreadLocal( final String messageFormat ) { 
     88                final MessageInfo messageInfo = lookupMessageInfo( messageFormat ); 
     89 
     90                return new ThreadLocalLogMessage( messageInfo ); 
     91        } 
     92 
     93        private final THashMap<String, MessageInfo> formats = new THashMap<String, MessageInfo>( 128 ); 
     94 
     95        public LogMessage message( final String messageFormat ) { 
     96                final MessageInfo messageInfo = lookupMessageInfo( messageFormat ); 
     97                final RawLogMessage message = holder.get(); 
     98                return message.setup( messageInfo ).start(); 
     99        } 
     100 
     101        public MessageInfo lookupMessageInfo( final String messageFormat ) { 
     102                //TODO RC: dcl, ok for testing, but needs rewrite 
     103                MessageInfo messageInfo = formats.get( messageFormat ); 
     104                if( messageInfo == null ) { 
     105                        synchronized( formats ) { 
     106                                messageInfo = formats.get( messageFormat ); 
     107                                if( messageInfo == null ) { 
     108                                        checkArgument( messageFormat != null, "messageFormat can't be null" ); 
     109                                        messageInfo = new MessageInfo( 
     110                                                        messageFormat, 
     111                                                        calculateArgumentsCount( messageFormat ), 
     112                                                        formats.size() + 1 
     113                                        ); 
     114                                        formats.put( messageFormat, messageInfo ); 
     115                                } 
     116                        } 
     117                } 
     118                return messageInfo; 
    83119        } 
    84120 
     
    86122                int argumentsCount = 0; 
    87123                for( int i = 0; i < formatMessage.length(); i++ ) { 
    88                         if( formatMessage.charAt( i ) == '%' ) { 
     124                        if( formatMessage.charAt( i ) == '%' ) {//TODO RC: not safe! '%%' is not placeholder 
    89125                                argumentsCount++; 
    90126                        } 
     
    99135                        final Drainer drainer = new Drainer( 
    100136                                        circularBuffer, new ConsumingDrainer( 
    101                                                         circularBuffer.buffer(), 
    102                                                         writer 
    103                                         ) 
     137                                        circularBuffer.buffer(), 
     138                                        writer 
     139                        ) 
    104140                        ); 
    105141                        drainerThread = threadFactory.newThread( 
     
    118154                        drainerThread = null; 
    119155                } 
    120         } 
    121  
    122         protected CircularBuffer getCircularBuffer() { 
    123                 return circularBuffer; 
    124156        } 
    125157 
     
    227259                                        final int formatId = formatId( header ); 
    228260                                        final int argumentsCount = argumentsCount( header ); 
     261 
     262                                        //ensure output has space 
    229263                                        if( output.remaining() < ( argumentsCount + 1 ) * 8 ) { 
    230264                                                writer.flush(); 
     
    235269                                        for( int i = 0; i <= argumentsCount; i++ ) { 
    236270                                                final long arg = buffer.get( pos + i ); 
    237                                                 //TODO RC: it is not required since Sequencer protect us? 
    238271                                                buffer.put( pos + i, NOT_SET );//need to reclaim each cell! 
    239272                                                output.putLong( arg ); 
     
    258291                } 
    259292        } 
     293 
     294 
     295        private final class ThreadLocalLogMessage implements LogMessage { 
     296 
     297                private final MessageInfo messageInfo; 
     298 
     299                private ThreadLocalLogMessage( final MessageInfo messageInfo ) { 
     300                        this.messageInfo = messageInfo; 
     301                } 
     302 
     303                @Override 
     304                public FluentLogBuilder with( final double value ) { 
     305                        return setupLocal().with( value ); 
     306                } 
     307 
     308                @Override 
     309                public FluentLogBuilder with( final long value ) { 
     310                        return setupLocal().with( value ); 
     311                } 
     312 
     313                @Override 
     314                public void log() { 
     315                        setupLocal().log(); 
     316                } 
     317 
     318                private RawLogMessage setupLocal() { 
     319                        final RawLogMessage formatter = holder.get(); 
     320                        return formatter.setup( messageInfo ).start(); 
     321                } 
     322 
     323                @Override 
     324                public String format() { 
     325                        return messageInfo.format; 
     326                } 
     327 
     328                @Override 
     329                public int argumentsCount() { 
     330                        return messageInfo.argumentsCount; 
     331                } 
     332        } 
    260333} 
  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/logger/formatters/AbstractLogBuilder.java

    r589 r590  
    3737        @Override 
    3838        public FluentLogBuilder with( final long value ) { 
    39                 checkState( position != INVALID_INDEX, "Not started" ); 
     39                ensureStarted(); 
    4040//              checkState( 
    4141//                              argumentIndex < argumentsCount(), 
    42 //                              "Only %s arguments allowed but %s is", 
    43 //                              argumentsCount(), argumentIndex 
     42//                              "Only %s arguments allowed but %s (%s) here", 
     43//                              argumentsCount(), argumentIndex, value 
    4444//              ); 
    4545 
     
    5555        @Override 
    5656        public void log() { 
    57                 checkState( position != INVALID_INDEX, "Not started" ); 
     57                ensureStarted(); 
    5858                try { 
    5959//                      checkState( 
     
    7070                        buffer.buffer().putOrdered( position, header ); 
    7171                } finally { 
    72                         argumentIndex = NOT_SET; 
    73                         position = INVALID_INDEX; 
     72                        reset(); 
    7473                } 
    7574        } 
    7675 
    77         protected void start() { 
    78                 checkState( argumentIndex == NOT_SET, "Can't start -- not submitted yet" ); 
     76        protected void reset() { 
     77                argumentIndex = NOT_SET; 
     78                position = INVALID_INDEX; 
     79        } 
    7980 
    80                 position = buffer.claim( argumentsCount() + 1 );//1 for header 
     81        protected void ensureStarted() { 
     82                if( position == INVALID_INDEX ) { 
     83                        position = buffer.claim( argumentsCount() + 1 );//1 for header 
     84                        checkState( position != INVALID_INDEX, "Claim failed" ); 
    8185 
    82                 argumentIndex = 0; 
     86                        argumentIndex = 0; 
     87                } 
    8388        } 
    8489 
  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/logger/formatters/FlyweightLogMessage.java

    r589 r590  
    33import com.db.logger.api.LogMessage; 
    44import com.db.logger.api.impl.logger.CircularBuffer; 
     5import com.db.logger.api.impl.logger.MessageInfo; 
     6 
     7import static com.google.common.base.Preconditions.checkArgument; 
    58 
    69/** 
     10 * format/formatId/agumentsCount are mutable, so instance may be adjusted to different 
     11 * messages 
     12 * 
    713 * @author ruslan 
    814 *         created 20.11.13 at 23:48 
     
    1016public class FlyweightLogMessage extends AbstractLogBuilder implements LogMessage { 
    1117 
    12         private String format; 
    13         private int formatId; 
    14  
    15         private int argumentsCount; 
     18        private MessageInfo messageInfo = null; 
    1619 
    1720        public FlyweightLogMessage( final CircularBuffer circularBuffer ) { 
     
    1922        } 
    2023 
    21         public void setup( final String format, 
    22                            final int formatId, 
    23                            final int argumentsCount ) { 
    24                 this.format = format; 
    25                 this.formatId = formatId; 
    26                 this.argumentsCount = argumentsCount; 
     24        public FlyweightLogMessage setup( final MessageInfo messageInfo ) { 
     25                checkArgument( messageInfo != null, "messageInfo can't be null" ); 
     26                this.messageInfo = messageInfo; 
     27                return this; 
    2728        } 
    2829 
    2930        public int formatId() { 
    30                 return formatId; 
     31                return messageInfo.formatId; 
    3132        } 
    3233 
    3334        @Override 
    3435        public String format() { 
    35                 return format; 
     36                return messageInfo.format; 
    3637        } 
    3738 
    3839        @Override 
    3940        public int argumentsCount() { 
    40                 return argumentsCount; 
     41                return messageInfo.argumentsCount; 
    4142        } 
    4243 
  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/logger/formatters/RawLogMessage.java

    r589 r590  
    44import com.db.logger.api.FluentLogBuilder; 
    55import com.db.logger.api.impl.logger.CircularBuffer; 
     6import com.db.logger.api.impl.logger.MessageInfo; 
    67import com.db.logger.api.impl.logger.RecordHelper; 
    78 
     
    910import static com.db.logger.api.impl.logger.DemultiplexingSequencer.INVALID_INDEX; 
    1011import static com.db.logger.api.impl.logger.RecordHelper.RecordType.LOG_RECORD; 
     12import static com.google.common.base.Preconditions.checkArgument; 
    1113import static com.google.common.base.Preconditions.checkState; 
    1214 
     
    2224        private long position = INVALID_INDEX; 
    2325 
    24         private final String format; 
    25         private final int formatId; 
     26        private String format; 
     27        private int formatId; 
    2628 
    27         private final int argumentsCount; 
     29        private int argumentsCount; 
    2830 
    29         public RawLogMessage( final String format, 
    30                               final int formatId, 
    31                               final int argumentsCount, 
    32                               final CircularBuffer circularBuffer ) { 
     31        public RawLogMessage( final CircularBuffer circularBuffer ) { 
    3332                this.buffer = circularBuffer; 
    34                 this.format = format; 
     33        } 
    3534 
    36                 this.formatId = formatId; 
    37                 this.argumentsCount = argumentsCount; 
     35        public RawLogMessage setup( final MessageInfo messageInfo ) { 
     36                checkArgument( messageInfo != null, "messageInfo can't be null" ); 
     37                this.format = messageInfo.format; 
     38                this.formatId = messageInfo.formatId; 
     39                this.argumentsCount = messageInfo.argumentsCount; 
     40                return this; 
     41        } 
     42 
     43        public RawLogMessage start() { 
     44                checkState( argumentIndex == NOT_SET, "Submit first!" ); 
     45                position = buffer.claim( argumentsCount + 1 );//1 for header 
     46                checkState( position != INVALID_INDEX, "Can't claim position" ); 
     47                argumentIndex = 0; 
     48                return this; 
    3849        } 
    3950 
     
    5061        public int argumentsCount() { 
    5162                return argumentsCount; 
    52         } 
    53  
    54         public FluentLogBuilder start() { 
    55                 checkState( argumentIndex == NOT_SET, "Submit first!" ); 
    56                 position = buffer.claim( argumentsCount + 1 );//1 for header 
    57                 checkState( position != INVALID_INDEX, "Can't claim position" ); 
    58                 argumentIndex = 0; 
    59                 return this; 
    6063        } 
    6164 
  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/logger/formatters/SimpleLogMessage.java

    r589 r590  
    1313 */ 
    1414@NotThreadSafe 
    15 public final class SimpleLogMessage implements LogMessage { 
     15public final class SimpleLogMessage extends AbstractLogBuilder implements LogMessage { 
    1616 
    1717        private final String format; 
     
    2020        private final int argumentsCount; 
    2121 
    22         private final AbstractLogBuilder builder; 
    23  
    2422 
    2523        public SimpleLogMessage( final String format, 
     
    2725                                 final int argumentsCount, 
    2826                                 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                 }; 
     27                super( circularBuffer ); 
    4028                this.format = format; 
    4129 
    4230                this.formatId = formatId; 
    4331                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(); 
    6232        } 
    6333 
  • Tests/JAVA/logger/src/main/java/com/db/logger/api/impl/logger/formatters/SimpleLogMessageExpanded.java

    r589 r590  
    11package com.db.logger.api.impl.logger.formatters; 
    22 
     3import com.db.logger.api.FluentLogBuilder; 
    34import com.db.logger.api.LogMessage; 
    4 import com.db.logger.api.FluentLogBuilder; 
    55import com.db.logger.api.impl.logger.CircularBuffer; 
    66import com.db.logger.api.impl.logger.RecordHelper; 
    77 
    8 import static com.db.logger.api.impl.logger.formatters.AbstractLogBuilder.NOT_SET; 
    98import static com.db.logger.api.impl.logger.DemultiplexingSequencer.INVALID_INDEX; 
    109import static com.db.logger.api.impl.logger.RecordHelper.RecordType.LOG_RECORD; 
     10import static com.db.logger.api.impl.logger.formatters.AbstractLogBuilder.NOT_SET; 
    1111import static com.google.common.base.Preconditions.checkState; 
    1212 
     
    1515 *         created 20.11.13 at 23:48 
    1616 */ 
    17 public final class RawLogMessage implements LogMessage, FluentLogBuilder { 
     17public final class SimpleLogMessageExpanded implements LogMessage, FluentLogBuilder { 
    1818 
    1919        private final CircularBuffer buffer; 
     
    2727        private final int argumentsCount; 
    2828 
    29         public RawLogMessage( final String format, 
    30                               final int formatId, 
    31                               final int argumentsCount, 
    32                               final CircularBuffer circularBuffer ) { 
     29        public SimpleLogMessageExpanded( final String format, 
     30                                         final int formatId, 
     31                                         final int argumentsCount, 
     32                                         final CircularBuffer circularBuffer ) { 
    3333                this.buffer = circularBuffer; 
    3434                this.format = format; 
     
    5252        } 
    5353 
    54         public FluentLogBuilder start() { 
    55                 checkState( argumentIndex == NOT_SET, "Submit first!" ); 
    56                 position = buffer.claim( argumentsCount + 1 );//1 for header 
    57                 checkState( position != INVALID_INDEX, "Can't claim position" ); 
    58                 argumentIndex = 0; 
    59                 return this; 
     54        protected void ensureStarted() { 
     55                if( position == INVALID_INDEX ) { 
     56                        position = buffer.claim( argumentsCount() + 1 );//1 for header 
     57                        checkState( position != INVALID_INDEX, "Claim failed" ); 
     58 
     59                        argumentIndex = 0; 
     60                } 
    6061        } 
    6162 
     
    6364        @Override 
    6465        public FluentLogBuilder with( final long value ) { 
    65                 checkState( position != INVALID_INDEX, "Not started" ); 
     66//              ensureStarted(); 
    6667                //              checkState( 
    6768                //                              argumentIndex < argumentsCount(), 
     
    8182        @Override 
    8283        public FluentLogBuilder with( final double value ) { 
     84                ensureStarted(); 
    8385                return with( Double.doubleToLongBits( value ) ); 
    8486        } 
     
    8688        @Override 
    8789        public void log() { 
    88                 checkState( position != INVALID_INDEX, "Not started" ); 
     90//              ensureStarted(); 
    8991                try { 
    9092                        //                      checkState( 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/BufferWriteAndDrainBenchmark.java

    r589 r590  
    9999        @GenerateMicroBenchmark 
    100100        @Group( "writeAndPayloadAndDummyDrain" ) 
    101         @Threads( 3 )//actually it's (CORES-1) 
     101        @GroupThreads( 3 )//actually it's (CORES-1) 
    102102        public void writer( final ThreadState ts ) { 
    103103                writeEntry( ts.id, ts.count ); 
     
    107107        @GenerateMicroBenchmark 
    108108        @Group( "writeAndPayloadAndDummyDrain" ) 
    109         @Threads( 1 ) 
     109        @GroupThreads( 1 ) 
    110110        public void dummyDrainer() { 
    111111                //mostly we do not care about drain latency here, measure just to be aware of it 
     
    123123        @GenerateMicroBenchmark 
    124124        @Group( "writeAndPayloadAndDrainAndRead" ) 
    125         @Threads( 3 ) //actually it's (CORES-1) 
     125        @GroupThreads( 3 ) //actually it's (CORES-1) 
    126126        public void writer2( final ThreadState ts ) { 
    127127                writeEntry( ts.id, ts.count ); 
     
    131131        @GenerateMicroBenchmark 
    132132        @Group( "writeAndPayloadAndDrainAndRead" ) 
    133         @Threads( 1 ) 
     133        @GroupThreads( 1 ) 
    134134        public void readingDrainer() { 
    135135                //mostly we do not care about drain latency here, measure just to be aware of it 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/ConsumingDrainer.java

    r589 r590  
    3636                        final int formatId = formatId( header ); 
    3737                        final int argumentsCount = argumentsCount( header ); 
     38 
     39                        buffer.put( pos, NOT_SET ); 
    3840                        for( int i = 1; i <= argumentsCount; i++ ) { 
    3941                                hole.consume( buffer.get( pos + i ) ); 
    4042                                buffer.put( pos + i, NOT_SET );//needs to reclaim all! 
    4143                        } 
    42                         buffer.put( pos, NOT_SET ); 
     44 
    4345                        pos += argumentsCount; 
    4446                } 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/FastLoggerWithoutWriteBenchmark.java

    r589 r590  
    55import java.util.concurrent.atomic.AtomicInteger; 
    66 
     7import com.db.logger.api.FluentLogBuilder; 
    78import com.db.logger.api.LogMessage; 
    8 import com.db.logger.api.FluentLogBuilder; 
    99import com.db.logger.api.impl.logger.*; 
    1010import com.db.logger.api.impl.logger.buffer.DirectAccessLongBuffer; 
    1111import com.db.logger.api.impl.logger.buffer.ILongsBuffer; 
     12import com.db.logger.api.impl.logger.formatters.DummyLogBuilder; 
    1213import org.apache.log4j.BasicConfigurator; 
    1314import org.apache.log4j.Logger; 
     
    1617 
    1718/** 
    18  * Becnhmark of SimpleFastLogger with dummy writer: just in-memory byte buffer which 
     19 * Benchmark of FastLoggerImpl with dummy writer: just in-memory byte buffer which 
    1920 * is cleared on flush. So, no real IO involved, nut apart from it, all other parts 
    2021 * benchmarked 
     
    2627@OutputTimeUnit( TimeUnit.NANOSECONDS ) 
    2728@State( Scope.Group ) 
    28 public class FastLoggerWithThreadLocalLogMessageBenchmark { 
    29         private static final Logger log = Logger.getLogger( FastLoggerWithThreadLocalLogMessageBenchmark.class ); 
     29public class FastLoggerWithoutWriteBenchmark { 
     30        private static final Logger log = Logger.getLogger( FastLoggerWithoutWriteBenchmark.class ); 
    3031        public static final int LENGTH = Integer.getInteger( "length", 1 << 14 ); 
    3132        public static final int CELLS_PER_RECORD = Integer.getInteger( "cells-per-record", 8 );//8longs = 1 cache line 
     
    4445        public DemultiplexingSequencer sequencer; 
    4546 
    46         public ThreadLocalFastLogger logger; 
     47        public FastLoggerImpl logger; 
    4748 
    4849        @Setup 
     
    5051                buffer = new DirectAccessLongBuffer( LENGTH, RecordHelper.NOT_SET ); 
    5152                sequencer = new DemultiplexingSequencer( LENGTH ); 
    52                 logger = new ThreadLocalFastLogger( 
     53                logger = new FastLoggerImpl( 
    5354                                new ThreadFactory() { 
    5455                                        @Override 
     
    7778        @GenerateMicroBenchmark 
    7879        @Group( "payload" ) 
     80        @GroupThreads( 3 )//to be consistent with others 
    7981        public void payloadAlone() { 
     82                FluentLogBuilder logBuilder = DummyLogBuilder.INSTANCE.with( 5d ); 
     83                final int count = CELLS_PER_RECORD; 
     84                for( int i = 1; i < count; i++ ) { 
     85                        logBuilder = logBuilder.with( ( long ) i ); 
     86                } 
     87                logBuilder.log(); 
     88                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     89        } 
     90 
     91        @GenerateMicroBenchmark 
     92        @Group( "logSimpleAndPayload" ) 
     93        @GroupThreads( 3 ) 
     94        public void writeSimpleMessage( final ThreadStateSimple ts ) { 
     95                if( ts.simpleMessage == null ) { 
     96                        ts.setup( this ); 
     97                } 
     98                FluentLogBuilder logBuilder = ts.simpleMessage.with( 5d ); 
     99                final int count = CELLS_PER_RECORD; 
     100                for( int i = 1; i < count; i++ ) { 
     101                        logBuilder = logBuilder.with( ( long ) i ); 
     102                } 
     103                logBuilder.log(); 
     104 
    80105                BlackHole.consumeCPU( WRITER_BACKOFF ); 
    81106        } 
     
    83108        /*=============================================================================*/ 
    84109        @GenerateMicroBenchmark 
    85         @Group( "loggingAndPayload" ) 
    86         public void writeFormatted( final ThreadState ts ) { 
    87                 if( ts.formatter == null ) { 
     110        @Group( "logTLAndPayload" ) 
     111        @GroupThreads( 3 ) 
     112        public void writeTLMessage( final ThreadStateTL ts ) { 
     113                if( ts.threadLocalMessage == null ) { 
    88114                        ts.setup( this ); 
    89115                } 
    90                 FluentLogBuilder logBuilder = ts.formatter.with( 5d ); 
    91                 final int count = CELLS_PER_RECORD; 
    92                 for( int i = 1; i < count; i++ ) { 
    93                         logBuilder = logBuilder.with( ( long ) i ); 
    94                 } 
    95                 logBuilder.log(); 
    96  
    97                 BlackHole.consumeCPU( WRITER_BACKOFF ); 
    98         } 
     116                FluentLogBuilder logBuilder = ts.threadLocalMessage.with( 5d ); 
     117                final int count = CELLS_PER_RECORD; 
     118                for( int i = 1; i < count; i++ ) { 
     119                        logBuilder = logBuilder.with( ( long ) i ); 
     120                } 
     121                logBuilder.log(); 
     122 
     123                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     124        } 
     125 
     126        /*=============================================================================*/ 
     127        @GenerateMicroBenchmark 
     128        @Group( "logAndPayload" ) 
     129        @GroupThreads( 3 ) 
     130        public void writeMessage( final ThreadState ts ) { 
     131                FluentLogBuilder logBuilder = logger.message( ts.messageFormat ) 
     132                                .with( 5d ); 
     133                final int count = CELLS_PER_RECORD; 
     134                for( int i = 1; i < count; i++ ) { 
     135                        logBuilder = logBuilder.with( ( long ) i ); 
     136                } 
     137                logBuilder.log(); 
     138 
     139                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     140        } 
     141 
     142//      @GenerateMicroBenchmark 
     143//      @Group( "lookupMessageInfo" ) 
     144//      @GroupThreads( 3 ) 
     145//      public Object lookupMessageInfo( final ThreadState ts ) { 
     146//              return logger.lookupMessageInfo( ts.messageFormat ); 
     147//      } 
    99148 
    100149        @State( Scope.Thread ) 
     
    102151                public final int id = ID_GENERATOR.incrementAndGet(); 
    103152 
    104                 public LogMessage formatter; 
    105  
    106                 public void setup( final FastLoggerWithThreadLocalLogMessageBenchmark b ) { 
    107                         formatter = b.logger.message( id + " %d %f %d %f %d %f %f %f" ); 
     153                public final String messageFormat; 
     154 
     155                public ThreadState() { 
     156                        final StringBuilder sb = new StringBuilder(); 
     157                        sb.append( id ); 
     158                        for( int i = 0; i < CELLS_PER_RECORD; i++ ) { 
     159                                sb.append( " %d" ); 
     160                        } 
     161                        messageFormat = sb.toString(); 
     162                } 
     163        } 
     164 
     165        @State( Scope.Thread ) 
     166        public static class ThreadStateSimple extends ThreadState { 
     167 
     168                public LogMessage simpleMessage; 
     169 
     170                public void setup( final FastLoggerWithoutWriteBenchmark b ) { 
     171                        simpleMessage = b.logger.messageSimple( messageFormat ); 
     172                } 
     173        } 
     174 
     175        @State( Scope.Thread ) 
     176        public static class ThreadStateTL extends ThreadState { 
     177 
     178                public LogMessage threadLocalMessage; 
     179 
     180                public void setup( final FastLoggerWithoutWriteBenchmark b ) { 
     181                        threadLocalMessage = b.logger.messageThreadLocal( messageFormat ); 
    108182                } 
    109183        } 
    110184 
    111185        public static void main( final String[] args ) throws Exception { 
    112                 final FastLoggerWithThreadLocalLogMessageBenchmark benchmark = new FastLoggerWithThreadLocalLogMessageBenchmark(); 
    113  
    114                 benchmark.setup(); 
    115                 final int BATCH = 1000000; 
    116                 final ThreadState[] states = new ThreadState[3]; 
    117                 for( int i = 0; i < states.length; i++ ) { 
    118                         final ThreadState state = new ThreadState(); 
    119                         states[i] = state; 
    120                         final Thread thread = new Thread() { 
    121                                 @Override 
    122                                 public void run() { 
    123                                         for( int turn = 0; ; turn += BATCH ) { 
    124                                                 for( int i = 0; i < BATCH; i++ ) { 
    125                                                         benchmark.writeFormatted( state ); 
    126                                                 } 
    127                                                 log.info( "Thread " + state.id + ": " + turn ); 
    128                                         } 
    129                                 } 
    130                         }; 
    131                         thread.setDaemon( true ); 
    132                         thread.start(); 
    133                 } 
    134  
    135                 Thread.sleep( 30000 ); 
    136                 benchmark.tearDown(); 
     186//              final FastLoggerWithoutWriteBenchmark benchmark = new FastLoggerWithoutWriteBenchmark(); 
     187// 
     188//              benchmark.setup(); 
     189//              final int BATCH = 1000000; 
     190//              final ThreadStateSimple[] states = new ThreadStateSimple[3]; 
     191//              for( int i = 0; i < states.length; i++ ) { 
     192//                      final ThreadStateSimple state = new ThreadStateSimple(); 
     193//                      states[i] = state; 
     194//                      final Thread thread = new Thread() { 
     195//                              @Override 
     196//                              public void run() { 
     197//                                      for( int turn = 0; ; turn += BATCH ) { 
     198//                                              for( int i = 0; i < BATCH; i++ ) { 
     199//                                                      benchmark.writeFormatted( state ); 
     200//                                              } 
     201//                                              log.info( "Thread " + state.id + ": " + turn ); 
     202//                                      } 
     203//                              } 
     204//                      }; 
     205//                      thread.setDaemon( true ); 
     206//                      thread.start(); 
     207//              } 
     208// 
     209//              Thread.sleep( 30000 ); 
     210//              benchmark.tearDown(); 
    137211        } 
    138212 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/Log4j20Benchmark.java

    r589 r590  
    6767        @GenerateMicroBenchmark 
    6868        @Group( "formatAndRead" ) 
    69         @Threads( 3 ) //actually it's (CORES-1) 
     69        @GroupThreads( 3 ) //actually it's (CORES-1) 
    7070        public void writeFormatted( final ThreadState ts ) { 
    7171                if( ts.logger == null ) { 
     
    8686        @GenerateMicroBenchmark 
    8787        @Group( "formatAndRead" ) 
    88         @Threads( 1 ) 
     88        @GroupThreads( 1 ) 
    8989        public void readingDrainer() { 
    9090                try { 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/RawLogMessageWriteAndDrainBenchmark.java

    r589 r590  
    6767        @GenerateMicroBenchmark 
    6868        @Group( "formatAndReadAndPayload" ) 
    69         @Threads( 3 ) //actually it's (CORES-1) 
     69        @GroupThreads( 3 ) //actually it's (CORES-1) 
    7070        public void writeFormatted( final ThreadState ts ) { 
    7171                if( ts.formatter == null ) { 
     
    8585        @GenerateMicroBenchmark 
    8686        @Group( "formatAndReadAndPayload" ) 
    87         @Threads( 1 ) 
     87        @GroupThreads( 1 ) 
    8888        public void readingDrainer() { 
    8989                try { 
     
    103103                public void setup( final RawLogMessageWriteAndDrainBenchmark b ) { 
    104104                        formatter = new RawLogMessage( 
    105                                         "", 
    106                                         id, 
    107                                         CELLS_PER_RECORD - 1, 
    108105                                        new CircularBuffer( b.sequencer, b.buffer, WAITING_STRATEGY ) 
     106                        ).setup( 
     107                                        new MessageInfo( 
     108                                                        "", 
     109                                                        id, 
     110                                                        CELLS_PER_RECORD - 1 
     111                                        ) 
    109112                        ); 
    110113                } 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/SimpleLogMessageWriteAndDrainBenchmark.java

    r589 r590  
    99import com.db.logger.api.impl.logger.buffer.ILongsBuffer; 
    1010import com.db.logger.api.impl.logger.formatters.SimpleLogMessage; 
     11import com.db.logger.api.impl.logger.formatters.SimpleLogMessageExpanded; 
    1112import org.openjdk.jmh.annotations.*; 
    1213import org.openjdk.jmh.logic.BlackHole; 
     
    6768        @GenerateMicroBenchmark 
    6869        @Group( "formatAndReadAndPayload" ) 
    69         @Threads( 3 ) //actually it's (CORES-1) 
     70        @GroupThreads( 3 ) //actually it's (CORES-1) 
    7071        public void writeFormatted( final ThreadState ts ) { 
    7172                if( ts.formatter == null ) { 
     
    8485        @GenerateMicroBenchmark 
    8586        @Group( "formatAndReadAndPayload" ) 
    86         @Threads( 1 ) 
     87        @GroupThreads( 1 ) 
    8788        public void readingDrainer() { 
    8889                try { 
    8990                        sequencer.drainTo( readingConsumer ); 
    90 //                      BlackHole.consumeCPU( 100 ); 
     91//                      BlackHole.consumeCPU( 20 ); 
    9192                } catch( Throwable e ) { 
    9293                        e.printStackTrace(); 
     
    9899                public final int id = ID_GENERATOR.incrementAndGet(); 
    99100 
    100                 public SimpleLogMessage formatter; 
     101                public SimpleLogMessageExpanded formatter; 
    101102 
    102103                public void setup( final SimpleLogMessageWriteAndDrainBenchmark b ) { 
    103                         formatter = new SimpleLogMessage( 
     104                        formatter = new SimpleLogMessageExpanded( 
    104105                                        "", 
    105106                                        id, 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/helpers/AtomicBenchmark.java

    r589 r590  
    2020                System.err.println( "payload=" + WRITER_BACKOFF ); 
    2121        } 
     22 
    2223        //TODO use Unsafe for paiding 
    2324        public AtomicInteger counter; 
     
    4849        @GenerateMicroBenchmark 
    4950        @Group( "writeAlone" ) 
    50         @Threads( 1 ) 
     51        @GroupThreads( 1 ) 
    5152        public long writerSolo() { 
    52                 //Nl reason to backoff since no contention in solo 
    53 //              BlackHole.consumeCPU( WRITER_BACKOFF ); 
     53                BlackHole.consumeCPU( WRITER_BACKOFF ); 
    5454                return counter.incrementAndGet(); 
    5555        } 
     
    5858        @GenerateMicroBenchmark 
    5959        @Group( "write4AndPayload" ) 
    60         @Threads( 4 )//actually it's (CORES) 
     60        @GroupThreads( 4 )//actually it's (CORES) 
    6161        public long writer4() { 
    6262                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     
    6767        @GenerateMicroBenchmark 
    6868        @Group( "write3Read1AndPayload" ) 
    69         @Threads( 3 )//actually it's (CORES-1) 
     69        @GroupThreads( 3 )//actually it's (CORES-1) 
    7070        public long writer3() { 
    7171                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     
    7575        @GenerateMicroBenchmark 
    7676        @Group( "write3Read1AndPayload" ) 
    77         @Threads( 1 ) 
     77        @GroupThreads( 1 ) 
    7878        public long reader1() { 
    7979                return counter.get(); 
     
    8484        @GenerateMicroBenchmark 
    8585        @Group( "write2Read2AndPayload" ) 
    86         @Threads( 2 ) 
     86        @GroupThreads( 2 ) 
    8787        public long writer2() { 
    8888                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     
    9292        @GenerateMicroBenchmark 
    9393        @Group( "write2Read2AndPayload" ) 
    94         @Threads( 2 ) 
     94        @GroupThreads( 2 ) 
    9595        public long reader2() { 
    9696                return counter.get(); 
     
    100100        @GenerateMicroBenchmark 
    101101        @Group( "write1Read3AndPayload" ) 
    102         @Threads( 1 ) 
     102        @GroupThreads( 1 ) 
    103103        public long writer1() { 
    104104                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     
    108108        @GenerateMicroBenchmark 
    109109        @Group( "write1Read3AndPayload" ) 
    110         @Threads( 3 ) 
     110        @GroupThreads( 3 ) 
    111111        public long reader3() { 
    112112                return counter.get(); 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/helpers/IOBenchmark.java

    r589 r590  
    2424@OutputTimeUnit( TimeUnit.MICROSECONDS ) 
    2525@State( Scope.Benchmark ) 
     26@Threads( 1 ) 
    2627public class IOBenchmark { 
    2728 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/helpers/SequencerBenchmark.java

    r589 r590  
    7474        @GenerateMicroBenchmark 
    7575        @Group( "claim3AndPayloadAndDrain1Dummy" ) 
    76         @Threads( 3 )//actually it's (CORES-1) 
     76        @GroupThreads( 3 )//actually it's (CORES-1) 
    7777        public void claimer( final ThreadState ts ) { 
    7878                claimEntry( ts.id, ts.count ); 
     
    8282        @GenerateMicroBenchmark 
    8383        @Group( "claim3AndPayloadAndDrain1Dummy" ) 
    84         @Threads( 1 ) 
     84        @GroupThreads( 1 ) 
    8585        public void drainer() { 
    8686                try { 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/helpers/ThreadLocalBenchmark.java

    r589 r590  
    1212@BenchmarkMode( { Mode.AverageTime } ) 
    1313@OutputTimeUnit( TimeUnit.NANOSECONDS ) 
    14 @State( Scope.Group ) 
     14@State( Scope.Benchmark ) 
    1515public class ThreadLocalBenchmark { 
    1616//      public static final int WRITER_BACKOFF = Integer.getInteger( "writer-backoff", 0 ); 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/helpers/UnsafeAtomicBenchmark.java

    r589 r590  
    5555        } 
    5656 
    57         /*=============================================================================*/ 
    58         @GenerateMicroBenchmark 
    59         @Group( "payload" ) 
    60         public void backoffAlone() { 
    61                 BlackHole.consumeCPU( WRITER_BACKOFF ); 
    62         } 
    63  
    64         /*=============================================================================*/ 
    65         @GenerateMicroBenchmark 
    66         @Group( "writeAlone" ) 
    67         @Threads( 1 ) 
    68         public long writerSolo() { 
    69                 //Nl reason to backoff since no contention in solo 
    70                 return incrementAndGet(); 
    71         } 
    72  
    7357        public long incrementAndGet() { 
    7458                for(; ; ) { 
     
    8367        /*=============================================================================*/ 
    8468        @GenerateMicroBenchmark 
     69        @Group( "payload" ) 
     70        public void backoffAlone() { 
     71                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     72        } 
     73 
     74        /*=============================================================================*/ 
     75        @GenerateMicroBenchmark 
     76        @Group( "writeAlone" ) 
     77        @GroupThreads( 1 ) 
     78        public long writerSolo() { 
     79                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     80                return incrementAndGet(); 
     81        } 
     82 
     83        /*=============================================================================*/ 
     84        @GenerateMicroBenchmark 
    8585        @Group( "write4AndPayload" ) 
    86         @Threads( 4 )//actually it's (CORES) 
     86        @GroupThreads( 4 )//actually it's (CORES) 
    8787        public long writer4() { 
    8888                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     
    9393        @GenerateMicroBenchmark 
    9494        @Group( "write3Read1AndPayload" ) 
    95         @Threads( 3 )//actually it's (CORES-1) 
     95        @GroupThreads( 3 )//actually it's (CORES-1) 
    9696        public long writer3() { 
    9797                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     
    101101        @GenerateMicroBenchmark 
    102102        @Group( "write3Read1AndPayload" ) 
    103         @Threads( 1 ) 
     103        @GroupThreads( 1 ) 
    104104        public long reader1() { 
    105105                return counter; 
     
    110110        @GenerateMicroBenchmark 
    111111        @Group( "write2Read2AndPayload" ) 
    112         @Threads( 2 ) 
     112        @GroupThreads( 2 ) 
    113113        public long writer2() { 
    114114                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     
    118118        @GenerateMicroBenchmark 
    119119        @Group( "write2Read2AndPayload" ) 
    120         @Threads( 2 ) 
     120        @GroupThreads( 2 ) 
    121121        public long reader2() { 
    122122                return counter; 
     
    126126        @GenerateMicroBenchmark 
    127127        @Group( "write1Read3AndPayload" ) 
    128         @Threads( 1 ) 
     128        @GroupThreads( 1 ) 
    129129        public long writer1() { 
    130130                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     
    134134        @GenerateMicroBenchmark 
    135135        @Group( "write1Read3AndPayload" ) 
    136         @Threads( 3 ) 
     136        @GroupThreads( 3 ) 
    137137        public long reader3() { 
    138138                return counter; 
  • Tests/JAVA/logger/src/main/java/com/db/logger/benchmarks/helpers/VolatileBenchmark.java

    r589 r590  
    4141        @GenerateMicroBenchmark 
    4242        @Group( "writeAlone" ) 
    43         @Threads( 1 ) 
     43        @GroupThreads( 1 ) 
    4444        public void writerSolo() { 
    4545                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     
    5050        @GenerateMicroBenchmark 
    5151        @Group( "write4" ) 
    52         @Threads( 4 )//actually it's (CORES) 
     52        @GroupThreads( 4 )//actually it's (CORES) 
    5353        public void writer4() { 
    5454                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     
    5959        @GenerateMicroBenchmark 
    6060        @Group( "writeRead31" ) 
    61         @Threads( 3 )//actually it's (CORES-1) 
     61        @GroupThreads( 3 )//actually it's (CORES-1) 
    6262        public void writer3() { 
    6363                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     
    6767        @GenerateMicroBenchmark 
    6868        @Group( "writeRead31" ) 
    69         @Threads( 1 ) 
     69        @GroupThreads( 1 ) 
    7070        public long reader1() { 
    7171                return counter; 
     
    7676        @GenerateMicroBenchmark 
    7777        @Group( "writeRead22" ) 
    78         @Threads( 2 ) 
     78        @GroupThreads( 2 ) 
    7979        public void writer2() { 
    8080                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     
    8484        @GenerateMicroBenchmark 
    8585        @Group( "writeRead22" ) 
    86         @Threads( 2 ) 
     86        @GroupThreads( 2 ) 
    8787        public long reader2() { 
    8888                return counter; 
     
    9292        @GenerateMicroBenchmark 
    9393        @Group( "writeRead13" ) 
    94         @Threads( 1 ) 
     94        @GroupThreads( 1 ) 
    9595        public void writer1() { 
    9696                BlackHole.consumeCPU( WRITER_BACKOFF ); 
     
    100100        @GenerateMicroBenchmark 
    101101        @Group( "writeRead13" ) 
    102         @Threads( 3 ) 
     102        @GroupThreads( 3 ) 
    103103        public long reader3() { 
    104104                return counter; 
Note: See TracChangeset for help on using the changeset viewer.