Commit | Line | Data |
---|---|---|
306586b1 SD |
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 { | |
306586b1 SD |
380 | private int nbEvents = 0; |
381 | private String backgroundName; | |
382 | ||
383 | BackgroundRequest(TmfTimeRange timeRange) { | |
7184fc40 AM |
384 | super(fixture.getEventType(), |
385 | timeRange, | |
386 | 0, | |
306586b1 | 387 | TmfDataRequest.ALL_DATA, |
306586b1 SD |
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 { | |
306586b1 SD |
407 | private int nbEvents = 0; |
408 | private String foregroundName; | |
409 | ||
410 | ForegroundRequest(TmfTimeRange timeRange) { | |
7184fc40 AM |
411 | super(fixture.getEventType(), |
412 | timeRange, | |
413 | 0, | |
306586b1 | 414 | TmfDataRequest.ALL_DATA, |
306586b1 SD |
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 | } |