---
name: "ck_ring_enqueue_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_enqueue_spmc"
---

# ck\_ring\_enqueue\_spmc(3)

enqueue pointer into bounded FIFO

## NAME

**ck\_ring\_enqueue\_spmc** – enqueue pointer into bounded FIFO

## LIBRARY

Concurrency Kit (libck, -lck)

## SYNOPSIS

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

*bool*\

**ck\_ring\_enqueue\_spmc**(*ck\_ring\_t \*ring*, *ck\_ring\_buffer\_t \*buffer*, *void \*entry*);

## DESCRIPTION

The **ck\_ring\_enqueue\_spmc**(*3*) function enqueues the pointer *entry* into the bounded buffer pointed to by *ring* in FIFO fashion. 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 *entry*. This function is safe to call without locking for UINT\_MAX concurrent invocations of **ck\_ring\_dequeue\_spmc**(*3*) or **ck\_ring\_trydequeue\_spmc**(*3*). This function provides wait-free progress guarantees for one active invocation.

## 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
enqueue(void)
{
	void *entry = some_object;
	/* Attempt to enqueue pointer to some_object into buffer. */
	if (ck_ring_enqueue_spmc(&ring, &buffer, &entry) == false) {
		/*
		 * The buffer was full and the enqueue operation
		 * has failed.
		 */
		return;
	}
	/* Enqueue operation completed successfully. */
	return;
}
```

## RETURN VALUES

The function returns true if the value of *entry* was successfully enqueued into *ring*. The function will return false if the value of *entry* could not be enqueued which only occurs if *ring* was full.

## SEE ALSO

[ck\_ring\_init(3)](/ck_ring_init/3.md), [ck\_ring\_dequeue\_spmc(3)](/ck_ring_dequeue_spmc/3.md), [ck\_ring\_trydequeue\_spmc(3)](/ck_ring_trydequeue_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/