From: "Mattias Rönnblom" <mattias.ronnblom@ericsson.com>
To: <dev@dpdk.org>
Cc: hofors@lysator.liu.se, "Morten Brørup" <mb@smartsharesystems.com>,
"Stephen Hemminger" <stephen@networkplumber.org>,
"Mattias Rönnblom" <mattias.ronnblom@ericsson.com>
Subject: [RFC 1/5] eal: add static per-lcore memory allocation facility
Date: Thu, 8 Feb 2024 19:16:40 +0100 [thread overview]
Message-ID: <20240208181644.455233-2-mattias.ronnblom@ericsson.com> (raw)
In-Reply-To: <20240208181644.455233-1-mattias.ronnblom@ericsson.com>
Introduce DPDK per-lcore id variables, or lcore variables for short.
An lcore variable has one value for every current and future lcore
id-equipped thread.
The primary <rte_lcore_var.h> use case is for statically allocating
small chunks of often-used data, which is related logically, but where
there are performance benefits to reap from having updates being local
to an lcore.
Lcore variables are similar to thread-local storage (TLS, e.g., C11
_Thread_local), but decoupling the values' life time with that of the
threads.
Lcore variables are also similar in terms of functionality provided by
FreeBSD kernel's DPCPU_*() family of macros and the associated
build-time machinery. DPCPU uses linker scripts, which effectively
prevents the reuse of its, otherwise seemingly viable, approach.
The currently-prevailing way to solve the same problem as lcore
variables is to keep a module's per-lcore data as RTE_MAX_LCORE-sized
array of cache-aligned, RTE_CACHE_GUARDed structs. The benefit of
lcore variables over this approach is that data related to the same
lcore now is close (spatially, in memory), rather than data used by
the same module, which in turn avoid excessive use of padding,
polluting caches with unused data.
Signed-off-by: Mattias Rönnblom <mattias.ronnblom@ericsson.com>
---
config/rte_config.h | 1 +
doc/api/doxy-api-index.md | 1 +
lib/eal/common/eal_common_lcore_var.c | 80 ++++++
lib/eal/common/meson.build | 1 +
lib/eal/include/meson.build | 1 +
lib/eal/include/rte_lcore_var.h | 352 ++++++++++++++++++++++++++
lib/eal/version.map | 4 +
7 files changed, 440 insertions(+)
create mode 100644 lib/eal/common/eal_common_lcore_var.c
create mode 100644 lib/eal/include/rte_lcore_var.h
diff --git a/config/rte_config.h b/config/rte_config.h
index da265d7dd2..884482e473 100644
--- a/config/rte_config.h
+++ b/config/rte_config.h
@@ -30,6 +30,7 @@
/* EAL defines */
#define RTE_CACHE_GUARD_LINES 1
#define RTE_MAX_HEAPS 32
+#define RTE_MAX_LCORE_VAR 1048576
#define RTE_MAX_MEMSEG_LISTS 128
#define RTE_MAX_MEMSEG_PER_LIST 8192
#define RTE_MAX_MEM_MB_PER_LIST 32768
diff --git a/doc/api/doxy-api-index.md b/doc/api/doxy-api-index.md
index a6a768bd7c..bb06bb7ca1 100644
--- a/doc/api/doxy-api-index.md
+++ b/doc/api/doxy-api-index.md
@@ -98,6 +98,7 @@ The public API headers are grouped by topics:
[interrupts](@ref rte_interrupts.h),
[launch](@ref rte_launch.h),
[lcore](@ref rte_lcore.h),
+ [lcore-varible](@ref rte_lcore_var.h),
[per-lcore](@ref rte_per_lcore.h),
[service cores](@ref rte_service.h),
[keepalive](@ref rte_keepalive.h),
diff --git a/lib/eal/common/eal_common_lcore_var.c b/lib/eal/common/eal_common_lcore_var.c
new file mode 100644
index 0000000000..5276fe7192
--- /dev/null
+++ b/lib/eal/common/eal_common_lcore_var.c
@@ -0,0 +1,80 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2024 Ericsson AB
+ */
+
+/* XXX: should this file be called eal_common_ldata.c or rte_ldata.c? */
+
+#include <inttypes.h>
+
+#include <rte_common.h>
+#include <rte_debug.h>
+#include <rte_log.h>
+
+#include <rte_lcore_var.h>
+
+#include "eal_private.h"
+
+#define WARN_THRESHOLD 75
+#define MAX_AUTO_ALIGNMENT 16U
+
+/*
+ * Avoid using offset zero, since it would result in a NULL-value
+ * "handle" (offset) pointer, which in principle and per the API
+ * definition shouldn't be an issue, but may confuse some tools and
+ * users.
+ */
+#define INITIAL_OFFSET MAX_AUTO_ALIGNMENT
+
+char rte_lcore_var[RTE_MAX_LCORE][RTE_MAX_LCORE_VAR] __rte_cache_aligned;
+
+static uintptr_t allocated = INITIAL_OFFSET;
+
+static void
+verify_allocation(uintptr_t new_allocated)
+{
+ static bool has_warned;
+
+ RTE_VERIFY(new_allocated < RTE_MAX_LCORE_VAR);
+
+ if (new_allocated > (WARN_THRESHOLD * RTE_MAX_LCORE_VAR) / 100 &&
+ !has_warned) {
+ EAL_LOG(WARNING, "Per-lcore data usage has exceeded %d%% "
+ "of the maximum capacity (%d bytes)", WARN_THRESHOLD,
+ RTE_MAX_LCORE_VAR);
+ has_warned = true;
+ }
+}
+
+static void *
+lcore_var_alloc(size_t size, size_t alignment)
+{
+ uintptr_t new_allocated = RTE_ALIGN_CEIL(allocated, alignment);
+
+ void *offset = (void *)new_allocated;
+
+ new_allocated += size;
+
+ verify_allocation(new_allocated);
+
+ allocated = new_allocated;
+
+ EAL_LOG(DEBUG, "Allocated %"PRIuPTR" bytes of per-lcore data with a "
+ "%"PRIuPTR"-byte alignment", size, alignment);
+
+ return offset;
+}
+
+void *
+rte_lcore_var_alloc(size_t size)
+{
+ RTE_BUILD_BUG_ON(RTE_MAX_LCORE_VAR % RTE_CACHE_LINE_SIZE != 0);
+
+ /* Allocations are naturally aligned (i.e., the same alignment
+ * as the object size, up to a maximum of 16 bytes, which
+ * should satisify alignment requirements of any kind of
+ * object.
+ */
+ size_t alignment = RTE_MIN(size, MAX_AUTO_ALIGNMENT);
+
+ return lcore_var_alloc(size, alignment);
+}
diff --git a/lib/eal/common/meson.build b/lib/eal/common/meson.build
index 22a626ba6f..d41403680b 100644
--- a/lib/eal/common/meson.build
+++ b/lib/eal/common/meson.build
@@ -18,6 +18,7 @@ sources += files(
'eal_common_interrupts.c',
'eal_common_launch.c',
'eal_common_lcore.c',
+ 'eal_common_lcore_var.c',
'eal_common_mcfg.c',
'eal_common_memalloc.c',
'eal_common_memory.c',
diff --git a/lib/eal/include/meson.build b/lib/eal/include/meson.build
index e94b056d46..9449253e23 100644
--- a/lib/eal/include/meson.build
+++ b/lib/eal/include/meson.build
@@ -27,6 +27,7 @@ headers += files(
'rte_keepalive.h',
'rte_launch.h',
'rte_lcore.h',
+ 'rte_lcore_var.h',
'rte_lock_annotations.h',
'rte_malloc.h',
'rte_mcslock.h',
diff --git a/lib/eal/include/rte_lcore_var.h b/lib/eal/include/rte_lcore_var.h
new file mode 100644
index 0000000000..c1854dc6a4
--- /dev/null
+++ b/lib/eal/include/rte_lcore_var.h
@@ -0,0 +1,352 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2024 Ericsson AB
+ */
+
+#ifndef _RTE_LCORE_VAR_H_
+#define _RTE_LCORE_VAR_H_
+
+/**
+ * @file
+ *
+ * RTE Per-lcore id variables
+ *
+ * This API provides a mechanism to create and access per-lcore id
+ * variables in a space- and cycle-efficient manner.
+ *
+ * A per-lcore id variable (or lcore variable for short) has one value
+ * for each EAL thread and registered non-EAL thread. In other words,
+ * there's one copy of its value for each and every current and future
+ * lcore id-equipped thread, with the total number of copies amounting
+ * to \c RTE_MAX_LCORE.
+ *
+ * In order to access the values of an lcore variable, a handle is
+ * used. The type of the handle is a pointer to the value's type
+ * (e.g., for \c uint32_t lcore variable, the handle is a
+ * <code>uint32_t *</code>. A handle may be passed between modules and
+ * threads just like any pointer, but its value is not the address of
+ * any particular object, but rather just an opaque identifier, stored
+ * in a typed pointer (to inform the access macro the type of values).
+ *
+ * @b Creation
+ *
+ * An lcore variable is created in two steps:
+ * 1. Define a lcore variable handle by using \ref RTE_LCORE_VAR_HANDLE.
+ * 2. Allocate lcore variable storage and initialize the handle with
+ * a unique identifier by \ref RTE_LCORE_VAR_ALLOC or
+ * \ref RTE_LCORE_VAR_INIT. Allocation generally occurs the time of
+ * module initialization, but may be done at any time.
+ *
+ * An lcore variable is not tied to the owning thread's lifetime. It's
+ * available for use by any thread immediately after having been
+ * allocated, and continues to be available throughout the lifetime of
+ * the EAL.
+ *
+ * Lcore variables cannot and need not be freed.
+ *
+ * @b Access
+ *
+ * The value of any lcore variable for any lcore id may be accessed
+ * from any thread (including unregistered threads), but is should
+ * generally only *frequently* read from or written to by the owner.
+ *
+ * Values of the same lcore variable but owned by to different lcore
+ * ids *may* be frequently read or written by the owners without the
+ * risk of false sharing.
+ *
+ * An appropriate synchronization mechanism (e.g., atomics) should
+ * employed to assure there are no data races between the owning
+ * thread and any non-owner threads accessing the same lcore variable
+ * instance.
+ *
+ * The value of the lcore variable for a particular lcore id may be
+ * retrieved with \ref RTE_LCORE_VAR_LCORE_GET. To get a pointer to the
+ * same object, use \ref RTE_LCORE_VAR_LCORE_PTR.
+ *
+ * To modify the value of an lcore variable for a particular lcore id,
+ * either access the object through the pointer retrieved by \ref
+ * RTE_LCORE_VAR_LCORE_PTR or, for primitive types, use \ref
+ * RTE_LCORE_VAR_LCORE_SET.
+ *
+ * The access macros each has a short-hand which may be used by an EAL
+ * thread or registered non-EAL thread to access the lcore variable
+ * instance of its own lcore id. Those are \ref RTE_LCORE_VAR_GET,
+ * \ref RTE_LCORE_VAR_PTR, and \ref RTE_LCORE_VAR_SET.
+ *
+ * Although the handle (as defined by \ref RTE_LCORE_VAR_HANDLE) is a
+ * pointer with the same type as the value, it may not be directly
+ * dereferenced and must be treated as an opaque identifier. The
+ * *identifier* value is common across all lcore ids.
+ *
+ * @b Storage
+ *
+ * An lcore variable's values may by of a primitive type like \c int,
+ * but would more typically be a \c struct. An application may choose
+ * to define an lcore variable, which it then it goes on to never
+ * allocate.
+ *
+ * The lcore variable handle introduces a per-variable (not
+ * per-value/per-lcore id) overhead of \c sizeof(void *) bytes, so
+ * there are some memory footprint gains to be made by organizing all
+ * per-lcore id data for a particular module as one lcore variable
+ * (e.g., as a struct).
+ *
+ * The sum of all lcore variables, plus any padding required, must be
+ * less than the DPDK build-time constant \c RTE_MAX_LCORE_VAR. A
+ * violation of this maximum results in the process being terminated.
+ *
+ * It's reasonable to expected that \c RTE_MAX_LCORE_VAR is on the
+ * same order of magnitude in size as a thread stack.
+ *
+ * The lcore variable storage buffers are kept in the BSS section in
+ * the resulting binary, where data generally isn't mapped in until
+ * it's accessed. This means that unused portions of the lcore
+ * variable storage area will not occupy any physical memory (with a
+ * granularity of the memory page size [usually 4 kB]).
+ *
+ * Lcore variables should generally *not* be \ref __rte_cache_aligned
+ * and need *not* include a \ref RTE_CACHE_GUARD field, since the use
+ * of these constructs are designed to avoid false sharing. In the
+ * case of an lcore variable instance, all nearby data structures
+ * should almost-always be written to by a single thread (the lcore
+ * variable owner). Adding padding will increase the effective memory
+ * working set size, and potentially reducing performance.
+ *
+ * @b Example
+ *
+ * Below is an example of the use of an lcore variable:
+ *
+ * \code{.c}
+ * struct foo_lcore_state {
+ * int a;
+ * long b;
+ * };
+ *
+ * static RTE_LCORE_VAR_HANDLE(struct foo_lcore_state, lcore_states);
+ *
+ * long foo_get_a_plus_b(void)
+ * {
+ * struct foo_lcore_state *state = RTE_LCORE_VAR_PTR(lcore_states);
+ *
+ * return state->a + state->b;
+ * }
+ *
+ * RTE_INIT(rte_foo_init)
+ * {
+ * unsigned int lcore_id;
+ *
+ * RTE_LCORE_VAR_ALLOC(foo_state);
+ *
+ * struct foo_lcore_state *state;
+ * RTE_LCORE_VAR_FOREACH(lcore_states) {
+ * (initialize 'state')
+ * }
+ *
+ * (other initialization)
+ * }
+ * \endcode
+ *
+ *
+ * @b Alternatives
+ *
+ * Lcore variables are designed to replace a pattern exemplified below:
+ * \code{.c}
+ * struct foo_lcore_state {
+ * int a;
+ * long b;
+ * RTE_CACHE_GUARD;
+ * } __rte_cache_aligned;
+ *
+ * static struct foo_lcore_state lcore_states[RTE_MAX_LCORE];
+ * \endcode
+ *
+ * This scheme is simple and effective, but has one drawback: the data
+ * is organized so that objects related to all lcores for a particular
+ * module is kept close in memory. At a bare minimum, this forces the
+ * use of cache-line alignment to avoid false sharing. With CPU
+ * hardware prefetching and memory loads resulting from speculative
+ * execution (functions which seemingly are getting more eager faster
+ * than they are getting more intelligent), one or more "guard" cache
+ * lines may be required to separate one lcore's data from another's.
+ *
+ * Lcore variables has the upside of working with, not against, the
+ * CPU's assumptions and for example next-line prefetchers may well
+ * work the way its designers intended (i.e., to the benefit, not
+ * detriment, of system performance).
+ *
+ * Another alternative to \ref rte_lcore_var.h is the \ref
+ * rte_per_lcore.h API, which make use of thread-local storage (TLS,
+ * e.g., GCC __thread or C11 _Thread_local). The main differences
+ * between by using the various forms of TLS (e.g., \ref
+ * RTE_DEFINE_PER_LCORE or _Thread_local) and the use of lcore
+ * variables are:
+ *
+ * * The existence and non-existence of a thread-local variable
+ * instance follow that of particular thread's. The data cannot be
+ * accessed before the thread has been created, nor after it has
+ * exited. One effect of this is thread-local variables must
+ * initialized in a "lazy" manner (e.g., at the point of thread
+ * creation). Lcore variables may be accessed immediately after
+ * having been allocated (which is usually prior any thread beyond
+ * the main thread is running).
+ * * A thread-local variable is duplicated across all threads in the
+ * process, including unregistered non-EAL threads (i.e.,
+ * "regular" threads). For DPDK applications heavily relying on
+ * multi-threading (in conjunction to DPDK's "one thread per core"
+ * pattern), either by having many concurrent threads or
+ * creating/destroying threads at a high rate, an excessive use of
+ * thread-local variables may cause inefficiencies (e.g.,
+ * increased thread creation overhead due to thread-local storage
+ * initialization or increased total RAM footprint usage). Lcore
+ * variables *only* exist for threads with an lcore id, and thus
+ * not for such "regular" threads.
+ * * If data in thread-local storage may be shared between threads
+ * (i.e., can a pointer to a thread-local variable be passed to
+ * and successfully dereferenced by non-owning thread) depends on
+ * the details of the TLS implementation. With GCC __thread and
+ * GCC _Thread_local, such data sharing is supported. In the C11
+ * standard, the result of accessing another thread's
+ * _Thread_local object is implementation-defined. Lcore variable
+ * instances may be accessed reliably by any thread.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+
+#include <rte_common.h>
+#include <rte_config.h>
+#include <rte_lcore.h>
+
+/**
+ * Given the lcore variable type, produces the type of the lcore
+ * variable handle.
+ */
+#define RTE_LCORE_VAR_HANDLE_TYPE(type) \
+ type *
+
+/**
+ * Define a lcore variable handle.
+ *
+ * This macro defines a variable which is used as a handle to access
+ * the various per-lcore id instances of a per-lcore id variable.
+ *
+ * The aim with this macro is to make clear at the point of
+ * declaration that this is an lcore handler, rather than a regular
+ * pointer.
+ *
+ * Add @b static as a prefix in case the lcore variable are only to be
+ * accessed from a particular translation unit.
+ */
+#define RTE_LCORE_VAR_HANDLE(type, name) \
+ RTE_LCORE_VAR_HANDLE_TYPE(type) name
+
+/**
+ * Allocate space for an lcore variable, and initialize its handle.
+ */
+#define RTE_LCORE_VAR_ALLOC_SZ(name, size) \
+ name = rte_lcore_var_alloc(size)
+
+/**
+ * Allocate space for an lcore variable of the size suggested by the
+ * handler pointer type and initialize its handle.
+ */
+#define RTE_LCORE_VAR_ALLOC(name) \
+ RTE_LCORE_VAR_ALLOC_SZ(name, sizeof(*(name)))
+
+/**
+ * Allocate an explicitly-sized lcore variable by means of a \ref
+ * RTE_INIT constructor.
+ */
+#define RTE_LCORE_VAR_INIT_SZ(name) \
+ RTE_INIT(rte_lcore_var_init_ ## name) \
+ { \
+ RTE_LCORE_VAR_ALLOC_SZ(name); \
+ }
+
+/**
+ * Allocate an lcore variable by means of a \ref RTE_INIT constructor.
+ */
+#define RTE_LCORE_VAR_INIT(name) \
+ RTE_INIT(rte_lcore_var_init_ ## name) \
+ { \
+ RTE_LCORE_VAR_ALLOC(name); \
+ }
+
+#define __RTE_LCORE_VAR_LCORE_PTR(lcore_id, name) \
+ ((void *)(&rte_lcore_var[lcore_id][(uintptr_t)(name)]))
+
+/**
+ * Get pointer to lcore variable instance with the specified lcore id.
+ */
+#define RTE_LCORE_VAR_LCORE_PTR(lcore_id, name) \
+ ((typeof(name))__RTE_LCORE_VAR_LCORE_PTR(lcore_id, name))
+
+/**
+ * Get value of a lcore variable instance of the specified lcore id.
+ */
+#define RTE_LCORE_VAR_LCORE_GET(lcore_id, name) \
+ (*(RTE_LCORE_VAR_LCORE_PTR(lcore_id, name)))
+
+/**
+ * Set the value of a lcore variable instance of the specified lcore id.
+ */
+#define RTE_LCORE_VAR_LCORE_SET(lcore_id, name, value) \
+ (*(RTE_LCORE_VAR_LCORE_PTR(lcore_id, name)) = (value))
+
+/**
+ * Get pointer to lcore variable instance of the current thread.
+ *
+ * May only be used by EAL threads and registered non-EAL threads.
+ */
+#define RTE_LCORE_VAR_PTR(name) RTE_LCORE_VAR_LCORE_PTR(rte_lcore_id(), name)
+
+/**
+ * Get value of lcore variable instance of the current thread.
+ *
+ * May only be used by EAL threads and registered non-EAL threads.
+ */
+#define RTE_LCORE_VAR_GET(name) RTE_LCORE_VAR_LCORE_GET(rte_lcore_id(), name)
+
+/**
+ * Set value of lcore variable instance of the current thread.
+ *
+ * May only be used by EAL threads and registered non-EAL threads.
+ */
+#define RTE_LCORE_VAR_SET(name, value) \
+ RTE_LCORE_VAR_LCORE_SET(rte_lcore_id(), name, value)
+
+/**
+ * Iterate over each lcore id's value for a lcore variable.
+ */
+#define RTE_LCORE_VAR_FOREACH(var, name) \
+ for (unsigned int lcore_id = \
+ (((var) = RTE_LCORE_VAR_LCORE_PTR(0, name)), 0); \
+ lcore_id < RTE_MAX_LCORE; \
+ lcore_id++, (var) = RTE_LCORE_VAR_LCORE_PTR(lcore_id, name))
+
+extern char rte_lcore_var[RTE_MAX_LCORE][RTE_MAX_LCORE_VAR];
+
+/**
+ * Allocate space in the per-lcore id buffer for a lcore variable.
+ *
+ * The pointer returned is only an opaque identifer of the variable. To
+ * get an actual pointer to a particular instance of the variable use
+ * \ref RTE_LCORE_VAR_PTR or \ref RTE_LCORE_VAR_LCORE_PTR.
+ *
+ * The allocation is always successful, barring an fatal exhaustion of
+ * the per-lcore id buffer space.
+ *
+ * @return
+ * The id of the variable, stored in a void pointer value.
+ */
+__rte_experimental
+void *
+rte_lcore_var_alloc(size_t size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _RTE_LCORE_VAR_H_ */
diff --git a/lib/eal/version.map b/lib/eal/version.map
index 5e0cd47c82..e90b86115a 100644
--- a/lib/eal/version.map
+++ b/lib/eal/version.map
@@ -393,6 +393,10 @@ EXPERIMENTAL {
# added in 23.07
rte_memzone_max_get;
rte_memzone_max_set;
+
+ # added in 24.03
+ rte_lcore_var_alloc;
+ rte_lcore_var;
};
INTERNAL {
--
2.34.1
next prev parent reply other threads:[~2024-02-08 18:24 UTC|newest]
Thread overview: 323+ messages / expand[flat|nested] mbox.gz Atom feed top
2024-02-08 18:16 [RFC 0/5] Lcore variables Mattias Rönnblom
2024-02-08 18:16 ` Mattias Rönnblom [this message]
2024-02-09 8:25 ` [RFC 1/5] eal: add static per-lcore memory allocation facility Morten Brørup
2024-02-09 11:46 ` Mattias Rönnblom
2024-02-09 13:04 ` Morten Brørup
2024-02-19 7:49 ` Mattias Rönnblom
2024-02-19 11:10 ` Morten Brørup
2024-02-19 14:31 ` Mattias Rönnblom
2024-02-19 15:04 ` Morten Brørup
2024-02-19 9:40 ` [RFC v2 0/5] Lcore variables Mattias Rönnblom
2024-02-19 9:40 ` [RFC v2 1/5] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-02-20 8:49 ` [RFC v3 0/6] Lcore variables Mattias Rönnblom
2024-02-20 8:49 ` [RFC v3 1/6] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-02-20 9:11 ` Bruce Richardson
2024-02-20 10:47 ` Mattias Rönnblom
2024-02-20 11:39 ` Bruce Richardson
2024-02-20 13:37 ` Morten Brørup
2024-02-20 16:26 ` Mattias Rönnblom
2024-02-21 9:43 ` Jerin Jacob
2024-02-21 10:31 ` Morten Brørup
2024-02-21 14:26 ` Mattias Rönnblom
2024-02-22 9:22 ` Morten Brørup
2024-02-23 10:12 ` Mattias Rönnblom
2024-02-25 15:03 ` [RFC v4 0/6] Lcore variables Mattias Rönnblom
2024-02-25 15:03 ` [RFC v4 1/6] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-02-27 9:58 ` Morten Brørup
2024-02-27 13:44 ` Mattias Rönnblom
2024-02-27 15:05 ` Morten Brørup
2024-02-27 16:27 ` Mattias Rönnblom
2024-02-27 16:51 ` Morten Brørup
2024-02-28 10:09 ` [RFC v5 0/6] Lcore variables Mattias Rönnblom
2024-02-28 10:09 ` [RFC v5 1/6] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-03-19 12:52 ` Konstantin Ananyev
2024-03-20 10:24 ` Mattias Rönnblom
2024-03-20 14:18 ` Konstantin Ananyev
2024-05-06 8:27 ` [RFC v6 0/6] Lcore variables Mattias Rönnblom
2024-05-06 8:27 ` [RFC v6 1/6] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-09-10 7:03 ` [PATCH 0/6] Lcore variables Mattias Rönnblom
2024-09-10 7:03 ` [PATCH 1/6] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-09-10 9:32 ` Morten Brørup
2024-09-10 10:44 ` Mattias Rönnblom
2024-09-10 13:07 ` Morten Brørup
2024-09-10 15:55 ` Stephen Hemminger
2024-09-11 10:32 ` Morten Brørup
2024-09-11 15:05 ` Mattias Rönnblom
2024-09-11 15:07 ` Morten Brørup
2024-09-11 17:04 ` [PATCH v2 0/6] Lcore variables Mattias Rönnblom
2024-09-11 17:04 ` [PATCH v2 1/6] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-09-12 2:33 ` fengchengwen
2024-09-12 5:35 ` Mattias Rönnblom
2024-09-12 7:05 ` fengchengwen
2024-09-12 7:28 ` Jerin Jacob
2024-09-12 8:44 ` [PATCH v3 0/7] Lcore variables Mattias Rönnblom
2024-09-12 8:44 ` [PATCH v3 1/7] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-09-16 10:52 ` [PATCH v4 0/7] Lcore variables Mattias Rönnblom
2024-09-16 10:52 ` [PATCH v4 1/7] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-09-16 14:02 ` Konstantin Ananyev
2024-09-16 17:39 ` Morten Brørup
2024-09-16 23:19 ` Konstantin Ananyev
2024-09-17 7:12 ` Morten Brørup
2024-09-17 8:09 ` Konstantin Ananyev
2024-09-17 14:28 ` Mattias Rönnblom
2024-09-17 16:11 ` Konstantin Ananyev
2024-09-18 7:00 ` Mattias Rönnblom
2024-09-17 16:29 ` Konstantin Ananyev
2024-09-18 7:50 ` Mattias Rönnblom
2024-09-17 14:32 ` [PATCH v5 0/7] Lcore variables Mattias Rönnblom
2024-09-17 14:32 ` [PATCH v5 1/7] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-09-18 8:00 ` [PATCH v6 0/7] Lcore variables Mattias Rönnblom
2024-09-18 8:00 ` [PATCH v6 1/7] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-09-18 8:24 ` Konstantin Ananyev
2024-09-18 8:25 ` Mattias Rönnblom
2024-09-18 8:26 ` [PATCH v7 0/7] Lcore variables Mattias Rönnblom
2024-09-18 8:26 ` [PATCH v7 1/7] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-09-18 9:23 ` Konstantin Ananyev
2024-10-09 22:15 ` Morten Brørup
2024-10-10 10:40 ` Mattias Rönnblom
2024-10-10 11:47 ` Morten Brørup
2024-10-10 13:12 ` Morten Brørup
2024-10-10 13:42 ` Mattias Rönnblom
2024-10-10 13:40 ` Mattias Rönnblom
2024-10-10 13:45 ` Morten Brørup
2024-10-10 16:21 ` Mattias Rönnblom
2024-10-10 14:13 ` [PATCH v8 0/7] Lcore variables Mattias Rönnblom
2024-10-10 14:13 ` [PATCH v8 1/7] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-10-10 14:21 ` [PATCH v9 0/7] Lcore variables Mattias Rönnblom
2024-10-10 14:21 ` [PATCH v9 1/7] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-10-10 15:54 ` Stephen Hemminger
2024-10-10 16:17 ` Mattias Rönnblom
2024-10-10 16:31 ` Stephen Hemminger
2024-10-10 21:24 ` Thomas Monjalon
2024-10-11 8:04 ` Mattias Rönnblom
2024-10-11 8:46 ` Morten Brørup
2024-10-11 9:11 ` Thomas Monjalon
2024-10-14 6:51 ` Mattias Rönnblom
2024-10-14 15:19 ` Stephen Hemminger
2024-10-16 8:05 ` Thomas Monjalon
2024-10-11 8:09 ` Morten Brørup
2024-10-11 8:42 ` Thomas Monjalon
2024-10-11 8:18 ` [PATCH v10 0/7] Lcore variables Mattias Rönnblom
2024-10-11 8:18 ` [PATCH v10 1/7] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-10-14 7:43 ` [PATCH v11 0/7] Lcore variables Mattias Rönnblom
2024-10-14 7:43 ` [PATCH v11 1/7] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-10-14 8:17 ` Morten Brørup
2024-10-15 6:41 ` Mattias Rönnblom
2024-10-15 7:10 ` Mattias Rönnblom
2024-10-15 7:39 ` Morten Brørup
2024-10-15 9:09 ` Mattias Rönnblom
2024-10-16 8:10 ` Thomas Monjalon
2024-10-15 8:19 ` Morten Brørup
2024-10-15 6:54 ` [PATCH v12 0/7] Lcore variables Mattias Rönnblom
2024-10-15 6:54 ` [PATCH v12 1/7] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-10-15 9:33 ` [PATCH v13 0/7] Lcore variables Mattias Rönnblom
2024-10-15 9:33 ` [PATCH v13 1/7] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-10-15 10:13 ` Morten Brørup
2024-10-15 19:02 ` Mattias Rönnblom
2024-10-15 20:19 ` Morten Brørup
2024-10-15 22:33 ` Stephen Hemminger
2024-10-16 4:13 ` Mattias Rönnblom
2024-10-16 8:17 ` Thomas Monjalon
2024-10-16 12:47 ` Mattias Rönnblom
2024-10-15 22:35 ` Stephen Hemminger
2024-10-16 4:23 ` Mattias Rönnblom
2024-10-16 13:19 ` [PATCH v14 0/7] Lcore variables Mattias Rönnblom
2024-10-16 13:19 ` [PATCH v14 1/7] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-10-16 14:53 ` Stephen Hemminger
2024-10-17 5:38 ` Mattias Rönnblom
2024-10-17 5:57 ` [PATCH v15 0/7] Lcore variables Mattias Rönnblom
2024-10-17 5:57 ` [PATCH v15 1/7] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-10-17 5:57 ` [PATCH v15 2/7] eal: add lcore variable functional tests Mattias Rönnblom
2024-10-17 5:57 ` [PATCH v15 3/7] eal: add lcore variable performance test Mattias Rönnblom
2024-10-17 5:57 ` [PATCH v15 4/7] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-10-17 5:57 ` [PATCH v15 5/7] power: keep per-lcore " Mattias Rönnblom
2024-10-17 5:57 ` [PATCH v15 6/7] service: " Mattias Rönnblom
2024-10-17 5:57 ` [PATCH v15 7/7] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-10-18 15:37 ` [PATCH v15 0/7] Lcore variables Thomas Monjalon
2024-10-19 4:24 ` Mattias Rönnblom
2024-10-21 9:16 ` Thomas Monjalon
2024-10-23 7:52 ` [PATCH v16 0/8] " Mattias Rönnblom
2024-10-23 7:52 ` [PATCH v16 1/8] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-10-23 7:52 ` [PATCH v16 2/8] eal: add lcore variable functional tests Mattias Rönnblom
2024-10-23 7:52 ` [PATCH v16 3/8] eal: add lcore variable performance test Mattias Rönnblom
2024-10-23 7:52 ` [PATCH v16 4/8] eal: add lcore variables' programmer's guide Mattias Rönnblom
2024-10-23 7:52 ` [PATCH v16 5/8] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-10-23 7:53 ` [PATCH v16 6/8] power: keep per-lcore " Mattias Rönnblom
2024-10-23 7:53 ` [PATCH v16 7/8] service: " Mattias Rönnblom
2024-10-23 7:53 ` [PATCH v16 8/8] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-10-25 8:41 ` [PATCH v17 0/8] Lcore variables Mattias Rönnblom
2024-10-25 8:41 ` [PATCH v17 1/8] eal: add static per-lcore memory allocation facility Mattias Rönnblom
2024-10-25 8:41 ` [PATCH v17 2/8] eal: add lcore variable functional tests Mattias Rönnblom
2024-10-25 8:41 ` [PATCH v17 3/8] eal: add lcore variable performance test Mattias Rönnblom
2024-10-25 8:41 ` [PATCH v17 4/8] eal: add lcore variables' programmer's guide Mattias Rönnblom
2024-10-25 8:41 ` [PATCH v17 5/8] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-10-25 8:41 ` [PATCH v17 6/8] power: keep per-lcore " Mattias Rönnblom
2024-10-25 8:41 ` [PATCH v17 7/8] service: " Mattias Rönnblom
2024-10-25 8:41 ` [PATCH v17 8/8] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-11-07 22:44 ` [PATCH v17 0/8] Lcore variables Thomas Monjalon
2024-10-16 13:19 ` [PATCH v14 2/7] eal: add lcore variable functional tests Mattias Rönnblom
2024-10-16 13:19 ` [PATCH v14 3/7] eal: add lcore variable performance test Mattias Rönnblom
2024-10-16 13:19 ` [PATCH v14 4/7] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-10-16 13:19 ` [PATCH v14 5/7] power: keep per-lcore " Mattias Rönnblom
2024-10-16 13:19 ` [PATCH v14 6/7] service: " Mattias Rönnblom
2024-10-16 13:19 ` [PATCH v14 7/7] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-10-16 14:58 ` [PATCH v14 0/7] Lcore variables Stephen Hemminger
2024-10-17 5:40 ` Mattias Rönnblom
2024-10-15 9:33 ` [PATCH v13 2/7] eal: add lcore variable functional tests Mattias Rönnblom
2024-10-15 9:33 ` [PATCH v13 3/7] eal: add lcore variable performance test Mattias Rönnblom
2024-10-15 9:33 ` [PATCH v13 4/7] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-10-15 9:33 ` [PATCH v13 5/7] power: keep per-lcore " Mattias Rönnblom
2024-10-15 9:33 ` [PATCH v13 6/7] service: " Mattias Rönnblom
2024-10-15 9:33 ` [PATCH v13 7/7] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-10-15 6:55 ` [PATCH v12 2/7] eal: add lcore variable functional tests Mattias Rönnblom
2024-10-15 6:55 ` [PATCH v12 3/7] eal: add lcore variable performance test Mattias Rönnblom
2024-10-15 6:55 ` [PATCH v12 4/7] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-10-15 6:55 ` [PATCH v12 5/7] power: keep per-lcore " Mattias Rönnblom
2024-10-15 6:55 ` [PATCH v12 6/7] service: " Mattias Rönnblom
2024-10-15 6:55 ` [PATCH v12 7/7] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-10-14 7:43 ` [PATCH v11 2/7] eal: add lcore variable functional tests Mattias Rönnblom
2024-10-14 7:43 ` [PATCH v11 3/7] eal: add lcore variable performance test Mattias Rönnblom
2024-10-14 7:43 ` [PATCH v11 4/7] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-10-14 7:43 ` [PATCH v11 5/7] power: keep per-lcore " Mattias Rönnblom
2024-10-14 7:43 ` [PATCH v11 6/7] service: " Mattias Rönnblom
2024-10-14 7:43 ` [PATCH v11 7/7] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-10-14 16:30 ` Stephen Hemminger
2024-10-15 6:48 ` Mattias Rönnblom
2024-10-11 8:18 ` [PATCH v10 2/7] eal: add lcore variable functional tests Mattias Rönnblom
2024-10-11 8:18 ` [PATCH v10 3/7] eal: add lcore variable performance test Mattias Rönnblom
2024-10-11 8:18 ` [PATCH v10 4/7] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-10-11 8:18 ` [PATCH v10 5/7] power: keep per-lcore " Mattias Rönnblom
2024-10-11 8:19 ` [PATCH v10 6/7] service: " Mattias Rönnblom
2024-10-11 8:19 ` [PATCH v10 7/7] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-10-11 14:25 ` [PATCH v10 0/7] Lcore variables Stephen Hemminger
2024-10-13 7:02 ` Mattias Rönnblom
2024-10-16 8:07 ` Thomas Monjalon
2024-10-10 14:22 ` [PATCH v9 2/7] eal: add lcore variable functional tests Mattias Rönnblom
2024-10-10 14:22 ` [PATCH v9 3/7] eal: add lcore variable performance test Mattias Rönnblom
2024-10-10 14:22 ` [PATCH v9 4/7] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-10-10 14:22 ` [PATCH v9 5/7] power: keep per-lcore " Mattias Rönnblom
2024-10-10 14:22 ` [PATCH v9 6/7] service: " Mattias Rönnblom
2024-10-10 14:22 ` [PATCH v9 7/7] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-10-10 14:13 ` [PATCH v8 2/7] eal: add lcore variable functional tests Mattias Rönnblom
2024-10-10 14:13 ` [PATCH v8 3/7] eal: add lcore variable performance test Mattias Rönnblom
2024-10-10 14:13 ` [PATCH v8 4/7] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-10-10 14:13 ` [PATCH v8 5/7] power: keep per-lcore " Mattias Rönnblom
2024-10-10 14:13 ` [PATCH v8 6/7] service: " Mattias Rönnblom
2024-10-10 14:13 ` [PATCH v8 7/7] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-10-11 14:23 ` [PATCH v8 0/7] Lcore variables Stephen Hemminger
2024-10-13 7:04 ` Mattias Rönnblom
2024-09-18 8:26 ` [PATCH v7 2/7] eal: add lcore variable functional tests Mattias Rönnblom
2024-09-18 8:26 ` [PATCH v7 3/7] eal: add lcore variable performance test Mattias Rönnblom
2024-10-09 20:46 ` Morten Brørup
2024-10-10 14:17 ` Mattias Rönnblom
2024-09-18 8:26 ` [PATCH v7 4/7] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-09-18 8:26 ` [PATCH v7 5/7] power: keep per-lcore " Mattias Rönnblom
2024-09-18 8:26 ` [PATCH v7 6/7] service: " Mattias Rönnblom
2024-09-18 8:26 ` [PATCH v7 7/7] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-09-18 9:30 ` [PATCH v7 0/7] Lcore variables fengchengwen
2024-10-10 5:06 ` Stephen Hemminger
2024-09-18 8:00 ` [PATCH v6 2/7] eal: add lcore variable functional tests Mattias Rönnblom
2024-09-18 8:25 ` Konstantin Ananyev
2024-09-18 8:00 ` [PATCH v6 3/7] eal: add lcore variable performance test Mattias Rönnblom
2024-09-18 8:00 ` [PATCH v6 4/7] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-09-18 8:00 ` [PATCH v6 5/7] power: keep per-lcore " Mattias Rönnblom
2024-09-18 8:00 ` [PATCH v6 6/7] service: " Mattias Rönnblom
2024-09-18 8:00 ` [PATCH v6 7/7] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-09-17 14:32 ` [PATCH v5 2/7] eal: add lcore variable functional tests Mattias Rönnblom
2024-09-17 14:32 ` [PATCH v5 3/7] eal: add lcore variable performance test Mattias Rönnblom
2024-09-17 15:40 ` Morten Brørup
2024-09-18 6:05 ` Mattias Rönnblom
2024-09-17 14:32 ` [PATCH v5 4/7] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-09-17 14:32 ` [PATCH v5 5/7] power: keep per-lcore " Mattias Rönnblom
2024-09-17 14:32 ` [PATCH v5 6/7] service: " Mattias Rönnblom
2024-09-17 14:32 ` [PATCH v5 7/7] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-09-16 10:52 ` [PATCH v4 2/7] eal: add lcore variable functional tests Mattias Rönnblom
2024-09-16 10:52 ` [PATCH v4 3/7] eal: add lcore variable performance test Mattias Rönnblom
2024-09-16 11:13 ` Mattias Rönnblom
2024-09-16 11:54 ` Morten Brørup
2024-09-16 16:12 ` Mattias Rönnblom
2024-09-16 17:19 ` Morten Brørup
2024-09-16 10:52 ` [PATCH v4 4/7] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-09-16 16:11 ` Konstantin Ananyev
2024-09-16 10:52 ` [PATCH v4 5/7] power: keep per-lcore " Mattias Rönnblom
2024-09-16 16:12 ` Konstantin Ananyev
2024-09-16 10:52 ` [PATCH v4 6/7] service: " Mattias Rönnblom
2024-09-16 16:13 ` Konstantin Ananyev
2024-09-16 10:52 ` [PATCH v4 7/7] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-09-16 16:14 ` Konstantin Ananyev
2024-09-12 8:44 ` [PATCH v3 2/7] eal: add lcore variable functional tests Mattias Rönnblom
2024-09-12 8:44 ` [PATCH v3 3/7] eal: add lcore variable performance test Mattias Rönnblom
2024-09-12 9:39 ` Morten Brørup
2024-09-12 13:01 ` Mattias Rönnblom
2024-09-12 13:09 ` Jerin Jacob
2024-09-12 13:20 ` Mattias Rönnblom
2024-09-12 15:11 ` Jerin Jacob
2024-09-13 6:47 ` Mattias Rönnblom
2024-09-13 11:23 ` Jerin Jacob
2024-09-13 14:40 ` Morten Brørup
2024-09-16 8:12 ` Jerin Jacob
2024-09-16 9:51 ` Morten Brørup
2024-09-16 10:50 ` Mattias Rönnblom
2024-09-18 10:04 ` Jerin Jacob
2024-09-12 8:44 ` [PATCH v3 4/7] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-09-12 8:44 ` [PATCH v3 5/7] power: keep per-lcore " Mattias Rönnblom
2024-09-12 8:44 ` [PATCH v3 6/7] service: " Mattias Rönnblom
2024-09-12 8:44 ` [PATCH v3 7/7] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-09-12 9:10 ` [PATCH v2 1/6] eal: add static per-lcore memory allocation facility Morten Brørup
2024-09-12 13:16 ` Jerin Jacob
2024-09-12 13:41 ` Morten Brørup
2024-09-12 15:22 ` Jerin Jacob
2024-09-18 10:11 ` Jerin Jacob
2024-09-19 19:31 ` Mattias Rönnblom
2024-10-14 7:56 ` Morten Brørup
2024-10-15 6:29 ` Mattias Rönnblom
2024-09-11 17:04 ` [PATCH v2 2/6] eal: add lcore variable test suite Mattias Rönnblom
2024-09-12 7:35 ` Jerin Jacob
2024-09-12 8:56 ` Mattias Rönnblom
2024-09-11 17:04 ` [PATCH v2 3/6] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-09-11 17:04 ` [PATCH v2 4/6] power: keep per-lcore " Mattias Rönnblom
2024-09-11 17:04 ` [PATCH v2 5/6] service: " Mattias Rönnblom
2024-09-11 17:04 ` [PATCH v2 6/6] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-09-10 7:03 ` [PATCH 2/6] eal: add lcore variable test suite Mattias Rönnblom
2024-09-10 7:03 ` [PATCH 3/6] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-09-10 7:03 ` [PATCH 4/6] power: keep per-lcore " Mattias Rönnblom
2024-09-10 7:03 ` [PATCH 5/6] service: " Mattias Rönnblom
2024-09-10 7:03 ` [PATCH 6/6] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-05-06 8:27 ` [RFC v6 2/6] eal: add lcore variable test suite Mattias Rönnblom
2024-05-06 8:27 ` [RFC v6 3/6] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-05-06 8:27 ` [RFC v6 4/6] power: keep per-lcore " Mattias Rönnblom
2024-05-06 8:27 ` [RFC v6 5/6] service: " Mattias Rönnblom
2024-05-06 8:27 ` [RFC v6 6/6] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-09-02 14:42 ` [RFC v6 0/6] Lcore variables Morten Brørup
2024-09-10 6:41 ` Mattias Rönnblom
2024-09-10 15:41 ` Stephen Hemminger
2024-02-28 10:09 ` [RFC v5 2/6] eal: add lcore variable test suite Mattias Rönnblom
2024-02-28 10:09 ` [RFC v5 3/6] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-02-28 10:09 ` [RFC v5 4/6] power: keep per-lcore " Mattias Rönnblom
2024-02-28 10:09 ` [RFC v5 5/6] service: " Mattias Rönnblom
2024-02-28 10:09 ` [RFC v5 6/6] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-02-25 15:03 ` [RFC v4 2/6] eal: add lcore variable test suite Mattias Rönnblom
2024-02-25 15:03 ` [RFC v4 3/6] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-02-25 15:03 ` [RFC v4 4/6] power: keep per-lcore " Mattias Rönnblom
2024-02-25 15:03 ` [RFC v4 5/6] service: " Mattias Rönnblom
2024-02-25 16:28 ` Mattias Rönnblom
2024-02-25 15:03 ` [RFC v4 6/6] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-02-20 8:49 ` [RFC v3 2/6] eal: add lcore variable test suite Mattias Rönnblom
2024-02-20 8:49 ` [RFC v3 3/6] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-02-20 15:31 ` Morten Brørup
2024-02-20 8:49 ` [RFC v3 4/6] power: keep per-lcore " Mattias Rönnblom
2024-02-20 8:49 ` [RFC v3 5/6] service: " Mattias Rönnblom
2024-02-22 9:42 ` Morten Brørup
2024-02-23 10:19 ` Mattias Rönnblom
2024-02-20 8:49 ` [RFC v3 6/6] eal: keep per-lcore power intrinsics " Mattias Rönnblom
2024-02-19 9:40 ` [RFC v2 2/5] eal: add lcore variable test suite Mattias Rönnblom
2024-02-19 9:40 ` [RFC v2 3/5] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-02-19 11:22 ` Morten Brørup
2024-02-19 14:04 ` Mattias Rönnblom
2024-02-19 15:10 ` Morten Brørup
2024-02-19 9:40 ` [RFC v2 4/5] power: keep per-lcore " Mattias Rönnblom
2024-02-19 9:40 ` [RFC v2 5/5] service: " Mattias Rönnblom
2024-02-08 18:16 ` [RFC 2/5] eal: add lcore variable test suite Mattias Rönnblom
2024-02-08 18:16 ` [RFC 3/5] random: keep PRNG state in lcore variable Mattias Rönnblom
2024-02-08 18:16 ` [RFC 4/5] power: keep per-lcore " Mattias Rönnblom
2024-02-08 18:16 ` [RFC 5/5] service: " Mattias Rönnblom
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20240208181644.455233-2-mattias.ronnblom@ericsson.com \
--to=mattias.ronnblom@ericsson.com \
--cc=dev@dpdk.org \
--cc=hofors@lysator.liu.se \
--cc=mb@smartsharesystems.com \
--cc=stephen@networkplumber.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).