libcilkrts/runtime/signal_node.c

   1 /* signal_node.c               -*-C-*-
   2  *
   3  *************************************************************************
   4  *
   5  *  Copyright (C) 2011-2016, Intel Corporation
   6  *  All rights reserved.
   7  *
   8  *  Redistribution and use in source and binary forms, with or without
   9  *  modification, are permitted provided that the following conditions
  10  *  are met:
  11  *
  12  *    * Redistributions of source code must retain the above copyright
  13  *      notice, this list of conditions and the following disclaimer.
  14  *    * Redistributions in binary form must reproduce the above copyright
  15  *      notice, this list of conditions and the following disclaimer in
  16  *      the documentation and/or other materials provided with the
  17  *      distribution.
  18  *    * Neither the name of Intel Corporation nor the names of its
  19  *      contributors may be used to endorse or promote products derived
  20  *      from this software without specific prior written permission.
  21  *
  22  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  26  *  HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  27  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  28  *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  29  *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  30  *  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
  32  *  WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  33  *  POSSIBILITY OF SUCH DAMAGE.
  34  *
  35  *  *********************************************************************
  36  *
  37  *  PLEASE NOTE: This file is a downstream copy of a file mainitained in
  38  *  a repository at cilkplus.org. Changes made to this file that are not
  39  *  submitted through the contribution process detailed at
  40  *  http://www.cilkplus.org/submit-cilk-contribution will be lost the next
  41  *  time that a new version is released. Changes only submitted to the
  42  *  GNU compiler collection or posted to the git repository at
  43  *  https://bitbucket.org/intelcilkruntime/intel-cilk-runtime.git are
  44  *  not tracked.
  45  *
  46  *  We welcome your contributions to this open source project. Thank you
  47  *  for your assistance in helping us improve Cilk Plus.
  48  *
  49  **************************************************************************/
  50
  51 #include "signal_node.h"
  52 #include <stdlib.h>
  53
  54 /* Define cilk_semaphore_t for all of the respective systems. */
  55 #if defined __APPLE__
  56 #   include <mach/mach_init.h>
  57 #   include <mach/semaphore.h>
  58 #   include <mach/task.h>
  59     typedef semaphore_t cilk_semaphore_t;
  60 #elif defined _WIN32
  61 #   include "windows-clean.h"
  62     typedef HANDLE cilk_semaphore_t;
  63 #else // Linux/MIC
  64 #   include <errno.h>
  65 #   include <semaphore.h>
  66 #   include <stdio.h>
  67     typedef sem_t cilk_semaphore_t;
  68 #endif // Linux/MIC
  69
  70 #include "bug.h"
  71 #include "cilk_malloc.h"
  72 #include "signal_node.h"
  73
  74 /**
  75  * Interface within the tree to notify workers to wait without consuming cycles
  76  * to expend cycles trying to steal.
  77  *
  78  * cilk_semaphore_t is implemented as an auto-reset event on Windows, and
  79  * as a semaphore_t on Linux and MacOS.
  80  */
  81 struct signal_node_t
  82 {
  83     /** 0 if the worker should wait, 1 if it should be running. */
  84     volatile unsigned int run;
  85
  86     /** OS-specific semaphore on which the worker can wait. */
  87     cilk_semaphore_t sem;
  88 };
  89
  90 /******************************************************************************/
  91 /* Semaphore-abstraction functions                                            */
  92 /******************************************************************************/
  93
  94 /*
  95  * All of these functions are simple wrappers for the system-specific semaphore
  96  * functions.  This keeps the rest of the code reasonably clean and readable.
  97  */
  98
  99 #if defined __APPLE__
 100 static void initialize_cilk_semaphore (cilk_semaphore_t *sem)
 101 {
 102     kern_return_t kstatus
 103         = semaphore_create(mach_task_self(), sem, SYNC_POLICY_FIFO, 0);
 104     assert(kstatus == KERN_SUCCESS);
 105 }
 106 static void deinitialize_cilk_semaphore (cilk_semaphore_t *sem)
 107 {
 108     kern_return_t kstatus = semaphore_destroy(mach_task_self(), *sem);
 109     assert(kstatus == KERN_SUCCESS);
 110 }
 111 static void wait_on_cilk_semaphore (cilk_semaphore_t *sem)
 112 {
 113     kern_return_t kstatus = semaphore_wait(*sem);
 114     assert(kstatus == KERN_SUCCESS);
 115 }
 116 static void signal_cilk_semaphore (cilk_semaphore_t *sem)
 117 {
 118     kern_return_t kstatus = semaphore_signal(*sem);
 119     assert(kstatus == KERN_SUCCESS);
 120 }
 121 #elif defined _WIN32
 122 // Note: Windows only provides counting semaphores, and we don't really
 123 // care about the count. So this is implemented using an auto-reset
 124 // event which will automatically reset after the WaitForSingleObject
 125 // call
 126 static void initialize_cilk_semaphore (cilk_semaphore_t *sem)
 127 {
 128     // Create an auto-reset event
 129     *sem = CreateEvent(NULL,    // Security attributes
 130                        FALSE,   // Manual reset
 131                        FALSE,   // Initial state (initially reset)
 132                        NULL);   // Name (anonymous)
 133     CILK_ASSERT (NULL != *sem);
 134 }
 135
 136 static void deinitialize_cilk_semaphore (cilk_semaphore_t *sem)
 137 {
 138     BOOL result = CloseHandle(*sem);
 139     CILK_ASSERT (0 != result);
 140 }
 141
 142 static void wait_on_cilk_semaphore (cilk_semaphore_t *sem)
 143 {
 144     // WaitForSingleObject will reset the event
 145     DWORD result = WaitForSingleObject (*sem, INFINITE);
 146     CILK_ASSERT (WAIT_OBJECT_0 == result);
 147 }
 148 static void signal_cilk_semaphore (cilk_semaphore_t *sem)
 149 {
 150     BOOL result = SetEvent (*sem);
 151     CILK_ASSERT (0 != result);
 152 }
 153 #else // Linux/MIC
 154 static void initialize_cilk_semaphore (cilk_semaphore_t *sem)
 155 {
 156     int status = sem_init(sem, 0, 0);
 157     assert(0 == status);
 158 }
 159 static void deinitialize_cilk_semaphore (cilk_semaphore_t *sem)
 160 {
 161     int status = sem_destroy(sem);
 162     assert(0 == status);
 163 }
 164 static void wait_on_cilk_semaphore (cilk_semaphore_t *sem)
 165 {
 166     int status;
 167
 168     do {
 169         status = sem_wait(sem);
 170     } while (status != 0 && errno == EINTR);
 171
 172     if (status != 0) {
 173         perror("sem_wait");
 174         abort();
 175     }
 176 }
 177 static void signal_cilk_semaphore (cilk_semaphore_t *sem)
 178 {
 179     sem_post(sem);
 180 }
 181 #endif // Linux/MIC
 182
 183 /******************************************************************************/
 184 /* Runtime interface functions                                                */
 185 /******************************************************************************/
 186
 187 /*
 188  * Return a newly malloc'd and initialized signal_node_t.
 189  */
 190 COMMON_SYSDEP
 191 signal_node_t *signal_node_create(void)
 192 {
 193      signal_node_t *node;
 194
 195     node = ( signal_node_t*)
 196         __cilkrts_malloc(sizeof( signal_node_t));
 197     node->run = 0;
 198     initialize_cilk_semaphore(&node->sem);
 199
 200     return node;
 201 }
 202
 203 /*
 204  * Clean and free a signal_node_t.
 205  */
 206 void signal_node_destroy(signal_node_t *node)
 207 {
 208     CILK_ASSERT(node);
 209     deinitialize_cilk_semaphore(&node->sem);
 210     __cilkrts_free(node);
 211 }
 212
 213 /*
 214  * Return 1 if the node thinks the worker should go to sleep, 0 otherwise.
 215  */
 216 unsigned int signal_node_should_wait(signal_node_t *node)
 217 {
 218     CILK_ASSERT(node);
 219     return !node->run;
 220 }
 221
 222 /*
 223  * Send a message to the node that the worker will eventually read.
 224  */
 225 void signal_node_msg(signal_node_t *node, unsigned int msg)
 226 {
 227     CILK_ASSERT(node);
 228     switch (msg) {
 229     case 0:                    // worker should go to sleep.
 230         node->run = msg;
 231         break;
 232     case 1:                    // worker should be awake.
 233         node->run = msg;
 234         signal_cilk_semaphore(&node->sem);
 235         break;
 236     default:                   // error.
 237         CILK_ASSERT(0 == "Bad signal_node_t message.");
 238     }
 239 }
 240
 241 /*
 242  * The current worker will wait on the semaphore.
 243  */
 244 void signal_node_wait(signal_node_t *node)
 245 {
 246     CILK_ASSERT(node);
 247     while (signal_node_should_wait(node)) {
 248         // The loop is here to consume extra semaphore signals that might have
 249         // accumulated.  No point in passing on the accumulation.
 250         wait_on_cilk_semaphore(&node->sem);
 251     }
 252 }