/*
 * @(#)hprof_tls.c	1.56 10/03/23
 * 
 * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 
 * -Redistribution of source code must retain the above copyright notice, this
 *  list of conditions and the following disclaimer.
 * 
 * -Redistribution 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 Oracle or the names of contributors may 
 * be used to endorse or promote products derived from this software without 
 * specific prior written permission.
 * 
 * This software is provided "AS IS," without a warranty of any kind. ALL 
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
 * ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
 * OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN")
 * AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE
 * AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
 * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST 
 * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, 
 * INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY 
 * OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, 
 * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 * 
 * You acknowledge that this software is not designed, licensed or intended
 * for use in the design, construction, operation or maintenance of any
 * nuclear facility.
 */

#include "hprof.h"

/* Thread Local Storage Table and method entry/exit handling. */

/*
 * The tls table items have a key of it's serial number, but may be
 *   searched via a walk of the table looking for a jthread match. 
 *   This isn't a performance
 *   issue because the table index should normally be stored in the
 *   Thread Local Storage for the thread. The table is only searched
 *   when the jthread is seen before the Thread Local Storage is set
 *   (e.g. before VM_INIT or the ThreadStart).
 *   The key is only used when we need to lookup a tls table entry by
 *   way of it's serial number, which should be unique per thread.
 *
 * Each active thread that we have seen should have a unique TlsIndex
 *   which is an index into this table.
 *
 * For cpu=times, each table entry will have a stack to hold the method
 *   that have been called, effectively keeping an active stack trace
 *   for the thread. As each method exits, the statistics for the trace
 *   associated with the current stack contents is updated.
 *
 * For cpu=samples, each thread is checked to see if it's runnable,
 *   and not suspended, and has a stack associated with it, and then
 *   that stack trace is updated with an additional 'hit'.
 *
 * This file also contains the dump logic for owned monitors, and for
 *   threads. 
 *
 */

/*
 * Initial number of stack elements to track per thread. This
 * value should be set to a reasonable guess as to the number of
 * methods deep a thread calls. This stack doubles in size for each
 * reallocation and does not shrink. 
 */

#define INITIAL_THREAD_STACK_LIMIT 64

typedef struct StackElement {
    FrameIndex  frame_index;	        /* Frame (method/location(-1)) */
    jmethodID   method;                 /* Method ID */
    jlong       method_start_time;      /* method start time */
    jlong       time_in_callees;        /* time in callees */
} StackElement;

typedef struct TlsInfo {
    jint            sample_status;      /* Thread status for cpu sampling */
    jboolean        agent_thread;       /* Is thread our own agent thread? */
    jthread         globalref;          /* Global reference for thread */
    Stack          *stack;              /* Stack of StackElements entry/exit */
    MonitorIndex    monitor_index;      /* last contended mon */
    jint            tracker_status;     /* If we are inside Tracker class */
    FrameIndex     *frames_buffer;      /* Buffer used to create TraceIndex */
    jvmtiFrameInfo *jframes_buffer;     /* Buffer used to create TraceIndex */
    int             buffer_depth;       /* Frames allowed in buffer */
    TraceIndex      last_trace;         /* Last trace for this thread */
    ObjectIndex     thread_object_index;/* If heap=dump */
    jlong           monitor_start_time; /* Start time for monitor */
    jint            in_heap_dump;       /* If we are an object in the dump */
} TlsInfo;

typedef struct SearchData {
    JNIEnv      *env;
    jthread      thread;
    TlsIndex     found;
} SearchData;

typedef struct IterateInfo {
    TlsIndex *		ptls_index;
    jthread  *		pthreads;
    jint		count;
} IterateInfo;

typedef struct ThreadList {
    jthread      *threads;
    SerialNumber *serial_nums;
    TlsInfo     **infos;
    jint          count;
    JNIEnv       *env;
} ThreadList;

typedef struct SampleData {
    ObjectIndex  thread_object_index;
    jint         sample_status;
} SampleData;

/* Private internal functions. */

static SerialNumber
get_key(TlsIndex index)
{
    SerialNumber *pkey;
    int           key_len;

    if ( index == 0 ) {
	return 0;
    }
    pkey    = NULL;
    key_len = 0;
    table_get_key(gdata->tls_table, index, (void**)&pkey, &key_len);
    HPROF_ASSERT(pkey!=NULL);
    HPROF_ASSERT(key_len==(int)sizeof(SerialNumber));
    return *pkey;
}

static TlsInfo *
get_info(TlsIndex index)
{
    return (TlsInfo*)table_get_info(gdata->tls_table, index);
}

static void
delete_globalref(JNIEnv *env, TlsInfo *info)
{
    jthread ref;
    
    HPROF_ASSERT(env!=NULL);
    HPROF_ASSERT(info!=NULL);
    ref = info->globalref;
    info->globalref = NULL;
    if ( ref != NULL ) {
	deleteWeakGlobalReference(env, ref);
    }
}

static void
clean_info(TlsInfo *info)
{
    /* Free up any allocated space in this TlsInfo structure */
    if ( info->stack != NULL ) {
	stack_term(info->stack);
	info->stack = NULL;
    }
    if ( info->frames_buffer != NULL ) {
	HPROF_FREE(info->frames_buffer);
	info->frames_buffer = NULL;
    }
    if ( info->jframes_buffer != NULL ) {
	HPROF_FREE(info->jframes_buffer);
	info->jframes_buffer = NULL;
    }
}

static void
cleanup_item(TableIndex index, void *key_ptr, int key_len, 
			void *info_ptr, void *arg)
{
    TlsInfo *   info;

    info = (TlsInfo*)info_ptr;
    clean_info(info);
}

static void
delete_ref_item(TableIndex index, void *key_ptr, int key_len, 
			void *info_ptr, void *arg)
{
    delete_globalref((JNIEnv*)arg, (TlsInfo*)info_ptr);
}

static void
list_item(TableIndex index, void *key_ptr, int key_len, 
			void *info_ptr, void *arg)
{
    TlsInfo     *info;
    
    HPROF_ASSERT(info_ptr!=NULL);
    
    info        = (TlsInfo*)info_ptr;
    debug_message( "Tls 0x%08x: SN=%u, sample_status=%d, agent=%d, "
			  "thread=%p, monitor=0x%08x, "
			  "tracker_status=%d\n",
                index,
                *(SerialNumber*)key_ptr,
                info->sample_status,
                info->agent_thread,
                (void*)info->globalref,
                info->monitor_index,
                info->tracker_status);
}

static void
search_item(TableIndex index, void *key_ptr, int key_len, 
			void *info_ptr, void *arg)
{
    TlsInfo     *info;
    SearchData  *data;
    jobject      lref;
    
    HPROF_ASSERT(info_ptr!=NULL);
    HPROF_ASSERT(arg!=NULL);
    info        = (TlsInfo*)info_ptr;
    data	= (SearchData*)arg;
    lref        = newLocalReference(data->env, info->globalref);
    if ( lref != NULL ) {
	if ( isSameObject(data->env, data->thread, lref) ) {
	    HPROF_ASSERT(data->found==0); /* Did we find more than one? */
	    data->found = index;
	}
	deleteLocalReference(data->env, lref);
    }
}

static TlsIndex
search(JNIEnv *env, jthread thread)
{
    SearchData  data;

    HPROF_ASSERT(env!=NULL);
    HPROF_ASSERT(thread!=NULL);
    
    data.env = env;
    data.thread = thread;
    data.found = 0;
    table_walk_items(gdata->tls_table, &search_item, (void*)&data);
    return data.found;
}

static void
garbage_collect_item(TableIndex index, void *key_ptr, int key_len, 
			void *info_ptr, void *arg)
{
    TlsInfo     *info;
    JNIEnv      *env;
    jobject      lref;
    
    HPROF_ASSERT(info_ptr!=NULL);
    HPROF_ASSERT(arg!=NULL);
    info        = (TlsInfo*)info_ptr;
    env 	= (JNIEnv*)arg;
    lref        = newLocalReference(env, info->globalref);
    if ( lref == NULL ) {
	delete_globalref(env, info);
	clean_info(info);
	table_free_entry(gdata->tls_table, index);
    } else {
	deleteLocalReference(env, lref);
    }
}

void
tls_garbage_collect(JNIEnv *env)
{
    HPROF_ASSERT(env!=NULL);
    rawMonitorEnter(gdata->data_access_lock); {
        table_walk_items(gdata->tls_table, &garbage_collect_item, (void*)env);
    } rawMonitorExit(gdata->data_access_lock);
}

static void
sum_sample_status_item(TableIndex index, void *key_ptr, int key_len, void *info_ptr, void *arg)
{
    TlsInfo     *info;
    
    HPROF_ASSERT(info_ptr!=NULL);
    info                = (TlsInfo*)info_ptr;
    if ( !info->agent_thread ) {
        (*(jint*)arg)      += info->sample_status;
    }
}

static void
setup_trace_buffers(TlsInfo *info, int max_depth)
{
    int nbytes;
    int max_frames;

    if ( info->frames_buffer != NULL && info->buffer_depth >= max_depth ) {
	return;
    }
    if ( info->frames_buffer != NULL ) {
	HPROF_FREE(info->frames_buffer);
    }
    if ( info->jframes_buffer != NULL ) {
	HPROF_FREE(info->jframes_buffer);
    }
    info->buffer_depth      = max_depth;
    max_frames              = max_depth + 4; /* Allow for BCI & <init> */
    nbytes                  = (int)sizeof(FrameIndex)*(max_frames+1);
    info->frames_buffer     = HPROF_MALLOC(nbytes);
    nbytes                  = (int)sizeof(jvmtiFrameInfo)*(max_frames+1);
    info->jframes_buffer    = HPROF_MALLOC(nbytes);
}

static TraceIndex
get_trace(jthread thread, SerialNumber thread_serial_num,
		int depth, jboolean skip_init,
		FrameIndex *frames_buffer, jvmtiFrameInfo *jframes_buffer)
{
    TraceIndex trace_index;
  
    trace_index = gdata->system_trace_index;
    if ( thread != NULL ) {
        trace_index = trace_get_current(thread,
			thread_serial_num, depth, skip_init,
			frames_buffer, jframes_buffer);
    }
    return trace_index;
}

/* Find thread with certain object index */
static void
sample_setter(TableIndex index, void *key_ptr, int key_len, void *info_ptr, void *arg)
{
    TlsInfo *info;
    
    HPROF_ASSERT(info_ptr!=NULL);
    
    info  = (TlsInfo*)info_ptr;
    if ( info->globalref != NULL && !info->agent_thread ) {
	SampleData *data;
	
	data   = (SampleData*)arg;
	if ( data->thread_object_index == info->thread_object_index ) {
	    info->sample_status = data->sample_status;
	}
    }
}

/* Get various lists on known threads */
static void
get_thread_list(TableIndex index, void *key_ptr, int key_len, void *info_ptr, void *arg)
{
    SerialNumber thread_serial_num;
    TlsInfo     *info;
    ThreadList  *list;
    jthread      thread;
    
    HPROF_ASSERT(key_ptr!=NULL);
    HPROF_ASSERT(info_ptr!=NULL);
    
    thread_serial_num = *(SerialNumber*)key_ptr;
    info              = (TlsInfo*)info_ptr;
    list              = (ThreadList*)arg;
    thread            = newLocalReference(list->env, info->globalref);
    if ( thread != NULL && info->sample_status != 0 && !info->agent_thread ) {
	if ( list->infos != NULL ) {
	    list->infos[list->count] = info;
	}
	if ( list->serial_nums != NULL ) {
	    list->serial_nums[list->count] = thread_serial_num;
	}
	list->threads[list->count] = thread;
	list->count++;
	/* Local reference gets freed by caller */
    } else {
	/* If we don't use the local reference, delete it now */
	if ( thread != NULL ) {
	    deleteLocalReference(list->env, thread);
	}
    }
}

static void
adjust_stats(jlong total_time, jlong self_time, TraceIndex trace_index,
	     StackElement *parent)
{
    if ( total_time > 0 && parent != NULL ) {  /* if a caller exists */
	parent->time_in_callees += total_time;
    }
    trace_increment_cost(trace_index, 1, self_time, total_time);
}

static void
push_method(Stack *stack, jlong method_start_time, jmethodID method)
{
    StackElement new_element;
    FrameIndex   frame_index;
    
    HPROF_ASSERT(method!=NULL);
    HPROF_ASSERT(stack!=NULL);

    frame_index                  = frame_find_or_create(method, -1);
    HPROF_ASSERT(frame_index != 0);
    new_element.frame_index      = frame_index;
    new_element.method           = method;
    new_element.method_start_time= method_start_time;
    new_element.time_in_callees  = (jlong)0;
    stack_push(stack, &new_element);
}  

static Stack *
insure_method_on_stack(jthread thread, TlsInfo *info, jlong current_time,
		FrameIndex frame_index, jmethodID method)
{
    StackElement  element;
    void         *p;
    int           depth;
    int           count;
    int           fcount;
    int           i;
    Stack         *new_stack;
    Stack         *stack;

    stack = info->stack;

    HPROF_ASSERT(method!=NULL);
   
    /* If this method is on the stack, just return */
    depth   = stack_depth(stack);
    p = stack_top(stack);
    if ( p != NULL ) {
        element = *(StackElement*)p;
	if ( element.frame_index == frame_index ) {
	    return stack;
        }
    }
    for ( i = 0 ; i < depth ; i++ ) {
        p = stack_element(stack, i);
        element = *(StackElement*)p;
	if ( element.frame_index == frame_index ) {
	    return stack;
	}
    }

    /* It wasn't found, create a new stack */
    getFrameCount(thread, &count);
    if ( count <= 0 ) {
        HPROF_ERROR(JNI_FALSE, "no frames, method can't be on stack");
    }
    setup_trace_buffers(info, count);
    getStackTrace(thread, info->jframes_buffer, count, &fcount);
    HPROF_ASSERT(count==fcount);

    /* Create a new stack */
    new_stack = stack_init(INITIAL_THREAD_STACK_LIMIT, 
			    INITIAL_THREAD_STACK_LIMIT,
			    (int)sizeof(StackElement));
    for ( i = count-1; i >= 0 ; i-- ) {
	push_method(new_stack, current_time, info->jframes_buffer[i].method);
    }
    if ( depth > 0 ) {
	for ( i = depth-1 ; i >= 0; i-- ) {
	    stack_push(new_stack, stack_element(stack, i));
	}
    }
    stack_term(stack);
    return new_stack;
}

static void
pop_method(TlsIndex index, jlong current_time, jmethodID method, FrameIndex frame_index)
{
    SerialNumber  thread_serial_num;
    TlsInfo  *    info;
    StackElement  element;
    void         *p;
    int           depth;
    int           trace_depth;
    jlong         total_time;
    jlong         self_time;
    int           i;
    TraceIndex    trace_index;

    HPROF_ASSERT(method!=NULL);
    HPROF_ASSERT(frame_index!=0);
    
    thread_serial_num  = get_key(index);
    info               = get_info(index);
    HPROF_ASSERT(info!=NULL);
    HPROF_ASSERT(info->stack!=NULL);
    depth   = stack_depth(info->stack);
    p = stack_pop(info->stack);
    if (p == NULL) {
        HPROF_ERROR(JNI_FALSE, "method return tracked, but stack is empty");
	return;
    }
    element = *(StackElement*)p;
    HPROF_ASSERT(element.frame_index!=0);

    /* The depth of frames we should keep track for reporting */
    if (gdata->prof_trace_depth > depth) {
	trace_depth = depth;
    } else {
	trace_depth = gdata->prof_trace_depth;
    }
    
    /* Create a trace entry */
    HPROF_ASSERT(info->frames_buffer!=NULL);
    HPROF_ASSERT(info->jframes_buffer!=NULL);
    setup_trace_buffers(info, trace_depth);
    info->frames_buffer[0] = element.frame_index;
    for (i = 1; i < trace_depth; i++) {
	StackElement e;
	
	e = *(StackElement*)stack_element(info->stack, (depth - i) - 1);
	info->frames_buffer[i] = e.frame_index;
	HPROF_ASSERT(e.frame_index!=0);
    }
    trace_index = trace_find_or_create(thread_serial_num,
		    trace_depth, info->frames_buffer, info->jframes_buffer);
   
    /* Calculate time spent */
    total_time = current_time - element.method_start_time;
    if ( total_time < 0 ) {
	total_time = 0;
        self_time = 0;
    } else {
        self_time = total_time - element.time_in_callees;
    }

    /* Update stats */
    p = stack_top(info->stack);
    if ( p != NULL ) {
        adjust_stats(total_time, self_time, trace_index, (StackElement*)p);
    } else {
        adjust_stats(total_time, self_time, trace_index, NULL);
    }
}

static void
dump_thread_state(TlsIndex index, void *key_ptr, int key_len, void *info_ptr, void *arg)
{
    SerialNumber thread_serial_num;
    TlsInfo     *info;
    jthread      thread;
    JNIEnv      *env;
    
    HPROF_ASSERT(key_ptr!=NULL);
    HPROF_ASSERT(info_ptr!=NULL);
    env                  = (JNIEnv*)arg;
    thread_serial_num    = *(SerialNumber*)key_ptr;
    info                 = (TlsInfo*)info_ptr;
    thread               = newLocalReference(env, info->globalref);
    if ( thread != NULL ) {
	jint         threadState;
	SerialNumber trace_serial_num;
	
	getThreadState(thread, &threadState);
	/* A 0 trace at this time means the thread is in unknown territory.
	 *   The trace serial number MUST be a valid serial number, so we use
	 *   the system trace (empty) just so it has a valid trace.
	 */
	if ( info->last_trace == 0 ) {
	    trace_serial_num = trace_get_serial_number(gdata->system_trace_index);
	} else {
	    trace_serial_num = trace_get_serial_number(info->last_trace);
	}
	io_write_monitor_dump_thread_state(thread_serial_num,
		       trace_serial_num, threadState);
	deleteLocalReference(env, thread);
    }
}

static SerialNumber
get_serial_number(JNIEnv *env, jthread thread)
{
    TlsIndex     index;
    
    if ( thread == NULL ) {
	return gdata->unknown_thread_serial_num;
    }
    HPROF_ASSERT(env!=NULL);
    index = tls_find_or_create(env, thread);
    return get_key(index);
}

static void
dump_monitor_state(TlsIndex index, void *key_ptr, int key_len, void *info_ptr, void *arg)
{
    TlsInfo *info;
    jthread  thread;
    JNIEnv  *env;
    
    HPROF_ASSERT(info_ptr!=NULL);
    env = (JNIEnv*)arg;
    info = (TlsInfo*)info_ptr;
    thread = newLocalReference(env, info->globalref);
    if ( thread != NULL ) {
	jobject *objects;
	jint     ocount;
	int      i;
	
	getOwnedMonitorInfo(thread, &objects, &ocount);
	if ( ocount > 0 ) {
	    for ( i = 0 ; i < ocount ; i++ ) {
		jvmtiMonitorUsage usage;
		SerialNumber *waiter_nums;
		SerialNumber *notify_waiter_nums;
		int           t;
		char *        sig;

		WITH_LOCAL_REFS(env, 1) {
		    jclass clazz;

		    clazz = getObjectClass(env, objects[i]);
		    getClassSignature(clazz, &sig, NULL);
		} END_WITH_LOCAL_REFS;
		
		getObjectMonitorUsage(objects[i], &usage);
		waiter_nums = HPROF_MALLOC(usage.waiter_count*
					(int)sizeof(SerialNumber)+1);
                for ( t = 0 ; t < usage.waiter_count ; t++ ) {
		    waiter_nums[t] = 
			get_serial_number(env, usage.waiters[t]);
		}
		notify_waiter_nums = HPROF_MALLOC(usage.notify_waiter_count*
					(int)sizeof(SerialNumber)+1);
                for ( t = 0 ; t < usage.notify_waiter_count ; t++ ) {
		    notify_waiter_nums[t] = 
			get_serial_number(env, usage.notify_waiters[t]);
		}
		io_write_monitor_dump_state(sig,
		       get_serial_number(env, usage.owner), 
		       usage.entry_count,
		       waiter_nums, usage.waiter_count,
		       notify_waiter_nums, usage.notify_waiter_count);
		jvmtiDeallocate(sig);
		jvmtiDeallocate(usage.waiters);
		jvmtiDeallocate(usage.notify_waiters);
		HPROF_FREE(waiter_nums);
		HPROF_FREE(notify_waiter_nums);
	    }
	}
	jvmtiDeallocate(objects);
	deleteLocalReference(env, thread);
    }
}

static jlong
monitor_time(void)
{
    jlong mtime;

    mtime = md_get_timemillis(); /* gettimeofday() */
    return mtime;
}

static jlong
method_time(void)
{
    jlong method_time;

    method_time = md_get_thread_cpu_timemillis(); /* thread CPU time */
    return method_time;
}

/* External interfaces */

TlsIndex
tls_find_or_create(JNIEnv *env, jthread thread)
{
    SerialNumber    thread_serial_num;
    static TlsInfo  empty_info;
    TlsInfo         info;
    TlsIndex        index;

    HPROF_ASSERT(env!=NULL);
    HPROF_ASSERT(thread!=NULL);
    
    /*LINTED*/
    index = (TlsIndex)(ptrdiff_t)getThreadLocalStorage(thread);
    if ( index != 0 ) {
	HPROF_ASSERT(isSameObject(env, thread, get_info(index)->globalref));
	return index;
    }
    index = search(env, thread);
    if ( index != 0 ) {
	setThreadLocalStorage(thread, (void*)(ptrdiff_t)index);
	return index;
    }
    thread_serial_num      = gdata->thread_serial_number_counter++;
    info                   = empty_info;
    info.monitor_index     = 0;
    info.sample_status     = 1;
    info.agent_thread      = JNI_FALSE;
    info.stack             = stack_init(INITIAL_THREAD_STACK_LIMIT, 
				INITIAL_THREAD_STACK_LIMIT,
				(int)sizeof(StackElement));
    setup_trace_buffers(&info, gdata->max_trace_depth);
    info.globalref = newWeakGlobalReference(env, thread);
    index = table_create_entry(gdata->tls_table, &thread_serial_num, (int)sizeof(SerialNumber), (void*)&info);
    setThreadLocalStorage(thread, (void*)(ptrdiff_t)index);
    HPROF_ASSERT(search(env,thread)==index);
    return index;
}

/* Mark a new or existing entry as being an agent thread */
void
tls_agent_thread(JNIEnv *env, jthread thread)
{
    TlsIndex  index;
    TlsInfo  *info;

    index              = tls_find_or_create(env, thread);
    info               = get_info(index);
    info->agent_thread = JNI_TRUE;
}

void
tls_init(void)
{
    gdata->tls_table = table_initialize("TLS",
                            16, 16, 16, (int)sizeof(TlsInfo));
}

void
tls_list(void)
{
    debug_message( 
        "--------------------- TLS Table ------------------------\n");
    table_walk_items(gdata->tls_table, &list_item, NULL);
    debug_message(
        "----------------------------------------------------------\n");
}

jint
tls_sum_sample_status(void)
{
    jint sample_status_total;
    
    sample_status_total = 0;
    table_walk_items(gdata->tls_table, &sum_sample_status_item, (void*)&sample_status_total);
    return sample_status_total;
}

void
tls_set_sample_status(ObjectIndex object_index, jint sample_status)
{
    SampleData  data;

    data.thread_object_index = object_index;
    data.sample_status       = sample_status;
    table_walk_items(gdata->tls_table, &sample_setter, (void*)&data);
}

jint
tls_get_tracker_status(JNIEnv *env, jthread thread, jboolean skip_init,
	jint **ppstatus, TlsIndex* pindex,
	SerialNumber *pthread_serial_num, TraceIndex *ptrace_index)
{
    TlsInfo      *info;
    TlsIndex      index;
    SerialNumber  thread_serial_num;
    jint          status;
  
    index             = tls_find_or_create(env, thread);
    info              = get_info(index);
    *ppstatus         = &(info->tracker_status);
    status            = **ppstatus;
    thread_serial_num = get_key(index);
    
    if ( pindex != NULL ) {
	*pindex = index;
    }
    if ( status != 0 ) {
	return status;
    }
    if ( ptrace_index != NULL ) {
	setup_trace_buffers(info, gdata->max_trace_depth);
	*ptrace_index = get_trace(thread, thread_serial_num, 
			    gdata->max_trace_depth, skip_init,
			    info->frames_buffer, info->jframes_buffer);
    }
    if ( pthread_serial_num != NULL ) {
	*pthread_serial_num = thread_serial_num;
    }
    return status;
}

MonitorIndex
tls_get_monitor(TlsIndex index)
{
    TlsInfo  *info;
    
    info = get_info(index);
    return info->monitor_index;
}

void
tls_set_thread_object_index(TlsIndex index, ObjectIndex thread_object_index)
{
    TlsInfo  *info;
    
    info = get_info(index);
    info->thread_object_index = thread_object_index;
}

SerialNumber
tls_get_thread_serial_number(TlsIndex index)
{
    return get_key(index);
}

void
tls_set_monitor(TlsIndex index, MonitorIndex monitor_index)
{
    TlsInfo  *info;
    
    info = get_info(index);
    info->monitor_index = monitor_index;
}

void
tls_cleanup(void)
{
    table_cleanup(gdata->tls_table, &cleanup_item, NULL);
    gdata->tls_table = NULL;
}

void
tls_delete_global_references(JNIEnv *env)
{
    table_walk_items(gdata->tls_table, &delete_ref_item, (void*)env);
}

void
tls_thread_ended(JNIEnv *env, TlsIndex index)
{
    HPROF_ASSERT(env!=NULL);
   
    /* Sample thread stack for last time, do NOT free the entry yet. */
    table_lock_enter(gdata->tls_table); {
	SerialNumber thread_serial_num;
        TlsInfo     *info;
	jthread      thread;
	
	thread_serial_num = get_key(index);
	info              = get_info(index);
	thread            = newLocalReference(env, info->globalref);
	if (gdata->heap_dump && thread!=NULL) {
	    setup_trace_buffers(info, gdata->max_trace_depth);
	    info->last_trace = get_trace(thread, thread_serial_num,
				    gdata->max_trace_depth, JNI_FALSE,
				    info->frames_buffer, info->jframes_buffer);
	}
	if ( thread != NULL ) {
	    deleteLocalReference(env, thread);
	}
    } table_lock_exit(gdata->tls_table);

}

/* Sample ALL threads and update the trace costs */
void
tls_sample_all_threads(JNIEnv *env)
{
    ThreadList    list;
    jthread      *threads;
    SerialNumber *serial_nums;
    
    table_lock_enter(gdata->tls_table); {
	int           max_count;
	int           nbytes;
	int           i;
 
	/* Get buffers to hold thread list and serial number list */
	max_count   = table_element_count(gdata->tls_table);
	nbytes      = (int)sizeof(jthread)*max_count;
	threads     = (jthread*)HPROF_MALLOC(nbytes);
	nbytes      = (int)sizeof(SerialNumber)*max_count;
	serial_nums = (SerialNumber*)HPROF_MALLOC(nbytes);
	
	/* Get list of threads and serial numbers */
	list.threads     = threads;
	list.infos       = NULL;
	list.serial_nums = serial_nums;
	list.count       = 0;
	list.env         = env;
        table_walk_items(gdata->tls_table, &get_thread_list, (void*)&list);
	
	/* Increment the cost on the traces for these threads */
	trace_increment_all_sample_costs(list.count, threads, serial_nums, 
			      gdata->max_trace_depth, JNI_FALSE);

	/* Loop over local refs and free them */
	for ( i = 0 ; i < list.count ; i++ ) {
	    if ( threads[i] != NULL ) {
		deleteLocalReference(env, threads[i]);
	    }
	}

    } table_lock_exit(gdata->tls_table);
    
    /* Free up allocated space */
    HPROF_FREE(threads);
    HPROF_FREE(serial_nums);

}

void
tls_push_method(TlsIndex index, jmethodID method)
{
    jlong    method_start_time;
    TlsInfo *info;
    
    HPROF_ASSERT(method!=NULL);
    info        = get_info(index);
    HPROF_ASSERT(info!=NULL);
    method_start_time  = method_time();
    HPROF_ASSERT(info->stack!=NULL);
    push_method(info->stack, method_start_time, method);
}  

void
tls_pop_exception_catch(TlsIndex index, jthread thread, jmethodID method)
{
    TlsInfo      *info;
    StackElement  element;
    void         *p;
    FrameIndex    frame_index;
    jlong         current_time;

    HPROF_ASSERT(method!=NULL);
    frame_index = frame_find_or_create(method, -1);
    HPROF_ASSERT(frame_index != 0);
    
    info = get_info(index);
    
    HPROF_ASSERT(info!=NULL);
    HPROF_ASSERT(info->stack!=NULL);
    HPROF_ASSERT(frame_index!=0);
    current_time = method_time();
    info->stack = insure_method_on_stack(thread, info, current_time,
			frame_index, method);
    p = stack_top(info->stack);
    if (p == NULL) {
	HPROF_ERROR(JNI_FALSE, "expection pop, nothing on stack");
	return;
    }
    element = *(StackElement*)p;
    HPROF_ASSERT(element.frame_index!=0);
    while ( element.frame_index != frame_index ) {
	pop_method(index, current_time, element.method, frame_index);
	p = stack_top(info->stack);
	if ( p == NULL ) {
	    break;
	}
	element = *(StackElement*)p;
    }
    if (p == NULL) {
	HPROF_ERROR(JNI_FALSE, "exception pop stack empty");
    }
}

void
tls_pop_method(TlsIndex index, jthread thread, jmethodID method)
{
    TlsInfo      *info;
    StackElement  element;
    void         *p;
    FrameIndex    frame_index;
    jlong         current_time;
    
    HPROF_ASSERT(method!=NULL);
    frame_index = frame_find_or_create(method, -1);
    HPROF_ASSERT(frame_index != 0);
    
    info = get_info(index);
    HPROF_ASSERT(info!=NULL);
    HPROF_ASSERT(info->stack!=NULL);
    current_time = method_time();
    HPROF_ASSERT(frame_index!=0);
    info->stack = insure_method_on_stack(thread, info, current_time,
		frame_index, method);
    p = stack_top(info->stack);
    HPROF_ASSERT(p!=NULL);
    element = *(StackElement*)p;
    while ( element.frame_index != frame_index ) {
	pop_method(index, current_time, element.method, frame_index);
	p = stack_top(info->stack);
	if ( p == NULL ) {
	    break;
	}
	element = *(StackElement*)p;
    }
    pop_method(index, current_time, method, frame_index);
}

/* For all TLS entries, update the last_trace on all threads */
static void         
update_all_last_traces(JNIEnv *env)
{
    jthread        *threads;
    TlsInfo       **infos;
    SerialNumber   *serial_nums;
    TraceIndex     *traces;
   
    if ( gdata->max_trace_depth == 0 ) {
	return;
    }

    table_lock_enter(gdata->tls_table); {
        
	ThreadList      list;
	int             max_count;
	int             nbytes;
	int             i;
 
	/* Get buffers to hold thread list and serial number list */
	max_count   = table_element_count(gdata->tls_table);
	nbytes      = (int)sizeof(jthread)*max_count;
	threads     = (jthread*)HPROF_MALLOC(nbytes);
	nbytes      = (int)sizeof(SerialNumber)*max_count;
	serial_nums = (SerialNumber*)HPROF_MALLOC(nbytes);
	nbytes      = (int)sizeof(TlsInfo*)*max_count;
	infos       = (TlsInfo**)HPROF_MALLOC(nbytes);
	
	/* Get list of threads, serial numbers, and info pointers */
	list.threads     = threads;
	list.serial_nums = serial_nums;
	list.infos       = infos;
	list.count       = 0;
	list.env         = env;
        table_walk_items(gdata->tls_table, &get_thread_list, (void*)&list);

	/* Get all stack trace index's for all these threadss */
	nbytes      = (int)sizeof(TraceIndex)*max_count;
	traces      = (TraceIndex*)HPROF_MALLOC(nbytes);
	trace_get_all_current(list.count, threads, serial_nums, 
			      gdata->max_trace_depth, JNI_FALSE,
			      traces, JNI_TRUE);

	/* Loop over traces and update last_trace's */
	for ( i = 0 ; i < list.count ; i++ ) {
	    if ( threads[i] != NULL ) {
		deleteLocalReference(env, threads[i]);
	    }
	    infos[i]->last_trace = traces[i];
	}
	
    } table_lock_exit(gdata->tls_table);
	
    /* Free up all allocated space */
    HPROF_FREE(threads);
    HPROF_FREE(serial_nums);
    HPROF_FREE(infos);
    HPROF_FREE(traces);

}

void         
tls_dump_traces(JNIEnv *env)
{
    rawMonitorEnter(gdata->data_access_lock); {
	update_all_last_traces(env);
	trace_output_unmarked(env);
    } rawMonitorExit(gdata->data_access_lock);
}    
    
void
tls_dump_monitor_state(JNIEnv *env)
{
    HPROF_ASSERT(env!=NULL);
    
    rawMonitorEnter(gdata->data_access_lock); {
	tls_dump_traces(env);
	io_write_monitor_dump_header();
	table_walk_items(gdata->tls_table, &dump_thread_state, (void*)env);
	table_walk_items(gdata->tls_table, &dump_monitor_state, (void*)env);
	io_write_monitor_dump_footer();
    } rawMonitorExit(gdata->data_access_lock);
}

void         
tls_monitor_start_timer(TlsIndex index)
{
    TlsInfo *info;
    
    info = get_info(index);
    HPROF_ASSERT(info!=NULL);
    HPROF_ASSERT(info->globalref!=NULL);
    info->monitor_start_time = monitor_time();
}

jlong        
tls_monitor_stop_timer(TlsIndex index)
{
    TlsInfo *info;
    jlong    t;

    info = get_info(index);
    HPROF_ASSERT(info!=NULL);
    t =  monitor_time() - info->monitor_start_time;
    info->monitor_start_time = 0;
    return t;
}

TraceIndex   
tls_get_trace(TlsIndex index, JNIEnv *env, int depth, jboolean skip_init)
{
    SerialNumber thread_serial_num;
    TraceIndex   trace_index;
    TlsInfo     *info;
    jthread      thread;

    thread_serial_num = get_key(index);
    info              = get_info(index);
    HPROF_ASSERT(info!=NULL);
    setup_trace_buffers(info, depth);
    thread = newLocalReference(env, info->globalref);
    if ( thread != NULL ) {
        trace_index = get_trace(thread, thread_serial_num, depth, skip_init,
			info->frames_buffer, info->jframes_buffer);
	deleteLocalReference(env, thread);
    } else {
        trace_index = gdata->system_trace_index;
    }
    return trace_index;
}

void
tls_set_in_heap_dump(TlsIndex index, jint in_heap_dump)
{
    TlsInfo  *info;
    
    info = get_info(index);
    info->in_heap_dump = in_heap_dump;
}

jint
tls_get_in_heap_dump(TlsIndex index)
{
    TlsInfo  *info;
    
    info = get_info(index);
    return info->in_heap_dump;
}

static void
clean_in_heap_dump(TableIndex index, void *key_ptr, int key_len, void *info_ptr, void *arg)
{
    TlsInfo *info;
    
    HPROF_ASSERT(info_ptr!=NULL);
    info  = (TlsInfo*)info_ptr;
    info->in_heap_dump = 0;
}

void
tls_clear_in_heap_dump(void)
{
    table_walk_items(gdata->tls_table, &clean_in_heap_dump, NULL);
}

TlsIndex
tls_find(SerialNumber thread_serial_num)
{
    TlsIndex index;
   
    if ( thread_serial_num == 0 ) {
	return 0;
    }
    index = table_find_entry(gdata->tls_table, 
	  (void*)&thread_serial_num, (int)sizeof(SerialNumber));
    return index;
}