- added a BogoPerf based test
diff --git a/slf4j-api/src/test/java/org/slf4j/helpers/BogoPerf.java b/slf4j-api/src/test/java/org/slf4j/helpers/BogoPerf.java
new file mode 100644
index 0000000..e5c3407
--- /dev/null
+++ b/slf4j-api/src/test/java/org/slf4j/helpers/BogoPerf.java
@@ -0,0 +1,127 @@
+package org.slf4j.helpers;
+
+import java.util.Arrays;
+import java.util.Random;
+
+import junit.framework.AssertionFailedError;
+
+public class BogoPerf {
+
+ private static long NANOS_IN_ONE_SECOND = 1000 * 1000 * 1000;
+ private static int INITIAL_N = 1000;
+ private static int LAST_N = 100;
+ private static int SLACK_FACTOR = 2;
+
+ static {
+ // let the JIT warm up
+ computeBogoIPS(INITIAL_N);
+ double bogo_ips = computeBogoIPS(INITIAL_N);
+ System.out.println("Host runs at "+bogo_ips + " BIPS");
+ }
+
+
+ /**
+ * Compute bogoInstructions per second
+ * <p>
+ * on a 3.2 Ghz Pentium D CPU (around 2007), we obtain about 10'000 bogoIPS.
+ *
+ * @param N
+ * number of bogoInstructions to average over in order to
+ * compute the result
+ * @return bogo Instructions Per Second
+ */
+ private static double computeBogoIPS(int N) {
+ long begin = System.nanoTime();
+
+ for (int i = 0; i < N; i++) {
+ bogoInstruction();
+ }
+ long end = System.nanoTime();
+
+ // duration
+ double D = end - begin;
+ // average duration per instruction
+ double avgDPIS = D / N;
+ // System.out.println(D + " nanos for " + N + " instructions");
+ // System.out.println(avgD + " nanos per instruction");
+
+ double bogoIPS = NANOS_IN_ONE_SECOND / avgDPIS;
+ // System.out.println(bogoIPS + " bogoIPS");
+
+ return bogoIPS;
+ }
+
+ private static void bogoInstruction() {
+ Random random = new Random(100);
+ int len = 500;
+ int[] intArray = new int[len];
+ for (int i = 0; i < len; i++) {
+ intArray[i] = random.nextInt();
+ }
+ Arrays.sort(intArray);
+ }
+
+ /**
+ * Computed the BogoIPS for this host CPU.
+ *
+ * @return
+ */
+ public static double currentBIPS() {
+ return computeBogoIPS(LAST_N);
+ }
+
+ static double min(double a, double b) {
+ return (a <= b) ? a : b;
+ }
+
+ /**
+ * Assertion used for values that <b>decrease</b> with faster CPUs,
+ * typically the time (duration) needed to perform a task.
+ *
+ * @param currentDuration
+ * @param referenceDuraion
+ * @param referenceBIPS
+ * @throws AssertionFailedError
+ */
+ public static void assertDuration(double currentDuration,
+ long referenceDuraion, double referenceBIPS)
+ throws AssertionFailedError {
+ double ajustedDuration = adjustExpectedDuration(referenceDuraion,
+ referenceBIPS);
+ if (currentDuration > ajustedDuration * SLACK_FACTOR) {
+ throw new AssertionFailedError(currentDuration + " exceeded expected "
+ + ajustedDuration + " (adjusted), " + referenceDuraion + " (raw)");
+ }
+ }
+ /**
+ * Assertion used for values that <b>increase<b> with faster CPUs, typically
+ * the number of operations accomplished per unit of time.
+ *
+ * @param currentPerformance
+ * @param referencePerformance
+ * @param referenceBIPS
+ * @throws AssertionFailedError
+ */
+ public static void assertPerformance(double currentPerformance,
+ long referencePerformance, double referenceBIPS)
+ throws AssertionFailedError {
+ double ajustedPerf = adjustExpectedPerformance(referencePerformance,
+ referenceBIPS);
+ if (currentPerformance*SLACK_FACTOR < ajustedPerf) {
+ throw new AssertionFailedError(currentPerformance + " below expected "
+ + ajustedPerf + " (adjusted), " + referencePerformance + " (raw)");
+ }
+ }
+
+ private static double adjustExpectedPerformance(long referenceDuration,
+ double referenceBIPS) {
+ double currentBIPS = currentBIPS();
+ return referenceDuration * (currentBIPS/referenceBIPS);
+ }
+
+ private static double adjustExpectedDuration(long referenceDuration,
+ double referenceBIPS) {
+ double currentBIPS = currentBIPS();
+ return referenceDuration * (referenceBIPS / currentBIPS);
+ }
+}
diff --git a/slf4j-api/src/test/java/org/slf4j/helpers/MessageFormatterPerfTest.java b/slf4j-api/src/test/java/org/slf4j/helpers/MessageFormatterPerfTest.java
new file mode 100644
index 0000000..a059329
--- /dev/null
+++ b/slf4j-api/src/test/java/org/slf4j/helpers/MessageFormatterPerfTest.java
@@ -0,0 +1,59 @@
+package org.slf4j.helpers;
+
+import java.text.MessageFormat;
+
+import junit.framework.TestCase;
+
+public class MessageFormatterPerfTest extends TestCase {
+
+ Integer i1 = new Integer(1);
+ static long RUN_LENGTH = 100000;
+ static long REFERENCE_BIPS = 9629;
+
+ public MessageFormatterPerfTest(String name) {
+ super(name);
+ }
+
+ protected void setUp() throws Exception {
+ }
+
+ protected void tearDown() throws Exception {
+ }
+
+ public void XtestJDKFormatterPerf() {
+ jdkMessageFormatter(RUN_LENGTH);
+ double avg = jdkMessageFormatter(RUN_LENGTH);
+ System.out.println("jdk avg = "+avg+" nanos");
+ }
+
+ public void testSLF4JPerf() {
+ slf4jMessageFormatter(RUN_LENGTH);
+ double avgDuration = slf4jMessageFormatter(RUN_LENGTH);
+
+ long referencePerf = 1700;
+ BogoPerf.assertDuration(avgDuration, referencePerf, REFERENCE_BIPS);
+ }
+
+ public double slf4jMessageFormatter(long len) {
+ String s = "";
+ s += ""; // keep compiler happy
+ long start = System.nanoTime();
+ for (int i = 0; i < len; i++) {
+ s = MessageFormatter.format("This is some rather short message {} ", i1);
+ }
+ long end = System.nanoTime();
+ return (1.0*end - start) / len;
+ }
+ public double jdkMessageFormatter(long len) {
+ String s = "";
+ s += ""; // keep compiler happy
+ long start = System.nanoTime();
+ Object[] oa = new Object[] {i1};
+ for (int i = 0; i < len; i++) {
+ s = MessageFormat.format("This is some rather short message {0}", oa);
+ }
+ long end = System.nanoTime();
+ return (1.0*end - start) / len;
+ }
+
+}
