---

prof_jvm.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 "../delay/delay.h"

#ifdef _DEBUG

#include "../shared/classField.h"
#include "../shared/groupThread.h"
#include "../alloc/allocArena.h"
#include "../alloc/allocObject.h"
#include "../alloc/allocTrace.h"
#include "../shared/traceFrame.h"
#include "../alloc/allocInstance.h"
#include "../gc/gc.h"
#include "../alloc/allocGlobalRef.h"
#include "../alloc/allocObjectMethod.h"
#include "../alloc/allocThreadObject.h"
#include "../alloc/allocThreadObjectMethod.h"
#include "../alloc/allocThreadMethod.h"
#include "../cpu/cpuThreadMethod.h"
#include "../mon/monThreadMethod.h"

static int printMethod( Method* m, void**) {
        
        cout << m->methodName << " SIGN = " << m->methodSignature << endl;
        return 0;
}

static int printField( ClassField* f, void**) {
        
        cout << f->fieldName << " SIGN = " << f->fieldSignature << endl;
        return 0;
}

static int printClass( Class* c, void**) {
        
        cout << "CLASS = " << c->className << endl << endl;
        
        cout << "METHODS:" << endl;
        c->methods.forEach( printMethod, NULL);
        cout << endl;
        
        cout << "INSTANCE FIELDS:" << endl;
        c->instances.forEach( printField, NULL);
        cout << endl;

        cout << "STATIC FIELDS:" << endl;
        c->statics.forEach( printField, NULL);
        cout << endl;

        return 0;
}

static int printThread( Thread* t, void**) {
        
        cout << t->threadName << " : " << (long)(t->threadEnvId) << endl;
        return 0;
}

static int printGroup( GroupThread* g, void**) {
        
        cout << "GROUP = " << g->groupName << endl;
        g->threads.forEach( printThread, NULL);
        cout << endl;

        return 0;
}

static int printArena( AllocArena* a, void**) {
        
        cout << "ARENA = " << a->arenaName << endl << endl;
        return 0;
}

static int printObject( AllocObject* o, void**) {
        
        cout << "OBJECT TYPE:" << endl;
        if( o->clss) cout << "CLASS = " << o->clss->className << endl;

        String s;
        switch( o->isArray) {
        case JVMPI_NORMAL_OBJECT:
                s = "JVMPI_NORMAL_OBJECT";
                break;
        case JVMPI_CLASS:
                s = "JVMPI_CLASS";
                break;
        case JVMPI_BOOLEAN:
                s = "JVMPI_BOOLEAN";
                break;
        case JVMPI_BYTE:
                s = "JVMPI_BYTE";
                break;
        case JVMPI_CHAR:
                s = "JVMPI_CHAR";
                break;
        case JVMPI_SHORT:
                s = "JVMPI_SHORT";
                break;
        case JVMPI_INT:
                s = "JVMPI_INT";
                break;
        case JVMPI_LONG:
                s = "JVMPI_LONG";
                break;
        case JVMPI_FLOAT:
                s = "JVMPI_FLOAT";
                break;
        case JVMPI_DOUBLE:
                s = "JVMPI_DOUBLE";
                break;
        }
        
        cout << "IS_ARRAY = " << s << endl;
        cout << endl;

        return 0;
}

static int printAllocTrace( AllocTrace* at, void**) {
        
        cout << "ALLOC_TRACE:" << endl;
        for( int i = 0; i < at->numFrames; i++) {

                cout << "method:       " << at->frames[i].method->methodName << endl;
                cout << "method sign:  " << at->frames[i].method->methodSignature << endl;
                cout << "method class: " << at->frames[i].method->clss->className << endl;
                cout << "lineno: " << at->frames[i].lineno << endl << endl;
        }

        return 0;
}

static int printInstance( AllocInstance* ins, void**) {
        
        cout << "INSTANCE:" << endl;
        cout << "id:   " << ins->objId << endl;
        cout << "size: " << ins->size << endl;
        cout << endl;

        return 0;
}

static int printGC( GC* gc, void**) {
        
        cout << "GC:" << endl;
        cout << "start: " << ctime( &gc->startTime) << endl;
        cout << "end:   " << ctime( &gc->endTime) << endl;
        cout << endl;

        return 0;
}

static int printGlobalRefs( AllocGlobalRef* r, void**) {

        cout << "JNI (WEAK) GLOBALREF:" << endl;
        printInstance( r->instance, NULL);
        cout << "reference id: " << r->refId << endl;
        cout << endl;

        return 0;
}

static void printHashStatistics() {

        Prof* _prof = &Prof::prof();

        cout << "HASH TABLE STATISTICS:" << endl;
        cout << endl;

        cout << "activeClasses:" << endl;
        _prof->activeClasses.printStatistics(); 
        cout << endl;

        cout << "activeMethods:" << endl;
        _prof->activeMethods.printStatistics(); 
        cout << endl;

        cout << "activeCpuThreadMethods:" << endl;
        _prof->activeCpuThreadMethods.printStatistics(); 
        cout << endl;

        cout << "activeCpuTraces:" << endl;
        _prof->activeCpuTraces.printStatistics(); 
        cout << endl;

        cout << "activeCpuThreadTraces:" << endl;
        _prof->activeCpuThreadTraces.printStatistics(); 
        cout << endl;

        cout << "instances:" << endl;
        _prof->instances.printStatistics(); 
        cout << endl;
}

static void printTotals() {

        Prof* _prof = &Prof::prof();

        long totalClasses = 0;
        long totalMethods = 0;
        long totalAllocTraces = 0;
        long totalAllocObjects = 0;
        long totalAllocObjectMethods = 0;
        long totalAllocObjectTraces = 0;
        long totalThreads = 0;
        long totalAllocThreadObjects = 0;
        long totalAllocThreadObjectMethods = 0;
        long totalAllocThreadObjectTraces = 0;
        long totalAllocThreadMethods = 0;
        long totalAllocThreadTraces = 0;
        long totalCpuTraces = 0;
        long totalCpuThreadMethods = 0;
        long totalCpuThreadTraces = 0;
        long totalMonTraces = 0;
        long totalMonThreadMethods = 0;
        long totalMonThreadTraces = 0;

        Class* c = _prof->classes.first();
        while (c) {

                Method* m = c->methods.first();
                while (m) {

                        AllocTrace* at = m->allocTraces.first();
                        while (at) {

                                totalAllocTraces++;
                                at = m->allocTraces.next(at);
                        }

                        CpuTrace* ct = m->cpuTraces.first();
                        while (ct) {

                                totalCpuTraces++;
                                ct = m->cpuTraces.next(ct);
                        }

                        MonTrace* mt = m->monTraces.first();
                        while (mt) {

                                totalMonTraces++;
                                mt = m->monTraces.next(mt);
                        }

                        totalMethods++;
                        m = c->methods.next(m);
                }

                totalClasses++;
                c = _prof->classes.next(c);
        }

        AllocObject* ao = _prof->allocObjects.first();
        while (ao) {

                AllocObjectMethod *aom = ao->objectMethods.first();
                while (aom) {

                        AllocObjectTrace* aot = aom->objectTraces.first();
                        while (aot) {

                                totalAllocObjectTraces++;
                                aot = aom->objectTraces.next(aot);
                        }

                        totalAllocObjectMethods++;
                        aom = ao->objectMethods.next(aom);
                }

                totalAllocObjects++;
                ao = _prof->allocObjects.next(ao);
        }

        Thread* t = _prof->threads.first();
        while (t) {

                AllocThreadObject* ato = t->allocThreadObjects.first();
                while (ato) {

                        AllocThreadObjectMethod* atom = ato->threadObjectMethods.first();
                        while (atom) {

                                AllocThreadObjectTrace* atot = atom->threadObjectTraces.first();
                                while (atot) {

                                        totalAllocThreadObjectTraces++;
                                        atot = atom->threadObjectTraces.next(atot);
                                }

                                totalAllocThreadObjectMethods++;
                                atom = ato->threadObjectMethods.next(atom);
                        }

                        totalAllocThreadObjects++;
                        ato = t->allocThreadObjects.next(ato);
                }

                AllocThreadMethod* atm = t->allocThreadMethods.first();
                while (atm) {

                        AllocThreadTrace* att = atm->threadTraces.first();
                        while (att) {

                                totalAllocThreadTraces++;
                                att = atm->threadTraces.next(att);
                        }

                        totalAllocThreadMethods++;
                        atm = t->allocThreadMethods.next(atm);
                }

                CpuThreadMethod* ctm = t->cpuThreadMethods.first();
                while (ctm) {

                        CpuThreadTrace* ctt = ctm->threadTraces.first();
                        while (ctt) {

                                totalCpuThreadTraces++;
                                ctt = ctm->threadTraces.next(ctt);
                        }

                        totalCpuThreadMethods++;
                        ctm = t->cpuThreadMethods.next(ctm);
                }

                MonThreadMethod* mtm = t->monThreadMethods.first();
                while (mtm) {

                        MonThreadTrace* mtt = mtm->threadTraces.first();
                        while (mtt) {

                                totalMonThreadTraces++;
                                mtt = mtm->threadTraces.next(mtt);
                        }

                        totalMonThreadMethods++;
                        mtm = t->monThreadMethods.next(mtm);
                }

                totalThreads++;
                t = _prof->threads.next(t);
        }

        cout << "TOTALS:" << endl;
        cout << endl;

        cout << "Classes: " << totalClasses << endl;
        cout << "Methods: " << totalMethods << endl;
        cout << "Threads: " << totalThreads << endl;
        cout << endl;

        cout << "AllocObject: " << totalAllocObjects << endl;
        cout << "AllocThreadObject: " << totalAllocThreadObjects << endl;
        cout << endl;

        cout << "AllocObjectMethod: " << totalAllocObjectMethods << endl;
        cout << "AllocThreadMethod: " << totalAllocThreadMethods << endl;
        cout << "AllocThreadObjectMethod: " << totalAllocThreadObjectMethods << endl;
        cout << endl;
        
        cout << "AllocTrace: " << totalAllocTraces << endl;
        cout << "AllocObjectTrace: " << totalAllocObjectTraces << endl;
        cout << "AllocThreadTrace: " << totalAllocThreadTraces << endl;
        cout << "AllocThreadObjectTrace: " << totalAllocThreadObjectTraces << endl;
        cout << endl;

        cout << "CpuThreadMethod: " << totalCpuThreadMethods << endl;
        cout << endl;

        cout << "CpuTrace: " << totalCpuTraces << endl;
        cout << "CpuThreadTrace: " << totalCpuThreadTraces << endl;
        cout << endl;

        cout << "MonThreadMethod: " << totalMonThreadMethods << endl;
        cout << endl;

        cout << "MonTrace: " << totalMonTraces << endl;
        cout << "MonThreadTrace: " << totalMonThreadTraces << endl;
        cout << endl;
}

static void printSampling() {

        unsigned long start = Prof::prof().sampling.start;
        unsigned long finish = Prof::prof().sampling.finish;
        unsigned long samples = Prof::prof().sampling.samples;

        cout << "SAMPLING:" << endl << endl;
        cout << "start: " << start << " ms" << endl;  
        cout << "finish: " << finish << " ms" << endl;  
        cout << "samples: " << samples << endl;  

        if ((samples > 0) && (finish > start)) 
                cout << "period: " << (double)(finish - start) / (double)samples << " ms" << endl;  

        cout << endl;
}
#endif // _DEBUG

void Prof::event_jvmInitDone( JVMPI_Event* event) {

        // enable some curious events ;-)

        jvmpiInterface->EnableEvent( JVMPI_EVENT_THREAD_START, NULL);
        jvmpiInterface->EnableEvent( JVMPI_EVENT_CLASS_LOAD,   NULL);

        if( setup.alloc.turnedOn) jvmpiInterface->EnableEvent( JVMPI_EVENT_ARENA_NEW, NULL);

        jvmpiInterface->EnableEvent ( JVMPI_EVENT_JVM_SHUT_DOWN, NULL);
        jvmpiInterface->DisableEvent( JVMPI_EVENT_JVM_INIT_DONE, NULL);

        if( setup.cpu.turnedOn && setup.cpu.sampling) sampling.startThread( 1);

        jvmpiInterface->CreateSystemThread( (char*)COMMUN_THREAD,
                JVMPI_NORMAL_PRIORITY,
                Prof::communThreadRoutine);
}

void Prof::event_jvmShutDown( JVMPI_Event* event) {

        if( isConnectionEstablished()) {

                communLock.wait();
                dataLock.wait();
        }

        if( setup.cpu.turnedOn && setup.cpu.sampling) sampling.terminateThread();
        shuttingDown = 1;

        if( isConnectionEstablished()) {

                communLock.release();
                shutdownLock.wait();
                communLock.wait();
        }
        else communThreadEnd = 1;

#ifdef _DEBUG
        classes.forEach( printClass, NULL);
        groupsOfThreads.forEach( printGroup, NULL);
        allocObjects.forEach( printObject, NULL);
        arenas.forEach( printArena, NULL);
        instances.forEach( printInstance, NULL);
        gcStat.forEach( printGC, NULL);
        jniGlobalRefs.forEach( printGlobalRefs, NULL);
        jniWeakGlobalRefs.forEach( printGlobalRefs, NULL);
        printHashStatistics();
        printTotals();
        printSampling();
#endif

        // that's amazing ! must be called in reverse order ;-)

        jvmpiInterface->DisableEvent( JVMPI_EVENT_CLASS_UNLOAD, NULL);
        jvmpiInterface->DisableEvent( JVMPI_EVENT_CLASS_LOAD,   NULL);

        jvmpiInterface->DisableEvent( JVMPI_EVENT_METHOD_EXIT,  NULL);
        jvmpiInterface->DisableEvent( JVMPI_EVENT_METHOD_ENTRY, NULL);

        jvmpiInterface->DisableEvent( JVMPI_EVENT_THREAD_END,   NULL);
        jvmpiInterface->DisableEvent( JVMPI_EVENT_THREAD_START, NULL);

        jvmpiInterface->DisableEvent( JVMPI_EVENT_GC_FINISH, NULL);
        jvmpiInterface->DisableEvent( JVMPI_EVENT_GC_START,  NULL);

        jvmpiInterface->DisableEvent( JVMPI_EVENT_ARENA_DELETE, NULL);
        jvmpiInterface->DisableEvent( JVMPI_EVENT_ARENA_NEW,    NULL);

        jvmpiInterface->DisableEvent( JVMPI_EVENT_OBJECT_FREE,  NULL);
        jvmpiInterface->DisableEvent( JVMPI_EVENT_OBJECT_MOVE,  NULL);
        jvmpiInterface->DisableEvent( JVMPI_EVENT_OBJECT_ALLOC, NULL);

        jvmpiInterface->DisableEvent( JVMPI_EVENT_JNI_GLOBALREF_FREE,  NULL);
        jvmpiInterface->DisableEvent( JVMPI_EVENT_JNI_GLOBALREF_ALLOC, NULL);

        jvmpiInterface->DisableEvent( JVMPI_EVENT_JNI_WEAK_GLOBALREF_FREE,  NULL);
        jvmpiInterface->DisableEvent( JVMPI_EVENT_JNI_WEAK_GLOBALREF_ALLOC, NULL);

        jvmpiInterface->DisableEvent( JVMPI_EVENT_MONITOR_WAITED,            NULL);
        jvmpiInterface->DisableEvent( JVMPI_EVENT_MONITOR_CONTENDED_ENTERED, NULL);
        jvmpiInterface->DisableEvent( JVMPI_EVENT_MONITOR_CONTENDED_ENTER,   NULL);

        jvmpiInterface->DisableEvent( JVMPI_EVENT_JVM_SHUT_DOWN, NULL);

        dataLock.release();

        while( !sampling.isTerminated()) Delay::delay( 10);
        Delay::delay( 1000);

        dataLock.wait();

        Prof::destroy();
        exit( 0); // for sure
}

---