* configure.ac: Bump version, append hg revision.

[cacao.git] / src / threads / threadlist.cpp

diff --git a/src/threads/threadlist.cpp b/src/threads/threadlist.cpp
index 546aa06822984303e1e701368dacb5674bfa61e7..ce055a083e15ff9f2dddd9b19a89472cdd1aff60 100644 (file)
--- a/src/threads/threadlist.cpp
+++ b/src/threads/threadlist.cpp
@@ -1,6 +1,6 @@
 /* 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.
@@ -47,6 +47,9 @@ 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;
 
 
@@ -56,13 +59,15 @@ 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;
 
@@ -70,13 +75,10 @@ void ThreadList::dump_threads()
                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. */
 
@@ -88,12 +90,10 @@ void ThreadList::dump_threads()
 
                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.
@@ -121,6 +121,34 @@ void ThreadList::get_active_threads(List<threadobject*> &list)
 }
 
 
+/**
+ * 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.
  *
@@ -165,6 +193,40 @@ int32_t ThreadList::get_free_thread_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.
  *