| /* Copyright (c) 2010 The Regents of the University of California |
| * Barret Rhoden <brho@cs.berkeley.edu> |
| * See LICENSE for details. |
| * |
| * Multi-producer, multi-consumer queues. Designed initially for an untrusted |
| * consumer. |
| */ |
| |
| #pragma once |
| |
| #include <ros/common.h> |
| #include <ros/bcq_struct.h> |
| #include <string.h> |
| |
| /* Pain in the ass includes. Glibc has an atomic.h, and eventually userspace |
| * will have to deal with the clobbering. */ |
| #ifdef ROS_KERNEL |
| #include <atomic.h> |
| /* dequeue uses relax_vc, which is user-only. Some kernel tests call dequeue.*/ |
| #define cpu_relax_vc(x) cpu_relax() |
| #else |
| #include <parlib/arch/atomic.h> |
| #include <parlib/vcore.h> |
| #endif /* ROS_KERNEL */ |
| |
| /* Bounded Concurrent Queues, untrusted consumer |
| * |
| * This is a producer/consumer circular buffer, in which the producer never |
| * blocks and does not need to trust the data structure (which is writable by |
| * the consumer). |
| * |
| * A producer enqueues an item, based on the indexes of the producer and |
| * consumer. Enqueue cannot block, but can fail if the queue is full or if it |
| * fails to enqueue after a certain amount of tries. |
| * |
| * prod_idx: the next item to be produced |
| * cons_pvt_idx: the next item a consumer can claim |
| * cons_pub_idx: the last item (farthest left / oldest) that hasn't been |
| * consumed/made ready to be clobbered by the producer (it is |
| * what the consumer produces). Once all are clear, this will be |
| * the same as the prod_idx. |
| * |
| * The number of free slots in the buffer is: BufSize - (prod_idx - cons_pub) |
| * The power-of-two nature of the number of elements makes this work when it |
| * wraps around, just like with Xen. Check it yourself with a counter of 8 and |
| * bufsizes of 8 and 4. |
| * |
| * |
| * General plan: |
| * |
| * Producers compete among themselves, using the prod_idx, to get a free spot. |
| * Once they have a spot, they fill in the item, and then toggle the "ready for |
| * consumption" bool for a client. If it cannot find one after a number of |
| * tries, it simply fails (could be a DoS from the client). |
| * |
| * Consumers fight with their private index, which they use to determine who is |
| * consuming which item. If there is an unconsumed item, they try to advance |
| * the pvt counter. If they succeed, they can consume the item. The item |
| * might not be there yet, so they must spin until it is there. Then, the |
| * consumer copies the item out, and clears the bool (rdy_for_cons). |
| * |
| * At this point, the consumer needs to make sure the pub_idx is advanced |
| * enough so the producer knows the item is free. If pub_idx was their item, |
| * they move it forward to the next item. If it is not, currently, they spin |
| * and wait until the previous consumer finishes, and then move it forward. |
| * This isn't ideal, and we can deal with this in the future. |
| * |
| * Enqueue will enqueue the item pointed to by elem. Dequeue will write an |
| * item into the memory pointed to by elem. |
| * |
| * The number of items must be a power of two. In the future, we'll probably |
| * use Xen's rounding macros. Not using powers of two is a pain, esp with mods |
| * of negative numbers. |
| * |
| * Here's how to use it: |
| * |
| * DEFINE_BCQ_TYPES(my_name, my_type, my_size); |
| * struct my_name_bcq some_bcq; |
| * bcq_init(&some_bcq, my_type, my_size); |
| * |
| * bcq_enqueue(&some_bcq, &some_my_type, my_size, num_fails_okay); |
| * bcq_dequeue(&some_bcq, &some_my_type, my_size); |
| * |
| * They both return 0 on success, or some error code on failure. |
| * |
| * TODO later: |
| * Automatically round up. |
| * |
| * Watch out for ABA. Could use ctrs in the top of the indexes. Not really an |
| * issue, since that would be a wraparound. |
| * |
| * Consumers could also just set their bit, and have whoever has the pub_idx |
| * right before them be the one to advance it all the way up. |
| * |
| * Using uint32_t for now, since that's the comp_and_swap we have. We'll |
| * probably get other sizes once we're sure we like the current one. */ |
| |
| #if 0 // Defined in the included header |
| |
| struct bcq_header { |
| uint32_t prod_idx; /* next to be produced in */ |
| uint32_t cons_pub_idx; /* last completely consumed */ |
| uint32_t cons_pvt_idx; /* last a consumer has dibs on */ |
| }; |
| |
| // This is there too: |
| #define DEFINE_BCQ_TYPES(__name, __elem_t, __num_elems) |
| |
| #endif |
| |
| /* Functions */ |
| #define bcq_init(_bcq, _ele_type, _num_elems) \ |
| ({ \ |
| memset((_bcq), 0, sizeof(*(_bcq))); \ |
| assert((_num_elems) == ROUNDUPPWR2(_num_elems)); \ |
| }) |
| |
| /* Num empty buffer slots in the BCQ */ |
| #define BCQ_FREE_SLOTS(_p, _cp, _ne) ((_ne) - ((_p) - (_cp))) |
| |
| /* Really empty */ |
| #define BCQ_EMPTY(_p, _cp, _ne) ((_ne) == BCQ_FREE_SLOTS(_p, _cp, _ne)) |
| |
| /* All work claimed by a consumer */ |
| #define BCQ_NO_WORK(_p, _cpv) ((_p) == (_cpv)) |
| |
| /* Buffer full */ |
| #define BCQ_FULL(_p, _cp, _ne) (0 == BCQ_FREE_SLOTS(_p, _cp, _ne)) |
| |
| /* Figure out the slot you want, bail if it's full, or if you failed too many |
| * times, CAS to set the new prod. Fill yours in, toggle the bool. Sorry, the |
| * macro got a bit ugly, esp with the __retval hackery. */ |
| #define bcq_enqueue(_bcq, _elem, _num_elems, _num_fail) \ |
| ({ \ |
| uint32_t __prod, __new_prod, __cons_pub, __failctr = 0; \ |
| int __retval = 0; \ |
| do { \ |
| cmb(); \ |
| if (((_num_fail)) && (__failctr++ >= (_num_fail))) { \ |
| __retval = -EFAIL; \ |
| break; \ |
| } \ |
| __prod = (_bcq)->hdr.prod_idx; \ |
| __cons_pub = (_bcq)->hdr.cons_pub_idx; \ |
| if (BCQ_FULL(__prod, __cons_pub, (_num_elems))) { \ |
| __retval = -EBUSY; \ |
| break; \ |
| } \ |
| __new_prod = __prod + 1; \ |
| } while (!atomic_cas_u32(&(_bcq)->hdr.prod_idx, __prod, __new_prod)); \ |
| if (!__retval) { \ |
| /* from here out, __prod is the local __prod that we won */ \ |
| (_bcq)->wraps[__prod & ((_num_elems)-1)].elem = *(_elem); \ |
| wmb(); \ |
| (_bcq)->wraps[__prod & ((_num_elems)-1)].rdy_for_cons = TRUE; \ |
| } \ |
| __retval; \ |
| }) |
| |
| /* Similar to enqueue, spin afterwards til cons_pub is our element, then |
| * advance it. */ |
| #define bcq_dequeue(_bcq, _elem, _num_elems) \ |
| ({ \ |
| uint32_t __prod, __cons_pvt, __new_cons_pvt, __cons_pub; \ |
| int __retval = 0; \ |
| do { \ |
| cmb(); \ |
| __prod = (_bcq)->hdr.prod_idx; \ |
| __cons_pvt = (_bcq)->hdr.cons_pvt_idx; \ |
| if (BCQ_NO_WORK(__prod, __cons_pvt)) { \ |
| __retval = -EBUSY; \ |
| break; \ |
| } \ |
| __new_cons_pvt = (__cons_pvt + 1); \ |
| } while (!atomic_cas_u32(&(_bcq)->hdr.cons_pvt_idx, __cons_pvt, \ |
| __new_cons_pvt)); \ |
| if (!__retval) { \ |
| /* from here out, __cons_pvt is the local __cons_pvt that we */\ |
| /* won. wait for the producer to finish copying it in */ \ |
| while (!(_bcq)->wraps[__cons_pvt & ((_num_elems)-1)].rdy_for_cons) \ |
| cpu_relax(); \ |
| *(_elem) = (_bcq)->wraps[__cons_pvt & ((_num_elems)-1)].elem; \ |
| (_bcq)->wraps[__cons_pvt & ((_num_elems)-1)].rdy_for_cons = FALSE; \ |
| /* wait til we're the cons_pub, then advance it by one */ \ |
| while ((_bcq)->hdr.cons_pub_idx != __cons_pvt) \ |
| cpu_relax_vc(vcore_id()); \ |
| (_bcq)->hdr.cons_pub_idx = __cons_pvt + 1; \ |
| } \ |
| __retval; \ |
| }) |
| |
| /* Checks of a bcq is empty (meaning no work), instead of trying to dequeue */ |
| #define bcq_empty(_bcq) \ |
| BCQ_NO_WORK((_bcq)->hdr.prod_idx, (_bcq)->hdr.cons_pvt_idx) |
| |
| #define bcq_nr_full(_bcq) \ |
| ((_bcq)->hdr.prod_idx - (_bcq)->hdr.cons_pub_idx) |
