org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/request/TmfSchedulerTest.java

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