statesystem/org.eclipse.tracecompass.statesystem.core/src/org/eclipse/tracecompass/internal/statesystem/core/backend/historytree/HT_IO.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.tracecompass.internal.statesystem.core.backend.historytree;
  14
  15 import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull;
  16
  17 import java.io.File;
  18 import java.io.FileInputStream;
  19 import java.io.FileOutputStream;
  20 import java.io.IOException;
  21 import java.nio.channels.ClosedChannelException;
  22 import java.nio.channels.FileChannel;
  23 import java.util.logging.Logger;
  24
  25 import org.eclipse.jdt.annotation.NonNull;
  26 import org.eclipse.tracecompass.common.core.log.TraceCompassLog;
  27 import java.util.Objects;
  28 import java.util.concurrent.ExecutionException;
  29
  30 import org.eclipse.jdt.annotation.Nullable;
  31 import org.eclipse.tracecompass.internal.statesystem.core.Activator;
  32
  33 import com.google.common.cache.CacheBuilder;
  34 import com.google.common.cache.CacheLoader;
  35 import com.google.common.cache.LoadingCache;
  36
  37 /**
  38  * This class abstracts inputs/outputs of the HistoryTree nodes.
  39  *
  40  * It contains all the methods and descriptors to handle reading/writing nodes
  41  * to the tree-file on disk and all the caching mechanisms.
  42  *
  43  * This abstraction is mainly for code isolation/clarification purposes. Every
  44  * HistoryTree must contain 1 and only 1 HT_IO element.
  45  *
  46  * @author Alexandre Montplaisir
  47  */
  48 class HT_IO {
  49
  50     private static final Logger LOGGER = TraceCompassLog.getLogger(HT_IO.class);
  51
  52     // ------------------------------------------------------------------------
  53     // Global cache of nodes
  54     // ------------------------------------------------------------------------
  55
  56     private static final class CacheKey {
  57
  58         public final HT_IO fStateHistory;
  59         public final int fSeqNumber;
  60
  61         public CacheKey(HT_IO stateHistory,  int seqNumber) {
  62             fStateHistory = stateHistory;
  63             fSeqNumber = seqNumber;
  64         }
  65
  66         @Override
  67         public int hashCode() {
  68             return Objects.hash(fStateHistory, fSeqNumber);
  69         }
  70
  71         @Override
  72         public boolean equals(@Nullable Object obj) {
  73             if (this == obj) {
  74                 return true;
  75             }
  76             if (obj == null) {
  77                 return false;
  78             }
  79             if (getClass() != obj.getClass()) {
  80                 return false;
  81             }
  82             CacheKey other = (CacheKey) obj;
  83             return (fStateHistory.equals(other.fStateHistory) &&
  84                     fSeqNumber == other.fSeqNumber);
  85         }
  86     }
  87
  88     private static final int CACHE_SIZE = 256;
  89
  90     private static final LoadingCache<CacheKey, HTNode> NODE_CACHE =
  91         checkNotNull(CacheBuilder.newBuilder()
  92             .maximumSize(CACHE_SIZE)
  93             .build(new CacheLoader<CacheKey, HTNode>() {
  94                 @Override
  95                 public HTNode load(CacheKey key) throws IOException {
  96                     HT_IO io = key.fStateHistory;
  97                     int seqNb = key.fSeqNumber;
  98
  99                     LOGGER.finest(() -> "[HtIo:CacheMiss] seqNum=" + seqNb); //$NON-NLS-1$
 100
 101                     io.seekFCToNodePos(io.fFileChannelIn, seqNb);
 102                     return HTNode.readNode(io.fConfig, io.fFileChannelIn);
 103                 }
 104             }));
 105
 106
 107     // ------------------------------------------------------------------------
 108     // Instance fields
 109     // ------------------------------------------------------------------------
 110
 111     /* Configuration of the History Tree */
 112     private final HTConfig fConfig;
 113
 114     /* Fields related to the file I/O */
 115     private final FileInputStream fFileInputStream;
 116     private final FileOutputStream fFileOutputStream;
 117     private final FileChannel fFileChannelIn;
 118     private final FileChannel fFileChannelOut;
 119
 120     // ------------------------------------------------------------------------
 121     // Methods
 122     // ------------------------------------------------------------------------
 123
 124
 125
 126     /**
 127      * Standard constructor
 128      *
 129      * @param config
 130      *            The configuration object for the StateHistoryTree
 131      * @param newFile
 132      *            Flag indicating that the file must be created from scratch
 133      *
 134      * @throws IOException
 135      *             An exception can be thrown when file cannot be accessed
 136      */
 137     public HT_IO(HTConfig config, boolean newFile) throws IOException {
 138         fConfig = config;
 139
 140         File historyTreeFile = config.getStateFile();
 141         if (newFile) {
 142             boolean success1 = true;
 143             /* Create a new empty History Tree file */
 144             if (historyTreeFile.exists()) {
 145                 success1 = historyTreeFile.delete();
 146             }
 147             boolean success2 = historyTreeFile.createNewFile();
 148             if (!(success1 && success2)) {
 149                 /* It seems we do not have permission to create the new file */
 150                 throw new IOException("Cannot create new file at " + //$NON-NLS-1$
 151                         historyTreeFile.getName());
 152             }
 153             fFileInputStream = new FileInputStream(historyTreeFile);
 154             fFileOutputStream = new FileOutputStream(historyTreeFile, false);
 155         } else {
 156             /*
 157              * We want to open an existing file, make sure we don't squash the
 158              * existing content when opening the fos!
 159              */
 160             fFileInputStream = new FileInputStream(historyTreeFile);
 161             fFileOutputStream = new FileOutputStream(historyTreeFile, true);
 162         }
 163         fFileChannelIn = fFileInputStream.getChannel();
 164         fFileChannelOut = fFileOutputStream.getChannel();
 165     }
 166
 167     /**
 168      * Read a node from the file on disk.
 169      *
 170      * @param seqNumber
 171      *            The sequence number of the node to read.
 172      * @return The object representing the node
 173      * @throws ClosedChannelException
 174      *             Usually happens because the file was closed while we were
 175      *             reading. Instead of using a big reader-writer lock, we'll
 176      *             just catch this exception.
 177      */
 178     public synchronized @NonNull HTNode readNode(int seqNumber) throws ClosedChannelException {
 179         /* Do a cache lookup. If it's not present it will be loaded from disk */
 180         LOGGER.finest(() -> "[HtIo:CacheLookup] seqNum=" + seqNumber); //$NON-NLS-1$
 181         CacheKey key = new CacheKey(this, seqNumber);
 182         try {
 183             return checkNotNull(NODE_CACHE.get(key));
 184
 185         } catch (ExecutionException e) {
 186             /* Get the inner exception that was generated */
 187             Throwable cause = e.getCause();
 188             if (cause instanceof ClosedChannelException) {
 189                 throw (ClosedChannelException) cause;
 190             }
 191             /*
 192              * Other types of IOExceptions shouldn't happen at this point though.
 193              */
 194             Activator.getDefault().logError(e.getMessage(), e);
 195             throw new IllegalStateException();
 196         }
 197     }
 198
 199     public synchronized void writeNode(HTNode node) {
 200         try {
 201             int seqNumber = node.getSequenceNumber();
 202
 203             /* "Write-back" the node into the cache */
 204             CacheKey key = new CacheKey(this, seqNumber);
 205             NODE_CACHE.put(key, node);
 206
 207             /* Position ourselves at the start of the node and write it */
 208             seekFCToNodePos(fFileChannelOut, seqNumber);
 209             node.writeSelf(fFileChannelOut);
 210         } catch (IOException e) {
 211             /* If we were able to open the file, we should be fine now... */
 212             Activator.getDefault().logError(e.getMessage(), e);
 213         }
 214     }
 215
 216     public FileChannel getFcOut() {
 217         return fFileChannelOut;
 218     }
 219
 220     public FileInputStream supplyATReader(int nodeOffset) {
 221         try {
 222             /*
 223              * Position ourselves at the start of the Mapping section in the
 224              * file (which is right after the Blocks)
 225              */
 226             seekFCToNodePos(fFileChannelIn, nodeOffset);
 227         } catch (IOException e) {
 228             Activator.getDefault().logError(e.getMessage(), e);
 229         }
 230         return fFileInputStream;
 231     }
 232
 233     public synchronized void closeFile() {
 234         try {
 235             fFileInputStream.close();
 236             fFileOutputStream.close();
 237         } catch (IOException e) {
 238             Activator.getDefault().logError(e.getMessage(), e);
 239         }
 240     }
 241
 242     public synchronized void deleteFile() {
 243         closeFile();
 244
 245         File historyTreeFile = fConfig.getStateFile();
 246         if (!historyTreeFile.delete()) {
 247             /* We didn't succeed in deleting the file */
 248             Activator.getDefault().logError("Failed to delete" + historyTreeFile.getName()); //$NON-NLS-1$
 249         }
 250     }
 251
 252     /**
 253      * Seek the given FileChannel to the position corresponding to the node that
 254      * has seqNumber
 255      *
 256      * @param fc
 257      *            the channel to seek
 258      * @param seqNumber
 259      *            the node sequence number to seek the channel to
 260      * @throws IOException
 261      *             If some other I/O error occurs
 262      */
 263     private void seekFCToNodePos(FileChannel fc, int seqNumber)
 264             throws IOException {
 265         /*
 266          * Cast to (long) is needed to make sure the result is a long too and
 267          * doesn't get truncated
 268          */
 269         fc.position(HistoryTree.TREE_HEADER_SIZE
 270                 + ((long) seqNumber) * fConfig.getBlockSize());
 271     }
 272
 273 }