Examples of Cleaner

com.sleepycat.je.cleaner.Cleaner
The Cleaner is responsible for effectively garbage collecting the JE log. It selects the least utilized log file for cleaning (see FileSelector), reads through the log file (FileProcessor) and determines whether each entry is obsolete (no longer relavent) or active (referenced by the Btree). Entries that are active are migrated (copied) to the end of the log, and finally the cleaned file is deleted. The migration of active entries is a multi-step process that can be configured to operate in different ways. Eviction and checkpointing, as well as the cleaner threads (FileProcessor instances) are participants in this process. Migration may be immediate, lazy, or proactive. Active INs are always migrated lazily, which means that they are marked dirty by the FileProcessor, and then logged later by an eviction or checkpoint. Active LNs are either migrated lazily or immediately depending on the EnvironmentConfig.CLEANER_LAZY_MIGRATION setting. If they are migrated lazily, the migrate flag is set in the LN slot by the FileProcessor, and the LN is logged later by an eviction or checkpoint. When the FileProcessor is finished with a file, all lazy migration for that file is normally completed by the end of the next checkpoint, if not sooner via eviction. The checkpoint/recovery mechanism will ensure that obsolete entries will not be referenced by the Btree. At the end of the checkpoint, it is therefore safe to delete the log file. There is one exception to the above paragraph. When attempting to migrate an LN, if the LN cannot be locked then we must retry the migration at a later time. Also, if a database removal is in progress, we consider all entries in the database obsolete but cannot delete the log file until database removal is complete. Such "pending" LNs and databases are queued and processed periodically during file processing and at the start of a checkpoint; see processPending(). In this case, we may have to wait for more than one checkpoint to occur before the log file can be deleted. See FileSelector and the use of the pendingLNs and pendingDBs collections. The last type of migration, proactive migration, is migration of LNs by the evictor or checkpointer for files that are to-be-cleaned, i.e., part of the cleaner's backlog. The idea is to prevent the backlog from growing too large (and potentially filling the disk) by doing more cleaner work during eviction, which will throttle the application threads. By default, proactive migration is disabled, but it can enabled using EnvironmentConfig.CLEANER_BACKGROUND_PROACTIVE_MIGRATION and CLEANER_FOREGROUND_PROACTIVE_MIGRATION.
com.sun.enterprise.ee.synchronization.cleaner.Cleaner
Repository cache cleaner interface. @author Nazrul Islam @since JDK1.4
jric.cleaner.Cleaner
@author jwb09119 @date 2014/8/15
no.priv.garshol.duke.Cleaner
A function which can turn a value into a normalized value suitable for comparison.
org.jsoup.safety.Cleaner
The whitelist based HTML cleaner. Use to ensure that end-user provided HTML contains only the elements and attributes that you are expecting; no junk, and no cross-site scripting attacks!
The HTML cleaner parses the input as HTML and then runs it through a white-list, so the output HTML can only contain HTML that is allowed by the whitelist.
It is assumed that the input HTML is a body fragment; the clean methods only pull from the source's body, and the canned white-lists only allow body contained tags.
Rather than interacting directly with a Cleaner object, generally see the {@code clean} methods in {@link org.jsoup.Jsoup}.
org.surfnet.oaaas.support.Cleaner
Helper class that contains scheduled tasks for database cleanup
sun.misc.Cleaner
General-purpose phantom-reference-based cleaners.
Cleaners are a lightweight and more robust alternative to finalization. They are lightweight because they are not created by the VM and thus do not require a JNI upcall to be created, and because their cleanup code is invoked directly by the reference-handler thread rather than by the finalizer thread. They are more robust because they use phantom references, the weakest type of reference object, thereby avoiding the nasty ordering problems inherent to finalization.
A cleaner tracks a referent object and encapsulates a thunk of arbitrary cleanup code. Some time after the GC detects that a cleaner's referent has become phantom-reachable, the reference-handler thread will run the cleaner. Cleaners may also be invoked directly; they are thread safe and ensure that they run their thunks at most once.
Cleaners are not a replacement for finalization. They should be used only when the cleanup code is extremely simple and straightforward. Nontrivial cleaners are inadvisable since they risk blocking the reference-handler thread and delaying further cleanup and finalization. @author Mark Reinhold

Examples of com.sleepycat.je.cleaner.Cleaner

         * If there are cleaned files to be deleted, flush an extra level to
         * write out the parents of cleaned nodes.  This ensures that the node
         * will contain the LSN of a cleaned files.
         */
        boolean flushExtraLevel = false;
        Cleaner cleaner = envImpl.getCleaner();
        CheckpointStartCleanerState cleanerState =
            cleaner.getFilesAtCheckpointStart();
        if (!cleanerState.isEmpty()) {
            flushExtraLevel = true;
        }


        lastCheckpointMillis = System.currentTimeMillis();
        flushStats.resetPerRunCounters();


        /* Get the next checkpoint id. */
        checkpointId++;
        nCheckpoints++;


        boolean success = false;
        boolean traced = false;


        LogManager logManager = envImpl.getLogManager();


        /*
         * Set the checkpoint state so that concurrent eviction can be
         * coordinated.
         */
        checkpointDirtyMap.beginCheckpoint(flushAll, flushExtraLevel);
        try {


            /*
             * Eviction can run during checkpoint as long as it follows the
             * same rules for using provisional logging and for propagating
             * logging of the checkpoint dirty set up the tree. We have to lock
             * out the evictor after the logging of checkpoint start until
             * we've selected the dirty set and decided on the highest level to
             * be flushed. See SR 11163, 11349.
             */
            long checkpointStart = DbLsn.NULL_LSN;
            long firstActiveLsn = DbLsn.NULL_LSN;


            /* Log the checkpoint start. */
            SingleItemEntry startEntry =
                new SingleItemEntry(LogEntryType.LOG_CKPT_START,
                                    new CheckpointStart(checkpointId,
                                                        invokingSource));
            checkpointStart =
                logManager.log(startEntry, ReplicationContext.NO_REPLICATE);


            /*
             * Note the first active LSN point. The definition of
             * firstActiveLsn is that all log entries for active transactions
             * are equal to or after that LSN.  This is the starting point for
             * replaying LNs during recovery and will be stored in the CkptEnd
             * entry.
             *
             * Use the checkpointStart as the firstActiveLsn if firstActiveLsn
             * is null, meaning that no txns are active.
             *
             * The current value must be retrieved from TxnManager after
             * logging CkptStart. If it were instead retrieved before logging
             * CkptStart, the following failure could occur.  [#20270]
             *
             *  ... getFirstActiveLsn returns NULL_LSN, will use 200 CkptStart
             *  100 LN-A in Txn-1
             *  200 CkptStart
             *  300 BIN-B refers to 100 LN-A
             *  400 CkptEnd
             *  ... Crash and recover.  Recovery does not undo 100 LN-A.
             *  ... Txn-1 is uncommitted, yet 100 LN-A takes effect.
             */
            firstActiveLsn = envImpl.getTxnManager().getFirstActiveLsn();
            if (firstActiveLsn == DbLsn.NULL_LSN) {
                firstActiveLsn = checkpointStart;
            }
                
            /*
             * In a replicated system, the checkpointer will be flushing out
             * the VLSNIndex, which is HA metadata. Check that the in-memory
             * version encompasses all metadata up to the point of the
             * CheckpointStart record. This is no-op for non-replicated
             * systems. [#19754]
             */
            envImpl.awaitVLSNConsistency();


            /* Find the set of dirty INs that must be logged. */
            checkpointDirtyMap.selectDirtyINsForCheckpoint();


            /* Call hook after dirty map creation and before flushing. */
            TestHookExecute.doHookIfSet(beforeFlushHook);


            /* Flush IN nodes. */
            flushDirtyNodes(envImpl, checkpointDirtyMap, allowDeltas,
                            checkpointStart, highPriority, flushStats);


            /*
             * Flush MapLNs if not already done by flushDirtyNodes.  Only flush
             * a database if it has not already been flushed since checkpoint
             * start.  Lastly, flush the DB mapping tree root.
             */
            checkpointDirtyMap.flushMapLNs(checkpointStart);
            checkpointDirtyMap.flushRoot(checkpointStart);


            /*
             * Flush replication information if necessary so that the VLSNIndex
             * cache is flushed and is recoverable.
             */
            envImpl.preCheckpointEndFlush();


            /*
             * Flush utilization info AFTER flushing IN nodes to reduce the
             * inaccuracies caused by the sequence FileSummaryLN-LN-BIN.
             */
            envImpl.getUtilizationProfile().flushFileUtilization
                (envImpl.getUtilizationTracker().getTrackedFiles());


            DbTree dbTree = envImpl.getDbTree();
            boolean willDeleteFiles = !cleanerState.isEmpty();
            CheckpointEnd ckptEnd = new CheckpointEnd
                (invokingSource, checkpointStart, envImpl.getRootLsn(),
                 firstActiveLsn,
                 envImpl.getNodeSequence().getLastLocalNodeId(),
                 envImpl.getNodeSequence().getLastReplicatedNodeId(),
                 dbTree.getLastLocalDbId(), dbTree.getLastReplicatedDbId(),
                 envImpl.getTxnManager().getLastLocalTxnId(),
                 envImpl.getTxnManager().getLastReplicatedTxnId(),
                 checkpointId, willDeleteFiles, cleaner.getLogSummary());


            SingleItemEntry endEntry =
                new SingleItemEntry(LogEntryType.LOG_CKPT_END, ckptEnd);


            /*
             * Log checkpoint end and update state kept about the last
             * checkpoint location. Send a trace message *before* the
             * checkpoint end log entry. This is done so that the normal trace
             * message doesn't affect the time-based isRunnable() calculation,
             * which only issues a checkpoint if a log record has been written
             * since the last checkpoint.
             */
            trace(envImpl, invokingSource, true);
            traced = true;


            /*
             * Always flush to ensure that cleaned files are not referenced,
             * and to ensure that this checkpoint is not wasted if we crash.
             */
            lastCheckpointEnd =
                logManager.logForceFlush(endEntry,
                                         true /*fsyncRequired*/,
                                         ReplicationContext.NO_REPLICATE);


            lastCheckpointStart = checkpointStart;


            success = true;
            cleaner.updateFilesAtCheckpointEnd(cleanerState);


        } catch (DatabaseException e) {
            LoggerUtils.traceAndLogException(envImpl, "Checkpointer",
                                             "doCheckpoint", "checkpointId=" +
                                             checkpointId, e);

View Full Code Here

Examples of com.sleepycat.je.cleaner.Cleaner

            (EnvironmentParams.COMPRESSOR_WAKEUP_INTERVAL);
        inCompressor = new INCompressor(this, compressorWakeupInterval,
                                        Environment.INCOMP_NAME);


        /* The cleaner is not time-based so no wakeup interval is used. */
        cleaner = new Cleaner(this, Environment.CLEANER_NAME);
    }

View Full Code Here

Examples of com.sleepycat.je.cleaner.Cleaner

     * later when latched), but an exception should not occur.
     */
    @Override
    int getChildEvictionType() {


        Cleaner cleaner = getDatabase().getDbEnvironment().getCleaner();


        for (int i = 0; i < getNEntries(); i++) {
            Node node = getTarget(i);
            if (node != null) {
                if (node instanceof LN) {
                    LN ln = (LN) node;


                    /*
                     * If the LN is not evictable, we may neither strip the LN
                     * nor evict the node.  isEvictableInexact is used here as
                     * a fast check, to avoid the overhead of acquiring a
                     * handle lock while selecting an IN for eviction.   See
                     * evictInternal which will call LN.isEvictable to acquire
                     * an handle lock and guarantee that another thread cannot
                     * open the MapLN.  [#13415]
                     */
                    if (!ln.isEvictableInexact()) {
                        return MAY_NOT_EVICT;
                    }


                    /*
                     * If the cleaner allows eviction, then this LN may be
                     * stripped.
                     */
                    if (cleaner.isEvictable(this, i)) {
                        return MAY_EVICT_LNS;
                    }
                } else {
                    return MAY_NOT_EVICT;
                }

View Full Code Here

Examples of com.sleepycat.je.cleaner.Cleaner

        throws DatabaseException {


        assert isLatchOwnerForWrite() :
            "BIN must be latched before evicting LNs";


        Cleaner cleaner = getDatabase().getDbEnvironment().getCleaner();


        /*
         * We can't evict an LN which is pointed to by a cursor, in case that
         * cursor has a reference to the LN object. We'll take the cheap choice
         * and avoid evicting any LNs if there are cursors on this BIN. We

View Full Code Here

Examples of com.sleepycat.je.cleaner.Cleaner

     * Evict a single LN if allowed and adjust the memory budget.
     */
    public void evictLN(int index)
        throws DatabaseException {


        Cleaner cleaner = getDatabase().getDbEnvironment().getCleaner();
        long removed = evictInternal(index, cleaner);
        updateMemorySize(removed, 0);


        /* May decrease the memory footprint by changing the INTargetRep. */
        if (removed > 0) {

View Full Code Here

Examples of com.sleepycat.je.cleaner.Cleaner

    /**
     * @Override
     */
    int getChildEvictionType() {


        Cleaner cleaner = getDatabase().getDbEnvironment().getCleaner();


        for (int i = 0; i < getNEntries(); i++) {
            Node node = getTarget(i);
            if (node != null) {
                if (node instanceof LN) {
                    if (cleaner == null || cleaner.isEvictable(this, i)) {
                        return MAY_EVICT_LNS;
                    }
                } else {
                    return MAY_NOT_EVICT;
                }

View Full Code Here

Examples of com.sleepycat.je.cleaner.Cleaner

        throws DatabaseException {


        assert isLatchOwner() :
            "BIN must be latched before evicting LNs";


        Cleaner cleaner = getDatabase().getDbEnvironment().getCleaner();


        /* We can't evict an LN which is pointed to by a cursor, in case that
         * cursor has a reference to the LN object. We'll take the cheap
         * choice and avoid evicting any LNs if there are cursors on this
         * BIN. We could do a more expensive, precise check to see entries

View Full Code Here

Examples of com.sleepycat.je.cleaner.Cleaner

     * Evict a single LN if allowed and adjust the memory budget.
     */
    public void evictLN(int index)
        throws DatabaseException {


        Cleaner cleaner = getDatabase().getDbEnvironment().getCleaner();
        long removed = evictInternal(index, cleaner);
        updateMemorySize(removed, 0);
    }

View Full Code Here

Examples of com.sleepycat.je.cleaner.Cleaner

                               IN parent)
        throws DatabaseException {


        boolean doDeltaLog = false;
        long lastFullVersion = getLastFullVersion();
        Cleaner cleaner = getDatabase().getDbEnvironment().getCleaner();


        if (cleaner != null) {
            if (allowMigration) {


                /*
                 * Allow the cleaner to migrate LNs before logging a full
                 * version.  In the future we may not perform clustering if not
                 * called from the evictor and the evictor is active, so that
                 * we only cluster cold/LRU BINs.
                 */
                cleaner.migrateLNs(this);
            } else {


                /*
                 * If we log a BIN without migrating, add any entries with the
                 * MIGRATE flag set to the cleaner's pending LN set, so that
                 * migration will be done later.  This prevents a cleaned file
                 * from being deleted prior to migrating its entries.  This
                 * situation arises when splits do logging, since LN migration
                 * is not allowed during a split for performance reasons.
                 */
                cleaner.handleNoMigrationLogging(this);
            }
        }


        /* 
         * We can log a delta rather than full version of this BIN if

View Full Code Here

Examples of com.sleepycat.je.cleaner.Cleaner

       (EnvironmentParams.COMPRESSOR_WAKEUP_INTERVAL));
        inCompressor = new INCompressor(this, compressorWakeupInterval,
                                        "INCompressor");


        /* The cleaner is not time-based so the wakeup interval is zero. */
        cleaner = new Cleaner(this, 0, "Cleaner");
    }

View Full Code Here

0 1 2 3 4

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.