---

prof.h

/*
 *                         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.
 */

#ifndef _PROF_H_
#define _PROF_H_

#include "../main/includes.h"
#include "../commun/iprof.h"
#include "../hash/hash.h"
#include "../cpu/sampling.h"
#include "../cpu/cpuThreadMethodKey.h"
#include "../shared/class.h"
#include "../shared/method.h"
#include "../shared/thread.h"
#include "../shared/groupThread.h"
#include "../alloc/allocArena.h"
#include "../alloc/allocObject.h"
#include "../alloc/allocGlobalRef.h"
#include "../gc/gc.h"

class Prof: public IProf {

        struct sF {

                jint event;

                void (Prof::*func)( JVMPI_Event*);
        };

        enum e {

                TAB_FUNC_SIZE = 40
        };

private:

        sF tabFunc[TAB_FUNC_SIZE];

public:

        JVMPI_Interface* jvmpiInterface;

public:

        Setup& setup;

        Lock gcLock;

        Lock dataLock;

        List<GroupThread,LI1> groupsOfThreads;

        List<Thread,LI4> threads;

        List<Class,LI2> classes;

        List<AllocObject,LI2> allocObjects;

        List<AllocArena,LI1> arenas;

        Hash<AllocInstance,jobjectID,LI1> instances;

        List<AllocInstance,LI1> unusedInstances;

        Hash<AllocGlobalRef,jobject,LI1> jniGlobalRefs;

        Hash<AllocGlobalRef,jobject,LI1> jniWeakGlobalRefs;

        List<GC,LI1> gcStat;

        Sampling sampling;

        List<Thread,LI5> sampledThreads;

public:

        Hash<Class,jobjectID,LI1> activeClasses;

        Hash<Method,jmethodID,LI1> activeMethods;

        Hash<Thread,JNIEnv*,LI1> activeThreads;

        Hash<AllocObject,AllocObjectKey,LI1> activeAllocObjects;

        Hash<AllocTrace,TraceKey,LI1> activeAllocTraces;

        Hash<AllocObjectMethod,AllocObjectMethodKey,LI3> activeAllocObjectMethods;

        Hash<AllocObjectTrace,AllocObjectTraceKey,LI3> activeAllocObjectTraces;

        Hash<AllocThreadMethod,AllocThreadMethodKey,LI2> activeAllocThreadMethods;

        Hash<AllocThreadTrace,AllocThreadTraceKey,LI2> activeAllocThreadTraces;

        Hash<AllocThreadObject,AllocThreadObjectKey,LI3> activeAllocThreadObjects;

        Hash<AllocThreadObjectMethod,AllocThreadObjectMethodKey,LI4> activeAllocThreadObjectMethods;

        Hash<AllocThreadObjectTrace,AllocThreadObjectTraceKey,LI4> activeAllocThreadObjectTraces;

        Hash<CpuTrace,TraceKey,LI1> activeCpuTraces;

        Hash<CpuThreadMethod,CpuThreadMethodKey,LI1> activeCpuThreadMethods;

        Hash<CpuThreadTrace,CpuThreadTraceKey,LI1> activeCpuThreadTraces;

        Hash<MonTrace,TraceKey,LI1> activeMonTraces;

        Hash<MonThreadMethod,MonThreadMethodKey,LI1> activeMonThreadMethods;

        Hash<MonThreadTrace,MonThreadTraceKey,LI1> activeMonThreadTraces;

protected:

        Prof( Setup& msetup, JVMPI_Interface* jvmpi);

public:

        virtual ~Prof();

        void runEvent( JVMPI_Event* event);

public:

        Class* getClass( jobjectID classId, int create = 1) {

                return activeClasses.get( classId);
        }       

        Method* getMethod( jmethodID methodId, int create = 1) {

                return activeMethods.get( methodId);
        }       

        Thread* getThread( JNIEnv* envId, int create = 1) {

                return activeThreads.get( envId);
        }       

        AllocTrace* getAllocTrace( int numFrames, JVMPI_CallFrame* frames, int create = 1);

        AllocObject* getAllocObject( jobjectID classId, jint isArray, int create = 1);

        AllocObjectMethod* getAllocObjectMethod( jobjectID classId, jint isArray, jmethodID methodId, int create = 1);

        AllocObjectTrace* getAllocObjectTrace( jobjectID classId, jint isArray, int numFrames, JVMPI_CallFrame* frames, int create = 1);

        AllocThreadMethod* getAllocThreadMethod( JNIEnv* envId, jmethodID methodId, int create = 1);

        AllocThreadTrace* getAllocThreadTrace( JNIEnv* envId, int numFrames, JVMPI_CallFrame* frames, int create = 1);

        AllocThreadObject* getAllocThreadObject( JNIEnv* envId, jobjectID classId, jint isArray, int create = 1);

        AllocThreadObjectMethod* getAllocThreadObjectMethod( JNIEnv* envId, jobjectID classId, jint isArray, jmethodID methodId, int create = 1);

        AllocThreadObjectTrace* getAllocThreadObjectTrace( JNIEnv* envId, jobjectID classId, jint isArray, int numFrames, JVMPI_CallFrame* frames, int create = 1);

        CpuTrace* getCpuTrace( int numFrames, JVMPI_CallFrame* frames, int create = 1);

        CpuThreadMethod* getCpuThreadMethod( JNIEnv* envId, jmethodID methodId, int create = 1);

        CpuThreadTrace* getCpuThreadTrace( JNIEnv* envId, int numFrames, JVMPI_CallFrame* frames, int create = 1);

        MonTrace* getMonTrace( int numFrames, JVMPI_CallFrame* frames, int create = 1);

        MonThreadMethod* getMonThreadMethod( JNIEnv* envId, jmethodID methodId, int create = 1);

        MonThreadTrace* getMonThreadTrace( JNIEnv* envId, int numFrames, JVMPI_CallFrame* frames, int create = 1);

private:

        void event_arenaDelete( JVMPI_Event* event);

        void event_arenaNew( JVMPI_Event* event);

        void event_classLoad( JVMPI_Event* event);

        void event_classUnload( JVMPI_Event* event);

        void event_gcStart( JVMPI_Event* event);

        void event_gcFinish( JVMPI_Event* event);

        void event_jniGlobalrefAlloc( JVMPI_Event* event);

        void event_jniGlobalrefFree( JVMPI_Event* event);

        void event_jniWeakGlobalrefAlloc( JVMPI_Event* event);

        void event_jniWeakGlobalrefFree( JVMPI_Event* event);

        void event_jvmInitDone( JVMPI_Event* event);

        void event_jvmShutDown( JVMPI_Event* event);

        void event_methodEntry( JVMPI_Event* event);

        void event_methodExit ( JVMPI_Event* event);

        void event_monitorContendedEnter( JVMPI_Event* event);

        void event_monitorContendedEntered( JVMPI_Event* event);

        void event_monitorWaited( JVMPI_Event* event);

        void event_objectAlloc( JVMPI_Event* event);

        void event_objectFree( JVMPI_Event* event);

        void event_objectMove( JVMPI_Event* event);

        void event_threadStart( JVMPI_Event* event);

        void event_threadEnd( JVMPI_Event* event);

private:

        int shuttingDown;

        int threadsSuspended;

public:

        Lock shutdownLock;

private:

        static int communThreadEnd;

        static void communThreadRoutine( void*);

public:

        virtual void shutdown();

        virtual jint isShutdowned();

        virtual void suspendVM();

        virtual void resumeVM();

        virtual void exitVM();

        virtual jint getInfo( objectID           infoId, // in (jint)
                              eInfoType          type,   // in (jint)
                              InfoBinaryFormat*& info);  // out

        virtual jint getData( objectID  objId, // in (jint)
                              eDataType type,  // in (jint)
                              sData&    data); // out

        virtual jint getAll( objectID objId,       // in (jint)
                             eSeqType what,        // in (jint)
                             jint     includeInfo, // in (jint)
                             jint     optionalArg, // in (jint)
                             seqID&   seq) {       // out

                return getAllOrChanged( objId, what, includeInfo, optionalArg, seq, 1);
        }

        virtual jint getChanged( objectID objId,       // in (jint)
                                 eSeqType what,        // in (jint)
                                 jint     includeInfo, // in (jint)
                                 jint     optionalArg, // in (jint)
                                 seqID&   seq) {       // out

                return getAllOrChanged( objId, what, includeInfo, optionalArg, seq, 0);
        }

        virtual void enableGC();

        virtual void disableGC();

        virtual void runGC();

private:

        // internally used by Prof::getAll() and Prof::getChanged()
        // not documented

        jint getAllOrChanged( objectID objId,
                              eSeqType what,
                              jint     includeInfo,
                              jint     optionalArg,
                              seqID&   seq,
                              int      all);

private:

        objectID getInfoId( IdObject* o, eSeqType seqType);

        sID* copy( sID* dest, IdObject* src, objectID infoId, jint includeInfo);

        template<class T, class L>
                void getDataFromList( List<T,L>& list,
                                      seqID&     seq,
                                      int        all,
                                      eSeqType   st,
                                      jint       includeInfo,
                                      jint       optionalArg) {
        
                T* a = list.first();
                while( a) {
                
                        if( (all || a->isChanged()) && getDataFromList_filter( a, optionalArg)) {
                        
                                seq.add( copy( new sID, a, getInfoId( a, st), includeInfo));
                                a->setUnchanged();
                        }

                        a = list.next( a);
                }
        }

        int getDataFromList_filter( IdObject* o, jint optionalArg);

        jint getInfoBinaryFormat( objectID           infoId,    // in  (jint)
                                  InfoBinaryFormat*& info,      // out (pointer)
                                  jint&              infoType); // out (jint)

public:

        static void dumpError( const char* context,
                               const char* error,
                               const char* file,
                               int line);

private:

        static Prof* _prof;

public:

        static Prof& prof() { return *_prof;}

        static Prof* create( char* options, JVMPI_Interface* jvmpi);

        static void destroy();

        static void notifyEvent( JVMPI_Event* event) {  

                if( _prof) _prof->runEvent( event);
        }

private:

        // internally used by event_threadStart() method
        // not documented

        static int findParent( Thread* t, void** inout);
        static int findGroup( GroupThread* g, void** inout);
};

#endif // _PROF_H_

---