Skip to contentSkip to conversation

urcu stack and queues updates and documentation

DISCUSSION Paul E. McKenney 2 participants 6 messages Oct 16, 2012 – Oct 23, 2012 6 messages not in the archive

lore
Share & tools
lore

A message that is not in the archive (sent off-list or not yet received): 20121014175332.GA2947@Krystal

#1 lore raw
Quoted 5 lines · Mathieu Desnoyers

Hi Paul!

I know you are currently looking at documentation of urcu data structures. I did quite a bit of work in that area these past days. Here is my plan:

Actually, I diverted to the atomic operations, given that the stack/queue API seems to be in flux. ;-)

Quoted 11 lines

1) I would like to deprecate, at some point, rculfqueue, wfqueue, and rculfstack.

2) For wfqueue, we replace it by wfcqueue, currently in the urcu master branch.

3) For rculfstack, we replace it by lfstack available here (volatile branch):

git://git.dorsal.polymtl.ca/~compudj/userspace-rcu
branch: urcu/lfstack

I probably have to document them to have any chance of having an opinion, other than my usual advice to avoid disrupting users of the old interfaces.

Quoted 5 lines

4) I did documentation improvements (and implemented pop_all as well as empty, and iterators) for wfstack here (volatile branch too):

git://git.dorsal.polymtl.ca/~compudj/userspace-rcu
branch: urcu/wfstack

I will be very happy to take advantage of this. ;-)

Quoted 3 lines

5) The last one to look into would be rculfqueue. I'd really like to create a lfcqueue derived from wfcqueue if possible. It's the next item on my todo list this weekend.

The piece I am missing is ABA avoidance. Or is this the approach that assumes a single dequeuer?

Thanx, Paul

Quoted 12 lines

Thoughts ?

Thanks,

Mathieu

Signature · 4 lines
Mathieu Desnoyers
Operating System Efficiency R&D Consultant
EfficiOS Inc.
http://www.efficios.com

A message that is not in the archive (sent off-list or not yet received): [email protected]

#3 lore raw
Quoted 9 lines · * Paul E. McKenney ([email protected]) wrote:
Quoted 5 lines · Mathieu Desnoyers

Hi Paul!

I know you are currently looking at documentation of urcu data structures. I did quite a bit of work in that area these past days. Here is my plan:

Actually, I diverted to the atomic operations, given that the stack/queue API seems to be in flux. ;-)

That sounds like a wise decision ;-)

Quoted 7 lines
Quoted 7 lines

1) I would like to deprecate, at some point, rculfqueue, wfqueue, and rculfstack.

2) For wfqueue, we replace it by wfcqueue, currently in the urcu master branch.

Quoted 8 lines
Quoted 5 lines

3) For rculfstack, we replace it by lfstack available here (volatile branch):

git://git.dorsal.polymtl.ca/~compudj/userspace-rcu
branch: urcu/lfstack

I probably have to document them to have any chance of having an opinion, other than my usual advice to avoid disrupting users of the old interfaces.

My general plan is to leave the old interfaces in place, marking them as
"deprecated" by adding a __attribute__((deprecated("This interface is deprecated. Please refer to urcu/xxxqueue.h for its replacement."))). Then we'll be able to drop the deprecated interfaces in a couple of
versions.

Quoted 8 lines
Quoted 6 lines

4) I did documentation improvements (and implemented pop_all as well as empty, and iterators) for wfstack here (volatile branch too):

git://git.dorsal.polymtl.ca/~compudj/userspace-rcu
branch: urcu/wfstack

I will be very happy to take advantage of this. ;-)

I wonder how we should move forward with these ? I could pull the urcu/wfstack, urcu/lfstack commits into master with your approval, and mark rculfstack and wfqueue as deprecated. wfstack is simply extended. I would wait a bit before deciding anything wrt rculfqueue. Thoughts ?

Quoted 7 lines
Quoted 4 lines

5) The last one to look into would be rculfqueue. I'd really like to create a lfcqueue derived from wfcqueue if possible. It's the next item on my todo list this weekend.

The piece I am missing is ABA avoidance. Or is this the approach that assumes a single dequeuer?

If we look at the big picture, the main difference between the "wf" and "lf" approaches, both for stack and queue, is that "wf" requires traversal to busy-wait when it sees the intermediate NULL pointer state. This allows wait-free push/enqueue with xchg. The "lf" approach ensures that a simple traversal can be done on the structures, at the expense of requiring a cmpxchg on the enqueue/push.

Luckily, for stacks, the nature of stacks makes "push" ABA-proof (see the documentation in the code), even if we use cmpxchg.

Unluckily, for queues, using cmpxchg on enqueue is ABA-prone. dequeue is ABA-prone too. Moreover, we need to have existance guarantees, so an enqueue does not attempt to do a cmpxchg on the next pointer of a node that has already been dequeued and reallocated. So, one approach is to always rely on RCU, and require the RCU read-side lock to be held around enqueue, and around dequeue. Now, the question is: can we rely on other, non-rcu techniques, to protect lfqueue against ABA and offer existance guarantees ?

A single-dequeuer approach would unfortunately not be sufficient, because enqueue is ABA-prone, and due to lack of existance guarantees for the node we are about to append after: if we have multiple enqueuers and a single dequeuer, one enqueue could suffer from ABA, and try to touch reallocated memory, due to dequeue+reallocation of a node.

Even forcing single-enqueuer/single-dequeuer would not suffice: if, between the moment we get the tail node we plan to append after, and the moment we perform the cmpxchg to that node next pointer, the node is dequeued and freed, we would be touching freed memory (corruption).

Therefore, that would require a single mutex on _both_ enqueue and dequeue operations, which really defeats the purpose of a lock-free queue.

So my current understanding is that we might have to stay with a RCU lfcqueue, requiring RCU read-side lock to be held for enqueue and dequeue, and requiring to wait for a grace period to elapse before freeing the memory returned by dequeue. The benefit of using rculfcqueue over wfcqueue is that traversal of the nodes, and dequeue, don't need to busy-loop on NULL next pointers.

Thoughts ?

Thanks!

Mathieu

Quoted 16 lines

Thanx, Paul

Quoted 12 lines

Thoughts ?

Thanks,

Mathieu

Signature · 4 lines
Mathieu Desnoyers
Operating System Efficiency R&D Consultant
EfficiOS Inc.
http://www.efficios.com
Signature · 4 lines
Mathieu Desnoyers
Operating System Efficiency R&D Consultant
EfficiOS Inc.
http://www.efficios.com

A message that is not in the archive (sent off-list or not yet received): 20121017151946.GA14514@Krystal

#5 lore raw
Quoted 25 lines · Mathieu Desnoyers
Quoted 9 lines · * Paul E. McKenney ([email protected]) wrote:
Quoted 5 lines · Mathieu Desnoyers

Hi Paul!

I know you are currently looking at documentation of urcu data structures. I did quite a bit of work in that area these past days. Here is my plan:

Actually, I diverted to the atomic operations, given that the stack/queue API seems to be in flux. ;-)

That sounds like a wise decision ;-)

Quoted 12 lines
Quoted 11 lines

1) I would like to deprecate, at some point, rculfqueue, wfqueue, and rculfstack.

2) For wfqueue, we replace it by wfcqueue, currently in the urcu master branch.

3) For rculfstack, we replace it by lfstack available here (volatile branch):

git://git.dorsal.polymtl.ca/~compudj/userspace-rcu
branch: urcu/lfstack

Quoted 7 lines
Quoted 2 lines

I probably have to document them to have any chance of having an opinion, other than my usual advice to avoid disrupting users of the old interfaces.

My general plan is to leave the old interfaces in place, marking them as
"deprecated" by adding a __attribute__((deprecated("This interface is deprecated. Please refer to urcu/xxxqueue.h for its replacement."))). Then we'll be able to drop the deprecated interfaces in a couple of
versions.

Fair enough. Should enough users protest, we can of course leave them in place.

Quoted 6 lines
Quoted 6 lines
Quoted 5 lines

4) I did documentation improvements (and implemented pop_all as well as empty, and iterators) for wfstack here (volatile branch too):

git://git.dorsal.polymtl.ca/~compudj/userspace-rcu
branch: urcu/wfstack

Quoted 6 lines
Quoted 1 line

I will be very happy to take advantage of this. ;-)

I wonder how we should move forward with these ? I could pull the urcu/wfstack, urcu/lfstack commits into master with your approval, and mark rculfstack and wfqueue as deprecated. wfstack is simply extended. I would wait a bit before deciding anything wrt rculfqueue. Thoughts ?

I would be in favor of pulling them in -- we can fix if need be. That said, I am not so sure that getting rid of wfqueue is a good idea, given your analysis below.

Quoted 41 lines
Quoted 6 lines
Quoted 3 lines

5) The last one to look into would be rculfqueue. I'd really like to create a lfcqueue derived from wfcqueue if possible. It's the next item on my todo list this weekend.

The piece I am missing is ABA avoidance. Or is this the approach that assumes a single dequeuer?

If we look at the big picture, the main difference between the "wf" and "lf" approaches, both for stack and queue, is that "wf" requires traversal to busy-wait when it sees the intermediate NULL pointer state. This allows wait-free push/enqueue with xchg. The "lf" approach ensures that a simple traversal can be done on the structures, at the expense of requiring a cmpxchg on the enqueue/push.

Luckily, for stacks, the nature of stacks makes "push" ABA-proof (see the documentation in the code), even if we use cmpxchg.

Unluckily, for queues, using cmpxchg on enqueue is ABA-prone. dequeue is ABA-prone too. Moreover, we need to have existance guarantees, so an enqueue does not attempt to do a cmpxchg on the next pointer of a node that has already been dequeued and reallocated. So, one approach is to always rely on RCU, and require the RCU read-side lock to be held around enqueue, and around dequeue. Now, the question is: can we rely on other, non-rcu techniques, to protect lfqueue against ABA and offer existance guarantees ?

A single-dequeuer approach would unfortunately not be sufficient, because enqueue is ABA-prone, and due to lack of existance guarantees for the node we are about to append after: if we have multiple enqueuers and a single dequeuer, one enqueue could suffer from ABA, and try to touch reallocated memory, due to dequeue+reallocation of a node.

Even forcing single-enqueuer/single-dequeuer would not suffice: if, between the moment we get the tail node we plan to append after, and the moment we perform the cmpxchg to that node next pointer, the node is dequeued and freed, we would be touching freed memory (corruption).

Therefore, that would require a single mutex on _both_ enqueue and dequeue operations, which really defeats the purpose of a lock-free queue.

Quoted 8 lines

So my current understanding is that we might have to stay with a RCU lfcqueue, requiring RCU read-side lock to be held for enqueue and dequeue, and requiring to wait for a grace period to elapse before freeing the memory returned by dequeue. The benefit of using rculfcqueue over wfcqueue is that traversal of the nodes, and dequeue, don't need to busy-loop on NULL next pointers.

Thoughts ?

Heh! It would indeed seem that we didn't think through the conversion from wfqueue as thoroughly as we might have. ;-)

Thanx, Paul

Quoted 27 lines

Thanks!

Mathieu

Quoted 16 lines

Thanx, Paul

Quoted 12 lines

Thoughts ?

Thanks,

Mathieu

Signature · 4 lines
Mathieu Desnoyers
Operating System Efficiency R&D Consultant
EfficiOS Inc.
http://www.efficios.com
Signature · 4 lines
Mathieu Desnoyers
Operating System Efficiency R&D Consultant
EfficiOS Inc.
http://www.efficios.com

A message that is not in the archive (sent off-list or not yet received): [email protected]

#7 lore raw
Quoted 29 lines · * Paul E. McKenney ([email protected]) wrote:
Quoted 28 lines · Mathieu Desnoyers
Quoted 9 lines · * Paul E. McKenney ([email protected]) wrote:
Quoted 5 lines · Mathieu Desnoyers

Hi Paul!

I know you are currently looking at documentation of urcu data structures. I did quite a bit of work in that area these past days. Here is my plan:

Actually, I diverted to the atomic operations, given that the stack/queue API seems to be in flux. ;-)

That sounds like a wise decision ;-)

Quoted 14 lines
Quoted 11 lines

1) I would like to deprecate, at some point, rculfqueue, wfqueue, and rculfstack.

2) For wfqueue, we replace it by wfcqueue, currently in the urcu master branch.

3) For rculfstack, we replace it by lfstack available here (volatile branch):

git://git.dorsal.polymtl.ca/~compudj/userspace-rcu
branch: urcu/lfstack

I probably have to document them to have any chance of having an opinion, other than my usual advice to avoid disrupting users of the old interfaces.

Quoted 7 lines
Quoted 4 lines

My general plan is to leave the old interfaces in place, marking them as
"deprecated" by adding a __attribute__((deprecated("This interface is deprecated. Please refer to urcu/xxxqueue.h for its replacement."))). Then we'll be able to drop the deprecated interfaces in a couple of
versions.

Fair enough. Should enough users protest, we can of course leave them in place.

OK.

Quoted 9 lines
Quoted 9 lines
Quoted 8 lines
Quoted 6 lines

4) I did documentation improvements (and implemented pop_all as well as empty, and iterators) for wfstack here (volatile branch too):

git://git.dorsal.polymtl.ca/~compudj/userspace-rcu
branch: urcu/wfstack

I will be very happy to take advantage of this. ;-)

Quoted 8 lines
Quoted 4 lines

I wonder how we should move forward with these ? I could pull the urcu/wfstack, urcu/lfstack commits into master with your approval, and mark rculfstack and wfqueue as deprecated. wfstack is simply extended. I would wait a bit before deciding anything wrt rculfqueue. Thoughts ?

I would be in favor of pulling them in -- we can fix if need be. That said, I am not so sure that getting rid of wfqueue is a good idea, given your analysis below.

My analysis below is about rculfqueue, not wfqueue. I think you got both of them mixed up.

Quoted 49 lines
Quoted 49 lines
Quoted 7 lines
Quoted 4 lines

5) The last one to look into would be rculfqueue. I'd really like to create a lfcqueue derived from wfcqueue if possible. It's the next item on my todo list this weekend.

The piece I am missing is ABA avoidance. Or is this the approach that assumes a single dequeuer?

If we look at the big picture, the main difference between the "wf" and "lf" approaches, both for stack and queue, is that "wf" requires traversal to busy-wait when it sees the intermediate NULL pointer state. This allows wait-free push/enqueue with xchg. The "lf" approach ensures that a simple traversal can be done on the structures, at the expense of requiring a cmpxchg on the enqueue/push.

Luckily, for stacks, the nature of stacks makes "push" ABA-proof (see the documentation in the code), even if we use cmpxchg.

Unluckily, for queues, using cmpxchg on enqueue is ABA-prone. dequeue is ABA-prone too. Moreover, we need to have existance guarantees, so an enqueue does not attempt to do a cmpxchg on the next pointer of a node that has already been dequeued and reallocated. So, one approach is to always rely on RCU, and require the RCU read-side lock to be held around enqueue, and around dequeue. Now, the question is: can we rely on other, non-rcu techniques, to protect lfqueue against ABA and offer existance guarantees ?

A single-dequeuer approach would unfortunately not be sufficient, because enqueue is ABA-prone, and due to lack of existance guarantees for the node we are about to append after: if we have multiple enqueuers and a single dequeuer, one enqueue could suffer from ABA, and try to touch reallocated memory, due to dequeue+reallocation of a node.

Even forcing single-enqueuer/single-dequeuer would not suffice: if, between the moment we get the tail node we plan to append after, and the moment we perform the cmpxchg to that node next pointer, the node is dequeued and freed, we would be touching freed memory (corruption).

Therefore, that would require a single mutex on _both_ enqueue and dequeue operations, which really defeats the purpose of a lock-free queue.

So my current understanding is that we might have to stay with a RCU lfcqueue, requiring RCU read-side lock to be held for enqueue and dequeue, and requiring to wait for a grace period to elapse before freeing the memory returned by dequeue. The benefit of using rculfcqueue over wfcqueue is that traversal of the nodes, and dequeue, don't need to busy-loop on NULL next pointers.

Quoted 4 lines
Quoted 1 line

Thoughts ?

Heh! It would indeed seem that we didn't think through the conversion from wfqueue as thoroughly as we might have. ;-)

The transition from wfqueue to wfcqueue does not pose any problem. It's transition from rculfqueue that is the concern here.

Thanks,

Mathieu

Quoted 36 lines

Thanx, Paul

Quoted 13 lines

Thanks!

Mathieu

Quoted 9 lines

Thanx, Paul

Quoted 6 lines

Thoughts ?

Thanks,

Mathieu

Quoted 14 lines
Quoted 7 lines
Quoted 6 lines
Signature · 4 lines
Mathieu Desnoyers
Operating System Efficiency R&D Consultant
EfficiOS Inc.
http://www.efficios.com
Signature · 4 lines
Mathieu Desnoyers
Operating System Efficiency R&D Consultant
EfficiOS Inc.
http://www.efficios.com

_______________________________________________
lttng-dev mailing list
[email protected]
http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev

Signature · 4 lines
Mathieu Desnoyers
Operating System Efficiency R&D Consultant
EfficiOS Inc.
http://www.efficios.com

A message that is not in the archive (sent off-list or not yet received): 20121023021202.GB13737@Krystal

#9 lore raw
Quoted 54 lines · * Mathieu Desnoyers ([email protected]) wrote:
Quoted 29 lines · * Paul E. McKenney ([email protected]) wrote:
Quoted 28 lines · Mathieu Desnoyers
Quoted 9 lines · * Paul E. McKenney ([email protected]) wrote:
Quoted 5 lines · Mathieu Desnoyers

Hi Paul!

I know you are currently looking at documentation of urcu data structures. I did quite a bit of work in that area these past days. Here is my plan:

Actually, I diverted to the atomic operations, given that the stack/queue API seems to be in flux. ;-)

That sounds like a wise decision ;-)

Quoted 14 lines
Quoted 11 lines

1) I would like to deprecate, at some point, rculfqueue, wfqueue, and rculfstack.

2) For wfqueue, we replace it by wfcqueue, currently in the urcu master branch.

3) For rculfstack, we replace it by lfstack available here (volatile branch):

git://git.dorsal.polymtl.ca/~compudj/userspace-rcu
branch: urcu/lfstack

I probably have to document them to have any chance of having an opinion, other than my usual advice to avoid disrupting users of the old interfaces.

Quoted 7 lines
Quoted 4 lines

My general plan is to leave the old interfaces in place, marking them as
"deprecated" by adding a __attribute__((deprecated("This interface is deprecated. Please refer to urcu/xxxqueue.h for its replacement."))). Then we'll be able to drop the deprecated interfaces in a couple of
versions.

Fair enough. Should enough users protest, we can of course leave them in place.

OK.

Quoted 14 lines
Quoted 13 lines
Quoted 8 lines
Quoted 6 lines

4) I did documentation improvements (and implemented pop_all as well as empty, and iterators) for wfstack here (volatile branch too):

git://git.dorsal.polymtl.ca/~compudj/userspace-rcu
branch: urcu/wfstack

I will be very happy to take advantage of this. ;-)

I wonder how we should move forward with these ? I could pull the urcu/wfstack, urcu/lfstack commits into master with your approval, and mark rculfstack and wfqueue as deprecated. wfstack is simply extended. I would wait a bit before deciding anything wrt rculfqueue. Thoughts ?

Quoted 6 lines
Quoted 3 lines

I would be in favor of pulling them in -- we can fix if need be. That said, I am not so sure that getting rid of wfqueue is a good idea, given your analysis below.

My analysis below is about rculfqueue, not wfqueue. I think you got both of them mixed up.

I just merged the content of the urcu/wfstack, urcu/lfstack, urcu/wfcqueue branches into master.

As explained below, urcu/rculfqueue needs more work.

Thanks!

Mathieu

Quoted 109 lines
Quoted 50 lines
Quoted 50 lines
Quoted 8 lines
Quoted 5 lines

5) The last one to look into would be rculfqueue. I'd really like to create a lfcqueue derived from wfcqueue if possible. It's the next item on my todo list this weekend.

The piece I am missing is ABA avoidance. Or is this the approach that assumes a single dequeuer?

If we look at the big picture, the main difference between the "wf" and "lf" approaches, both for stack and queue, is that "wf" requires traversal to busy-wait when it sees the intermediate NULL pointer state. This allows wait-free push/enqueue with xchg. The "lf" approach ensures that a simple traversal can be done on the structures, at the expense of requiring a cmpxchg on the enqueue/push.

Luckily, for stacks, the nature of stacks makes "push" ABA-proof (see the documentation in the code), even if we use cmpxchg.

Unluckily, for queues, using cmpxchg on enqueue is ABA-prone. dequeue is ABA-prone too. Moreover, we need to have existance guarantees, so an enqueue does not attempt to do a cmpxchg on the next pointer of a node that has already been dequeued and reallocated. So, one approach is to always rely on RCU, and require the RCU read-side lock to be held around enqueue, and around dequeue. Now, the question is: can we rely on other, non-rcu techniques, to protect lfqueue against ABA and offer existance guarantees ?

A single-dequeuer approach would unfortunately not be sufficient, because enqueue is ABA-prone, and due to lack of existance guarantees for the node we are about to append after: if we have multiple enqueuers and a single dequeuer, one enqueue could suffer from ABA, and try to touch reallocated memory, due to dequeue+reallocation of a node.

Even forcing single-enqueuer/single-dequeuer would not suffice: if, between the moment we get the tail node we plan to append after, and the moment we perform the cmpxchg to that node next pointer, the node is dequeued and freed, we would be touching freed memory (corruption).

Therefore, that would require a single mutex on _both_ enqueue and dequeue operations, which really defeats the purpose of a lock-free queue.

So my current understanding is that we might have to stay with a RCU lfcqueue, requiring RCU read-side lock to be held for enqueue and dequeue, and requiring to wait for a grace period to elapse before freeing the memory returned by dequeue. The benefit of using rculfcqueue over wfcqueue is that traversal of the nodes, and dequeue, don't need to busy-loop on NULL next pointers.

Quoted 4 lines
Quoted 1 line

Thoughts ?

Heh! It would indeed seem that we didn't think through the conversion from wfqueue as thoroughly as we might have. ;-)

The transition from wfqueue to wfcqueue does not pose any problem. It's transition from rculfqueue that is the concern here.

Thanks,

Mathieu

Quoted 36 lines

Thanx, Paul

Quoted 13 lines

Thanks!

Mathieu

Quoted 9 lines

Thanx, Paul

Quoted 6 lines

Thoughts ?

Thanks,

Mathieu

Quoted 14 lines
Quoted 7 lines
Quoted 6 lines
Signature · 4 lines
Mathieu Desnoyers
Operating System Efficiency R&D Consultant
EfficiOS Inc.
http://www.efficios.com
Signature · 4 lines
Mathieu Desnoyers
Operating System Efficiency R&D Consultant
EfficiOS Inc.
http://www.efficios.com

_______________________________________________
lttng-dev mailing list
[email protected]
http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev

Signature · 9 lines
Mathieu Desnoyers
Operating System Efficiency R&D Consultant
EfficiOS Inc.
http://www.efficios.com

_______________________________________________
lttng-dev mailing list
[email protected]
http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev
Signature · 4 lines
Mathieu Desnoyers
Operating System Efficiency R&D Consultant
EfficiOS Inc.
http://www.efficios.com

A message that is not in the archive (sent off-list or not yet received): 20121023122926.GA20944@Krystal

#11 lore raw
Quoted 36 lines · * Mathieu Desnoyers ([email protected]) wrote:
Quoted 35 lines · * Mathieu Desnoyers ([email protected]) wrote:
Quoted 34 lines · * Paul E. McKenney ([email protected]) wrote:
Quoted 32 lines · Mathieu Desnoyers
Quoted 9 lines · * Paul E. McKenney ([email protected]) wrote:
Quoted 5 lines · Mathieu Desnoyers

Hi Paul!

I know you are currently looking at documentation of urcu data structures. I did quite a bit of work in that area these past days. Here is my plan:

Actually, I diverted to the atomic operations, given that the stack/queue API seems to be in flux. ;-)

That sounds like a wise decision ;-)

Quoted 6 lines
Quoted 6 lines

1) I would like to deprecate, at some point, rculfqueue, wfqueue, and rculfstack.

2) For wfqueue, we replace it by wfcqueue, currently in the urcu master branch.

Quoted 8 lines
Quoted 5 lines

3) For rculfstack, we replace it by lfstack available here (volatile branch):

git://git.dorsal.polymtl.ca/~compudj/userspace-rcu
branch: urcu/lfstack

I probably have to document them to have any chance of having an opinion, other than my usual advice to avoid disrupting users of the old interfaces.

My general plan is to leave the old interfaces in place, marking them as
"deprecated" by adding a __attribute__((deprecated("This interface is deprecated. Please refer to urcu/xxxqueue.h for its replacement."))). Then we'll be able to drop the deprecated interfaces in a couple of
versions.

Quoted 4 lines
Quoted 4 lines
Quoted 2 lines

Fair enough. Should enough users protest, we can of course leave them in place.

OK.

FYI, wfqueue and rculfstack are now deprecated:

commit 147485105cf7b5c8ea96d7f68df973b9c5a94e8e

Author: Mathieu Desnoyers <[email protected]>
Date:   Tue Oct 23 08:43:33 2012 -0400

Deprecate wfqueue

Replaced by "wfcqueue", which has a semantic that allows placing head and tail on different cache lines, and does not allocate memory internally. wfqueue users can easily migrate to wfcqueue.

We choose to deprecate wfqueue rather than reimplementing it on top of wfcqueue to ensure we keep strong ABI compatibility for existing wfqueue users.

commit d89ec7629b8cafdc12e619cf5f07ceb5b0279275

Author: Mathieu Desnoyers <[email protected]>
Date:   Tue Oct 23 08:36:42 2012 -0400

Deprecate rculfstack

Replaced by "lfstack", which has a less restrictive semantic, and covers rculfstack completely.

wfstack is kept as-is (and has been recently extended with pop_all(), iterators, and empty() APIs). rculfqueue needs more work. I'd be tempted not to detail rculfqueue in the upcoming LWN article, but detailing wfqueue, wfstack and lfstack should be fine.

Thanks!

Mathieu

Signature · 4 lines
Mathieu Desnoyers
Operating System Efficiency R&D Consultant
EfficiOS Inc.
http://www.efficios.com