---

sampling.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 "../cpu/sampling.h"
#include "../prof/prof.h"
#include "../delay/delay.h"
#include "../prof/synchronized.h"
#include "../cpu/cpuThreadMethod.h"
#include "../cpu/cpuThreadTrace.h"
#include "../cpu/cpuTrace.h"

Sampling::Sampling( JVMPI_Interface* jvmpi) :

#ifdef USE_RAW_MONITORS
        _lock( "_sampling_raw_monitor", jvmpi),
#endif
        _terminated( 1) {

        _cmd = CMD_TURN_ON;

#ifndef USE_RAW_MONITORS
#ifdef WIN32
        _turnedOn = CreateEvent(NULL, TRUE, TRUE, NULL);
        InitializeCriticalSection(&_cs);
#else
        pthread_cond_init(&_cond, NULL);
        pthread_mutex_init(&_mutex, NULL);
#endif
#endif

#ifdef _DEBUG
        start = 0;
        finish = 0;
        samples = 0;
#endif
}

Sampling::~Sampling() {

#ifndef USE_RAW_MONITORS
#ifdef WIN32
        CloseHandle(_turnedOn);
        DeleteCriticalSection(&_cs);
#else
        pthread_cond_destroy(&_cond);
        pthread_mutex_destroy(&_mutex);
#endif
#endif
}

void Sampling::main() {

        _terminated = 0;

        Prof* _prof = &Prof::prof();
        unsigned long waitTime = 1;
        unsigned long avgSampleTime = 1;
        unsigned long lastSampleTime;
        unsigned long startTime;
        unsigned long endTime;

#ifdef _DEBUG
        start = Delay::getMilliticks();
#endif

        for (;;) {

#ifndef USE_RAW_MONITORS
#ifdef WIN32
                WaitForSingleObject(_turnedOn, INFINITE);
#else
                pthread_mutex_lock(&_mutex);
                while (_cmd == CMD_TURN_OFF)
                        pthread_cond_wait(&_cond, &_mutex);
                pthread_mutex_unlock(&_mutex);
#endif
#endif

#ifdef USE_RAW_MONITORS
                Synchronized sync( _lock);
#endif

                if (_cmd == CMD_TERMINATE) {

                        _terminated = 1;
                        return;
                }

#ifdef USE_RAW_MONITORS
                sync.release();
#endif

                _prof->gcLock.wait();
                _prof->jvmpiInterface->DisableGC(); 
                _prof->dataLock.wait();

                if (_cmd != CMD_TURN_ON) {
                        _prof->dataLock.release();
                        _prof->jvmpiInterface->EnableGC(); 
                        _prof->gcLock.release(); 
                        continue;
                }

                startTime = Delay::getMilliticks();
                doOneSample();
                endTime = Delay::getMilliticks();

#ifdef _DEBUG
                finish = endTime;
#endif

                _prof->dataLock.release();
                _prof->jvmpiInterface->EnableGC(); 
                _prof->gcLock.release(); 

                if (endTime > startTime) {

                        lastSampleTime = endTime - startTime;
                        avgSampleTime = (int)(.9 * avgSampleTime + .1 * lastSampleTime);
                        if (avgSampleTime == 0) avgSampleTime = 1;

                        waitTime = avgSampleTime;
                        if (waitTime == 0) waitTime = 1;
                }

                if (_cmd != CMD_TURN_ON) continue;

                Delay::delay(waitTime);
        }
}

int Sampling::startThread(int turnedOn) {

#ifndef USE_RAW_MONITORS
#ifdef WIN32
        if (turnedOn) {

                _cmd = CMD_TURN_ON;
                SetEvent(_turnedOn);
        }
        else {
                
                _cmd = CMD_TURN_OFF;
                ResetEvent(_turnedOn);
        }
#else
        if (turnedOn) _cmd = CMD_TURN_ON;
        else _cmd = CMD_TURN_OFF;
#endif
#else
        if( !turnedOn) {

                _cmd = CMD_TURN_OFF;
                return 0;
        }
#endif

        if (Prof::prof().jvmpiInterface->CreateSystemThread((char*)SAMPLING_THREAD,
                        JVMPI_NORMAL_PRIORITY, Sampling::samplingMain) == JNI_OK) return 0;
        return -1;
}

void Sampling::terminateThread() {

#ifndef USE_RAW_MONITORS
#ifdef WIN32
        EnterCriticalSection(&_cs);

        _cmd = CMD_TERMINATE;
        SetEvent(_turnedOn);

        LeaveCriticalSection(&_cs);
#else
        pthread_mutex_lock(&_mutex);

        _cmd = CMD_TERMINATE;
        pthread_cond_signal(&_cond);

        pthread_mutex_unlock(&_mutex);
#endif
#else
        Synchronized sync( _lock);
        _cmd = CMD_TERMINATE;
#endif
}

#ifndef USE_RAW_MONITORS
void Sampling::turnOn() {

#ifdef WIN32
        EnterCriticalSection(&_cs);

        if (_cmd != CMD_TERMINATE) {

                _cmd = CMD_TURN_ON;
                SetEvent(_turnedOn);
        }

        LeaveCriticalSection(&_cs);
#else
        pthread_mutex_lock(&_mutex);

        if (_cmd != CMD_TERMINATE) {

                _cmd = CMD_TURN_ON;
                pthread_cond_signal(&_cond);
        }

        pthread_mutex_unlock(&_mutex);
#endif
}

void Sampling::turnOff() {

#ifdef WIN32
        EnterCriticalSection(&_cs);

        if (_cmd != CMD_TERMINATE) {

                _cmd = CMD_TURN_OFF;
                ResetEvent(_turnedOn);
        }

        LeaveCriticalSection(&_cs);
#else
        pthread_mutex_lock(&_mutex);

        if (_cmd != CMD_TERMINATE) {

                _cmd = CMD_TURN_OFF;
        }

        pthread_mutex_unlock(&_mutex);
#endif
}
#endif // !USE_RAW_MONITORS

void Sampling::doOneSample() {

        Prof* _prof = &Prof::prof();
        Thread* suspendList = NULL;
        Thread* thread;
        JNIEnv* envId;
        jint status;
        JVMPI_CallTrace* trace;
        JVMPI_CallFrame* frames;
        int traceDepth;
        int numFrames;
        CpuStatData* stat;

#ifdef _DEBUG
        samples++;
#endif

        if (_prof->setup.cpu.level == Setup::LEVEL_METHOD) traceDepth = 1;
        else traceDepth = _prof->setup.cpu.traceDepth; 

        thread = _prof->sampledThreads.first();
        while (thread) {

                envId = thread->threadEnvId; 
                status = _prof->jvmpiInterface->GetThreadStatus(envId);

                if ((status & (~JVMPI_THREAD_INTERRUPTED)) == JVMPI_THREAD_RUNNABLE) {

                        _prof->jvmpiInterface->SuspendThread(envId);
                        thread->nextSuspended = suspendList;
                        suspendList = thread;
                }

                thread = _prof->sampledThreads.next(thread);
        }

        for (thread = suspendList; thread; thread = thread->nextSuspended) {

                envId = thread->threadEnvId; 
                thread->hasRun = (_prof->jvmpiInterface->ThreadHasRun(envId) == JNI_TRUE);

                if (thread->hasRun) { 

                        trace = &thread->callTrace; 
                        trace->env_id = envId;
                        trace->num_frames = traceDepth;
                        
                        _prof->jvmpiInterface->GetCallTrace(trace, traceDepth);
                }
        }

        for (thread = suspendList; thread; thread = thread->nextSuspended)
                _prof->jvmpiInterface->ResumeThread(thread->threadEnvId);

        for (thread = suspendList; thread; thread = thread->nextSuspended) {

                if (thread->hasRun) {

                        envId = thread->threadEnvId; 
                        numFrames = thread->callTrace.num_frames;
                        frames = thread->callTrace.frames;
                        
                        if (numFrames > 0) {

                                if (_prof->setup.cpu.threadsEnabled) {

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

                                                if (!(stat = _prof->getCpuThreadMethod(envId, frames[0].method_id))) {
                                                        PROF_ERROR("CPU SAMPLE", "Cannot get CpuThreadMethod");
                                                        continue;
                                                }
                                        }
                                        else {

                                                if (!(stat = _prof->getCpuThreadTrace(envId, numFrames, frames))) {
                                                        PROF_ERROR("CPU SAMPLE", "Cannot get CpuThreadTrace");
                                                        continue;
                                                }
                                        }
                                }
                                else {

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

                                                if (!(stat = _prof->getMethod(frames[0].method_id))) {
                                                        PROF_ERROR("CPU SAMPLE", "Method not found");
                                                        continue;
                                                }
                                        }
                                        else {

                                                if (!(stat = _prof->getCpuTrace(numFrames, frames))) {
                                                        PROF_ERROR("CPU SAMPLE", "Cannot get CPU trace");
                                                        continue;
                                                }
                                        }
                                }
                                
                                stat->addCpuStat((jlong)1, (jlong)0);
                        }
                }
        }
}

void Sampling::samplingMain( void*) {
        
        Prof::prof().sampling.main();
}

int Sampling::isTerminated() {

#ifdef USE_RAW_MONITORS
        Synchronized sync( _lock);
#endif

        return _terminated;
}

---