---

threads.cpp

Go to the documentation of this file.

/*
Copyright (c) 2001, John Lambert jlambert@jlambert.com
All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are 
permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of 
conditions and the following disclaimer.

Redistributions in binary form must reproduce the above copyright notice, this list
of conditions and the following disclaimer in the documentation and/or other
materials provided with the distribution. 

Neither the name of the xdProf project nor the names of its contributors may be used
to endorse or promote products derived from this software without specific prior 
written permission. 

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
$Header: /xdprof-dll/threads.cpp 40    5/09/01 5:29a Admin $ 
 */
#include "xdprof.h"


bool HotSpot = false;

static char* const NullCharPointer = "null";

static inline char* FixNull(char* c)
{
    return (c == null) ? NullCharPointer : c;
}


ThreadInfo::ThreadInfo(char *thread_name, char *group_name, char *parent_name, jobjectID thread_id, JNIEnv *thread_env_id)
:   m_thread_name(FixNull(thread_name)), 
    m_thread_id(thread_id),
    m_thread_env_id(*thread_env_id),
    m_started(0)
{
    _snprintf(m_printable, 512, "%s\n%s\n%s\n", FixNull(thread_name), FixNull(group_name), FixNull(parent_name));
}

ThreadInfo::ThreadInfo(const ThreadInfo & ci)
{
    strncpy(m_printable, ci.m_printable, 512);
    m_thread_name = ci.m_thread_name;
}

void ThreadInfo::setStarted(unsigned long started) const
{
    m_started = started;
}

inline unsigned long ThreadInfo::getStarted() const
{
    return m_started;
}

inline const char* ThreadInfo::getShortInfo() const
{
    return m_printable;
}

string ThreadInfo::getThreadName() const
{
    return m_thread_name;
}


ClassInfo::ClassInfo(const ClassInfo & ci)
{
    m_class_name = ci.m_class_name;
    m_source_name = ci.m_source_name;
    m_class_id = ci.m_class_id;

    if (ci.m_printable == null)
    {
        m_printable = null;
    }
    else
    {
        m_printable = new char[512];
        strncpy(m_printable, ci.m_printable, 512);
    }
}

ClassInfo::~ClassInfo()
{
    delete[] m_printable ;  // works even if m_printable is null
}

ClassInfo::ClassInfo(  char * class_name,  char * source_name, jclassID class_id)
{
    if (!HotSpot)
    {
        m_class_name = class_name;
        m_source_name = source_name;
    }
    else
    {

        m_class_name = new char[512];
        strncpy(m_class_name, class_name, 512);
        
        if (source_name != null)
        {
            m_source_name = new char[512];
            strncpy(m_source_name, source_name, 512);
        }
        else
            m_source_name = null;

    }
    m_class_id = class_id;
    m_printable = null;
}

const char * ClassInfo::getShortInfo() const
{
    if (m_printable != null)
        return m_printable;
    m_printable = new char[512];
    _snprintf(m_printable, 512, "%08X %s %s", m_class_id, m_class_name, (m_source_name == null) ? "unknown" : m_source_name);
    return m_printable;
}

MethodInfo::MethodInfo(const MethodInfo & mi)
{
    m_class_id = mi.m_class_id;
    m_method_id = mi.m_method_id;
    m_method_name = mi.m_method_name;
    m_method_signature = mi.m_method_signature;
    m_short_string = null;
}

MethodInfo::~MethodInfo()
{
    cout << "~MI " << m_method_id << endl;
    delete[] m_short_string;
}


// classid methodid methodname methodsig
inline const char* MethodInfo::getShortInfo() const
{
    if (m_short_string != null)
        return m_short_string;
    
    m_short_string = new char[512];
    _snprintf(m_short_string, 512, "%08X %08X %s %s\0", m_class_id, m_method_id, m_method_name, m_method_signature);
    return m_short_string;
}
jobjectID MethodInfo::getClassID() const
{
    return m_class_id;
}

MethodInfo::MethodInfo(
     char * method_name,
     char * method_signature,
    jint /* start_lineno */,
    jint /* end_lineno */,
    jmethodID method_id,
    jobjectID class_id)
{
    m_class_id = class_id;
    m_method_id = method_id;
    m_short_string = null;

    if (!HotSpot)
    {
        m_method_name = method_name;
        m_method_signature = method_signature; 
    }
    else
    {
        m_method_name = new char[512];
        m_method_signature = new char[512];
        strncpy(m_method_name, method_name, 512);
        strncpy(m_method_signature, method_signature , 512);
    }
    
    //printf("%s\n",m_short_string);
}



void ThreadDump(const string& info, ThreadID caller)
{
    ostringstream output;

    Lock(threads_lock);
    Lock(methods_lock);
    Lock(output_lock);

    if (ShutdownRequested)
    {
    unsafe_debug("shutdown in ", "ThreadDump");
    Unlock(output_lock);
    Unlock(methods_lock);
    Unlock(threads_lock);
    return;

    }

//if(false)
    CALL(DisableGC());
    
    ThreadMap::iterator t;
    set<ThreadID> SuspendedThreads;

    const char Endl = '\n';

    // suspend all threads
    for (t = Threads.begin(); t != Threads.end(); ++t)
    {
        ThreadID tid = t->first;
        jlong status = CALL(GetThreadStatus)(tid);
        if ((tid != caller) &&
            (
            ((status & (~JVMPI_THREAD_INTERRUPTED)) == JVMPI_THREAD_RUNNABLE) 
            ||      HotSpot
            )
            )
        {
            CALL(SuspendThread)(tid);   
            SuspendedThreads.insert(tid);
            unsafe_debug("Suspended ", tid);
        }
        else
        {
            unsafe_debug(tid, (long)status);
        }
    }

    unsafe_debug("#threads ", Threads.size());
    output << "// start_message; num threads: " << Threads.size() << Endl;
    output << Threads.size() << Endl;
    const int number_of_frames = 100;

    MethodSet methods_to_send;
    JVMPI_CallTrace trace;
    JVMPI_CallFrame tframes[number_of_frames];
    const JVMPI_CallFrame* f;
    for (t = Threads.begin(); t != Threads.end(); ++t)
    {
        const ThreadInfo& ti = t->second;

        output << "// start_thread " << t->first  << Endl;
        output << t->first << Endl; // threadid
    
        jint thread_status = CALL(GetThreadStatus)(t->first);
        output << ti.getShortInfo();
        output << ti.getStarted() << Endl;
        output << thread_status << Endl;    // thread status

//      unsafe_debug(t->first, ti.getThreadName(), thread_status);
        
        trace.frames = tframes;
        trace.env_id = t->first;
//assert(false);        
        CALL(GetCallTrace)(&trace, number_of_frames);

        unsafe_debug("num frames: ", trace.num_frames);

        output << "// num frames = " << trace.num_frames << Endl;
        output << trace.num_frames << Endl;
        
        // send each frame
        for (int i = 0; i < trace.num_frames; i++)
        {
            //output << "// start frame " << i << Endl;
            f = &trace.frames[i];
            
            output << f->method_id << ' ' << f->lineno << Endl; // send method_id lineno
            
            methods_to_send.insert(f->method_id);
        }

    }

    output << "// sending methods now, count=" << methods_to_send.size() << Endl;
    output << methods_to_send.size() << Endl;
    ClassSet classes_to_send;
    
    const MethodInfo * the_method;
    //const MethodMap::iterator
    MethodMap::iterator m;
    const MethodMap::iterator m_end = Methods.end();
    MethodMap::iterator mc_end = MethodCache.end(); // look in the cache
    const MethodSet::iterator mse =  methods_to_send.end();
    for(MethodSet::iterator mi = methods_to_send.begin(); mi != mse; ++mi)
    {

        m = MethodCache.find(*mi);
        if (m == mc_end)
        {
            // couldn't find, so load it and cache it
            m = Methods.find(*mi);
            
            //assert(m != Methods.end());
            if (m == m_end )
            {
                jclassID cid = CALL(GetMethodClass(*mi));
                unsafe_debug("Couldn't find ", *mi, cid);
                unsafe_debug("perf Methods = ", Methods.size());
                output << ends;
//              unsafe_debug("output:: ", output.str());
                
                assert(m != Methods.end());
                CALL(EnableGC());
                Unlock(output_lock);
                Unlock(methods_lock);
                Unlock(threads_lock);
                return;
            }       
                        
            MethodCache.insert(make_pair(*mi, m->second));
            mc_end = MethodCache.end();
        }
        //m = Methods.find(*mi);    //TODO: caching?
        assert(m != Methods.end());
        the_method = m->second;

        //classid methodid methodname methodsig
        output << the_method->getShortInfo() << Endl;
        unsafe_debug(the_method->getClassID(), the_method->getShortInfo());
        classes_to_send.insert(the_method->getClassID());
    }

    output << "// sending classes now, count=" << classes_to_send.size() << Endl;
    output << classes_to_send.size() << Endl;
    const ClassInfoMap::iterator end = ClassCache.end();
    ClassInfoMap::iterator c;
    const ClassSet::iterator cse = classes_to_send.end();
    for (ClassSet::iterator ci = classes_to_send.begin(); ci != cse; ++ci)
    {
        c = ClassCache.find(*ci);
        if (c == end)
        {
            c = Classes.find(*ci);
            ClassCache.insert(make_pair(*ci, c->second));
        }
        //c = Classes.find(*ci);    //TODO: caching?
        assert(c != Classes.end());
        // class_id class_name source_name
        //unsafe_debug("ci1", c->second.getShortInfo() );
        output << c->second.getShortInfo() << Endl;
    }


    output << "// end_message" << Endl;
    output << ends;

    // Restart all suspended threads; in reverse order.
    set<ThreadID>::reverse_iterator susIter;
    const set<ThreadID>::reverse_iterator stre = SuspendedThreads.rend();
    for (susIter = SuspendedThreads.rbegin(); susIter != stre; ++susIter)
    {
        CALL(ResumeThread(*susIter));
        unsafe_debug("Resumed", *susIter);
    }

//if(false)
    CALL(EnableGC());
    Unlock(output_lock);
    Unlock(methods_lock);
    Unlock(threads_lock);
    //return;
    Lock(output_lock);
    const int chunk = 1024;
    const string s = output.str();
    const char* cp = s.c_str();
    // send in tiny chunks

RecordPacket(info.size() + s.size());

    Send(info);

    for (string::size_type p = 0; p < (s.size()/chunk); p++)
    {
        Send(cp, chunk);
        cp += chunk;
    }
    Send(cp, strlen(cp));
    Unlock(output_lock);
    
    LeaveRelease;
    unsafe_debug("perf ", "");
    unsafe_debug("perf classes to send count", classes_to_send.size());
    unsafe_debug("perf Classes", Classes.size());
    unsafe_debug("perf ClassesCache", ClassCache.size());
    unsafe_debug("perf methods to send count", methods_to_send.size());
    unsafe_debug("perf MethodsCache = ", MethodCache.size());
    unsafe_debug("perf Methods = ", Methods.size());


    
    ofstream outtrace("network.txt");
    outtrace << info <<  s << endl;

    debug("message", s.size());
    debug(s);

}

---