ctf/org.eclipse.tracecompass.tmf.ctf.core.tests/src/org/eclipse/tracecompass/tmf/ctf/core/tests/temp/request/TmfSchedulerTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2013, 2014 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  *   Simon Delisle - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.tracecompass.tmf.ctf.core.tests.temp.request;
  14
  15 import static org.junit.Assert.assertEquals;
  16 import static org.junit.Assert.assertFalse;
  17 import static org.junit.Assert.assertTrue;
  18 import static org.junit.Assert.fail;
  19
  20 import java.util.ArrayList;
  21 import java.util.LinkedList;
  22 import java.util.List;
  23 import java.util.concurrent.TimeUnit;
  24
  25 import org.eclipse.jdt.annotation.NonNull;
  26 import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
  27 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
  28 import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest;
  29 import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
  30 import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
  31 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
  32 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
  33 import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
  34 import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
  35 import org.junit.After;
  36 import org.junit.Before;
  37 import org.junit.Ignore;
  38 import org.junit.Rule;
  39 import org.junit.Test;
  40 import org.junit.rules.TestRule;
  41 import org.junit.rules.Timeout;
  42
  43 /**
  44  * Test suite for the scheduler.
  45  */
  46 public class TmfSchedulerTest {
  47
  48     /** Time-out tests after 60 seconds */
  49     @Rule
  50     public TestRule globalTimeout = new Timeout(1, TimeUnit.MINUTES);
  51
  52     // ------------------------------------------------------------------------
  53     // Constants
  54     // ------------------------------------------------------------------------
  55
  56     private static final @NonNull CtfTestTrace testTrace = CtfTestTrace.KERNEL;
  57     private static final int NB_EVENTS_TRACE = 695319;
  58     private static final int NB_EVENTS_TIME_RANGE = 155133;
  59
  60     // ------------------------------------------------------------------------
  61     // Attributes
  62     // ------------------------------------------------------------------------
  63
  64     private CtfTmfTrace fixture;
  65
  66     private long fStartTime;
  67     private long fEndTime;
  68     private TmfTimeRange fForegroundTimeRange;
  69
  70     private final List<String> fOrderList = new ArrayList<>();
  71     private int fForegroundId = 0;
  72     private int fBackgroundId = 0;
  73
  74     /**
  75      * Perform pre-test initialization.
  76      */
  77     @Before
  78     public void setUp() {
  79         fixture = CtfTmfTestTraceUtils.getTrace(testTrace);
  80         fixture.indexTrace(true);
  81         fStartTime = fixture.getStartTime().toNanos();
  82         fEndTime = fixture.getEndTime().toNanos();
  83
  84         long foregroundStartTime = fStartTime + ((fEndTime - fStartTime) / 4);
  85         long foregroundEndTime = fStartTime + ((fEndTime - fStartTime) / 2);
  86         fForegroundTimeRange = new TmfTimeRange(TmfTimestamp.fromNanos(foregroundStartTime),
  87                 TmfTimestamp.fromNanos(foregroundEndTime));
  88     }
  89
  90     /**
  91      * Perform post-test clean-up.
  92      */
  93     @After
  94     public void tearDown() {
  95         if (fixture != null) {
  96             fixture.dispose();
  97         }
  98     }
  99
 100     // ------------------------------------------------------------------------
 101     // Tests cases
 102     // ------------------------------------------------------------------------
 103
 104     /**
 105      * Test one background request
 106      */
 107     @Test
 108     public void backgroundRequest() {
 109         BackgroundRequest background = new BackgroundRequest(TmfTimeRange.ETERNITY);
 110         fixture.sendRequest(background);
 111         try {
 112             background.waitForCompletion();
 113         } catch (InterruptedException e) {
 114             fail();
 115         }
 116         assertEquals(NB_EVENTS_TRACE, background.getNbEvents());
 117     }
 118
 119     /**
 120      * Test one foreground request
 121      */
 122     @Test
 123     public void foregroundRequest() {
 124         ForegroundRequest foreground = new ForegroundRequest(TmfTimeRange.ETERNITY);
 125         fixture.sendRequest(foreground);
 126         try {
 127             foreground.waitForCompletion();
 128         } catch (InterruptedException e) {
 129             fail();
 130         }
 131         assertEquals(NB_EVENTS_TRACE, foreground.getNbEvents());
 132     }
 133
 134     /**
 135      * Test one foreground and one background request for the entire trace at
 136      * the same time
 137      */
 138     @Test
 139     public void TestMultiRequest1() {
 140         BackgroundRequest background = new BackgroundRequest(TmfTimeRange.ETERNITY);
 141         ForegroundRequest foreground = new ForegroundRequest(TmfTimeRange.ETERNITY);
 142
 143         fixture.sendRequest(background);
 144         fixture.sendRequest(foreground);
 145         try {
 146             background.waitForCompletion();
 147             foreground.waitForCompletion();
 148         } catch (InterruptedException e) {
 149             fail();
 150         }
 151
 152         assertEquals(NB_EVENTS_TRACE, background.getNbEvents());
 153         assertEquals(NB_EVENTS_TRACE, foreground.getNbEvents());
 154     }
 155
 156     /**
 157      * Test one background request for the entire trace and one foreground
 158      * request for smaller time range
 159      */
 160     @Test
 161     public void TestMultiRequest2() {
 162         BackgroundRequest background2 = new BackgroundRequest(TmfTimeRange.ETERNITY);
 163         ForegroundRequest foreground2 = new ForegroundRequest(fForegroundTimeRange);
 164
 165         fixture.sendRequest(background2);
 166         fixture.sendRequest(foreground2);
 167         try {
 168             background2.waitForCompletion();
 169             foreground2.waitForCompletion();
 170         } catch (InterruptedException e) {
 171             fail();
 172         }
 173
 174         assertEquals(NB_EVENTS_TRACE, background2.getNbEvents());
 175         assertEquals(NB_EVENTS_TIME_RANGE, foreground2.getNbEvents());
 176     }
 177
 178     /**
 179      * Test two foreground request, one to select a time range and one to select
 180      * an event in this time range
 181      */
 182     @Test
 183     public void TestMultiRequest3() {
 184         ForegroundRequest foreground3 = new ForegroundRequest(TmfTimeRange.ETERNITY);
 185         fixture.sendRequest(foreground3);
 186
 187         TmfSelectionRangeUpdatedSignal signal3 = new TmfSelectionRangeUpdatedSignal(this, fForegroundTimeRange.getStartTime());
 188         fixture.broadcast(signal3);
 189
 190         try {
 191             foreground3.waitForCompletion();
 192         } catch (InterruptedException e) {
 193             fail();
 194         }
 195
 196         assertEquals(NB_EVENTS_TRACE, foreground3.getNbEvents());
 197     }
 198
 199     /**
 200      * Test two foreground request, one to select a time range and one to select
 201      * an event before this time range
 202      */
 203     @Test
 204     public void TestMultiRequest4() {
 205         ForegroundRequest foreground4 = new ForegroundRequest(fForegroundTimeRange);
 206         fixture.sendRequest(foreground4);
 207         TmfSelectionRangeUpdatedSignal signal4 = new TmfSelectionRangeUpdatedSignal(this, TmfTimestamp.fromSeconds(fStartTime + ((fEndTime - fStartTime) / 8)));
 208         fixture.broadcast(signal4);
 209
 210         try {
 211             foreground4.waitForCompletion();
 212         } catch (InterruptedException e) {
 213             fail();
 214         }
 215
 216         assertEquals(NB_EVENTS_TIME_RANGE, foreground4.getNbEvents());
 217     }
 218
 219     /**
 220      * Test two foreground request, one to select a time range and one to select
 221      * an event after this time range
 222      */
 223     @Test
 224     public void TestMultiRequest5() {
 225         ForegroundRequest foreground5 = new ForegroundRequest(fForegroundTimeRange);
 226         fixture.sendRequest(foreground5);
 227         TmfSelectionRangeUpdatedSignal signal5 = new TmfSelectionRangeUpdatedSignal(this, TmfTimestamp.fromSeconds(fEndTime - ((fEndTime - fStartTime) / 4)));
 228         fixture.broadcast(signal5);
 229
 230         try {
 231             foreground5.waitForCompletion();
 232         } catch (InterruptedException e) {
 233             fail();
 234         }
 235
 236         assertEquals(NB_EVENTS_TIME_RANGE, foreground5.getNbEvents());
 237     }
 238
 239     /**
 240      * Test one background and one foreground request for the entire trace and
 241      * one foreground request to select an event
 242      */
 243     @Test
 244     public void TestMultiRequest6() {
 245         BackgroundRequest background6 = new BackgroundRequest(TmfTimeRange.ETERNITY);
 246         ForegroundRequest foreground6 = new ForegroundRequest(TmfTimeRange.ETERNITY);
 247
 248         fixture.sendRequest(background6);
 249         fixture.sendRequest(foreground6);
 250
 251         TmfSelectionRangeUpdatedSignal signal6 = new TmfSelectionRangeUpdatedSignal(this, TmfTimestamp.fromSeconds(fStartTime + ((fEndTime - fStartTime) / 8)));
 252         fixture.broadcast(signal6);
 253
 254         try {
 255             background6.waitForCompletion();
 256             foreground6.waitForCompletion();
 257         } catch (InterruptedException e) {
 258             fail();
 259         }
 260
 261         assertEquals(NB_EVENTS_TRACE, background6.getNbEvents());
 262         assertEquals(NB_EVENTS_TRACE, foreground6.getNbEvents());
 263     }
 264
 265     /**
 266      * Four request, two foreground and two background
 267      */
 268     @Test
 269     public void TestMultiRequest7() {
 270         ForegroundRequest foreground7 = new ForegroundRequest(TmfTimeRange.ETERNITY);
 271         ForegroundRequest foreground8 = new ForegroundRequest(fForegroundTimeRange);
 272         BackgroundRequest background7 = new BackgroundRequest(TmfTimeRange.ETERNITY);
 273         BackgroundRequest background8 = new BackgroundRequest(TmfTimeRange.ETERNITY);
 274         fixture.sendRequest(foreground7);
 275         fixture.sendRequest(foreground8);
 276         fixture.sendRequest(background7);
 277         fixture.sendRequest(background8);
 278         try {
 279             foreground7.waitForCompletion();
 280             foreground8.waitForCompletion();
 281             background7.waitForCompletion();
 282             background8.waitForCompletion();
 283         } catch (InterruptedException e) {
 284             fail();
 285         }
 286         assertEquals(NB_EVENTS_TRACE, foreground7.getNbEvents());
 287         assertEquals(NB_EVENTS_TIME_RANGE, foreground8.getNbEvents());
 288         assertEquals(NB_EVENTS_TRACE, background7.getNbEvents());
 289         assertEquals(NB_EVENTS_TRACE, background8.getNbEvents());
 290     }
 291
 292     /**
 293      * One long foreground request and one short foreground request, the short
 294      * one should finish first
 295      */
 296     @Test
 297     public void preemptedForegroundRequest() {
 298         ForegroundRequest foreground9 = new ForegroundRequest(TmfTimeRange.ETERNITY);
 299         TmfTimeRange shortTimeRange = new TmfTimeRange(TmfTimestamp.fromNanos(fStartTime),
 300                 TmfTimestamp.fromNanos(fStartTime + ((fEndTime - fStartTime) / 16)));
 301         ForegroundRequest shortForeground = new ForegroundRequest(shortTimeRange);
 302         fixture.sendRequest(foreground9);
 303         try {
 304             foreground9.waitForStart();
 305         } catch (InterruptedException e) {
 306             fail();
 307         }
 308         fixture.sendRequest(shortForeground);
 309         try {
 310             shortForeground.waitForCompletion();
 311         } catch (InterruptedException e) {
 312             fail();
 313         }
 314         assertFalse(foreground9.isCompleted());
 315     }
 316
 317     /**
 318      * One long background request and one short foreground request, the
 319      * foreground request should finish first
 320      */
 321     @Test
 322     public void preemptedBackgroundRequest() {
 323         BackgroundRequest background9 = new BackgroundRequest(TmfTimeRange.ETERNITY);
 324         ForegroundRequest foreground10 = new ForegroundRequest(fForegroundTimeRange);
 325         fixture.sendRequest(background9);
 326         fixture.sendRequest(foreground10);
 327         try {
 328             foreground10.waitForCompletion();
 329         } catch (InterruptedException e) {
 330             fail();
 331         }
 332         assertTrue(foreground10.isCompleted());
 333         assertFalse(background9.isCompleted());
 334     }
 335
 336     /**
 337      * Test if the scheduler is working as expected
 338      */
 339     @Ignore
 340     @Test
 341     public void executionOrder() {
 342         List<String> expectedOrder = new LinkedList<>();
 343         expectedOrder.add("FOREGROUND1");
 344         expectedOrder.add("FOREGROUND2");
 345         expectedOrder.add("FOREGROUND3");
 346         expectedOrder.add("FOREGROUND4");
 347         expectedOrder.add("BACKGROUND1");
 348         expectedOrder.add("FOREGROUND1");
 349         expectedOrder.add("FOREGROUND2");
 350         expectedOrder.add("FOREGROUND3");
 351         expectedOrder.add("FOREGROUND4");
 352         expectedOrder.add("BACKGROUND2");
 353
 354         fOrderList.clear();
 355         fForegroundId = 0;
 356         fBackgroundId = 0;
 357
 358         BackgroundRequest background1 = new BackgroundRequest(TmfTimeRange.ETERNITY);
 359         BackgroundRequest background2 = new BackgroundRequest(TmfTimeRange.ETERNITY);
 360
 361         ForegroundRequest foreground1 = new ForegroundRequest(TmfTimeRange.ETERNITY);
 362         ForegroundRequest foreground2 = new ForegroundRequest(TmfTimeRange.ETERNITY);
 363         ForegroundRequest foreground3 = new ForegroundRequest(TmfTimeRange.ETERNITY);
 364         ForegroundRequest foreground4 = new ForegroundRequest(TmfTimeRange.ETERNITY);
 365
 366         fixture.sendRequest(foreground1);
 367         fixture.sendRequest(foreground2);
 368         fixture.sendRequest(foreground3);
 369         fixture.sendRequest(foreground4);
 370         fixture.sendRequest(background1);
 371         fixture.sendRequest(background2);
 372         try {
 373             foreground1.waitForCompletion();
 374             foreground2.waitForCompletion();
 375             foreground3.waitForCompletion();
 376             foreground4.waitForCompletion();
 377             background1.waitForCompletion();
 378             background2.waitForCompletion();
 379         } catch (InterruptedException e) {
 380             fail();
 381         }
 382         assertEquals(expectedOrder, fOrderList.subList(0, expectedOrder.size()));
 383     }
 384
 385     // ------------------------------------------------------------------------
 386     // Helper methods
 387     // ------------------------------------------------------------------------
 388
 389     private class BackgroundRequest extends TmfEventRequest {
 390         private int nbEvents = 0;
 391         private String backgroundName;
 392
 393         BackgroundRequest(TmfTimeRange timeRange) {
 394             super(fixture.getEventType(),
 395                     timeRange,
 396                     0,
 397                     ITmfEventRequest.ALL_DATA,
 398                     ExecutionType.BACKGROUND);
 399             backgroundName = getExecType().toString() + ++fBackgroundId;
 400         }
 401
 402         @Override
 403         public void handleData(final ITmfEvent event) {
 404             super.handleData(event);
 405             synchronized (fOrderList) {
 406                 if (fOrderList.isEmpty() || !fOrderList.get(fOrderList.size() - 1).equals(backgroundName)) {
 407                     fOrderList.add(backgroundName);
 408                 }
 409             }
 410             ++nbEvents;
 411         }
 412
 413         public int getNbEvents() {
 414             return nbEvents;
 415         }
 416     }
 417
 418     private class ForegroundRequest extends TmfEventRequest {
 419         private int nbEvents = 0;
 420         private String foregroundName;
 421
 422         ForegroundRequest(TmfTimeRange timeRange) {
 423             super(fixture.getEventType(),
 424                     timeRange,
 425                     0,
 426                     ITmfEventRequest.ALL_DATA,
 427                     ExecutionType.FOREGROUND);
 428             foregroundName = getExecType().toString() + ++fForegroundId;
 429         }
 430
 431         @Override
 432         public void handleData(final ITmfEvent event) {
 433             super.handleData(event);
 434             synchronized (fOrderList) {
 435                 if (fOrderList.isEmpty() || !fOrderList.get(fOrderList.size() - 1).equals(foregroundName)) {
 436                     fOrderList.add(foregroundName);
 437                 }
 438             }
 439             ++nbEvents;
 440         }
 441
 442         public int getNbEvents() {
 443             return nbEvents;
 444         }
 445     }
 446 }