Examples with Log com.oracle.svm.core.log.Log used on opensource projects

Example 41 with Log

use of com.oracle.svm.core.log.Log in project graal by oracle.

the class AlignedHeapChunkMemoryWalkerAccessFeature method cleanRememberedSetOfAlignedHeapChunk.

/**
 * Clean the remembered set for an AlignedHeapChunk.
 */
static void cleanRememberedSetOfAlignedHeapChunk(AlignedHeader that) {
    final Log trace = Log.noopLog().string("[AlignedHeapChunk.cleanRememberedSet:");
    trace.string("  that: ").hex(that);
    final Pointer cardTableStart = getCardTableStart(that);
    final Pointer objectsStart = getAlignedHeapChunkStart(that);
    final Pointer objectsLimit = that.getTop();
    final UnsignedWord memorySize = objectsLimit.subtract(objectsStart);
    final UnsignedWord indexLimit = CardTable.indexLimitForMemorySize(memorySize);
    trace.string("  objectsStart: ").hex(objectsStart).string("  objectsLimit: ").hex(objectsLimit).string("  indexLimit: ").unsigned(indexLimit);
    CardTable.cleanTableToIndex(cardTableStart, indexLimit);
    trace.string("]").newline();
}

Example 42 with Log

use of com.oracle.svm.core.log.Log in project graal by oracle.

the class CardTable method verifyDirtyCards.

/**
 * Check that that every object with a pointer to young space has a corresponding dirty card.
 */
private static boolean verifyDirtyCards(Pointer ctStart, Pointer objectsStart, Pointer objectsLimit) {
    final Log trace = Log.noopLog().string("[CardTable.verifyDirtyCards:");
    trace.string("  ctStart: ").hex(ctStart).string("  objectsStart: ").hex(objectsStart).string("  objectsLimit: ").hex(objectsLimit);
    /* Walk the objects */
    Pointer ptr = objectsStart;
    while (ptr.belowThan(objectsLimit)) {
        final Object obj = ptr.toObject();
        final boolean containsYoung = containsReferenceToYoungSpace(obj);
        if (containsYoung) {
            final UnsignedWord index = memoryPointerToIndex(objectsStart, objectsLimit, ptr);
            final boolean isClean = isCleanEntryAtIndex(ctStart, index);
            if (isClean) {
                /* { WITNESS */
                final boolean witnessForDebugging = true;
                final Log witness = (witnessForDebugging ? Log.log() : HeapImpl.getHeapImpl().getHeapVerifierImpl().getTraceLog());
                witness.string("[CardTable.verifyDirtyCards:").string("  objectsStart: ").hex(objectsStart).string("  objectsLimit: ").hex(objectsLimit).newline();
                witness.string("  obj: ").object(obj).string("  contains young: ").bool(containsYoung).string("  but index: ").unsigned(index).string(" is clean.").string(" returns false").string("]").newline();
                /* Return early on failure. */
                return false;
            }
        }
        ptr = LayoutEncoding.getObjectEnd(obj);
    }
    trace.string("]").newline();
    return true;
}

Example 43 with Log

use of com.oracle.svm.core.log.Log in project graal by oracle.

the class DiscoverableReferenceProcessing method clearDiscoveredReferences.

/**
 * Clear the discovered DiscoverableReference list.
 */
static void clearDiscoveredReferences() {
    final Log trace = Log.noopLog().string("[DiscoverableReference.clearDiscoveredList:").newline();
    /*
         * It's not enough to just set the discovered list to null. I also have to clean all the
         * entries from the discovered references from last time.
         */
    for (DiscoverableReference current = popDiscoveredReference(); current != null; current = popDiscoveredReference()) {
        trace.string("  current: ").object(current).string("  referent: ").hex(current.getReferentPointer()).newline();
        current.clean();
    }
    setDiscoveredList(null);
    trace.string("]");
}

Example 44 with Log

use of com.oracle.svm.core.log.Log in project graal by oracle.

the class DiscoverableReferenceProcessing method verify.

public static boolean verify(DiscoverableReference dr) {
    final Pointer refPointer = dr.getReferentPointer();
    final int refClassification = HeapVerifierImpl.classifyPointer(refPointer);
    if (refClassification < 0) {
        final Log witness = Log.log();
        witness.string("[DiscoverableReference.verify:");
        witness.string("  epoch: ").unsigned(HeapImpl.getHeapImpl().getGCImpl().getCollectionEpoch());
        witness.string("  refClassification: ").signed(refClassification);
        witness.string("]").newline();
        assert (!(refClassification < 0)) : "Bad referent.";
        return false;
    }
    /* Figure out where the referent is. */
    final HeapImpl heap = HeapImpl.getHeapImpl();
    final YoungGeneration youngGen = heap.getYoungGeneration();
    final OldGeneration oldGen = heap.getOldGeneration();
    final boolean refNull = refPointer.isNull();
    final boolean refBootImage = (!refNull) && HeapVerifierImpl.slowlyFindPointerInBootImage(refPointer);
    final boolean refYoung = (!refNull) && youngGen.slowlyFindPointer(refPointer);
    final boolean refOldFrom = (!refNull) && oldGen.slowlyFindPointerInFromSpace(refPointer);
    final boolean refOldTo = (!refNull) && oldGen.slowlyFindPointerInToSpace(refPointer);
    final boolean refOldPinnedFrom = (!refNull) && oldGen.slowlyFindPointerInPinnedFromSpace(refPointer);
    final boolean refOldPinnedTo = (!refNull) && oldGen.slowlyFindPointerInPinnedToSpace(refPointer);
    /* The referent might already have survived, or might not have. */
    if (!(refNull || refYoung || refBootImage || refOldFrom || refOldPinnedFrom)) {
        final Log witness = Log.log();
        witness.string("[DiscoverableReference.verify:");
        witness.string("  epoch: ").unsigned(HeapImpl.getHeapImpl().getGCImpl().getCollectionEpoch());
        witness.string("  refBootImage: ").bool(refBootImage);
        witness.string("  refYoung: ").bool(refYoung);
        witness.string("  refOldFrom: ").bool(refOldFrom);
        witness.string("  refOldPinnedFrom: ").bool(refOldPinnedFrom);
        witness.string("  referent should be in heap.");
        witness.string("]").newline();
        return false;
    }
    assert (!(refOldTo || refOldPinnedTo)) : "referent should be in the heap.";
    return true;
}

Example 45 with Log

use of com.oracle.svm.core.log.Log in project graal by oracle.

the class DiscoverableReferenceProcessing method processDiscoveredReferences.

/**
 * Scrub the list of entries whose referent is in the old space.
 */
static void processDiscoveredReferences() {
    final Log trace = Log.noopLog().string("[DiscoverableReference.processDiscoveredReferences: ").string("  discoveredList: ").object(getDiscoveredList()).newline();
    /* Start a new list. */
    DiscoverableReference newList = null;
    for (DiscoverableReference current = popDiscoveredReference(); current != null; current = popDiscoveredReference()) {
        trace.string("  [current: ").object(current).string("  referent before: ").hex(current.getReferentPointer()).string("]").newline();
        /*
             * The referent *has not* been processed as a grey reference, so I have to be careful
             * about looking through the referent field.
             */
        if (!processReferent(current)) {
            /* The referent isn't live: put it on the new list. */
            trace.string("  unpromoted current: ").object(current).newline();
            newList = current.prependToDiscoveredReference(newList);
        } else {
            /* Referent did get promoted: don't add it to the new list. */
            trace.string("  promoted current: ").object(current).newline();
        }
    }
    setDiscoveredList(newList);
    trace.string("]").newline();
}