31 #include <synch.h> 32 33 // 34 // See threadCritical.hpp for details of this class. 35 // 36 // For some reason, we don't do locking until the 37 // os::init() call completes. I'm not sure why this 38 // is, and have left it that way for now. This should 39 // be reviewed later. 40 41 static mutex_t global_mut; 42 static thread_t global_mut_owner = -1; 43 static int global_mut_count = 0; 44 static bool initialized = false; 45 46 ThreadCritical::ThreadCritical() { 47 if (initialized) { 48 thread_t owner = thr_self(); 49 if (global_mut_owner != owner) { 50 if (os::Solaris::mutex_lock(&global_mut)) 51 fatal(err_msg("ThreadCritical::ThreadCritical: mutex_lock failed (%s)", 52 strerror(errno))); 53 assert(global_mut_count == 0, "must have clean count"); 54 assert(global_mut_owner == -1, "must have clean owner"); 55 } 56 global_mut_owner = owner; 57 ++global_mut_count; 58 } else { 59 assert (Threads::number_of_threads() == 0, "valid only during initialization"); 60 } 61 } 62 63 ThreadCritical::~ThreadCritical() { 64 if (initialized) { 65 assert(global_mut_owner == thr_self(), "must have correct owner"); 66 assert(global_mut_count > 0, "must have correct count"); 67 --global_mut_count; 68 if (global_mut_count == 0) { 69 global_mut_owner = -1; 70 if (os::Solaris::mutex_unlock(&global_mut)) 71 fatal(err_msg("ThreadCritical::~ThreadCritical: mutex_unlock failed " 72 "(%s)", strerror(errno))); 73 } 74 } else { 75 assert (Threads::number_of_threads() == 0, "valid only during initialization"); 76 } 77 } 78 79 void ThreadCritical::initialize() { 80 // This method is called at the end of os::init(). Until 81 // then, we don't do real locking. 82 initialized = true; 83 } 84 85 void ThreadCritical::release() { 86 } | 31 #include <synch.h> 32 33 // 34 // See threadCritical.hpp for details of this class. 35 // 36 // For some reason, we don't do locking until the 37 // os::init() call completes. I'm not sure why this 38 // is, and have left it that way for now. This should 39 // be reviewed later. 40 41 static mutex_t global_mut; 42 static thread_t global_mut_owner = -1; 43 static int global_mut_count = 0; 44 static bool initialized = false; 45 46 ThreadCritical::ThreadCritical() { 47 if (initialized) { 48 thread_t owner = thr_self(); 49 if (global_mut_owner != owner) { 50 if (os::Solaris::mutex_lock(&global_mut)) 51 fatal("ThreadCritical::ThreadCritical: mutex_lock failed (%s)", 52 strerror(errno)); 53 assert(global_mut_count == 0, "must have clean count"); 54 assert(global_mut_owner == -1, "must have clean owner"); 55 } 56 global_mut_owner = owner; 57 ++global_mut_count; 58 } else { 59 assert (Threads::number_of_threads() == 0, "valid only during initialization"); 60 } 61 } 62 63 ThreadCritical::~ThreadCritical() { 64 if (initialized) { 65 assert(global_mut_owner == thr_self(), "must have correct owner"); 66 assert(global_mut_count > 0, "must have correct count"); 67 --global_mut_count; 68 if (global_mut_count == 0) { 69 global_mut_owner = -1; 70 if (os::Solaris::mutex_unlock(&global_mut)) 71 fatal("ThreadCritical::~ThreadCritical: mutex_unlock failed (%s)", strerror(errno)); 72 } 73 } else { 74 assert (Threads::number_of_threads() == 0, "valid only during initialization"); 75 } 76 } 77 78 void ThreadCritical::initialize() { 79 // This method is called at the end of os::init(). Until 80 // then, we don't do real locking. 81 initialized = true; 82 } 83 84 void ThreadCritical::release() { 85 } |