/* src/threads/threadlist.cpp - thread list
- Copyright (C) 2008
+ Copyright (C) 2008, 2009
CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
This file is part of CACAO.
Mutex ThreadList::_mutex; // a mutex for all thread lists
-list<threadobject*> ThreadList::_active_thread_list; // list of active threads
-list<threadobject*> ThreadList::_free_thread_list; // list of free threads
-list<int32_t> ThreadList::_free_index_list; // list of free thread indexes
+List<threadobject*> ThreadList::_active_thread_list; // list of active threads
+List<threadobject*> ThreadList::_free_thread_list; // list of free threads
+List<int32_t> ThreadList::_free_index_list; // list of free thread indexes
+int32_t ThreadList::_number_of_started_java_threads;
+int32_t ThreadList::_number_of_active_java_threads;
+int32_t ThreadList::_peak_of_active_java_threads;
int32_t ThreadList::_number_of_non_daemon_threads;
*/
void ThreadList::dump_threads()
{
- // XXX we should stop the world here
+ // XXX we should stop the world here and remove explicit
+ // thread suspension from the loop below.
// Lock the thread lists.
lock();
- printf("Full thread dump CACAO "VERSION":\n");
+ printf("Full thread dump CACAO "VERSION_FULL":\n");
// Iterate over all started threads.
+ threadobject* self = THREADOBJECT;
for (List<threadobject*>::iterator it = _active_thread_list.begin(); it != _active_thread_list.end(); it++) {
threadobject* t = *it;
if (t->state == THREAD_STATE_NEW)
continue;
-#if defined(ENABLE_GC_CACAO)
- /* Suspend the thread. */
- /* XXX Is the suspend reason correct? */
+ /* Suspend the thread (and ignore return value). */
- if (threads_suspend_thread(t, SUSPEND_REASON_JNI) == false)
- vm_abort("threads_dump: threads_suspend_thread failed");
-#endif
+ if (t != self)
+ (void) threads_suspend_thread(t, SUSPEND_REASON_DUMP);
/* Print thread info. */
stacktrace_print_of_thread(t);
-#if defined(ENABLE_GC_CACAO)
- /* Resume the thread. */
+ /* Resume the thread (and ignore return value). */
- if (threads_resume_thread(t) == false)
- vm_abort("threads_dump: threads_resume_thread failed");
-#endif
+ if (t != self)
+ (void) threads_resume_thread(t, SUSPEND_REASON_DUMP);
}
// Unlock the thread lists.
*
* @param list list class to be filled
*/
-void ThreadList::get_active_threads(list<threadobject*> &list)
+void ThreadList::get_active_threads(List<threadobject*> &list)
{
// Lock the thread lists.
lock();
}
+/**
+ * Fills the passed list with all currently active threads which should be
+ * visible to Java. Creating a copy of the thread list here, is the only way
+ * to ensure we do not end up in a dead-lock when iterating over the list.
+ *
+ * @param list list class to be filled
+ */
+void ThreadList::get_active_java_threads(List<threadobject*> &list)
+{
+ // Lock the thread lists.
+ lock();
+
+ // Iterate over all active threads.
+ for (List<threadobject*>::iterator it = _active_thread_list.begin(); it != _active_thread_list.end(); it++) {
+ threadobject* t = *it;
+
+ // We skip internal threads.
+ if (t->flags & THREAD_FLAG_INTERNAL)
+ continue;
+
+ list.push_back(t);
+ }
+
+ // Unlock the thread lists.
+ unlock();
+}
+
+
/**
* Return a free thread object.
*
{
threadobject* t = NULL;
+ lock();
+
// Do we have free threads in the free-list?
if (_free_thread_list.empty() == false) {
// Yes, get the index and remove it from the free list.
- threadobject* t = _free_thread_list.front();
+ t = _free_thread_list.front();
_free_thread_list.remove(t);
}
+ unlock();
+
return t;
}
{
int32_t index;
+ lock();
+
// Do we have free indexes in the free-list?
if (_free_index_list.empty() == false) {
// Yes, get the index and remove it from the free list.
index = _active_thread_list.size() + 1;
}
+ unlock();
+
return index;
}
+/**
+ * Return the number of daemon threads visible to Java.
+ *
+ * NOTE: This function does a linear-search over the threads list,
+ * because it is only used by the management interface.
+ *
+ * @return number of daemon threads
+ */
+int32_t ThreadList::get_number_of_daemon_java_threads(void)
+{
+ int number = 0;
+
+ // Lock the thread lists.
+ lock();
+
+ // Iterate over all active threads.
+ for (List<threadobject*>::iterator it = _active_thread_list.begin(); it != _active_thread_list.end(); it++) {
+ threadobject* t = *it;
+
+ // We skip internal threads.
+ if (t->flags & THREAD_FLAG_INTERNAL)
+ continue;
+
+ if (thread_is_daemon(t))
+ number++;
+ }
+
+ // Unlock the thread lists.
+ unlock();
+
+ return number;
+}
+
+
/**
* Return the number of non-daemon threads.
*
return NULL;
}
+void ThreadList::deactivate_thread(threadobject *t)
+{
+ ThreadListLocker lock;
+ remove_from_active_thread_list(t);
+ threads_impl_clear_heap_pointers(t); // allow it to be garbage collected
+}
/**
* Release the thread.
*
* @return free thread index
*/
-void ThreadList::release_thread(threadobject* t)
+void ThreadList::release_thread(threadobject* t, bool needs_deactivate)
{
lock();
- // Move thread from active thread list to free thread list.
- remove_from_active_thread_list(t);
+ if (needs_deactivate)
+ // Move thread from active thread list to free thread list.
+ remove_from_active_thread_list(t);
+ else
+ assert(!t->is_in_active_list);
+
add_to_free_thread_list(t);
// Add thread index to free index list.
void ThreadList_lock() { ThreadList::lock(); }
void ThreadList_unlock() { ThreadList::unlock(); }
void ThreadList_dump_threads() { ThreadList::dump_threads(); }
- void ThreadList_release_thread(threadobject* t) { ThreadList::release_thread(t); }
threadobject* ThreadList_get_free_thread() { return ThreadList::get_free_thread(); }
int32_t ThreadList_get_free_thread_index() { return ThreadList::get_free_thread_index(); }
void ThreadList_add_to_active_thread_list(threadobject* t) { ThreadList::add_to_active_thread_list(t); }
projects / cacao.git / blobdiff