org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/internal/tmf/core/statesystem/backends/historytree/HistoryTreeBackend.java

   1 /*******************************************************************************
   2  * Copyright (c) 2012, 2014 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.io.File;
  16 import java.io.FileInputStream;
  17 import java.io.IOException;
  18 import java.io.PrintWriter;
  19 import java.nio.channels.ClosedChannelException;
  20 import java.util.List;
  21
  22 import org.eclipse.linuxtools.internal.tmf.core.statesystem.backends.IStateHistoryBackend;
  23 import org.eclipse.linuxtools.tmf.core.exceptions.StateSystemDisposedException;
  24 import org.eclipse.linuxtools.tmf.core.exceptions.TimeRangeException;
  25 import org.eclipse.linuxtools.tmf.core.interval.ITmfStateInterval;
  26 import org.eclipse.linuxtools.tmf.core.statevalue.ITmfStateValue;
  27 import org.eclipse.linuxtools.tmf.core.statevalue.TmfStateValue;
  28
  29 /**
  30  * History Tree backend for storing a state history. This is the basic version
  31  * that runs in the same thread as the class creating it.
  32  *
  33  * @author Alexandre Montplaisir
  34  *
  35  */
  36 public class HistoryTreeBackend implements IStateHistoryBackend {
  37
  38     /** The history tree that sits underneath */
  39     protected final HistoryTree sht;
  40
  41     /** Indicates if the history tree construction is done */
  42     protected boolean isFinishedBuilding = false;
  43
  44     /**
  45      * Constructor for new history files. Use this when creating a new history
  46      * from scratch.
  47      *
  48      * @param newStateFile
  49      *            The filename/location where to store the state history (Should
  50      *            end in .ht)
  51      * @param blockSize
  52      *            The size of the blocks in the history file. This should be a
  53      *            multiple of 4096.
  54      * @param maxChildren
  55      *            The maximum number of children each core node can have
  56      * @param providerVersion
  57      *            Version of of the state provider. We will only try to reopen
  58      *            existing files if this version matches the one in the
  59      *            framework.
  60      * @param startTime
  61      *            The earliest time stamp that will be stored in the history
  62      * @throws IOException
  63      *             Thrown if we can't create the file for some reason
  64      */
  65     public HistoryTreeBackend(File newStateFile, int blockSize,
  66             int maxChildren, int providerVersion, long startTime) throws IOException {
  67         final HTConfig conf = new HTConfig(newStateFile, blockSize, maxChildren,
  68                 providerVersion, startTime);
  69         sht = new HistoryTree(conf);
  70     }
  71
  72     /**
  73      * Constructor for new history files. Use this when creating a new history
  74      * from scratch. This version supplies sane defaults for the configuration
  75      * parameters.
  76      *
  77      * @param newStateFile
  78      *            The filename/location where to store the state history (Should
  79      *            end in .ht)
  80      * @param providerVersion
  81      *            Version of of the state provider. We will only try to reopen
  82      *            existing files if this version matches the one in the
  83      *            framework.
  84      * @param startTime
  85      *            The earliest time stamp that will be stored in the history
  86      * @throws IOException
  87      *             Thrown if we can't create the file for some reason
  88      */
  89     public HistoryTreeBackend(File newStateFile, int providerVersion, long startTime)
  90             throws IOException {
  91         this(newStateFile, 64 * 1024, 50, providerVersion, startTime);
  92     }
  93
  94     /**
  95      * Existing history constructor. Use this to open an existing state-file.
  96      *
  97      * @param existingStateFile
  98      *            Filename/location of the history we want to load
  99      * @param providerVersion
 100      *            Expected version of of the state provider plugin.
 101      * @throws IOException
 102      *             If we can't read the file, if it doesn't exist, is not
 103      *             recognized, or if the version of the file does not match the
 104      *             expected providerVersion.
 105      */
 106     public HistoryTreeBackend(File existingStateFile, int providerVersion)
 107             throws IOException {
 108         sht = new HistoryTree(existingStateFile, providerVersion);
 109         isFinishedBuilding = true;
 110     }
 111
 112     @Override
 113     public long getStartTime() {
 114         return sht.getTreeStart();
 115     }
 116
 117     @Override
 118     public long getEndTime() {
 119         return sht.getTreeEnd();
 120     }
 121
 122     @Override
 123     public void insertPastState(long stateStartTime, long stateEndTime,
 124             int quark, ITmfStateValue value) throws TimeRangeException {
 125         HTInterval interval = new HTInterval(stateStartTime, stateEndTime,
 126                 quark, (TmfStateValue) value);
 127
 128         /* Start insertions at the "latest leaf" */
 129         sht.insertInterval(interval);
 130     }
 131
 132     @Override
 133     public void finishedBuilding(long endTime) {
 134         sht.closeTree(endTime);
 135         isFinishedBuilding = true;
 136     }
 137
 138     @Override
 139     public FileInputStream supplyAttributeTreeReader() {
 140         return sht.supplyATReader();
 141     }
 142
 143     @Override
 144     public File supplyAttributeTreeWriterFile() {
 145         return sht.supplyATWriterFile();
 146     }
 147
 148     @Override
 149     public long supplyAttributeTreeWriterFilePosition() {
 150         return sht.supplyATWriterFilePos();
 151     }
 152
 153     @Override
 154     public void removeFiles() {
 155         sht.deleteFile();
 156     }
 157
 158     @Override
 159     public void dispose() {
 160         if (isFinishedBuilding) {
 161             sht.closeFile();
 162         } else {
 163             /*
 164              * The build is being interrupted, delete the file we partially
 165              * built since it won't be complete, so shouldn't be re-used in the
 166              * future (.deleteFile() will close the file first)
 167              */
 168             sht.deleteFile();
 169         }
 170     }
 171
 172     @Override
 173     public void doQuery(List<ITmfStateInterval> stateInfo, long t)
 174             throws TimeRangeException, StateSystemDisposedException {
 175         if (!checkValidTime(t)) {
 176             /* We can't possibly have information about this query */
 177             throw new TimeRangeException();
 178         }
 179
 180         /* We start by reading the information in the root node */
 181         // FIXME using CoreNode for now, we'll have to redo this part to handle
 182         // different node types
 183         CoreNode currentNode = sht.getRootNode();
 184         currentNode.writeInfoFromNode(stateInfo, t);
 185
 186         /* Then we follow the branch down in the relevant children */
 187         try {
 188             while (currentNode.getNbChildren() > 0) {
 189                 currentNode = (CoreNode) sht.selectNextChild(currentNode, t);
 190                 currentNode.writeInfoFromNode(stateInfo, t);
 191             }
 192         } catch (ClosedChannelException e) {
 193             throw new StateSystemDisposedException(e);
 194         }
 195
 196         /*
 197          * The stateInfo should now be filled with everything needed, we pass
 198          * the control back to the State System.
 199          */
 200         return;
 201     }
 202
 203     @Override
 204     public ITmfStateInterval doSingularQuery(long t, int attributeQuark)
 205             throws TimeRangeException, StateSystemDisposedException {
 206         return getRelevantInterval(t, attributeQuark);
 207     }
 208
 209     @Override
 210     public boolean checkValidTime(long t) {
 211         return (t >= sht.getTreeStart() && t <= sht.getTreeEnd());
 212     }
 213
 214     /**
 215      * Inner method to find the interval in the tree containing the requested
 216      * key/timestamp pair, wherever in which node it is.
 217      *
 218      * @param t
 219      * @param key
 220      * @return The node containing the information we want
 221      */
 222     private HTInterval getRelevantInterval(long t, int key)
 223             throws TimeRangeException, StateSystemDisposedException {
 224         if (!checkValidTime(t)) {
 225             throw new TimeRangeException();
 226         }
 227
 228         // FIXME using CoreNode for now, we'll have to redo this part to handle
 229         // different node types
 230         CoreNode currentNode = sht.getRootNode();
 231         HTInterval interval = currentNode.getRelevantInterval(key, t);
 232
 233         try {
 234             while (interval == null && currentNode.getNbChildren() > 0) {
 235                 currentNode = (CoreNode) sht.selectNextChild(currentNode, t);
 236                 interval = currentNode.getRelevantInterval(key, t);
 237             }
 238         } catch (ClosedChannelException e) {
 239             throw new StateSystemDisposedException(e);
 240         }
 241         /*
 242          * Since we should now have intervals at every attribute/timestamp
 243          * combination, it should NOT be null here.
 244          */
 245         assert (interval != null);
 246         return interval;
 247     }
 248
 249     /**
 250      * Return the size of the tree history file
 251      *
 252      * @return The current size of the history file in bytes
 253      */
 254     public long getFileSize() {
 255         return sht.getFileSize();
 256     }
 257
 258     /**
 259      * Return the average node usage as a percentage (between 0 and 100)
 260      *
 261      * @return Average node usage %
 262      */
 263     public int getAverageNodeUsage() {
 264         HTNode node;
 265         long total = 0;
 266         long ret;
 267
 268         try {
 269             for (int seq = 0; seq < sht.getNodeCount(); seq++) {
 270                 node = sht.readNode(seq);
 271                 total += node.getNodeUsagePercent();
 272             }
 273         } catch (ClosedChannelException e) {
 274             e.printStackTrace();
 275         }
 276
 277         ret = total / sht.getNodeCount();
 278         assert (ret >= 0 && ret <= 100);
 279         return (int) ret;
 280     }
 281
 282     @Override
 283     public void debugPrint(PrintWriter writer) {
 284         /* By default don't print out all the intervals */
 285         this.debugPrint(writer, false);
 286     }
 287
 288     /**
 289      * The basic debugPrint method will print the tree structure, but not their
 290      * contents.
 291      *
 292      * This method here print the contents (the intervals) as well.
 293      *
 294      * @param writer
 295      *            The PrintWriter to which the debug info will be written
 296      * @param printIntervals
 297      *            Should we also print every contained interval individually?
 298      */
 299     public void debugPrint(PrintWriter writer, boolean printIntervals) {
 300         /* Only used for debugging, shouldn't be externalized */
 301         writer.println("------------------------------"); //$NON-NLS-1$
 302         writer.println("State History Tree:\n"); //$NON-NLS-1$
 303         writer.println(sht.toString());
 304         writer.println("Average node utilization: " //$NON-NLS-1$
 305                 + this.getAverageNodeUsage());
 306         writer.println(""); //$NON-NLS-1$
 307
 308         sht.debugPrintFullTree(writer, printIntervals);
 309     }
 310 }