}
static inline struct cds_wfcq_node *
-___cds_wfcq_dequeue(struct cds_wfcq_head *head,
+___cds_wfcq_dequeue_with_state(struct cds_wfcq_head *head,
struct cds_wfcq_tail *tail,
+ int *state,
int blocking)
{
struct cds_wfcq_node *node, *next;
- if (_cds_wfcq_empty(head, tail))
+ if (state)
+ *state = 0;
+
+ if (_cds_wfcq_empty(head, tail)) {
return NULL;
+ }
node = ___cds_wfcq_node_sync_next(&head->node, blocking);
- if (!blocking && node == CDS_WFCQ_WOULDBLOCK)
+ if (!blocking && node == CDS_WFCQ_WOULDBLOCK) {
return CDS_WFCQ_WOULDBLOCK;
+ }
if ((next = CMM_LOAD_SHARED(node->next)) == NULL) {
/*
* content.
*/
_cds_wfcq_node_init(&head->node);
- if (uatomic_cmpxchg(&tail->p, node, &head->node) == node)
+ if (uatomic_cmpxchg(&tail->p, node, &head->node) == node) {
+ if (state)
+ *state |= CDS_WFCQ_STATE_LAST;
return node;
+ }
next = ___cds_wfcq_node_sync_next(node, blocking);
/*
* In nonblocking mode, if we would need to block to
}
/*
- * __cds_wfcq_dequeue_blocking: dequeue a node from the queue.
+ * __cds_wfcq_dequeue_with_state_blocking: dequeue node from queue, with state.
*
* Content written into the node before enqueue is guaranteed to be
* consistent, but no other memory ordering is ensured.
* caller.
*/
static inline struct cds_wfcq_node *
+___cds_wfcq_dequeue_with_state_blocking(struct cds_wfcq_head *head,
+ struct cds_wfcq_tail *tail, int *state)
+{
+ return ___cds_wfcq_dequeue_with_state(head, tail, state, 1);
+}
+
+/*
+ * ___cds_wfcq_dequeue_blocking: dequeue node from queue.
+ *
+ * Same as __cds_wfcq_dequeue_with_state_blocking, but without saving
+ * state.
+ */
+static inline struct cds_wfcq_node *
___cds_wfcq_dequeue_blocking(struct cds_wfcq_head *head,
struct cds_wfcq_tail *tail)
{
- return ___cds_wfcq_dequeue(head, tail, 1);
+ return ___cds_wfcq_dequeue_with_state_blocking(head, tail, NULL);
}
/*
- * __cds_wfcq_dequeue_nonblocking: dequeue a node from a wait-free queue.
+ * __cds_wfcq_dequeue_with_state_nonblocking: dequeue node, with state.
*
* Same as __cds_wfcq_dequeue_blocking, but returns CDS_WFCQ_WOULDBLOCK
* if it needs to block.
*/
static inline struct cds_wfcq_node *
+___cds_wfcq_dequeue_with_state_nonblocking(struct cds_wfcq_head *head,
+ struct cds_wfcq_tail *tail, int *state)
+{
+ return ___cds_wfcq_dequeue_with_state(head, tail, state, 0);
+}
+
+/*
+ * ___cds_wfcq_dequeue_nonblocking: dequeue node from queue.
+ *
+ * Same as __cds_wfcq_dequeue_with_state_nonblocking, but without saving
+ * state.
+ */
+static inline struct cds_wfcq_node *
___cds_wfcq_dequeue_nonblocking(struct cds_wfcq_head *head,
struct cds_wfcq_tail *tail)
{
- return ___cds_wfcq_dequeue(head, tail, 0);
+ return ___cds_wfcq_dequeue_with_state_nonblocking(head, tail, NULL);
}
/*
}
/*
- * cds_wfcq_dequeue_blocking: dequeue a node from a wait-free queue.
+ * cds_wfcq_dequeue_with_state_blocking: dequeue a node from a wait-free queue.
*
* Content written into the node before enqueue is guaranteed to be
* consistent, but no other memory ordering is ensured.
* It is valid to reuse and free a dequeued node immediately.
*/
static inline struct cds_wfcq_node *
-_cds_wfcq_dequeue_blocking(struct cds_wfcq_head *head,
- struct cds_wfcq_tail *tail)
+_cds_wfcq_dequeue_with_state_blocking(struct cds_wfcq_head *head,
+ struct cds_wfcq_tail *tail, int *state)
{
struct cds_wfcq_node *retval;
_cds_wfcq_dequeue_lock(head, tail);
- retval = ___cds_wfcq_dequeue_blocking(head, tail);
+ retval = ___cds_wfcq_dequeue_with_state_blocking(head, tail, state);
_cds_wfcq_dequeue_unlock(head, tail);
return retval;
}
+/*
+ * cds_wfcq_dequeue_blocking: dequeue node from queue.
+ *
+ * Same as cds_wfcq_dequeue_blocking, but without saving state.
+ */
+static inline struct cds_wfcq_node *
+_cds_wfcq_dequeue_blocking(struct cds_wfcq_head *head,
+ struct cds_wfcq_tail *tail)
+{
+ return _cds_wfcq_dequeue_with_state_blocking(head, tail, NULL);
+}
+
/*
* cds_wfcq_splice_blocking: enqueue all src_q nodes at the end of dest_q.
*
CDS_WFCQ_RET_SRC_EMPTY = 2,
};
+enum cds_wfcq_state {
+ CDS_WFCQ_STATE_LAST = (1U << 0),
+};
+
struct cds_wfcq_node {
struct cds_wfcq_node *next;
};
/* Locking performed within cds_wfcq calls. */
#define cds_wfcq_dequeue_blocking _cds_wfcq_dequeue_blocking
+#define cds_wfcq_dequeue_with_state_blocking \
+ _cds_wfcq_dequeue_with_state_blocking
#define cds_wfcq_splice_blocking _cds_wfcq_splice_blocking
#define cds_wfcq_first_blocking _cds_wfcq_first_blocking
#define cds_wfcq_next_blocking _cds_wfcq_next_blocking
/* Locking ensured by caller by holding cds_wfcq_dequeue_lock() */
#define __cds_wfcq_dequeue_blocking ___cds_wfcq_dequeue_blocking
+#define __cds_wfcq_dequeue_with_state_blocking \
+ ___cds_wfcq_dequeue_with_state_blocking
#define __cds_wfcq_splice_blocking ___cds_wfcq_splice_blocking
#define __cds_wfcq_first_blocking ___cds_wfcq_first_blocking
#define __cds_wfcq_next_blocking ___cds_wfcq_next_blocking
* need to block. splice returns nonzero if it needs to block.
*/
#define __cds_wfcq_dequeue_nonblocking ___cds_wfcq_dequeue_nonblocking
+#define __cds_wfcq_dequeue_with_state_nonblocking \
+ ___cds_wfcq_dequeue_with_state_nonblocking
#define __cds_wfcq_splice_nonblocking ___cds_wfcq_splice_nonblocking
#define __cds_wfcq_first_nonblocking ___cds_wfcq_first_nonblocking
#define __cds_wfcq_next_nonblocking ___cds_wfcq_next_nonblocking
struct cds_wfcq_head *head,
struct cds_wfcq_tail *tail);
+/*
+ * cds_wfcq_dequeue_with_state_blocking: dequeue with state.
+ *
+ * Same as cds_wfcq_dequeue_blocking, but saves whether dequeueing the
+ * last node of the queue into state (CDS_WFCQ_STATE_LAST).
+ */
+extern struct cds_wfcq_node *cds_wfcq_dequeue_with_state_blocking(
+ struct cds_wfcq_head *head,
+ struct cds_wfcq_tail *tail,
+ int *state);
+
/*
* cds_wfcq_splice_blocking: enqueue all src_q nodes at the end of dest_q.
*
struct cds_wfcq_head *head,
struct cds_wfcq_tail *tail);
+/*
+ * __cds_wfcq_dequeue_with_state_blocking: dequeue with state.
+ *
+ * Same as __cds_wfcq_dequeue_blocking, but saves whether dequeueing the
+ * last node of the queue into state (CDS_WFCQ_STATE_LAST).
+ */
+extern struct cds_wfcq_node *__cds_wfcq_dequeue_with_state_blocking(
+ struct cds_wfcq_head *head,
+ struct cds_wfcq_tail *tail,
+ int *state);
+
/*
* __cds_wfcq_dequeue_nonblocking: dequeue a node from a wait-free queue.
*
struct cds_wfcq_head *head,
struct cds_wfcq_tail *tail);
+/*
+ * __cds_wfcq_dequeue_with_state_blocking: dequeue with state.
+ *
+ * Same as __cds_wfcq_dequeue_nonblocking, but saves whether dequeueing
+ * the last node of the queue into state (CDS_WFCQ_STATE_LAST).
+ */
+extern struct cds_wfcq_node *__cds_wfcq_dequeue_with_state_nonblocking(
+ struct cds_wfcq_head *head,
+ struct cds_wfcq_tail *tail,
+ int *state);
+
/*
* __cds_wfcq_splice_blocking: enqueue all src_q nodes at the end of dest_q.
*
return _cds_wfcq_dequeue_blocking(head, tail);
}
+struct cds_wfcq_node *cds_wfcq_dequeue_with_state_blocking(
+ struct cds_wfcq_head *head,
+ struct cds_wfcq_tail *tail,
+ int *state)
+{
+ return _cds_wfcq_dequeue_with_state_blocking(head, tail, state);
+}
+
enum cds_wfcq_ret cds_wfcq_splice_blocking(
struct cds_wfcq_head *dest_q_head,
struct cds_wfcq_tail *dest_q_tail,
return ___cds_wfcq_dequeue_blocking(head, tail);
}
+struct cds_wfcq_node *__cds_wfcq_dequeue_with_state_blocking(
+ struct cds_wfcq_head *head,
+ struct cds_wfcq_tail *tail,
+ int *state)
+{
+ return ___cds_wfcq_dequeue_with_state_blocking(head, tail, state);
+}
+
struct cds_wfcq_node *__cds_wfcq_dequeue_nonblocking(
struct cds_wfcq_head *head,
struct cds_wfcq_tail *tail)
return ___cds_wfcq_dequeue_nonblocking(head, tail);
}
+struct cds_wfcq_node *__cds_wfcq_dequeue_with_state_nonblocking(
+ struct cds_wfcq_head *head,
+ struct cds_wfcq_tail *tail,
+ int *state)
+{
+ return ___cds_wfcq_dequeue_with_state_nonblocking(head, tail, state);
+}
+
enum cds_wfcq_ret __cds_wfcq_splice_blocking(
struct cds_wfcq_head *dest_q_head,
struct cds_wfcq_tail *dest_q_tail,
projects / urcu.git / commitdiff
