X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=lib%2Flibrte_ring%2Frte_ring.c;h=ebe5ccf0de686bf5e1060b58190aced968a415b8;hb=861ca8b1e97c68727cbafbb859cc6c2ff017801e;hp=550549db39245e3de52d54fa720a6c0fc53bcc7c;hpb=c0c055f5f773adca467d256298d8e777024f085f;p=dpdk.git diff --git a/lib/librte_ring/rte_ring.c b/lib/librte_ring/rte_ring.c index 550549db39..ebe5ccf0de 100644 --- a/lib/librte_ring/rte_ring.c +++ b/lib/librte_ring/rte_ring.c @@ -30,8 +30,10 @@ #include #include #include +#include #include "rte_ring.h" +#include "rte_ring_elem.h" TAILQ_HEAD(rte_ring_list, rte_tailq_entry); @@ -43,25 +45,134 @@ EAL_REGISTER_TAILQ(rte_ring_tailq) /* true if x is a power of 2 */ #define POWEROF2(x) ((((x)-1) & (x)) == 0) +/* by default set head/tail distance as 1/8 of ring capacity */ +#define HTD_MAX_DEF 8 + /* return the size of memory occupied by a ring */ ssize_t -rte_ring_get_memsize(unsigned count) +rte_ring_get_memsize_elem(unsigned int esize, unsigned int count) { ssize_t sz; + /* Check if element size is a multiple of 4B */ + if (esize % 4 != 0) { + RTE_LOG(ERR, RING, "element size is not a multiple of 4\n"); + + return -EINVAL; + } + /* count must be a power of 2 */ if ((!POWEROF2(count)) || (count > RTE_RING_SZ_MASK )) { RTE_LOG(ERR, RING, - "Requested size is invalid, must be power of 2, and " - "do not exceed the size limit %u\n", RTE_RING_SZ_MASK); + "Requested number of elements is invalid, must be power of 2, and not exceed %u\n", + RTE_RING_SZ_MASK); + return -EINVAL; } - sz = sizeof(struct rte_ring) + count * sizeof(void *); + sz = sizeof(struct rte_ring) + count * esize; sz = RTE_ALIGN(sz, RTE_CACHE_LINE_SIZE); return sz; } +/* return the size of memory occupied by a ring */ +ssize_t +rte_ring_get_memsize(unsigned int count) +{ + return rte_ring_get_memsize_elem(sizeof(void *), count); +} + +/* + * internal helper function to reset prod/cons head-tail values. + */ +static void +reset_headtail(void *p) +{ + struct rte_ring_headtail *ht; + struct rte_ring_hts_headtail *ht_hts; + struct rte_ring_rts_headtail *ht_rts; + + ht = p; + ht_hts = p; + ht_rts = p; + + switch (ht->sync_type) { + case RTE_RING_SYNC_MT: + case RTE_RING_SYNC_ST: + ht->head = 0; + ht->tail = 0; + break; + case RTE_RING_SYNC_MT_RTS: + ht_rts->head.raw = 0; + ht_rts->tail.raw = 0; + break; + case RTE_RING_SYNC_MT_HTS: + ht_hts->ht.raw = 0; + break; + default: + /* unknown sync mode */ + RTE_ASSERT(0); + } +} + +void +rte_ring_reset(struct rte_ring *r) +{ + reset_headtail(&r->prod); + reset_headtail(&r->cons); +} + +/* + * helper function, calculates sync_type values for prod and cons + * based on input flags. Returns zero at success or negative + * errno value otherwise. + */ +static int +get_sync_type(uint32_t flags, enum rte_ring_sync_type *prod_st, + enum rte_ring_sync_type *cons_st) +{ + static const uint32_t prod_st_flags = + (RING_F_SP_ENQ | RING_F_MP_RTS_ENQ | RING_F_MP_HTS_ENQ); + static const uint32_t cons_st_flags = + (RING_F_SC_DEQ | RING_F_MC_RTS_DEQ | RING_F_MC_HTS_DEQ); + + switch (flags & prod_st_flags) { + case 0: + *prod_st = RTE_RING_SYNC_MT; + break; + case RING_F_SP_ENQ: + *prod_st = RTE_RING_SYNC_ST; + break; + case RING_F_MP_RTS_ENQ: + *prod_st = RTE_RING_SYNC_MT_RTS; + break; + case RING_F_MP_HTS_ENQ: + *prod_st = RTE_RING_SYNC_MT_HTS; + break; + default: + return -EINVAL; + } + + switch (flags & cons_st_flags) { + case 0: + *cons_st = RTE_RING_SYNC_MT; + break; + case RING_F_SC_DEQ: + *cons_st = RTE_RING_SYNC_ST; + break; + case RING_F_MC_RTS_DEQ: + *cons_st = RTE_RING_SYNC_MT_RTS; + break; + case RING_F_MC_HTS_DEQ: + *cons_st = RTE_RING_SYNC_MT_HTS; + break; + default: + return -EINVAL; + } + + return 0; +} + int rte_ring_init(struct rte_ring *r, const char *name, unsigned count, unsigned flags) @@ -76,14 +187,25 @@ rte_ring_init(struct rte_ring *r, const char *name, unsigned count, RTE_BUILD_BUG_ON((offsetof(struct rte_ring, prod) & RTE_CACHE_LINE_MASK) != 0); + RTE_BUILD_BUG_ON(offsetof(struct rte_ring_headtail, sync_type) != + offsetof(struct rte_ring_hts_headtail, sync_type)); + RTE_BUILD_BUG_ON(offsetof(struct rte_ring_headtail, tail) != + offsetof(struct rte_ring_hts_headtail, ht.pos.tail)); + + RTE_BUILD_BUG_ON(offsetof(struct rte_ring_headtail, sync_type) != + offsetof(struct rte_ring_rts_headtail, sync_type)); + RTE_BUILD_BUG_ON(offsetof(struct rte_ring_headtail, tail) != + offsetof(struct rte_ring_rts_headtail, tail.val.pos)); + /* init the ring structure */ memset(r, 0, sizeof(*r)); - ret = snprintf(r->name, sizeof(r->name), "%s", name); + ret = strlcpy(r->name, name, sizeof(r->name)); if (ret < 0 || ret >= (int)sizeof(r->name)) return -ENAMETOOLONG; r->flags = flags; - r->prod.single = (flags & RING_F_SP_ENQ) ? __IS_SP : __IS_MP; - r->cons.single = (flags & RING_F_SC_DEQ) ? __IS_SC : __IS_MC; + ret = get_sync_type(flags, &r->prod.sync_type, &r->cons.sync_type); + if (ret != 0) + return ret; if (flags & RING_F_EXACT_SZ) { r->size = rte_align32pow2(count + 1); @@ -100,16 +222,20 @@ rte_ring_init(struct rte_ring *r, const char *name, unsigned count, r->mask = count - 1; r->capacity = r->mask; } - r->prod.head = r->cons.head = 0; - r->prod.tail = r->cons.tail = 0; + + /* set default values for head-tail distance */ + if (flags & RING_F_MP_RTS_ENQ) + rte_ring_set_prod_htd_max(r, r->capacity / HTD_MAX_DEF); + if (flags & RING_F_MC_RTS_DEQ) + rte_ring_set_cons_htd_max(r, r->capacity / HTD_MAX_DEF); return 0; } -/* create the ring */ +/* create the ring for a given element size */ struct rte_ring * -rte_ring_create(const char *name, unsigned count, int socket_id, - unsigned flags) +rte_ring_create_elem(const char *name, unsigned int esize, unsigned int count, + int socket_id, unsigned int flags) { char mz_name[RTE_MEMZONE_NAMESIZE]; struct rte_ring *r; @@ -127,7 +253,7 @@ rte_ring_create(const char *name, unsigned count, int socket_id, if (flags & RING_F_EXACT_SZ) count = rte_align32pow2(count + 1); - ring_size = rte_ring_get_memsize(count); + ring_size = rte_ring_get_memsize_elem(esize, count); if (ring_size < 0) { rte_errno = ring_size; return NULL; @@ -147,7 +273,7 @@ rte_ring_create(const char *name, unsigned count, int socket_id, return NULL; } - rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK); + rte_mcfg_tailq_write_lock(); /* reserve a memory zone for this ring. If we can't get rte_config or * we are secondary process, the memzone_reserve function will set @@ -169,11 +295,20 @@ rte_ring_create(const char *name, unsigned count, int socket_id, RTE_LOG(ERR, RING, "Cannot reserve memory\n"); rte_free(te); } - rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK); + rte_mcfg_tailq_write_unlock(); return r; } +/* create the ring */ +struct rte_ring * +rte_ring_create(const char *name, unsigned int count, int socket_id, + unsigned int flags) +{ + return rte_ring_create_elem(name, sizeof(void *), count, socket_id, + flags); +} + /* free the ring */ void rte_ring_free(struct rte_ring *r) @@ -200,7 +335,7 @@ rte_ring_free(struct rte_ring *r) } ring_list = RTE_TAILQ_CAST(rte_ring_tailq.head, rte_ring_list); - rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK); + rte_mcfg_tailq_write_lock(); /* find out tailq entry */ TAILQ_FOREACH(te, ring_list, next) { @@ -209,13 +344,13 @@ rte_ring_free(struct rte_ring *r) } if (te == NULL) { - rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK); + rte_mcfg_tailq_write_unlock(); return; } TAILQ_REMOVE(ring_list, te, next); - rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK); + rte_mcfg_tailq_write_unlock(); rte_free(te); } @@ -245,13 +380,13 @@ rte_ring_list_dump(FILE *f) ring_list = RTE_TAILQ_CAST(rte_ring_tailq.head, rte_ring_list); - rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK); + rte_mcfg_tailq_read_lock(); TAILQ_FOREACH(te, ring_list, next) { rte_ring_dump(f, (struct rte_ring *) te->data); } - rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK); + rte_mcfg_tailq_read_unlock(); } /* search a ring from its name */ @@ -264,7 +399,7 @@ rte_ring_lookup(const char *name) ring_list = RTE_TAILQ_CAST(rte_ring_tailq.head, rte_ring_list); - rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK); + rte_mcfg_tailq_read_lock(); TAILQ_FOREACH(te, ring_list, next) { r = (struct rte_ring *) te->data; @@ -272,7 +407,7 @@ rte_ring_lookup(const char *name) break; } - rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK); + rte_mcfg_tailq_read_unlock(); if (te == NULL) { rte_errno = ENOENT;