---
name: "ck_ring_trydequeue_spmc"
section: "3"
platform: "linux"
package: "libck-dev"
version: "0.7.2-6"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/ck_ring_trydequeue_spmc"
---

# ck\_ring\_trydequeue\_spmc(3)

dequeue from bounded FIFO and allow for spurious failure

## NAME

**ck\_ring\_trydequeue\_spmc** – dequeue from bounded FIFO and allow for spurious failure

## LIBRARY

Concurrency Kit (libck, -lck)

## SYNOPSIS

**#include \<ck\_ring.h\>**

*bool*\

**ck\_ring\_trydequeue\_spmc**(*ck\_ring\_t \*ring*, *ck\_ring\_buffer\_t \*buffer*, *void \*result*);

## DESCRIPTION

The **ck\_ring\_trydequeue\_spmc**(*3*) function attempts to dequeue a pointer from the bounded buffer pointed to by *ring* in FIFO fashion. The pointer is stored in the pointer pointed to by *result*. The buffer pointed to by *buffer* must be unique to *ring* and point to an array of ck\_ring\_buffer\_t of sufficient length (according to the power-of-2 elements in the buffer). The decoupling of the ring from the buffer serves to address use-cases involving multiple address spaces and DMA, among others. If you are on non-POSIX platforms or wish for strict compliance with C, then it is recommended to pass a pointer of type void \*\* for *result*. This function is safe to call without locking for UINT\_MAX concurrent **ck\_ring\_dequeue\_spmc**(*3*) or **ck\_ring\_trydequeue\_spmc**(*3*) invocations and up to one concurrent **ck\_ring\_enqueue\_spmc**(*3*) or **ck\_ring\_tryenqueue\_spmc**(*3*) invocation. This operation will always complete in a bounded number of steps. It is possible for the function to return false even if *ring* is non-empty. This

## EXAMPLE

```
#include <ck_ring.h>
/* This ring was previously initialized with ck_ring_init. */
ck_ring_t ring;
/* The ring was initialized for 1023 elements. */
ck_ring_buffer_t buffer[1024];
void
dequeue(void)
{
	void *result;
	/* Dequeue from ring until contention is actively observed. */
	while (ck_ring_trydequeue_spmc(&ring, &buffer, &result) == true) {
		/*
		 * Results contains the oldest pointer in ring
		 * since the dequeue operation returned true.
		 */
		operation(result);
	}
	/* An empty ring was encountered, leave. */
	return;
}
```

## RETURN VALUES

The function returns true if the dequeue operation completely successfully in a bounded number of steps. The result of the dequeue operation is stored in the value pointed to by *result*. Otherwise, the function will return false if the buffer was empty or if the operation could not be completed in a bounded number of steps. If the function returns false, then the contents of *result* are undefined.

## SEE ALSO

[ck\_ring\_init(3)](/ck_ring_init/3.md), [ck\_ring\_dequeue\_spmc(3)](/ck_ring_dequeue_spmc/3.md), [ck\_ring\_enqueue\_spmc(3)](/ck_ring_enqueue_spmc/3.md), [ck\_ring\_enqueue\_spmc\_size(3)](/ck_ring_enqueue_spmc_size/3.md), [ck\_ring\_dequeue\_spsc(3)](/ck_ring_dequeue_spsc/3.md), [ck\_ring\_enqueue\_spsc(3)](/ck_ring_enqueue_spsc/3.md), [ck\_ring\_enqueue\_spsc\_size(3)](/ck_ring_enqueue_spsc_size/3.md), [ck\_ring\_capacity(3)](/ck_ring_capacity/3.md), [ck\_ring\_size(3)](/ck_ring_size/3.md)

Additional information available at http://concurrencykit.org/