ctf/org.eclipse.tracecompass.tmf.ctf.core.tests/src/org/eclipse/tracecompass/tmf/ctf/core/tests/event/CtfTmfLostEventsTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2013, 2015 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made 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  *   Alexandre Montplaisir - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.tracecompass.tmf.ctf.core.tests.event;
  14
  15 import static org.junit.Assert.assertEquals;
  16 import static org.junit.Assert.assertFalse;
  17 import static org.junit.Assert.assertTrue;
  18
  19 import org.eclipse.jdt.annotation.NonNull;
  20 import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
  21 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
  22 import org.eclipse.tracecompass.tmf.core.event.ITmfLostEvent;
  23 import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest;
  24 import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
  25 import org.eclipse.tracecompass.tmf.core.synchronization.TimestampTransformFactory;
  26 import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
  27 import org.eclipse.tracecompass.tmf.core.timestamp.TmfNanoTimestamp;
  28 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
  29 import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
  30 import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
  31 import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
  32 import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
  33 import org.junit.After;
  34 import org.junit.Before;
  35 import org.junit.Test;
  36
  37 /**
  38  * Tests to verify that lost events are handled correctly.
  39  *
  40  * Be wary if you are using Babeltrace to cross-check those values. There could
  41  * be a bug in Babeltrace with regards to lost events. See
  42  * http://bugs.lttng.org/issues/589
  43  *
  44  * It's not 100% sure at this point which implementation is correct, so for now
  45  * these tests assume the Java implementation is the right one.
  46  *
  47  * @author Alexandre Montplaisir
  48  */
  49 public class CtfTmfLostEventsTest {
  50
  51     private static final @NonNull CtfTestTrace testTrace = CtfTestTrace.HELLO_LOST;
  52
  53     private CtfTmfTrace fixture = null;
  54
  55     /**
  56      * Class setup
  57      */
  58     @Before
  59     public void setUp() {
  60         fixture = CtfTmfTestTraceUtils.getTrace(testTrace);
  61         fixture.indexTrace(true);
  62     }
  63
  64     /**
  65      * Clean-up
  66      */
  67     @After
  68     public void tearDown() {
  69         if (fixture != null) {
  70             fixture.dispose();
  71         }
  72     }
  73
  74     // ------------------------------------------------------------------------
  75     // Test methods
  76     // ------------------------------------------------------------------------
  77
  78     /**
  79      * Test that the number of events is reported correctly (a range of lost
  80      * events is counted as one event).
  81      */
  82     @Test
  83     public void testNbEvents() {
  84         final long expectedReal = 32300;
  85         final long expectedLost = 562;
  86
  87         EventCountRequest req = new EventCountRequest();
  88         fixture.sendRequest(req);
  89         try {
  90             req.waitForCompletion();
  91         } catch (InterruptedException e) {
  92             e.printStackTrace();
  93         }
  94
  95         assertEquals(expectedReal, req.getReal());
  96         assertEquals(expectedLost, req.getLost());
  97     }
  98
  99     /**
 100      * Test that the number of events is reported correctly (a range of lost
 101      * events is counted as one event). Events could be wrongly counted as lost
 102      * events in certain situations.
 103      */
 104     @Test
 105     public void testNbEventsBug475007() {
 106         final CtfTestTrace tmfTestTrace = CtfTestTrace.DYNSCOPE;
 107         CtfTmfTrace trace = CtfTmfTestTraceUtils.getTrace(tmfTestTrace);
 108         trace.indexTrace(true);
 109
 110         final long expectedReal = 100003;
 111         final long expectedLost = 1;
 112
 113         EventCountRequest req = new EventCountRequest();
 114         trace.sendRequest(req);
 115         try {
 116             req.waitForCompletion();
 117         } catch (InterruptedException e) {
 118             e.printStackTrace();
 119         }
 120
 121         assertEquals(expectedReal, req.getReal());
 122         assertEquals(expectedLost, req.getLost());
 123
 124         trace.dispose();
 125     }
 126
 127     /**
 128      * Test getting the first lost event from the trace.
 129      */
 130     @Test
 131     public void testFirstLostEvent() {
 132         final long rank = 190;
 133         final ITmfTimestamp start = new TmfNanoTimestamp(1376592664828900165L);
 134         final ITmfTimestamp end   = new TmfNanoTimestamp(1376592664829403076L);
 135         final long nbLost = 859;
 136
 137         final CtfTmfEvent ev = getOneEventTime(start);
 138         /* Make sure seeking by rank yields the same event */
 139         final CtfTmfEvent ev2 = getOneEventRank(rank);
 140         assertEquals(ev, ev2);
 141
 142         assertTrue(ev instanceof ITmfLostEvent);
 143         ITmfLostEvent event = (ITmfLostEvent) ev;
 144
 145         assertEquals(start, event.getTimestamp());
 146         assertEquals(start, event.getTimeRange().getStartTime());
 147         assertEquals(end, event.getTimeRange().getEndTime());
 148         assertEquals(nbLost, event.getNbLostEvents());
 149     }
 150
 151     /**
 152      * Test getting the second lost event from the trace.
 153      */
 154     @Test
 155     public void testSecondLostEvent() {
 156         final long rank = 229;
 157         final ITmfTimestamp start = new TmfNanoTimestamp(1376592664829477058L);
 158         final ITmfTimestamp end   = new TmfNanoTimestamp(1376592664829824514L);
 159         final long nbLost = 488;
 160
 161         final CtfTmfEvent ev = getOneEventTime(start);
 162         /* Make sure seeking by rank yields the same event */
 163         final CtfTmfEvent ev2 = getOneEventRank(rank);
 164         assertEquals(ev, ev2);
 165
 166         assertTrue(ev instanceof ITmfLostEvent);
 167         ITmfLostEvent event = (ITmfLostEvent) ev;
 168
 169         assertEquals(start, event.getTimestamp());
 170         assertEquals(start, event.getTimeRange().getStartTime());
 171         assertEquals(end, event.getTimeRange().getEndTime());
 172         assertEquals(nbLost, event.getNbLostEvents());
 173     }
 174
 175     /**
 176      * Test getting one normal event from the trace (lost events should not
 177      * interfere).
 178      */
 179     @Test
 180     public void testNormalEvent() {
 181         final long rank = 200;
 182         final ITmfTimestamp ts = new TmfNanoTimestamp(1376592664829425780L);
 183
 184         final CtfTmfEvent event = getOneEventTime(ts);
 185         /* Make sure seeking by rank yields the same event */
 186         final CtfTmfEvent event2 = getOneEventRank(rank);
 187         assertEquals(event, event2);
 188
 189         assertFalse(event instanceof ITmfLostEvent);
 190         assertEquals(ts, event.getTimestamp());
 191     }
 192
 193     /**
 194      * Test getting a lost event from a trace that has a timestamp transform.
 195      */
 196     @Test
 197     public void testLostEventWithTransform() {
 198         CtfTmfTrace trace = CtfTmfTestTraceUtils.getTrace(testTrace);
 199         long offset = 1234567890L;
 200         trace.setTimestampTransform(TimestampTransformFactory.createWithOffset(offset));
 201         trace.indexTrace(true);
 202
 203         final long rank = 190;
 204         final ITmfTimestamp start = new TmfNanoTimestamp(1376592664828900165L + offset);
 205         final ITmfTimestamp end   = new TmfNanoTimestamp(1376592664829403076L + offset);
 206         final long nbLost = 859;
 207
 208         ITmfContext context = trace.seekEvent(rank);
 209         final CtfTmfEvent ev = trace.getNext(context);
 210         context.dispose();
 211
 212         assertTrue(ev instanceof ITmfLostEvent);
 213         ITmfLostEvent event = (ITmfLostEvent) ev;
 214
 215         assertEquals(start, event.getTimestamp());
 216         assertEquals(start, event.getTimeRange().getStartTime());
 217         assertEquals(end, event.getTimeRange().getEndTime());
 218         assertEquals(nbLost, event.getNbLostEvents());
 219
 220         trace.setTimestampTransform(null);
 221         trace.dispose();
 222     }
 223
 224     // ------------------------------------------------------------------------
 225     // Event requests
 226     // ------------------------------------------------------------------------
 227
 228     private CtfTmfEvent getOneEventRank(long rank) {
 229         OneEventRequestPerRank req = new OneEventRequestPerRank(rank);
 230         fixture.sendRequest(req);
 231         try {
 232             req.waitForCompletion();
 233         } catch (InterruptedException e) {
 234             e.printStackTrace();
 235         }
 236         return req.getEvent();
 237     }
 238
 239     private CtfTmfEvent getOneEventTime(@NonNull ITmfTimestamp ts) {
 240         OneEventRequestPerTs req = new OneEventRequestPerTs(ts);
 241         fixture.sendRequest(req);
 242         try {
 243             req.waitForCompletion();
 244         } catch (InterruptedException e) {
 245             e.printStackTrace();
 246         }
 247         return req.getEvent();
 248     }
 249
 250     private class OneEventRequestPerRank extends TmfEventRequest {
 251
 252         private CtfTmfEvent event = null;
 253
 254         public OneEventRequestPerRank(long rank) {
 255             super(CtfTmfEvent.class, TmfTimeRange.ETERNITY, rank, 1, ExecutionType.FOREGROUND);
 256         }
 257
 258         @Override
 259         public void handleData(ITmfEvent ev) {
 260             /* Type is checked by the request, cast should be safe */
 261             event = (CtfTmfEvent) ev;
 262         }
 263
 264         public CtfTmfEvent getEvent() {
 265             return event;
 266         }
 267     }
 268
 269     private class OneEventRequestPerTs extends TmfEventRequest {
 270
 271         private CtfTmfEvent event = null;
 272
 273         public OneEventRequestPerTs(@NonNull ITmfTimestamp ts) {
 274             super(CtfTmfEvent.class,
 275                     new TmfTimeRange(ts, ts),
 276                     0, ITmfEventRequest.ALL_DATA, ExecutionType.FOREGROUND);
 277         }
 278
 279         @Override
 280         public void handleData(ITmfEvent ev) {
 281             event = (CtfTmfEvent) ev;
 282         }
 283
 284         public CtfTmfEvent getEvent() {
 285             return event;
 286         }
 287     }
 288
 289     private class EventCountRequest extends TmfEventRequest {
 290
 291         private long nbReal = 0;
 292         private long nbLost = 0;
 293
 294         public EventCountRequest() {
 295             super(CtfTmfEvent.class, TmfTimeRange.ETERNITY, 0,
 296                     ITmfEventRequest.ALL_DATA, ExecutionType.FOREGROUND);
 297         }
 298
 299         @Override
 300         public void handleData(ITmfEvent event) {
 301             if (event instanceof ITmfLostEvent) {
 302                 nbLost++;
 303             } else {
 304                 nbReal++;
 305             }
 306         }
 307
 308         public long getReal() {
 309             return nbReal;
 310         }
 311
 312         public long getLost() {
 313             return nbLost;
 314         }
 315     }
 316 }