tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderWeightedTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2013, 2015 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are made
   5  * available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *     Patrick Tasse - Updates to mipmap feature
  11  *******************************************************************************/
  12
  13 package org.eclipse.tracecompass.tmf.core.tests.statesystem.mipmap;
  14
  15 import static org.junit.Assert.assertEquals;
  16 import static org.junit.Assert.assertNotNull;
  17 import static org.junit.Assert.fail;
  18
  19 import org.eclipse.jdt.annotation.NonNull;
  20 import org.eclipse.tracecompass.internal.tmf.core.statesystem.mipmap.TmfStateSystemOperations;
  21 import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder;
  22 import org.eclipse.tracecompass.statesystem.core.StateSystemFactory;
  23 import org.eclipse.tracecompass.statesystem.core.backend.IStateHistoryBackend;
  24 import org.eclipse.tracecompass.statesystem.core.backend.StateHistoryBackendFactory;
  25 import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException;
  26 import org.eclipse.tracecompass.statesystem.core.exceptions.StateValueTypeException;
  27 import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException;
  28 import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue.Type;
  29 import org.eclipse.tracecompass.statesystem.core.statevalue.TmfStateValue;
  30 import org.junit.BeforeClass;
  31 import org.junit.Test;
  32
  33 /**
  34  * @author Patrick Tasse
  35  *
  36  */
  37 public class TmfMipmapStateProviderWeightedTest {
  38
  39     @NonNull private static final String SSID = "mipmap-test";
  40     private static final String TEST_ATTRIBUTE_NAME = TmfMipmapStateProviderStub.TEST_ATTRIBUTE_NAME;
  41     private static final long END_TIME = 250000L;
  42     private static final long INTERVAL = 1000L;
  43     private static final int RESOLUTION = 2;
  44     private static final double DELTA = 0.0001;
  45     private static ITmfStateSystemBuilder ssqi;
  46     private static ITmfStateSystemBuilder ssqd;
  47
  48     /**
  49      * Startup code, build a state system with uneven state durations
  50      */
  51     @BeforeClass
  52     public static void init() {
  53         /* setup for INTEGER test */
  54         TmfMipmapStateProviderStub mmpi = new TmfMipmapStateProviderStub(RESOLUTION, Type.INTEGER);
  55         IStateHistoryBackend bei = StateHistoryBackendFactory.createInMemoryBackend(SSID, 0);
  56         ITmfStateSystemBuilder ssbi = StateSystemFactory.newStateSystem(bei);
  57         mmpi.assignTargetStateSystem(ssbi);
  58         ssqi = ssbi;
  59         /* setup for DOUBLE test */
  60         TmfMipmapStateProviderStub mmpd = new TmfMipmapStateProviderStub(RESOLUTION, Type.DOUBLE);
  61         IStateHistoryBackend bed = StateHistoryBackendFactory.createInMemoryBackend(SSID, 0);
  62         ITmfStateSystemBuilder ssbd = StateSystemFactory.newStateSystem(bed);
  63         mmpd.assignTargetStateSystem(ssbd);
  64         ssqd = ssbd;
  65         /*
  66          * Every 10,000 ns chunk contains the following states:
  67          *
  68          * | null |  10  | null |      20     | null |        30          | null |
  69          * 0     1000   2000   3000   4000   5000   6000   7000   8000   9000  10,000
  70          *
  71          * The weighted average for a chunk is (1 x 10 + 2 x 20 + 3 x 30) / 10 = 14.
  72          */
  73         for (int i = 0; i < END_TIME / INTERVAL / 10; i++) {
  74             long time = i * 10 * INTERVAL;
  75             /* update for INTEGER test */
  76             mmpi.processEvent(mmpi.createEvent(time, null));
  77             mmpi.processEvent(mmpi.createEvent(time + 1000, 10L));
  78             mmpi.processEvent(mmpi.createEvent(time + 2000, null));
  79             mmpi.processEvent(mmpi.createEvent(time + 3000, 20L));
  80             mmpi.processEvent(mmpi.createEvent(time + 5000, null));
  81             mmpi.processEvent(mmpi.createEvent(time + 6000, 30L));
  82             mmpi.processEvent(mmpi.createEvent(time + 9000, null));
  83             /* update for DOUBLE test */
  84             mmpd.processEvent(mmpd.createEvent(time, null));
  85             mmpd.processEvent(mmpd.createEvent(time + 1000, 10L));
  86             mmpd.processEvent(mmpd.createEvent(time + 2000, null));
  87             mmpd.processEvent(mmpd.createEvent(time + 3000, 20L));
  88             mmpd.processEvent(mmpd.createEvent(time + 5000, null));
  89             mmpd.processEvent(mmpd.createEvent(time + 6000, 30L));
  90             mmpd.processEvent(mmpd.createEvent(time + 9000, null));
  91         }
  92         /* cleanup for INTEGER test */
  93         mmpi.processEvent(mmpi.createEvent(END_TIME, 0L));
  94         mmpi.dispose();
  95         ssqi.waitUntilBuilt();
  96         /* cleanup for DOUBLE test */
  97         mmpd.processEvent(mmpd.createEvent(END_TIME, 0L));
  98         mmpd.dispose();
  99         ssqd.waitUntilBuilt();
 100     }
 101
 102     /**
 103      * Test a query range to the state system to get the maximum value in the
 104      * range. The test values are INTEGER.
 105      */
 106     @Test
 107     public void testQueryMipmapRangeMaxInteger() {
 108         assertNotNull(ssqi);
 109         try {
 110             int quark = ssqi.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 111             assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMax(ssqi, 0, 0, quark));
 112             assertEquals(10, TmfStateSystemOperations.queryRangeMax(ssqi, 500, 1500, quark).unboxInt());
 113             assertEquals(20, TmfStateSystemOperations.queryRangeMax(ssqi, 1500, 5000, quark).unboxInt());
 114             assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 5000, 10000, quark).unboxInt());
 115             assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 0, 10000, quark).unboxInt());
 116             assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMax(ssqi, 120000, 120000, quark));
 117             assertEquals(10, TmfStateSystemOperations.queryRangeMax(ssqi, 120500, 121500, quark).unboxInt());
 118             assertEquals(20, TmfStateSystemOperations.queryRangeMax(ssqi, 121500, 125000, quark).unboxInt());
 119             assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 125000, 130000, quark).unboxInt());
 120             assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 120000, 130000, quark).unboxInt());
 121             assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 100000, 150000, quark).unboxInt());
 122             assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 240000, 250000, quark).unboxInt());
 123             assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 0, 250000, quark).unboxInt());
 124             assertEquals(00, TmfStateSystemOperations.queryRangeMax(ssqi, 250000, 250000, quark).unboxInt());
 125
 126         } catch (AttributeNotFoundException e) {
 127             fail(e.getMessage());
 128         } catch (StateValueTypeException e) {
 129             fail(e.getMessage());
 130         } catch (TimeRangeException e) {
 131             fail(e.getMessage());
 132         }
 133     }
 134
 135     /**
 136      * Test a query range to the state system to get the minimum value in the
 137      * range. The test values are INTEGER.
 138      */
 139     @Test
 140     public void testQueryMipmapRangeMinInteger() {
 141         assertNotNull(ssqi);
 142         try {
 143             int quark = ssqi.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 144             assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMin(ssqi, 0, 0, quark));
 145             assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 500, 1500, quark).unboxInt());
 146             assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 1500, 5000, quark).unboxInt());
 147             assertEquals(30, TmfStateSystemOperations.queryRangeMin(ssqi, 5000, 10000, quark).unboxInt());
 148             assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 0, 10000, quark).unboxInt());
 149             assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMin(ssqi, 120000, 120000, quark));
 150             assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 120500, 121500, quark).unboxInt());
 151             assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 121500, 125000, quark).unboxInt());
 152             assertEquals(30, TmfStateSystemOperations.queryRangeMin(ssqi, 125000, 130000, quark).unboxInt());
 153             assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 120000, 130000, quark).unboxInt());
 154             assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 100000, 150000, quark).unboxInt());
 155             assertEquals(00, TmfStateSystemOperations.queryRangeMin(ssqi, 240000, 250000, quark).unboxInt());
 156             assertEquals(00, TmfStateSystemOperations.queryRangeMin(ssqi, 0, 250000, quark).unboxInt());
 157             assertEquals(00, TmfStateSystemOperations.queryRangeMin(ssqi, 250000, 250000, quark).unboxInt());
 158
 159         } catch (AttributeNotFoundException e) {
 160             fail(e.getMessage());
 161         } catch (StateValueTypeException e) {
 162             fail(e.getMessage());
 163         } catch (TimeRangeException e) {
 164             fail(e.getMessage());
 165         }
 166     }
 167
 168     /**
 169      * Test a query range to the state system to get the average value in the
 170      * range. The test values are INTEGER.
 171      */
 172     @Test
 173     public void testQueryMipmapRangeAvgInteger() {
 174         assertNotNull(ssqi);
 175         try {
 176             int quark = ssqi.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 177             assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 0, 0, quark), DELTA);
 178             assertEquals(5.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 500, 1500, quark), DELTA);
 179             assertEquals(90.0 / 7, TmfStateSystemOperations.queryRangeAverage(ssqi, 1500, 5000, quark), DELTA);
 180             assertEquals(90.0 / 5, TmfStateSystemOperations.queryRangeAverage(ssqi, 5000, 10000, quark), DELTA);
 181             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 0, 10000, quark), DELTA);
 182             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 0, 20000, quark), DELTA);
 183             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 500, 20500, quark), DELTA);
 184             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 1000, 21000, quark), DELTA);
 185             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 2000, 22000, quark), DELTA);
 186             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 3000, 23000, quark), DELTA);
 187             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 4000, 24000, quark), DELTA);
 188             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 5000, 25000, quark), DELTA);
 189             assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 120000, 120000, quark), DELTA);
 190             assertEquals(5.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 120500, 121500, quark), DELTA);
 191             assertEquals(90.0 / 7, TmfStateSystemOperations.queryRangeAverage(ssqi, 121500, 125000, quark), DELTA);
 192             assertEquals(90.0 / 5, TmfStateSystemOperations.queryRangeAverage(ssqi, 125000, 130000, quark), DELTA);
 193             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 120000, 130000, quark), DELTA);
 194             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 100000, 150000, quark), DELTA);
 195             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 240000, 250000, quark), DELTA);
 196             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 0, 250000, quark), DELTA);
 197             assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 250000, 250000, quark), DELTA);
 198
 199         } catch (AttributeNotFoundException e) {
 200             fail(e.getMessage());
 201         } catch (TimeRangeException e) {
 202             fail(e.getMessage());
 203         } catch (StateValueTypeException e) {
 204             fail(e.getMessage());
 205         }
 206     }
 207
 208     /**
 209      * Test a query range to the state system to get the maximum value in the
 210      * range. The test values are DOUBLE.
 211      */
 212     @Test
 213     public void testQueryMipmapRangeMaxDouble() {
 214         assertNotNull(ssqd);
 215         try {
 216             int quark = ssqd.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 217             assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMax(ssqd, 0, 0, quark));
 218             assertEquals(10.0, TmfStateSystemOperations.queryRangeMax(ssqd, 500, 1500, quark).unboxDouble(), DELTA);
 219             assertEquals(20.0, TmfStateSystemOperations.queryRangeMax(ssqd, 1500, 5000, quark).unboxDouble(), DELTA);
 220             assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 5000, 10000, quark).unboxDouble(), DELTA);
 221             assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 0, 10000, quark).unboxDouble(), DELTA);
 222             assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMax(ssqd, 120000, 120000, quark));
 223             assertEquals(10.0, TmfStateSystemOperations.queryRangeMax(ssqd, 120500, 121500, quark).unboxDouble(), DELTA);
 224             assertEquals(20.0, TmfStateSystemOperations.queryRangeMax(ssqd, 121500, 125000, quark).unboxDouble(), DELTA);
 225             assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 125000, 130000, quark).unboxDouble(), DELTA);
 226             assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 120000, 130000, quark).unboxDouble(), DELTA);
 227             assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 100000, 150000, quark).unboxDouble(), DELTA);
 228             assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 240000, 250000, quark).unboxDouble(), DELTA);
 229             assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 0, 250000, quark).unboxDouble(), DELTA);
 230             assertEquals(00.0, TmfStateSystemOperations.queryRangeMax(ssqd, 250000, 250000, quark).unboxDouble(), DELTA);
 231
 232         } catch (AttributeNotFoundException e) {
 233             fail(e.getMessage());
 234         } catch (StateValueTypeException e) {
 235             fail(e.getMessage());
 236         } catch (TimeRangeException e) {
 237             fail(e.getMessage());
 238         }
 239     }
 240
 241     /**
 242      * Test a query range to the state system to get the minimum value in the
 243      * range. The test values are DOUBLE.
 244      */
 245     @Test
 246     public void testQueryMipmapRangeMinDouble() {
 247         assertNotNull(ssqd);
 248         try {
 249             int quark = ssqd.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 250             assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMin(ssqd, 0, 0, quark));
 251             assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 500, 1500, quark).unboxDouble(), DELTA);
 252             assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 1500, 5000, quark).unboxDouble(), DELTA);
 253             assertEquals(30.0, TmfStateSystemOperations.queryRangeMin(ssqd, 5000, 10000, quark).unboxDouble(), DELTA);
 254             assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 0, 10000, quark).unboxDouble(), DELTA);
 255             assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMin(ssqd, 120000, 120000, quark));
 256             assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 120500, 121500, quark).unboxDouble(), DELTA);
 257             assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 121500, 125000, quark).unboxDouble(), DELTA);
 258             assertEquals(30.0, TmfStateSystemOperations.queryRangeMin(ssqd, 125000, 130000, quark).unboxDouble(), DELTA);
 259             assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 120000, 130000, quark).unboxDouble(), DELTA);
 260             assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 100000, 150000, quark).unboxDouble(), DELTA);
 261             assertEquals(00.0, TmfStateSystemOperations.queryRangeMin(ssqd, 240000, 250000, quark).unboxDouble(), DELTA);
 262             assertEquals(00.0, TmfStateSystemOperations.queryRangeMin(ssqd, 0, 250000, quark).unboxDouble(), DELTA);
 263             assertEquals(00.0, TmfStateSystemOperations.queryRangeMin(ssqd, 250000, 250000, quark).unboxDouble(), DELTA);
 264
 265         } catch (AttributeNotFoundException e) {
 266             fail(e.getMessage());
 267         } catch (StateValueTypeException e) {
 268             fail(e.getMessage());
 269         } catch (TimeRangeException e) {
 270             fail(e.getMessage());
 271         }
 272     }
 273
 274     /**
 275      * Test a query range to the state system to get the average value in the
 276      * range. The test values are DOUBLE.
 277      */
 278     @Test
 279     public void testQueryMipmapRangeAvgDouble() {
 280         assertNotNull(ssqd);
 281         try {
 282             int quark = ssqd.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 283             assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 0, 0, quark), DELTA);
 284             assertEquals(5.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 500, 1500, quark), DELTA);
 285             assertEquals(90.0 / 7, TmfStateSystemOperations.queryRangeAverage(ssqd, 1500, 5000, quark), DELTA);
 286             assertEquals(90.0 / 5, TmfStateSystemOperations.queryRangeAverage(ssqd, 5000, 10000, quark), DELTA);
 287             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 0, 10000, quark), DELTA);
 288             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 0, 20000, quark), DELTA);
 289             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 500, 20500, quark), DELTA);
 290             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 1000, 21000, quark), DELTA);
 291             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 2000, 22000, quark), DELTA);
 292             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 3000, 23000, quark), DELTA);
 293             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 4000, 24000, quark), DELTA);
 294             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 5000, 25000, quark), DELTA);
 295             assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 120000, 120000, quark), DELTA);
 296             assertEquals(5.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 120500, 121500, quark), DELTA);
 297             assertEquals(90.0 / 7, TmfStateSystemOperations.queryRangeAverage(ssqd, 121500, 125000, quark), DELTA);
 298             assertEquals(90.0 / 5, TmfStateSystemOperations.queryRangeAverage(ssqd, 125000, 130000, quark), DELTA);
 299             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 120000, 130000, quark), DELTA);
 300             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 100000, 150000, quark), DELTA);
 301             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 240000, 250000, quark), DELTA);
 302             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 0, 250000, quark), DELTA);
 303             assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 250000, 250000, quark), DELTA);
 304
 305         } catch (AttributeNotFoundException e) {
 306             fail(e.getMessage());
 307         } catch (TimeRangeException e) {
 308             fail(e.getMessage());
 309         } catch (StateValueTypeException e) {
 310             fail(e.getMessage());
 311         }
 312     }
 313 }