tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/synchronization/TsTransformFastTest.java - tracecompass/org.eclipse.tracecompass - Git at Google

 /*******************************************************************************
  * Copyright (c) 2015 École Polytechnique de Montréal
  *
  * All rights reserved. This program and the accompanying materials are made
  * available under the terms of the Eclipse Public License 2.0 which
  * accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *   Francis Giraldeau - Initial implementation and API
  *   Geneviève Bastien - Fixes and improvements
  *******************************************************************************/

 package org.eclipse.tracecompass.tmf.core.tests.synchronization;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;

 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.util.Arrays;

 import org.eclipse.tracecompass.internal.tmf.core.synchronization.TmfTimestampTransformLinear;
 import org.eclipse.tracecompass.internal.tmf.core.synchronization.TmfTimestampTransformLinearFast;
 import org.eclipse.tracecompass.tmf.core.synchronization.ITmfTimestampTransform;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;

 /**
  * Tests for {@link TmfTimestampTransformLinearFast}
  *
  * @author Geneviève Bastien
  */
 @RunWith(Parameterized.class)
 public class TsTransformFastTest {

     private static final long ts = 1361657893526374091L;

     private static interface IFastTransformFactory {
         public TmfTimestampTransformLinearFast create(double alpha, double beta);
     }

     private static final IFastTransformFactory fNewObject = (a, b) -> {
         return new TmfTimestampTransformLinearFast(a, b);
     };

     private static final IFastTransformFactory fDeserialized = (a, b) -> {
         TmfTimestampTransformLinearFast tt = new TmfTimestampTransformLinearFast(a, b);
         /* Serialize the object */
         String filePath = null;
         try {
             File temp = File.createTempFile("serialSyncAlgo", ".tmp");
             filePath = temp.getAbsolutePath();
         } catch (IOException e) {
             fail("Could not create temporary file for serialization");
         }
         assertNotNull(filePath);

         try (FileOutputStream fileOut = new FileOutputStream(filePath);
                 ObjectOutputStream out = new ObjectOutputStream(fileOut);) {
             out.writeObject(tt);
         } catch (IOException e) {
             fail("Error serializing the synchronization algorithm " + e.getMessage());
         }

         TmfTimestampTransformLinearFast deserialTt = null;
         /* De-Serialize the object */
         try (FileInputStream fileIn = new FileInputStream(filePath);
                 ObjectInputStream in = new ObjectInputStream(fileIn);) {
             deserialTt = (TmfTimestampTransformLinearFast) in.readObject();
         } catch (IOException | ClassNotFoundException e) {
             fail("Error de-serializing the synchronization algorithm " + e.getMessage());
         }
         return deserialTt;
     };

     private final IFastTransformFactory fTransformFactory;

     /**
      * Constructor
      *
      * @param name
      *            The name of this parameterized test
      * @param factory
      *            Factory to create the timestamp transform
      */
     public TsTransformFastTest(String name, IFastTransformFactory factory) {
         fTransformFactory = factory;
     }

     /**
      * @return the test parameters
      */
     @Parameters(name = "Factory={0}")
     public static Iterable<Object[]> parameters() {
         return Arrays.asList(new Object[][] {
                 { "Object", fNewObject },
                 { "Deserialized", fDeserialized }
         });
     }

     /**
      * Test whether the fast linear transform always yields the same value for
      * the same timestamp
      */
     @Test
     public void testFLTRepeatability() {
         TmfTimestampTransformLinearFast fast = fTransformFactory.create(Math.PI, 0);
         // Access fDeltaMax to compute the cache range boundaries
         long deltaMax = fast.getDeltaMax();
         // Initialize the transform
         long timestamp = ts - (ts % deltaMax);
         fast.transform(timestamp);
         long tsMiss = timestamp + deltaMax;
         long tsNoMiss = timestamp + deltaMax - 1;

         // Get the transformed value to a timestamp without cache miss
         long tsTNoMiss = fast.transform(tsNoMiss);
         assertEquals(1, fast.getCacheMisses());

         // Cause a cache miss
         fast.transform(tsMiss);
         assertEquals(2, fast.getCacheMisses());

         /*
          * Get the transformed value of the same previous timestamp after the
          * miss
          */
         long tsTAfterMiss = fast.transform(tsNoMiss);
         assertEquals(tsTNoMiss, tsTAfterMiss);
     }

     /**
      * Test that 2 equal fast transform always give the same results for the
      * same values
      */
     @Test
     public void testFLTEquivalence() {
         TmfTimestampTransformLinearFast fast = fTransformFactory.create(Math.PI, 0);
         TmfTimestampTransformLinearFast fast2 = fTransformFactory.create(Math.PI, 0);

         long deltaMax = fast.getDeltaMax();

         long start = (ts - (ts % deltaMax) - 10);
         checkTime(fast, fast2, 20, start, 1);
     }

     /**
      * Test the precision of the fast timestamp transform compared to the
      * original transform.
      */
     @Test
     public void testFastTransformPrecision() {
         TmfTimestampTransformLinear precise = new TmfTimestampTransformLinear(Math.PI, 0);
         TmfTimestampTransformLinearFast fast = fTransformFactory.create(Math.PI, 0);
         int samples = 100;
         long start = (long) Math.pow(10, 18);
         long end = Long.MAX_VALUE;
         int step = (int) ((end - start) / (samples * Math.PI));
         checkTime(precise, fast, samples, start, step);
         assertEquals(samples, fast.getCacheMisses());

         // check that rescale is done only when required
         // assumes tsBitWidth == 30
         // test forward and backward timestamps
         samples = 1000;
         int[] directions = new int[] { 1, -1 };
         for (Integer direction : directions) {
             for (int i = 0; i <= 30; i++) {
                 fast.resetScaleStats();
                 step = (1 << i) * direction;
                 checkTime(precise, fast, samples, start, step);
                 assertTrue(String.format("samples: %d scale misses: %d",
                         samples, fast.getCacheMisses()), samples >= fast.getCacheMisses());
             }
         }
     }

     /**
      * Test that fast transform produces the same result for small and large
      * slopes.
      */
     @Test
     public void testFastTransformSlope() {
         int[] dir = new int[] { 1, -1 };
         long start = (1 << 30);
         for (int ex = -9; ex <= 9; ex++) {
             for (int d = 0; d < dir.length; d++) {
                 double slope = Math.pow(10.0, ex);
                 TmfTimestampTransformLinear precise = new TmfTimestampTransformLinear(slope, 0);
                 TmfTimestampTransformLinearFast fast = fTransformFactory.create(slope, 0);
                 checkTime(precise, fast, 1000, start, dir[d]);
             }
         }
     }

     /**
      * Test that fast transform produces the same result with a slope and
      * offset, for small and large values
      */
     @Test
     public void testFastTransformSlopeAndOffset() {
         double offset = 54321.0;
         double slope = Math.pow(10.0, 4);
         for (int ex = 0; ex <= Long.SIZE - 1; ex++) {
             long start = 1 << ex;
             TmfTimestampTransformLinear precise = new TmfTimestampTransformLinear(slope, offset);
             TmfTimestampTransformLinearFast fast = fTransformFactory.create(slope, offset);
             checkTime(precise, fast, 5, start, 1);
         }
     }

     /**
      * Check that the proper exception are raised for illegal slopes
      */
     @Test
     public void testFastTransformArguments() {
         double[] slopes = new double[] { -1.0, ((double) Integer.MAX_VALUE) + 1, 1e-10 };
         for (double slope : slopes) {
             Exception exception = null;
             try {
                 fTransformFactory.create(slope, 0.0);
             } catch (IllegalArgumentException e) {
                 exception = e;
             }
             assertNotNull(exception);
         }
     }

     private static void checkTime(ITmfTimestampTransform precise, ITmfTimestampTransform fast,
             int samples, long start, long step) {
         long prev = 0;
         for (int i = 0; i < samples; i++) {
             long time = start + i * step;
             long exp = precise.transform(time);
             long act = fast.transform(time);
             long err = act - exp;
             // allow only two ns of error
             assertTrue("start: " + start + " [" + err + "]", Math.abs(err) < 3);
             if (i > 0) {
                 if (step > 0) {
                     assertTrue("monotonic error" + act + " " + prev, act >= prev);
                 } else if (step < 0) {
                     assertTrue("monotonic ", act <= prev);
                 }
             }
             prev = act;
         }
     }

 }
	/*******************************************************************************
	* Copyright (c) 2015 École Polytechnique de Montréal
	*
	* All rights reserved. This program and the accompanying materials are made
	* available under the terms of the Eclipse Public License 2.0 which
	* accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* Francis Giraldeau - Initial implementation and API
	* Geneviève Bastien - Fixes and improvements
	*******************************************************************************/

	package org.eclipse.tracecompass.tmf.core.tests.synchronization;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertNotNull;
	import static org.junit.Assert.assertTrue;
	import static org.junit.Assert.fail;

	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.ObjectInputStream;
	import java.io.ObjectOutputStream;
	import java.util.Arrays;

	import org.eclipse.tracecompass.internal.tmf.core.synchronization.TmfTimestampTransformLinear;
	import org.eclipse.tracecompass.internal.tmf.core.synchronization.TmfTimestampTransformLinearFast;
	import org.eclipse.tracecompass.tmf.core.synchronization.ITmfTimestampTransform;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.junit.runners.Parameterized;
	import org.junit.runners.Parameterized.Parameters;

	/**
	* Tests for {@link TmfTimestampTransformLinearFast}
	*
	* @author Geneviève Bastien
	*/
	@RunWith(Parameterized.class)
	public class TsTransformFastTest {

	private static final long ts = 1361657893526374091L;

	private static interface IFastTransformFactory {
	public TmfTimestampTransformLinearFast create(double alpha, double beta);
	}

	private static final IFastTransformFactory fNewObject = (a, b) -> {
	return new TmfTimestampTransformLinearFast(a, b);
	};

	private static final IFastTransformFactory fDeserialized = (a, b) -> {
	TmfTimestampTransformLinearFast tt = new TmfTimestampTransformLinearFast(a, b);
	/* Serialize the object */
	String filePath = null;
	try {
	File temp = File.createTempFile("serialSyncAlgo", ".tmp");
	filePath = temp.getAbsolutePath();
	} catch (IOException e) {
	fail("Could not create temporary file for serialization");
	}
	assertNotNull(filePath);

	try (FileOutputStream fileOut = new FileOutputStream(filePath);
	ObjectOutputStream out = new ObjectOutputStream(fileOut);) {
	out.writeObject(tt);
	} catch (IOException e) {
	fail("Error serializing the synchronization algorithm " + e.getMessage());
	}

	TmfTimestampTransformLinearFast deserialTt = null;
	/* De-Serialize the object */
	try (FileInputStream fileIn = new FileInputStream(filePath);
	ObjectInputStream in = new ObjectInputStream(fileIn);) {
	deserialTt = (TmfTimestampTransformLinearFast) in.readObject();
	} catch (IOException \| ClassNotFoundException e) {
	fail("Error de-serializing the synchronization algorithm " + e.getMessage());
	}
	return deserialTt;
	};

	private final IFastTransformFactory fTransformFactory;

	/**
	* Constructor
	*
	* @param name
	* The name of this parameterized test
	* @param factory
	* Factory to create the timestamp transform
	*/
	public TsTransformFastTest(String name, IFastTransformFactory factory) {
	fTransformFactory = factory;
	}

	/**
	* @return the test parameters
	*/
	@Parameters(name = "Factory={0}")
	public static Iterable<Object[]> parameters() {
	return Arrays.asList(new Object[][] {
	{ "Object", fNewObject },
	{ "Deserialized", fDeserialized }
	});
	}

	/**
	* Test whether the fast linear transform always yields the same value for
	* the same timestamp
	*/
	@Test
	public void testFLTRepeatability() {
	TmfTimestampTransformLinearFast fast = fTransformFactory.create(Math.PI, 0);
	// Access fDeltaMax to compute the cache range boundaries
	long deltaMax = fast.getDeltaMax();
	// Initialize the transform
	long timestamp = ts - (ts % deltaMax);
	fast.transform(timestamp);
	long tsMiss = timestamp + deltaMax;
	long tsNoMiss = timestamp + deltaMax - 1;

	// Get the transformed value to a timestamp without cache miss
	long tsTNoMiss = fast.transform(tsNoMiss);
	assertEquals(1, fast.getCacheMisses());

	// Cause a cache miss
	fast.transform(tsMiss);
	assertEquals(2, fast.getCacheMisses());

	/*
	* Get the transformed value of the same previous timestamp after the
	* miss
	*/
	long tsTAfterMiss = fast.transform(tsNoMiss);
	assertEquals(tsTNoMiss, tsTAfterMiss);
	}

	/**
	* Test that 2 equal fast transform always give the same results for the
	* same values
	*/
	@Test
	public void testFLTEquivalence() {
	TmfTimestampTransformLinearFast fast = fTransformFactory.create(Math.PI, 0);
	TmfTimestampTransformLinearFast fast2 = fTransformFactory.create(Math.PI, 0);

	long deltaMax = fast.getDeltaMax();

	long start = (ts - (ts % deltaMax) - 10);
	checkTime(fast, fast2, 20, start, 1);
	}

	/**
	* Test the precision of the fast timestamp transform compared to the
	* original transform.
	*/
	@Test
	public void testFastTransformPrecision() {
	TmfTimestampTransformLinear precise = new TmfTimestampTransformLinear(Math.PI, 0);
	TmfTimestampTransformLinearFast fast = fTransformFactory.create(Math.PI, 0);
	int samples = 100;
	long start = (long) Math.pow(10, 18);
	long end = Long.MAX_VALUE;
	int step = (int) ((end - start) / (samples * Math.PI));
	checkTime(precise, fast, samples, start, step);
	assertEquals(samples, fast.getCacheMisses());

	// check that rescale is done only when required
	// assumes tsBitWidth == 30
	// test forward and backward timestamps
	samples = 1000;
	int[] directions = new int[] { 1, -1 };
	for (Integer direction : directions) {
	for (int i = 0; i <= 30; i++) {
	fast.resetScaleStats();
	step = (1 << i) * direction;
	checkTime(precise, fast, samples, start, step);
	assertTrue(String.format("samples: %d scale misses: %d",
	samples, fast.getCacheMisses()), samples >= fast.getCacheMisses());
	}
	}
	}

	/**
	* Test that fast transform produces the same result for small and large
	* slopes.
	*/
	@Test
	public void testFastTransformSlope() {
	int[] dir = new int[] { 1, -1 };
	long start = (1 << 30);
	for (int ex = -9; ex <= 9; ex++) {
	for (int d = 0; d < dir.length; d++) {
	double slope = Math.pow(10.0, ex);
	TmfTimestampTransformLinear precise = new TmfTimestampTransformLinear(slope, 0);
	TmfTimestampTransformLinearFast fast = fTransformFactory.create(slope, 0);
	checkTime(precise, fast, 1000, start, dir[d]);
	}
	}
	}

	/**
	* Test that fast transform produces the same result with a slope and
	* offset, for small and large values
	*/
	@Test
	public void testFastTransformSlopeAndOffset() {
	double offset = 54321.0;
	double slope = Math.pow(10.0, 4);
	for (int ex = 0; ex <= Long.SIZE - 1; ex++) {
	long start = 1 << ex;
	TmfTimestampTransformLinear precise = new TmfTimestampTransformLinear(slope, offset);
	TmfTimestampTransformLinearFast fast = fTransformFactory.create(slope, offset);
	checkTime(precise, fast, 5, start, 1);
	}
	}

	/**
	* Check that the proper exception are raised for illegal slopes
	*/
	@Test
	public void testFastTransformArguments() {
	double[] slopes = new double[] { -1.0, ((double) Integer.MAX_VALUE) + 1, 1e-10 };
	for (double slope : slopes) {
	Exception exception = null;
	try {
	fTransformFactory.create(slope, 0.0);
	} catch (IllegalArgumentException e) {
	exception = e;
	}
	assertNotNull(exception);
	}
	}

	private static void checkTime(ITmfTimestampTransform precise, ITmfTimestampTransform fast,
	int samples, long start, long step) {
	long prev = 0;
	for (int i = 0; i < samples; i++) {
	long time = start + i * step;
	long exp = precise.transform(time);
	long act = fast.transform(time);
	long err = act - exp;
	// allow only two ns of error
	assertTrue("start: " + start + " [" + err + "]", Math.abs(err) < 3);
	if (i > 0) {
	if (step > 0) {
	assertTrue("monotonic error" + act + " " + prev, act >= prev);
	} else if (step < 0) {
	assertTrue("monotonic ", act <= prev);
	}
	}
	prev = act;
	}
	}

	}