---

prof_object.cpp

/*
 *                         Sun Public License Notice
 *
 * The contents of this file are subject to the Sun Public License
 * Version 1.0 (the "License"); you may not use this file except
 * in compliance with the License. A copy of the License is available
 * at http://www.sun.com/
 *
 * The Original Code is the Java Profiler module.  The Initial Developers
 * of the Original Code are Jan Stola, Pavel Vacha, Michal Pise, Petr Luner,
 * Lukas Petru and Marek Przeczek.
 *
 * Portions created by Jan Stola are Copyright (C) 2000-2001.
 * All Rights Reserved.
 *
 * Portions created by Pavel Vacha are Copyright (C) 2000-2001.
 * All Rights Reserved.
 *
 * Portions created by Michal Pise are Copyright (C) 2000-2001.
 * All Rights Reserved.
 *
 * Portions created by Petr Luner are Copyright (C) 2000-2001.
 * All Rights Reserved.
 *
 * Portions created by Lukas Petru are Copyright (C) 2000-2001.
 * All Rights Reserved.
 *
 * Portions created by Marek Przeczek are Copyright (C) 2000-2001.
 * All Rights Reserved.
 *
 * Contributors: Jan Stola, Pavel Vacha, Michal Pise, Petr Luner,
 *               Lukas Petru and Marek Przeczek.
 */

#include "../prof/prof.h"
#include "../prof/synchronized.h"
#include "../alloc/allocThreadObject.h"
#include "../alloc/allocObject.h"
#include "../alloc/allocThreadObjectMethod.h"
#include "../alloc/allocObjectMethod.h"
#include "../alloc/allocThreadObjectTrace.h"
#include "../alloc/allocObjectTrace.h"
#include "../alloc/allocInstance.h"
#include "../alloc/allocArena.h"

void Prof::event_objectAlloc( JVMPI_Event* event) {

        Synchronized sync(dataLock, 0);
        if (!(event->event_type & JVMPI_REQUESTED_EVENT)) sync.enter();

        JNIEnv* envId = event->env_id;
        jint arenaId = event->u.obj_alloc.arena_id;
        jobjectID classId = event->u.obj_alloc.class_id;
        jint isArray = event->u.obj_alloc.is_array;
        jint size = event->u.obj_alloc.size;
        jobjectID objId = event->u.obj_alloc.obj_id;

        if (!envId) return;
        if (!objId) return;

        AllocAbstractStatThreadObject* stat;

        if (setup.alloc.level == Setup::LEVEL_OBJECT) {

                if (setup.alloc.threadsEnabled) {

                        if (!(stat = getAllocThreadObject(envId, classId, isArray))) {
                                PROF_ERROR("OBJECT ALLOC", "Cannot get AllocThreadObject");
                                return;
                        }
                }
                else {

                        if (!(stat = getAllocObject(classId, isArray))) {
                                PROF_ERROR("OBJECT ALLOC", "Cannot get AllocObject");
                                return;
                        }
                }
        }
        else if (setup.alloc.level == Setup::LEVEL_METHOD) {

                JVMPI_CallTrace trace;
                JVMPI_CallFrame frame;

                trace.env_id     = envId;
                trace.num_frames = (jint)1;
                trace.frames     = &frame;

                jvmpiInterface->GetCallTrace(&trace, (jint)1);
                if (trace.num_frames == (jint)0) {
                        PROF_ERROR("OBJECT ALLOC", "GetCallTrace failed");
                        return;
                }

                jmethodID methodId = frame.method_id;

                if (setup.alloc.threadsEnabled) {

                        if (!(stat = getAllocThreadObjectMethod(envId, classId, isArray, methodId))) {
                                PROF_ERROR("OBJECT ALLOC", "Cannot get AllocThreadObjectMethod");
                                return;
                        }
                }
                else {

                        if (!(stat = getAllocObjectMethod(classId, isArray, methodId))) {
                                PROF_ERROR("OBJECT ALLOC", "Cannot get AllocObjectMethod");
                                return;
                        }
                }
        }
        else {
                JVMPI_CallTrace trace;
                JVMPI_CallFrame frames[MAX_TRACE];
                
                trace.env_id     = envId;
                trace.num_frames = setup.alloc.traceDepth; 
                trace.frames     = frames;

                jvmpiInterface->GetCallTrace(&trace, setup.alloc.traceDepth);
                if (trace.num_frames == (jint)0) {
                        PROF_ERROR("OBJECT ALLOC", "GetCallTrace failed");
                        return;
                }

                int numFrames = trace.num_frames;

                if (setup.alloc.threadsEnabled) {

                        if (!(stat = getAllocThreadObjectTrace(envId, classId, isArray, numFrames, frames))) {
                                PROF_ERROR("OBJECT ALLOC", "Cannot get AllocThreadObjectTrace");
                                return;
                        }
                }
                else {

                        if (!(stat = getAllocObjectTrace(classId, isArray, numFrames, frames))) {
                                PROF_ERROR("OBJECT ALLOC", "Cannot get AllocObjectTrace");
                                return;
                        }
                }
        }

        static int firstTime = 1;
        if( firstTime) {

                jvmpiInterface->EnableEvent( JVMPI_EVENT_GC_START, NULL);

                jvmpiInterface->EnableEvent( JVMPI_EVENT_JNI_GLOBALREF_ALLOC,      NULL);
                jvmpiInterface->EnableEvent( JVMPI_EVENT_JNI_WEAK_GLOBALREF_ALLOC, NULL);

                firstTime = 0;
        }

        AllocInstance* instance = unusedInstances.first();
        if (instance) unusedInstances.remove(instance);
        else instance = new AllocInstance;

        instance->objId = objId;
        instance->size  = size;
        instance->objectMethodTraceThread = stat;

        AllocArena* arena = arenas.first();
        while (arena && (!arena->active || arena->arenaId != arenaId))
                arena = arenas.next(arena);

        instance->arena = arena;
        if (arena) arena->instances.add(instance);

        instances.add(instance);

        stat->addMemoryStat(size);
}

void Prof::event_objectFree( JVMPI_Event* event) {

        jobjectID obj_id = event->u.obj_free.obj_id;

        AllocInstance* ins = instances.get( obj_id);
        if( !ins) return;

        ins->objectMethodTraceThread->subMemoryStat( ins->size);

        instances.removeNoRehash( ins);
        if( ins->arena) ins->arena->instances.remove( ins);

        unusedInstances.add( ins);
}

void Prof::event_objectMove( JVMPI_Event* event) {

        jobjectID obj_id = event->u.obj_move.obj_id;
        AllocInstance* ins = instances.get( obj_id);

        if( !ins) {

                Class* c = activeClasses.get(obj_id);
                if( !c) return;

                activeClasses.removeNoRehash(c);
                c->classId = event->u.obj_move.new_obj_id;
                activeClasses.addNoRehash(c);

                AllocObject* o;

                if (o = c->allocObject) {
                        activeAllocObjects.removeNoRehash(o);
                        o->classId = event->u.obj_move.new_obj_id;
                        activeAllocObjects.addNoRehash(o);
                }

                if (o = c->allocObjectArray) {
                        activeAllocObjects.removeNoRehash(o);
                        o->classId = event->u.obj_move.new_obj_id;
                        activeAllocObjects.addNoRehash(o);
                }

                return;
        }

        instances.removeNoRehash(ins);
        if( ins->arena) ins->arena->instances.remove( ins);

        ins->objId = event->u.obj_move.new_obj_id;

        jint new_arena_id = event->u.obj_move.new_arena_id;
        AllocArena* a = arenas.first();

        while( a && ( !a->active || a->arenaId != new_arena_id))
                a = arenas.next(a);

        ins->arena = a;
        if( a) a->instances.add( ins);

        instances.addNoRehash( ins);
}

---