00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035 #include "../prof/prof.h"
00036 #include "../prof/synchronized.h"
00037 #include "../commun2/counter.h"
00038 #include "../commun2/objectTable.h"
00039 #include "../commun2/idObject.h"
00040 #include "../shared/classField.h"
00041 #include "../alloc/allocTrace.h"
00042 #include "../cpu/cpuTrace.h"
00043 #include "../alloc/allocObject.h"
00044 #include "../alloc/allocArena.h"
00045 #include "../shared/groupThread.h"
00046 #include "../gc/gc.h"
00047 #include "../alloc/allocObjectMethod.h"
00048 #include "../alloc/allocObjectTrace.h"
00049 #include "../alloc/allocThreadObject.h"
00050 #include "../alloc/allocThreadMethod.h"
00051 #include "../alloc/allocThreadObjectMethod.h"
00052 #include "../alloc/allocThreadObjectTrace.h"
00053 #include "../alloc/allocThreadTrace.h"
00054 #include "../cpu/cpuThreadMethod.h"
00055 #include "../cpu/cpuThreadTrace.h"
00056 #include "../mon/monThreadMethod.h"
00057 #include "../mon/monThreadTrace.h"
00058 #include "../mon/monTrace.h"
00059
00060 void Prof::shutdown() {
00061
00062 if( shuttingDown) {
00063
00064 communThreadEnd = 1;
00065 shutdownLock.release();
00066 }
00067 }
00068
00069 jint Prof::isShutdowned() {
00070
00071 return shuttingDown;
00072 }
00073
00074 void Prof::suspendVM() {
00075
00076 if( !shuttingDown) {
00077
00078 if( threadsSuspended) return;
00079
00080 communLock.release();
00081 gcLock.wait();
00082 jvmpiInterface->DisableGC();
00083 communLock.wait();
00084 dataLock.wait();
00085
00086 Thread* t = activeThreads.first();
00087 while( t) {
00088
00089 jvmpiInterface->SuspendThread(t->threadEnvId);
00090 t = activeThreads.next(t);
00091 }
00092
00093 threadsSuspended = 1;
00094 }
00095 }
00096
00097 void Prof::resumeVM() {
00098
00099 if( !shuttingDown) {
00100
00101 if( !threadsSuspended) return;
00102
00103 Thread* t = activeThreads.first();
00104 while( t) {
00105
00106 jvmpiInterface->ResumeThread(t->threadEnvId);
00107 t = activeThreads.next(t);
00108 }
00109
00110 threadsSuspended = 0;
00111
00112 dataLock.release();
00113 jvmpiInterface->EnableGC();
00114 gcLock.release();
00115 }
00116 }
00117
00118 void Prof::exitVM() {
00119
00120 jvmpiInterface->ProfilerExit( 0);
00121 }
00122
00123 jint Prof::getInfo( objectID infoId,
00124 eInfoType type,
00125 InfoBinaryFormat*& info) {
00126
00127 Synchronized sync( dataLock, 0);
00128 if( !shuttingDown && !threadsSuspended) sync.enter();
00129
00130 info = NULL;
00131
00132 ObjectTable* o = Counter::getCounter()->table.get( infoId);
00133 if( !o) return RC_BAD_INFO_ID;
00134
00135 IdObject* p = o->obj;
00136 IdObject::eClassIdent cI = p->getClassIdent();
00137
00138 if( type == CLASS_INFO && cI == IdObject::CLASS) {
00139
00140 info = static_cast<Class*>( p);
00141 }
00142 else if( type == CLASS_FIELD_INFO && cI == IdObject::CLASS_FIELD) {
00143
00144 info = static_cast<ClassField*>( p);
00145 }
00146 else if( type == METHOD_INFO && cI == IdObject::METHOD) {
00147
00148 info = static_cast<Method*>( p);
00149 }
00150 else if( type == TRACE_INFO && cI == IdObject::ALLOC_TRACE) {
00151
00152 info = static_cast<AllocTrace*>( p);
00153 }
00154 else if( type == TRACE_INFO && cI == IdObject::CPU_TRACE) {
00155
00156 info = static_cast<CpuTrace*>( p);
00157 }
00158 else if( type == TRACE_INFO && cI == IdObject::MON_TRACE) {
00159
00160 info = static_cast<MonTrace*>( p);
00161 }
00162 else if( type == OBJECT_INFO && cI == IdObject::ALLOC_OBJECT) {
00163
00164 info = static_cast<AllocObject*>( p);
00165 }
00166 else if( type == ARENA_INFO && cI == IdObject::ALLOC_ARENA) {
00167
00168 info = static_cast<AllocArena*>( p);
00169 }
00170 else if( type == THREAD_INFO && cI == IdObject::THREAD) {
00171
00172 info = static_cast<Thread*>( p);
00173 }
00174 else if( type == THREAD_GROUP_INFO && cI == IdObject::GROUP_THREAD) {
00175
00176 info = static_cast<GroupThread*>( p);
00177 }
00178 else if( type == GC_INFO && cI == IdObject::GARBAGE_C) {
00179
00180 info = static_cast<GC*>( p);
00181 }
00182 else return RC_BAD_INFO_TYPE;
00183
00184 return RC_OK;
00185 }
00186
00187 jint Prof::getData( objectID objId,
00188 eDataType type,
00189 sData& data) {
00190
00191 Synchronized sync( dataLock, 0);
00192 if( !shuttingDown && !threadsSuspended) sync.enter();
00193
00194 ObjectTable* o = Counter::getCounter()->table.get( objId);
00195 if( !o) return RC_BAD_OBJ_ID;
00196
00197 IdObject* p = o->obj;
00198 IdObject::eClassIdent cI = p->getClassIdent();
00199
00200 if( type == ALLOC_DATA && (cI & IdObject::ALLOC));
00201 else if( type == CPU_DATA && (cI & IdObject::CPU));
00202 else if( type == MON_DATA && (cI & IdObject::MON));
00203 else return RC_BAD_DATA_TYPE;
00204
00205 data.active = p->isActive();
00206
00207 if( cI == IdObject::ALLOC_OBJECT) {
00208
00209 AllocStatData::copy( data.alloc, *static_cast<AllocObject*>( p));
00210 }
00211 else if( cI == IdObject::ALLOC_OBJECT_METHOD) {
00212
00213 AllocStatData::copy( data.alloc, *static_cast<AllocObjectMethod*>( p));
00214 }
00215 else if( cI == IdObject::ALLOC_OBJECT_TRACE) {
00216
00217 AllocStatData::copy( data.alloc, *static_cast<AllocObjectTrace*>( p));
00218 }
00219 else if( cI == IdObject::ALLOC_THREAD_METHOD) {
00220
00221 AllocStatData::copy( data.alloc, *static_cast<AllocThreadMethod*>( p));
00222 }
00223 else if( cI == IdObject::ALLOC_THREAD_OBJECT) {
00224
00225 AllocStatData::copy( data.alloc, *static_cast<AllocThreadObject*>( p));
00226 }
00227 else if( cI == IdObject::ALLOC_THREAD_OBJECT_METHOD) {
00228
00229 AllocStatData::copy( data.alloc, *static_cast<AllocThreadObjectMethod*>( p));
00230 }
00231 else if( cI == IdObject::ALLOC_THREAD_OBJECT_TRACE) {
00232
00233 AllocStatData::copy( data.alloc, *static_cast<AllocThreadObjectTrace*>( p));
00234 }
00235 else if( cI == IdObject::ALLOC_THREAD_TRACE) {
00236
00237 AllocStatData::copy( data.alloc, *static_cast<AllocThreadTrace*>( p));
00238 }
00239 else if( cI == IdObject::ALLOC_TRACE) {
00240
00241 AllocStatData::copy( data.alloc, *static_cast<AllocTrace*>( p));
00242 }
00243 else if( cI == IdObject::CPU_THREAD_METHOD) {
00244
00245 CpuStatData::copy( data.cpu, *static_cast<CpuThreadMethod*>( p));
00246 }
00247 else if( cI == IdObject::CPU_THREAD_TRACE) {
00248
00249 CpuStatData::copy( data.cpu, *static_cast<CpuThreadTrace*>( p));
00250 }
00251 else if( cI == IdObject::CPU_TRACE) {
00252
00253 CpuStatData::copy( data.cpu, *static_cast<CpuTrace*>( p));
00254 }
00255 else if( cI == IdObject::METHOD) {
00256
00257 if( type == ALLOC_DATA) {
00258
00259 AllocStatData::copy( data.alloc, *static_cast<Method*>( p));
00260 }
00261 else if( type == CPU_DATA) {
00262
00263 CpuStatData::copy( data.cpu, *static_cast<Method*>( p));
00264 }
00265 else {
00266
00267 MonStatData::copy( data.mon, *static_cast<Method*>( p));
00268 }
00269 }
00270 else if( cI == IdObject::THREAD) {
00271
00272 AllocStatData::copy( data.alloc, *static_cast<Thread*>( p));
00273 }
00274 else if( cI == IdObject::MON_THREAD_METHOD) {
00275
00276 MonStatData::copy( data.mon, *static_cast<MonThreadMethod*>( p));
00277 }
00278 else if( cI == IdObject::MON_THREAD_TRACE) {
00279
00280 MonStatData::copy( data.mon, *static_cast<MonThreadTrace*>( p));
00281 }
00282 else if( cI == IdObject::MON_TRACE) {
00283
00284 MonStatData::copy( data.mon, *static_cast<MonTrace*>( p));
00285 }
00286 else if( cI == IdObject::ALLOC_ARENA) {}
00287 else if( cI == IdObject::GARBAGE_C) {}
00288 else if( cI == IdObject::CLASS) {}
00289 else if( cI == IdObject::CLASS_FIELD) {}
00290 else if( cI == IdObject::GROUP_THREAD) {}
00291 else return RC_BAD_OBJ_ID;
00292
00293 return RC_OK;
00294 }
00295
00296 jint Prof::getAllOrChanged( objectID objId,
00297 eSeqType what,
00298 jint iI,
00299 jint oA,
00300 seqID& seq,
00301 int all) {
00302
00303 Synchronized sync( dataLock, 0);
00304 if( !shuttingDown && !threadsSuspended) sync.enter();
00305
00306 switch( what) {
00307
00308 case CLASSES: {
00309
00310 getDataFromList( classes, seq, all, what, iI, oA);
00311
00312 break;
00313 }
00314
00315 case METHODS: {
00316
00317 Class* c = classes.first();
00318 while( c) {
00319
00320 getDataFromList( c->methods, seq, all, what, iI, oA);
00321
00322 c = classes.next( c);
00323 }
00324
00325 break;
00326 }
00327
00328 case ALLOC_TRACES: {
00329
00330 Class* c = classes.first();
00331 while( c) {
00332
00333 Method* m = c->methods.first();
00334 while( m) {
00335
00336 getDataFromList( m->allocTraces, seq, all, what, iI, oA);
00337 m = c->methods.next( m);
00338 }
00339
00340 c = classes.next( c);
00341 }
00342
00343 break;
00344 }
00345
00346 case CPU_TRACES: {
00347
00348 Class* c = classes.first();
00349 while( c) {
00350
00351 Method* m = c->methods.first();
00352 while( m) {
00353
00354 getDataFromList( m->cpuTraces, seq, all, what, iI, oA);
00355 m = c->methods.next( m);
00356 }
00357
00358 c = classes.next( c);
00359 }
00360
00361 break;
00362 }
00363
00364 case MON_TRACES: {
00365
00366 Class* c = classes.first();
00367 while( c) {
00368
00369 Method* m = c->methods.first();
00370 while( m) {
00371
00372 getDataFromList( m->monTraces, seq, all, what, iI, oA);
00373 m = c->methods.next( m);
00374 }
00375
00376 c = classes.next( c);
00377 }
00378
00379 break;
00380 }
00381
00382 case OBJECT_TYPES: {
00383
00384 getDataFromList( allocObjects, seq, all, what, iI, oA);
00385 break;
00386 }
00387
00388 case THREADS: {
00389
00390 getDataFromList( threads, seq, all, what, iI, oA);
00391 break;
00392 }
00393
00394 case GROUPS_OF_THREADS: {
00395
00396 getDataFromList( groupsOfThreads, seq, all, what, iI, oA);
00397 break;
00398 }
00399
00400 case ARENAS: {
00401
00402 getDataFromList( arenas, seq, all, what, iI, oA);
00403 break;
00404 }
00405
00406 case GCS: {
00407
00408 getDataFromList( gcStat, seq, all, what, iI, oA);
00409 break;
00410 }
00411
00412 default: {
00413
00414 ObjectTable* o = Counter::getCounter()->table.get( objId);
00415 if( !o) return RC_BAD_OBJ_ID;
00416
00417 IdObject* p = o->obj;
00418
00419 switch( what) {
00420 case CLASS_FIELDS_STATICS:
00421 case CLASS_FIELDS_INSTANCES:
00422 case CLASS_METHODS: {
00423
00424 if( !p->isOfType( IdObject::CLASS)) return RC_BAD_COMMAND;
00425
00426 Class* c = static_cast<Class*>( p);
00427
00428 if( what == CLASS_FIELDS_STATICS) getDataFromList( c->statics, seq, all, what, iI, oA);
00429 else if( what == CLASS_FIELDS_INSTANCES) getDataFromList( c->instances, seq, all, what, iI, oA);
00430 else getDataFromList( c->methods, seq, all, what, iI, oA);
00431
00432 break;
00433 }
00434
00435 case ALLOC_METHOD_OBJECTS:
00436 case ALLOC_METHOD_THREADS:
00437 case ALLOC_METHOD_TRACES:
00438 case CPU_METHOD_THREADS:
00439 case CPU_METHOD_TRACES:
00440 case MON_METHOD_THREADS:
00441 case MON_METHOD_TRACES: {
00442
00443 if( !p->isOfType( IdObject::METHOD)) return RC_BAD_COMMAND;
00444
00445 Method* m = static_cast<Method*>( p);
00446
00447 if( what == ALLOC_METHOD_OBJECTS) getDataFromList( m->allocObjectMethods, seq, all, what, iI, oA);
00448 else if( what == ALLOC_METHOD_THREADS) getDataFromList( m->allocThreadMethods, seq, all, what, iI, oA);
00449 else if( what == ALLOC_METHOD_TRACES) getDataFromList( m->allocTraces, seq, all, what, iI, oA);
00450 else if( what == CPU_METHOD_THREADS) getDataFromList( m->cpuThreadMethods, seq, all, what, iI, oA);
00451 else if( what == CPU_METHOD_TRACES) getDataFromList( m->cpuTraces, seq, all, what, iI, oA);
00452 else if( what == MON_METHOD_THREADS) getDataFromList( m->monThreadMethods, seq, all, what, iI, oA);
00453 else getDataFromList( m->monTraces, seq, all, what, iI, oA);
00454
00455 break;
00456 }
00457
00458 case ALLOC_TRACE_OBJECTS:
00459 case ALLOC_METHOD_TRACE_THREADS: {
00460
00461 if( !p->isOfType( IdObject::ALLOC_TRACE)) return RC_BAD_COMMAND;
00462
00463 AllocTrace* tr = static_cast<AllocTrace*>( p);
00464
00465 if( what == ALLOC_TRACE_OBJECTS) getDataFromList( tr->objectTraces, seq, all, what, iI, oA);
00466 else getDataFromList( tr->threadTraces, seq, all, what, iI, oA);
00467
00468 break;
00469 }
00470
00471 case ALLOC_OBJECT_METHODS:
00472 case ALLOC_OBJECT_THREADS: {
00473
00474 if( !p->isOfType( IdObject::ALLOC_OBJECT)) return RC_BAD_COMMAND;
00475
00476 AllocObject* o = static_cast<AllocObject*>( p);
00477
00478 if( what == ALLOC_OBJECT_METHODS) getDataFromList( o->objectMethods, seq, all, what, iI, oA);
00479 else getDataFromList( o->threadObjects, seq, all, what, iI, oA);
00480
00481 break;
00482 }
00483
00484 case ALLOC_OBJECT_METHOD_THREADS:
00485 case ALLOC_OBJECT_METHOD_TRACES: {
00486
00487 if( !p->isOfType( IdObject::ALLOC_OBJECT_METHOD)) return RC_BAD_COMMAND;
00488
00489 AllocObjectMethod* om = static_cast<AllocObjectMethod*>( p);
00490
00491 if( what == ALLOC_OBJECT_METHOD_THREADS) getDataFromList( om->threadObjectMethods, seq, all, what, iI, oA);
00492 else getDataFromList( om->objectTraces, seq, all, what, iI, oA);
00493
00494 break;
00495 }
00496
00497 case ALLOC_OBJECT_METHOD_TRACE_THREADS: {
00498
00499 if( !p->isOfType( IdObject::ALLOC_OBJECT_TRACE)) return RC_BAD_COMMAND;
00500
00501 AllocObjectTrace* otr = static_cast<AllocObjectTrace*>( p);
00502 getDataFromList( otr->threadObjectTraces, seq, all, what, iI, oA);
00503
00504 break;
00505 }
00506
00507 case ALLOC_THREAD_OBJECTS:
00508 case ALLOC_THREAD_METHODS:
00509 case CPU_THREAD_METHODS:
00510 case MON_THREAD_METHODS: {
00511
00512 if( !p->isOfType( IdObject::THREAD)) return RC_BAD_COMMAND;
00513
00514 Thread* th = static_cast<Thread*>( p);
00515
00516 if( what == ALLOC_THREAD_OBJECTS) getDataFromList( th->allocThreadObjects, seq, all, what, iI, oA);
00517 else if( what == ALLOC_THREAD_METHODS) getDataFromList( th->allocThreadMethods, seq, all, what, iI, oA);
00518 else if( what == CPU_THREAD_METHODS) getDataFromList( th->cpuThreadMethods, seq, all, what, iI, oA);
00519 else getDataFromList( th->monThreadMethods, seq, all, what, iI, oA);
00520
00521 break;
00522 }
00523
00524 case ALLOC_THREAD_OBJECT_METHODS: {
00525
00526 if( !p->isOfType( IdObject::ALLOC_THREAD_OBJECT)) return RC_BAD_COMMAND;
00527
00528 AllocThreadObject* to = static_cast<AllocThreadObject*>( p);
00529 getDataFromList( to->threadObjectMethods, seq, all, what, iI, oA);
00530
00531 break;
00532 }
00533
00534 case ALLOC_THREAD_OBJECT_METHOD_TRACES: {
00535
00536 if( !p->isOfType( IdObject::ALLOC_THREAD_OBJECT_METHOD)) return RC_BAD_COMMAND;
00537
00538 AllocThreadObjectMethod* tom = static_cast<AllocThreadObjectMethod*>( p);
00539 getDataFromList( tom->threadObjectTraces, seq, all, what, iI, oA);
00540
00541 break;
00542 }
00543
00544 case ALLOC_THREAD_METHOD_OBJECTS:
00545 case ALLOC_THREAD_METHOD_TRACES: {
00546
00547 if( !p->isOfType( IdObject::ALLOC_THREAD_METHOD)) return RC_BAD_COMMAND;
00548
00549 AllocThreadMethod* tm = static_cast<AllocThreadMethod*>( p);
00550
00551 if( what == ALLOC_THREAD_METHOD_OBJECTS) getDataFromList( tm->threadObjectMethods, seq, all, what, iI, oA);
00552 else getDataFromList( tm->threadTraces, seq, all, what, iI, oA);
00553
00554 break;
00555 }
00556
00557 case ALLOC_THREAD_METHOD_TRACE_OBJECTS: {
00558
00559 if( !p->isOfType( IdObject::ALLOC_THREAD_TRACE)) return RC_BAD_COMMAND;
00560
00561 AllocThreadTrace* ttr = static_cast<AllocThreadTrace*>( p);
00562 getDataFromList( ttr->threadObjectTraces, seq, all, what, iI, oA);
00563
00564 break;
00565 }
00566
00567 case CPU_METHOD_TRACE_THREADS: {
00568
00569 if( !p->isOfType( IdObject::CPU_TRACE)) return RC_BAD_COMMAND;
00570
00571 CpuTrace* tr = static_cast<CpuTrace*>( p);
00572 getDataFromList( tr->threadTraces, seq, all, what, iI, oA);
00573
00574 break;
00575 }
00576
00577 case CPU_THREAD_METHOD_TRACES: {
00578
00579 if( !p->isOfType( IdObject::CPU_THREAD_METHOD)) return RC_BAD_COMMAND;
00580
00581 CpuThreadMethod* tm = static_cast<CpuThreadMethod*>( p);
00582 getDataFromList( tm->threadTraces, seq, all, what, iI, oA);
00583
00584 break;
00585 }
00586
00587 case MON_METHOD_TRACE_THREADS: {
00588
00589 if( !p->isOfType( IdObject::MON_TRACE)) return RC_BAD_COMMAND;
00590
00591 MonTrace* tr = static_cast<MonTrace*>( p);
00592 getDataFromList( tr->threadTraces, seq, all, what, iI, oA);
00593
00594 break;
00595 }
00596
00597 case MON_THREAD_METHOD_TRACES: {
00598
00599 if( !p->isOfType( IdObject::MON_THREAD_METHOD)) return RC_BAD_COMMAND;
00600
00601 MonThreadMethod* tm = static_cast<MonThreadMethod*>( p);
00602 getDataFromList( tm->threadTraces, seq, all, what, iI, oA);
00603
00604 break;
00605 }
00606
00607 case GROUP_THREADS: {
00608
00609 if( !p->isOfType( IdObject::GROUP_THREAD)) return RC_BAD_COMMAND;
00610
00611 GroupThread* g = static_cast<GroupThread*>( p);
00612 getDataFromList( g->threads, seq, all, what, iI, oA);
00613
00614 break;
00615 }
00616
00617 default:
00618
00619 return RC_BAD_COMMAND;
00620 }
00621
00622 break;
00623 }
00624 }
00625
00626 return seq.length();
00627 }
00628
00629 Prof::sID* Prof::copy( sID* dest,
00630 IdObject* src,
00631 objectID infoId,
00632 jint includeInfo) {
00633
00634 dest->infoId = infoId;
00635 dest->objId = src->getProfID();
00636
00637 dest->parentLeftObjId = 0;
00638 dest->parentUpObjId = 0;
00639 dest->parentRightObjId = 0;
00640
00641 dest->active = src->isActive();
00642
00643 dest->hasAllocData = src->getClassIdent() & IdObject::ALLOC;
00644 dest->hasCpuData = src->getClassIdent() & IdObject::CPU;
00645 dest->hasMonData = src->getClassIdent() & IdObject::MON;
00646
00647 AllocStatData* alloc = NULL;
00648 CpuStatData* cpu = NULL;
00649 MonStatData* mon = NULL;
00650
00651 IdObject::eClassIdent cI = src->getClassIdent();
00652
00653 if( cI == IdObject::ALLOC_OBJECT) {
00654
00655 alloc = static_cast<AllocObject*>( src);
00656 }
00657 else if( cI == IdObject::ALLOC_OBJECT_METHOD) {
00658
00659 AllocObjectMethod* aom = static_cast<AllocObjectMethod*>( src);
00660
00661 dest->parentLeftObjId = aom->method->getProfID();
00662 dest->parentUpObjId = aom->object->getProfID();
00663
00664 alloc = aom;
00665 }
00666 else if( cI == IdObject::ALLOC_OBJECT_TRACE) {
00667
00668 AllocObjectTrace* aotr = static_cast<AllocObjectTrace*>( src);
00669
00670 dest->parentLeftObjId = aotr->trace->getProfID();
00671 dest->parentUpObjId = aotr->objectMethod->getProfID();
00672
00673 alloc = aotr;
00674 }
00675 else if( cI == IdObject::ALLOC_THREAD_METHOD) {
00676
00677 AllocThreadMethod* athm = static_cast<AllocThreadMethod*>( src);
00678
00679 dest->parentLeftObjId = athm->method->getProfID();
00680 dest->parentUpObjId = athm->thread->getProfID();
00681
00682 alloc = athm;
00683 }
00684 else if( cI == IdObject::ALLOC_THREAD_OBJECT) {
00685
00686 AllocThreadObject* atho = static_cast<AllocThreadObject*>( src);
00687
00688 dest->parentLeftObjId = atho->object->getProfID();
00689 dest->parentUpObjId = atho->thread->getProfID();
00690
00691 alloc = atho;
00692 }
00693 else if( cI == IdObject::ALLOC_THREAD_OBJECT_METHOD) {
00694
00695 AllocThreadObjectMethod* athom = static_cast<AllocThreadObjectMethod*>( src);
00696
00697 dest->parentLeftObjId = athom->objectMethod->getProfID();
00698 dest->parentUpObjId = athom->threadObject->getProfID();
00699 dest->parentRightObjId = athom->threadMethod->getProfID();
00700
00701 alloc = athom;
00702 }
00703 else if( cI == IdObject::ALLOC_THREAD_OBJECT_TRACE) {
00704
00705 AllocThreadObjectTrace* athotr = static_cast<AllocThreadObjectTrace*>( src);
00706
00707 dest->parentLeftObjId = athotr->objectTrace->getProfID();
00708 dest->parentUpObjId = athotr->threadObjectMethod->getProfID();
00709 dest->parentRightObjId = athotr->threadTrace->getProfID();
00710
00711 alloc = athotr;
00712 }
00713 else if( cI == IdObject::ALLOC_THREAD_TRACE) {
00714
00715 AllocThreadTrace* athtr = static_cast<AllocThreadTrace*>( src);
00716
00717 dest->parentLeftObjId = athtr->trace->getProfID();
00718 dest->parentUpObjId = athtr->threadMethod->getProfID();
00719
00720 alloc = athtr;
00721 }
00722 else if( cI == IdObject::ALLOC_TRACE) {
00723
00724 AllocTrace* atr = static_cast<AllocTrace*>( src);
00725
00726 dest->parentUpObjId = atr->method->getProfID();
00727
00728 alloc = atr;
00729 }
00730 else if( cI == IdObject::CPU_THREAD_METHOD) {
00731
00732 CpuThreadMethod* cthm = static_cast<CpuThreadMethod*>( src);
00733
00734 dest->parentLeftObjId = cthm->method->getProfID();
00735 dest->parentUpObjId = cthm->thread->getProfID();
00736
00737 cpu = cthm;
00738 }
00739 else if( cI == IdObject::CPU_THREAD_TRACE) {
00740
00741 CpuThreadTrace* cthtr = static_cast<CpuThreadTrace*>( src);
00742
00743 dest->parentLeftObjId = cthtr->trace->getProfID();
00744 dest->parentUpObjId = cthtr->threadMethod->getProfID();
00745
00746 cpu = cthtr;
00747 }
00748 else if( cI == IdObject::CPU_TRACE) {
00749
00750 CpuTrace* ctr = static_cast<CpuTrace*>( src);
00751
00752 dest->parentUpObjId = ctr->method->getProfID();
00753
00754 cpu = ctr;
00755 }
00756 else if( cI == IdObject::METHOD) {
00757
00758 Method* m = static_cast<Method*>( src);
00759
00760 dest->parentUpObjId = m->clss->getProfID();
00761
00762 alloc = m;
00763 cpu = m;
00764 mon = m;
00765 }
00766 else if( cI == IdObject::THREAD) {
00767
00768 Thread* th = static_cast<Thread*>( src);
00769
00770 dest->parentUpObjId = th->group->getProfID();
00771
00772 alloc = th;
00773 }
00774 else if( cI == IdObject::MON_THREAD_METHOD) {
00775
00776 MonThreadMethod* mthm = static_cast<MonThreadMethod*>( src);
00777
00778 dest->parentLeftObjId = mthm->method->getProfID();
00779 dest->parentUpObjId = mthm->thread->getProfID();
00780
00781 mon = mthm;
00782 }
00783 else if( cI == IdObject::MON_THREAD_TRACE) {
00784
00785 MonThreadTrace* mthtr = static_cast<MonThreadTrace*>( src);
00786
00787 dest->parentLeftObjId = mthtr->trace->getProfID();
00788 dest->parentUpObjId = mthtr->threadMethod->getProfID();
00789
00790 mon = mthtr;
00791 }
00792 else if( cI == IdObject::MON_TRACE) {
00793
00794 MonTrace* mtr = static_cast<MonTrace*>( src);
00795
00796 dest->parentUpObjId = mtr->method->getProfID();
00797
00798 mon = mtr;
00799 }
00800 else if( cI == IdObject::ALLOC_ARENA) {}
00801 else if( cI == IdObject::GARBAGE_C) {}
00802 else if( cI == IdObject::CLASS) {}
00803 else if( cI == IdObject::CLASS_FIELD) {}
00804 else if( cI == IdObject::GROUP_THREAD) {}
00805
00806 if( dest->hasAllocData && alloc) AllocStatData::copy( dest->alloc, *alloc);
00807 if( dest->hasCpuData && cpu) CpuStatData::copy( dest->cpu, *cpu);
00808 if( dest->hasMonData && mon) MonStatData::copy( dest->mon, *mon);
00809
00810 dest->hasInfo = 0;
00811 dest->info = NULL;
00812 dest->infoType = 0;
00813
00814 if( includeInfo)
00815 dest->hasInfo = getInfoBinaryFormat( dest->objId, dest->info, dest->infoType);
00816
00817 return dest;
00818 }
00819
00820 IProf::objectID Prof::getInfoId( IdObject* o, eSeqType seqType) {
00821
00822 switch( seqType) {
00823 case ALLOC_METHOD_OBJECTS: {
00824
00825 o = (static_cast<AllocObjectMethod*>( o))->object;
00826 break;
00827 }
00828 case ALLOC_METHOD_THREADS: {
00829
00830 o = (static_cast<AllocThreadMethod*>( o))->thread;
00831 break;
00832 }
00833 case ALLOC_TRACE_OBJECTS: {
00834
00835 o = (static_cast<AllocObjectTrace*>( o))->objectMethod->object;
00836 break;
00837 }
00838 case ALLOC_METHOD_TRACE_THREADS: {
00839
00840 o = (static_cast<AllocThreadTrace*>( o))->threadMethod->thread;
00841 break;
00842 }
00843 case ALLOC_OBJECT_METHODS: {
00844
00845 o = (static_cast<AllocObjectMethod*>( o))->method;
00846 break;
00847 }
00848 case ALLOC_OBJECT_METHOD_TRACES: {
00849
00850 o = (static_cast<AllocObjectTrace*>( o))->trace;
00851 break;
00852 }
00853 case ALLOC_OBJECT_THREADS: {
00854
00855 o = (static_cast<AllocThreadObject*>( o))->thread;
00856 break;
00857 }
00858 case ALLOC_OBJECT_METHOD_THREADS: {
00859
00860 o = (static_cast<AllocThreadObjectMethod*>( o))->threadObject->thread;
00861 break;
00862 }
00863 case ALLOC_OBJECT_METHOD_TRACE_THREADS: {
00864
00865 o = (static_cast<AllocThreadObjectTrace*>( o))->threadObjectMethod->threadObject->thread;
00866 break;
00867 }
00868 case ALLOC_THREAD_OBJECTS: {
00869
00870 o = (static_cast<AllocThreadObject*>( o))->object;
00871 break;
00872 }
00873 case ALLOC_THREAD_OBJECT_METHODS: {
00874
00875 o = (static_cast<AllocThreadObjectMethod*>( o))->objectMethod->method;
00876 break;
00877 }
00878 case ALLOC_THREAD_OBJECT_METHOD_TRACES: {
00879
00880 o = (static_cast<AllocThreadObjectTrace*>( o))->objectTrace->trace;
00881 break;
00882 }
00883 case ALLOC_THREAD_METHODS: {
00884
00885 o = (static_cast<AllocThreadMethod*>( o))->method;
00886 break;
00887 }
00888 case ALLOC_THREAD_METHOD_TRACES: {
00889
00890 o = (static_cast<AllocThreadTrace*>( o))->trace;
00891 break;
00892 }
00893 case ALLOC_THREAD_METHOD_OBJECTS: {
00894
00895 o = (static_cast<AllocThreadObjectMethod*>( o))->objectMethod->object;
00896 break;
00897 }
00898 case ALLOC_THREAD_METHOD_TRACE_OBJECTS: {
00899
00900 o = (static_cast<AllocThreadObjectTrace*>( o))->objectTrace->objectMethod->object;
00901 break;
00902 }
00903 case CPU_METHOD_THREADS: {
00904
00905 o = (static_cast<CpuThreadMethod*>( o))->thread;
00906 break;
00907 }
00908 case CPU_METHOD_TRACE_THREADS: {
00909
00910 o = (static_cast<CpuThreadTrace*>( o))->threadMethod->thread;
00911 break;
00912 }
00913 case CPU_THREAD_METHODS: {
00914
00915 o = (static_cast<CpuThreadMethod*>( o))->method;
00916 break;
00917 }
00918 case CPU_THREAD_METHOD_TRACES: {
00919
00920 o = (static_cast<CpuThreadTrace*>( o))->trace;
00921 break;
00922 }
00923 case MON_METHOD_THREADS: {
00924
00925 o = (static_cast<MonThreadMethod*>( o))->thread;
00926 break;
00927 }
00928 case MON_METHOD_TRACE_THREADS: {
00929
00930 o = (static_cast<MonThreadTrace*>( o))->threadMethod->thread;
00931 break;
00932 }
00933 case MON_THREAD_METHODS: {
00934
00935 o = (static_cast<MonThreadMethod*>( o))->method;
00936 break;
00937 }
00938 case MON_THREAD_METHOD_TRACES: {
00939
00940 o = (static_cast<MonThreadTrace*>( o))->trace;
00941 break;
00942 }
00943 }
00944
00945 return o->getProfID();
00946 }
00947
00948 jint Prof::getInfoBinaryFormat( objectID infoId,
00949 InfoBinaryFormat*& info,
00950 jint& infoType) {
00951
00952 ObjectTable* o = Counter::getCounter()->table.get( infoId);
00953 if( !o) return 0;
00954
00955 IdObject* p = o->obj;
00956
00957 switch( p->getClassIdent()) {
00958 case IdObject::CLASS: {
00959
00960 info = static_cast<Class*>( p);
00961 infoType = CLASS_INFO;
00962
00963 break;
00964 }
00965 case IdObject::CLASS_FIELD: {
00966
00967 info = static_cast<ClassField*>( p);
00968 infoType = CLASS_FIELD_INFO;
00969
00970 break;
00971 }
00972 case IdObject::METHOD: {
00973
00974 info = static_cast<Method*>( p);
00975 infoType = METHOD_INFO;
00976
00977 break;
00978 }
00979 case IdObject::ALLOC_TRACE: {
00980
00981 info = static_cast<AllocTrace*>( p);
00982 infoType = TRACE_INFO;
00983
00984 break;
00985 }
00986 case IdObject::CPU_TRACE: {
00987
00988 info = static_cast<CpuTrace*>( p);
00989 infoType = TRACE_INFO;
00990
00991 break;
00992 }
00993 case IdObject::MON_TRACE: {
00994
00995 info = static_cast<MonTrace*>( p);
00996 infoType = TRACE_INFO;
00997
00998 break;
00999 }
01000 case IdObject::ALLOC_OBJECT: {
01001
01002 info = static_cast<AllocObject*>( p);
01003 infoType = OBJECT_INFO;
01004
01005 break;
01006 }
01007 case IdObject::ALLOC_ARENA: {
01008
01009 info = static_cast<AllocArena*>( p);
01010 infoType = ARENA_INFO;
01011
01012 break;
01013 }
01014 case IdObject::THREAD: {
01015
01016 info = static_cast<Thread*>( p);
01017 infoType = THREAD_INFO;
01018
01019 break;
01020 }
01021 case IdObject::GROUP_THREAD: {
01022
01023 info = static_cast<GroupThread*>( p);
01024 infoType = THREAD_GROUP_INFO;
01025
01026 break;
01027 }
01028 case IdObject::GARBAGE_C: {
01029
01030 info = static_cast<GC*>( p);
01031 infoType = GC_INFO;
01032
01033 break;
01034 }
01035 default: {
01036
01037 return 0;
01038 }
01039 }
01040
01041 return 1;
01042 }
01043
01044 int Prof::getDataFromList_filter( IdObject* o, jint optionalArg) {
01045
01046 IdObject::eClassIdent cI = o->getClassIdent();
01047
01048 switch( cI) {
01049
01050 case IdObject::ALLOC_TRACE:
01051 case IdObject::ALLOC_OBJECT_TRACE:
01052 case IdObject::ALLOC_THREAD_OBJECT_TRACE:
01053 case IdObject::ALLOC_THREAD_TRACE: {
01054
01055 AllocStatData* alloc = NULL;
01056
01057 switch( cI) {
01058 case IdObject::ALLOC_TRACE: {
01059
01060 alloc = static_cast<AllocTrace*>( o);
01061 break;
01062 }
01063 case IdObject::ALLOC_OBJECT_TRACE: {
01064
01065 alloc = static_cast<AllocObjectTrace*>( o);
01066 break;
01067 }
01068 case IdObject::ALLOC_THREAD_OBJECT_TRACE: {
01069
01070 alloc = static_cast<AllocThreadObjectTrace*>( o);
01071 break;
01072 }
01073 case IdObject::ALLOC_THREAD_TRACE: {
01074
01075 alloc = static_cast<AllocThreadTrace*>( o);
01076 break;
01077 }
01078 }
01079
01080 if( alloc->allocNumInstancesLive < optionalArg) return 0;
01081
01082 break;
01083 }
01084
01085 case IdObject::CPU_TRACE:
01086 case IdObject::CPU_THREAD_TRACE: {
01087
01088 CpuStatData* cpu = NULL;
01089
01090 switch( cI) {
01091 case IdObject::CPU_TRACE: {
01092
01093 cpu = static_cast<CpuTrace*>( o);
01094 break;
01095 }
01096 case IdObject::CPU_THREAD_TRACE: {
01097
01098 cpu = static_cast<CpuThreadTrace*>( o);
01099 break;
01100 }
01101 }
01102
01103 if( cpu->hits < optionalArg) return 0;
01104
01105 break;
01106 }
01107
01108 case IdObject::MON_TRACE:
01109 case IdObject::MON_THREAD_TRACE: {
01110
01111 MonStatData* mon = NULL;
01112
01113 switch( cI) {
01114 case IdObject::MON_TRACE: {
01115
01116 mon = static_cast<MonTrace*>( o);
01117 break;
01118 }
01119 case IdObject::MON_THREAD_TRACE: {
01120
01121 mon = static_cast<MonThreadTrace*>( o);
01122 break;
01123 }
01124 }
01125
01126 if( mon->hits < optionalArg) return 0;
01127
01128 break;
01129 }
01130 }
01131
01132 return 1;
01133 }
01134
01135 void Prof::enableGC() {
01136
01137 gcLock.wait();
01138 jvmpiInterface->EnableGC();
01139 gcLock.release();
01140 }
01141
01142 void Prof::disableGC() {
01143
01144 communLock.release();
01145
01146 gcLock.wait();
01147 jvmpiInterface->DisableGC();
01148 gcLock.release();
01149
01150 communLock.wait();
01151 }
01152
01153 void Prof::runGC() {
01154
01155 communLock.release();
01156 gcLock.wait();
01157
01158 jvmpiInterface->RunGC();
01159
01160 communLock.wait();
01161 gcLock.release();
01162 }
