#include <jvmpi.h>
#include <iostream.h>
#include <strstream.h>
#include <fstream.h>
#include <pfstream.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <time.h>
#include <sys/times.h>
#include <sys/utsname.h>
#include <vector>
#include <string>
#include <algorithm>

/*
 * Profiler: A profiler for the Linux Java JDK1.2 that reports time
 * spent in native code. Useful for understanding how much time is
 * spent in various libraries.
 *
 * Author: Nathan Meyers, nmeyers@javalinux.net
 * $Id: profiler.C,v 1.24 1999/11/07 20:18:21 nathanm Exp $
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * with this program. If not, the license is available from the
 * GNU project, at http://www.gnu.org.
 */

// Our main profiler class, which sets up, starts, and stops the profiler.
// Everything in this class is static... the static functions are usable
// with the C interfaces required by JVMPI.

class profiler
{
public:
    static JVMPI_Interface *jvmpi_interface;
    static unsigned long size, user_scale, scale, expand;
    static unsigned long low_address;
    static unsigned long high_address;
    static unsigned long address_range;
    static unsigned long array_size;
    static int expand_is_percent, global;
    static string filename;
    static jint JVM_OnLoad(JavaVM *jvm, char *options);
    static void NotifyEvent(JVMPI_Event *event);
    static jint usage();
    static ostream *outfile;
    static struct tms initial_times;
};

// This class encapsulates data on hot spots
class hotspot
{
public:
    string label;
    unsigned int count;
    hotspot() : label(""), count(0)     {}
    hotspot(string s, unsigned int c) :
	label(s), count(c)      {}
    hotspot& operator=(const hotspot &src)
    {
	label = src.label;
	count = src.count;
	return *this;
    }
    friend int operator==(const hotspot &lhs, const hotspot &rhs)
    {
	return lhs.label == rhs.label;
    }
    static int compare(const hotspot &lhs, const hotspot &rhs)
    {
	return lhs.count > rhs.count;
    }
    hotspot& operator+=(const hotspot &hs)
    {
	count += hs.count;
	return *this;
    }
};

// This class encapsulates a line of data from the /proc/<pid>/maps file
// describing the address range covered by a mapped shared library
class shared_library
{
    shared_library() : lib_total_time(0),
		       lib_no_procedure_time(0),
		       nm_pipe(0),
		       current_addr(0),
		       next_addr(0),
		       current_proc(""),
		       next_proc("")    {}
public:
    unsigned long range_start, range_end;
    unsigned long lib_total_time;
    unsigned long lib_no_procedure_time;
    string filename;
    static shared_library *factory(string &);
    istream *nm_pipe;
    string current_proc, next_proc;
    unsigned long current_addr, next_addr;
    static int compare(shared_library *a,
		       shared_library *b)
    {
	return a->range_start < b->range_start;
    }
    static int compare2(shared_library *a,
		       shared_library *b)
    {
	return a->lib_total_time > b->lib_total_time;
    }
    void charge_time(unsigned long, unsigned long, unsigned int, int);
    vector<hotspot> hotspots;
    void cleanup()
    {
	if (nm_pipe) delete nm_pipe;
	nm_pipe = 0;
    }
    ~shared_library()   { cleanup(); }
};

// This class encapsulates data read from the /proc/<pid>/maps file
class memory_map
{
public:
    vector<shared_library *> libraries;
    memory_map();
    ~memory_map();
};

// External entry point to match JVMPI's requirements - calls a static
// class function to handle initialization.
extern "C"
jint JNICALL JVM_OnLoad(JavaVM *jvm, char *options, void *)
{
    return profiler::JVM_OnLoad(jvm, options);
}

JVMPI_Interface *profiler::jvmpi_interface;
unsigned long profiler::size = 0;
unsigned long profiler::user_scale = 1024;
unsigned long profiler::scale;
unsigned long profiler::expand = 0;
unsigned long profiler::low_address;
unsigned long profiler::high_address;
unsigned long profiler::address_range;
unsigned long profiler::array_size;
ostream *profiler::outfile;
struct tms profiler::initial_times;
int profiler::expand_is_percent = 0;
int profiler::global = 1;
string profiler::filename = "";
u_short *profile_buffer = 0;

// Handle initialization: load the JVMPI pointer, parse args, set up
// profiling.
jint profiler::JVM_OnLoad(JavaVM *jvm, char *options)
{
    // Get our JVM interface pointer
    if (jvm->GetEnv((void **)&jvmpi_interface, JVMPI_VERSION_1) < 0)
	return JNI_ERR;

    // Set up pointer to our NotifyEvent function
    jvmpi_interface->NotifyEvent = NotifyEvent;

    // Initialize output file
    outfile = &cerr;

    // Legal options:
    //   size=<#bytes>  Allocate #bytes for the profile array
    //   scale=<scale>  Map <scale> bytes per profile array entry
    //   expand=<#bytes>  Allow for <#bytes> growth of shared lib space
    //   expand=<percent>%  Allow for <percent> grown of shared lib space
    //   scope=local    Report local & global addresses
    //   scope=global   Report global addresses (default)
    //   help
    while (options && *options)
    {
	char *p2;
	if (!strncmp(options, "file=", 5))
	{
	    options += 5;
	    p2 = strchr(options, ',');
	    int len = p2 ? p2 - options : strlen(options);
	    if (!len) return usage();
	    filename = options;
	    filename.erase(len);
	    options = p2 ? p2 : options + len;
	}
	else if (!strncmp(options, "size=", 5))
	{
	    options += 5;
	    size = strtol(options, &p2, 0);
	    if (p2 == options) return usage();
	    options = p2;
	}
	else if (!strncmp(options, "scale=", 6))
	{
	    options += 6;
	    user_scale = strtol(options, &p2, 0);
	    if (user_scale < 1) user_scale = 1;
	    if (p2 == options) return usage();
	    options = p2;
	}
	else if (!strncmp(options, "expand=", 7))
	{
	    options += 7;
	    expand = strtol(options, &p2, 0);
	    if (p2 == options) return usage();
	    options = p2;
	    if ((expand_is_percent = (*options == '%'))) options++;
	}
	else if (!strncmp(options, "scope=local", 11))
	{
	    options += 11;
	    global = 0;
	}
	else if (!strncmp(options, "scope=global", 12))
	{
	    options += 12;
	    global = 1;
	}
	else return usage();
	if (*options && *options++ != ',') return usage();
    }

    if (filename.length())
    {
	outfile = new ofstream(filename.c_str());
	if (outfile->fail())
	{
	    cerr << "Cannot open " << filename << " for output\n";
	    return JNI_ERR;
	}
    }

    // Indicate that we want only the init-done and shutdown events
    jvmpi_interface->EnableEvent(JVMPI_EVENT_JVM_INIT_DONE, 0);
    jvmpi_interface->EnableEvent(JVMPI_EVENT_JVM_SHUT_DOWN, 0);
}

jint profiler::usage()
{
    cerr << "Profiler usage: -XrunProfiler:[<option>=<value>, ...]\n\n"
	 << "Option Name and Value    Description\n"
	 << "---------------------    -----------\n"
	 << "size=<#bytes>            Allocate #bytes for profile array\n"
	 << "scale=<#bytes>           Alternative to #bytes; map #bytes\n"
	 << "                         per profile array entry\n"
	 << "expand=<#bytes>          Allow for #byte expansion in shared\n"
	 << "                         libs\n"
	 << "expand=<percent>%        Allow for <percent>% expansion in\n"
	 << "                         shared libs\n"
	 << "scope=global             Report time against global procedures\n"
	 << "                         (default)\n"
	 << "scope=local              Report time against local labels\n"
	 << "file=<filename>          Save output to specified file\n\n";
    return JNI_ERR;
}

// Memory map constructor. Read the contents of the /proc/<pid>/maps
// file and build a map of shared library regions.
memory_map::memory_map()
{
    // Figure out the name of the memory map file
    char namebuf[NAME_MAX + 1];
    ostrstream(namebuf, sizeof(namebuf)) << "/proc/" << getpid()
					 << "/maps" << '\0';
    // Open the mapfile
    ifstream mapfile(namebuf);
    // Start reading...
    string line;
    while (!getline(mapfile, line).fail())
    {
	// See if we can build a shared_library entry from it
	shared_library *range =
	    shared_library::factory(line);
	// Got one... add it to our vector
	if (range) libraries.push_back(range);
    }
    // Sort our vector, although it's probably already in order
    sort(libraries.begin(), libraries.end(), shared_library::compare);
}

// Memory map destructor: free our entries.
memory_map::~memory_map()
{
    vector<shared_library *>::iterator first = libraries.begin();
    vector<shared_library *>::iterator last = libraries.end();
    while (first != last) delete(*first++);
}

// NotifyEvent: Here is where we get the events that start and stop
// profiling
void profiler::NotifyEvent(JVMPI_Event *event)
{
    // Create a map of shared libraries. We do this twice, once at
    // startup to figure out how large an area to profile, and again
    // at shutdown to map the addresses profiled to the shared
    // libraries.
    memory_map map;
    if (event->event_type == JVMPI_EVENT_JVM_INIT_DONE)
    {
	// Sanity check
	if (map.libraries.empty())
	{
	    cerr << "Profiler: Could not identify shared libs to profile\n";
	    // Figure out our Linux release; complain if <2.2.
	    struct utsname utsbuf;
	    uname(&utsbuf);
	    int major, minor;
	    char ch;
	    if ((istrstream(utsbuf.release) >> major
					    >> ch
					    >> minor).fail() ||
		major < 2 || major == 2 && minor < 2)
		cerr << "Profiler requires Linux version >= 2.2\n";
	    jvmpi_interface->ProfilerExit(1);
	}
	// We're starting up. Figure out where shared libs start and end
	low_address = map.libraries.front()->range_start;
	high_address = map.libraries.back()->range_end;
	// Another sanity check
	if (high_address <= low_address)
	{
	    cerr << "Profiler: Could not identify address range to profile\n";
	    jvmpi_interface->ProfilerExit(1);
	}
	// Compute the size of the address range to profile
	address_range = high_address - low_address;
	// If a fudge factor was specified, apply it
	if (expand > 0)
	{
	    address_range += expand_is_percent ?
			     address_range * expand / 100:
			     expand;
	}
	// Announce the address range of the shared libs we're profiling
	cerr << "Profiler: profiling over " << address_range
	     << "-byte address range\n";
	// Compute the dimension of the array we need
	array_size = (size > 0) ?
		     size / sizeof(u_short) :
		     address_range / (user_scale) + 1;
	// Announce it
	cerr << "Profiler: allocating " << array_size
	     << " profiling elements\n";
	// Allocate the array
	profile_buffer = new u_short[array_size];
	if (!profile_buffer)
	{
	    // Bomb if necessary
	    cerr << "Profiler: failed to allocate profile buffer\n";
	    jvmpi_interface->ProfilerExit(1);
	}
	cerr << '\n';
	// Clear the counters
	memset(profile_buffer, 0, array_size * sizeof(u_short));
	// Compute the scale value profil() needs
	scale = (unsigned long)
	    ((unsigned long long)array_size * 131072 / address_range);
	if (scale < 1) scale = 1;
	// Record current user time
	times(&initial_times);
	// Turn on profiling
	profil(profile_buffer, array_size * sizeof(u_short),
	       low_address, (u_int)scale);
    }
    else if (event->event_type == JVMPI_EVENT_JVM_SHUT_DOWN)
    {
	// Shutdown... we're done profiling
	profil(0, 0, 0, 0);
	struct tms curr_times;
	times(&curr_times);
	// Step through the profile addresses and the library addresses
	// in parallel, looking for libraries and functions to charge.
	// Depending on how much address space is covered by a profiling
	// element, a count might be chargeable to a single procedure,
	// to a single library, or to the entire application. Record
	// each case appropriately.
	vector<shared_library *>::iterator first = map.libraries.begin();
	vector<shared_library *>::iterator last = map.libraries.end();
	unsigned long app_total_time = 0;
	unsigned long app_no_library_time = 0;
	for (int i = 0; i < array_size; i++)
	{
	    // Do we have a hit in the profile buffer?
	    if (profile_buffer[i])
	    {
		// Yes.
		app_total_time += profile_buffer[i];
		// See where it falls in the libraries.
		unsigned long addr1 =
		    (unsigned long)
			((unsigned long long)i * 131072 / scale) +
			low_address;
		unsigned long addr2 =
		    (unsigned long)
			((unsigned long long)(i+1) * 131072 / scale) +
			low_address;
		while (first != last && addr1 > (*first)->range_end)
		{
		    // Move on to the next library, performing cleanup
		    // for the current one
		    (*first++)->cleanup();
		}
		// If first != last, we've found the library where this
		// profile range starts. Does it also end in this library?
		if (first != last && addr2 <= (*first)->range_end)
		{
		    // Yes. Charge time to this library.
		    (*first)->charge_time(addr1, addr2,
			(unsigned int)profile_buffer[i], global);
		}
		else app_no_library_time += profile_buffer[i];
	    }
	}
	// Report results
	*outfile << "Total time: "
		 << (curr_times.tms_utime + curr_times.tms_stime -
		     initial_times.tms_utime - initial_times.tms_stime) *
		    1000 / CLK_TCK
		 << " ms ("
		 << (curr_times.tms_utime - initial_times.tms_utime) *
		    1000 / CLK_TCK
		 << " ms user, "
		 << (curr_times.tms_stime - initial_times.tms_stime) *
		    1000 / CLK_TCK
		 << " ms system)\n";
	*outfile << "Total time profiled: " << app_total_time * 10
		 << " ms\n";
	if (app_no_library_time)
	    *outfile << "Non-library time profiled: "
		     << app_no_library_time * 10 << " ms\n";
	*outfile << "\nObserved total time > profiled time "
		 << "can be due to:\n"
		 << " + JIT-compiled code not running in the shared "
		 << "library address space\n"
		 << " + Unprofiled dynamically loaded shared libraries "
		 << "(use expand= option)\n"
		 << "Observed total time < profiled time "
		 << "can be due to:\n"
		 << " + Native-threaded apps can confuse the times(2) "
		 << "system call\n";
	if (app_no_library_time)
	{
	    *outfile << "Non-library time profiled can be due to:\n"
		     << " + Dynamically loaded shared libraries (use "
		     << "expand= option)\n";
	    if (user_scale > 1)
		*outfile << " + Profile data that cannot be resolved to "
			 << "a single library\n"
			 << "     (use smaller scale= option, "
			 << "current value = " << user_scale
			 << ")\n";
	}
	*outfile << "\nCPU Use by Library"
		 << "\n------------------\n";
	first = map.libraries.begin();
	last = map.libraries.end();
	sort(first, last, shared_library::compare2);
	vector<hotspot> global_hotspot_list;
	int found_non_procedure_time = 0;
	while (first != last)
	{
	    // Any hits for this library?
	    if ((*first)->lib_total_time)
	    {
		// Yes. Report them
		*outfile << (*first)->filename << "\n"
			 << "  Total time: "
			 << (*first)->lib_total_time * 10
			 << " ms\n";
		if ((*first)->lib_no_procedure_time)
		{
		    *outfile << "  Non-procedure time: "
			     << (*first)->lib_no_procedure_time * 10
			     << " ms\n";
		    found_non_procedure_time = 1;
		}
		// Any hotspots recorded for this library?
		if (!(*first)->hotspots.empty())
		{
		    // Add them to the global list
		    global_hotspot_list.insert(
			global_hotspot_list.end(),
			(*first)->hotspots.begin(),
			(*first)->hotspots.end());
		}
	    }
	    // Move on to the next library
	    first++;
	}
	if (found_non_procedure_time && user_scale > 1)
	{
	    *outfile << "\nNon-procedure time can be due to:\n"
		     << " + Profile data that cannot be resolved to a "
		     << "single procedure\n"
		     << "     (use smaller scale= option, "
		     << "current value = " << user_scale
		     << ")\n";
	}
	if (!global_hotspot_list.empty())
	{
	    *outfile << "\nHot Spots\n---------\n";
	    if (found_non_procedure_time && user_scale > 1)
		*outfile << "Hot spot information is reported for "
			 << "profiling data that can\nbe resolved to "
			 << "individual library procedures. The most "
			 << "accurate\nresults will generated by using "
			 << "small values for the scale=\noption "
			 << "(current value = " << user_scale
			 << ")\n\n";
	    sort(global_hotspot_list.begin(),
		 global_hotspot_list.end(),
		 hotspot::compare);
	    for (vector<hotspot>::iterator hsit =
		     global_hotspot_list.begin();
		 hsit != global_hotspot_list.end();
		 hsit++)
	    {    
		*outfile << hsit->label
			 << ": " << hsit->count * 10
			 << " ms\n";
	    }
	}
    }
}

void shared_library::charge_time(unsigned long addr1,
				 unsigned long addr2,
				 unsigned int ticks,
				 int global)
{
    // Charge the tick count to the total time
    lib_total_time += ticks;
    // Have we started reading nm data from the shared library?
    if (!nm_pipe)
    {
	// No. Give it a try. Put together a command string to gather
	// the data and massage it appropriately
	string cmdline = "|nm --portability ";
	cmdline += filename;
	cmdline += " | grep ";
	if (!global) cmdline += "-i ";
	cmdline += "' T ' | sort +2 2>/dev/null";
	nm_pipe = new ipfstream(cmdline.c_str());
    }
    string line, tempbuf;
    // Read library addresses until we find nearest label <= IP
    while (!current_addr || addr1 >= next_addr)
    {
	current_proc = next_proc;
	current_addr = next_addr;
	// Can we read more?
	if (getline(*nm_pipe, line).fail())
	{
	    // No. fix final address range.
	    next_addr = range_end;
	}
	else
	{
	    // Yes. Read next address
	    istrstream(line.c_str()) >> hex >> next_proc >> tempbuf
				     >> next_addr;
	    next_proc = filename + ":" + next_proc;
	    next_addr += range_start;
	}
    }
    // While the next label is at same address, skip ahead
    while (current_addr == next_addr &&
	   !getline(*nm_pipe, line).fail())
    {
	istrstream(line.c_str()) >> hex >> next_proc >> tempbuf
				 >> next_addr;
	next_proc = filename + ":" + next_proc;
	next_addr += range_start;
    }
    if (addr1 >= current_addr && addr2 <= next_addr)
    {
	// We have a hit on the current procedure. Find it in the
	// hotspot array or append it
	hotspot newspot(current_proc, ticks);
	if (!hotspots.empty() && hotspots.back() == newspot)
	    hotspots.back() += newspot;
	else hotspots.push_back(newspot);
    }
    else
    {
	// The address range did not fit within the boundaries of one
	// procedure. Don't credit it to a particular procedure.
	lib_no_procedure_time += ticks;
    }
}

// shared_library::factory - build an element from an input line
// read from /proc/<pid>/maps, if it is relevant. A relevant line
// will be in the address range used by shared libraries, have
// the executable bit set, and show a filename - the latter is
// a Linux 2.2 feature.
shared_library *shared_library::factory(string &line)
{
    shared_library *result = 0;
    long range_start, range_end;
    string tempbuf, permissions, filename;
    char dash;
    // Extract the fields we care about
    if (!(istrstream(line.c_str()) >> hex >> range_start >> dash
				   >> range_end >> permissions >> tempbuf
				   >> tempbuf >> tempbuf >> filename).fail()
	&& range_start >= 0x40000000
	&& range_end < 0x80000000
	&& permissions.substr(2, 1) == "x")
    {
	result = new shared_library;
	result->range_start = range_start;
	result->range_end = range_end;
	result->filename = filename;
    }
    return result;
}