Calling close on a closed channel panics.
Don't limit number of receives on a closed channel.
From-SVN: r171364
}
})
- // sending (a small number of times) to a closed channel is not specified
- // but the current implementation doesn't block: test that different
- // implementations behave the same
- testBlock(never, func() {
- for i := 0; i < 10; i++ {
- closedch <- 7
- }
+ // sending to a closed channel panics.
+ testPanic(always, func() {
+ closedch <- 7
})
// receiving from a non-ready channel always blocks
}
})
- // selects with closed channels don't block
+ // selects with closed channels behave like ordinary operations
testBlock(never, func() {
select {
case <-closedch:
}
})
- testBlock(never, func() {
+ testPanic(always, func() {
select {
case closedch <- 7:
}
return "(select)"
}
+func shouldPanic(f func()) {
+ defer func() {
+ if recover() == nil {
+ panic("did not panic")
+ }
+ }()
+ f()
+}
+
func test1(c Chan) {
// not closed until the close signal (a zero value) has been received.
if c.Closed() {
}
// send should work with ,ok too: sent a value without blocking, so ok == true.
- ok := c.Nbsend(1)
- if !ok {
- println("test1: send on closed got not ok", c.Impl())
- }
+ shouldPanic(func(){c.Nbsend(1)})
- // but the value should have been discarded.
+ // the value should have been discarded.
if x := c.Recv(); x != 0 {
println("test1: recv on closed got non-zero after send on closed:", x, c.Impl())
}
// similarly Send.
- c.Send(2)
+ shouldPanic(func(){c.Send(2)})
if x := c.Recv(); x != 0 {
println("test1: recv on closed got non-zero after send on closed:", x, c.Impl())
}
pthread_cond_t cond;
/* The size of elements on this channel. */
size_t element_size;
- /* Number of operations on closed channel. */
- unsigned short closed_op_count;
/* True if a goroutine is waiting to send on a synchronous
channel. */
_Bool waiting_to_send;
acquired while this mutex is held. */
extern pthread_mutex_t __go_select_data_mutex;
-/* Maximum permitted number of operations on a closed channel. */
-#define MAX_CLOSED_OPERATIONS (0x100)
-
extern struct __go_channel *__go_new_channel (size_t, size_t);
extern _Bool __go_synch_with_select (struct __go_channel *, _Bool);
extern void __go_broadcast_to_select (struct __go_channel *);
-extern _Bool __go_send_acquire (struct __go_channel *, _Bool);
-
-#define SEND_NONBLOCKING_ACQUIRE_SPACE 0
-#define SEND_NONBLOCKING_ACQUIRE_NOSPACE 1
-#define SEND_NONBLOCKING_ACQUIRE_CLOSED 2
+extern void __go_send_acquire (struct __go_channel *, _Bool);
-extern int __go_send_nonblocking_acquire (struct __go_channel *);
+extern _Bool __go_send_nonblocking_acquire (struct __go_channel *);
extern void __go_send_release (struct __go_channel *);
license that can be found in the LICENSE file. */
#include "go-assert.h"
+#include "go-panic.h"
#include "channel.h"
/* Close a channel. After a channel is closed, sends are no longer
__go_assert (i == 0);
}
+ if (channel->is_closed)
+ {
+ i = pthread_mutex_unlock (&channel->lock);
+ __go_assert (i == 0);
+ __go_panic_msg ("close of closed channel");
+ }
+
channel->is_closed = 1;
i = pthread_cond_broadcast (&channel->cond);
i = pthread_cond_init (&ret->cond, NULL);
__go_assert (i == 0);
ret->element_size = element_size;
- ret->closed_op_count = 0;
ret->waiting_to_send = 0;
ret->waiting_to_receive = 0;
ret->selected_for_send = 0;
? channel->next_store == 0
: channel->next_fetch == channel->next_store))
{
- if (channel->saw_close)
- {
- ++channel->closed_op_count;
- if (channel->closed_op_count >= MAX_CLOSED_OPERATIONS)
- {
- i = pthread_mutex_unlock (&channel->lock);
- __go_assert (i == 0);
- __go_panic_msg ("too many operations on closed channel");
- }
- }
channel->saw_close = 1;
__go_unlock_and_notify_selects (channel);
return RECEIVE_NONBLOCKING_ACQUIRE_CLOSED;
? channel->next_store == 0
: channel->next_fetch == channel->next_store))
{
- if (channel->saw_close)
- {
- ++channel->closed_op_count;
- if (channel->closed_op_count >= MAX_CLOSED_OPERATIONS)
- __go_panic_msg ("too many operations on closed channel");
- }
channel->saw_close = 1;
channel->selected_for_receive = 0;
__go_unlock_and_notify_selects (channel);
alloc_size = ((channel->element_size + sizeof (uint64_t) - 1)
/ sizeof (uint64_t));
- if (!__go_send_acquire (channel, for_select))
- return;
+ __go_send_acquire (channel, for_select);
offset = channel->next_store * alloc_size;
__builtin_memcpy (&channel->data[offset], val, channel->element_size);
alloc_size = ((channel->element_size + sizeof (uint64_t) - 1)
/ sizeof (uint64_t));
- int data = __go_send_nonblocking_acquire (channel);
- if (data != SEND_NONBLOCKING_ACQUIRE_SPACE)
- return data == SEND_NONBLOCKING_ACQUIRE_CLOSED;
+ if (!__go_send_nonblocking_acquire (channel))
+ return 0;
offset = channel->next_store * alloc_size;
__builtin_memcpy (&channel->data[offset], val, channel->element_size);
#include "go-panic.h"
#include "channel.h"
-/* Prepare to send something on a nonblocking channel. */
+/* Prepare to send something on a nonblocking channel. Return true if
+ we acquired the channel, false if we did not acquire it because
+ there is no space to send a value. */
-int
+_Bool
__go_send_nonblocking_acquire (struct __go_channel *channel)
{
int i;
if (channel->is_closed)
{
- ++channel->closed_op_count;
- if (channel->closed_op_count >= MAX_CLOSED_OPERATIONS)
- {
- i = pthread_mutex_unlock (&channel->lock);
- __go_assert (i == 0);
- __go_panic_msg ("too many operations on closed channel");
- }
i = pthread_mutex_unlock (&channel->lock);
__go_assert (i == 0);
- return SEND_NONBLOCKING_ACQUIRE_CLOSED;
+ __go_panic_msg ("send on closed channel");
}
if (channel->num_entries > 0)
i = pthread_mutex_unlock (&channel->lock);
__go_assert (i == 0);
- return SEND_NONBLOCKING_ACQUIRE_NOSPACE;
+ return 0;
}
- return SEND_NONBLOCKING_ACQUIRE_SPACE;
+ return 1;
}
/* Send something 64 bits or smaller on a channel. */
{
__go_assert (channel->element_size <= sizeof (uint64_t));
- int data = __go_send_nonblocking_acquire (channel);
- if (data != SEND_NONBLOCKING_ACQUIRE_SPACE)
- return data == SEND_NONBLOCKING_ACQUIRE_CLOSED;
+ if (!__go_send_nonblocking_acquire (channel))
+ return 0;
channel->data[channel->next_store] = val;
#include "go-panic.h"
#include "channel.h"
-/* Prepare to send something on a channel. Return true if the channel
- is acquired, false, if it is closed. FOR_SELECT is true if this
+/* Prepare to send something on a channel. FOR_SELECT is true if this
call is being made after a select statement returned with this
channel selected. */
-_Bool
+void
__go_send_acquire (struct __go_channel *channel, _Bool for_select)
{
int i;
while (1)
{
- /* Check whether the channel is closed. */
if (channel->is_closed)
{
- ++channel->closed_op_count;
- if (channel->closed_op_count >= MAX_CLOSED_OPERATIONS)
- {
- i = pthread_mutex_unlock (&channel->lock);
- __go_assert (i == 0);
- __go_panic_msg ("too many operations on closed channel");
- }
- channel->selected_for_send = 0;
- __go_unlock_and_notify_selects (channel);
- return 0;
+ if (for_select)
+ channel->selected_for_send = 0;
+ i = pthread_mutex_unlock (&channel->lock);
+ __go_assert (i == 0);
+ __go_panic_msg ("send on closed channel");
}
/* If somebody else has the channel locked for sending, we have
if (!channel->waiting_to_send)
{
__go_assert (channel->next_store == 0);
- return 1;
+ return;
}
}
else
/* If there is room on the channel, we are OK. */
if ((channel->next_store + 1) % channel->num_entries
!= channel->next_fetch)
- return 1;
+ return;
}
}
__go_assert (channel->element_size <= sizeof (uint64_t));
- if (!__go_send_acquire (channel, for_select))
- return;
+ __go_send_acquire (channel, for_select);
channel->data[channel->next_store] = val;
projects / gcc.git / commitdiff