X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=src%2Fthreads%2Fthreadlist.hpp;h=76cd7c5538f5dcc58ad80db775337bdf53e078fb;hb=faf9ced36a84879b43e9b41783ba891cce356dd0;hp=2a9f2059c296ce538ca1e60be51fe0d01424ff15;hpb=cce34f898a508bde05c54be7f19c0fbfeb2dc0a2;p=cacao.git diff --git a/src/threads/threadlist.hpp b/src/threads/threadlist.hpp index 2a9f2059c..76cd7c553 100644 --- a/src/threads/threadlist.hpp +++ b/src/threads/threadlist.hpp @@ -1,6 +1,6 @@ /* src/threads/threadlist.hpp - different thread-lists - Copyright (C) 2008 + Copyright (C) 1996-2011 CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO This file is part of CACAO. @@ -34,26 +34,32 @@ #include "toolbox/list.hpp" +#include "vm/global.h" + /* ThreadList *****************************************************************/ #ifdef __cplusplus -using std::list; - class ThreadList { private: static Mutex _mutex; // a mutex for all thread lists - static list _active_thread_list; // list of active threads - static list _free_thread_list; // list of free threads - static list _free_index_list; // list of free thread indexes + static List _active_thread_list; // list of active threads + static List _free_thread_list; // list of free threads + static List _free_index_list; // list of free thread indexes + // Thread counters visible to Java. + static int32_t _number_of_started_java_threads; + static int32_t _number_of_active_java_threads; + static int32_t _peak_of_active_java_threads; + + // Thread counters for internal usage. static int32_t _number_of_non_daemon_threads; - static inline void remove_from_active_thread_list(threadobject* t); - static inline void add_to_free_thread_list(threadobject* t); - static inline void add_to_free_index_list(int32_t index); + static void remove_from_active_thread_list(threadobject* t); + static void add_to_free_thread_list(threadobject* t); + static void add_to_free_index_list(int32_t index); private: // Comparator class. @@ -66,46 +72,132 @@ private: }; public: - static inline void lock() { _mutex.lock(); } - static inline void unlock() { _mutex.unlock(); } + static void lock() { _mutex.lock(); } + static void unlock() { _mutex.unlock(); } - // TODO make private - static inline void add_to_active_thread_list(threadobject* t); + static void add_to_active_thread_list(threadobject* t); - static void dump_threads(); - static inline threadobject* get_main_thread(); + // Thread management methods. + static threadobject* get_main_thread(); static threadobject* get_free_thread(); static int32_t get_free_thread_index(); - static int32_t get_number_of_non_daemon_threads(); static threadobject* get_thread_by_index(int32_t index); static threadobject* get_thread_from_java_object(java_handle_t* h); - static void release_thread(threadobject* t); + static void release_thread(threadobject* t, bool needs_deactivate); + static void deactivate_thread(threadobject *t); + + // Thread listing methods. + static void get_active_threads(List &list); + static void get_active_java_threads(List &list); + + // Thread counting methods visible to Java. + static int32_t get_number_of_started_java_threads(); + static int32_t get_number_of_active_java_threads(); + static int32_t get_number_of_daemon_java_threads(); + static int32_t get_peak_of_active_java_threads(); + static void reset_peak_of_active_java_threads(); + + // Thread counting methods for internal use. + static int32_t get_number_of_active_threads(); + static int32_t get_number_of_non_daemon_threads(); + + // Debugging methods. + static void dump_threads(); +}; + +struct ThreadListLocker { + ThreadListLocker() { ThreadList::lock(); } + ~ThreadListLocker() { ThreadList::unlock(); } }; inline void ThreadList::add_to_active_thread_list(threadobject* t) { + lock(); _active_thread_list.push_back(t); + t->is_in_active_list = true; + + // Update counter variables. + if ((t->flags & THREAD_FLAG_INTERNAL) == 0) { + _number_of_started_java_threads++; + _number_of_active_java_threads++; + _peak_of_active_java_threads = MAX(_peak_of_active_java_threads, _number_of_active_java_threads); + } + unlock(); } inline void ThreadList::remove_from_active_thread_list(threadobject* t) { + lock(); _active_thread_list.remove(t); + t->is_in_active_list = false; + + // Update counter variables. + if ((t->flags & THREAD_FLAG_INTERNAL) == 0) { + _number_of_active_java_threads--; + } + unlock(); } inline void ThreadList::add_to_free_thread_list(threadobject* t) { + lock(); _free_thread_list.push_back(t); + unlock(); } inline void ThreadList::add_to_free_index_list(int32_t index) { + lock(); _free_index_list.push_back(index); + unlock(); } inline threadobject* ThreadList::get_main_thread() { - return _active_thread_list.front(); + lock(); + threadobject *r = _active_thread_list.front(); + unlock(); + return r; +} + +inline int32_t ThreadList::get_number_of_active_threads() +{ + lock(); + int32_t size = _active_thread_list.size(); + unlock(); + return size; +} + +inline int32_t ThreadList::get_number_of_started_java_threads() +{ + lock(); + int32_t num = _number_of_started_java_threads; + unlock(); + return num; +} + +inline int32_t ThreadList::get_number_of_active_java_threads() +{ + lock(); + int32_t num = _number_of_active_java_threads; + unlock(); + return num; +} + +inline int32_t ThreadList::get_peak_of_active_java_threads() +{ + lock(); + int32_t num = _peak_of_active_java_threads; + unlock(); + return num; +} + +inline void ThreadList::reset_peak_of_active_java_threads() +{ + lock(); + _peak_of_active_java_threads = _number_of_active_java_threads; + unlock(); } #else @@ -115,7 +207,6 @@ typedef struct ThreadList ThreadList; void ThreadList_lock(); void ThreadList_unlock(); void ThreadList_dump_threads(); -void ThreadList_release_thread(threadobject* t); threadobject* ThreadList_get_free_thread(); int32_t ThreadList_get_free_thread_index(); void ThreadList_add_to_active_thread_list(threadobject* t);