Exemplo n.º 1
0
            /// <summary>Pull a slot out of a preexisting shared memory segment.</summary>
            /// <remarks>
            /// Pull a slot out of a preexisting shared memory segment.
            /// Must be called with the manager lock held.
            /// </remarks>
            /// <param name="blockId">The blockId to put inside the Slot object.</param>
            /// <returns>
            /// null if none of our shared memory segments contain a
            /// free slot; the slot object otherwise.
            /// </returns>
            private ShortCircuitShm.Slot AllocSlotFromExistingShm(ExtendedBlockId blockId)
            {
                if (this.notFull.IsEmpty())
                {
                    return(null);
                }
                KeyValuePair <ShortCircuitShm.ShmId, DfsClientShm> entry = this.notFull.FirstEntry
                                                                               ();
                DfsClientShm shm = entry.Value;

                ShortCircuitShm.ShmId shmId = shm.GetShmId();
                ShortCircuitShm.Slot  slot  = shm.AllocAndRegisterSlot(blockId);
                if (shm.IsFull())
                {
                    if (DfsClientShmManager.Log.IsTraceEnabled())
                    {
                        DfsClientShmManager.Log.Trace(this + ": pulled the last slot " + slot.GetSlotIdx(
                                                          ) + " out of " + shm);
                    }
                    DfsClientShm removedShm = Sharpen.Collections.Remove(this.notFull, shmId);
                    Preconditions.CheckState(removedShm == shm);
                    this.full[shmId] = shm;
                }
                else
                {
                    if (DfsClientShmManager.Log.IsTraceEnabled())
                    {
                        DfsClientShmManager.Log.Trace(this + ": pulled slot " + slot.GetSlotIdx() + " out of "
                                                      + shm);
                    }
                }
                return(slot);
            }
Exemplo n.º 2
0
 /// <summary>
 /// Invalidate any slot associated with a blockId that we are invalidating
 /// (deleting) from this DataNode.
 /// </summary>
 /// <remarks>
 /// Invalidate any slot associated with a blockId that we are invalidating
 /// (deleting) from this DataNode.  When a slot is invalid, the DFSClient will
 /// not use the corresponding replica for new read or mmap operations (although
 /// existing, ongoing read or mmap operations will complete.)
 /// </remarks>
 /// <param name="blockId">The block ID.</param>
 public virtual void ProcessBlockInvalidation(ExtendedBlockId blockId)
 {
     lock (this)
     {
         if (!enabled)
         {
             return;
         }
         ICollection <ShortCircuitShm.Slot> affectedSlots = ((ICollection <ShortCircuitShm.Slot
                                                                           >)slots.Get(blockId));
         if (!affectedSlots.IsEmpty())
         {
             StringBuilder bld    = new StringBuilder();
             string        prefix = string.Empty;
             bld.Append("Block ").Append(blockId).Append(" has been invalidated.  ").Append("Marking short-circuit slots as invalid: "
                                                                                            );
             foreach (ShortCircuitShm.Slot slot in affectedSlots)
             {
                 slot.MakeInvalid();
                 bld.Append(prefix).Append(slot.ToString());
                 prefix = ", ";
             }
             Log.Info(bld.ToString());
         }
     }
 }
Exemplo n.º 3
0
 /// <summary>Register a slot.</summary>
 /// <remarks>
 /// Register a slot.
 /// This function looks at a slot which has already been initialized (by
 /// another process), and registers it with us.  Then, it returns the
 /// relevant Slot object.
 /// </remarks>
 /// <returns>The slot.</returns>
 /// <exception cref="Org.Apache.Hadoop.FS.InvalidRequestException">
 /// If the slot index we're trying to allocate has not been
 /// initialized, or is already in use.
 /// </exception>
 public ShortCircuitShm.Slot RegisterSlot(int slotIdx, ExtendedBlockId blockId)
 {
     lock (this)
     {
         if (slotIdx < 0)
         {
             throw new InvalidRequestException(this + ": invalid negative slot " + "index " +
                                               slotIdx);
         }
         if (slotIdx >= slots.Length)
         {
             throw new InvalidRequestException(this + ": invalid slot " + "index " + slotIdx);
         }
         if (allocatedSlots.Get(slotIdx))
         {
             throw new InvalidRequestException(this + ": slot " + slotIdx + " is already in use."
                                               );
         }
         ShortCircuitShm.Slot slot = new ShortCircuitShm.Slot(this, CalculateSlotAddress(slotIdx
                                                                                         ), blockId);
         if (!slot.IsValid())
         {
             throw new InvalidRequestException(this + ": slot " + slotIdx + " is not marked as valid."
                                               );
         }
         slots[slotIdx] = slot;
         allocatedSlots.Set(slotIdx, true);
         if (Log.IsTraceEnabled())
         {
             Log.Trace(this + ": registerSlot " + slotIdx + ": allocatedSlots=" + allocatedSlots
                       + StringUtils.GetStackTrace(Sharpen.Thread.CurrentThread()));
         }
         return(slot);
     }
 }
Exemplo n.º 4
0
 internal Slot(ShortCircuitShm _enclosing, long slotAddress, ExtendedBlockId blockId
               )
 {
     this._enclosing  = _enclosing;
     this.slotAddress = slotAddress;
     this.blockId     = blockId;
 }
Exemplo n.º 5
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.º 6
0
 internal CachingTask(FsDatasetCache _enclosing, ExtendedBlockId key, string blockFileName
                      , long length, long genstamp)
 {
     this._enclosing    = _enclosing;
     this.key           = key;
     this.blockFileName = blockFileName;
     this.length        = length;
     this.genstamp      = genstamp;
 }
Exemplo n.º 7
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.º 8
0
 public _ShortCircuitReplicaCreator_330(ExtendedBlockId key, TestShortCircuitCache.TestFileDescriptorPair
                                        [] pairs, int iVal, ShortCircuitCache cache, long HourInMs)
 {
     this.key      = key;
     this.pairs    = pairs;
     this.iVal     = iVal;
     this.cache    = cache;
     this.HourInMs = HourInMs;
 }
Exemplo n.º 9
0
            public void Visit(int numOutstandingMmaps, IDictionary <ExtendedBlockId, ShortCircuitReplica
                                                                    > replicas, IDictionary <ExtendedBlockId, SecretManager.InvalidToken> failedLoads
                              , IDictionary <long, ShortCircuitReplica> evictable, IDictionary <long, ShortCircuitReplica
                                                                                                > evictableMmapped)
            {
                ShortCircuitReplica replica = replicas[ExtendedBlockId.FromExtendedBlock(block)];

                NUnit.Framework.Assert.IsNotNull(replica);
                NUnit.Framework.Assert.IsFalse(replica.GetSlot().IsValid());
            }
Exemplo n.º 10
0
 public virtual ShortCircuitReplicaInfo CreateShortCircuitReplicaInfo()
 {
     try
     {
         ExtendedBlockId key = new ExtendedBlockId(blockId, "test_bp1");
         return(new ShortCircuitReplicaInfo(new ShortCircuitReplica(key, pair.GetFileInputStreams
                                                                        ()[0], pair.GetFileInputStreams()[1], cache, Time.MonotonicNow(), null)));
     }
     catch (IOException e)
     {
         throw new RuntimeException(e);
     }
 }
Exemplo n.º 11
0
 internal UncachingTask(FsDatasetCache _enclosing, ExtendedBlockId key, long revocationDelayMs
                        )
 {
     this._enclosing = _enclosing;
     this.key        = key;
     if (revocationDelayMs == 0)
     {
         this.revocationTimeMs = 0;
     }
     else
     {
         this.revocationTimeMs = revocationDelayMs + Org.Apache.Hadoop.Util.Time.MonotonicNow
                                     ();
     }
 }
Exemplo n.º 12
0
 /// <summary>Process a block mlock event from the FsDatasetCache.</summary>
 /// <param name="blockId">The block that was mlocked.</param>
 public virtual void ProcessBlockMlockEvent(ExtendedBlockId blockId)
 {
     lock (this)
     {
         if (!enabled)
         {
             return;
         }
         ICollection <ShortCircuitShm.Slot> affectedSlots = ((ICollection <ShortCircuitShm.Slot
                                                                           >)slots.Get(blockId));
         foreach (ShortCircuitShm.Slot slot in affectedSlots)
         {
             slot.MakeAnchorable();
         }
     }
 }
Exemplo n.º 13
0
 /// <exception cref="System.IO.IOException"/>
 public ShortCircuitReplica(ExtendedBlockId key, FileInputStream dataStream, FileInputStream
                            metaStream, ShortCircuitCache cache, long creationTimeMs, ShortCircuitShm.Slot
                            slot)
 {
     this.key        = key;
     this.dataStream = dataStream;
     this.metaStream = metaStream;
     this.metaHeader = BlockMetadataHeader.PreadHeader(metaStream.GetChannel());
     if (metaHeader.GetVersion() != 1)
     {
         throw new IOException("invalid metadata header version " + metaHeader.GetVersion(
                                   ) + ".  Can only handle version 1.");
     }
     this.cache          = cache;
     this.creationTimeMs = creationTimeMs;
     this.slot           = slot;
 }
Exemplo n.º 14
0
 public virtual string GetClientNames(ExtendedBlockId blockId)
 {
     lock (this)
     {
         if (!enabled)
         {
             return(string.Empty);
         }
         HashSet <string> clientNames = new HashSet <string>();
         ICollection <ShortCircuitShm.Slot> affectedSlots = ((ICollection <ShortCircuitShm.Slot
                                                                           >)slots.Get(blockId));
         foreach (ShortCircuitShm.Slot slot in affectedSlots)
         {
             clientNames.AddItem(((ShortCircuitRegistry.RegisteredShm)slot.GetShm()).GetClientName
                                     ());
         }
         return(Joiner.On(",").Join(clientNames));
     }
 }
                public void Visit(int numOutstandingMmaps, IDictionary <ExtendedBlockId, ShortCircuitReplica
                                                                        > replicas, IDictionary <ExtendedBlockId, SecretManager.InvalidToken> failedLoads
                                  , IDictionary <long, ShortCircuitReplica> evictable, IDictionary <long, ShortCircuitReplica
                                                                                                    > evictableMmapped)
                {
                    NUnit.Framework.Assert.AreEqual(expectedOutstandingMmaps, numOutstandingMmaps);
                    ShortCircuitReplica replica = replicas[ExtendedBlockId.FromExtendedBlock(block)];

                    NUnit.Framework.Assert.IsNotNull(replica);
                    ShortCircuitShm.Slot slot = replica.GetSlot();
                    if ((expectedIsAnchorable != slot.IsAnchorable()) || (expectedIsAnchored != slot.
                                                                          IsAnchored()))
                    {
                        TestEnhancedByteBufferAccess.Log.Info("replica " + replica + " has isAnchorable = "
                                                              + slot.IsAnchorable() + ", isAnchored = " + slot.IsAnchored() + ".  Waiting for isAnchorable = "
                                                              + expectedIsAnchorable + ", isAnchored = " + expectedIsAnchored);
                        return;
                    }
                    result.SetValue(true);
                }
Exemplo n.º 16
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.º 17
0
 /// <exception cref="Org.Apache.Hadoop.FS.InvalidRequestException"/>
 public virtual void RegisterSlot(ExtendedBlockId blockId, ShortCircuitShm.SlotId
                                  slotId, bool isCached)
 {
     lock (this)
     {
         if (!enabled)
         {
             if (Log.IsTraceEnabled())
             {
                 Log.Trace(this + " can't register a slot because the " + "ShortCircuitRegistry is not enabled."
                           );
             }
             throw new NotSupportedException();
         }
         ShortCircuitShm.ShmId shmId            = slotId.GetShmId();
         ShortCircuitRegistry.RegisteredShm shm = segments[shmId];
         if (shm == null)
         {
             throw new InvalidRequestException("there is no shared memory segment " + "registered with shmId "
                                               + shmId);
         }
         ShortCircuitShm.Slot slot = shm.RegisterSlot(slotId.GetSlotIdx(), blockId);
         if (isCached)
         {
             slot.MakeAnchorable();
         }
         else
         {
             slot.MakeUnanchorable();
         }
         bool added = slots.Put(blockId, slot);
         Preconditions.CheckState(added);
         if (Log.IsTraceEnabled())
         {
             Log.Trace(this + ": registered " + blockId + " with slot " + slotId + " (isCached="
                       + isCached + ")");
         }
     }
 }
Exemplo n.º 18
0
 /// <summary>Mark any slots associated with this blockId as unanchorable.</summary>
 /// <param name="blockId">The block ID.</param>
 /// <returns>True if we should allow the munlock request.</returns>
 public virtual bool ProcessBlockMunlockRequest(ExtendedBlockId blockId)
 {
     lock (this)
     {
         if (!enabled)
         {
             return(true);
         }
         bool allowMunlock = true;
         ICollection <ShortCircuitShm.Slot> affectedSlots = ((ICollection <ShortCircuitShm.Slot
                                                                           >)slots.Get(blockId));
         foreach (ShortCircuitShm.Slot slot in affectedSlots)
         {
             slot.MakeUnanchorable();
             if (slot.IsAnchored())
             {
                 allowMunlock = false;
             }
         }
         return(allowMunlock);
     }
 }
Exemplo n.º 19
0
 /// <summary>Allocate a new slot and register it.</summary>
 /// <remarks>
 /// Allocate a new slot and register it.
 /// This function chooses an empty slot, initializes it, and then returns
 /// the relevant Slot object.
 /// </remarks>
 /// <returns>The new slot.</returns>
 public ShortCircuitShm.Slot AllocAndRegisterSlot(ExtendedBlockId blockId)
 {
     lock (this)
     {
         int idx = allocatedSlots.NextClearBit(0);
         if (idx >= slots.Length)
         {
             throw new RuntimeException(this + ": no more slots are available.");
         }
         allocatedSlots.Set(idx, true);
         ShortCircuitShm.Slot slot = new ShortCircuitShm.Slot(this, CalculateSlotAddress(idx
                                                                                         ), blockId);
         slot.Clear();
         slot.MakeValid();
         slots[idx] = slot;
         if (Log.IsTraceEnabled())
         {
             Log.Trace(this + ": allocAndRegisterSlot " + idx + ": allocatedSlots=" + allocatedSlots
                       + StringUtils.GetStackTrace(Sharpen.Thread.CurrentThread()));
         }
         return(slot);
     }
 }
Exemplo n.º 20
0
        /// <exception cref="System.Exception"/>
        public virtual void TestTimeBasedStaleness()
        {
            // Set up the cache with a short staleness time.
            ShortCircuitCache cache = new ShortCircuitCache(2, 10000000, 1, 10000000, 1, 10,
                                                            0);

            TestShortCircuitCache.TestFileDescriptorPair[] pairs = new TestShortCircuitCache.TestFileDescriptorPair
                                                                   [] { new TestShortCircuitCache.TestFileDescriptorPair(), new TestShortCircuitCache.TestFileDescriptorPair
                                                                            () };
            ShortCircuitReplicaInfo[] replicaInfos = new ShortCircuitReplicaInfo[] { null, null };
            long HourInMs = 60 * 60 * 1000;

            for (int i = 0; i < pairs.Length; i++)
            {
                int             iVal = i;
                ExtendedBlockId key  = new ExtendedBlockId(i, "test_bp1");
                replicaInfos[i] = cache.FetchOrCreate(key, new _ShortCircuitReplicaCreator_330(key
                                                                                               , pairs, iVal, cache, HourInMs));
                Preconditions.CheckNotNull(replicaInfos[i].GetReplica());
                Preconditions.CheckState(replicaInfos[i].GetInvalidTokenException() == null);
                pairs[i].CompareWith(replicaInfos[i].GetReplica().GetDataStream(), replicaInfos[i
                                     ].GetReplica().GetMetaStream());
            }
            // Keep trying to getOrCreate block 0 until it goes stale (and we must re-create.)
            GenericTestUtils.WaitFor(new _Supplier_351(cache), 500, 60000);
            // Make sure that second replica did not go stale.
            ShortCircuitReplicaInfo info = cache.FetchOrCreate(new ExtendedBlockId(1, "test_bp1"
                                                                                   ), new _ShortCircuitReplicaCreator_371());

            info.GetReplica().Unref();
            // Clean up
            for (int i_1 = 1; i_1 < pairs.Length; i_1++)
            {
                replicaInfos[i_1].GetReplica().Unref();
            }
            cache.Close();
        }
Exemplo n.º 21
0
 /// <exception cref="System.IO.IOException"/>
 public virtual ShortCircuitShm.Slot AllocSlot(DatanodeInfo datanode, DomainPeer peer
                                               , MutableBoolean usedPeer, ExtendedBlockId blockId, string clientName)
 {
     Lock.Lock();
     try
     {
         if (closed)
         {
             Log.Trace(this + ": the DfsClientShmManager isclosed.");
             return(null);
         }
         DfsClientShmManager.EndpointShmManager shmManager = datanodes[datanode];
         if (shmManager == null)
         {
             shmManager          = new DfsClientShmManager.EndpointShmManager(this, datanode);
             datanodes[datanode] = shmManager;
         }
         return(shmManager.AllocSlot(peer, usedPeer, clientName, blockId));
     }
     finally
     {
         Lock.Unlock();
     }
 }
Exemplo n.º 22
0
        /// <exception cref="System.Exception"/>
        public virtual void TestAllocShm()
        {
            BlockReaderTestUtil.EnableShortCircuitShmTracing();
            TemporarySocketDirectory sockDir = new TemporarySocketDirectory();
            Configuration            conf    = CreateShortCircuitConf("testAllocShm", sockDir);
            MiniDFSCluster           cluster = new MiniDFSCluster.Builder(conf).NumDataNodes(1).Build();

            cluster.WaitActive();
            DistributedFileSystem fs    = cluster.GetFileSystem();
            ShortCircuitCache     cache = fs.GetClient().GetClientContext().GetShortCircuitCache(
                );

            cache.GetDfsClientShmManager().Visit(new _Visitor_423());
            // The ClientShmManager starts off empty
            DomainPeer      peer     = GetDomainPeerToDn(conf);
            MutableBoolean  usedPeer = new MutableBoolean(false);
            ExtendedBlockId blockId  = new ExtendedBlockId(123, "xyz");
            DatanodeInfo    datanode = new DatanodeInfo(cluster.GetDataNodes()[0].GetDatanodeId(
                                                            ));

            // Allocating the first shm slot requires using up a peer.
            ShortCircuitShm.Slot slot = cache.AllocShmSlot(datanode, peer, usedPeer, blockId,
                                                           "testAllocShm_client");
            NUnit.Framework.Assert.IsNotNull(slot);
            NUnit.Framework.Assert.IsTrue(usedPeer.BooleanValue());
            cache.GetDfsClientShmManager().Visit(new _Visitor_441(datanode));
            // The ClientShmManager starts off empty
            cache.ScheduleSlotReleaser(slot);
            // Wait for the slot to be released, and the shared memory area to be
            // closed.  Since we didn't register this shared memory segment on the
            // server, it will also be a test of how well the server deals with
            // bogus client behavior.
            GenericTestUtils.WaitFor(new _Supplier_458(cache, datanode), 10, 60000);
            cluster.Shutdown();
            sockDir.Close();
        }
Exemplo n.º 23
0
 /// <summary>Allocate a new shared memory slot connected to this datanode.</summary>
 /// <remarks>
 /// Allocate a new shared memory slot connected to this datanode.
 /// Must be called with the EndpointShmManager lock held.
 /// </remarks>
 /// <param name="peer">The peer to use to talk to the DataNode.</param>
 /// <param name="usedPeer">
 /// (out param) Will be set to true if we used the peer.
 /// When a peer is used
 /// </param>
 /// <param name="clientName">The client name.</param>
 /// <param name="blockId">The block ID to use.</param>
 /// <returns>
 /// null if the DataNode does not support shared memory
 /// segments, or experienced an error creating the
 /// shm.  The shared memory segment itself on success.
 /// </returns>
 /// <exception cref="System.IO.IOException">If there was an error communicating over the socket.
 ///     </exception>
 internal virtual ShortCircuitShm.Slot AllocSlot(DomainPeer peer, MutableBoolean usedPeer
                                                 , string clientName, ExtendedBlockId blockId)
 {
     while (true)
     {
         if (this._enclosing.closed)
         {
             if (DfsClientShmManager.Log.IsTraceEnabled())
             {
                 DfsClientShmManager.Log.Trace(this + ": the DfsClientShmManager has been closed."
                                               );
             }
             return(null);
         }
         if (this.disabled)
         {
             if (DfsClientShmManager.Log.IsTraceEnabled())
             {
                 DfsClientShmManager.Log.Trace(this + ": shared memory segment access is disabled."
                                               );
             }
             return(null);
         }
         // Try to use an existing slot.
         ShortCircuitShm.Slot slot = this.AllocSlotFromExistingShm(blockId);
         if (slot != null)
         {
             return(slot);
         }
         // There are no free slots.  If someone is loading more slots, wait
         // for that to finish.
         if (this.loading)
         {
             if (DfsClientShmManager.Log.IsTraceEnabled())
             {
                 DfsClientShmManager.Log.Trace(this + ": waiting for loading to finish...");
             }
             this._enclosing.finishedLoading.AwaitUninterruptibly();
         }
         else
         {
             // Otherwise, load the slot ourselves.
             this.loading = true;
             this._enclosing.Lock.Unlock();
             DfsClientShm shm;
             try
             {
                 shm = this.RequestNewShm(clientName, peer);
                 if (shm == null)
                 {
                     continue;
                 }
                 // See #{DfsClientShmManager#domainSocketWatcher} for details
                 // about why we do this before retaking the manager lock.
                 this._enclosing.domainSocketWatcher.Add(peer.GetDomainSocket(), shm);
                 // The DomainPeer is now our responsibility, and should not be
                 // closed by the caller.
                 usedPeer.SetValue(true);
             }
             finally
             {
                 this._enclosing.Lock.Lock();
                 this.loading = false;
                 this._enclosing.finishedLoading.SignalAll();
             }
             if (shm.IsDisconnected())
             {
                 // If the peer closed immediately after the shared memory segment
                 // was created, the DomainSocketWatcher callback might already have
                 // fired and marked the shm as disconnected.  In this case, we
                 // obviously don't want to add the SharedMemorySegment to our list
                 // of valid not-full segments.
                 if (DfsClientShmManager.Log.IsDebugEnabled())
                 {
                     DfsClientShmManager.Log.Debug(this + ": the UNIX domain socket associated with "
                                                   + "this short-circuit memory closed before we could make " + "use of the shm.");
                 }
             }
             else
             {
                 this.notFull[shm.GetShmId()] = shm;
             }
         }
     }
 }