← Back to branch summary

~ubuntu-branches/ubuntu/trusty/eclipse-linuxtools/trusty

« back to all changes in this revision

Viewing changes to lttng/org.eclipse.linuxtools.lttng2.kernel.ui/src/org/eclipse/linuxtools/internal/lttng2/kernel/ui/views/controlflow/ControlFlowEntry.java

  • Committer: Package Import Robot
  • Author(s): tony mancill
  • Date: 2013-05-13 21:43:22 UTC
  • mfrom: (1.2.1) (2.1.2 experimental)
  • Revision ID: package-import@ubuntu.com-20130513214322-6frgd9du1n0w2uo7
Tags: 1.2.1-1
* Team upload.
* New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lttng/org.eclipse.linuxtools.lttng2.kernel.ui/src/org/eclipse/linuxtools/internal/lttng2/kernel/ui/views/controlflow/ControlFlowEntry.java
1
 
/*******************************************************************************
2
 
 * Copyright (c) 2012 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
 
 *   Patrick Tasse - Initial API and implementation
11
 
 *******************************************************************************/
12
 
 
13
 
package org.eclipse.linuxtools.internal.lttng2.kernel.ui.views.controlflow;
14
 
 
15
 
import java.util.ArrayList;
16
 
import java.util.Iterator;
17
 
import java.util.List;
18
 
 
19
 
import org.eclipse.linuxtools.internal.lttng2.kernel.ui.views.common.EventIterator;
20
 
import org.eclipse.linuxtools.lttng2.kernel.core.trace.CtfKernelTrace;
21
 
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeEvent;
22
 
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;
23
 
 
24
 
public class ControlFlowEntry implements ITimeGraphEntry {
25
 
    private int fThreadQuark;
26
 
    private CtfKernelTrace fTrace;
27
 
    private ControlFlowEntry fParent = null;
28
 
    private ArrayList<ControlFlowEntry> fChildren = new ArrayList<ControlFlowEntry>();
29
 
    private String fName;
30
 
    private int fThreadId;
31
 
    private int fParentThreadId;
32
 
    private long fBirthTime = -1;
33
 
    private long fStartTime = -1;
34
 
    private long fEndTime = -1;
35
 
    private List<ITimeEvent> fEventList = new ArrayList<ITimeEvent>();
36
 
    private List<ITimeEvent> fZoomedEventList = null;
37
 
 
38
 
    public ControlFlowEntry(int threadQuark, CtfKernelTrace trace, String execName, int threadId, int parentThreadId, long birthTime, long startTime, long endTime) {
39
 
        fThreadQuark = threadQuark;
40
 
        fTrace = trace;
41
 
        fName = execName;
42
 
        fThreadId = threadId;
43
 
        fParentThreadId = parentThreadId;
44
 
        fBirthTime = birthTime;
45
 
        fStartTime = startTime;
46
 
        fEndTime = endTime;
47
 
    }
48
 
 
49
 
    @Override
50
 
    public ITimeGraphEntry getParent() {
51
 
        return fParent;
52
 
    }
53
 
 
54
 
    @Override
55
 
    public boolean hasChildren() {
56
 
        return fChildren != null && fChildren.size() > 0;
57
 
    }
58
 
 
59
 
    @Override
60
 
    public ControlFlowEntry[] getChildren() {
61
 
        return fChildren.toArray(new ControlFlowEntry[0]);
62
 
    }
63
 
 
64
 
    @Override
65
 
    public String getName() {
66
 
        return fName;
67
 
    }
68
 
 
69
 
    @Override
70
 
    public long getStartTime() {
71
 
        return fStartTime;
72
 
    }
73
 
 
74
 
    @Override
75
 
    public long getEndTime() {
76
 
        return fEndTime;
77
 
    }
78
 
 
79
 
    @Override
80
 
    public boolean hasTimeEvents() {
81
 
        return true;
82
 
    }
83
 
 
84
 
    @Override
85
 
    public Iterator<ITimeEvent> getTimeEventsIterator() {
86
 
        return new EventIterator(fEventList, fZoomedEventList);
87
 
    }
88
 
 
89
 
    @Override
90
 
    public Iterator<ITimeEvent> getTimeEventsIterator(long startTime, long stopTime, long visibleDuration) {
91
 
        return new EventIterator(fEventList, fZoomedEventList, startTime, stopTime);
92
 
    }
93
 
 
94
 
    public int getThreadQuark() {
95
 
        return fThreadQuark;
96
 
    }
97
 
 
98
 
    public CtfKernelTrace getTrace() {
99
 
        return fTrace;
100
 
    }
101
 
 
102
 
    public int getThreadId() {
103
 
        return fThreadId;
104
 
    }
105
 
 
106
 
    public int getParentThreadId() {
107
 
        return fParentThreadId;
108
 
    }
109
 
 
110
 
    public long getBirthTime() {
111
 
        return fBirthTime;
112
 
    }
113
 
 
114
 
    public void addEvent(ITimeEvent event) {
115
 
        long start = event.getTime();
116
 
        long end = start + event.getDuration();
117
 
        synchronized (fEventList) {
118
 
            fEventList.add(event);
119
 
            if (fStartTime == -1 || start < fStartTime) {
120
 
                fStartTime = start;
121
 
            }
122
 
            if (fEndTime == -1 || end > fEndTime) {
123
 
                fEndTime = end;
124
 
            }
125
 
        }
126
 
    }
127
 
 
128
 
    public void setEventList(List<ITimeEvent> eventList) {
129
 
        fEventList = eventList;
130
 
    }
131
 
 
132
 
    public void setZoomedEventList(List<ITimeEvent> eventList) {
133
 
        fZoomedEventList = eventList;
134
 
    }
135
 
 
136
 
    public void addChild(ControlFlowEntry child) {
137
 
        child.fParent = this;
138
 
        fChildren.add(child);
139
 
    }
140
 
}
 
1
/*******************************************************************************
 
2
 * Copyright (c) 2012 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
 *   Patrick Tasse - Initial API and implementation
 
11
 *******************************************************************************/
 
12
 
 
13
package org.eclipse.linuxtools.internal.lttng2.kernel.ui.views.controlflow;
 
14
 
 
15
import java.util.ArrayList;
 
16
import java.util.Iterator;
 
17
import java.util.List;
 
18
 
 
19
import org.eclipse.linuxtools.internal.lttng2.kernel.ui.views.common.EventIterator;
 
20
import org.eclipse.linuxtools.lttng2.kernel.core.trace.CtfKernelTrace;
 
21
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeEvent;
 
22
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;
 
23
 
 
24
/**
 
25
 * An entry in the Control Flow view
 
26
 */
 
27
public class ControlFlowEntry implements ITimeGraphEntry {
 
28
    private final int fThreadQuark;
 
29
    private final CtfKernelTrace fTrace;
 
30
    private ControlFlowEntry fParent = null;
 
31
    private final ArrayList<ControlFlowEntry> fChildren = new ArrayList<ControlFlowEntry>();
 
32
    private final String fName;
 
33
    private final int fThreadId;
 
34
    private final int fParentThreadId;
 
35
    private long fBirthTime = -1;
 
36
    private long fStartTime = -1;
 
37
    private long fEndTime = -1;
 
38
    private List<ITimeEvent> fEventList = new ArrayList<ITimeEvent>();
 
39
    private List<ITimeEvent> fZoomedEventList = null;
 
40
 
 
41
    /**
 
42
     * Constructor
 
43
     *
 
44
     * @param threadQuark
 
45
     *            The attribute quark matching the thread
 
46
     * @param trace
 
47
     *            The trace on which we are working
 
48
     * @param execName
 
49
     *            The exec_name of this entry
 
50
     * @param threadId
 
51
     *            The TID of the thread
 
52
     * @param parentThreadId
 
53
     *            the Parent_TID of this thread
 
54
     * @param birthTime
 
55
     *            The birth time of this entry (this allows separating different
 
56
     *            process that could have the same TID)
 
57
     * @param startTime
 
58
     *            The start time of this process's lifetime
 
59
     * @param endTime
 
60
     *            The end time of this process
 
61
     */
 
62
    public ControlFlowEntry(int threadQuark, CtfKernelTrace trace, String execName, int threadId, int parentThreadId, long birthTime, long startTime, long endTime) {
 
63
        fThreadQuark = threadQuark;
 
64
        fTrace = trace;
 
65
        fName = execName;
 
66
        fThreadId = threadId;
 
67
        fParentThreadId = parentThreadId;
 
68
        fBirthTime = birthTime;
 
69
        fStartTime = startTime;
 
70
        fEndTime = endTime;
 
71
    }
 
72
 
 
73
    @Override
 
74
    public ITimeGraphEntry getParent() {
 
75
        return fParent;
 
76
    }
 
77
 
 
78
    @Override
 
79
    public boolean hasChildren() {
 
80
        return fChildren != null && fChildren.size() > 0;
 
81
    }
 
82
 
 
83
    @Override
 
84
    public ControlFlowEntry[] getChildren() {
 
85
        return fChildren.toArray(new ControlFlowEntry[0]);
 
86
    }
 
87
 
 
88
    @Override
 
89
    public String getName() {
 
90
        return fName;
 
91
    }
 
92
 
 
93
    @Override
 
94
    public long getStartTime() {
 
95
        return fStartTime;
 
96
    }
 
97
 
 
98
    @Override
 
99
    public long getEndTime() {
 
100
        return fEndTime;
 
101
    }
 
102
 
 
103
    @Override
 
104
    public boolean hasTimeEvents() {
 
105
        return true;
 
106
    }
 
107
 
 
108
    @Override
 
109
    public Iterator<ITimeEvent> getTimeEventsIterator() {
 
110
        return new EventIterator(fEventList, fZoomedEventList);
 
111
    }
 
112
 
 
113
    @Override
 
114
    public Iterator<ITimeEvent> getTimeEventsIterator(long startTime, long stopTime, long visibleDuration) {
 
115
        return new EventIterator(fEventList, fZoomedEventList, startTime, stopTime);
 
116
    }
 
117
 
 
118
    /**
 
119
     * Get the quark of the attribute matching this thread's TID
 
120
     *
 
121
     * @return The quark
 
122
     */
 
123
    public int getThreadQuark() {
 
124
        return fThreadQuark;
 
125
    }
 
126
 
 
127
    /**
 
128
     * Get the CTF trace object
 
129
     *
 
130
     * @return The trace
 
131
     */
 
132
    public CtfKernelTrace getTrace() {
 
133
        return fTrace;
 
134
    }
 
135
 
 
136
    /**
 
137
     * Get this entry's thread ID
 
138
     *
 
139
     * @return The TID
 
140
     */
 
141
    public int getThreadId() {
 
142
        return fThreadId;
 
143
    }
 
144
 
 
145
    /**
 
146
     * Get this thread's parent TID
 
147
     *
 
148
     * @return The "PTID"
 
149
     */
 
150
    public int getParentThreadId() {
 
151
        return fParentThreadId;
 
152
    }
 
153
 
 
154
    /**
 
155
     * Get the birth time of this entry/process
 
156
     *
 
157
     * @return The birth time
 
158
     */
 
159
    public long getBirthTime() {
 
160
        return fBirthTime;
 
161
    }
 
162
 
 
163
    /**
 
164
     * Add an event to this process's timeline
 
165
     *
 
166
     * @param event
 
167
     *            The time event
 
168
     */
 
169
    public void addEvent(ITimeEvent event) {
 
170
        long start = event.getTime();
 
171
        long end = start + event.getDuration();
 
172
        synchronized (fEventList) {
 
173
            fEventList.add(event);
 
174
            if (fStartTime == -1 || start < fStartTime) {
 
175
                fStartTime = start;
 
176
            }
 
177
            if (fEndTime == -1 || end > fEndTime) {
 
178
                fEndTime = end;
 
179
            }
 
180
        }
 
181
    }
 
182
 
 
183
    /**
 
184
     * Set the general event list of this entry
 
185
     *
 
186
     * @param eventList
 
187
     *            The list of time events
 
188
     */
 
189
    public void setEventList(List<ITimeEvent> eventList) {
 
190
        fEventList = eventList;
 
191
    }
 
192
 
 
193
    /**
 
194
     * Set the zoomed event list of this entry
 
195
     *
 
196
     * @param eventList
 
197
     *            The list of time events
 
198
     */
 
199
    public void setZoomedEventList(List<ITimeEvent> eventList) {
 
200
        fZoomedEventList = eventList;
 
201
    }
 
202
 
 
203
    /**
 
204
     * Add a child entry to this one (to show relationships between processes as
 
205
     * a tree)
 
206
     *
 
207
     * @param child
 
208
     *            The child entry
 
209
     */
 
210
    public void addChild(ControlFlowEntry child) {
 
211
        child.fParent = this;
 
212
        fChildren.add(child);
 
213
    }
 
214
}