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 Alexandre Montplaisir
  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 config
  49      *            Configuration of the History Tree
  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(HTConfig config, int seqNumber, int parentSeqNumber,
  58             long start) {
  59         super(config, seqNumber, parentSeqNumber, start);
  60         this.nbChildren = 0;
  61         int size = config.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 = 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 = 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 < 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 = 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 }