---

iprof.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 "../commun/iprof.h"
#include "../commun/communSocket.h"
#include "../commun3/communShMem.h"
#include "../delay/delay.h"
#include "../prof/synchronized.h"
#include "../prof/prof.h"

#ifdef USE_ALLOCATOR
Allocator IProf::sID::_allocator;
#endif

IProf::IProf( const Setup& setup, JVMPI_Interface* jvmpi) :

        communLock( "_commun_lock", jvmpi),
        conEstabl( 0) {

        _func[F_SHUTDOWN]      = &IProf::_shutdown;
        _func[F_IS_SHUTDOWNED] = &IProf::_isShutdowned;
        _func[F_SUSPEND_VM]    = &IProf::_suspendVM;
        _func[F_RESUME_VM]     = &IProf::_resumeVM;
        _func[F_EXIT_VM]       = &IProf::_exitVM;
        _func[F_GET_INFO]      = &IProf::_getInfo;
        _func[F_GET_DATA]      = &IProf::_getData;
        _func[F_GET_ALL]       = &IProf::_getAll;
        _func[F_GET_CHANGED]   = &IProf::_getChanged;
        _func[F_ENABLE_GC]     = &IProf::_enableGC;
        _func[F_DISABLE_GC]    = &IProf::_disableGC;
        _func[F_RUN_GC]        = &IProf::_runGC;

        if( setup.com.communType == Setup::COMMUN_SOCKET)

                _commun = new CommunSocket( setup.com.connectMode,
                                                                        setup.com.hostname,
                                                                        setup.com.port);

        else _commun = new CommunShMem( setup.com.shmemId, setup.com.shmemSize);
}

IProf::~IProf() {

        if( _commun) delete _commun;
}

int IProf::run() {

        conEstabl = 0;
        if( !_commun->initialize()) {

                Delay::delay( 100);
                return 0;
        }
        conEstabl = 1;

        Buffer buf;
        while( 1) {

                if( !_commun->isReady()) {

                        if( _commun->hasFailed()) return (conEstabl = 0);
                        continue;
                }

                Synchronized sync( communLock);

                buf.clear();

                (*_commun) >> buf;
                if( _commun->hasFailed()) return (conEstabl = 0);

                jint naction = *(jint*)(buf.getBuffer());
                jint action = ntohl( naction); // back to host-byte-order

                if( action < 0 || action >= FUNC_COUNT) return (conEstabl = 0);

                (this->*(_func[action]))( buf);

                (*_commun) << buf;
                if( _commun->hasFailed()) return (conEstabl = 0);
        }

        return 1;
}

void IProf::_shutdown( Buffer& b) {

        shutdown();
        b.clear();
}

void IProf::_isShutdowned( Buffer& b) {

        jint rc = isShutdowned();
        
        b.clear();
        b += rc; // automatically stored in network-byte-order
}

void IProf::_suspendVM( Buffer& b) {

        suspendVM();
        b.clear();
}

void IProf::_resumeVM( Buffer& b) {

        resumeVM();
        b.clear();
}

void IProf::_exitVM( Buffer& b) {

        exitVM();
        b.clear();
}

void IProf::_getInfo( Buffer& b) {

        const char* buf = b.getBuffer()+sizeof( jint); // jump the "action" field
        
        jint infoId = ntohl( *(const jint*)buf);
        buf += sizeof( infoId);
        jint type = ntohl( *(const jint*)buf);

        InfoBinaryFormat* info;
        jint rc = getInfo( infoId, (eInfoType)type, info);

        b.clear( sizeof( InfoBinaryFormat));
        b += rc;

        if( rc != RC_OK) return;

        info->infoToBin( b);
}

void IProf::_getData( Buffer& b) {

        const char* buf = b.getBuffer()+sizeof( jint); // jump the "action" field

        jint objId = ntohl( *(const jint*)buf);
        buf += sizeof( objId);
        jint type = ntohl( *(const jint*)buf);

        sData data;
        jint rc = getData( objId, (eDataType)type, data);

        b.clear( sizeof( sData));
        b += rc;

        if( rc != RC_OK) return;

        b += data.active;

        if( type == ALLOC_DATA)    data.alloc.dataToBin( b);
        else if( type == CPU_DATA) data.cpu  .dataToBin( b);
        else                       data.mon  .dataToBin( b); // MON_DATA
}

int IProf::sToBin( sID* s, void** inout) {

        Buffer* buf = reinterpret_cast<Buffer*> ( *inout);
        Buffer& b = *buf;

        b += s->infoId;
        b += s->objId;

        b += s->parentLeftObjId;
        b += s->parentUpObjId;
        b += s->parentRightObjId;

        b += s->active;
        
        b += s->hasAllocData;

        if( s->hasAllocData) s->alloc.dataToBin( b);

        b += s->hasCpuData;

        if( s->hasCpuData) s->cpu.dataToBin( b);

        b += s->hasMonData;

        if( s->hasMonData) s->mon.dataToBin( b);

        b += s->hasInfo;

        if( s->hasInfo) {

                b += s->infoType;
                s->info->infoToBin( b);
        }

        return 0;
}

void IProf::_getAllOrChanged( int all, Buffer& b) {

        const char* buf = b.getBuffer()+sizeof( jint); // jump the "action" field

        jint objId = ntohl( *(const jint*)buf);
        buf += sizeof( objId);

        jint what = ntohl( *(const jint*)buf);
        buf += sizeof( what);

        jint includeInfo = ntohl( *(const jint*)buf);
        buf += sizeof( includeInfo);

        jint optionalArg = ntohl( *(const jint*)buf);   

        seqID seq;
        jint rc;

        if( all) rc = getAll( objId, (eSeqType)what, includeInfo, optionalArg, seq);
        else rc = getChanged( objId, (eSeqType)what, includeInfo, optionalArg, seq);

        b.clear( seq.length()*sizeof( sID));
        b += rc;

        if( rc < 0) return;

        void* buf2 = &b;
        seq.forEach( sToBin, &buf2);
}

void IProf::_enableGC( Buffer& b) {

        enableGC();
        b.clear();
}

void IProf::_disableGC( Buffer& b) {

        disableGC();
        b.clear();
}

void IProf::_runGC( Buffer& b) {

        runGC();
        b.clear();
}

---