jvmpi.c

来自「This is a resource based on j2me embedde」· C语言 代码 · 共 1,650 行 · 第 1/5 页

    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_JNI_GLOBALREF_FREE);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_JNI_WEAK_GLOBALREF_ALLOC);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_JNI_WEAK_GLOBALREF_FREE);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_METHOD_ENTRY);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_METHOD_ENTRY2);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_METHOD_EXIT);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_LOAD_COMPILED_METHOD);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_UNLOAD_COMPILED_METHOD);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_JVM_INIT_DONE);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_JVM_SHUT_DOWN);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_DATA_DUMP_REQUEST);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_DATA_RESET_REQUEST);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_OBJ_MOVE);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_ARENA_NEW);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_ARENA_DELETE);

    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_RAW_MONITOR_CONTENDED_ENTER);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_RAW_MONITOR_CONTENDED_ENTERED);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_RAW_MONITOR_CONTENDED_EXIT);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_MONITOR_CONTENDED_ENTER);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_MONITOR_CONTENDED_ENTERED);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_MONITOR_CONTENDED_EXIT);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_MONITOR_WAIT);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_MONITOR_WAITED);

    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_GC_START);
    CVMjvmpiEventInfoDisableX(JVMPI_EVENT_GC_FINISH);

#undef CVMjvmpiEventInfoDisableX

    CVMsysMicroUnlock(ee, CVM_TOOLS_MICROLOCK);
}

/* Purpose: Disable notification of the specified Event. */
static void CVMjvmpiEventInfoDisable(CVMJvmpiEventInfo *self, CVMExecEnv *ee,
                                     CVMInt32 event)
{
    CVMsysMicroLock(ee, CVM_TOOLS_MICROLOCK);
    self->eventInfoX[event] = CVMJvmpiEventInfo_DISABLED;
    CVMsysMicroUnlock(ee, CVM_TOOLS_MICROLOCK);
}

/* Purpose: Marks all event notifications as being disabled. */
static void CVMjvmpiEventInfoDisableAll(CVMJvmpiEventInfo *self, CVMExecEnv *ee)
{
    int i;
    CVMsysMicroLock(ee, CVM_TOOLS_MICROLOCK);
    for (i = 0; i <= JVMPI_MAX_EVENT_TYPE_VAL; i++) {
        if (!CVMjvmpiEventInfoIsNotAvailable(self, i)) {
            self->eventInfoX[i] = CVMJvmpiEventInfo_DISABLED;
        }
    }
    CVMsysMicroUnlock(ee, CVM_TOOLS_MICROLOCK);
}

/* Purpose: Enable notification of the specified Event. */
static void CVMjvmpiEventInfoEnable(CVMJvmpiEventInfo *self, CVMExecEnv *ee,
                                    CVMInt32 event)
{
    CVMsysMicroLock(ee, CVM_TOOLS_MICROLOCK);
    self->eventInfoX[event] = CVMJvmpiEventInfo_ENABLED;
    CVMsysMicroUnlock(ee, CVM_TOOLS_MICROLOCK);
}

/*=============================================================================
    Definition of the CVMDumper utility class for generating the dump info
    required for JVMPI support:
*/

/* 
 * Data struture used by the heap dump routines to temporarily hold
 * trace information. For simplicity, we place an upper bound on the 
 * number of threads traced by GC.
 */
#define JVMPI_DUMP_MAX_TRACES 1024

typedef struct CVMDumper CVMDumper;
struct CVMDumper
{
    CVMUint8 *buffer;       /* Beginning of the allocated buffer. */
    CVMUint8 *bufferEnd;    /* End of the allocated buffer. */
    CVMUint8 *ptr;          /* Current write location in buffer. */

    CVMInt32  dumpLevel;    /* level of information in the dump */
    CVMBool isOverflowed;   /* Indicates if a buffer overflow was detected. */

    CVMUint8 *dumpStart;    /* Start of dump. */
    jint *threadStatusList; /* Start or thread status list. */

    CVMUint32 tracesCount;  /* number of threads traced by GC */
    JVMPI_CallTrace traces[JVMPI_DUMP_MAX_TRACES];
};

/* Some of the following are implemented as macros below.  For these, the
   "static" modifier has to omitted to placate the compiler from generating
   warnings.  The modifiers are left here in commented form to indicate that
   these functions should be static if the macros are ever converted back into
   functions: */

static void CVMdumperInit(CVMDumper *self, CVMInt32 dumpLevel);
static void CVMdumperInitBuffer(CVMDumper *self, CVMUint8 *buffer,
                                CVMUint32 bufferSize);
/* static */ CVMBool CVMdumperIsOverflowed(CVMDumper *self);
/* static */ CVMUint32 CVMdumperGetRequiredBufferSize(CVMDumper *self);
/* static */ void CVMdumperSetThreadStatusList(CVMDumper *self,
                                               jint *threadStatusList);
/* static */ void CVMdumperSetDumpStart(CVMDumper *self, CVMUint8 *position);
/* static */ CVMUint8 *CVMdumperGetPosition(CVMDumper *self);
/* static */ void CVMdumperSeekTo(CVMDumper *self, CVMUint8 *position);
/* static */ CVMInt32 CVMdumperGetLevel(CVMDumper *self);

static void *CVMdumperAlloc(CVMDumper *self, CVMUint32 size);
static void CVMdumperWrite(CVMDumper *self, void *srcBuffer, CVMUint32 size);
static void CVMdumperWriteID(CVMDumper *self, void *value);
static void CVMdumperWriteU4(CVMDumper *self, CVMUint32 value);
static void CVMdumperWriteU2(CVMDumper *self, CVMUint16 value);
static void CVMdumperWriteU1(CVMDumper *self, CVMUint8 value);
static void CVMdumperWrite64(CVMDumper *self, CVMJavaVal64 value);

/* static */ void CVMdumperWriteLong(CVMDumper *self, CVMJavaLong value);
/* static */ void CVMdumperWriteDouble(CVMDumper *self, CVMJavaDouble value);
/* static */ void CVMdumperWriteInt(CVMDumper *self, CVMJavaInt value);
/* static */ void CVMdumperWriteFloat(CVMDumper *self, CVMJavaFloat value);
/* static */ void CVMdumperWriteShort(CVMDumper *self, CVMJavaShort value);
/* static */ void CVMdumperWriteChar(CVMDumper *self, CVMJavaChar value);
/* static */ void CVMdumperWriteByte(CVMDumper *self, CVMJavaByte value);
/* static */ void CVMdumperWriteBoolean(CVMDumper *self, CVMJavaBoolean value);

static void CVMdumperDumpThreadTrace(CVMDumper *self, CVMExecEnv *targetEE);
static void CVMdumperDumpRoot(CVMObject **ref, void *data);
static jint CVMdumperDumpInstance(CVMDumper *self, CVMObject *obj);
static jint CVMdumperDumpClass(CVMDumper *self, CVMObject *clazz);
static jint CVMdumperDumpArray(CVMDumper *self, CVMObject *arrObj);
static jint CVMdumperDumpObject(CVMDumper *self, CVMObject *obj);
static void CVMdumperDumpThreadInfo(CVMDumper *self, CVMExecEnv *threadEE);

static jsize CVMdumperComputeInstanceDumpSize(CVMDumper *self, CVMObject *obj);
static jsize CVMdumperComputeClassDumpSize(CVMDumper *self, CVMObject *clazz);
static jsize CVMdumperComputeArrayDumpSize(CVMDumper *self, CVMObject *arrObj);
static jsize CVMdumperComputeObjectDumpSize(CVMDumper *self, CVMObject *obj);

#if CVM_FASTLOCK_TYPE != CVM_FASTLOCK_NONE
static void CVMdumperDumpFastLockInfo(CVMDumper *self, CVMExecEnv *threadEE);
#endif

static void CVMdumperDumpMonitor(CVMDumper *self, CVMProfiledMonitor *mon);
static void CVMdumperDumpThreadsAndMonitors(CVMDumper *dumper, CVMExecEnv *ee);
static CVMBool CVMdumperHeapDumpCallback(CVMObject* obj, CVMClassBlock* cb,
                                         CVMUint32 size, void* data);
static void CVMdumperDumpHeap(CVMDumper *self, CVMExecEnv *ee);

/*=============================================================================
    Methods of the CVMDumper utility class for generating the dump info
    required for JVMPI support:
*/

/* Purpose: Initializes the Dumper object. */
static void CVMdumperInit(CVMDumper *self, CVMInt32 dumpLevel)
{
    memset(self, 0, sizeof(CVMDumper));
    self->dumpLevel = dumpLevel; 
}

/* Purpose: Initializes the Dumper's buffer. */
static void CVMdumperInitBuffer(CVMDumper *self, CVMUint8 *buffer,
                                CVMUint32 bufferSize)
{
    self->buffer = buffer;
    self->bufferEnd = buffer + bufferSize;
    self->ptr = buffer;
    self->dumpStart = buffer;
    self->isOverflowed = CVM_FALSE;
}

/* Purpose: Checks to see if the Dumper has been overflowed. */
#define CVMdumperIsOverflowed(/* CVMDumper * */ self) \
    ((self)->isOverflowed)

/* Purpose: Gets the actual amount of memory needed for the entire dump
            operation. */
#define CVMdumperGetRequiredBufferSize(/* CVMDumper * */ self) \
    (((self)->ptr) - ((self)->buffer))

/* Purpose: Sets the threadStatusList field. */
#define CVMdumperSetThreadStatusList(/* CVMDumper * */ self,         \
                                     /* jint * */ threadStatusList_) \
    ((self)->threadStatusList = threadStatusList_)

/* Purpose: Sets the dumpStart field. */
#define CVMdumperSetDumpStart(/* CVMDumper * */ self,    \
                              /* CVMUint8 * */ position) \
    ((self)->dumpStart = position)

/* Purpose: Gets the current position of the dumper. */
#define CVMdumperGetPosition(/* CVMDumper * */self) \
    ((CVMUint8 *)(self)->ptr)

/* Purpose: Seeks to the specified position. */
#define CVMdumperSeekTo(/* CVMDumper * */self, /* CVMUint8 * */position) \
    ((self)->ptr = (position))

/* Purpose: Gets the level of the dump. */
#define CVMdumperGetLevel(/* CVMDumper * */self) \
    ((self)->dumpLevel)


/* Purpose: Allocate a block of memory from the dump buffer. */
static void *CVMdumperAlloc(CVMDumper *self, CVMUint32 size)
{
    void *result = self->ptr;
    size = CVMpackSizeBy(size, 8);
    self->ptr += size;
    if (self->ptr >= self->bufferEnd) {
        self->isOverflowed = CVM_TRUE;
        return NULL;
    }
    return result;
}

/* Purpose: Dumps an arbitary value. */
static void CVMdumperWrite(CVMDumper *self, void *srcBuffer, CVMUint32 size)
{
    self->ptr += size;
    if (self->ptr >= self->bufferEnd) {
        self->isOverflowed = CVM_TRUE;
    } else {
        memcpy(self->ptr - size, srcBuffer, size);
    }
}

/* Purpose: Dumps a (void *) value. */
static void CVMdumperWriteID(CVMDumper *self, void *value)
{
    CVMdumperWrite((self), &value, sizeof(void *));
}

/* Purpose: Dumps a CVMUint32 value. */
static void CVMdumperWriteU4(CVMDumper *self, CVMUint32 value)
{
#if (CVM_ENDIANNESS == CVM_LITTLE_ENDIAN)
    /* NOTE: According to JDK Classic's implementation, the byte-order expected
        by the profiler is the network byte order i.e. BIG ENDIAN.  Hence, if
        this platform is little endian, then we need to convert the byte-order
        to BIG ENDIAN before passing it to the profiler: */
    {
        /* Convert endianness of value: */
        CVMUint32 newValue =
            ((value & 0x000000FF) << 24) |
            ((value & 0x0000FF00) << 8)  |
            ((value & 0x00FF0000) >> 8)  |
            ((value & 0xFF000000) >> 24);
        value = newValue;
    }
#endif
    CVMdumperWrite(self, &value, sizeof(CVMUint32));
}

/* Purpose: Dumps a CVMUint16 value. */
static void CVMdumperWriteU2(CVMDumper *self, CVMUint16 value)
{
#if (CVM_ENDIANNESS == CVM_LITTLE_ENDIAN)
    /* NOTE: According to JDK Classic's implementation, the byte-order expected
        by the profiler is the network byte order i.e. BIG ENDIAN.  Hence, if
        this platform is little endian, then we need to convert the byte-order
        to BIG ENDIAN before passing it to the profiler: */
    {
        /* Convert endianness of value: */
        CVMUint16 newValue =
            ((value & 0x00FF) << 8) |
            ((value & 0xFF00) >> 8);
        value = newValue;
    }
#endif
    CVMdumperWrite(self, &value, sizeof(CVMUint16));
}

/* Purpose: Dumps a CVMUint8 value. */
static void CVMdumperWriteU1(CVMDumper *self, CVMUint8 value)
{
    CVMdumperWrite(self, &value, sizeof(CVMUint8));
}

/* Purpose: Dumps a CVMJavaVal64 value. */
static void CVMdumperWrite64(CVMDumper *self, CVMJavaVal64 value)
{
    CVMJavaLong highLong = CVMlongShr(value.l, 32);
    CVMUint32 high = CVMlong2Int(highLong);
    CVMUint32 low = CVMlong2Int(value.l);
    CVMdumperWriteU4(self, high);
    CVMdumperWriteU4(self, low);
}

/* Purpose: Dumps a Long value. */
#define CVMdumperWriteLong(/* CVMDumper * */self, /* CVMJavaLong */value_) { \
    CVMJavaVal64 val_;                                                       \
    val_.l = (value_);                                                       \
    CVMdumperWrite64(self, val_);                                            \
}

/* Purpose: Dumps a Double value. */
#define CVMdumperWriteDouble(/* CVMDumper * */self,       \
                             /* CVMJavaDouble */value_) { \
    CVMJavaVal64 val_;                                    \
    val_.d = (value_);                                    \
    CVMdumperWrite64(self, val_);                         \
}

/* Purpose: Dumps an Int value. */
#define CVMdumperWriteInt(/* CVMDumper * */self, /* CVMJavaInt */value_) { \
    CVMJavaInt val_ = (value_);                                            \
    CVMdumperWriteU4(self, (CVMUint32) val_);                              \
}

/* Purpose: Dumps a Float value. */
#define CVMdumperWriteFloat(/* CVMDumper * */self, /* CVMJavaFloat */value_) {\
    CVMJavaVal32 val_;                                              \
    val_.f = (value_);                                              \
    CVMdumperWriteU4(self, (CVMUint32) val_.i);                     \
}

/* Purpose: Dumps a Short value. */
#define CVMdumperWriteShort(/* CVMDumper * */self,      \
                            /* CVMJavaShort */value_) { \
    CVMJavaShort val_ = (value_);                       \
    CVMdumperWriteU2(self, (CVMUint16) val_);           \
}

/* Purpose: Dumps a Char value. */
#define CVMdumperWriteChar(/* CVMDumper * */self, /* CVMJavaChar */value_) { \
    CVMJavaChar val_ = (value_);                                             \