/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * @file * @brief Extended Treading and synchronization support * @details * Thread Manager native interface. Provides basic capablitites for managing native threads in the system. * *

*

Overview

* The Thread Manager (TM) component provides various threading functionality for VM and class libraries code. * provides support for threading inside the virtual machine and for class libraries. * The implementation of thread management uses the black-box approach exposing two interfaces: Java and native. * The whole component is divided into two layers: the middle layer of native threading with the layer of * Java threading on top. The implementation of Thread manager is based solely on the Apache Portable Runtime (APR) layer. *

* The top layer provides the following functionality (see jthread, thread_ti.h): *

* The middle layer does the following (see hythread.h, hythread_ext.h): * *

* *

Interaction

* The following components are primary customers of the Thread Manager: * * These components interact with different parts of thread management: some work with Java threads and objects, * while others interact with the middle layer of native threading. Whenever the component operates with Java * objects and threads, it would call the top (Java) interface functions. Otherwise, it would call the middle (native) * interface functions. *

Safe suspension

* One of the key features of thread management in the VM is the safe suspension functionality. * The purpose of the safe suspension mechanism is mostly to ensure that: * * At every time moment, thread can be in one of three possible states: * * Each thread managed by TM has the following fields: * * The suspension algorithm typically invokes two threads 226 223suspender224 thread and 223suspendee224 thread. * A typical example is than "suspender" is GC thread, and the "suspendee" is Java thread. * The safe thread suspension algorithm works as follows: * 
 *   1.  GC thread invokes thread_supend() method of a thread manager which does the following:
 *       a.  If  Java thread was already requested to suspend, increase the suspend_count count and return;
 *       b.  Increase suspend_count for Java thread;
 *       c.  If Java thread is currently in unsafe region, wait while it reaches the safe region.
 *   2.  GC thread, after completing the enumeration-related activities, calls the resume_thread() method which does the following:
 *       a.  If suspend_count was previously set, decrease the number of suspend requests;
 *       b.  If the number of suspend requests reaches zero, notifies the Java thread that it can wake up now.
 *   3.  A Java thread may reach safe point, which is denoted by calling the safe_point() method in the Java thread. 
 *       The safe_point() method does the following:
 *       a.  If there was request for suspension then: 
 *           i.  notify GC thread that it can proceed with enumeration activities
 *           ii. wait for the resume notification to come from the GC thread
 *   4.  A Java thread may enter the safe region, which is denoted by calling the suspend_enable() method in the Java thread. 
 *       The suspend_enable() method does the following:
 *       a.  Sets the flag safe_region to true;
 *       b.  If there was a request for suspension, notifies the GC thread that Java thread has reached safe region so GC may 
 *           proceed with enumeration activities
 *   5.  A Java thread may leave the safe region, which is denoted by calling the suspend_disable() method in the Java thread. 
 *       The suspend_disable() method does the following:
 *       a.  Sets the flag safe_region to false;
 *       b.  Calls the safe_point() method.
 *
* * For more detailes see thread manager component documentation located at vm/thread/doc/ThreadManager.htm * */ #if !defined(HYTHREAD_EXT_H) #define HYTHREAD_EXT_H #include "open/types.h" #include "open/hythread.h" #if defined(__cplusplus) extern "C" { #endif #include #include #include #include #include #include #include #include "port_barriers.h" //@{ /** * Opaque structures */ //@{ #if defined(LINUX) || defined(FREEBSD) #include #define osmutex_t pthread_mutex_t #define hycond_t pthread_cond_t #endif // LINUX || FREEBSD #ifdef _WIN32 #define osmutex_t CRITICAL_SECTION #define hycond_t struct HyCond #include "hycond_win.h" #endif // _WIN32 #if defined(__linux__) || defined(FREEBSD) #include #define osthread_t pthread_t #define thread_context_t ucontext_t #elif _WIN32 #define osthread_t HANDLE #define thread_context_t CONTEXT #else // !_WIN32 && !__linux__ #error "threading is only supported on __linux__ or _WIN32" #endif // !_WIN32 && !__linux__ #if !defined (_IPF_) //use lock reservation #define LOCK_RESERVATION #endif // !defined (_IPF_) typedef struct HyLatch *hylatch_t; typedef struct HyThread *hythread_iterator_t; typedef struct HyThreadLibraryInternal *hythread_library_t; typedef U_32 hythread_thin_monitor_t; typedef void (*hythread_event_callback_proc)(void); typedef int (HYTHREAD_PROC *hythread_wrapper_t)(void*); typedef struct hythread_start_proc_data * hythread_start_proc_data_t; /** * Native thread control structure. */ typedef struct HyThread { #ifndef POSIX // This is dummy pointer for Microsoft Visual Studio debugging // If this is removed, Visual Studio, when attached to VM, will show // no symbolic information void* reserved; #endif // Public fields exported by HyThread_public. If you change these fields, // please, check fields in hythread.h/HyThread_public /** * Number of requests made for this thread, it includes both * suspend requests and safe point callback requests. * The field is modified by atomic operations. * * Increment in functions: * 1. send_suspend_request() * - sets suspend request for a given thread * 2. hythread_set_safepoint_callback() * - sets safe point callback request for a given thread * * Decrement in functions: * 1. hythread_resume() * - removes suspend request for a given thread * 2. hythread_exception_safe_point() * - removes safe point callback request for current thread */ U_32 request; /** * Field indicating that thread can safely be suspended. * Safe suspension is enabled on value 0. * * The disable_count is increased/decreaded in * hythread_suspend_disable()/hythread_suspend_enable() function * for current thread only. * * Also disable_count could be reset to value 0 and restored in * hythread_set_suspend_disable()/hythread_set_suspend_disable() function * for current thread only. * * Function hythread_exception_safe_point() sets disable_count to * value 1 before safe point callback function calling and restores * it after the call. * * Function thread_safe_point_impl() sets disable_count to * value 0 before entering to the safe point and restores it * after exitting. */ int16 disable_count; /** * Group for this thread. Different groups are needed in order * to be able to quickly iterate over the specific group. * Examples are: Java threads, GC private threads. * Equal to the address of the head of the list of threads for this group. */ hythread_group_t group; /** * Array representing thread local storage */ void *thread_local_storage[10]; // Private fields /** * Each thread keeps a pointer to the library it belongs to. */ hythread_library_t library; // Suspension /** * Number of suspend requests made for this thread. * The field is modified by atomic operations. * * After increment/decrement of suspend_count, request field * should be incremented/decremented too. */ U_32 suspend_count; /** * Function to be executed at safepoint upon thread resume. * * Field is set in hythread_set_safepoint_callback() function * and reset hythread_exception_safe_point() function. * * After set/reset of safepoint_callback, request field * should be incremented/decremented too. */ hythread_event_callback_proc safepoint_callback; /** * Event used to notify suspended thread that it needs to wake up. */ hysem_t resume_event; // Basic manipulation fields /** * Points to the next thread within the group. */ hythread_t next; /** * Points to the last thread within the group. */ hythread_t prev; /** * Handle to OS thread. */ osthread_t os_handle; // Synchronization stuff /** * Thread local lock, used to serialize thread state; */ osmutex_t mutex; /** * Monitor used to implement wait function for sleep/park; */ hythread_monitor_t monitor; /** * Current conditional variable thread is waiting on (used for interrupting) */ hycond_t *current_condition; // State /** * Thread state. Holds thread state flags as defined in JVMTI specification, plus some additional * flags. See * JVMTI Specification for more details. */ IDATA state; // Attributes /** * Hint for scheduler about thread priority */ int priority; /** * Flag illustrates that java thread status */ char java_status; /** * Release indicator */ char need_to_free; /** * Flag of interruption */ U_32 interrupted; // Monitors /** * Monitor this thread is waiting on now. */ hythread_monitor_t waited_monitor; /** * ID for this thread. The maximum number of threads is governed by the size of lockword record. */ IDATA thread_id; } HyThread; /** * Start procedure data structure. */ typedef struct hythread_start_proc_data { /** * A new thread */ hythread_t thread; /** * Thread group of a new thread */ hythread_group_t group; /** * Thread start procedure */ hythread_entrypoint_t proc; /** * Start procedure arguments */ void *proc_args; } hythread_start_proc_data; typedef struct tm_props { int use_soft_unreservation; } tm_props; extern VMIMPORT tm_props *tm_properties; //@} /** @name Thread Manager initialization / shutdown */ //@{ //temporary, should be static for the file containing dinamic library //initialization //// IDATA VMCALL hythread_global_lock(); IDATA VMCALL hythread_global_unlock(); void VMCALL hythread_init(hythread_library_t lib); void VMCALL hythread_shutdown(); void VMCALL hythread_shutdowning(); int VMCALL hythread_lib_state(); IDATA VMCALL hythread_lib_create(hythread_library_t * lib); void VMCALL hythread_lib_destroy(hythread_library_t lib); hythread_group_t VMCALL get_java_thread_group(void); //@} /** @name Basic manipulation */ //@{ IDATA VMCALL hythread_create_ex(hythread_t new_thread, hythread_group_t group, UDATA stacksize, UDATA priority, hythread_wrapper_t wrapper, hythread_entrypoint_t func, void *data); IDATA VMCALL hythread_attach_ex(hythread_t new_handle, hythread_library_t lib, hythread_group_t group); void VMCALL hythread_detach_ex(hythread_t thread); IDATA VMCALL hythread_set_to_group(hythread_t thread, hythread_group_t group); IDATA VMCALL hythread_remove_from_group(hythread_t thread); void VMCALL hythread_set_self(hythread_t thread); UDATA VMCALL hythread_clear_interrupted_other(hythread_t thread); void VMCALL hythread_yield_other(hythread_t thread); IDATA VMCALL hythread_get_self_id(); IDATA VMCALL hythread_get_id(hythread_t t); hythread_t VMCALL hythread_get_thread(IDATA id); IDATA VMCALL hythread_struct_init(hythread_t new_thread); IDATA VMCALL hythread_struct_release(hythread_t thread); IDATA VMCALL hythread_cancel_all(hythread_group_t group); IDATA hythread_group_create(hythread_group_t *group); IDATA VMCALL hythread_group_release(hythread_group_t group); IDATA VMCALL hythread_group_get_list(hythread_group_t **list, int* size); UDATA VMCALL hythread_tls_get_offset(hythread_tls_key_t key); UDATA VMCALL hythread_tls_get_request_offset(); UDATA VMCALL hythread_get_thread_times(hythread_t thread, int64* pkernel, int64* puser); UDATA VMCALL hythread_uses_fast_tls(void); IDATA VMCALL hythread_get_hythread_offset_in_tls(void); IDATA VMCALL hythread_get_struct_size(); IDATA VMCALL hythread_thread_lock(hythread_t thread); IDATA VMCALL hythread_thread_unlock(hythread_t thread); IDATA VMCALL hythread_get_state(hythread_t thread); IDATA VMCALL hythread_set_state(hythread_t thread, IDATA state); int VMCALL hythread_reset_suspend_disable(); void VMCALL hythread_set_suspend_disable(int count); int VMCALL hythread_is_fat_lock(hythread_thin_monitor_t lockword); hythread_monitor_t VMCALL hythread_inflate_lock(hythread_thin_monitor_t *lockword_ptr); IDATA VMCALL hythread_owns_thin_lock(hythread_t thread, hythread_thin_monitor_t lockword); IDATA VMCALL hythread_unreserve_lock(hythread_thin_monitor_t *lockword_ptr); IDATA VMCALL hythread_get_thread_id_offset(); IDATA VMCALL hythread_set_thread_stop_callback(hythread_t thread, hythread_event_callback_proc stop_callback); IDATA VMCALL hythread_wait_for_nondaemon_threads(hythread_t thread, IDATA threads_to_keep); IDATA VMCALL hythread_increase_nondaemon_threads_count(hythread_t thread); IDATA VMCALL hythread_decrease_nondaemon_threads_count(hythread_t thread, IDATA threads_to_keep); //@} /** @name Conditional variable */ //@{ IDATA VMCALL hycond_create (hycond_t *cond); IDATA VMCALL hycond_wait (hycond_t *cond, osmutex_t *mutex); IDATA VMCALL hycond_wait_timed (hycond_t *cond, osmutex_t *mutex, I_64 millis, IDATA nanos); IDATA VMCALL hycond_wait_timed_raw(hycond_t * cond, osmutex_t * mutex, I_64 ms, IDATA nano); IDATA VMCALL hycond_wait_interruptable (hycond_t *cond, osmutex_t *mutex, I_64 millis, IDATA nanos); IDATA VMCALL hycond_notify (hycond_t *cond); IDATA VMCALL hycond_notify_all (hycond_t *cond); IDATA VMCALL hycond_destroy (hycond_t *cond); //@} /** @name Safe suspension support */ //@{ hy_inline IDATA VMCALL hythread_is_suspend_enabled(); hy_inline void VMCALL hythread_suspend_enable(); hy_inline void VMCALL hythread_suspend_disable(); void hythread_safe_point(); void hythread_safe_point_other(hythread_t thread); void VMCALL hythread_exception_safe_point(); void VMCALL hythread_send_suspend_request(hythread_t thread); IDATA VMCALL hythread_suspend_other(hythread_t thread); IDATA VMCALL hythread_set_safepoint_callback(hythread_t thread, hythread_event_callback_proc callback); IDATA VMCALL hythread_suspend_all(hythread_iterator_t *t, hythread_group_t group); IDATA VMCALL hythread_resume_all(hythread_group_t group); //@} /** @name Latch */ //@{ IDATA VMCALL hylatch_create(hylatch_t *latch, IDATA count); IDATA VMCALL hylatch_wait(hylatch_t latch); IDATA VMCALL hylatch_wait_timed(hylatch_t latch, I_64 ms, IDATA nano); IDATA VMCALL hylatch_wait_interruptable(hylatch_t latch, I_64 ms, IDATA nano); IDATA VMCALL hylatch_set(hylatch_t latch, IDATA count); IDATA VMCALL hylatch_count_down(hylatch_t latch); IDATA VMCALL hylatch_get_count(IDATA *count, hylatch_t latch); IDATA VMCALL hylatch_destroy(hylatch_t latch); //@} /** @name Thread iterator support */ //@{ hythread_iterator_t VMCALL hythread_iterator_create(hythread_group_t group); IDATA VMCALL hythread_iterator_release(hythread_iterator_t *it); IDATA VMCALL hythread_iterator_reset(hythread_iterator_t *it); hythread_t VMCALL hythread_iterator_next(hythread_iterator_t *it); IDATA VMCALL hythread_iterator_has_next(hythread_iterator_t it); IDATA VMCALL hythread_iterator_size(hythread_iterator_t iterator); //@} /** @name Semaphore */ //@{ IDATA hysem_create(hysem_t *sem, UDATA initial_count, UDATA max_count); IDATA VMCALL hysem_wait_timed(hysem_t sem, I_64 ms, IDATA nano); IDATA VMCALL hysem_wait_interruptable(hysem_t sem, I_64 ms, IDATA nano); IDATA VMCALL hysem_getvalue(IDATA *count, hysem_t sem); IDATA hysem_set(hysem_t sem, IDATA count); //@} /** @name Thin monitors support */ //@{ IDATA VMCALL hythread_thin_monitor_create(hythread_thin_monitor_t *lockword); IDATA VMCALL hythread_thin_monitor_enter(hythread_thin_monitor_t *lockword); IDATA VMCALL hythread_thin_monitor_try_enter(hythread_thin_monitor_t *lockword); IDATA VMCALL hythread_thin_monitor_exit(hythread_thin_monitor_t *lockword); IDATA VMCALL hythread_thin_monitor_release(hythread_thin_monitor_t *lockword); IDATA VMCALL hythread_thin_monitor_wait(hythread_thin_monitor_t *lockword); IDATA VMCALL hythread_thin_monitor_wait_timed(hythread_thin_monitor_t *lockword_ptr, I_64 ms, IDATA nano); IDATA VMCALL hythread_thin_monitor_wait_interruptable(hythread_thin_monitor_t *lockword_ptr, I_64 ms, IDATA nano); IDATA VMCALL hythread_thin_monitor_notify(hythread_thin_monitor_t *lockword); IDATA VMCALL hythread_thin_monitor_notify_all(hythread_thin_monitor_t *lockword); IDATA VMCALL hythread_thin_monitor_destroy(hythread_thin_monitor_t *lockword); hythread_t VMCALL hythread_thin_monitor_get_owner(hythread_thin_monitor_t *lockword); IDATA VMCALL hythread_thin_monitor_get_recursion(hythread_thin_monitor_t *lockword); void VMCALL hythread_native_resource_is_live(U_32); void VMCALL hythread_reclaim_resources(); //@} /** @name State query */ //@{ int VMCALL hythread_is_alive(hythread_t thread) ; int VMCALL hythread_is_terminated(hythread_t thread) ; int VMCALL hythread_is_runnable(hythread_t thread) ; int VMCALL hythread_is_blocked_on_monitor_enter(hythread_t thread) ; int VMCALL hythread_is_waiting(hythread_t thread) ; int VMCALL hythread_is_waiting_indefinitely(hythread_t thread) ; int VMCALL hythread_is_waiting_with_timeout(hythread_t thread) ; int VMCALL hythread_is_sleeping(hythread_t thread) ; int VMCALL hythread_is_in_monitor_wait(hythread_t thread) ; int VMCALL hythread_is_parked(hythread_t thread) ; int VMCALL hythread_is_suspended(hythread_t thread) ; int VMCALL hythread_is_interrupted(hythread_t thread) ; int VMCALL hythread_is_in_native(hythread_t thread) ; int VMCALL hythread_is_daemon(hythread_t thread) ; // inline functions declarations /** * Returns non-zero if thread is suspended. */ hy_inline IDATA VMCALL hythread_is_suspend_enabled(){ return ((HyThread_public *)tm_self_tls)->disable_count == 0; } /** * Denotes the beginning of the code region where safe suspension is possible. * * The method decreases the disable_count field. The disable_count could be * recursive, so safe suspension region is enabled on value 0. * *

* A thread marks itself with functions hythread_suspend_enable() * and hythread_suspend_disable() in order to denote a safe region of code. * A thread may also call hythread_safe_point() method to denote a selected * point where safe suspension is possible. */ hy_inline void VMCALL hythread_suspend_enable() { register hythread_t thread; assert(!hythread_is_suspend_enabled()); thread = tm_self_tls; ((HyThread_public *)thread)->disable_count--; } /** * Denotes the end of the code region where safe suspension was possible. * * The method increases the disable_count field. The disable_count could be * recursive, so safe suspension region is enabled on value 0. * If there was a suspension request set for this thread, the method invokes * hythread_safe_point(). *

* A thread marks itself with functions hythread_suspend_enable() * and hythread_suspend_disable() in order to denote a safe region of code. * A thread may also call hythread_safe_point() method to denote a selected * point where safe suspension is possible. */ hy_inline void VMCALL hythread_suspend_disable() { register hythread_t thread; // Check that current thread is in default thread group. // Justification: GC suspends and enumerates threads from // default group only. assert(((HyThread_public *)hythread_self())->group == get_java_thread_group()); thread = tm_self_tls; ((HyThread_public *)thread)->disable_count++; //port_rw_barrier(); if (((HyThread_public *)thread)->request && ((HyThread_public *)thread)->disable_count == 1) { // enter to safe point if suspend request was set // and suspend disable was made a moment ago // (it's a point of entry to the unsafe region) hythread_safe_point_other(thread); } return; } #define TM_THREAD_QUANTITY_OF_PREDEFINED_TLS_KEYS 1 //@} /** * TM Thread states constants. They are compatible with JVMTI. */ //@{ // 0x00000000 Thread is new. #define TM_THREAD_STATE_NEW 0 // 0x00000001 Thread is alive. Zero if thread is new (not started) or terminated. #define TM_THREAD_STATE_ALIVE JVMTI_THREAD_STATE_ALIVE // 0x00000002 Thread has completed execution. #define TM_THREAD_STATE_TERMINATED JVMTI_THREAD_STATE_TERMINATED // 0x00000004 Thread is runnable. #define TM_THREAD_STATE_WAITING JVMTI_THREAD_STATE_WAITING // 0x00000010 Thread is waiting without a timeout. For example, Object.wait(). #define TM_THREAD_STATE_WAITING_INDEFINITELY JVMTI_THREAD_STATE_WAITING_INDEFINITELY // 0x00000020 Thread is waiting with a maximum time to wait specified. // For example, Object.wait(long). #define TM_THREAD_STATE_WAITING_WITH_TIMEOUT JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT // 0x00000040 Thread is sleeping. For example, Thread.sleep(long). #define TM_THREAD_STATE_RUNNABLE JVMTI_THREAD_STATE_RUNNABLE // 0x00000080 Thread is waiting. #define TM_THREAD_STATE_SLEEPING JVMTI_THREAD_STATE_SLEEPING // 0x00000100 Thread is waiting on an object monitor -- Object.wait. #define TM_THREAD_STATE_IN_MONITOR_WAIT JVMTI_THREAD_STATE_IN_OBJECT_WAIT // 0x00000200 Thread is parked. // For example: LockSupport.park, LockSupport.parkUtil and LockSupport.parkNanos. #define TM_THREAD_STATE_PARKED JVMTI_THREAD_STATE_PARKED // 0x00000400 Thread is waiting to enter a synchronization block/method or, // after an Object.wait(), waiting to re-enter a synchronization block/method. #define TM_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER // 0x00000800 Thread is unparked, to track staled unparks #define TM_THREAD_STATE_UNPARKED 0x0800 // 0x00100000 Thread suspended. // For example, java.lang.Thread.suspend() // or a JVMTI suspend function (such as SuspendThread) // has been called on the thread. If this bit is set, // the other bits refer to the thread state before suspension. #define TM_THREAD_STATE_SUSPENDED JVMTI_THREAD_STATE_SUSPENDED // 0x00200000 Thread has been interrupted. #define TM_THREAD_STATE_INTERRUPTED JVMTI_THREAD_STATE_INTERRUPTED // 0x00400000 Thread is in native code. That is a native method is running which // has not called back into the VM or Java programming language code. #define TM_THREAD_STATE_IN_NATIVE JVMTI_THREAD_STATE_IN_NATIVE #define WAIT_INTERRUPTABLE 1 #define WAIT_NONINTERRUPTABLE 0 /** * TM functions error codes (they are mostly coming from APR). */ #define TM_ERROR_NONE (0) // No error has occurred. This is the error code that is returned on successful completion of the function. #define TM_ERROR_INVALID_MONITOR (50) // Monitor pointer provided to the function id invalid #define TM_ERROR_NOT_MONITOR_OWNER (51) // Thread is not owner of the monitor #define TM_ERROR_INTERRUPT (52) // The call has been interrupted before completion. #define TM_ERROR_NULL_POINTER (100) // Pointer is unexpectedly NULL. #define TM_ERROR_OUT_OF_MEMORY (110) // The function attempted to allocate memory and no more memory was available for allocation. #define TM_ERROR_ACCESS_DENIED (111) // The desired functionality has not been enabled in this virtual machine. #define TM_ERROR_WRONG_PHASE (112) // The desired functionality is not available in the current phase. Always returned if the virtual machine has completed running. #define TM_ERROR_INTERNAL (113) // An unexpected internal error has occurred. #define TM_ERROR_UNATTACHED_THREAD (115) // The thread being used to call this function is not attached to the virtual machine. Calls must be made from attached threads. See AttachCurrentThread in the JNI invocation API. #define TM_ERROR_INVALID_ENVIRONMENT (116) // The JVMTI environment provided is no longer connected or is not an environment. #define TM_ERROR_MAX_THREADS (117) //Max number of threads exceeded #define TM_ERROR_ILLEGAL_STATE (51) //incorrect syncronizer state For example monitor wait without lock. #define TM_ERROR_RUNNING_THREADS (119) //error relesing group/destroying library if there are running threads #define TM_ERROR_EBUSY APR_EBUSY // returned by try_lock #define TM_ERROR_TIMEOUT APR_TIMEUP // returned by try_lock #define TM_ERROR_START 1000 // possible values for tm_status_t #define TM_OS_ERROR (TM_ERROR_START+1) // if default stack size is not through -Xss parameter, it is 512kb #ifndef POINTER64 #define TM_DEFAULT_STACKSIZE (512 * 1024) #else // Make stack size default to 2Mb on 64-bit platforms #define TM_DEFAULT_STACKSIZE (2048 * 1024) #endif // java thread status #define TM_STATUS_WITHOUT_JAVA 0 // native thread cannot has associated java thread #define TM_STATUS_ALLOCATED 1 // associated java thread is allocated #define TM_STATUS_INITIALIZED 2 // associated java thread is initialized #define TM_LIBRARY_STATUS_NOT_INITIALIZED 0 #define TM_LIBRARY_STATUS_INITIALIZED 1 #define TM_LIBRARY_STATUS_SHUTDOWN 2 #if defined(__cplusplus) } #endif #endif /* HYTHREAD_EXT_H */