Exemplo n.º 1
0
 public virtual bool IsCached(string bpid, long blockId)
 {
     lock (this)
     {
         ExtendedBlockId      block = new ExtendedBlockId(blockId, bpid);
         FsDatasetCache.Value val   = mappableBlockMap[block];
         return((val != null) && val.state.ShouldAdvertise());
     }
 }
Exemplo n.º 2
0
        internal virtual void UncacheBlock(string bpid, long blockId)
        {
            lock (this)
            {
                ExtendedBlockId      key       = new ExtendedBlockId(blockId, bpid);
                FsDatasetCache.Value prevValue = mappableBlockMap[key];
                bool deferred = false;
                if (!dataset.datanode.GetShortCircuitRegistry().ProcessBlockMunlockRequest(key))
                {
                    deferred = true;
                }
                if (prevValue == null)
                {
                    Log.Debug("Block with id {}, pool {} does not need to be uncached, " + "because it is not currently in the mappableBlockMap."
                              , blockId, bpid);
                    numBlocksFailedToUncache.IncrementAndGet();
                    return;
                }
                switch (prevValue.state)
                {
                case FsDatasetCache.State.Caching:
                {
                    Log.Debug("Cancelling caching for block with id {}, pool {}.", blockId, bpid);
                    mappableBlockMap[key] = new FsDatasetCache.Value(prevValue.mappableBlock, FsDatasetCache.State
                                                                     .CachingCancelled);
                    break;
                }

                case FsDatasetCache.State.Cached:
                {
                    mappableBlockMap[key] = new FsDatasetCache.Value(prevValue.mappableBlock, FsDatasetCache.State
                                                                     .Uncaching);
                    if (deferred)
                    {
                        Log.Debug("{} is anchored, and can't be uncached now.  Scheduling it " + "for uncaching in {} "
                                  , key, DurationFormatUtils.FormatDurationHMS(revocationPollingMs));
                        deferredUncachingExecutor.Schedule(new FsDatasetCache.UncachingTask(this, key, revocationMs
                                                                                            ), revocationPollingMs, TimeUnit.Milliseconds);
                    }
                    else
                    {
                        Log.Debug("{} has been scheduled for immediate uncaching.", key);
                        uncachingExecutor.Execute(new FsDatasetCache.UncachingTask(this, key, 0));
                    }
                    break;
                }

                default:
                {
                    Log.Debug("Block with id {}, pool {} does not need to be uncached, " + "because it is in state {}."
                              , blockId, bpid, prevValue.state);
                    numBlocksFailedToUncache.IncrementAndGet();
                    break;
                }
                }
            }
        }
Exemplo n.º 3
0
 /// <summary>Attempt to begin caching a block.</summary>
 internal virtual void CacheBlock(long blockId, string bpid, string blockFileName,
                                  long length, long genstamp, Executor volumeExecutor)
 {
     lock (this)
     {
         ExtendedBlockId      key       = new ExtendedBlockId(blockId, bpid);
         FsDatasetCache.Value prevValue = mappableBlockMap[key];
         if (prevValue != null)
         {
             Log.Debug("Block with id {}, pool {} already exists in the " + "FsDatasetCache with state {}"
                       , blockId, bpid, prevValue.state);
             numBlocksFailedToCache.IncrementAndGet();
             return;
         }
         mappableBlockMap[key] = new FsDatasetCache.Value(null, FsDatasetCache.State.Caching
                                                          );
         volumeExecutor.Execute(new FsDatasetCache.CachingTask(this, key, blockFileName, length
                                                               , genstamp));
         Log.Debug("Initiating caching for Block with id {}, pool {}", blockId, bpid);
     }
 }
Exemplo n.º 4
0
            public virtual void Run()
            {
                bool            success       = false;
                FileInputStream blockIn       = null;
                FileInputStream metaIn        = null;
                MappableBlock   mappableBlock = null;
                ExtendedBlock   extBlk        = new ExtendedBlock(this.key.GetBlockPoolId(), this.key.GetBlockId
                                                                      (), this.length, this.genstamp);
                long newUsedBytes  = this._enclosing.usedBytesCount.Reserve(this.length);
                bool reservedBytes = false;

                try
                {
                    if (newUsedBytes < 0)
                    {
                        FsDatasetCache.Log.Warn("Failed to cache " + this.key + ": could not reserve " +
                                                this.length + " more bytes in the cache: " + DFSConfigKeys.DfsDatanodeMaxLockedMemoryKey
                                                + " of " + this._enclosing.maxBytes + " exceeded.");
                        return;
                    }
                    reservedBytes = true;
                    try
                    {
                        blockIn = (FileInputStream)this._enclosing.dataset.GetBlockInputStream(extBlk, 0);
                        metaIn  = DatanodeUtil.GetMetaDataInputStream(extBlk, this._enclosing.dataset);
                    }
                    catch (InvalidCastException e)
                    {
                        FsDatasetCache.Log.Warn("Failed to cache " + this.key + ": Underlying blocks are not backed by files."
                                                , e);
                        return;
                    }
                    catch (FileNotFoundException)
                    {
                        FsDatasetCache.Log.Info("Failed to cache " + this.key + ": failed to find backing "
                                                + "files.");
                        return;
                    }
                    catch (IOException e)
                    {
                        FsDatasetCache.Log.Warn("Failed to cache " + this.key + ": failed to open file",
                                                e);
                        return;
                    }
                    try
                    {
                        mappableBlock = MappableBlock.Load(this.length, blockIn, metaIn, this.blockFileName
                                                           );
                    }
                    catch (ChecksumException)
                    {
                        // Exception message is bogus since this wasn't caused by a file read
                        FsDatasetCache.Log.Warn("Failed to cache " + this.key + ": checksum verification failed."
                                                );
                        return;
                    }
                    catch (IOException e)
                    {
                        FsDatasetCache.Log.Warn("Failed to cache " + this.key, e);
                        return;
                    }
                    lock (this._enclosing)
                    {
                        FsDatasetCache.Value value = this._enclosing.mappableBlockMap[this.key];
                        Preconditions.CheckNotNull(value);
                        Preconditions.CheckState(value.state == FsDatasetCache.State.Caching || value.state
                                                 == FsDatasetCache.State.CachingCancelled);
                        if (value.state == FsDatasetCache.State.CachingCancelled)
                        {
                            Sharpen.Collections.Remove(this._enclosing.mappableBlockMap, this.key);
                            FsDatasetCache.Log.Warn("Caching of " + this.key + " was cancelled.");
                            return;
                        }
                        this._enclosing.mappableBlockMap[this.key] = new FsDatasetCache.Value(mappableBlock
                                                                                              , FsDatasetCache.State.Cached);
                    }
                    FsDatasetCache.Log.Debug("Successfully cached {}.  We are now caching {} bytes in"
                                             + " total.", this.key, newUsedBytes);
                    this._enclosing.dataset.datanode.GetShortCircuitRegistry().ProcessBlockMlockEvent
                        (this.key);
                    this._enclosing.numBlocksCached.AddAndGet(1);
                    this._enclosing.dataset.datanode.GetMetrics().IncrBlocksCached(1);
                    success = true;
                }
                finally
                {
                    IOUtils.CloseQuietly(blockIn);
                    IOUtils.CloseQuietly(metaIn);
                    if (!success)
                    {
                        if (reservedBytes)
                        {
                            this._enclosing.usedBytesCount.Release(this.length);
                        }
                        FsDatasetCache.Log.Debug("Caching of {} was aborted.  We are now caching only {} "
                                                 + "bytes in total.", this.key, this._enclosing.usedBytesCount.Get());
                        if (mappableBlock != null)
                        {
                            mappableBlock.Close();
                        }
                        this._enclosing.numBlocksFailedToCache.IncrementAndGet();
                        lock (this._enclosing)
                        {
                            Sharpen.Collections.Remove(this._enclosing.mappableBlockMap, this.key);
                        }
                    }
                }
            }