---

prof_get.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 "../cpu/cpuTrace.h"
#include "../shared/traceFrame.h"
#include "../cpu/cpuThreadMethod.h"
#include "../cpu/cpuThreadTrace.h"
#include "../alloc/allocTrace.h"
#include "../alloc/allocObject.h"
#include "../alloc/allocObjectMethod.h"
#include "../alloc/allocObjectTrace.h"
#include "../alloc/allocThreadMethod.h"
#include "../alloc/allocThreadTrace.h"
#include "../alloc/allocThreadObject.h"
#include "../alloc/allocThreadObjectMethod.h"
#include "../alloc/allocThreadObjectTrace.h"
#include "../mon/monTrace.h"
#include "../mon/monThreadMethod.h"
#include "../mon/monThreadTrace.h"

CpuTrace* Prof::getCpuTrace(int numFrames, JVMPI_CallFrame* frames, int create) {

        TraceKey key;
        CpuTrace* trace;

        key.numFrames = numFrames;
        key.frames = frames;

        if (trace = activeCpuTraces.get(key)) return trace;
        if (!create) return NULL;

        TraceFrame* traceFrames = TraceFrame::newArray(numFrames);
        Method *method;

        for (int i = 0; i < numFrames; i++) {
                if (!(method = getMethod(frames[i].method_id))) {
                        TraceFrame::deleteArray(traceFrames, numFrames);
                        return NULL;
                }
                traceFrames[i].method = method;
                traceFrames[i].lineno = frames[i].lineno;
        }

        trace = new CpuTrace;

        trace->method = traceFrames[0].method;
        trace->numFrames = numFrames;
        trace->frames = traceFrames;

        activeCpuTraces.add(trace);
        trace->method->cpuTraces.add(trace);

        return trace;
}

CpuThreadMethod* Prof::getCpuThreadMethod(JNIEnv* envId, jmethodID methodId, int create) {

        CpuThreadMethodKey key;
        CpuThreadMethod* threadMethod;

        key.envId = envId;
        key.methodId = methodId;
        
        if (threadMethod = activeCpuThreadMethods.get(key)) return threadMethod;
        if (!create) return NULL;

        Method* method;
        Thread* thread;

        if (!(method = getMethod(methodId))) return NULL;
        if (!(thread = getThread(envId))) return NULL;

        threadMethod = new CpuThreadMethod;

        threadMethod->method = method;
        threadMethod->thread = thread;

        activeCpuThreadMethods.add(threadMethod);
        method->cpuThreadMethods.add(threadMethod);
        thread->cpuThreadMethods.add(threadMethod);

        return threadMethod;
}

CpuThreadTrace* Prof::getCpuThreadTrace(JNIEnv* envId, int numFrames, JVMPI_CallFrame* frames, int create) {

        CpuThreadTraceKey key;
        CpuThreadTrace* threadTrace;

        key.envId = envId;
        key.traceKey.numFrames = numFrames;
        key.traceKey.frames = frames;
        
        if (threadTrace = activeCpuThreadTraces.get(key)) return threadTrace;
        if (!create) return NULL;

        CpuThreadMethod* threadMethod;
        CpuTrace* trace;

        if (!(threadMethod = getCpuThreadMethod(envId, frames[0].method_id))) return NULL;
        if (!(trace = getCpuTrace(numFrames, frames))) return NULL;

        threadTrace = new CpuThreadTrace;

        threadTrace->threadMethod = threadMethod;
        threadTrace->trace = trace;

        activeCpuThreadTraces.add(threadTrace);
        threadMethod->threadTraces.add(threadTrace);
        trace->threadTraces.add(threadTrace);

        return threadTrace;
}

AllocTrace* Prof::getAllocTrace(int numFrames, JVMPI_CallFrame* frames, int create) {

        TraceKey key;
        AllocTrace* trace;

        key.numFrames = numFrames;
        key.frames = frames;

        if (trace = activeAllocTraces.get(key)) return trace;
        if (!create) return NULL;

        TraceFrame* traceFrames = TraceFrame::newArray(numFrames);
        Method *method;

        for (int i = 0; i < numFrames; i++) {
                if (!(method = getMethod(frames[i].method_id))) {
                        TraceFrame::deleteArray(traceFrames, numFrames);
                        return NULL;
                }
                traceFrames[i].method = method;
                traceFrames[i].lineno = frames[i].lineno;
        }

        trace = new AllocTrace;

        trace->method = traceFrames[0].method;
        trace->numFrames = numFrames;
        trace->frames = traceFrames;

        activeAllocTraces.add(trace);
        trace->method->allocTraces.add(trace);

        return trace;
}

AllocObject* Prof::getAllocObject(jobjectID classId, jint isArray, int create) {

        AllocObjectKey key;
        AllocObject* object;

        key.classId = classId;
        key.isArray = isArray;

        if (object = activeAllocObjects.get(key)) return object;
        if (!create) return NULL;

        Class *clss = NULL;

        if ((isArray == JVMPI_NORMAL_OBJECT) || (isArray == JVMPI_CLASS))
                if (!(clss = getClass(classId))) return NULL;

        object = new AllocObject;

        object->clss = clss;
        object->classId = classId;
        object->isArray = isArray;

        if (isArray == JVMPI_NORMAL_OBJECT) clss->allocObject = object;
        else if (isArray == JVMPI_CLASS) clss->allocObjectArray = object;

        activeAllocObjects.add(object);
        allocObjects.add(object);

        return object;
}

AllocObjectMethod* Prof::getAllocObjectMethod(jobjectID classId, jint isArray, jmethodID methodId, int create) {

        AllocObjectMethodKey key;
        AllocObjectMethod* objectMethod;

        key.objectKey.classId = classId;
        key.objectKey.isArray = isArray;
        key.methodId = methodId;

        if (objectMethod = activeAllocObjectMethods.get(key)) return objectMethod;
        if (!create) return NULL;

        AllocObject *object;
        Method* method;

        if (!(object = getAllocObject(classId, isArray))) return NULL;
        if (!(method = getMethod(methodId))) return NULL;

        objectMethod = new AllocObjectMethod;

        objectMethod->object = object;
        objectMethod->method = method;

        activeAllocObjectMethods.add(objectMethod);
        object->objectMethods.add(objectMethod);
        method->allocObjectMethods.add(objectMethod);

        return objectMethod;
}

AllocObjectTrace* Prof::getAllocObjectTrace(jobjectID classId, jint isArray, int numFrames, JVMPI_CallFrame* frames, int create) {

        AllocObjectTraceKey key;
        AllocObjectTrace* objectTrace;

        key.objectKey.classId = classId;
        key.objectKey.isArray = isArray;
        key.traceKey.numFrames = numFrames;
        key.objectKey.isArray = isArray;

        if (objectTrace = activeAllocObjectTraces.get(key)) return objectTrace;
        if (!create) return NULL;

        AllocObjectMethod *objectMethod;
        AllocTrace* trace;

        if (!(objectMethod = getAllocObjectMethod(classId, isArray, frames[0].method_id))) return NULL;
        if (!(trace = getAllocTrace(numFrames, frames))) return NULL;

        objectTrace = new AllocObjectTrace;

        objectTrace->objectMethod = objectMethod;
        objectTrace->trace = trace;

        activeAllocObjectTraces.add(objectTrace);
        objectMethod->objectTraces.add(objectTrace);
        trace->objectTraces.add(objectTrace);

        return objectTrace;
}
        
AllocThreadMethod* Prof::getAllocThreadMethod(JNIEnv* envId, jmethodID methodId, int create) {

        AllocThreadMethodKey key;
        AllocThreadMethod* threadMethod;

        key.envId = envId;
        key.methodId = methodId;

        if (threadMethod = activeAllocThreadMethods.get(key)) return threadMethod;
        if (!create) return NULL;

        Thread* thread;
        Method* method;

        if (!(thread = getThread(envId))) return NULL;
        if (!(method = getMethod(methodId))) return NULL;

        threadMethod = new AllocThreadMethod;

        threadMethod->thread = thread;
        threadMethod->method = method;

        activeAllocThreadMethods.add(threadMethod);
        thread->allocThreadMethods.add(threadMethod);
        method->allocThreadMethods.add(threadMethod);

        return  threadMethod;
}

AllocThreadTrace* Prof::getAllocThreadTrace(JNIEnv* envId, int numFrames, JVMPI_CallFrame* frames, int create) {

        AllocThreadTraceKey key;
        AllocThreadTrace* threadTrace;

        key.envId = envId;
        key.traceKey.numFrames = numFrames;
        key.traceKey.frames = frames; 

        if (threadTrace = activeAllocThreadTraces.get(key)) return threadTrace;
        if (!create) return NULL;

        AllocThreadMethod* threadMethod;
        AllocTrace* trace;

        if (!(threadMethod = getAllocThreadMethod(envId, frames[0].method_id))) return NULL;
        if (!(trace = getAllocTrace(numFrames, frames))) return NULL;

        threadTrace = new AllocThreadTrace;

        threadTrace->threadMethod = threadMethod;
        threadTrace->trace = trace;

        activeAllocThreadTraces.add(threadTrace);
        threadMethod->threadTraces.add(threadTrace);
        trace->threadTraces.add(threadTrace);

        return  threadTrace;
}

AllocThreadObject* Prof::getAllocThreadObject(JNIEnv* envId, jobjectID classId, jint isArray, int create) {

        AllocThreadObjectKey key;
        AllocThreadObject* threadObject;

        key.envId = envId;
        key.objectKey.classId = classId;
        key.objectKey.isArray = isArray;

        if (threadObject = activeAllocThreadObjects.get(key)) return threadObject;
        if (!create) return NULL;

        Thread *thread;
        AllocObject *object;

        if (!(thread = getThread(envId))) return NULL;
        if (!(object = getAllocObject(classId, isArray))) return NULL;

        threadObject = new AllocThreadObject;

        threadObject->thread = thread;
        threadObject->object = object;

        activeAllocThreadObjects.add(threadObject);
        thread->allocThreadObjects.add(threadObject);
        object->threadObjects.add(threadObject);

        return threadObject;
}

AllocThreadObjectMethod* Prof::getAllocThreadObjectMethod(JNIEnv* envId, jobjectID classId, jint isArray, jmethodID methodId, int create) {

        AllocThreadObjectMethodKey key;
        AllocThreadObjectMethod* threadObjectMethod;

        key.envId = envId;
        key.objectMethodKey.objectKey.classId = classId;
        key.objectMethodKey.objectKey.isArray = isArray;
        key.objectMethodKey.methodId = methodId; 

        if (threadObjectMethod = activeAllocThreadObjectMethods.get(key)) return threadObjectMethod;
        if (!create) return NULL;

        AllocThreadObject *threadObject;
        AllocObjectMethod *objectMethod;
        AllocThreadMethod *threadMethod;

        if (!(threadObject = getAllocThreadObject(envId, classId, isArray))) return NULL;
        if (!(objectMethod = getAllocObjectMethod(classId, isArray, methodId))) return NULL;
        if (!(threadMethod = getAllocThreadMethod(envId, methodId))) return NULL;

        threadObjectMethod = new AllocThreadObjectMethod;

        threadObjectMethod->threadObject = threadObject;
        threadObjectMethod->objectMethod = objectMethod;
        threadObjectMethod->threadMethod = threadMethod;

        activeAllocThreadObjectMethods.add(threadObjectMethod);
        threadObject->threadObjectMethods.add(threadObjectMethod);
        objectMethod->threadObjectMethods.add(threadObjectMethod);
        threadMethod->threadObjectMethods.add(threadObjectMethod);

        return threadObjectMethod;
}

AllocThreadObjectTrace* Prof::getAllocThreadObjectTrace(JNIEnv* envId, jobjectID classId, jint isArray, int numFrames, JVMPI_CallFrame* frames, int create) {

        AllocThreadObjectTraceKey key;
        AllocThreadObjectTrace* threadObjectTrace;

        key.envId = envId;
        key.objectTraceKey.objectKey.classId = classId;
        key.objectTraceKey.objectKey.isArray = isArray;
        key.objectTraceKey.traceKey.numFrames = numFrames; 
        key.objectTraceKey.traceKey.frames = frames; 

        if (threadObjectTrace = activeAllocThreadObjectTraces.get(key)) return threadObjectTrace;
        if (!create) return NULL;

        AllocThreadObjectMethod *threadObjectMethod;
        AllocObjectTrace *objectTrace;
        AllocThreadTrace *threadTrace;

        if (!(threadObjectMethod = getAllocThreadObjectMethod(envId, classId, isArray, frames[0].method_id))) return NULL;
        if (!(objectTrace = getAllocObjectTrace(classId, isArray, numFrames, frames))) return NULL;
        if (!(threadTrace = getAllocThreadTrace(envId, numFrames, frames))) return NULL;

        threadObjectTrace = new AllocThreadObjectTrace;

        threadObjectTrace->threadObjectMethod = threadObjectMethod;
        threadObjectTrace->objectTrace = objectTrace;
        threadObjectTrace->threadTrace = threadTrace;

        activeAllocThreadObjectTraces.add(threadObjectTrace);
        threadObjectMethod->threadObjectTraces.add(threadObjectTrace);
        objectTrace->threadObjectTraces.add(threadObjectTrace);
        threadTrace->threadObjectTraces.add(threadObjectTrace);

        return threadObjectTrace;
}

MonTrace* Prof::getMonTrace(int numFrames, JVMPI_CallFrame* frames, int create) {

        TraceKey key;
        MonTrace* trace;

        key.numFrames = numFrames;
        key.frames = frames;

        if (trace = activeMonTraces.get(key)) return trace;
        if (!create) return NULL;

        TraceFrame* traceFrames = TraceFrame::newArray(numFrames);
        Method *method;

        for (int i = 0; i < numFrames; i++) {
                if (!(method = getMethod(frames[i].method_id))) {
                        TraceFrame::deleteArray(traceFrames, numFrames);
                        return NULL;
                }
                traceFrames[i].method = method;
                traceFrames[i].lineno = frames[i].lineno;
        }

        trace = new MonTrace;

        trace->method = traceFrames[0].method;
        trace->numFrames = numFrames;
        trace->frames = traceFrames;

        activeMonTraces.add(trace);
        trace->method->monTraces.add(trace);

        return trace;
}

MonThreadMethod* Prof::getMonThreadMethod(JNIEnv* envId, jmethodID methodId, int create) {

        MonThreadMethodKey key;
        MonThreadMethod* threadMethod;

        key.envId = envId;
        key.methodId = methodId;
        
        if (threadMethod = activeMonThreadMethods.get(key)) return threadMethod;
        if (!create) return NULL;

        Method* method;
        Thread* thread;

        if (!(method = getMethod(methodId))) return NULL;
        if (!(thread = getThread(envId))) return NULL;

        threadMethod = new MonThreadMethod;

        threadMethod->method = method;
        threadMethod->thread = thread;

        activeMonThreadMethods.add(threadMethod);
        method->monThreadMethods.add(threadMethod);
        thread->monThreadMethods.add(threadMethod);

        return threadMethod;
}

MonThreadTrace* Prof::getMonThreadTrace(JNIEnv* envId, int numFrames, JVMPI_CallFrame* frames, int create) {

        MonThreadTraceKey key;
        MonThreadTrace* threadTrace;

        key.envId = envId;
        key.traceKey.numFrames = numFrames;
        key.traceKey.frames = frames;
        
        if (threadTrace = activeMonThreadTraces.get(key)) return threadTrace;
        if (!create) return NULL;

        MonThreadMethod* threadMethod;
        MonTrace* trace;

        if (!(threadMethod = getMonThreadMethod(envId, frames[0].method_id))) return NULL;
        if (!(trace = getMonTrace(numFrames, frames))) return NULL;

        threadTrace = new MonThreadTrace;

        threadTrace->threadMethod = threadMethod;
        threadTrace->trace = trace;

        activeMonThreadTraces.add(threadTrace);
        threadMethod->threadTraces.add(threadTrace);
        trace->threadTraces.add(threadTrace);

        return threadTrace;
}

---