1 /*******************************************************************************
2 * Copyright (c) 2016 Ericsson
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 *******************************************************************************/
10 package org
.eclipse
.tracecompass
.analysis
.timing
.core
.tests
.flamegraph
;
12 import static org
.junit
.Assert
.assertEquals
;
13 import static org
.junit
.Assert
.assertNotNull
;
14 import static org
.junit
.Assert
.assertTrue
;
16 import java
.util
.Collections
;
17 import java
.util
.List
;
19 import org
.eclipse
.core
.runtime
.IProgressMonitor
;
20 import org
.eclipse
.core
.runtime
.NullProgressMonitor
;
21 import org
.eclipse
.jdt
.annotation
.NonNull
;
22 import org
.eclipse
.jdt
.annotation
.Nullable
;
23 import org
.eclipse
.tracecompass
.common
.core
.NonNullUtils
;
24 import org
.eclipse
.tracecompass
.internal
.analysis
.timing
.core
.callgraph
.AggregatedCalledFunction
;
25 import org
.eclipse
.tracecompass
.internal
.analysis
.timing
.core
.callgraph
.CallGraphAnalysis
;
26 import org
.eclipse
.tracecompass
.internal
.analysis
.timing
.core
.callgraph
.ThreadNode
;
27 import org
.eclipse
.tracecompass
.statesystem
.core
.ITmfStateSystem
;
28 import org
.eclipse
.tracecompass
.statesystem
.core
.ITmfStateSystemBuilder
;
29 import org
.eclipse
.tracecompass
.statesystem
.core
.StateSystemFactory
;
30 import org
.eclipse
.tracecompass
.statesystem
.core
.backend
.IStateHistoryBackend
;
31 import org
.eclipse
.tracecompass
.statesystem
.core
.backend
.StateHistoryBackendFactory
;
32 import org
.eclipse
.tracecompass
.statesystem
.core
.statevalue
.TmfStateValue
;
33 import org
.eclipse
.tracecompass
.tmf
.core
.segment
.ISegmentAspect
;
34 import org
.junit
.Test
;
37 * Test the CallGraphAnalysis.This creates a virtual state system in each test
38 * and tests the aggregation tree returned by the CallGraphAnalysis.
40 * @author Sonia Farrah
43 public class AggregationTreeTest
{
45 private static final @NonNull String PROCESS_PATH
= "Processes";
46 private static final @NonNull String THREAD_PATH
= "Thread";
47 private static final @NonNull String CALLSTACK_PATH
= "CallStack";
48 private static final String QUARK_0
= "0";
49 private static final String QUARK_1
= "1";
50 private static final String QUARK_2
= "2";
51 private static final String QUARK_3
= "3";
52 private static final Integer SMALL_AMOUNT_OF_SEGMENT
= 3;
53 private static final int LARGE_AMOUNT_OF_SEGMENTS
= 1000;
54 private static final String
@NonNull [] CSP
= { CALLSTACK_PATH
};
55 private static final String
@NonNull [] PP
= { PROCESS_PATH
};
56 private static final String
@NonNull [] TP
= { THREAD_PATH
};
59 * This class is used to make the CallGraphAnalysis's method
60 * iterateOverStateSystem() visible to test
62 private class CGAnalysis
extends CallGraphAnalysis
{
65 protected boolean iterateOverStateSystem(@Nullable ITmfStateSystem ss
, String
[] threadsPattern
, String
[] processesPattern
, String
[] callStackPath
, IProgressMonitor monitor
) {
66 return super.iterateOverStateSystem(ss
, threadsPattern
, processesPattern
, callStackPath
, monitor
);
70 public @NonNull Iterable
<@NonNull ISegmentAspect
> getSegmentAspects() {
71 return Collections
.EMPTY_LIST
;
76 private static ITmfStateSystemBuilder
createFixture() {
77 IStateHistoryBackend backend
;
78 backend
= StateHistoryBackendFactory
.createInMemoryBackend("Test", 0L);
79 ITmfStateSystemBuilder fixture
= StateSystemFactory
.newStateSystem(backend
);
83 private CGAnalysis fCga
;
86 * Test an empty state system.
89 public void emptyStateSystemTest() {
90 ITmfStateSystemBuilder fixture
= createFixture();
91 fixture
.closeHistory(1002);
92 CGAnalysis cga
= new CGAnalysis();
93 assertTrue(cga
.iterateOverStateSystem(fixture
, TP
, PP
, CSP
, new NullProgressMonitor()));
94 List
<ThreadNode
> threads
= cga
.getThreadNodes();
95 assertNotNull(threads
);
96 assertEquals("Number of threads found", 0, threads
.size());
100 * Test cascade state system. The call stack's structure used in this test
111 public void cascadeTest() {
112 ITmfStateSystemBuilder fixture
= createFixture();
113 // Build the state system
116 int threadQuark
= fixture
.getQuarkAbsoluteAndAdd(PROCESS_PATH
, THREAD_PATH
);
117 int parentQuark
= fixture
.getQuarkRelativeAndAdd(threadQuark
, CALLSTACK_PATH
);
118 fixture
.updateOngoingState(TmfStateValue
.newValueLong(100), threadQuark
);
119 for (int i
= 1; i
<= SMALL_AMOUNT_OF_SEGMENT
; i
++) {
120 int quark
= fixture
.getQuarkRelativeAndAdd(parentQuark
, Integer
.toString(i
));
121 TmfStateValue statev
= TmfStateValue
.newValueLong(i
);
122 fixture
.modifyAttribute(start
, TmfStateValue
.nullValue(), quark
);
123 fixture
.modifyAttribute(start
+ i
, statev
, quark
);
124 fixture
.modifyAttribute(end
- i
, TmfStateValue
.nullValue(), quark
);
127 fixture
.closeHistory(1002);
128 // Execute the CallGraphAnalysis
129 CGAnalysis cga
= new CGAnalysis();
131 assertTrue(cga
.iterateOverStateSystem(fixture
, TP
, PP
, CSP
, new NullProgressMonitor()));
133 List
<ThreadNode
> threads
= cga
.getThreadNodes();
134 // Test the threads generated by the analysis
135 assertNotNull(threads
);
136 assertEquals("Number of thread nodes Found", 1, threads
.size());
137 assertEquals("Number of root functions ", 1, threads
.get(0).getChildren().size());
138 assertEquals("Thread id", 100, threads
.get(0).getId());
139 assertEquals("Thread name", "Thread", threads
.get(0).getSymbol());
140 Object
[] children
= threads
.get(0).getChildren().toArray();
141 AggregatedCalledFunction firstFunction
= (AggregatedCalledFunction
) children
[0];
142 assertEquals("Children number: First function", 1, firstFunction
.getChildren().size());
143 Object
@NonNull [] firstFunctionChildren
= firstFunction
.getChildren().toArray();
144 AggregatedCalledFunction secondFunction
= (AggregatedCalledFunction
) firstFunctionChildren
[0];
145 assertEquals("Children number: Second function", 1, secondFunction
.getChildren().size());
146 Object
@NonNull [] secondFunctionChildren
= secondFunction
.getChildren().toArray();
147 AggregatedCalledFunction thirdFunction
= (AggregatedCalledFunction
) secondFunctionChildren
[0];
148 assertEquals("Children number: Third function", 0, thirdFunction
.getChildren().size());
150 assertEquals("Test parenthood ", NonNullUtils
.checkNotNull(secondFunction
.getParent()).getSymbol(), firstFunction
.getSymbol());
151 assertEquals("Test parenthood ", NonNullUtils
.checkNotNull(thirdFunction
.getParent()).getSymbol(), secondFunction
.getSymbol());
153 assertEquals("Test first function's duration", 998, firstFunction
.getDuration());
154 assertEquals("Test second function's duration", 996, secondFunction
.getDuration());
155 assertEquals("Test third function's duration", 994, thirdFunction
.getDuration());
157 assertEquals("Test first function's self time", 2, firstFunction
.getSelfTime());
158 assertEquals("Test second function's self time", 2, secondFunction
.getSelfTime());
159 assertEquals("Test third function's self time", 994, thirdFunction
.getSelfTime());
161 assertEquals("Test first function's depth", 0, firstFunction
.getDepth());
162 assertEquals("Test second function's depth", 1, secondFunction
.getDepth());
163 assertEquals("Test third function's depth", 2, thirdFunction
.getDepth());
164 // Test number of calls
165 assertEquals("Test first function's nombre of calls", 1, firstFunction
.getNbCalls());
166 assertEquals("Test second function's nombre of calls", 1, secondFunction
.getNbCalls());
167 assertEquals("Test third function's nombre of calls", 1, thirdFunction
.getNbCalls());
171 * Test a state system with a two calls for the same function. The call
172 * stack's structure used in this test is shown below:
176 * ___ main___ ___ main___
182 public void treeTest() {
183 ITmfStateSystemBuilder fixture
= createFixture();
184 // Build the state system
185 int threadQuark
= fixture
.getQuarkAbsoluteAndAdd(PROCESS_PATH
, THREAD_PATH
);
186 int parentQuark
= fixture
.getQuarkRelativeAndAdd(threadQuark
, CALLSTACK_PATH
);
187 fixture
.updateOngoingState(TmfStateValue
.newValueDouble(0.001), threadQuark
);
188 int quark
= fixture
.getQuarkRelativeAndAdd(parentQuark
, QUARK_0
);
189 TmfStateValue statev
= TmfStateValue
.newValueLong(0);
190 fixture
.modifyAttribute(0, statev
, quark
);
191 fixture
.modifyAttribute(100, TmfStateValue
.nullValue(), quark
);
193 quark
= fixture
.getQuarkRelativeAndAdd(parentQuark
, QUARK_1
);
194 statev
= TmfStateValue
.newValueLong(1);
195 fixture
.modifyAttribute(0, statev
, quark
);
196 fixture
.modifyAttribute(50, TmfStateValue
.nullValue(), quark
);
197 fixture
.modifyAttribute(60, statev
, quark
);
198 fixture
.modifyAttribute(90, TmfStateValue
.nullValue(), quark
);
200 quark
= fixture
.getQuarkRelativeAndAdd(parentQuark
, QUARK_2
);
201 fixture
.modifyAttribute(0, statev
, quark
);
202 fixture
.modifyAttribute(30, TmfStateValue
.nullValue(), quark
);
203 fixture
.closeHistory(102);
205 // Execute the CallGraphAnalysis
206 CGAnalysis cga
= new CGAnalysis();
208 assertTrue(cga
.iterateOverStateSystem(fixture
, TP
, PP
, CSP
, new NullProgressMonitor()));
209 List
<ThreadNode
> threads
= cga
.getThreadNodes();
210 // Test the threads generated by the analysis
211 assertNotNull(threads
);
212 assertEquals("Number of thread nodes Found", 1, threads
.size());
213 assertEquals("Thread id", -1, threads
.get(0).getId());
214 assertEquals("Thread name", "Thread", threads
.get(0).getSymbol());
215 Object
[] children
= threads
.get(0).getChildren().toArray();
216 AggregatedCalledFunction firstFunction
= (AggregatedCalledFunction
) children
[0];
217 assertEquals("Children number: First function", 1, firstFunction
.getChildren().size());
218 Object
[] firstFunctionChildren
= firstFunction
.getChildren().toArray();
219 AggregatedCalledFunction secondFunction
= (AggregatedCalledFunction
) firstFunctionChildren
[0];
220 assertEquals("Children number: Second function", 1, secondFunction
.getChildren().size());
221 Object
[] secondFunctionChildren
= secondFunction
.getChildren().toArray();
222 AggregatedCalledFunction thirdFunction
= (AggregatedCalledFunction
) secondFunctionChildren
[0];
223 assertEquals("Children number: Third function", 0, thirdFunction
.getChildren().size());
225 assertEquals("Test parenthood ", NonNullUtils
.checkNotNull(secondFunction
.getParent()).getSymbol(), firstFunction
.getSymbol());
226 assertEquals("Test parenthood ", NonNullUtils
.checkNotNull(thirdFunction
.getParent()).getSymbol(), secondFunction
.getSymbol());
228 assertEquals("Test first function's duration", 100, firstFunction
.getDuration());
229 assertEquals("Test second function's duration", 80, secondFunction
.getDuration());
230 assertEquals("Test third function's duration", 30, thirdFunction
.getDuration());
232 assertEquals("Test first function's self time", 20, firstFunction
.getSelfTime());
233 assertEquals("Test second function's self time", 50, secondFunction
.getSelfTime());
234 assertEquals("Test third function's self time", 30, thirdFunction
.getSelfTime());
236 assertEquals("Test first function's depth", 0, firstFunction
.getDepth());
237 assertEquals("Test second function's depth", 1, secondFunction
.getDepth());
238 assertEquals("Test third function's depth", 2, thirdFunction
.getDepth());
239 // Test number of calls
240 assertEquals("Test first function's number of calls", 1, firstFunction
.getNbCalls());
241 assertEquals("Test second function's number of calls", 2, secondFunction
.getNbCalls());
242 assertEquals("Test third function's number of calls", 1, thirdFunction
.getNbCalls());
246 * Test the callees merge. The call stack's structure used in this test is
251 * ___ main___ ___ main___
257 public void mergeFirstLevelCalleesTest() {
258 ITmfStateSystemBuilder fixture
= createFixture();
259 // Build the state system
260 int threadQuark
= fixture
.getQuarkAbsoluteAndAdd(PROCESS_PATH
, "123");
261 int parentQuark
= fixture
.getQuarkRelativeAndAdd(threadQuark
, CALLSTACK_PATH
);
262 fixture
.updateOngoingState(TmfStateValue
.newValueDouble(0.001), threadQuark
);
263 int quark
= fixture
.getQuarkRelativeAndAdd(parentQuark
, QUARK_0
);
264 TmfStateValue statev
= TmfStateValue
.newValueLong(0);
265 fixture
.modifyAttribute(0, statev
, quark
);
266 fixture
.modifyAttribute(100, TmfStateValue
.nullValue(), quark
);
268 quark
= fixture
.getQuarkRelativeAndAdd(parentQuark
, QUARK_1
);
269 statev
= TmfStateValue
.newValueLong(1);
270 fixture
.modifyAttribute(0, statev
, quark
);
271 fixture
.modifyAttribute(50, TmfStateValue
.nullValue(), quark
);
272 fixture
.modifyAttribute(60, statev
, quark
);
273 fixture
.modifyAttribute(90, TmfStateValue
.nullValue(), quark
);
275 quark
= fixture
.getQuarkRelativeAndAdd(parentQuark
, QUARK_2
);
276 statev
= TmfStateValue
.newValueLong(2);
277 fixture
.modifyAttribute(0, statev
, quark
);
278 fixture
.modifyAttribute(30, TmfStateValue
.nullValue(), quark
);
279 statev
= TmfStateValue
.newValueLong(3);
280 fixture
.modifyAttribute(60, statev
, quark
);
281 fixture
.modifyAttribute(80, TmfStateValue
.nullValue(), quark
);
282 fixture
.closeHistory(102);
284 // Execute the CallGraphAnalysis
285 CGAnalysis cga
= new CGAnalysis();
286 String
@NonNull [] tp
= { "123" };
287 assertTrue(cga
.iterateOverStateSystem(fixture
, tp
, PP
, CSP
, new NullProgressMonitor()));
289 List
<ThreadNode
> threads
= cga
.getThreadNodes();
290 // Test the threads generated by the analysis
291 assertNotNull(threads
);
292 assertEquals("Number of thread nodes Found", 1, threads
.size());
293 assertEquals("Thread id", 123, threads
.get(0).getId());
294 assertEquals("Thread name", "123", threads
.get(0).getSymbol());
295 assertEquals("Number of root functions ", 1, threads
.get(0).getChildren().size());
296 Object
[] children
= threads
.get(0).getChildren().toArray();
298 AggregatedCalledFunction firstFunction
= (AggregatedCalledFunction
) children
[0];
299 assertEquals("Children number: First function", 1, firstFunction
.getChildren().size());
300 Object
[] firstFunctionChildren
= firstFunction
.getChildren().toArray();
301 AggregatedCalledFunction secondFunction
= (AggregatedCalledFunction
) firstFunctionChildren
[0];
302 assertEquals("Children number: Second function", 2, secondFunction
.getChildren().size());
303 Object
[] secondFunctionChildren
= secondFunction
.getChildren().toArray();
304 AggregatedCalledFunction leaf1
= (AggregatedCalledFunction
) secondFunctionChildren
[0];
305 AggregatedCalledFunction leaf2
= (AggregatedCalledFunction
) secondFunctionChildren
[1];
306 assertEquals("Children number: First leaf function", 0, leaf1
.getChildren().size());
307 assertEquals("Children number: Second leaf function", 0, leaf2
.getChildren().size());
309 assertEquals("Test parenthood ", NonNullUtils
.checkNotNull(secondFunction
.getParent()).getSymbol(), firstFunction
.getSymbol());
310 assertEquals("Test parenthood ", NonNullUtils
.checkNotNull(leaf1
.getParent()).getSymbol(), secondFunction
.getSymbol());
311 assertEquals("Test parenthood ", NonNullUtils
.checkNotNull(leaf2
.getParent()).getSymbol(), secondFunction
.getSymbol());
313 assertEquals("Test first function's duration", 100, firstFunction
.getDuration());
314 assertEquals("Test second function's duration", 80, secondFunction
.getDuration());
315 assertEquals("Test first leaf's duration", 30, leaf1
.getDuration());
316 assertEquals("Test second leaf's duration", 20, leaf2
.getDuration());
318 assertEquals("Test first function's self time", 20, firstFunction
.getSelfTime());
319 assertEquals("Test second function's self time", 30, secondFunction
.getSelfTime());
320 assertEquals("Test first leaf's self time", 30, leaf1
.getSelfTime());
321 assertEquals("Test second leaf's self time", 20, leaf2
.getSelfTime());
323 assertEquals("Test first function's depth", 0, firstFunction
.getDepth());
324 assertEquals("Test second function's depth", 1, secondFunction
.getDepth());
325 assertEquals("Test first leaf's depth", 2, leaf1
.getDepth());
326 assertEquals("Test second leaf's depth", 2, leaf2
.getDepth());
327 // Test number of calls
328 assertEquals("Test first function's number of calls", 1, firstFunction
.getNbCalls());
329 assertEquals("Test second function's number of calls", 2, secondFunction
.getNbCalls());
330 assertEquals("Test first leaf's number of calls", 1, leaf1
.getNbCalls());
331 assertEquals("Test second leaf's number of calls", 1, leaf2
.getNbCalls());
335 * Build a call stack example.This call stack's structure is shown below :
344 private static void buildCallStack(ITmfStateSystemBuilder fixture
) {
345 int parentQuark
= fixture
.getQuarkAbsoluteAndAdd(PROCESS_PATH
, THREAD_PATH
, CALLSTACK_PATH
);
346 // Create the first function
347 int quark
= fixture
.getQuarkRelativeAndAdd(parentQuark
, QUARK_0
);
348 TmfStateValue statev
= TmfStateValue
.newValueLong(0);
349 fixture
.modifyAttribute(0, statev
, quark
);
350 fixture
.modifyAttribute(100, TmfStateValue
.nullValue(), quark
);
351 // Create the first level functions
352 quark
= fixture
.getQuarkRelativeAndAdd(parentQuark
, QUARK_1
);
353 statev
= TmfStateValue
.newValueLong(1);
354 fixture
.modifyAttribute(0, statev
, quark
);
355 fixture
.modifyAttribute(50, TmfStateValue
.nullValue(), quark
);
356 fixture
.modifyAttribute(60, statev
, quark
);
357 fixture
.modifyAttribute(100, TmfStateValue
.nullValue(), quark
);
358 // Create the third function
359 quark
= fixture
.getQuarkRelativeAndAdd(parentQuark
, QUARK_2
);
360 statev
= TmfStateValue
.newValueLong(2);
361 fixture
.modifyAttribute(0, statev
, quark
);
362 fixture
.modifyAttribute(10, TmfStateValue
.nullValue(), quark
);
364 statev
= TmfStateValue
.newValueLong(3);
365 fixture
.modifyAttribute(20, statev
, quark
);
366 fixture
.modifyAttribute(30, TmfStateValue
.nullValue(), quark
);
368 statev
= TmfStateValue
.newValueLong(2);
369 fixture
.modifyAttribute(60, statev
, quark
);
370 fixture
.modifyAttribute(90, TmfStateValue
.nullValue(), quark
);
372 quark
= fixture
.getQuarkRelativeAndAdd(parentQuark
, QUARK_3
);
373 statev
= TmfStateValue
.newValueLong(4);
374 fixture
.modifyAttribute(0, statev
, quark
);
375 fixture
.modifyAttribute(10, TmfStateValue
.nullValue(), quark
);
377 fixture
.modifyAttribute(60, statev
, quark
);
378 fixture
.modifyAttribute(80, TmfStateValue
.nullValue(), quark
);
379 fixture
.closeHistory(102);
383 * Test the merge of The callees children. The call stack's structure used
384 * in this test is shown below:
388 * ___ main____ ____ main____
390 * _2_ _3_ _2_ => _2_ _3_
395 public void mergeSecondLevelCalleesTest() {
396 ITmfStateSystemBuilder fixture
= createFixture();
397 buildCallStack(fixture
);
398 // Execute the CallGraphAnalysis
399 CGAnalysis cga
= new CGAnalysis();
401 assertTrue(cga
.iterateOverStateSystem(fixture
, TP
, PP
, CSP
, new NullProgressMonitor()));
402 List
<ThreadNode
> threads
= cga
.getThreadNodes();
403 // Test the threads generated by the analysis
404 assertNotNull(threads
);
405 assertEquals("Number of thread nodes Found", 1, threads
.size());
406 assertEquals("Thread id", -1, threads
.get(0).getId());
407 assertEquals("Thread name", "Thread", threads
.get(0).getSymbol());
408 assertEquals("Number of root functions ", 1, threads
.get(0).getChildren().size());
409 Object
[] children
= threads
.get(0).getChildren().toArray();
410 AggregatedCalledFunction main
= (AggregatedCalledFunction
) children
[0];
411 assertEquals("Children number: main", 1, main
.getChildren().size());
412 Object
[] mainChildren
= main
.getChildren().toArray();
413 AggregatedCalledFunction function1
= (AggregatedCalledFunction
) mainChildren
[0];
414 assertEquals("Children number: first function", 2, function1
.getChildren().size());
415 Object
[] firstFunctionChildren
= function1
.getChildren().toArray();
416 AggregatedCalledFunction function2
= (AggregatedCalledFunction
) firstFunctionChildren
[0];
417 AggregatedCalledFunction function3
= (AggregatedCalledFunction
) firstFunctionChildren
[1];
418 assertEquals("Children number: First child", 1, function2
.getChildren().size());
419 assertEquals("Children number: Second child", 0, function3
.getChildren().size());
420 Object
[] firstChildCallee
= function2
.getChildren().toArray();
421 AggregatedCalledFunction function4
= (AggregatedCalledFunction
) firstChildCallee
[0];
422 assertEquals("Children number: leaf function", 0, function4
.getChildren().size());
424 assertEquals("Test parenthood ", NonNullUtils
.checkNotNull(function1
.getParent()).getSymbol(), main
.getSymbol());
425 assertEquals("Test parenthood ", NonNullUtils
.checkNotNull(function2
.getParent()).getSymbol(), function1
.getSymbol());
426 assertEquals("Test parenthood ", NonNullUtils
.checkNotNull(function3
.getParent()).getSymbol(), function1
.getSymbol());
427 assertEquals("Test parenthood ", NonNullUtils
.checkNotNull(function4
.getParent()).getSymbol(), function2
.getSymbol());
429 assertEquals("Test main's duration", 100, main
.getDuration());
430 assertEquals("Test first function's duration", 90, function1
.getDuration());
431 assertEquals("Test first child's duration", 40, function2
.getDuration());
432 assertEquals("Test second child's duration", 10, function3
.getDuration());
433 assertEquals("Test leaf's duration", 30, function4
.getDuration());
435 assertEquals("Test main's self time", 10, main
.getSelfTime());
436 assertEquals("Test first function's self time", 40, function1
.getSelfTime());
437 assertEquals("Test first child's self time", 10,
438 function2
.getSelfTime());
439 assertEquals("Test second child's self time", 10, function3
.getSelfTime());
440 assertEquals("Test leaf's self time", 30, function4
.getSelfTime());
442 assertEquals("Test main function's depth", 0, main
.getDepth());
443 assertEquals("Test first function's depth", 1, function1
.getDepth());
444 assertEquals("Test first child's depth", 2, function2
.getDepth());
445 assertEquals("Test second child's depth", 2, function3
.getDepth());
446 assertEquals("Test leaf's depth", 3, function4
.getDepth());
447 // Test number of calls
448 assertEquals("Test main's number of calls", 1, main
.getNbCalls());
449 assertEquals("Test first function's number of calls", 2, function1
.getNbCalls());
450 assertEquals("Test first child's number of calls", 2, function2
.getNbCalls());
451 assertEquals("Test second child's number of calls", 1, function3
.getNbCalls());
452 assertEquals("Test leaf's number of calls", 2, function4
.getNbCalls());
456 * Test state system with a large amount of segments. All segments have the
457 * same length. The call stack's structure used in this test is shown below:
467 public void largeTest() {
468 ITmfStateSystemBuilder fixture
= createFixture();
469 int parentQuark
= fixture
.getQuarkAbsoluteAndAdd(PROCESS_PATH
, THREAD_PATH
, CALLSTACK_PATH
);
470 for (int i
= 0; i
< LARGE_AMOUNT_OF_SEGMENTS
; i
++) {
471 TmfStateValue statev
= TmfStateValue
.newValueLong(i
);
472 fixture
.pushAttribute(0, statev
, parentQuark
);
474 for (int i
= 0; i
< LARGE_AMOUNT_OF_SEGMENTS
; i
++) {
475 fixture
.popAttribute(10, parentQuark
);
477 fixture
.closeHistory(11);
478 // Execute the callGraphAnalysis
479 CGAnalysis cga
= new CGAnalysis();
481 assertTrue(cga
.iterateOverStateSystem(fixture
, TP
, PP
, CSP
, new NullProgressMonitor()));
482 List
<ThreadNode
> threads
= cga
.getThreadNodes();
483 // Test the threads generated by the analysis
484 assertNotNull(threads
);
485 assertEquals("Thread id", -1, threads
.get(0).getId());
486 assertEquals("Thread name", "Thread", threads
.get(0).getSymbol());
487 Object
[] children
= threads
.get(0).getChildren().toArray();
488 AggregatedCalledFunction parent
= (AggregatedCalledFunction
) children
[0];
489 for (int i
= 1; i
< LARGE_AMOUNT_OF_SEGMENTS
; i
++) {
490 children
= parent
.getChildren().toArray();
491 AggregatedCalledFunction child
= (AggregatedCalledFunction
) children
[0];
492 assertEquals("Test parenthood", NonNullUtils
.checkNotNull(child
.getParent()).getSymbol(), NonNullUtils
.checkNotNull(parent
.getSymbol()));
498 * Test mutliRoots state system.This tests if a root function called twice
499 * will be merged into one function or not. The call stack's structure used
500 * in this test is shown below:
509 public void multiFunctionRootsTest() {
510 ITmfStateSystemBuilder fixture
= createFixture();
511 int parentQuark
= fixture
.getQuarkAbsoluteAndAdd(PROCESS_PATH
, THREAD_PATH
, CALLSTACK_PATH
);
512 // Create the first root function
513 int quark
= fixture
.getQuarkRelativeAndAdd(parentQuark
, QUARK_0
);
514 TmfStateValue statev
= TmfStateValue
.newValueLong(1);
515 fixture
.modifyAttribute(0, statev
, quark
);
516 fixture
.modifyAttribute(20, TmfStateValue
.nullValue(), quark
);
517 // Create the second root function
518 fixture
.modifyAttribute(30, statev
, quark
);
519 fixture
.modifyAttribute(50, TmfStateValue
.nullValue(), quark
);
520 // Create the first root function's callee
521 quark
= fixture
.getQuarkRelativeAndAdd(parentQuark
, QUARK_1
);
522 statev
= TmfStateValue
.newValueLong(2);
523 fixture
.modifyAttribute(0, statev
, quark
);
524 fixture
.modifyAttribute(10, TmfStateValue
.nullValue(), quark
);
525 // Create the second root function's callee
526 statev
= TmfStateValue
.newValueLong(3);
527 fixture
.modifyAttribute(30, statev
, quark
);
528 fixture
.modifyAttribute(40, TmfStateValue
.nullValue(), quark
);
529 fixture
.closeHistory(51);
531 // Execute the callGraphAnalysis
532 CGAnalysis cga
= new CGAnalysis();
534 assertTrue(cga
.iterateOverStateSystem(fixture
, TP
, PP
, CSP
, new NullProgressMonitor()));
535 List
<ThreadNode
> threads
= cga
.getThreadNodes();
536 // Test the threads generated by the analysis
537 assertNotNull(threads
);
538 assertEquals("Number of thread nodes Found", 1, threads
.size());
539 assertEquals("Thread id", -1, threads
.get(0).getId());
540 assertEquals("Thread name", "Thread", threads
.get(0).getSymbol());
541 assertEquals("Number of root functions ", 1, threads
.get(0).getChildren().size());
542 Object
[] children
= threads
.get(0).getChildren().toArray();
543 AggregatedCalledFunction firstFunction
= (AggregatedCalledFunction
) children
[0];
544 assertEquals("Children number: First function", 2, firstFunction
.getChildren().size());
545 Object
[] firstFunctionChildren
= firstFunction
.getChildren().toArray();
546 AggregatedCalledFunction function2
= (AggregatedCalledFunction
) firstFunctionChildren
[0];
547 AggregatedCalledFunction function3
= (AggregatedCalledFunction
) firstFunctionChildren
[1];
548 assertEquals("Children number: Second function", 0, function2
.getChildren().size());
549 assertEquals("Children number: Third function", 0, function3
.getChildren().size());
551 assertEquals("Test parenthood ", NonNullUtils
.checkNotNull(function2
.getParent()).getSymbol(), firstFunction
.getSymbol());
552 assertEquals("Test parenthood ", NonNullUtils
.checkNotNull(function3
.getParent()).getSymbol(), firstFunction
.getSymbol());
554 assertEquals("Test first function's duration", 40, firstFunction
.getDuration());
555 assertEquals("Test second function's duration", 10, function2
.getDuration());
556 assertEquals("Test third function's duration", 10, function3
.getDuration());
558 assertEquals("Test first function's self time", 20, firstFunction
.getSelfTime());
559 assertEquals("Test second function's self time", 10, function2
.getSelfTime());
560 assertEquals("Test third function's self time", 10, function2
.getSelfTime());
562 assertEquals("Test first function's depth", 0, firstFunction
.getDepth());
563 assertEquals("Test second function's depth", 1, function2
.getDepth());
564 assertEquals("Test third function's depth", 1, function3
.getDepth());
565 // Test number of calls
566 assertEquals("Test first function's number of calls", 2, firstFunction
.getNbCalls());
567 assertEquals("Test second function's number of calls", 1, function2
.getNbCalls());
568 assertEquals("Test third function's number of calls", 1, function3
.getNbCalls());
573 * Test mutliRoots state system. The call stack's structure used in this
574 * test is shown below:
584 public void multiFunctionRootsSecondTest() {
585 ITmfStateSystemBuilder fixture
= createFixture();
586 int parentQuark
= fixture
.getQuarkAbsoluteAndAdd(PROCESS_PATH
, THREAD_PATH
, CALLSTACK_PATH
);
587 // Create the first root function
588 int quark
= fixture
.getQuarkRelativeAndAdd(parentQuark
, QUARK_0
);
589 TmfStateValue statev
= TmfStateValue
.newValueLong(0);
590 fixture
.modifyAttribute(0, statev
, quark
);
591 fixture
.modifyAttribute(20, TmfStateValue
.nullValue(), quark
);
592 // Create the second root function
593 statev
= TmfStateValue
.newValueLong(1);
594 fixture
.modifyAttribute(30, statev
, quark
);
595 fixture
.modifyAttribute(50, TmfStateValue
.nullValue(), quark
);
596 // Create the first root function's callee
597 quark
= fixture
.getQuarkRelativeAndAdd(parentQuark
, QUARK_1
);
598 statev
= TmfStateValue
.newValueLong(2);
599 fixture
.modifyAttribute(0, statev
, quark
);
600 fixture
.modifyAttribute(10, TmfStateValue
.nullValue(), quark
);
601 // Create the second root function's callee
602 fixture
.modifyAttribute(30, statev
, quark
);
603 fixture
.modifyAttribute(40, TmfStateValue
.nullValue(), quark
);
604 fixture
.closeHistory(51);
606 // Execute the callGraphAnalysis
607 CGAnalysis cga
= new CGAnalysis();
609 assertTrue(cga
.iterateOverStateSystem(fixture
, TP
, PP
, CSP
, new NullProgressMonitor()));
610 List
<ThreadNode
> threads
= cga
.getThreadNodes();
611 // Test the threads generated by the analysis
612 assertNotNull(threads
);
613 assertEquals("Number of thread nodes Found", 1, threads
.size());
614 assertEquals("Thread id", -1, threads
.get(0).getId());
615 assertEquals("Thread name", "Thread", threads
.get(0).getSymbol());
616 assertEquals("Number of root functions ", 2, threads
.get(0).getChildren().size());
617 Object
[] children
= threads
.get(0).getChildren().toArray();
618 AggregatedCalledFunction firstFunction
= (AggregatedCalledFunction
) children
[0];
619 AggregatedCalledFunction secondFunction
= (AggregatedCalledFunction
) children
[1];
621 assertEquals("Children number: First function", 1, firstFunction
.getChildren().size());
622 assertEquals("Children number: Second function", 1, secondFunction
.getChildren().size());
623 Object
[] firstFunctionChildren
= firstFunction
.getChildren().toArray();
624 Object
[] secondFunctionChildren
= secondFunction
.getChildren().toArray();
625 AggregatedCalledFunction function3
= (AggregatedCalledFunction
) firstFunctionChildren
[0];
626 AggregatedCalledFunction function4
= (AggregatedCalledFunction
) secondFunctionChildren
[0];
628 assertEquals("Children number: third function", 0, function3
.getChildren().size());
629 assertEquals("Children number: fourth function", 0, function4
.getChildren().size());
631 assertEquals("Test parenthood ", NonNullUtils
.checkNotNull(function3
.getParent()).getSymbol(), firstFunction
.getSymbol());
632 assertEquals("Test parenthood ", NonNullUtils
.checkNotNull(function4
.getParent()).getSymbol(), secondFunction
.getSymbol());
634 assertEquals("Test second function's duration", 20, firstFunction
.getDuration());
635 assertEquals("Test second function's duration", 20, secondFunction
.getDuration());
636 assertEquals("Test first leaf's duration", 10, function3
.getDuration());
637 assertEquals("Test second leaf's duration", 10, function4
.getDuration());
639 assertEquals("Test first function's self time", 10, firstFunction
.getSelfTime());
640 assertEquals("Test second function's duration", 10, secondFunction
.getSelfTime());
641 assertEquals("Test second function's self time", 10, function3
.getSelfTime());
642 assertEquals("Test second function's self time", 10, function4
.getSelfTime());
644 assertEquals("Test first function's depth", 0, firstFunction
.getDepth());
645 assertEquals("Test first function's depth", 0, secondFunction
.getDepth());
646 assertEquals("Test third function's depth", 1, function3
.getDepth());
647 assertEquals("Test third function's depth", 1, function4
.getDepth());
648 // Test number of calls
649 assertEquals("Test first function's number of calls", 1, firstFunction
.getNbCalls());
650 assertEquals("Test first function's number of calls", 1, secondFunction
.getNbCalls());
651 assertEquals("Test third function's number of calls", 1, function3
.getNbCalls());
652 assertEquals("Test third function's number of calls", 1, function4
.getNbCalls());
657 * Gets the call graph analysis
658 * @return the call graph analysis
660 protected CGAnalysis
getCga() {
664 private void setCga(CGAnalysis cga
) {