ring: add elem API

ring/common.go

@@ -17,6 +17,17 @@ func args(r *Ring, obj []unsafe.Pointer) (*C.struct_rte_ring,
 	return (*C.struct_rte_ring)(r), C.uintptr_t(uintptr(unsafe.Pointer(&obj[0]))), C.uint(len(obj))
 }
 
+func argsElem(r *Ring, objtable unsafe.Pointer, esize uintptr, n int) (*C.struct_rte_ring,
+	C.uint, C.uintptr_t, C.uint) {
+	return (*C.struct_rte_ring)(r), C.uint(esize), C.uintptr_t(uintptr(unsafe.Pointer(objtable))), C.uint(n)
+}
+
+func argsSliceElem(r *Ring, obj []unsafe.Pointer) (*C.struct_rte_ring,
+	C.uint, C.uintptr_t, C.uint) {
+	x, p, n := args(r, obj)
+	return x, C.uint(ptrSize), p, n
+}
+
 func ret(out C.struct_compound_int) (rc, n uint32) {
 	return uint32(out.rc), uint32(out.n)
 }

ring/dequeue.go

@@ -9,82 +9,79 @@ package ring
 #include <rte_memory.h>
 
 #include "ring.h"
-
-struct someptr {
-	void *p;
-};
 */
 import "C"
 
 import (
 	"unsafe"
 )
 
+const (
+	ptrSize = unsafe.Sizeof(unsafe.Pointer(nil))
+)
+
 // Dequeue dequeues single object from Ring.
 func (r *Ring) Dequeue() (unsafe.Pointer, bool) {
-	objs := []unsafe.Pointer{nil}
-	n, _ := r.DequeueBulk(objs)
-	return objs[0], n != 0
+	var p unsafe.Pointer
+	return p, r.DequeueElem(unsafe.Pointer(&p), ptrSize)
 }
 
 // ScDequeue dequeues single object from Ring.
 func (r *Ring) ScDequeue() (unsafe.Pointer, bool) {
-	objs := []unsafe.Pointer{nil}
-	n, _ := r.ScDequeueBulk(objs)
-	return objs[0], n != 0
+	var p unsafe.Pointer
+	return p, r.ScDequeueElem(unsafe.Pointer(&p), ptrSize)
 }
 
 // McDequeue dequeues single object from Ring.
 func (r *Ring) McDequeue() (unsafe.Pointer, bool) {
-	objs := []unsafe.Pointer{nil}
-	n, _ := r.McDequeueBulk(objs)
-	return objs[0], n != 0
+	var p unsafe.Pointer
+	return p, r.McDequeueElem(unsafe.Pointer(&p), ptrSize)
 }
 
 // McDequeueBulk dequeues objects into given slice of pointers.
 // Returns number of dequeued objects (either 0 or len(obj)) and
 // amount of remaining ring entries in the ring after the enqueue
 // operation has finished.
 func (r *Ring) McDequeueBulk(obj []unsafe.Pointer) (n, avail uint32) {
-	return ret(C.mc_dequeue_bulk(args(r, obj)))
+	return ret(C.mc_dequeue_bulk_elem(argsSliceElem(r, obj)))
 }
 
 // ScDequeueBulk dequeues objects into given slice of pointers.
 // Returns number of dequeued objects (either 0 or len(obj)) and
 // amount of remaining ring entries in the ring after the enqueue
 // operation has finished.
 func (r *Ring) ScDequeueBulk(obj []unsafe.Pointer) (n, avail uint32) {
-	return ret(C.sc_dequeue_bulk(args(r, obj)))
+	return ret(C.sc_dequeue_bulk_elem(argsSliceElem(r, obj)))
 }
 
 // DequeueBulk dequeues objects into given slice of pointers.
 // Returns number of dequeued objects (either 0 or len(obj)) and
 // amount of remaining ring entries in the ring after the enqueue
 // operation has finished.
 func (r *Ring) DequeueBulk(obj []unsafe.Pointer) (n, avail uint32) {
-	return ret(C.dequeue_bulk(args(r, obj)))
+	return ret(C.dequeue_bulk_elem(argsSliceElem(r, obj)))
 }
 
 // McDequeueBurst dequeues objects into given slice of pointers.
 // Returns number of dequeued objects and amount of remaining ring
 // entries in the ring after the enqueue operation has finished.
 // after the enqueue operation has finished.
 func (r *Ring) McDequeueBurst(obj []unsafe.Pointer) (n, avail uint32) {
-	return ret(C.mc_dequeue_burst(args(r, obj)))
+	return ret(C.mc_dequeue_burst_elem(argsSliceElem(r, obj)))
 }
 
 // ScDequeueBurst dequeues objects into given slice of pointers.
 // Returns number of dequeued objects and amount of remaining ring
 // entries in the ring after the enqueue operation has finished.
 // after the enqueue operation has finished.
 func (r *Ring) ScDequeueBurst(obj []unsafe.Pointer) (n, avail uint32) {
-	return ret(C.sc_dequeue_burst(args(r, obj)))
+	return ret(C.sc_dequeue_burst_elem(argsSliceElem(r, obj)))
 }
 
 // DequeueBurst dequeues objects into given slice of pointers.
 // Returns number of dequeued objects and amount of remaining ring
 // entries in the ring after the enqueue operation has finished.
 // after the enqueue operation has finished.
 func (r *Ring) DequeueBurst(obj []unsafe.Pointer) (n, avail uint32) {
-	return ret(C.dequeue_burst(args(r, obj)))
+	return ret(C.dequeue_burst_elem(argsSliceElem(r, obj)))
 }

ring/dequeue_elem.go

@@ -0,0 +1,80 @@
+package ring
+
+/*
+#include <stdlib.h>
+
+#include <rte_config.h>
+#include <rte_ring.h>
+#include <rte_errno.h>
+#include <rte_memory.h>
+
+#include "ring.h"
+*/
+import "C"
+
+import (
+	"unsafe"
+)
+
+// DequeueElem dequeues an object from given Ring.
+func (r *Ring) DequeueElem(obj unsafe.Pointer, esize uintptr) bool {
+	n, _ := r.DequeueBulkElem(obj, esize, 1)
+	return n != 0
+}
+
+// ScDequeueElem dequeues an object from given Ring.
+func (r *Ring) ScDequeueElem(obj unsafe.Pointer, esize uintptr) bool {
+	n, _ := r.ScDequeueBulkElem(obj, esize, 1)
+	return n != 0
+}
+
+// McDequeueElem dequeues an object from given Ring.
+func (r *Ring) McDequeueElem(obj unsafe.Pointer, esize uintptr) bool {
+	n, _ := r.McDequeueBulkElem(obj, esize, 1)
+	return n != 0
+}
+
+// McDequeueBulkElem dequeues given objects to slice from Ring.
+// Returns number of dequeued objects (either 0 or len(obj)) and
+// amount of space in the ring after the dequeue operation has
+// finished.
+func (r *Ring) McDequeueBulkElem(objtable unsafe.Pointer, esize uintptr, n int) (processed, free uint32) {
+	return ret(C.mc_dequeue_bulk_elem(argsElem(r, objtable, esize, n)))
+}
+
+// ScDequeueBulkElem dequeues given objects to slice from Ring.
+// Returns number of dequeued objects (either 0 or len(obj)) and
+// amount of space in the ring after the dequeue operation has
+// finished.
+func (r *Ring) ScDequeueBulkElem(objtable unsafe.Pointer, esize uintptr, n int) (processed, free uint32) {
+	return ret(C.sc_dequeue_bulk_elem(argsElem(r, objtable, esize, n)))
+}
+
+// DequeueBulkElem dequeues given objects to slice from Ring.
+// Returns number of dequeued objects (either 0 or len(obj)) and
+// amount of space in the ring after the dequeue operation has
+// finished.
+func (r *Ring) DequeueBulkElem(objtable unsafe.Pointer, esize uintptr, n int) (processed, free uint32) {
+	return ret(C.dequeue_bulk_elem(argsElem(r, objtable, esize, n)))
+}
+
+// McDequeueBurstElem dequeues given objects to slice from Ring.
+// Returns number of dequeued objects and amount of space in the ring
+// after the dequeue operation has finished.
+func (r *Ring) McDequeueBurstElem(objtable unsafe.Pointer, esize uintptr, n int) (processed, free uint32) {
+	return ret(C.mc_dequeue_burst_elem(argsElem(r, objtable, esize, n)))
+}
+
+// ScDequeueBurstElem dequeues given objects to slice from Ring.
+// Returns number of dequeued objects and amount of space in the ring
+// after the dequeue operation has finished.
+func (r *Ring) ScDequeueBurstElem(objtable unsafe.Pointer, esize uintptr, n int) (processed, free uint32) {
+	return ret(C.sc_dequeue_burst_elem(argsElem(r, objtable, esize, n)))
+}
+
+// DequeueBurstElem dequeues given objects to slice from Ring. Returns
+// number of dequeued objects and amount of space in the ring after
+// the dequeue operation has finished.
+func (r *Ring) DequeueBurstElem(objtable unsafe.Pointer, esize uintptr, n int) (processed, free uint32) {
+	return ret(C.dequeue_burst_elem(argsElem(r, objtable, esize, n)))
+}

ring/enqueue.go

@@ -9,10 +9,6 @@ package ring
 #include <rte_memory.h>
 
 #include "ring.h"
-
-struct someptr {
-	void *p;
-};
 */
 import "C"
 
@@ -43,42 +39,42 @@ func (r *Ring) MpEnqueue(obj unsafe.Pointer) bool {
 // amount of space in the ring after the enqueue operation has
 // finished.
 func (r *Ring) MpEnqueueBulk(obj []unsafe.Pointer) (n, free uint32) {
-	return ret(C.mp_enqueue_bulk(args(r, obj)))
+	return ret(C.mp_enqueue_bulk_elem(argsSliceElem(r, obj)))
 }
 
 // SpEnqueueBulk enqueues given objects from slice into Ring.
 // Returns number of enqueued objects (either 0 or len(obj)) and
 // amount of space in the ring after the enqueue operation has
 // finished.
 func (r *Ring) SpEnqueueBulk(obj []unsafe.Pointer) (n, free uint32) {
-	return ret(C.sp_enqueue_bulk(args(r, obj)))
+	return ret(C.sp_enqueue_bulk_elem(argsSliceElem(r, obj)))
 }
 
 // EnqueueBulk enqueues given objects from slice into Ring.
 // Returns number of enqueued objects (either 0 or len(obj)) and
 // amount of space in the ring after the enqueue operation has
 // finished.
 func (r *Ring) EnqueueBulk(obj []unsafe.Pointer) (n, free uint32) {
-	return ret(C.enqueue_bulk(args(r, obj)))
+	return ret(C.enqueue_bulk_elem(argsSliceElem(r, obj)))
 }
 
 // MpEnqueueBurst enqueues given objects from slice into Ring.
 // Returns number of enqueued objects and amount of space in the ring
 // after the enqueue operation has finished.
 func (r *Ring) MpEnqueueBurst(obj []unsafe.Pointer) (n, free uint32) {
-	return ret(C.mp_enqueue_burst(args(r, obj)))
+	return ret(C.mp_enqueue_burst_elem(argsSliceElem(r, obj)))
 }
 
 // SpEnqueueBurst enqueues given objects from slice into Ring.
 // Returns number of enqueued objects and amount of space in the ring
 // after the enqueue operation has finished.
 func (r *Ring) SpEnqueueBurst(obj []unsafe.Pointer) (n, free uint32) {
-	return ret(C.sp_enqueue_burst(args(r, obj)))
+	return ret(C.sp_enqueue_burst_elem(argsSliceElem(r, obj)))
 }
 
 // EnqueueBurst enqueues given objects from slice into Ring. Returns
 // number of enqueued objects and amount of space in the ring after
 // the enqueue operation has finished.
 func (r *Ring) EnqueueBurst(obj []unsafe.Pointer) (n, free uint32) {
-	return ret(C.enqueue_burst(args(r, obj)))
+	return ret(C.enqueue_burst_elem(argsSliceElem(r, obj)))
 }

ring/enqueue_elem.go

@@ -0,0 +1,80 @@
+package ring
+
+/*
+#include <stdlib.h>
+
+#include <rte_config.h>
+#include <rte_ring.h>
+#include <rte_errno.h>
+#include <rte_memory.h>
+
+#include "ring.h"
+*/
+import "C"
+
+import (
+	"unsafe"
+)
+
+// EnqueueElem enqueues an object into given Ring.
+func (r *Ring) EnqueueElem(obj unsafe.Pointer, esize uintptr) bool {
+	n, _ := r.EnqueueBulkElem(obj, esize, 1)
+	return n != 0
+}
+
+// SpEnqueueElem enqueues an object into given Ring.
+func (r *Ring) SpEnqueueElem(obj unsafe.Pointer, esize uintptr) bool {
+	n, _ := r.SpEnqueueBulkElem(obj, esize, 1)
+	return n != 0
+}
+
+// MpEnqueueElem enqueues an object into given Ring.
+func (r *Ring) MpEnqueueElem(obj unsafe.Pointer, esize uintptr) bool {
+	n, _ := r.MpEnqueueBulkElem(obj, esize, 1)
+	return n != 0
+}
+
+// MpEnqueueBulkElem enqueues given objects from slice into Ring.
+// Returns number of enqueued objects (either 0 or len(obj)) and
+// amount of space in the ring after the enqueue operation has
+// finished.
+func (r *Ring) MpEnqueueBulkElem(objtable unsafe.Pointer, esize uintptr, n int) (processed, free uint32) {
+	return ret(C.mp_enqueue_bulk_elem(argsElem(r, objtable, esize, n)))
+}
+
+// SpEnqueueBulkElem enqueues given objects from slice into Ring.
+// Returns number of enqueued objects (either 0 or len(obj)) and
+// amount of space in the ring after the enqueue operation has
+// finished.
+func (r *Ring) SpEnqueueBulkElem(objtable unsafe.Pointer, esize uintptr, n int) (processed, free uint32) {
+	return ret(C.sp_enqueue_bulk_elem(argsElem(r, objtable, esize, n)))
+}
+
+// EnqueueBulkElem enqueues given objects from slice into Ring.
+// Returns number of enqueued objects (either 0 or len(obj)) and
+// amount of space in the ring after the enqueue operation has
+// finished.
+func (r *Ring) EnqueueBulkElem(objtable unsafe.Pointer, esize uintptr, n int) (processed, free uint32) {
+	return ret(C.enqueue_bulk_elem(argsElem(r, objtable, esize, n)))
+}
+
+// MpEnqueueBurstElem enqueues given objects from slice into Ring.
+// Returns number of enqueued objects and amount of space in the ring
+// after the enqueue operation has finished.
+func (r *Ring) MpEnqueueBurstElem(objtable unsafe.Pointer, esize uintptr, n int) (processed, free uint32) {
+	return ret(C.mp_enqueue_burst_elem(argsElem(r, objtable, esize, n)))
+}
+
+// SpEnqueueBurstElem enqueues given objects from slice into Ring.
+// Returns number of enqueued objects and amount of space in the ring
+// after the enqueue operation has finished.
+func (r *Ring) SpEnqueueBurstElem(objtable unsafe.Pointer, esize uintptr, n int) (processed, free uint32) {
+	return ret(C.sp_enqueue_burst_elem(argsElem(r, objtable, esize, n)))
+}
+
+// EnqueueBurstElem enqueues given objects from slice into Ring. Returns
+// number of enqueued objects and amount of space in the ring after
+// the enqueue operation has finished.
+func (r *Ring) EnqueueBurstElem(objtable unsafe.Pointer, esize uintptr, n int) (processed, free uint32) {
+	return ret(C.enqueue_burst_elem(argsElem(r, objtable, esize, n)))
+}