On Thu, Apr 07, 2022 at 11:04:53AM +0200, Morten Brørup wrote: > > From: Morten Brørup [mailto:m...@smartsharesystems.com] > > Sent: Wednesday, 2 February 2022 11.34 > > > > This patch fixes the rte_mempool_do_generic_put() caching algorithm, > > which was fundamentally wrong, causing multiple performance issues when > > flushing. > > > > [...] > > Olivier, > > Will you please consider this patch [1] and the other one [2]. > > The primary bug here is this: When a mempool cache becomes full (i.e. exceeds > the "flush threshold"), and is flushed to the backing ring, it is still full > afterwards; but it should be empty afterwards. It is not flushed entirely, > only the elements exceeding "size" are flushed. >
I don't believe it should be flushed entirely, there should always be some elements left so that even after flush we can still allocate an additional burst. We want to avoid the situation where a flush of all elements is immediately followed by a refill of new elements. However, we can flush to maybe size/2, and improve things. In short, this not emptying is by design rather than a bug, though we can look to tweak the behaviour. > E.g. pipelined applications having ingress threads and egress threads running > on different lcores are affected by this bug. > If we are looking at improvements for pipelined applications, I think a bigger win would be to change the default mempool from ring-based to stack-based. For apps using a run-to-completion model, they should run out of cache and should therefore be largely unaffected by such a change. > I don't think the real performance impact is very big, but these algorithm > level bugs really annoy me. > > I'm still wondering how the patch introducing the mempool cache flush > threshold could pass internal code review with so many bugs. > > [1] > https://patchwork.dpdk.org/project/dpdk/patch/20220202103354.79832-1...@smartsharesystems.com/ > [2] > https://patchwork.dpdk.org/project/dpdk/patch/20220202081426.77975-1...@smartsharesystems.com/ > > -Morten > > > Signed-off-by: Morten Brørup <m...@smartsharesystems.com> > > --- > > lib/mempool/rte_mempool.h | 34 ++++++++++++++++++++++------------ > > 1 file changed, 22 insertions(+), 12 deletions(-) > > > > diff --git a/lib/mempool/rte_mempool.h b/lib/mempool/rte_mempool.h > > index 1e7a3c1527..e7e09e48fc 100644 > > --- a/lib/mempool/rte_mempool.h > > +++ b/lib/mempool/rte_mempool.h > > @@ -1344,31 +1344,41 @@ rte_mempool_do_generic_put(struct rte_mempool > > *mp, void * const *obj_table, > > if (unlikely(cache == NULL || n > RTE_MEMPOOL_CACHE_MAX_SIZE)) > > goto ring_enqueue; > > > > - cache_objs = &cache->objs[cache->len]; > > + /* If the request itself is too big for the cache */ > > + if (unlikely(n > cache->flushthresh)) > > + goto ring_enqueue; > > > > /* > > * The cache follows the following algorithm > > - * 1. Add the objects to the cache > > - * 2. Anything greater than the cache min value (if it crosses > > the > > - * cache flush threshold) is flushed to the ring. > > In the code, "the cache min value" is actually "the cache size". This > indicates an intention to do something more. Perhaps the patch introducing > the "flush threshold" was committed while still incomplete, and just never > got completed? > > > + * 1. If the objects cannot be added to the cache without > > + * crossing the flush threshold, flush the cache to the ring. > > + * 2. Add the objects to the cache. > > */ > > > > - /* Add elements back into the cache */ > > - rte_memcpy(&cache_objs[0], obj_table, sizeof(void *) * n); > > + if (cache->len + n <= cache->flushthresh) { > > + cache_objs = &cache->objs[cache->len]; > > > > - cache->len += n; > > + cache->len += n; > > + } else { > > + cache_objs = &cache->objs[0]; > > > > - if (cache->len >= cache->flushthresh) { > > - rte_mempool_ops_enqueue_bulk(mp, &cache->objs[cache->size], > > - cache->len - cache->size); > > - cache->len = cache->size; > > +#ifdef RTE_LIBRTE_MEMPOOL_DEBUG > > + if (rte_mempool_ops_enqueue_bulk(mp, cache_objs, cache- > > >len) < 0) > > + rte_panic("cannot put objects in mempool\n"); > > +#else > > + rte_mempool_ops_enqueue_bulk(mp, cache_objs, cache->len); > > +#endif > > + cache->len = n; > > } > > > > + /* Add the objects to the cache. */ > > + rte_memcpy(cache_objs, obj_table, sizeof(void *) * n); > > + > > return; > > > > ring_enqueue: > > > > - /* push remaining objects in ring */ > > + /* Put the objects into the ring */ > > #ifdef RTE_LIBRTE_MEMPOOL_DEBUG > > if (rte_mempool_ops_enqueue_bulk(mp, obj_table, n) < 0) > > rte_panic("cannot put objects in mempool\n"); > > -- > > 2.17.1 >
