src/threads/threadlist.cpp

   1 /* src/threads/threadlist.cpp - thread list
   2
   3    Copyright (C) 2008
   4    CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
   5
   6    This file is part of CACAO.
   7
   8    This program is free software; you can redistribute it and/or
   9    modify it under the terms of the GNU General Public License as
  10    published by the Free Software Foundation; either version 2, or (at
  11    your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23 */
  24
  25
  26 #include "config.h"
  27
  28 #include <stdint.h>
  29
  30 #include <algorithm>
  31
  32 #include "threads/mutex.hpp"
  33 #include "threads/threadlist.hpp"
  34 #include "threads/thread.hpp"
  35
  36 #include "toolbox/list.hpp"
  37 #include "toolbox/logging.h"
  38
  39 #include "vm/jit/stacktrace.hpp"
  40
  41
  42 /* class variables */
  43
  44 Mutex               ThreadList::_mutex;                // a mutex for all thread lists
  45
  46 list<threadobject*> ThreadList::_active_thread_list;   // list of active threads
  47 list<threadobject*> ThreadList::_free_thread_list;     // list of free threads
  48 list<int32_t>       ThreadList::_free_index_list;      // list of free thread indexes
  49
  50 int32_t             ThreadList::_number_of_non_daemon_threads;
  51
  52
  53 /**
  54  * Dumps info for all threads running in the VM.  This function is
  55  * called when SIGQUIT (<ctrl>-\) is sent to the VM.
  56  */
  57 void ThreadList::dump_threads()
  58 {
  59         // XXX we should stop the world here
  60         // Lock the thread lists.
  61         lock();
  62
  63         printf("Full thread dump CACAO "VERSION":\n");
  64
  65         // Iterate over all started threads.
  66         for (List<threadobject*>::iterator it = _active_thread_list.begin(); it != _active_thread_list.end(); it++) {
  67                 threadobject* t = *it;
  68
  69                 // Ignore threads which are in state NEW.
  70                 if (t->state == THREAD_STATE_NEW)
  71                         continue;
  72
  73 #if defined(ENABLE_GC_CACAO)
  74                 /* Suspend the thread. */
  75                 /* XXX Is the suspend reason correct? */
  76
  77                 if (threads_suspend_thread(t, SUSPEND_REASON_JNI) == false)
  78                         vm_abort("threads_dump: threads_suspend_thread failed");
  79 #endif
  80
  81                 /* Print thread info. */
  82
  83                 printf("\n");
  84                 thread_print_info(t);
  85                 printf("\n");
  86
  87                 /* Print trace of thread. */
  88
  89                 stacktrace_print_of_thread(t);
  90
  91 #if defined(ENABLE_GC_CACAO)
  92                 /* Resume the thread. */
  93
  94                 if (threads_resume_thread(t) == false)
  95                         vm_abort("threads_dump: threads_resume_thread failed");
  96 #endif
  97         }
  98
  99         // Unlock the thread lists.
 100         unlock();
 101 }
 102
 103
 104 /**
 105  * Return a free thread object.
 106  *
 107  * @return free thread object or NULL if none available
 108  */
 109 threadobject* ThreadList::get_free_thread()
 110 {
 111         threadobject* t = NULL;
 112
 113         // Do we have free threads in the free-list?
 114         if (_free_thread_list.empty() == false) {
 115                 // Yes, get the index and remove it from the free list.
 116                 threadobject* t = _free_thread_list.front();
 117                 _free_thread_list.remove(t);
 118         }
 119
 120         return t;
 121 }
 122
 123
 124 /**
 125  * Return a free thread index.
 126  *
 127  * @return free thread index
 128  */
 129 int32_t ThreadList::get_free_thread_index()
 130 {
 131         int32_t index;
 132
 133         // Do we have free indexes in the free-list?
 134         if (_free_index_list.empty() == false) {
 135                 // Yes, get the index and remove it from the free list.
 136                 index = _free_index_list.front();
 137                 _free_index_list.remove(index);
 138         }
 139         else {
 140                 // Get a new the thread index.
 141                 index = _active_thread_list.size() + 1;
 142         }
 143
 144         return index;
 145 }
 146
 147
 148 /**
 149  * Return the number of non-daemon threads.
 150  *
 151  * NOTE: This function does a linear-search over the threads list,
 152  *       because it is only used for joining the threads.
 153  *
 154  * @return number of non daemon threads
 155  */
 156 int32_t ThreadList::get_number_of_non_daemon_threads(void)
 157 {
 158         int nondaemons = 0;
 159
 160         lock();
 161
 162         for (List<threadobject*>::iterator it = _active_thread_list.begin(); it != _active_thread_list.end(); it++) {
 163                 threadobject* t = *it;
 164
 165                 if (!thread_is_daemon(t))
 166                         nondaemons++;
 167         }
 168
 169         unlock();
 170
 171         return nondaemons;
 172 }
 173
 174
 175 /**
 176  * Return the thread object with the given index.
 177  *
 178  * @return thread object
 179  */
 180 threadobject* ThreadList::get_thread_by_index(int32_t index)
 181 {
 182         lock();
 183
 184         List<threadobject*>::iterator it = find_if(_active_thread_list.begin(), _active_thread_list.end(), std::bind2nd(comparator(), index));
 185
 186         // No thread found.
 187         if (it == _active_thread_list.end()) {
 188                 unlock();
 189                 return NULL;
 190         }
 191
 192         threadobject* t = *it;
 193
 194         // The thread found is in state new.
 195         if (t->state == THREAD_STATE_NEW) {
 196                 unlock();
 197                 return NULL;
 198         }
 199
 200         unlock();
 201         return t;
 202 }
 203
 204
 205 /**
 206  * Return the Java thread object from the given thread object.
 207  *
 208  * @return Java thread object
 209  */
 210 threadobject* ThreadList::get_thread_from_java_object(java_handle_t* h)
 211 {
 212         List<threadobject*>::iterator it;
 213         threadobject* t;
 214         bool          equal;
 215
 216         lock();
 217
 218         for (it = _active_thread_list.begin(); it != _active_thread_list.end(); it++) {
 219                 t = *it;
 220
 221                 LLNI_equals(t->object, h, equal);
 222
 223                 if (equal == true) {
 224                         unlock();
 225                         return t;
 226                 }
 227         }
 228
 229         unlock();
 230
 231         return NULL;
 232 }
 233
 234
 235 /**
 236  * Release the thread.
 237  *
 238  * @return free thread index
 239  */
 240 void ThreadList::release_thread(threadobject* t)
 241 {
 242         lock();
 243
 244         // Move thread from active thread list to free thread list.
 245         remove_from_active_thread_list(t);
 246         add_to_free_thread_list(t);
 247
 248         // Add thread index to free index list.
 249         add_to_free_index_list(t->index);
 250
 251         unlock();
 252 }
 253
 254
 255 /* C interface functions ******************************************************/
 256
 257 extern "C" {
 258         void ThreadList_lock() { ThreadList::lock(); }
 259         void ThreadList_unlock() { ThreadList::unlock(); }
 260         void ThreadList_dump_threads() { ThreadList::dump_threads(); }
 261         void ThreadList_release_thread(threadobject* t) { ThreadList::release_thread(t); }
 262         threadobject* ThreadList_get_free_thread() { return ThreadList::get_free_thread(); }
 263         int32_t ThreadList_get_free_thread_index() { return ThreadList::get_free_thread_index(); }
 264         void ThreadList_add_to_active_thread_list(threadobject* t) { ThreadList::add_to_active_thread_list(t); }
 265         threadobject* ThreadList_get_thread_by_index(int32_t index) { return ThreadList::get_thread_by_index(index); }
 266         threadobject* ThreadList_get_main_thread() { return ThreadList::get_main_thread(); }
 267         threadobject* ThreadList_get_thread_from_java_object(java_handle_t* h) { return ThreadList::get_thread_from_java_object(h); }
 268
 269         int32_t ThreadList_get_number_of_non_daemon_threads() { return ThreadList::get_number_of_non_daemon_threads(); }
 270 }
 271
 272 /*
 273  * These are local overrides for various environment variables in Emacs.
 274  * Please do not remove this and leave it at the end of the file, where
 275  * Emacs will automagically detect them.
 276  * ---------------------------------------------------------------------
 277  * Local variables:
 278  * mode: c++
 279  * indent-tabs-mode: t
 280  * c-basic-offset: 4
 281  * tab-width: 4
 282  * End:
 283  * vim:noexpandtab:sw=4:ts=4:
 284  */