libobjc/thr-mach.c

   1 /* GNU Objective C Runtime Thread Implementation
   2    Copyright (C) 1996, 1997, 2002 Free Software Foundation, Inc.
   3    Contributed by Galen C. Hunt (gchunt@cs.rochester.edu)
   4    Modified for Mach threads by Bill Bumgarner <bbum@friday.com>
   5    Condition functions added by Mircea Oancea <mircea@first.elcom.pub.ro>
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under the
  10 terms of the GNU General Public License as published by the Free Software
  11 Foundation; either version 2, or (at your option) any later version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  15 FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  16 details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23 /* As a special exception, if you link this library with files compiled with
  24    GCC to produce an executable, this does not cause the resulting executable
  25    to be covered by the GNU General Public License. This exception does not
  26    however invalidate any other reasons why the executable file might be
  27    covered by the GNU General Public License.  */
  28
  29 #include <mach/mach.h>
  30 #include <mach/cthreads.h>
  31 #include <objc/thr.h>
  32 #include "runtime.h"
  33
  34 /*
  35   Obtain the maximum thread priority that can set for t.  Under the
  36   mach threading model, it is possible for the developer to adjust the
  37   maximum priority downward only-- cannot be raised without superuser
  38   privileges.  Once lowered, it cannot be raised.
  39   */
  40 static int
  41 __mach_get_max_thread_priority (cthread_t t, int *base)
  42 {
  43   thread_t threadP;
  44   kern_return_t error;
  45   struct thread_sched_info info;
  46   unsigned int info_count=THREAD_SCHED_INFO_COUNT;
  47
  48   if (t == NULL)
  49     return -1;
  50
  51   threadP  = cthread_thread (t);        /* get thread underlying */
  52
  53   error = thread_info (threadP, THREAD_SCHED_INFO,
  54                        (thread_info_t) &info, &info_count);
  55
  56   if (error != KERN_SUCCESS)
  57     return -1;
  58
  59   if (base != NULL)
  60     *base = info.base_priority;
  61
  62   return info.max_priority;
  63 }
  64
  65 /* Backend initialization functions */
  66
  67 /* Initialize the threads subsystem. */
  68 int
  69 __objc_init_thread_system (void)
  70 {
  71   return 0;
  72 }
  73
  74 /* Close the threads subsystem. */
  75 int
  76 __objc_close_thread_system (void)
  77 {
  78   return 0;
  79 }
  80
  81 /* Backend thread functions */
  82
  83 /* Create a new thread of execution. */
  84 objc_thread_t
  85 __objc_thread_detach (void (*func) (void *arg), void *arg)
  86 {
  87   objc_thread_t thread_id;
  88   cthread_t new_thread_handle;
  89
  90   /* create thread */
  91   new_thread_handle = cthread_fork ((cthread_fn_t) func, arg);
  92
  93   if (new_thread_handle)
  94     {
  95       /* this is not terribly portable */
  96       thread_id = *(objc_thread_t *) &new_thread_handle;
  97       cthread_detach (new_thread_handle);
  98     }
  99   else
 100     thread_id = NULL;
 101
 102   return thread_id;
 103 }
 104
 105 /* Set the current thread's priority. */
 106 int
 107 __objc_thread_set_priority (int priority)
 108 {
 109   objc_thread_t *t = objc_thread_id ();
 110   cthread_t cT = (cthread_t) t;
 111   int maxPriority = __mach_get_max_thread_priority (cT, NULL);
 112   int sys_priority = 0;
 113
 114   if (maxPriority == -1)
 115     return -1;
 116
 117   switch (priority)
 118     {
 119     case OBJC_THREAD_INTERACTIVE_PRIORITY:
 120       sys_priority = maxPriority;
 121       break;
 122     case OBJC_THREAD_BACKGROUND_PRIORITY:
 123       sys_priority = (maxPriority * 2) / 3;
 124       break;
 125     case OBJC_THREAD_LOW_PRIORITY:
 126       sys_priority = maxPriority / 3;
 127       break;
 128     default:
 129       return -1;
 130     }
 131
 132   if (sys_priority == 0)
 133     return -1;
 134
 135   /* Change the priority */
 136   if (cthread_priority (cT, sys_priority, 0) == KERN_SUCCESS)
 137     return 0;
 138   else
 139     return -1;
 140 }
 141
 142 /* Return the current thread's priority. */
 143 int
 144 __objc_thread_get_priority (void)
 145 {
 146   objc_thread_t *t = objc_thread_id ();
 147   cthread_t cT = (cthread_t) t; /* see objc_thread_id () */
 148   int basePriority;
 149   int maxPriority;
 150   int sys_priority = 0;
 151
 152   int interactiveT, backgroundT, lowT; /* thresholds */
 153
 154   maxPriority = __mach_get_max_thread_priority (cT, &basePriority);
 155
 156   if (maxPriority == -1)
 157     return -1;
 158
 159   if (basePriority > ( (maxPriority * 2) / 3))
 160     return OBJC_THREAD_INTERACTIVE_PRIORITY;
 161
 162   if (basePriority > ( maxPriority / 3))
 163     return OBJC_THREAD_BACKGROUND_PRIORITY;
 164
 165   return OBJC_THREAD_LOW_PRIORITY;
 166 }
 167
 168 /* Yield our process time to another thread. */
 169 void
 170 __objc_thread_yield (void)
 171 {
 172   cthread_yield ();
 173 }
 174
 175 /* Terminate the current thread. */
 176 int
 177 __objc_thread_exit (void)
 178 {
 179   /* exit the thread */
 180   cthread_exit (&__objc_thread_exit_status);
 181
 182   /* Failed if we reached here */
 183   return -1;
 184 }
 185
 186 /* Returns an integer value which uniquely describes a thread. */
 187 objc_thread_t
 188 __objc_thread_id (void)
 189 {
 190   cthread_t self = cthread_self ();
 191
 192   return *(objc_thread_t *) &self;
 193 }
 194
 195 /* Sets the thread's local storage pointer. */
 196 int
 197 __objc_thread_set_data (void *value)
 198 {
 199   cthread_set_data (cthread_self (), (any_t) value);
 200   return 0;
 201 }
 202
 203 /* Returns the thread's local storage pointer. */
 204 void *
 205 __objc_thread_get_data (void)
 206 {
 207   return (void *) cthread_data (cthread_self ());
 208 }
 209
 210 /* Backend mutex functions */
 211
 212 /* Allocate a mutex. */
 213 int
 214 __objc_mutex_allocate (objc_mutex_t mutex)
 215 {
 216   int err = 0;
 217   mutex->backend = objc_malloc (sizeof (struct mutex));
 218
 219   err = mutex_init ((mutex_t) (mutex->backend));
 220
 221   if (err != 0)
 222     {
 223       objc_free (mutex->backend);
 224       return -1;
 225     }
 226   else
 227     return 0;
 228 }
 229
 230 /* Deallocate a mutex. */
 231 int
 232 __objc_mutex_deallocate (objc_mutex_t mutex)
 233 {
 234   mutex_clear ((mutex_t) (mutex->backend));
 235
 236   objc_free (mutex->backend);
 237   mutex->backend = NULL;
 238   return 0;
 239 }
 240
 241 /* Grab a lock on a mutex. */
 242 int
 243 __objc_mutex_lock (objc_mutex_t mutex)
 244 {
 245   mutex_lock ((mutex_t) (mutex->backend));
 246   return 0;
 247 }
 248
 249 /* Try to grab a lock on a mutex. */
 250 int
 251 __objc_mutex_trylock (objc_mutex_t mutex)
 252 {
 253   if (mutex_try_lock ((mutex_t) (mutex->backend)) == 0)
 254     return -1;
 255   else
 256     return 0;
 257 }
 258
 259 /* Unlock the mutex */
 260 int
 261 __objc_mutex_unlock (objc_mutex_t mutex)
 262 {
 263   mutex_unlock ((mutex_t) (mutex->backend));
 264   return 0;
 265 }
 266
 267 /* Backend condition mutex functions */
 268
 269 /* Allocate a condition. */
 270 int
 271 __objc_condition_allocate (objc_condition_t condition)
 272 {
 273   condition->backend = objc_malloc (sizeof (struct condition));
 274   condition_init ((condition_t) (condition->backend));
 275   return 0;
 276 }
 277
 278 /* Deallocate a condition. */
 279 int
 280 __objc_condition_deallocate (objc_condition_t condition)
 281 {
 282   condition_clear ((condition_t) (condition->backend));
 283   objc_free (condition->backend);
 284   condition->backend = NULL;
 285   return 0;
 286 }
 287
 288 /* Wait on the condition */
 289 int
 290 __objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex)
 291 {
 292   condition_wait ((condition_t) (condition->backend),
 293                   (mutex_t) (mutex->backend));
 294   return 0;
 295 }
 296
 297 /* Wake up all threads waiting on this condition. */
 298 int
 299 __objc_condition_broadcast (objc_condition_t condition)
 300 {
 301   condition_broadcast ((condition_t) (condition->backend));
 302   return 0;
 303 }
 304
 305 /* Wake up one thread waiting on this condition. */
 306 int
 307 __objc_condition_signal (objc_condition_t condition)
 308 {
 309   condition_signal ((condition_t) (condition->backend));
 310   return 0;
 311 }
 312
 313 /* End of File */