Inheritance diagram for com.cliffc.aa.util.ConcurrentAutoTable.CAT:

Collaboration diagram for com.cliffc.aa.util.ConcurrentAutoTable.CAT:

Public Member Functions
long	add_if (long x, int hash, ConcurrentAutoTable master)

long	estimate_sum ()

void	print ()

long	sum ()

String	toString ()

Package Functions
	CAT (CAT next, int sz, long init)

Static Private Member Functions
static boolean	CAS (long[] A, int idx, long old, long nnn)

static long	rawIndex (long[] ary, int i)

Private Attributes
volatile long	_fuzzy_sum_cache

volatile long	_fuzzy_time

final CAT	_next

final long[]	_t

Static Private Attributes
static final int	_Lbase = _unsafe.arrayBaseOffset(long[].class)

static final int	_Lscale = _unsafe.arrayIndexScale(long[].class)

static final Unsafe	_unsafe = UtilUnsafe.getUnsafe()

static final int	MAX_SPIN =1

Detailed Description

Definition at line 98 of file ConcurrentAutoTable.java.

Constructor & Destructor Documentation

◆ CAT()

com.cliffc.aa.util.ConcurrentAutoTable.CAT.CAT	(	CAT	next,
		int	sz,
		long	init
	)

package

Definition at line 122 of file ConcurrentAutoTable.java.

                                        {
       _next = next;
       _t = new long[sz];
       _t[0] = init;
     }

References com.cliffc.aa.util.ConcurrentAutoTable.CAT._next, and com.cliffc.aa.util.ConcurrentAutoTable.CAT._t.

Referenced by com.cliffc.aa.util.ConcurrentAutoTable.CAT.add_if().

Here is the caller graph for this function:

Member Function Documentation

◆ add_if()

long com.cliffc.aa.util.ConcurrentAutoTable.CAT.add_if	(	long	x,
		int	hash,
		ConcurrentAutoTable	master
	)

Definition at line 131 of file ConcurrentAutoTable.java.

                                                                        {
       final long[] t = _t;
       final int idx = hash & (t.length-1);
       // Peel loop; try once fast
       long old = t[idx];
       final boolean ok = CAS( t, idx, old, old+x );
       if( ok ) return old;      // Got it
       // Try harder
       int cnt=0;
       while( true ) {
         old = t[idx];
         if( CAS( t, idx, old, old+x ) ) break; // Got it!
         cnt++;
       }
       if( cnt < MAX_SPIN ) return old; // Allowable spin loop count
       if( t.length >= 1024*1024 ) return old; // too big already
  
       // Too much contention; double array size in an effort to reduce contention
       //long r = _resizers;
       //final int newbytes = (t.length<<1)<<3/*word to bytes*/;
       //while( !_resizerUpdater.compareAndSet(this,r,r+newbytes) )
       //  r = _resizers;
       //r += newbytes;
       if( master._cat != this ) return old; // Already doubled, don't bother
       //if( (r>>17) != 0 ) {      // Already too much allocation attempts?
       //  // We could use a wait with timeout, so we'll wakeup as soon as the new
       //  // table is ready, or after the timeout in any case.  Annoyingly, this
       //  // breaks the non-blocking property - so for now we just briefly sleep.
       //  //synchronized( this ) { wait(8*megs); }         // Timeout - we always wakeup
       //  try { Thread.sleep(r>>17); } catch( InterruptedException e ) { }
       //  if( master._cat != this ) return old;
       //}
  
       CAT newcat = new CAT(this,t.length*2,0);
       // Take 1 stab at updating the CAT with the new larger size.  If this
       // fails, we assume some other thread already expanded the CAT - so we
       // do not need to retry until it succeeds.
       while( master._cat == this && !master.CAS_cat(this,newcat) ) {/*empty*/}
       return old;
     }

References com.cliffc.aa.util.ConcurrentAutoTable._cat, com.cliffc.aa.util.ConcurrentAutoTable.CAT._t, com.cliffc.aa.util.ConcurrentAutoTable.CAT.CAS(), com.cliffc.aa.util.ConcurrentAutoTable.CAS_cat(), com.cliffc.aa.util.ConcurrentAutoTable.CAT.CAT(), com.cliffc.aa.util.ConcurrentAutoTable.hash(), and com.cliffc.aa.util.ConcurrentAutoTable.CAT.MAX_SPIN.

Referenced by com.cliffc.aa.util.ConcurrentAutoTable.add_if().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CAS()

static boolean com.cliffc.aa.util.ConcurrentAutoTable.CAT.CAS	(	long[]	A,
		int	idx,
		long	old,
		long	nnn
	)

staticprivate

Definition at line 108 of file ConcurrentAutoTable.java.

                                                                         {
       return _unsafe.compareAndSwapLong( A, rawIndex(A,idx), old, nnn );
     }

References com.cliffc.aa.util.ConcurrentAutoTable.CAT._unsafe, and com.cliffc.aa.util.ConcurrentAutoTable.CAT.rawIndex().

Referenced by com.cliffc.aa.util.ConcurrentAutoTable.CAT.add_if().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ estimate_sum()

long com.cliffc.aa.util.ConcurrentAutoTable.CAT.estimate_sum ( )

Definition at line 184 of file ConcurrentAutoTable.java.

                                 {
       // For short tables, just do the work
       if( _t.length <= 64 ) return sum();
       // For bigger tables, periodically freshen a cached value
       long millis = System.currentTimeMillis();
       if( _fuzzy_time != millis ) { // Time marches on?
         _fuzzy_sum_cache = sum(); // Get sum the hard way
         _fuzzy_time = millis;   // Indicate freshness of cached value
       }
       return _fuzzy_sum_cache;  // Return cached sum
     }

References com.cliffc.aa.util.ConcurrentAutoTable.CAT._fuzzy_sum_cache, com.cliffc.aa.util.ConcurrentAutoTable.CAT._fuzzy_time, com.cliffc.aa.util.ConcurrentAutoTable.CAT._t, and com.cliffc.aa.util.ConcurrentAutoTable.CAT.sum().

Referenced by com.cliffc.aa.util.ConcurrentAutoTable.estimate_get().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print()

void com.cliffc.aa.util.ConcurrentAutoTable.CAT.print ( )

Definition at line 198 of file ConcurrentAutoTable.java.

                         { 
       long[] t = _t;
       System.out.print("["+t[0]);
       for( int i=1; i<t.length; i++ ) 
         System.out.print(","+t[i]);
       System.out.print("]");
       if( _next != null ) _next.print();
     }

References com.cliffc.aa.util.ConcurrentAutoTable.CAT._next, com.cliffc.aa.util.ConcurrentAutoTable.CAT._t, and com.cliffc.aa.util.ConcurrentAutoTable.CAT.print().

Referenced by com.cliffc.aa.util.ConcurrentAutoTable.print(), and com.cliffc.aa.util.ConcurrentAutoTable.CAT.print().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rawIndex()

static long com.cliffc.aa.util.ConcurrentAutoTable.CAT.rawIndex	(	long[]	ary,
		int	i
	)

staticprivate

Definition at line 104 of file ConcurrentAutoTable.java.

                                                     {
       assert i >= 0 && i < ary.length;
       return _Lbase + i * _Lscale;
     }

References com.cliffc.aa.util.ConcurrentAutoTable.CAT._Lbase, and com.cliffc.aa.util.ConcurrentAutoTable.CAT._Lscale.

Referenced by com.cliffc.aa.util.ConcurrentAutoTable.CAT.CAS().

Here is the caller graph for this function:

◆ sum()

long com.cliffc.aa.util.ConcurrentAutoTable.CAT.sum ( )

Definition at line 175 of file ConcurrentAutoTable.java.

                        {
       long sum = _next == null ? 0 : _next.sum(); // Recursively get cached sum
       final long[] t = _t;
       for( long cnt : t ) sum += cnt;
       return sum;
     }