---

prof_monitor.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 "../delay/delay.h"
#include "../mon/monThreadMethod.h"
#include "../mon/monThreadTrace.h"
#include "../mon/monTrace.h"

void Prof::event_monitorContendedEnter( JVMPI_Event* event) {

        Synchronized sync(dataLock);

        Thread* t;
        if (!(t = getThread(event->env_id))) {
                PROF_ERROR("MONITOR CONTENDED ENTER", "Thread not found");
                return;
        }

        static int firstTime = 1;
        if( firstTime) {

                jvmpiInterface->EnableEvent( JVMPI_EVENT_MONITOR_CONTENDED_ENTERED, NULL);
                jvmpiInterface->EnableEvent( JVMPI_EVENT_MONITOR_WAITED,            NULL);

                firstTime = 0;
        }

        t->monitorEnter = 1;
        t->monitorEnterObject = event->u.monitor.object;
        t->monitorEnterTime = Delay::getMilliticks(); 
}

void Prof::event_monitorContendedEntered( JVMPI_Event* event) {

        Synchronized sync(dataLock);

        Thread* t;
        if (!(t = getThread(event->env_id))) {
                PROF_ERROR("MONITOR CONTENDED ENTERED", "Thread not found");
                return;
        }

        if ((!(t->monitorEnter)) || (t->monitorEnterObject != event->u.monitor.object)) {
                PROF_ERROR("MONITOR CONTENDED ENTERED", "No corresponding MONITOR CONTENDED ENTER");
                t->monitorEnter = 0;
                return;
        }
        t->monitorEnter = 0;

        unsigned long curTime = Delay::getMilliticks();
        if (curTime < t->monitorEnterTime) return;

        int numFrames = 1;
        if (setup.mon.level == Setup::LEVEL_TRACE) numFrames = setup.mon.traceDepth; 

        JVMPI_CallTrace callTrace;
        JVMPI_CallFrame callFrames[MAX_TRACE];

        callTrace.env_id     = event->env_id;
        callTrace.num_frames = (jint)numFrames;
        callTrace.frames     = callFrames;

        jvmpiInterface->GetCallTrace(&callTrace, (jint)numFrames);
        numFrames = callTrace.num_frames;
        if (numFrames == 0) {
                PROF_ERROR("MONITOR CONTENDED ENTERED", "GetCallTrace failed");
                return;
        }

        MonStatData* stat;

        if (setup.mon.threadsEnabled) {

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

                        if (!(stat = getMonThreadMethod(event->env_id, callFrames[0].method_id))) {
                                PROF_ERROR("MONITOR CONTENDED ENTERED", "Cannot get MonThreadMethod");
                                return;
                        }
                }
                else {

                        if (!(stat = getMonThreadTrace(event->env_id, numFrames, callFrames))) {
                                PROF_ERROR("MONITOR CONTENDED ENTERED", "Cannot get MonThreadTrace");
                                return;
                        }
                }
        }
        else {
                if (setup.mon.level == Setup::LEVEL_METHOD) {

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

                        if (!(stat = getMonTrace(numFrames, callFrames))) {
                                PROF_ERROR("MONITOR CONTENDED ENTERED", "Cannot get MonTrace");
                                return;
                        }
                }
        } 

        int hits = (stat->wait) ? 0 : 1;
        stat->addMonStat(hits, curTime - t->monitorEnterTime);
}

void Prof::event_monitorWaited( JVMPI_Event* event) {

        Synchronized sync(dataLock);

        Thread* t;
        if (!(t = getThread(event->env_id))) {
                PROF_ERROR("MONITOR WAITED", "Thread not found");
                return;
        }

        int numFrames = 1;
        if (setup.mon.level == Setup::LEVEL_TRACE) numFrames = setup.mon.traceDepth; 

        JVMPI_CallTrace callTrace;
        JVMPI_CallFrame callFrames[MAX_TRACE];

        callTrace.env_id     = event->env_id;
        callTrace.num_frames = (jint)numFrames;
        callTrace.frames     = callFrames;

        jvmpiInterface->GetCallTrace(&callTrace, (jint)numFrames);
        numFrames = callTrace.num_frames;
        if (numFrames == 0) {
                PROF_ERROR("MONITOR WAITED", "GetCallTrace failed");
                return;
        }

        MonStatData* stat;

        if (setup.mon.threadsEnabled) {

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

                        if (!(stat = getMonThreadMethod(event->env_id, callFrames[0].method_id))) {
                                PROF_ERROR("MONITOR WAITED", "Cannot get MonThreadMethod");
                                return;
                        }
                }
                else {

                        if (!(stat = getMonThreadTrace(event->env_id, numFrames, callFrames))) {
                                PROF_ERROR("MONITOR WAITED", "Cannot get MonThreadTrace");
                                return;
                        }
                }
        }
        else {
                if (setup.mon.level == Setup::LEVEL_METHOD) {

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

                        if (!(stat = getMonTrace(numFrames, callFrames))) {
                                PROF_ERROR("MONITOR WAITED", "Cannot get MonTrace");
                                return;
                        }
                }
        } 

        stat->wait = 1;
        stat->addMonStat(1, event->u.monitor_wait.timeout);
}

---