← Back to branch summary

~ubuntu-branches/ubuntu/wily/eclipse-linuxtools/wily

« back to all changes in this revision

Viewing changes to lttng/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/internal/tmf/core/statesystem/backends/historytree/CoreNode.java

  • Committer: Package Import Robot
  • Author(s): Jakub Adam, Jakub Adam, tony mancill
  • Date: 2014-10-11 11:44:05 UTC
  • mfrom: (1.2.4)
  • Revision ID: package-import@ubuntu.com-20141011114405-yazjvxfzzhmi5sgj
Tags: 3.1.0-1
http://bugs.debian.org/761524
[ Jakub Adam ]
* New upstream release (Closes: #761524).
* Refreshed d/patches.
* Don't build removed feature org.eclipse.linuxtools.tools.launch
  - merged into org.eclipse.linuxtools.profiling.
* Use javac target 1.7.
* Build new feature org.eclipse.linuxtools.dataviewers.feature
  - required by Valgrind integration.
* Build-depend on eclipse-remote-services-api and eclipse-cdt-autotools.
* Bump Standards-Version to 3.9.6.
* Override incompatible-java-bytecode-format - linuxtools needs Java 7.
* Remove unused codeless-jar override.

[ tony mancill ]
* Tweak short package description to make lintian happy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lttng/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/internal/tmf/core/statesystem/backends/historytree/CoreNode.java
1
 
/*******************************************************************************
2
 
 * Copyright (c) 2012, 2013 Ericsson
3
 
 * Copyright (c) 2010, 2011 École Polytechnique de Montréal
4
 
 * Copyright (c) 2010, 2011 Alexandre Montplaisir <alexandre.montplaisir@gmail.com>
5
 
 *
6
 
 * All rights reserved. This program and the accompanying materials are
7
 
 * made available under the terms of the Eclipse Public License v1.0 which
8
 
 * accompanies this distribution, and is available at
9
 
 * http://www.eclipse.org/legal/epl-v10.html
10
 
 *
11
 
 *******************************************************************************/
12
 
 
13
 
package org.eclipse.linuxtools.internal.tmf.core.statesystem.backends.historytree;
14
 
 
15
 
import java.nio.ByteBuffer;
16
 
 
17
 
/**
18
 
 * A Core node is a first-level node of a History Tree which is not a leaf node.
19
 
 *
20
 
 * It extends HTNode by adding support for child nodes, and also extensions.
21
 
 *
22
 
 * @author alexmont
23
 
 *
24
 
 */
25
 
class CoreNode extends HTNode {
26
 
 
27
 
    /** Number of bytes in a int */
28
 
    private static final int SIZE_INT = 4;
29
 
 
30
 
    /** Number of bytes in a long */
31
 
    private static final int SIZE_LONG = 8;
32
 
 
33
 
    /** Nb. of children this node has */
34
 
    private int nbChildren;
35
 
 
36
 
    /** Seq. numbers of the children nodes (size = MAX_NB_CHILDREN) */
37
 
    private int[] children;
38
 
 
39
 
    /** Start times of each of the children (size = MAX_NB_CHILDREN) */
40
 
    private long[] childStart;
41
 
 
42
 
    /** Seq number of this node's extension. -1 if none */
43
 
    private int extension;
44
 
 
45
 
    /**
46
 
     * Initial constructor. Use this to initialize a new EMPTY node.
47
 
     *
48
 
     * @param tree
49
 
     *            The HistoryTree to which this node belongs
50
 
     * @param seqNumber
51
 
     *            The (unique) sequence number assigned to this particular node
52
 
     * @param parentSeqNumber
53
 
     *            The sequence number of this node's parent node
54
 
     * @param start
55
 
     *            The earliest timestamp stored in this node
56
 
     */
57
 
    CoreNode(HistoryTree tree, int seqNumber, int parentSeqNumber,
58
 
            long start) {
59
 
        super(tree, seqNumber, parentSeqNumber, start);
60
 
        this.nbChildren = 0;
61
 
        int size = getTree().getConfig().getMaxChildren();
62
 
 
63
 
        /*
64
 
         * We instantiate the two following arrays at full size right away,
65
 
         * since we want to reserve that space in the node's header.
66
 
         * "this.nbChildren" will tell us how many relevant entries there are in
67
 
         * those tables.
68
 
         */
69
 
        this.children = new int[size];
70
 
        this.childStart = new long[size];
71
 
    }
72
 
 
73
 
    @Override
74
 
    protected void readSpecificHeader(ByteBuffer buffer) {
75
 
        int size = getTree().getConfig().getMaxChildren();
76
 
 
77
 
        extension = buffer.getInt();
78
 
        nbChildren = buffer.getInt();
79
 
 
80
 
        children = new int[size];
81
 
        for (int i = 0; i < nbChildren; i++) {
82
 
            children[i] = buffer.getInt();
83
 
        }
84
 
        for (int i = nbChildren; i < size; i++) {
85
 
            buffer.getInt();
86
 
        }
87
 
 
88
 
        this.childStart = new long[size];
89
 
        for (int i = 0; i < nbChildren; i++) {
90
 
            childStart[i] = buffer.getLong();
91
 
        }
92
 
        for (int i = nbChildren; i < size; i++) {
93
 
            buffer.getLong();
94
 
        }
95
 
    }
96
 
 
97
 
    @Override
98
 
    protected void writeSpecificHeader(ByteBuffer buffer) {
99
 
        int size = getTree().getConfig().getMaxChildren();
100
 
 
101
 
        buffer.putInt(extension);
102
 
        buffer.putInt(nbChildren);
103
 
 
104
 
        /* Write the "children's seq number" array */
105
 
        for (int i = 0; i < nbChildren; i++) {
106
 
            buffer.putInt(children[i]);
107
 
        }
108
 
        for (int i = nbChildren; i < size; i++) {
109
 
            buffer.putInt(0);
110
 
        }
111
 
 
112
 
        /* Write the "children's start times" array */
113
 
        for (int i = 0; i < nbChildren; i++) {
114
 
            buffer.putLong(childStart[i]);
115
 
        }
116
 
        for (int i = nbChildren; i < size; i++) {
117
 
            buffer.putLong(0);
118
 
        }
119
 
    }
120
 
 
121
 
    int getNbChildren() {
122
 
        return nbChildren;
123
 
    }
124
 
 
125
 
    int getChild(int index) {
126
 
        return children[index];
127
 
    }
128
 
 
129
 
    int getLatestChild() {
130
 
        return children[nbChildren - 1];
131
 
    }
132
 
 
133
 
    long getChildStart(int index) {
134
 
        return childStart[index];
135
 
    }
136
 
 
137
 
    long getLatestChildStart() {
138
 
        return childStart[nbChildren - 1];
139
 
    }
140
 
 
141
 
    int getExtensionSequenceNumber() {
142
 
        return extension;
143
 
    }
144
 
 
145
 
    /**
146
 
     * Tell this node that it has a new child (Congrats!)
147
 
     *
148
 
     * @param childNode
149
 
     *            The SHTNode object of the new child
150
 
     */
151
 
    void linkNewChild(CoreNode childNode) {
152
 
        assert (this.nbChildren < getTree().getConfig().getMaxChildren());
153
 
 
154
 
        this.children[nbChildren] = childNode.getSequenceNumber();
155
 
        this.childStart[nbChildren] = childNode.getNodeStart();
156
 
        this.nbChildren++;
157
 
    }
158
 
 
159
 
    @Override
160
 
    protected byte getNodeType() {
161
 
        return 1;
162
 
    }
163
 
 
164
 
    @Override
165
 
    protected int getTotalHeaderSize() {
166
 
        int maxChildren = getTree().getConfig().getMaxChildren();
167
 
        int specificSize =
168
 
                  SIZE_INT /* 1x int (extension node) */
169
 
                + SIZE_INT /* 1x int (nbChildren) */
170
 
 
171
 
                /* MAX_NB * int ('children' table) */
172
 
                + SIZE_INT * maxChildren
173
 
 
174
 
                /* MAX_NB * Timevalue ('childStart' table) */
175
 
                + SIZE_LONG * maxChildren;
176
 
 
177
 
        return COMMON_HEADER_SIZE + specificSize;
178
 
    }
179
 
 
180
 
    @Override
181
 
    protected String toStringSpecific() {
182
 
        /* Only used for debugging, shouldn't be externalized */
183
 
        return "Core Node, " + nbChildren + " children, "; //$NON-NLS-1$ //$NON-NLS-2$
184
 
    }
185
 
 
186
 
}