Collaboration diagram for com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >:

[legend]

Public Member Functions
int	size ()

int	slots ()

Package Functions
	CHM (ConcurrentAutoTable size)

boolean	CAS_newkvs (Object[] newkvs)

Package Attributes
volatile long	_copyDone = 0

volatile long	_copyIdx = 0

volatile Object[]	_newkvs

volatile long	_resizers

Private Member Functions
final void	copy_check_and_promote (NonBlockingHashMap topmap, Object[] oldkvs, int workdone)

boolean	copy_slot (NonBlockingHashMap topmap, int idx, Object[] oldkvs, Object[] newkvs)

final Object[]	copy_slot_and_check (NonBlockingHashMap topmap, Object[] oldkvs, int idx, Object should_help)

final void	help_copy_impl (NonBlockingHashMap topmap, Object[] oldkvs, boolean copy_all)

final Object[]	resize (NonBlockingHashMap topmap, Object[] kvs)

final boolean	tableFull (int reprobe_cnt, int len)

Private Attributes
final AtomicReferenceFieldUpdater< CHM, Object[]>	_newkvsUpdater

final ConcurrentAutoTable	_size

final ConcurrentAutoTable	_slots

Static Private Attributes
static final AtomicLongFieldUpdater< CHM >	_copyDoneUpdater

static final AtomicLongFieldUpdater< CHM >	_copyIdxUpdater

static final AtomicLongFieldUpdater< CHM >	_resizerUpdater

Detailed Description

Definition at line 802 of file NonBlockingHashMap.java.

Constructor & Destructor Documentation

◆ CHM()

com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.CHM ( ConcurrentAutoTable size )

package

Definition at line 856 of file NonBlockingHashMap.java.

                                     {
       _size = size;
       _slots= new ConcurrentAutoTable();
     }

References com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >._size, com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >._slots, and com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.size().

Referenced by com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.resize().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

◆ CAS_newkvs()

boolean com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.CAS_newkvs ( Object[] newkvs )

package

Definition at line 831 of file NonBlockingHashMap.java.

                                           {
       while( _newkvs == null )
         if( _newkvsUpdater.compareAndSet(this,null,newkvs) )
           return true;
       return false;
     }

References com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >._newkvs, and com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >._newkvsUpdater.

Referenced by com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.resize().

Here is the caller graph for this function:

◆ copy_check_and_promote()

final void com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.copy_check_and_promote	(	NonBlockingHashMap	topmap,
		Object[]	oldkvs,
		int	workdone
	)

private

Definition at line 1079 of file NonBlockingHashMap.java.

                                                                                                           {
       assert chm(oldkvs) == this;
       int oldlen = len(oldkvs);
       // We made a slot unusable and so did some of the needed copy work
       long copyDone = _copyDone;
       assert (copyDone+workdone) <= oldlen;
       if( workdone > 0 ) {
         while( !_copyDoneUpdater.compareAndSet(this,copyDone,copyDone+workdone) ) {
           copyDone = _copyDone; // Reload, retry
           assert (copyDone+workdone) <= oldlen;
         }
         //if( (10*copyDone/oldlen) != (10*(copyDone+workdone)/oldlen) )
         //System.out.print(" "+(copyDone+workdone)*100/oldlen+"%"+"_"+(_copyIdx*100/oldlen)+"%");
       }
  
       // Check for copy being ALL done, and promote.  Note that we might have
       // nested in-progress copies and manage to finish a nested copy before
       // finishing the top-level copy.  We only promote top-level copies.
       if( copyDone+workdone == oldlen && // Ready to promote this table?
           topmap._kvs == oldkvs &&       // Looking at the top-level table?
           // Attempt to promote
           topmap.CAS_kvs(oldkvs,_newkvs) ) {
         topmap._last_resize_milli = System.currentTimeMillis(); // Record resize time for next check
         //long nano = System.nanoTime();
         //System.out.println(" "+nano+" Promote table to "+len(_newkvs));
         //if( System.out != null ) System.out.print("]");
       }
     }

Referenced by com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.copy_slot_and_check(), and com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.help_copy_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copy_slot()

boolean com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.copy_slot	(	NonBlockingHashMap	topmap,
		int	idx,
		Object[]	oldkvs,
		Object[]	newkvs
	)

private

Definition at line 1119 of file NonBlockingHashMap.java.

                                                                                                       {
       // Blindly set the key slot from null to TOMBSTONE, to eagerly stop
       // fresh put's from inserting new values in the old table when the old
       // table is mid-resize.  We don't need to act on the results here,
       // because our correctness stems from box'ing the Value field.  Slamming
       // the Key field is a minor speed optimization.
       Object key;
       while( (key=key(oldkvs,idx)) == null )
         CAS_key(oldkvs,idx, null, TOMBSTONE);
  
       // ---
       // Prevent new values from appearing in the old table.
       // Box what we see in the old table, to prevent further updates.
       Object oldval = val(oldkvs,idx); // Read OLD table
       while( !(oldval instanceof Prime) ) {
         final Prime box = (oldval == null || oldval == TOMBSTONE) ? TOMBPRIME : new Prime(oldval);
         if( CAS_val(oldkvs,idx,oldval,box) ) { // CAS down a box'd version of oldval
           // If we made the Value slot hold a TOMBPRIME, then we both
           // prevented further updates here but also the (absent)
           // oldval is vacuously available in the new table.  We
           // return with true here: any thread looking for a value for
           // this key can correctly go straight to the new table and
           // skip looking in the old table.
           if( box == TOMBPRIME )
             return true;
           // Otherwise we boxed something, but it still needs to be
           // copied into the new table.
           oldval = box;         // Record updated oldval
           break;                // Break loop; oldval is now boxed by us
         }
         oldval = val(oldkvs,idx); // Else try, try again
       }
       if( oldval == TOMBPRIME ) return false; // Copy already complete here!
  
       // ---
       // Copy the value into the new table, but only if we overwrite a null.
       // If another value is already in the new table, then somebody else
       // wrote something there and that write is happens-after any value that
       // appears in the old table.  If putIfMatch does not find a null in the
       // new table - somebody else should have recorded the null-not_null
       // transition in this copy.
       Object old_unboxed = ((Prime)oldval)._V;
       assert old_unboxed != TOMBSTONE;
       putIfMatch(topmap, newkvs, key, old_unboxed, null);
  
       // ---
       // Finally, now that any old value is exposed in the new table, we can
       // forever hide the old-table value by slapping a TOMBPRIME down.  This
       // will stop other threads from uselessly attempting to copy this slot
       // (i.e., it's a speed optimization not a correctness issue).
       while( oldval != TOMBPRIME && !CAS_val(oldkvs,idx,oldval,TOMBPRIME) )
         oldval = val(oldkvs,idx);
  
       return true;
     } // end copy_slot

References com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CAS_key(), com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CAS_val(), com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.key(), com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.putIfMatch(), com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.TOMBPRIME, com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.TOMBSTONE, and com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.val().

Referenced by com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.copy_slot_and_check(), and com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.help_copy_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copy_slot_and_check()

final Object [] com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.copy_slot_and_check	(	NonBlockingHashMap	topmap,
		Object[]	oldkvs,
		int	idx,
		Object	should_help
	)

private

Definition at line 1066 of file NonBlockingHashMap.java.

                                                                                                                           {
       assert chm(oldkvs) == this;
       Object[] newkvs = _newkvs; // VOLATILE READ
       // We're only here because the caller saw a Prime, which implies a
       // table-copy is in progress.
       assert newkvs != null;
       if( copy_slot(topmap,idx,oldkvs,_newkvs) )   // Copy the desired slot
         copy_check_and_promote(topmap, oldkvs, 1); // Record the slot copied
       // Generically help along any copy (except if called recursively from a helper)
       return (should_help == null) ? newkvs : topmap.help_copy(newkvs);
     }

References com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >._newkvs, com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.chm(), com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.copy_check_and_promote(), com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.copy_slot(), and com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.help_copy().

Referenced by com.cliffc.aa.util.NonBlockingHashMap< com.cliffc.aa.type.Type.Key, com.cliffc.aa.type.Type >.get_impl(), and com.cliffc.aa.util.NonBlockingHashMap< com.cliffc.aa.type.Type.Key, com.cliffc.aa.type.Type >.putIfMatch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ help_copy_impl()

final void com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.help_copy_impl	(	NonBlockingHashMap	topmap,
		Object[]	oldkvs,
		boolean	copy_all
	)

private

Definition at line 1007 of file NonBlockingHashMap.java.

                                                                                                       {
       assert chm(oldkvs) == this;
       Object[] newkvs = _newkvs;
       assert newkvs != null;    // Already checked by caller
       int oldlen = len(oldkvs); // Total amount to copy
       final int MIN_COPY_WORK = Math.min(oldlen,1024); // Limit per-thread work
  
       // ---
       int panic_start = -1;
       int copyidx=-9999;            // Fool javac to think it's initialized
       while( _copyDone < oldlen ) { // Still needing to copy?
         // Carve out a chunk of work.  The counter wraps around so every
         // thread eventually tries to copy every slot repeatedly.
  
         // We "panic" if we have tried TWICE to copy every slot - and it still
         // has not happened.  i.e., twice some thread somewhere claimed they
         // would copy 'slot X' (by bumping _copyIdx) but they never claimed to
         // have finished (by bumping _copyDone).  Our choices become limited:
         // we can wait for the work-claimers to finish (and become a blocking
         // algorithm) or do the copy work ourselves.  Tiny tables with huge
         // thread counts trying to copy the table often 'panic'.
         if( panic_start == -1 ) { // No panic?
           copyidx = (int)_copyIdx;
           while( !_copyIdxUpdater.compareAndSet(this,copyidx,copyidx+MIN_COPY_WORK) )
             copyidx = (int)_copyIdx;      // Re-read
           if( !(copyidx < (oldlen<<1)) )  // Panic!
             panic_start = copyidx;        // Record where we started to panic-copy
         }
  
         // We now know what to copy.  Try to copy.
         int workdone = 0;
         for( int i=0; i<MIN_COPY_WORK; i++ )
           if( copy_slot(topmap,(copyidx+i)&(oldlen-1),oldkvs,newkvs) ) // Made an oldtable slot go dead?
             workdone++;         // Yes!
         if( workdone > 0 )      // Report work-done occasionally
           copy_check_and_promote( topmap, oldkvs, workdone );// See if we can promote
  
         copyidx += MIN_COPY_WORK;
         // Uncomment these next 2 lines to turn on incremental table-copy.
         // Otherwise this thread continues to copy until it is all done.
         if( !copy_all && panic_start == -1 ) // No panic?
           return;       // Then done copying after doing MIN_COPY_WORK
       }
       // Extra promotion check, in case another thread finished all copying
       // then got stalled before promoting.
       copy_check_and_promote( topmap, oldkvs, 0 );// See if we can promote
     }

Referenced by com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.SnapshotV.SnapshotV().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resize()

final Object [] com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.resize	(	NonBlockingHashMap	topmap,
		Object[]	kvs
	)

private

Definition at line 885 of file NonBlockingHashMap.java.

                                                                             {
       assert chm(kvs) == this;
  
       // Check for resize already in progress, probably triggered by another thread
       Object[] newkvs = _newkvs; // VOLATILE READ
       if( newkvs != null )       // See if resize is already in progress
         return newkvs;           // Use the new table already
  
       // No copy in-progress, so start one.  First up: compute new table size.
       int oldlen = len(kvs);    // Old count of K,V pairs allowed
       int sz = size();          // Get current table count of active K,V pairs
       int newsz = sz;           // First size estimate
  
       // Heuristic to determine new size.  We expect plenty of dead-slots-with-keys
       // and we need some decent padding to avoid endless reprobing.
       if( sz >= (oldlen>>2) ) { // If we are >25% full of keys then...
         newsz = oldlen<<1;      // Double size, so new table will be between 12.5% and 25% full
         // For tables less than 1M entries, if >50% full of keys then...
         // For tables more than 1M entries, if >75% full of keys then...
         if( 4L*sz >= ((oldlen>>20)!=0?3L:2L)*oldlen )
           newsz = oldlen<<2;    // Double double size, so new table will be between %12.5 (18.75%) and 25% (25%)
       }
       // This heuristic in the next 2 lines leads to a much denser table
       // with a higher reprobe rate
       //if( sz >= (oldlen>>1) ) // If we are >50% full of keys then...
       //  newsz = oldlen<<1;    // Double size
  
       // Last (re)size operation was very recent?  Then double again; slows
       // down resize operations for tables subject to a high key churn rate.
       long tm = System.currentTimeMillis();
       long q=0;
       if( newsz <= oldlen && // New table would shrink or hold steady?
           (tm <= topmap._last_resize_milli+10000 || // Recent resize (less than 10 sec ago)
            (q=_slots.estimate_get()) >= (sz<<1)) )  // 1/2 of keys are dead?
         newsz = oldlen<<1;      // Double the existing size
  
       // Do not shrink, ever
       if( newsz < oldlen ) newsz = oldlen;
  
       // Convert to power-of-2
       int log2;
       for( log2=MIN_SIZE_LOG; (1<<log2) < newsz; log2++ ) ; // Compute log2 of size
       long len = ((1L << log2) << 1) + 2;
       // prevent integer overflow - limit of 2^31 elements in a Java array
       // so here, 2^30 + 2 is the largest number of elements in the hash table
       if ((int)len!=len) {
         log2 = 30;
         len = (1L << log2) + 2;
         if (sz > ((len >> 2) + (len >> 1))) throw new RuntimeException("Table is full.");
       }
  
       // Now limit the number of threads actually allocating memory to a
       // handful - lest we have 750 threads all trying to allocate a giant
       // resized array.
       long r = _resizers;
       while( !_resizerUpdater.compareAndSet(this,r,r+1) )
         r = _resizers;
       // Size calculation: 2 words (K+V) per table entry, plus a handful.  We
       // guess at 64-bit pointers; 32-bit pointers screws up the size calc by
       // 2x but does not screw up the heuristic very much.
       long megs = ((((1L<<log2)<<1)+8)<<3/*word to bytes*/)>>20/*megs*/;
       if( r >= 2 && megs > 0 ) { // Already 2 guys trying; wait and see
         newkvs = _newkvs;        // Between dorking around, another thread did it
         if( newkvs != null )     // See if resize is already in progress
           return newkvs;         // Use the new table already
         // TODO - use a wait with timeout, so we'll wakeup as soon as the new table
         // is ready, or after the timeout in any case.
         //synchronized( this ) { wait(8*megs); }         // Timeout - we always wakeup
         // For now, sleep a tad and see if the 2 guys already trying to make
         // the table actually get around to making it happen.
         try { Thread.sleep(megs); } catch( Exception e ) { }
       }
       // Last check, since the 'new' below is expensive and there is a chance
       // that another thread slipped in a new thread while we ran the heuristic.
       newkvs = _newkvs;
       if( newkvs != null )      // See if resize is already in progress
         return newkvs;          // Use the new table already
  
       // Double size for K,V pairs, add 1 for CHM
       newkvs = new Object[(int)len]; // This can get expensive for big arrays
       newkvs[0] = new CHM(_size); // CHM in slot 0
       newkvs[1] = new int[1<<log2]; // hashes in slot 1
  
       // Another check after the slow allocation
       if( _newkvs != null )     // See if resize is already in progress
         return _newkvs;         // Use the new table already
  
       // The new table must be CAS'd in so only 1 winner amongst duplicate
       // racing resizing threads.  Extra CHM's will be GC'd.
       if( CAS_newkvs( newkvs ) ) { // NOW a resize-is-in-progress!
         //notifyAll();            // Wake up any sleepers
         //long nano = System.nanoTime();
         //System.out.println(" "+nano+" Resize from "+oldlen+" to "+(1<<log2)+" and had "+(_resizers-1)+" extras" );
         //if( System.out != null ) System.out.print("["+log2);
         topmap.rehash();        // Call for Hashtable's benefit
       } else                    // CAS failed?
         newkvs = _newkvs;       // Reread new table
       return newkvs;
     }

Referenced by com.cliffc.aa.util.NonBlockingHashMap< com.cliffc.aa.type.Type.Key, com.cliffc.aa.type.Type >.putIfMatch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ size()

int com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.size ( )

Definition at line 805 of file NonBlockingHashMap.java.

805 { return (int)_size.get(); }

References com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >._size, and com.cliffc.aa.util.ConcurrentAutoTable.get().

Referenced by com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.CHM(), com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.resize(), and com.cliffc.aa.util.NonBlockingHashMap< com.cliffc.aa.type.Type.Key, com.cliffc.aa.type.Type >.size().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slots()

int com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.slots ( )

Definition at line 818 of file NonBlockingHashMap.java.

818 { return (int)_slots.get(); }

References com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >._slots, and com.cliffc.aa.util.ConcurrentAutoTable.get().

Here is the call graph for this function:

◆ tableFull()

final boolean com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.tableFull	(	int	reprobe_cnt,
		int	len
	)

private

Definition at line 870 of file NonBlockingHashMap.java.

                                                                 {
       return
         // Do the cheap check first: we allow some number of reprobes always
         reprobe_cnt >= REPROBE_LIMIT &&
         (reprobe_cnt >= reprobe_limit(len) ||
          // More expensive check: see if the table is > 1/2 full.
          _slots.estimate_get() >= (len>>1));
     }

References com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >._slots, com.cliffc.aa.util.ConcurrentAutoTable.estimate_get(), com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.len(), com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.REPROBE_LIMIT, and com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.reprobe_limit().

Referenced by com.cliffc.aa.util.NonBlockingHashMap< com.cliffc.aa.type.Type.Key, com.cliffc.aa.type.Type >.putIfMatch().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ _copyDone

volatile long com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >._copyDone = 0

package

Definition at line 999 of file NonBlockingHashMap.java.

Referenced by com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.copy_check_and_promote(), and com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.help_copy_impl().

◆ _copyDoneUpdater

final AtomicLongFieldUpdater<CHM> com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >._copyDoneUpdater

staticprivate

Initial value:

=

AtomicLongFieldUpdater.newUpdater(CHM.class, "_copyDone")

Definition at line 1000 of file NonBlockingHashMap.java.

Referenced by com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.copy_check_and_promote().

◆ _copyIdx

volatile long com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >._copyIdx = 0

package

Definition at line 992 of file NonBlockingHashMap.java.

Referenced by com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.help_copy_impl().

◆ _copyIdxUpdater

final AtomicLongFieldUpdater<CHM> com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >._copyIdxUpdater

staticprivate

Initial value:

=

AtomicLongFieldUpdater.newUpdater(CHM.class, "_copyIdx")

Definition at line 993 of file NonBlockingHashMap.java.

Referenced by com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.help_copy_impl().

◆ _newkvs

volatile Object [] com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >._newkvs

package

Definition at line 827 of file NonBlockingHashMap.java.

◆ _newkvsUpdater

final AtomicReferenceFieldUpdater<CHM,Object[]> com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >._newkvsUpdater

private

Initial value:

=

AtomicReferenceFieldUpdater.newUpdater(CHM.class,Object[].class, "_newkvs")

Definition at line 828 of file NonBlockingHashMap.java.

Referenced by com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.CAS_newkvs().

◆ _resizers

volatile long com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >._resizers

package

Definition at line 850 of file NonBlockingHashMap.java.

Referenced by com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.resize().

◆ _resizerUpdater

final AtomicLongFieldUpdater<CHM> com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >._resizerUpdater

staticprivate

Initial value:

=

AtomicLongFieldUpdater.newUpdater(CHM.class, "_resizers")

Definition at line 851 of file NonBlockingHashMap.java.

Referenced by com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.resize().

◆ _size

final ConcurrentAutoTable com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >._size

private

Definition at line 804 of file NonBlockingHashMap.java.

Referenced by com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.CHM(), com.cliffc.aa.util.NonBlockingHashMap< com.cliffc.aa.type.Type.Key, com.cliffc.aa.type.Type >.putIfMatch(), com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.resize(), and com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.size().

◆ _slots

final ConcurrentAutoTable com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >._slots

private

Definition at line 817 of file NonBlockingHashMap.java.

Referenced by com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.CHM(), com.cliffc.aa.util.NonBlockingHashMap< com.cliffc.aa.type.Type.Key, com.cliffc.aa.type.Type >.putIfMatch(), com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.resize(), com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.slots(), and com.cliffc.aa.util.NonBlockingHashMap< TypeK, TypeV >.CHM< TypeK, TypeV >.tableFull().

The documentation for this class was generated from the following file:

NonBlockingHashMap.java

Public Member Functions

Package Functions

Package Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CHM()

Member Function Documentation

◆ CAS_newkvs()

◆ copy_check_and_promote()

◆ copy_slot()

◆ copy_slot_and_check()

◆ help_copy_impl()

◆ resize()

◆ size()

◆ slots()

◆ tableFull()

Member Data Documentation

◆ _copyDone

◆ _copyDoneUpdater

◆ _copyIdx

◆ _copyIdxUpdater

◆ _newkvs

◆ _newkvsUpdater

◆ _resizers

◆ _resizerUpdater

◆ _size

◆ _slots