---

prof_method.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 "../cpu/cpuThreadMethod.h"
#include "../cpu/cpuThreadTrace.h"
#include "../cpu/cpuTrace.h"

void Prof::event_methodEntry( JVMPI_Event* event) {

        Synchronized sync(dataLock);

        jlong entryTime;
        JVMPI_CallFrame callFrame;
        JVMPI_CallTrace callTrace;
        Thread* thread;

        callTrace.env_id     = event->env_id;
        callTrace.num_frames = (jint)1;
        callTrace.frames     = &callFrame;

        jvmpiInterface->GetCallTrace(&callTrace, (jint)1);

        if (callTrace.num_frames != (jint)1) {
                PROF_ERROR("METHOD ENTRY", "GetCallTrace failed");
                return;
        }
        if (callFrame.method_id != event->u.method.method_id) {
                PROF_ERROR("METHOD ENTRY", "callFrame.method_id != event->method.method_id");
                return;
        }

        if (!(thread = getThread(event->env_id))) {
                PROF_ERROR("METHOD ENTRY", "Thread not found");
                return;
        }

        entryTime = jvmpiInterface->GetCurrentThreadCpuTime();
        thread->stack.push(callFrame, entryTime); 

        static int firstTime = 1;
        if( firstTime) {

                jvmpiInterface->EnableEvent( JVMPI_EVENT_METHOD_EXIT, NULL);
                firstTime = 0;
        }
}

void Prof::event_methodExit( JVMPI_Event* event) {

        Synchronized sync(dataLock);

        Thread* thread;
        JVMPI_CallFrame callFrames[MAX_TRACE];
        int numFrames;
        jlong exitTime;
        jlong totalTime;
        jlong pureTime;
        CpuStatData* stat;
        
        if (!(thread = getThread(event->env_id))) {
                PROF_ERROR("METHOD EXIT", "Thread not found");
                return;
        }

        if (setup.cpu.level == Setup::LEVEL_METHOD) {
                numFrames = 1;
        }
        else numFrames = setup.cpu.traceDepth;

        numFrames = thread->stack.getTopCallTrace(numFrames, callFrames);
        if (numFrames == 0) {
                PROF_ERROR("METHOD EXIT", "Empty stack");
                return;
        }

        if (callFrames[0].method_id != event->u.method.method_id) {
                PROF_ERROR("METHOD EXIT", "top method != event->method.method_id");
                return;
        }

        exitTime = jvmpiInterface->GetCurrentThreadCpuTime();
        thread->stack.pop(exitTime, totalTime, pureTime);

        if (setup.cpu.threadsEnabled) {

                if (setup.cpu.level == Setup::LEVEL_METHOD) {

                        if (!(stat = getCpuThreadMethod(event->env_id, callFrames[0].method_id))) {
                                PROF_ERROR("METHOD EXIT", "Cannot get CpuThreadMethod");
                                return;
                        }
                }
                else {

                        if (!(stat = getCpuThreadTrace(event->env_id, numFrames, callFrames))) {
                                PROF_ERROR("METHOD EXIT", "Cannot get CpuThreadTrace");
                                return;
                        }
                }
        }
        else {
                if (setup.cpu.level == Setup::LEVEL_METHOD) {

                        if (!(stat = getMethod(callFrames[0].method_id))) {
                                PROF_ERROR("METHOD EXIT", "Method not found");
                                return;
                        }
                }
                else {

                        if (!(stat = getCpuTrace(numFrames, callFrames))) {
                                PROF_ERROR("METHOD EXIT", "Cannot get CPU trace");
                                return;
                        }
                }
        } 

        stat->addCpuStat((jlong)1, pureTime);
}

---