libgo/runtime/go-send-small.c

   1 /* go-send-small.c -- send something 64 bits or smaller on a channel.
   2
   3    Copyright 2009 The Go Authors. All rights reserved.
   4    Use of this source code is governed by a BSD-style
   5    license that can be found in the LICENSE file.  */
   6
   7 #include <stdint.h>
   8
   9 #include "go-assert.h"
  10 #include "go-panic.h"
  11 #include "channel.h"
  12
  13 /* Prepare to send something on a channel.  Return true if the channel
  14    is acquired, false, if it is closed.  FOR_SELECT is true if this
  15    call is being made after a select statement returned with this
  16    channel selected.  */
  17
  18 _Bool
  19 __go_send_acquire (struct __go_channel *channel, _Bool for_select)
  20 {
  21   int i;
  22
  23   i = pthread_mutex_lock (&channel->lock);
  24   __go_assert (i == 0);
  25
  26   while (1)
  27     {
  28       /* Check whether the channel is closed.  */
  29       if (channel->is_closed)
  30         {
  31           ++channel->closed_op_count;
  32           if (channel->closed_op_count >= MAX_CLOSED_OPERATIONS)
  33             {
  34               i = pthread_mutex_unlock (&channel->lock);
  35               __go_assert (i == 0);
  36               __go_panic_msg ("too many operations on closed channel");
  37             }
  38           channel->selected_for_send = 0;
  39           __go_unlock_and_notify_selects (channel);
  40           return 0;
  41         }
  42
  43       /* If somebody else has the channel locked for sending, we have
  44          to wait.  If FOR_SELECT is true, then we are the one with the
  45          lock.  */
  46       if (!channel->selected_for_send || for_select)
  47         {
  48           if (channel->num_entries == 0)
  49             {
  50               /* This is a synchronous channel.  If nobody else is
  51                  waiting to send, we grab the channel and tell the
  52                  caller to send the data.  We will then wait for a
  53                  receiver.  */
  54               if (!channel->waiting_to_send)
  55                 {
  56                   __go_assert (channel->next_store == 0);
  57                   return 1;
  58                 }
  59             }
  60           else
  61             {
  62               /* If there is room on the channel, we are OK.  */
  63               if ((channel->next_store + 1) % channel->num_entries
  64                   != channel->next_fetch)
  65                 return 1;
  66             }
  67         }
  68
  69       /* Wait for something to change, then loop around and try
  70          again.  */
  71
  72       i = pthread_cond_wait (&channel->cond, &channel->lock);
  73       __go_assert (i == 0);
  74     }
  75 }
  76
  77 /* Finished sending something on a channel.  */
  78
  79 void
  80 __go_send_release (struct __go_channel *channel)
  81 {
  82   int i;
  83
  84   if (channel->num_entries != 0)
  85     {
  86       /* This is a buffered channel.  Bump the store count and signal
  87          the condition variable.  */
  88       channel->next_store = (channel->next_store + 1) % channel->num_entries;
  89
  90       i = pthread_cond_signal (&channel->cond);
  91       __go_assert (i == 0);
  92     }
  93   else
  94     {
  95       _Bool synched_with_select;
  96
  97       /* This is a synchronous channel.  Indicate that we have a value
  98          waiting.  */
  99       channel->next_store = 1;
 100       channel->waiting_to_send = 1;
 101
 102       /* Tell everybody else to do something.  This has to be a
 103          broadcast because we might have both senders and receivers
 104          waiting on the condition, but senders won't send another
 105          signal.  */
 106       i = pthread_cond_broadcast (&channel->cond);
 107       __go_assert (i == 0);
 108
 109       /* Wait until the value is received.  */
 110       synched_with_select = 0;
 111       while (1)
 112         {
 113           if (channel->next_store == 0)
 114             break;
 115
 116           /* If nobody is currently waiting to receive, try to synch
 117              up with a select.  */
 118           if (!channel->waiting_to_receive && !synched_with_select)
 119             {
 120               if (__go_synch_with_select (channel, 1))
 121                 {
 122                   synched_with_select = 1;
 123                   __go_broadcast_to_select (channel);
 124                   continue;
 125                 }
 126             }
 127
 128           i = pthread_cond_wait (&channel->cond, &channel->lock);
 129           __go_assert (i == 0);
 130         }
 131
 132       channel->waiting_to_send = 0;
 133
 134       /* Using the mutexes should implement a memory barrier.  */
 135
 136       /* We have to signal again since we cleared the waiting_to_send
 137          field.  This has to be a broadcast because both senders and
 138          receivers might be waiting, but only senders will be able to
 139          act.  */
 140       i = pthread_cond_broadcast (&channel->cond);
 141       __go_assert (i == 0);
 142     }
 143
 144   channel->selected_for_send = 0;
 145
 146   __go_unlock_and_notify_selects (channel);
 147 }
 148
 149 /* Send something 64 bits or smaller on a channel.  */
 150
 151 void
 152 __go_send_small (struct __go_channel *channel, uint64_t val, _Bool for_select)
 153 {
 154   if (channel == NULL)
 155     __go_panic_msg ("send to nil channel");
 156
 157   __go_assert (channel->element_size <= sizeof (uint64_t));
 158
 159   if (!__go_send_acquire (channel, for_select))
 160     return;
 161
 162   channel->data[channel->next_store] = val;
 163
 164   __go_send_release (channel);
 165 }