[v5] graph: expose node context as pointers
Checks
Commit Message
In some cases, the node context data is used to store two pointers
because the data is larger than the reserved 16 bytes. Having to define
intermediate structures just to be able to cast is tedious. And without
intermediate structures, casting to opaque pointers is hard without
violating strict aliasing rules.
Add an unnamed union to allow storing opaque pointers in the node
context. Unfortunately, aligning an unnamed union that contains an array
produces inconsistent results between C and C++. To preserve ABI/API
compatibility in both C and C++, move all fast-path area fields into an
unnamed struct which is cache aligned. Use __rte_cache_min_aligned to
preserve existing alignment on architectures where cache lines are 128
bytes.
Add a static assert to ensure that the unnamed union is not larger than
the context array (RTE_NODE_CTX_SZ).
Signed-off-by: Robin Jarry <rjarry@redhat.com>
---
Notes:
v5:
* Helper functions to hide casting proved to be harder than expected.
Naive casting may even be impossible without breaking strict aliasing
rules. The only other option would be to use explicit memcpy calls.
* Unnamed union tentative again. As suggested by Tyler (thank you!),
using an intermediate unnamed struct to carry the alignment produces
consistent ABI in C and C++.
* Also, Tyler (thank you!) suggested that the fast path area alignment
size may be incorrect for architectures where the cache line is not 64
bytes. There will be a 64 bytes hole in the structure at the end of
the unnamed struct before the zero length next nodes array. Use
__rte_cache_min_aligned to preserve existing alignment.
v4:
* Replaced the unnamed union with helper inline functions.
v3:
* Added __extension__ to the unnamed struct inside the union.
* Fixed C++ header checks.
* Replaced alignas() with an explicit static_assert.
lib/graph/rte_graph_worker_common.h | 27 ++++++++++++++++++++-------
1 file changed, 20 insertions(+), 7 deletions(-)
Comments
Acked-by: Nithin Dabilpuram <ndabilpuram@marvell.com>
On Wed, Mar 27, 2024 at 2:47 PM Robin Jarry <rjarry@redhat.com> wrote:
>
> In some cases, the node context data is used to store two pointers
> because the data is larger than the reserved 16 bytes. Having to define
> intermediate structures just to be able to cast is tedious. And without
> intermediate structures, casting to opaque pointers is hard without
> violating strict aliasing rules.
>
> Add an unnamed union to allow storing opaque pointers in the node
> context. Unfortunately, aligning an unnamed union that contains an array
> produces inconsistent results between C and C++. To preserve ABI/API
> compatibility in both C and C++, move all fast-path area fields into an
> unnamed struct which is cache aligned. Use __rte_cache_min_aligned to
> preserve existing alignment on architectures where cache lines are 128
> bytes.
>
> Add a static assert to ensure that the unnamed union is not larger than
> the context array (RTE_NODE_CTX_SZ).
>
> Signed-off-by: Robin Jarry <rjarry@redhat.com>
> ---
>
> Notes:
> v5:
>
> * Helper functions to hide casting proved to be harder than expected.
> Naive casting may even be impossible without breaking strict aliasing
> rules. The only other option would be to use explicit memcpy calls.
> * Unnamed union tentative again. As suggested by Tyler (thank you!),
> using an intermediate unnamed struct to carry the alignment produces
> consistent ABI in C and C++.
> * Also, Tyler (thank you!) suggested that the fast path area alignment
> size may be incorrect for architectures where the cache line is not 64
> bytes. There will be a 64 bytes hole in the structure at the end of
> the unnamed struct before the zero length next nodes array. Use
> __rte_cache_min_aligned to preserve existing alignment.
>
> v4:
>
> * Replaced the unnamed union with helper inline functions.
>
> v3:
>
> * Added __extension__ to the unnamed struct inside the union.
> * Fixed C++ header checks.
> * Replaced alignas() with an explicit static_assert.
>
> lib/graph/rte_graph_worker_common.h | 27 ++++++++++++++++++++-------
> 1 file changed, 20 insertions(+), 7 deletions(-)
>
> diff --git a/lib/graph/rte_graph_worker_common.h b/lib/graph/rte_graph_worker_common.h
> index 36d864e2c14e..84d4997bbbf6 100644
> --- a/lib/graph/rte_graph_worker_common.h
> +++ b/lib/graph/rte_graph_worker_common.h
> @@ -12,7 +12,9 @@
> * process, enqueue and move streams of objects to the next nodes.
> */
>
> +#include <assert.h>
> #include <stdalign.h>
> +#include <stddef.h>
>
> #include <rte_common.h>
> #include <rte_cycles.h>
> @@ -111,14 +113,21 @@ struct __rte_cache_aligned rte_node {
> } dispatch;
> };
> /* Fast path area */
> + __extension__ struct __rte_cache_min_aligned {
> #define RTE_NODE_CTX_SZ 16
> - alignas(RTE_CACHE_LINE_SIZE) uint8_t ctx[RTE_NODE_CTX_SZ]; /**< Node Context. */
> - uint16_t size; /**< Total number of objects available. */
> - uint16_t idx; /**< Number of objects used. */
> - rte_graph_off_t off; /**< Offset of node in the graph reel. */
> - uint64_t total_cycles; /**< Cycles spent in this node. */
> - uint64_t total_calls; /**< Calls done to this node. */
> - uint64_t total_objs; /**< Objects processed by this node. */
> + union {
> + uint8_t ctx[RTE_NODE_CTX_SZ];
> + __extension__ struct {
> + void *ctx_ptr;
> + void *ctx_ptr2;
> + };
> + }; /**< Node Context. */
> + uint16_t size; /**< Total number of objects available. */
> + uint16_t idx; /**< Number of objects used. */
> + rte_graph_off_t off; /**< Offset of node in the graph reel. */
> + uint64_t total_cycles; /**< Cycles spent in this node. */
> + uint64_t total_calls; /**< Calls done to this node. */
> + uint64_t total_objs; /**< Objects processed by this node. */
> union {
> void **objs; /**< Array of object pointers. */
> uint64_t objs_u64;
> @@ -127,9 +136,13 @@ struct __rte_cache_aligned rte_node {
> rte_node_process_t process; /**< Process function. */
> uint64_t process_u64;
> };
> + };
> alignas(RTE_CACHE_LINE_MIN_SIZE) struct rte_node *nodes[]; /**< Next nodes. */
> };
>
> +static_assert(offsetof(struct rte_node, size) - offsetof(struct rte_node, ctx) == RTE_NODE_CTX_SZ,
> + "rte_node context must be RTE_NODE_CTX_SZ bytes exactly");
> +
> /**
> * @internal
> *
> --
> 2.44.0
>
Re Robin,
On Wed, Mar 27, 2024 at 10:17 AM Robin Jarry <rjarry@redhat.com> wrote:
>
> In some cases, the node context data is used to store two pointers
> because the data is larger than the reserved 16 bytes. Having to define
> intermediate structures just to be able to cast is tedious. And without
> intermediate structures, casting to opaque pointers is hard without
> violating strict aliasing rules.
>
> Add an unnamed union to allow storing opaque pointers in the node
> context. Unfortunately, aligning an unnamed union that contains an array
> produces inconsistent results between C and C++. To preserve ABI/API
> compatibility in both C and C++, move all fast-path area fields into an
> unnamed struct which is cache aligned. Use __rte_cache_min_aligned to
> preserve existing alignment on architectures where cache lines are 128
> bytes.
>
> Add a static assert to ensure that the unnamed union is not larger than
> the context array (RTE_NODE_CTX_SZ).
>
> Signed-off-by: Robin Jarry <rjarry@redhat.com>
> ---
>
> Notes:
> v5:
>
> * Helper functions to hide casting proved to be harder than expected.
> Naive casting may even be impossible without breaking strict aliasing
> rules. The only other option would be to use explicit memcpy calls.
> * Unnamed union tentative again. As suggested by Tyler (thank you!),
> using an intermediate unnamed struct to carry the alignment produces
> consistent ABI in C and C++.
> * Also, Tyler (thank you!) suggested that the fast path area alignment
> size may be incorrect for architectures where the cache line is not 64
> bytes. There will be a 64 bytes hole in the structure at the end of
> the unnamed struct before the zero length next nodes array. Use
> __rte_cache_min_aligned to preserve existing alignment.
- There is still an issue with that approach on 128 bytes cache line
arches, like ARM.
This results in a ABI breakage:
Functions changes summary: 0 Removed, 1 Changed (9 filtered out), 0
Added functions
Variables changes summary: 0 Removed, 0 Changed, 0 Added variable
1 function with some indirect sub-type change:
[C] 'function bool
__rte_graph_mcore_dispatch_sched_node_enqueue(rte_node*,
rte_graph_rq_head*)' at rte_graph_model_mcore_dispatch.c:117:1 has
some indirect sub-type changes:
parameter 1 of type 'rte_node*' has sub-type changes:
in pointed to type 'struct rte_node' at rte_graph_worker_common.h:92:1:
type size changed from 3072 to 2048 (in bits)
7 data member deletions:
'uint8_t ctx[16]', at offset 2048 (in bits) at
rte_graph_worker_common.h:115:1
'uint16_t size', at offset 2176 (in bits) at
rte_graph_worker_common.h:116:1
'uint16_t idx', at offset 2192 (in bits) at
rte_graph_worker_common.h:117:1
'rte_graph_off_t off', at offset 2208 (in bits) at
rte_graph_worker_common.h:118:1
'uint64_t total_cycles', at offset 2240 (in bits) at
rte_graph_worker_common.h:119:1
'uint64_t total_calls', at offset 2304 (in bits) at
rte_graph_worker_common.h:120:1
'uint64_t total_objs', at offset 2368 (in bits) at
rte_graph_worker_common.h:121:1
1 data member insertion:
'struct {union {uint8_t ctx[16]; struct {void* ctx_ptr;
void* ctx_ptr2;};}; uint16_t size; uint16_t idx; rte_graph_off_t off;
uint64_t total_cycles; uint64_t total_calls; uint64_t total_objs;
union {void** objs; uint64_t objs_u64;}; union {rte_node_process_t
process; uint64_t process_u64;};}', at offset 1536 (in bits)
1 data member changes (1 filtered):
'rte_node* nodes[]' offset changed from 2560 to 2048 (in
bits) (by -512 bits)
Before the patch, the rte_node object layout was:
struct rte_node {
...
/* XXX 64 bytes hole, try to pack */
/* --- cacheline 4 boundary (256 bytes) --- */
uint8_t ctx[16]
__attribute__((__aligned__(128))); /* 256 16 */
uint16_t size; /* 272 2 */
uint16_t idx; /* 274 2 */
rte_graph_off_t off; /* 276 4 */
uint64_t total_cycles; /* 280 8 */
uint64_t total_calls; /* 288 8 */
uint64_t total_objs; /* 296 8 */
union {
void * * objs; /* 304 8 */
uint64_t objs_u64; /* 304 8 */
}; /* 304 8 */
union {
rte_node_process_t process; /* 312 8 */
uint64_t process_u64; /* 312 8 */
}; /* 312 8 */
/* --- cacheline 5 boundary (320 bytes) --- */
struct rte_node * nodes[]
__attribute__((__aligned__(64))); /* 320 0 */
/* size: 384, cachelines: 6, members: 20 */
/* sum members: 250, holes: 3, sum holes: 70 */
/* padding: 64 */
/* forced alignments: 2, forced holes: 1, sum forced holes: 64 */
} __attribute__((__aligned__(128)));
After this patch:
struct rte_node {
...
/* --- cacheline 3 boundary (192 bytes) --- */
struct {
union {
uint8_t ctx[16]; /* 192 16 */
struct {
void * ctx_ptr; /* 192 8 */
void * ctx_ptr2; /* 200 8 */
}; /* 192 16 */
}; /* 192 16 */
uint16_t size; /* 208 2 */
uint16_t idx; /* 210 2 */
rte_graph_off_t off; /* 212 4 */
uint64_t total_cycles; /* 216 8 */
uint64_t total_calls; /* 224 8 */
uint64_t total_objs; /* 232 8 */
union {
void * * objs; /* 240 8 */
uint64_t objs_u64; /* 240 8 */
}; /* 240 8 */
union {
rte_node_process_t process; /* 248 8 */
uint64_t process_u64; /* 248 8 */
}; /* 248 8 */
} __attribute__((__aligned__(64)))
__attribute__((__aligned__(64))); /* 192 64 */
/* --- cacheline 4 boundary (256 bytes) --- */
struct rte_node * nodes[]
__attribute__((__aligned__(64))); /* 256 0 */
/* size: 256, cachelines: 4, members: 12 */
/* sum members: 250, holes: 2, sum holes: 6 */
/* forced alignments: 2 */
} __attribute__((__aligned__(128)));
The introduced anonymous structure gets aligned on the minimum cache
line size (64 bytes): with this change, ctx[] move from offset 256, to
offset 192.
Similarly, nodes[] moves from offset 320 to offset 256.
As we discussed offlist, there are a few options to workaround this
issue (like moving nodes[] inside the anonymous struct though it still
results in an increased rte_node struct, or like adding an explicit
padding field right before the newly introduced anonymous struct,
...).
- Additionally, anonymous structures are not correctly handled with
libabigail 2.4 which is the version used in the CI.
At the moment, the ABI check in GHA and UNH will fail on x86 with:
1 function with some indirect sub-type change:
[C] 'function bool
__rte_graph_mcore_dispatch_sched_node_enqueue(rte_node*,
rte_graph_rq_head*)' at rte_graph_model_mcore_dispatch.c:117:1 has
some indirect sub-type changes:
parameter 1 of type 'rte_node*' has sub-type changes:
in pointed to type 'struct rte_node' at rte_graph_worker_common.h:92:1:
type size hasn't changed
2 data member deletions:
'union {void** objs; uint64_t objs_u64;}', at offset 1920 (in bits)
'union {rte_node_process_t process; uint64_t process_u64;}',
at offset 1984 (in bits)
no data member changes (2 filtered);
On this topic, we have to either put a suppression rule on the
rte_node structure, or bump the libabigail version in UNH, GHA, and
the maintainers build env (though the latter won't happen overnight,
and we are really close to rc1).
For those two reasons, it is better to revisit this patch and have it
ready for the next release.
While at it, it may be worth cleaning up the rte_node structure in
v24.11, if so, please announce in a deprecation notice for this
planned ABI breakage.
Sad :(
> The introduced anonymous structure gets aligned on the minimum cache
> line size (64 bytes): with this change, ctx[] move from offset 256, to
> offset 192.
> Similarly, nodes[] moves from offset 320 to offset 256.
>
> As we discussed offlist, there are a few options to workaround this
> issue (like moving nodes[] inside the anonymous struct though it still
> results in an increased rte_node struct, or like adding an explicit
> padding field right before the newly introduced anonymous struct,
> ...).
[snip]
> For those two reasons, it is better to revisit this patch and have it
> ready for the next release.
> While at it, it may be worth cleaning up the rte_node structure in
> v24.11, if so, please announce in a deprecation notice for this
> planned ABI breakage.
Jerin, wouldn't it be better if we managed to fill in that 64 bytes
hole?
I don't know what to announce precisely about the breakage nature.
On Tue, Jun 25, 2024 at 9:02 PM Robin Jarry <rjarry@redhat.com> wrote:
>
> Sad :(
>
> > The introduced anonymous structure gets aligned on the minimum cache
> > line size (64 bytes): with this change, ctx[] move from offset 256, to
> > offset 192.
> > Similarly, nodes[] moves from offset 320 to offset 256.
> >
> > As we discussed offlist, there are a few options to workaround this
> > issue (like moving nodes[] inside the anonymous struct though it still
> > results in an increased rte_node struct, or like adding an explicit
> > padding field right before the newly introduced anonymous struct,
> > ...).
> [snip]
> > For those two reasons, it is better to revisit this patch and have it
> > ready for the next release.
> > While at it, it may be worth cleaning up the rte_node structure in
> > v24.11, if so, please announce in a deprecation notice for this
> > planned ABI breakage.
>
> Jerin, wouldn't it be better if we managed to fill in that 64 bytes
> hole?
It will be available only for 128B cache line system. So may not make sense.
I think, following change will resolve the issue in your patch.
From
__extension__ struct __rte_cache_min_aligned {
#define RTE_NODE_CTX_SZ 16
To
__extension__ struct __rte_cache__aligned {
#define RTE_NODE_CTX_SZ 16
>
> I don't know what to announce precisely about the breakage nature.
>
@@ -12,7 +12,9 @@
* process, enqueue and move streams of objects to the next nodes.
*/
+#include <assert.h>
#include <stdalign.h>
+#include <stddef.h>
#include <rte_common.h>
#include <rte_cycles.h>
@@ -111,14 +113,21 @@ struct __rte_cache_aligned rte_node {
} dispatch;
};
/* Fast path area */
+ __extension__ struct __rte_cache_min_aligned {
#define RTE_NODE_CTX_SZ 16
- alignas(RTE_CACHE_LINE_SIZE) uint8_t ctx[RTE_NODE_CTX_SZ]; /**< Node Context. */
- uint16_t size; /**< Total number of objects available. */
- uint16_t idx; /**< Number of objects used. */
- rte_graph_off_t off; /**< Offset of node in the graph reel. */
- uint64_t total_cycles; /**< Cycles spent in this node. */
- uint64_t total_calls; /**< Calls done to this node. */
- uint64_t total_objs; /**< Objects processed by this node. */
+ union {
+ uint8_t ctx[RTE_NODE_CTX_SZ];
+ __extension__ struct {
+ void *ctx_ptr;
+ void *ctx_ptr2;
+ };
+ }; /**< Node Context. */
+ uint16_t size; /**< Total number of objects available. */
+ uint16_t idx; /**< Number of objects used. */
+ rte_graph_off_t off; /**< Offset of node in the graph reel. */
+ uint64_t total_cycles; /**< Cycles spent in this node. */
+ uint64_t total_calls; /**< Calls done to this node. */
+ uint64_t total_objs; /**< Objects processed by this node. */
union {
void **objs; /**< Array of object pointers. */
uint64_t objs_u64;
@@ -127,9 +136,13 @@ struct __rte_cache_aligned rte_node {
rte_node_process_t process; /**< Process function. */
uint64_t process_u64;
};
+ };
alignas(RTE_CACHE_LINE_MIN_SIZE) struct rte_node *nodes[]; /**< Next nodes. */
};
+static_assert(offsetof(struct rte_node, size) - offsetof(struct rte_node, ctx) == RTE_NODE_CTX_SZ,
+ "rte_node context must be RTE_NODE_CTX_SZ bytes exactly");
+
/**
* @internal
*