docs: private void sweep()
      {
          final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
          if (isTraceOn && isTraceEnabled(false))
              Tr.entry(tc.isEntryEnabled() ? tc : tcOOM,
                       ivCache.getName() + ": Sweep (" + ivCache.numSweeps +
                                       "," + ivDiscardThreshold + ")" +
                                       " - Cache limit exceeded : " + ivCache.getSize() +
                                       "/" + ivPreferredMaxSize);
  
          int numEvicted = 0, numEvictedBelowSoftLimit = 0;
          long sweepCount = 0; // d112258
  
          try
          {
              while (ivElements.hasMoreElements() &&
                     (numEvictedBelowSoftLimit < ivSoftLimitBuffer ||
                     preferredSizeReached()))
              {
                  Element element = ivElements.nextElement();
  
                  // Basic operations on basic types are atomic, and we
                  // don't care about out-of-sync reads, so we don't
                  // bother synchronizing access to the LRU flag here
                  if (canBeDiscarded(element))
                  {
                      boolean evicted = false;
  
                      if (ivCache.ivEvictionLocks != null)
                      {
                          // DiscardStrategy requies a lock be obtained to perform
                          // eviction processing to avoid a potential deadlock.  PK04804
                          synchronized (ivCache.ivEvictionLocks.getLock(element.key))
                          {
                              evicted = ivCache.evictObject(element.key);
                          }
                      }
                      else
                      {
                          evicted = ivCache.evictObject(element.key);
                      }
  
                      if (evicted)
                      {
                          numEvicted++;
                          if (preferredSizeReached())
                              numEvictedBelowSoftLimit = 0;
                          else
                              numEvictedBelowSoftLimit++;
                      }
                  }
              }
          } catch (NoSuchElementException e)
          {
              // Enumeration may fail earlier than expected due to
              // concurrent cache access; this is not an error
              FFDCFilter.processException(e, CLASS_NAME + ".sweep", "526", this);
  
              if (isTraceOn && isTraceEnabled(false))
                  Tr.exit(tc.isEntryEnabled() ? tc : tcOOM,
                          ivCache.getName() + ": Sweep (" + ivCache.numSweeps +
                                          "," + ivDiscardThreshold + ")" +
                                          " - Evicted = " + numEvicted + " : " + ivCache.getSize() +
                                          " : NoSuchElementException");
              return;
          } finally { //PM11713
  
              // Reset the cached enumaration, so it is just like new.  This is
              // done for performance, so a new enumeration doesn't have to be
              // created (and discarded) every sweep.                          d103404.2
              // Note: performing the reset AFTER the sweep insures that the
              // cached enumerator does not hold any resources while not in
              // use (such as a copy of one of the cache buckets).               d310114 
              ivElements.reset();
          }
  
          if (isTraceOn && isTraceEnabled(false))
              Tr.exit(tc.isEntryEnabled() ? tc : tcOOM,
                      ivCache.getName() + ": Sweep (" + ivCache.numSweeps +
                                      "," + ivDiscardThreshold + ")" +
                                      " - Evicted = " + numEvicted + " : " + ivCache.getSize() +
                                      "/" + ivPreferredMaxSize);
      }