}
}
+ /**
+ * <pre>
+ * 1 - byte (type)
+ * 16 - 2x long (start time, end time)
+ * 16 - 4x int (seq number, parent seq number, intervalcount,
+ * strings section pos.)
+ * 1 - byte (done or not)
+ * </pre>
+ */
+ private static final int COMMON_HEADER_SIZE = 34;
+
// ------------------------------------------------------------------------
// Attributes
// ------------------------------------------------------------------------
/* Configuration of the History Tree to which belongs this node */
- private final HTConfig config;
+ private final HTConfig fConfig;
/* Time range of this node */
- private final long nodeStart;
- private long nodeEnd;
+ private final long fNodeStart;
+ private long fNodeEnd;
/* Sequence number = position in the node section of the file */
- private final int sequenceNumber;
- private int parentSequenceNumber; /* = -1 if this node is the root node */
+ private final int fSequenceNumber;
+ private int fParentSequenceNumber; /* = -1 if this node is the root node */
/* Where the Strings section begins (from the start of the node */
- private int stringSectionOffset;
+ private int fStringSectionOffset;
/* Sum of bytes of all intervals in the node */
- private int sizeOfIntervalSection;
+ private int fSizeOfIntervalSection;
/* True if this node was read from disk (meaning its end time is now fixed) */
- private volatile boolean isOnDisk;
+ private volatile boolean fIsOnDisk;
/* Vector containing all the intervals contained in this node */
- private final List<HTInterval> intervals;
+ private final List<HTInterval> fIntervals;
/* Lock used to protect the accesses to intervals, nodeEnd and such */
- private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock(false);
+ private final ReentrantReadWriteLock fRwl = new ReentrantReadWriteLock(false);
/**
* Constructor
* The earliest timestamp stored in this node
*/
protected HTNode(HTConfig config, int seqNumber, int parentSeqNumber, long start) {
- this.config = config;
- this.nodeStart = start;
- this.sequenceNumber = seqNumber;
- this.parentSequenceNumber = parentSeqNumber;
-
- this.stringSectionOffset = config.getBlockSize();
- this.sizeOfIntervalSection = 0;
- this.isOnDisk = false;
- this.intervals = new ArrayList<>();
+ fConfig = config;
+ fNodeStart = start;
+ fSequenceNumber = seqNumber;
+ fParentSequenceNumber = parentSeqNumber;
+
+ fStringSectionOffset = config.getBlockSize();
+ fSizeOfIntervalSection = 0;
+ fIsOnDisk = false;
+ fIntervals = new ArrayList<>();
}
/**
*/
for (i = 0; i < intervalCount; i++) {
HTInterval interval = HTInterval.readFrom(buffer);
- newNode.intervals.add(interval);
- newNode.sizeOfIntervalSection += interval.getIntervalSize();
+ newNode.fIntervals.add(interval);
+ newNode.fSizeOfIntervalSection += interval.getIntervalSize();
}
/* Assign the node's other information we have read previously */
- newNode.nodeEnd = end;
- newNode.stringSectionOffset = stringSectionOffset;
- newNode.isOnDisk = true;
+ newNode.fNodeEnd = end;
+ newNode.fStringSectionOffset = stringSectionOffset;
+ newNode.fIsOnDisk = true;
return newNode;
}
* Yes, we are taking the *read* lock here, because we are reading the
* information in the node to write it to disk.
*/
- rwl.readLock().lock();
+ fRwl.readLock().lock();
try {
- final int blockSize = config.getBlockSize();
+ final int blockSize = fConfig.getBlockSize();
int curStringsEntryEndPos = blockSize;
ByteBuffer buffer = ByteBuffer.allocate(blockSize);
buffer.clear();
/* Write the common header part */
- buffer.put(this.getNodeType().toByte());
- buffer.putLong(nodeStart);
- buffer.putLong(nodeEnd);
- buffer.putInt(sequenceNumber);
- buffer.putInt(parentSequenceNumber);
- buffer.putInt(intervals.size());
- buffer.putInt(stringSectionOffset);
+ buffer.put(getNodeType().toByte());
+ buffer.putLong(fNodeStart);
+ buffer.putLong(fNodeEnd);
+ buffer.putInt(fSequenceNumber);
+ buffer.putInt(fParentSequenceNumber);
+ buffer.putInt(fIntervals.size());
+ buffer.putInt(fStringSectionOffset);
buffer.put((byte) 1); // TODO Used to be "isDone", to be removed from header
/* Now call the inner method to write the specific header part */
- this.writeSpecificHeader(buffer);
+ writeSpecificHeader(buffer);
/* Back to us, we write the intervals */
- for (HTInterval interval : intervals) {
+ for (HTInterval interval : fIntervals) {
int size = interval.writeInterval(buffer, curStringsEntryEndPos);
curStringsEntryEndPos -= size;
}
* of the Strings section (needed to fill the node in case there is
* no Strings section)
*/
- while (buffer.position() < stringSectionOffset) {
+ while (buffer.position() < fStringSectionOffset) {
buffer.put((byte) 0);
}
* If the offsets were right, the size of the Strings section should
* be == to the expected size
*/
- assert (curStringsEntryEndPos == stringSectionOffset);
+ assert (curStringsEntryEndPos == fStringSectionOffset);
/* Finally, write everything in the Buffer to disk */
assert (res == blockSize);
} finally {
- rwl.readLock().unlock();
+ fRwl.readLock().unlock();
}
- isOnDisk = true;
+ fIsOnDisk = true;
}
// ------------------------------------------------------------------------
* @return The history tree config
*/
protected HTConfig getConfig() {
- return config;
+ return fConfig;
}
/**
* @return The start time of this node
*/
public long getNodeStart() {
- return nodeStart;
+ return fNodeStart;
}
/**
* @return The end time of this node
*/
public long getNodeEnd() {
- if (this.isOnDisk) {
- return nodeEnd;
+ if (fIsOnDisk) {
+ return fNodeEnd;
}
return 0;
}
* @return The sequence number of this node
*/
public int getSequenceNumber() {
- return sequenceNumber;
+ return fSequenceNumber;
}
/**
* @return The parent sequence number
*/
public int getParentSequenceNumber() {
- return parentSequenceNumber;
+ return fParentSequenceNumber;
}
/**
* The sequence number of the node that is the new parent
*/
public void setParentSequenceNumber(int newParent) {
- parentSequenceNumber = newParent;
+ fParentSequenceNumber = newParent;
}
/**
* @return If this node is done or not
*/
public boolean isOnDisk() {
- return isOnDisk;
+ return fIsOnDisk;
}
/**
* Interval to add to this node
*/
public void addInterval(HTInterval newInterval) {
- rwl.writeLock().lock();
+ fRwl.writeLock().lock();
try {
/* Just in case, should be checked before even calling this function */
- assert (newInterval.getIntervalSize() <= this.getNodeFreeSpace());
+ assert (newInterval.getIntervalSize() <= getNodeFreeSpace());
/* Find the insert position to keep the list sorted */
- int index = intervals.size();
- while (index > 0 && newInterval.compareTo(intervals.get(index - 1)) < 0) {
+ int index = fIntervals.size();
+ while (index > 0 && newInterval.compareTo(fIntervals.get(index - 1)) < 0) {
index--;
}
- intervals.add(index, newInterval);
- sizeOfIntervalSection += newInterval.getIntervalSize();
+ fIntervals.add(index, newInterval);
+ fSizeOfIntervalSection += newInterval.getIntervalSize();
/* Update the in-node offset "pointer" */
- stringSectionOffset -= (newInterval.getStringsEntrySize());
+ fStringSectionOffset -= (newInterval.getStringsEntrySize());
} finally {
- rwl.writeLock().unlock();
+ fRwl.writeLock().unlock();
}
}
* The nodeEnd time that the node will have
*/
public void closeThisNode(long endtime) {
- rwl.writeLock().lock();
+ fRwl.writeLock().lock();
try {
- assert (endtime >= this.nodeStart);
+ assert (endtime >= fNodeStart);
- if (!intervals.isEmpty()) {
+ if (!fIntervals.isEmpty()) {
/*
* Make sure there are no intervals in this node with their
* EndTime > the one requested. Only need to check the last one
* since they are sorted
*/
- assert (endtime >= intervals.get(intervals.size() - 1).getEndTime());
+ assert (endtime >= fIntervals.get(fIntervals.size() - 1).getEndTime());
}
- this.nodeEnd = endtime;
+ fNodeEnd = endtime;
} finally {
- rwl.writeLock().unlock();
+ fRwl.writeLock().unlock();
}
}
public void writeInfoFromNode(List<ITmfStateInterval> stateInfo, long t)
throws TimeRangeException {
/* This is from a state system query, we are "reading" this node */
- rwl.readLock().lock();
+ fRwl.readLock().lock();
try {
- for (int i = getStartIndexFor(t); i < intervals.size(); i++) {
+ for (int i = getStartIndexFor(t); i < fIntervals.size(); i++) {
/*
* Now we only have to compare the Start times, since we now the
* End times necessarily fit.
* been created after stateInfo was instantiated (they would be
* null anyway).
*/
- ITmfStateInterval interval = intervals.get(i);
+ ITmfStateInterval interval = fIntervals.get(i);
if (interval.getStartTime() <= t &&
interval.getAttribute() < stateInfo.size()) {
stateInfo.set(interval.getAttribute(), interval);
}
}
} finally {
- rwl.readLock().unlock();
+ fRwl.readLock().unlock();
}
}
* If 't' is invalid
*/
public HTInterval getRelevantInterval(int key, long t) throws TimeRangeException {
- rwl.readLock().lock();
+ fRwl.readLock().lock();
try {
- for (int i = getStartIndexFor(t); i < intervals.size(); i++) {
- HTInterval curInterval = intervals.get(i);
+ for (int i = getStartIndexFor(t); i < fIntervals.size(); i++) {
+ HTInterval curInterval = fIntervals.get(i);
if (curInterval.getAttribute() == key
&& curInterval.getStartTime() <= t
&& curInterval.getEndTime() >= t) {
return null;
} finally {
- rwl.readLock().unlock();
+ fRwl.readLock().unlock();
}
}
private int getStartIndexFor(long t) throws TimeRangeException {
/* Should only be called by methods with the readLock taken */
- if (intervals.isEmpty()) {
+ if (fIntervals.isEmpty()) {
return 0;
}
/*
* provides a .binarySearch method, but its API is quite weird...
*/
HTInterval dummy = new HTInterval(0, t, 0, TmfStateValue.nullValue());
- int index = Collections.binarySearch(intervals, dummy);
+ int index = Collections.binarySearch(fIntervals, dummy);
if (index < 0) {
/*
if (index < 0) {
index = 0;
}
- if (index >= intervals.size()) {
- index = intervals.size() - 1;
+ if (index >= fIntervals.size()) {
+ index = fIntervals.size() - 1;
}
/*
* again.
*/
while (index > 0
- && intervals.get(index - 1).compareTo(intervals.get(index)) == 0) {
+ && fIntervals.get(index - 1).compareTo(fIntervals.get(index)) == 0) {
index--;
}
return index;
}
- /**
- * <pre>
- * 1 - byte (type)
- * 16 - 2x long (start time, end time)
- * 16 - 4x int (seq number, parent seq number, intervalcount,
- * strings section pos.)
- * 1 - byte (done or not)
- * </pre>
- */
- private static final int COMMON_HEADER_SIZE = 34;
-
/**
* Return the total header size of this node (will depend on the node type).
*
* @return The offset, within the node, where the Data section ends
*/
private int getDataSectionEndOffset() {
- return this.getTotalHeaderSize() + sizeOfIntervalSection;
+ return getTotalHeaderSize() + fSizeOfIntervalSection;
}
/**
* @return The amount of free space in the node (in bytes)
*/
public int getNodeFreeSpace() {
- rwl.readLock().lock();
- int ret = stringSectionOffset - this.getDataSectionEndOffset();
- rwl.readLock().unlock();
+ fRwl.readLock().lock();
+ int ret = fStringSectionOffset - getDataSectionEndOffset();
+ fRwl.readLock().unlock();
return ret;
}
* in this node.
*/
public long getNodeUsagePercent() {
- rwl.readLock().lock();
+ fRwl.readLock().lock();
try {
- final int blockSize = config.getBlockSize();
- float freePercent = (float) this.getNodeFreeSpace()
- / (float) (blockSize - this.getTotalHeaderSize())
+ final int blockSize = fConfig.getBlockSize();
+ float freePercent = (float) getNodeFreeSpace()
+ / (float) (blockSize - getTotalHeaderSize())
* 100F;
return (long) (100L - freePercent);
} finally {
- rwl.readLock().unlock();
+ fRwl.readLock().unlock();
}
}
@Override
public String toString() {
/* Only used for debugging, shouldn't be externalized */
- StringBuffer buf = new StringBuffer("Node #" + sequenceNumber + ", ");
- buf.append(this.toStringSpecific());
- buf.append(intervals.size() + " intervals (" + this.getNodeUsagePercent()
+ StringBuffer buf = new StringBuffer("Node #" + fSequenceNumber + ", ");
+ buf.append(toStringSpecific());
+ buf.append(fIntervals.size() + " intervals (" + getNodeUsagePercent()
+ "% used), ");
- buf.append("[" + this.nodeStart + " - ");
- if (this.isOnDisk) {
- buf = buf.append("" + this.nodeEnd + "]");
+ buf.append("[" + fNodeStart + " - ");
+ if (fIsOnDisk) {
+ buf = buf.append("" + fNodeEnd + "]");
} else {
buf = buf.append("...]");
}
@SuppressWarnings("nls")
public void debugPrintIntervals(PrintWriter writer) {
/* Only used for debugging, shouldn't be externalized */
- writer.println("Node #" + sequenceNumber + ":");
+ writer.println("Node #" + fSequenceNumber + ":");
/* Array of children */
- if (this.getNodeType() == NodeType.CORE) { /* Only Core Nodes can have children */
+ if (getNodeType() == NodeType.CORE) { /* Only Core Nodes can have children */
CoreNode thisNode = (CoreNode) this;
writer.print(" " + thisNode.getNbChildren() + " children");
if (thisNode.getNbChildren() >= 1) {
/* List of intervals in the node */
writer.println(" Intervals contained:");
- for (int i = 0; i < intervals.size(); i++) {
- writer.println(intervals.get(i).toString());
+ for (int i = 0; i < fIntervals.size(); i++) {
+ writer.println(fIntervals.get(i).toString());
}
writer.println('\n');
}
// ------------------------------------------------------------------------
/** Container for all the configuration constants */
- private final HTConfig config;
+ private final HTConfig fConfig;
/** Reader/writer object */
- private final HT_IO treeIO;
+ private final HT_IO fTreeIO;
// ------------------------------------------------------------------------
// Variable Fields (will change throughout the existence of the SHT)
// ------------------------------------------------------------------------
/** Latest timestamp found in the tree (at any given moment) */
- private long treeEnd;
+ private long fTreeEnd;
/** The total number of nodes that exists in this tree */
- private int nodeCount;
+ private int fNodeCount;
/** "Cache" to keep the active nodes in memory */
- private final List<HTNode> latestBranch;
+ private final List<HTNode> fLatestBranch;
// ------------------------------------------------------------------------
// Constructors/"Destructors"
throw new IllegalArgumentException();
}
- config = conf;
- treeEnd = conf.getTreeStart();
- nodeCount = 0;
- latestBranch = Collections.synchronizedList(new ArrayList<HTNode>());
+ fConfig = conf;
+ fTreeEnd = conf.getTreeStart();
+ fNodeCount = 0;
+ fLatestBranch = Collections.synchronizedList(new ArrayList<HTNode>());
/* Prepare the IO object */
- treeIO = new HT_IO(config, true);
+ fTreeIO = new HT_IO(fConfig, true);
/* Add the first node to the tree */
LeafNode firstNode = initNewLeafNode(-1, conf.getTreeStart());
- latestBranch.add(firstNode);
+ fLatestBranch.add(firstNode);
}
/**
bs = buffer.getInt(); /* Block Size */
maxc = buffer.getInt(); /* Max nb of children per node */
- this.nodeCount = buffer.getInt();
+ fNodeCount = buffer.getInt();
rootNodeSeqNb = buffer.getInt();
startTime = buffer.getLong();
- this.config = new HTConfig(existingStateFile, bs, maxc, expProviderVersion, startTime);
+ fConfig = new HTConfig(existingStateFile, bs, maxc, expProviderVersion, startTime);
}
/*
* file, not extremely elegant. But how to pass the information here to
* the SHT otherwise?
*/
- this.treeIO = new HT_IO(config, false);
+ fTreeIO = new HT_IO(fConfig, false);
- this.latestBranch = buildLatestBranch(rootNodeSeqNb);
- this.treeEnd = getRootNode().getNodeEnd();
+ fLatestBranch = buildLatestBranch(rootNodeSeqNb);
+ fTreeEnd = getRootNode().getNodeEnd();
/*
* Make sure the history start time we read previously is consistent
private List<HTNode> buildLatestBranch(int rootNodeSeqNb) throws ClosedChannelException {
List<HTNode> list = new ArrayList<>();
- HTNode nextChildNode = treeIO.readNode(rootNodeSeqNb);
+ HTNode nextChildNode = fTreeIO.readNode(rootNodeSeqNb);
list.add(nextChildNode);
/* Follow the last branch up to the leaf */
while (nextChildNode.getNodeType() == HTNode.NodeType.CORE) {
- nextChildNode = treeIO.readNode(((CoreNode) nextChildNode).getLatestChild());
+ nextChildNode = fTreeIO.readNode(((CoreNode) nextChildNode).getLatestChild());
list.add(nextChildNode);
}
return Collections.synchronizedList(list);
*/
public void closeTree(long requestedEndTime) {
/* This is an important operation, queries can wait */
- synchronized (latestBranch) {
+ synchronized (fLatestBranch) {
/*
* Work-around the "empty branches" that get created when the root
* node becomes full. Overwrite the tree's end time with the
*
* This won't be needed once extended nodes are implemented.
*/
- this.treeEnd = requestedEndTime;
+ fTreeEnd = requestedEndTime;
/* Close off the latest branch of the tree */
- for (int i = 0; i < latestBranch.size(); i++) {
- latestBranch.get(i).closeThisNode(treeEnd);
- treeIO.writeNode(latestBranch.get(i));
+ for (int i = 0; i < fLatestBranch.size(); i++) {
+ fLatestBranch.get(i).closeThisNode(fTreeEnd);
+ fTreeIO.writeNode(fLatestBranch.get(i));
}
- try (FileChannel fc = treeIO.getFcOut();) {
+ try (FileChannel fc = fTreeIO.getFcOut();) {
ByteBuffer buffer = ByteBuffer.allocate(TREE_HEADER_SIZE);
buffer.order(ByteOrder.LITTLE_ENDIAN);
buffer.clear();
buffer.putInt(HISTORY_FILE_MAGIC_NUMBER);
buffer.putInt(FILE_VERSION);
- buffer.putInt(config.getProviderVersion());
+ buffer.putInt(fConfig.getProviderVersion());
- buffer.putInt(config.getBlockSize());
- buffer.putInt(config.getMaxChildren());
+ buffer.putInt(fConfig.getBlockSize());
+ buffer.putInt(fConfig.getMaxChildren());
- buffer.putInt(nodeCount);
+ buffer.putInt(fNodeCount);
/* root node seq. nb */
- buffer.putInt(latestBranch.get(0).getSequenceNumber());
+ buffer.putInt(fLatestBranch.get(0).getSequenceNumber());
/* start time of this history */
- buffer.putLong(latestBranch.get(0).getNodeStart());
+ buffer.putLong(fLatestBranch.get(0).getNodeStart());
buffer.flip();
int res = fc.write(buffer);
* @return The start time
*/
public long getTreeStart() {
- return config.getTreeStart();
+ return fConfig.getTreeStart();
}
/**
* @return The end time
*/
public long getTreeEnd() {
- return treeEnd;
+ return fTreeEnd;
}
/**
* @return The number of nodes
*/
public int getNodeCount() {
- return nodeCount;
+ return fNodeCount;
}
/**
* @return The root node
*/
public HTNode getRootNode() {
- return latestBranch.get(0);
+ return fLatestBranch.get(0);
}
// ------------------------------------------------------------------------
* the attribute tree can be read.
*/
public FileInputStream supplyATReader() {
- return treeIO.supplyATReader(getNodeCount());
+ return fTreeIO.supplyATReader(getNodeCount());
}
/**
* @return The file to which we will write the attribute tree
*/
public File supplyATWriterFile() {
- return config.getStateFile();
+ return fConfig.getStateFile();
}
/**
*/
public long supplyATWriterFilePos() {
return HistoryTree.TREE_HEADER_SIZE
- + ((long) getNodeCount() * config.getBlockSize());
+ + ((long) getNodeCount() * fConfig.getBlockSize());
}
/**
*/
public HTNode readNode(int seqNumber) throws ClosedChannelException {
/* Try to read the node from memory */
- synchronized (latestBranch) {
- for (HTNode node : latestBranch) {
+ synchronized (fLatestBranch) {
+ for (HTNode node : fLatestBranch) {
if (node.getSequenceNumber() == seqNumber) {
return node;
}
}
/* Read the node from disk */
- return treeIO.readNode(seqNumber);
+ return fTreeIO.readNode(seqNumber);
}
/**
* The node to write to disk
*/
public void writeNode(HTNode node) {
- treeIO.writeNode(node);
+ fTreeIO.writeNode(node);
}
/**
* Close the history file.
*/
public void closeFile() {
- treeIO.closeFile();
+ fTreeIO.closeFile();
}
/**
* Delete the history file.
*/
public void deleteFile() {
- treeIO.deleteFile();
+ fTreeIO.deleteFile();
}
// ------------------------------------------------------------------------
* If the start of end time of the interval are invalid
*/
public void insertInterval(HTInterval interval) throws TimeRangeException {
- if (interval.getStartTime() < config.getTreeStart()) {
- throw new TimeRangeException("Interval Start:" + interval.getStartTime() + ", Config Start:" + config.getTreeStart()); //$NON-NLS-1$ //$NON-NLS-2$
+ if (interval.getStartTime() < fConfig.getTreeStart()) {
+ throw new TimeRangeException("Interval Start:" + interval.getStartTime() + ", Config Start:" + fConfig.getTreeStart()); //$NON-NLS-1$ //$NON-NLS-2$
}
- tryInsertAtNode(interval, latestBranch.size() - 1);
+ tryInsertAtNode(interval, fLatestBranch.size() - 1);
}
/**
* insertion
*/
private void tryInsertAtNode(HTInterval interval, int indexOfNode) {
- HTNode targetNode = latestBranch.get(indexOfNode);
+ HTNode targetNode = fLatestBranch.get(indexOfNode);
/* Verify if there is enough room in this node to store this interval */
if (interval.getIntervalSize() > targetNode.getNodeFreeSpace()) {
/* Nope, not enough room. Insert in a new sibling instead. */
addSiblingNode(indexOfNode);
- tryInsertAtNode(interval, latestBranch.size() - 1);
+ tryInsertAtNode(interval, fLatestBranch.size() - 1);
return;
}
targetNode.addInterval(interval);
/* Update treeEnd if needed */
- if (interval.getEndTime() > this.treeEnd) {
- this.treeEnd = interval.getEndTime();
+ if (interval.getEndTime() > fTreeEnd) {
+ fTreeEnd = interval.getEndTime();
}
}
* The index in latestBranch where we start adding
*/
private void addSiblingNode(int indexOfNode) {
- synchronized (latestBranch) {
- final long splitTime = treeEnd;
+ synchronized (fLatestBranch) {
+ final long splitTime = fTreeEnd;
- if (indexOfNode >= latestBranch.size()) {
+ if (indexOfNode >= fLatestBranch.size()) {
/*
* We need to make sure (indexOfNode - 1) doesn't get the last
* node in the branch, because that one is a Leaf Node.
}
/* Check if we can indeed add a child to the target parent */
- if (((CoreNode) latestBranch.get(indexOfNode - 1)).getNbChildren() == config.getMaxChildren()) {
+ if (((CoreNode) fLatestBranch.get(indexOfNode - 1)).getNbChildren() == fConfig.getMaxChildren()) {
/* If not, add a branch starting one level higher instead */
addSiblingNode(indexOfNode - 1);
return;
}
/* Split off the new branch from the old one */
- for (int i = indexOfNode; i < latestBranch.size(); i++) {
- latestBranch.get(i).closeThisNode(splitTime);
- treeIO.writeNode(latestBranch.get(i));
+ for (int i = indexOfNode; i < fLatestBranch.size(); i++) {
+ fLatestBranch.get(i).closeThisNode(splitTime);
+ fTreeIO.writeNode(fLatestBranch.get(i));
- CoreNode prevNode = (CoreNode) latestBranch.get(i - 1);
+ CoreNode prevNode = (CoreNode) fLatestBranch.get(i - 1);
HTNode newNode;
- switch (latestBranch.get(i).getNodeType()) {
+ switch (fLatestBranch.get(i).getNodeType()) {
case CORE:
newNode = initNewCoreNode(prevNode.getSequenceNumber(), splitTime + 1);
break;
}
prevNode.linkNewChild(newNode);
- latestBranch.set(i, newNode);
+ fLatestBranch.set(i, newNode);
}
}
}
* latestBranch
*/
private void addNewRootNode() {
- final long splitTime = this.treeEnd;
+ final long splitTime = fTreeEnd;
- HTNode oldRootNode = latestBranch.get(0);
- CoreNode newRootNode = initNewCoreNode(-1, config.getTreeStart());
+ HTNode oldRootNode = fLatestBranch.get(0);
+ CoreNode newRootNode = initNewCoreNode(-1, fConfig.getTreeStart());
/* Tell the old root node that it isn't root anymore */
oldRootNode.setParentSequenceNumber(newRootNode.getSequenceNumber());
/* Close off the whole current latestBranch */
- for (int i = 0; i < latestBranch.size(); i++) {
- latestBranch.get(i).closeThisNode(splitTime);
- treeIO.writeNode(latestBranch.get(i));
+ for (int i = 0; i < fLatestBranch.size(); i++) {
+ fLatestBranch.get(i).closeThisNode(splitTime);
+ fTreeIO.writeNode(fLatestBranch.get(i));
}
/* Link the new root to its first child (the previous root node) */
newRootNode.linkNewChild(oldRootNode);
/* Rebuild a new latestBranch */
- int depth = latestBranch.size();
- latestBranch.clear();
- latestBranch.add(newRootNode);
+ int depth = fLatestBranch.size();
+ fLatestBranch.clear();
+ fLatestBranch.add(newRootNode);
// Create new coreNode
for (int i = 1; i < depth + 1; i++) {
- CoreNode prevNode = (CoreNode) latestBranch.get(i - 1);
+ CoreNode prevNode = (CoreNode) fLatestBranch.get(i - 1);
CoreNode newNode = initNewCoreNode(prevNode.getParentSequenceNumber(),
splitTime + 1);
prevNode.linkNewChild(newNode);
- latestBranch.add(newNode);
+ fLatestBranch.add(newNode);
}
// Create the new leafNode
- CoreNode prevNode = (CoreNode) latestBranch.get(depth);
+ CoreNode prevNode = (CoreNode) fLatestBranch.get(depth);
LeafNode newNode = initNewLeafNode(prevNode.getParentSequenceNumber(), splitTime + 1);
prevNode.linkNewChild(newNode);
- latestBranch.add(newNode);
+ fLatestBranch.add(newNode);
}
/**
* @return The newly created node
*/
private CoreNode initNewCoreNode(int parentSeqNumber, long startTime) {
- CoreNode newNode = new CoreNode(config, this.nodeCount, parentSeqNumber,
+ CoreNode newNode = new CoreNode(fConfig, fNodeCount, parentSeqNumber,
startTime);
- this.nodeCount++;
+ fNodeCount++;
/* Update the treeEnd if needed */
- if (startTime >= this.treeEnd) {
- this.treeEnd = startTime + 1;
+ if (startTime >= fTreeEnd) {
+ fTreeEnd = startTime + 1;
}
return newNode;
}
* @return The newly created node
*/
private LeafNode initNewLeafNode(int parentSeqNumber, long startTime) {
- LeafNode newNode = new LeafNode(config, this.nodeCount, parentSeqNumber,
+ LeafNode newNode = new LeafNode(fConfig, fNodeCount, parentSeqNumber,
startTime);
- this.nodeCount++;
+ fNodeCount++;
/* Update the treeEnd if needed */
- if (startTime >= this.treeEnd) {
- this.treeEnd = startTime + 1;
+ if (startTime >= fTreeEnd) {
+ fTreeEnd = startTime + 1;
}
return newNode;
}
* node has to be on disk
*/
if (currentNode.isOnDisk()) {
- return treeIO.readNode(potentialNextSeqNb);
+ return fTreeIO.readNode(potentialNextSeqNb);
}
return readNode(potentialNextSeqNb);
}
* @return The history file size
*/
public long getFileSize() {
- return config.getStateFile().length();
+ return fConfig.getStateFile().length();
}
// ------------------------------------------------------------------------
* first child and the end of the last child, respectively
*/
if (node.getNbChildren() > 0) {
- otherNode = treeIO.readNode(node.getChild(0));
+ otherNode = fTreeIO.readNode(node.getChild(0));
if (node.getNodeStart() != otherNode.getNodeStart()) {
buf.append("Start time of node (" + node.getNodeStart() + ") "
+ "does not match start time of first child " + "("
ret = false;
}
if (node.isOnDisk()) {
- otherNode = treeIO.readNode(node.getLatestChild());
+ otherNode = fTreeIO.readNode(node.getLatestChild());
if (node.getNodeEnd() != otherNode.getNodeEnd()) {
buf.append("End time of node (" + node.getNodeEnd()
+ ") does not match end time of last child ("
* start times
*/
for (int i = 0; i < node.getNbChildren(); i++) {
- otherNode = treeIO.readNode(node.getChild(i));
+ otherNode = fTreeIO.readNode(node.getChild(i));
if (otherNode.getNodeStart() != node.getChildStart(i)) {
buf.append(" Expected start time of child node #"
+ node.getChild(i) + ": " + node.getChildStart(i)
}
} catch (ClosedChannelException e) {
- e.printStackTrace();
+ Activator.getDefault().logError(e.getMessage(), e);
}
if (!ret) {
- System.out.println("");
- System.out.println("SHT: Integrity check failed for node #"
- + node.getSequenceNumber() + ":");
- System.out.println(buf.toString());
+ Activator.getDefault().logError("SHT: Integrity check failed for node #"
+ + node.getSequenceNumber() + ":" + buf.toString());
}
return ret;
}
*/
public void checkIntegrity() {
try {
- for (int i = 0; i < nodeCount; i++) {
- checkNodeIntegrity(treeIO.readNode(i));
+ for (int i = 0; i < fNodeCount; i++) {
+ checkNodeIntegrity(fTreeIO.readNode(i));
}
} catch (ClosedChannelException e) {
}
@Override
public String toString() {
return "Information on the current tree:\n\n" + "Blocksize: "
- + config.getBlockSize() + "\n" + "Max nb. of children per node: "
- + config.getMaxChildren() + "\n" + "Number of nodes: " + nodeCount
- + "\n" + "Depth of the tree: " + latestBranch.size() + "\n"
- + "Size of the treefile: " + this.getFileSize() + "\n"
+ + fConfig.getBlockSize() + "\n" + "Max nb. of children per node: "
+ + fConfig.getMaxChildren() + "\n" + "Number of nodes: " + fNodeCount
+ + "\n" + "Depth of the tree: " + fLatestBranch.size() + "\n"
+ + "Size of the treefile: " + getFileSize() + "\n"
+ "Root node has sequence number: "
- + latestBranch.get(0).getSequenceNumber() + "\n"
+ + fLatestBranch.get(0).getSequenceNumber() + "\n"
+ "'Latest leaf' has sequence number: "
- + latestBranch.get(latestBranch.size() - 1).getSequenceNumber();
+ + fLatestBranch.get(fLatestBranch.size() - 1).getSequenceNumber();
}
/**
/* Print the extensions, if any */
int extension = node.getExtensionSequenceNumber();
while (extension != -1) {
- HTNode nextNode = treeIO.readNode(extension);
+ HTNode nextNode = fTreeIO.readNode(extension);
preOrderPrint(writer, printIntervals, nextNode, curDepth);
}
/* Print the child nodes */
for (int i = 0; i < node.getNbChildren(); i++) {
- HTNode nextNode = treeIO.readNode(node.getChild(i));
+ HTNode nextNode = fTreeIO.readNode(node.getChild(i));
for (int j = 0; j < curDepth; j++) {
writer.print(" ");
}
public void debugPrintFullTree(PrintWriter writer, boolean printIntervals) {
/* Only used for debugging, shouldn't be externalized */
- this.preOrderPrint(writer, false, latestBranch.get(0), 0);
+ preOrderPrint(writer, false, fLatestBranch.get(0), 0);
if (printIntervals) {
writer.println("\nDetails of intervals:"); //$NON-NLS-1$
- this.preOrderPrint(writer, true, latestBranch.get(0), 0);
+ preOrderPrint(writer, true, fLatestBranch.get(0), 0);
}
writer.println('\n');
}
import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.tracecompass.internal.statesystem.core.Activator;
import org.eclipse.tracecompass.internal.statesystem.core.backend.historytree.CoreNode;
import org.eclipse.tracecompass.internal.statesystem.core.backend.historytree.HTConfig;
import org.eclipse.tracecompass.internal.statesystem.core.backend.historytree.HTInterval;
*/
public class HistoryTreeBackend implements IStateHistoryBackend {
- private final @NonNull String ssid;
+ private final @NonNull String fSsid;
/**
* The history tree that sits underneath.
*/
- private final HistoryTree sht;
+ private final HistoryTree fSht;
/** Indicates if the history tree construction is done */
private volatile boolean fFinishedBuilding = false;
* is the history tree finished building
*/
protected void setFinishedBuilding(boolean isFinishedBuilding) {
- this.fFinishedBuilding = isFinishedBuilding;
+ fFinishedBuilding = isFinishedBuilding;
}
/**
long startTime,
int blockSize,
int maxChildren) throws IOException {
- this.ssid = ssid;
+ fSsid = ssid;
final HTConfig conf = new HTConfig(newStateFile, blockSize, maxChildren,
providerVersion, startTime);
- sht = new HistoryTree(conf);
+ fSht = new HistoryTree(conf);
}
/**
*/
public HistoryTreeBackend(@NonNull String ssid, File existingStateFile, int providerVersion)
throws IOException {
- this.ssid = ssid;
- sht = new HistoryTree(existingStateFile, providerVersion);
+ fSsid = ssid;
+ fSht = new HistoryTree(existingStateFile, providerVersion);
fFinishedBuilding = true;
}
* @return The history tree
*/
protected HistoryTree getSHT() {
- return sht;
+ return fSht;
}
@Override
public String getSSID() {
- return ssid;
+ return fSsid;
}
@Override
public long getStartTime() {
- return sht.getTreeStart();
+ return fSht.getTreeStart();
}
@Override
public long getEndTime() {
- return sht.getTreeEnd();
+ return fSht.getTreeEnd();
}
@Override
quark, (TmfStateValue) value);
/* Start insertions at the "latest leaf" */
- sht.insertInterval(interval);
+ fSht.insertInterval(interval);
}
@Override
public void finishedBuilding(long endTime) {
- sht.closeTree(endTime);
+ fSht.closeTree(endTime);
fFinishedBuilding = true;
}
@Override
public FileInputStream supplyAttributeTreeReader() {
- return sht.supplyATReader();
+ return fSht.supplyATReader();
}
@Override
public File supplyAttributeTreeWriterFile() {
- return sht.supplyATWriterFile();
+ return fSht.supplyATWriterFile();
}
@Override
public long supplyAttributeTreeWriterFilePosition() {
- return sht.supplyATWriterFilePos();
+ return fSht.supplyATWriterFilePos();
}
@Override
public void removeFiles() {
- sht.deleteFile();
+ fSht.deleteFile();
}
@Override
public void dispose() {
if (fFinishedBuilding) {
- sht.closeFile();
+ fSht.closeFile();
} else {
/*
* The build is being interrupted, delete the file we partially
* built since it won't be complete, so shouldn't be re-used in the
* future (.deleteFile() will close the file first)
*/
- sht.deleteFile();
+ fSht.deleteFile();
}
}
checkValidTime(t);
/* We start by reading the information in the root node */
- HTNode currentNode = sht.getRootNode();
+ HTNode currentNode = fSht.getRootNode();
currentNode.writeInfoFromNode(stateInfo, t);
/* Then we follow the branch down in the relevant children */
try {
while (currentNode.getNodeType() == HTNode.NodeType.CORE) {
- currentNode = sht.selectNextChild((CoreNode) currentNode, t);
+ currentNode = fSht.selectNextChild((CoreNode) currentNode, t);
currentNode.writeInfoFromNode(stateInfo, t);
}
} catch (ClosedChannelException e) {
* The stateInfo should now be filled with everything needed, we pass
* the control back to the State System.
*/
- return;
}
@Override
}
private void checkValidTime(long t) {
- long treeStart = sht.getTreeStart();
- long treeEnd = sht.getTreeEnd();
+ long treeStart = fSht.getTreeStart();
+ long treeEnd = fSht.getTreeEnd();
if (t < treeStart || t > treeEnd) {
- throw new TimeRangeException(ssid + " Time:" + t + ", Start:" + treeStart + ", End:" + treeEnd); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ throw new TimeRangeException(fSsid + " Time:" + t + ", Start:" + treeStart + ", End:" + treeEnd); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
}
throws TimeRangeException, StateSystemDisposedException {
checkValidTime(t);
- HTNode currentNode = sht.getRootNode();
+ HTNode currentNode = fSht.getRootNode();
HTInterval interval = currentNode.getRelevantInterval(key, t);
try {
while (interval == null && currentNode.getNodeType() == HTNode.NodeType.CORE) {
- currentNode = sht.selectNextChild((CoreNode) currentNode, t);
+ currentNode = fSht.selectNextChild((CoreNode) currentNode, t);
interval = currentNode.getRelevantInterval(key, t);
}
} catch (ClosedChannelException e) {
* @return The current size of the history file in bytes
*/
public long getFileSize() {
- return sht.getFileSize();
+ return fSht.getFileSize();
}
/**
long ret;
try {
- for (int seq = 0; seq < sht.getNodeCount(); seq++) {
- node = sht.readNode(seq);
+ for (int seq = 0; seq < fSht.getNodeCount(); seq++) {
+ node = fSht.readNode(seq);
total += node.getNodeUsagePercent();
}
} catch (ClosedChannelException e) {
- e.printStackTrace();
+ Activator.getDefault().logError(e.getMessage(), e);
}
- ret = total / sht.getNodeCount();
+ ret = total / fSht.getNodeCount();
assert (ret >= 0 && ret <= 100);
return (int) ret;
}
@Override
public void debugPrint(PrintWriter writer) {
/* By default don't print out all the intervals */
- this.debugPrint(writer, false);
+ debugPrint(writer, false);
}
/**
/* Only used for debugging, shouldn't be externalized */
writer.println("------------------------------"); //$NON-NLS-1$
writer.println("State History Tree:\n"); //$NON-NLS-1$
- writer.println(sht.toString());
+ writer.println(fSht.toString());
writer.println("Average node utilization: " //$NON-NLS-1$
- + this.getAverageNodeUsage());
+ + getAverageNodeUsage());
writer.println(""); //$NON-NLS-1$
- sht.debugPrintFullTree(writer, printIntervals);
+ fSht.debugPrintFullTree(writer, printIntervals);
}
}
projects / deliverable / tracecompass.git / commitdiff
