Java ArrayCounter类代码示例

import org.hsqldb.lib.ArrayCounter; //导入依赖的package包/类
/**
 * Return the max accessCount value for count elements with the lowest
 * access count. Always return at least accessMin + 1
 */
protected int getAccessCountCeiling(int count, int margin) {
    return ArrayCounter.rank(accessTable, hashIndex.newNodePointer, count,
                             accessMin, accessCount, margin);
}
 

import org.hsqldb.lib.ArrayCounter; //导入依赖的package包/类
/**
 * Return the max accessCount value for count elements with the lowest
 * access count. Always return at least accessMin + 1
 */
public int getAccessCountCeiling(int count, int margin) {
    return ArrayCounter.rank(accessTable, hashIndex.newNodePointer, count,
                             accessMin + 1, accessCount, margin);
}
 

import org.hsqldb.lib.ArrayCounter; //导入依赖的package包/类
/**
     * Reduces the number of rows held in this Cache object. <p>
     *
     * Cleanup is done by checking the accessCount of the Rows and removing
     * the rows with the lowest access count.
     *
     * Index operations require that up to 5 recently accessed rows remain
     * in the cache.
     *
     */
    private void cleanUp() throws HsqlException {

        // put access count in the array
        for (int i = 0; i < iCacheSize; i++) {
            accessCount[i] = rFirst.iLastAccess;
            rFirst         = rFirst.rNext;
        }

//        rankTimer.start();
        // It is possible the target access count is shared
        // by many elements due to resetting of all access counts. So remove
        // the next access count to account for this condition.
        firstAccessCount =
            ArrayCounter.rank(
                accessCount, iCacheSize / 4, firstAccessCount,
                currentAccessCount, iCacheSize / 512) + 1;

//        rankTimer.stop();
        // put all low rows in the array
        int removecount = 0;

        for (int i = 0; i < iCacheSize; i++) {
            if (rFirst.iLastAccess < firstAccessCount) {
                rowTable[removecount++] = rFirst;
            }

            rFirst = rFirst.rNext;
        }

        rowComparator.setType(rowComparator.COMPARE_POSITION);

//        sortTimer.start();
        Sort.sort(rowTable, rowComparator, 0, removecount - 1);

//        sortTimer.stop();
//        saveAllTimer.start();
        int removedRows = 0;

        for (int i = 0; i < removecount; i++) {
            CachedRow r = rowTable[i];

            try {
                if (r.hasChanged()) {
                    saveRow(r);

                    saveRowCount++;
                }

                if (!r.isRoot()) {
                    remove(r);

                    removedRows++;
                }
            } catch (Exception e) {
                throw Trace.error(Trace.FILE_IO_ERROR, Trace.Cache_cleanUp,
                                  new Object[]{ e });
            }

            // all rows must be cleard from array - even those that remain in cache
            rowTable[i] = null;
        }

//        saveAllTimer.stop();
        // Trace.printSystemOut("cache.cleanup() min access: ", tempfirstaccess);
        // Trace.printSystemOut("cache.cleanup() current access: ", currentAccessCount);
        // Trace.printSystemOut("cache.cleanup() total saveRowCount: ", saveRowCount);
        // Trace.printSystemOut("cache.cleanup() removed row count for this call: ", removedRows);
        initBuffers();
    }
 

import org.hsqldb.lib.ArrayCounter; //导入依赖的package包/类
/**
 * Return the max accessCount value for count elements with the lowest
 * access count
 */
protected int getAccessCountCeiling(int count, int margin) {
    return ArrayCounter.rank(accessTable, count, accessMin, accessCount,
                             margin);
}
 

import org.hsqldb.lib.ArrayCounter; //导入依赖的package包/类
/**
 * Return the max accessCount value for count elements with the lowest
 * access count. Always return at least accessMin + 1
 */
protected int getAccessCountCeiling(int count, int margin) {
    return ArrayCounter.rank(accessTable, hashIndex.newNodePointer, count,
                             accessMin + 1, accessCount, margin);
}