Skip to contentSkip to conversation

eal: allow worker lcore stacks to be allocated from hugepage memory

PATCH In review Don Wallwork 10 participants 36 messages May 2, 2022 – Jun 23, 2022

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 eal: allow worker lcore stacks to be allocated from hugepage memory

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore.

EAL option '--huge-worker-stack [stack-size-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

---
 lib/eal/common/eal_common_options.c | 31 ++++++++++++++
 lib/eal/common/eal_internal_cfg.h   |  4 ++
 lib/eal/common/eal_options.h        |  2 +
 lib/eal/linux/eal.c                 | 65 ++++++++++++++++++++++++++++-
 4 files changed, 100 insertions(+), 2 deletions(-)
lib/eal/common/eal_common_options.c +31 -0
index f247a42455..be9db9ee37 100644
@@ -103,6 +103,7 @@ eal_long_options[] = {
 	{OPT_TELEMETRY,         0, NULL, OPT_TELEMETRY_NUM        },
 	{OPT_NO_TELEMETRY,      0, NULL, OPT_NO_TELEMETRY_NUM     },
 	{OPT_FORCE_MAX_SIMD_BITWIDTH, 1, NULL, OPT_FORCE_MAX_SIMD_BITWIDTH_NUM},
+	{OPT_HUGE_WORKER_STACK, 2, NULL, OPT_HUGE_WORKER_STACK_NUM     },
 
 	{0,                     0, NULL, 0                        }
 };
@@ -1618,6 +1619,22 @@ eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out)
 	return -1;
 }
 
+static int
+eal_parse_huge_worker_stack(const char *arg, size_t *huge_worker_stack_size)
+{
+	size_t worker_stack_size;
+	if (arg == NULL) {
+		*huge_worker_stack_size = USE_OS_STACK_SIZE;
+		return 0;
+	}
+	worker_stack_size = atoi(arg);
+	if (worker_stack_size == 0)
+		return -1;
+
+	*huge_worker_stack_size = worker_stack_size * 1024;
+	return 0;
+}
+
 int
 eal_parse_common_option(int opt, const char *optarg,
 			struct internal_config *conf)
@@ -1921,6 +1938,15 @@ eal_parse_common_option(int opt, const char *optarg,
 		}
 		break;
 
+	case OPT_HUGE_WORKER_STACK_NUM:
+		if (eal_parse_huge_worker_stack(optarg,
+						&conf->huge_worker_stack_size) < 0) {
+			RTE_LOG(ERR, EAL, "invalid parameter for --"
+				OPT_HUGE_WORKER_STACK"\n");
+			return -1;
+		}
+		break;
+
 	/* don't know what to do, leave this to caller */
 	default:
 		return 1;
@@ -2235,5 +2261,10 @@ eal_common_usage(void)
 	       "  --"OPT_NO_PCI"            Disable PCI\n"
 	       "  --"OPT_NO_HPET"           Disable HPET\n"
 	       "  --"OPT_NO_SHCONF"         No shared config (mmap'd files)\n"
+	       "  --"OPT_HUGE_WORKER_STACK"[=size]\n"
+	       "                      Allocate worker thread stacks from\n"
+	       "                      hugepage memory.  Size is in units of\n"
+	       "                      kbytes and defaults to system thread\n"
+	       "                      stack size if not specified.\n"
 	       "\n", RTE_MAX_LCORE);
 }
lib/eal/common/eal_internal_cfg.h +4 -0
index b71faadd18..6a43c872fc 100644
@@ -48,6 +48,9 @@ struct hugepage_file_discipline {
 	bool unlink_existing;
 };
 
+/** Worker hugepage stack size should default to OS value. */
+#define USE_OS_STACK_SIZE ((size_t)~0)
+
 /**
  * internal configuration
  */
@@ -102,6 +105,7 @@ struct internal_config {
 	unsigned int no_telemetry; /**< true to disable Telemetry */
 	struct simd_bitwidth max_simd_bitwidth;
 	/**< max simd bitwidth path to use */
+	size_t huge_worker_stack_size; /**< worker thread stack size in bytes */
 };
 
 void eal_reset_internal_config(struct internal_config *internal_cfg);
lib/eal/common/eal_options.h +2 -0
index 8e4f7202a2..3cc9cb6412 100644
@@ -87,6 +87,8 @@ enum {
 	OPT_NO_TELEMETRY_NUM,
 #define OPT_FORCE_MAX_SIMD_BITWIDTH  "force-max-simd-bitwidth"
 	OPT_FORCE_MAX_SIMD_BITWIDTH_NUM,
+#define OPT_HUGE_WORKER_STACK  "huge-worker-stack"
+	OPT_HUGE_WORKER_STACK_NUM,
 
 	OPT_LONG_MAX_NUM
 };
lib/eal/linux/eal.c +63 -2

71 lines not on this page · raw message

Signature · 1 line
2.17.1
Acked-by on v1 1/1
#1 lore raw
Quoted 11 lines

From: Don Wallwork [mailto:[email protected]]
Sent: Monday, 2 May 2022 16.11

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore.

EAL option '--huge-worker-stack [stack-size-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

Quoted 8 lines
---
 lib/eal/common/eal_common_options.c | 31 ++++++++++++++
 lib/eal/common/eal_internal_cfg.h   |  4 ++
 lib/eal/common/eal_options.h        |  2 +
 lib/eal/linux/eal.c                 | 65 ++++++++++++++++++++++++++++-
 4 files changed, 100 insertions(+), 2 deletions(-)
#2 lore raw
In reply to Don Wallwork
Quoted 42 lines

-----Original Message-----
From: Don Wallwork <[email protected]>
Sent: Monday, May 2, 2022 22:11
To: [email protected]
Cc: [email protected]; [email protected]; [email protected]; Burakov, Anatoly <[email protected]>; [email protected]; Richardson, Bruce <[email protected]>; [email protected]; [email protected]
Subject: [PATCH] eal: allow worker lcore stacks to be allocated from hugepage memory

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore.

EAL option '--huge-worker-stack [stack-size-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

---
 lib/eal/common/eal_common_options.c | 31 ++++++++++++++
 lib/eal/common/eal_internal_cfg.h   |  4 ++
 lib/eal/common/eal_options.h        |  2 +
 lib/eal/linux/eal.c                 | 65 ++++++++++++++++++++++++++++-
 4 files changed, 100 insertions(+), 2 deletions(-)
lib/eal/common/eal_common_options.c +2 -0
index f247a42455..be9db9ee37 100644
@@ -103,6 +103,7 @@ eal_long_options[] = {
 	{OPT_TELEMETRY,         0, NULL, OPT_TELEMETRY_NUM        },
 	{OPT_NO_TELEMETRY,      0, NULL, OPT_NO_TELEMETRY_NUM     },
 	{OPT_FORCE_MAX_SIMD_BITWIDTH, 1, NULL, OPT_FORCE_MAX_SIMD_BITWIDTH_NUM},
+	{OPT_HUGE_WORKER_STACK, 2, NULL, OPT_HUGE_WORKER_STACK_NUM     },
 
 	{0,                     0, NULL, 0                        }
 };
@@ -1618,6 +1619,22 @@ eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out)
 	return -1;
 }
 
+static int

lib/eal/common/eal_common_options.c eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out) · line 1632

Quoted 10 lines
lib/eal/common/eal_common_options.c +10 -0
+eal_parse_huge_worker_stack(const char *arg, size_t *huge_worker_stack_size)
+{
+	size_t worker_stack_size;
+	if (arg == NULL) {
+		*huge_worker_stack_size = USE_OS_STACK_SIZE;
+		return 0;
+	}
+	worker_stack_size = atoi(arg);
+	if (worker_stack_size == 0)
+		return -1;

Should we also to check "worker_stack_size *1024 < PTHREAD_STACK_MIN" ?

Quoted 9 lines
lib/eal/common/eal_common_options.c +5 -1
+
+	*huge_worker_stack_size = worker_stack_size * 1024;
+	return 0;
+}
+
 
 
--

2.17.1

#3 lore raw
Quoted 41 lines · Haiyue
Quoted 41 lines

-----Original Message-----
From: Don Wallwork <[email protected]>
Sent: Monday, May 2, 2022 22:11
To: [email protected]
Cc: [email protected]; [email protected]; [email protected]; Burakov, Anatoly <[email protected]>; [email protected]; Richardson, Bruce <[email protected]>; [email protected]; [email protected]
Subject: [PATCH] eal: allow worker lcore stacks to be allocated from hugepage memory

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore.

EAL option '--huge-worker-stack [stack-size-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

---
  lib/eal/common/eal_common_options.c | 31 ++++++++++++++
  lib/eal/common/eal_internal_cfg.h   |  4 ++
  lib/eal/common/eal_options.h        |  2 +
  lib/eal/linux/eal.c                 | 65 ++++++++++++++++++++++++++++-
  4 files changed, 100 insertions(+), 2 deletions(-)
lib/eal/common/eal_common_options.c +1 -0
index f247a42455..be9db9ee37 100644
@@ -103,6 +103,7 @@ eal_long_options[] = {
  	{OPT_TELEMETRY,         0, NULL, OPT_TELEMETRY_NUM        },
  	{OPT_NO_TELEMETRY,      0, NULL, OPT_NO_TELEMETRY_NUM     },
  	{OPT_FORCE_MAX_SIMD_BITWIDTH, 1, NULL, OPT_FORCE_MAX_SIMD_BITWIDTH_NUM},
+	{OPT_HUGE_WORKER_STACK, 2, NULL, OPT_HUGE_WORKER_STACK_NUM     },
 
  	{0,                     0, NULL, 0                        }
  };
@@ -1618,6 +1619,22 @@ eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out)
  	return -1;
  }
 
Quoted 12 lines

lib/eal/common/eal_common_options.c eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out) · line 1632

Quoted 11 lines
lib/eal/common/eal_common_options.c +11 -0
+static int
+eal_parse_huge_worker_stack(const char *arg, size_t *huge_worker_stack_size)
+{
+	size_t worker_stack_size;
+	if (arg == NULL) {
+		*huge_worker_stack_size = USE_OS_STACK_SIZE;
+		return 0;
+	}
+	worker_stack_size = atoi(arg);
+	if (worker_stack_size == 0)
+		return -1;

Should we also to check "worker_stack_size *1024 < PTHREAD_STACK_MIN" ?

This may be too restrictive in certain environments.  For example, memory constrained platforms may require a smaller worker stack size than this limit would allow.

Quoted 8 lines
Quoted 8 lines
lib/eal/common/eal_common_options.c +5 -1
+
+	*huge_worker_stack_size = worker_stack_size * 1024;
+	return 0;
+}
+
 
--

2.17.1

#4 lore raw
Quoted 64 lines

-----Original Message-----
From: Don Wallwork <[email protected]>
Sent: Wednesday, May 4, 2022 03:47
To: Wang, Haiyue <[email protected]>; [email protected]
Cc: [email protected]; [email protected]; Burakov, Anatoly <[email protected]>; [email protected]; Richardson, Bruce <[email protected]>; [email protected]; [email protected]
Subject: Re: [PATCH] eal: allow worker lcore stacks to be allocated from hugepage memory

Quoted 6 lines · Haiyue
Quoted 6 lines

-----Original Message-----
From: Don Wallwork <[email protected]>
Sent: Monday, May 2, 2022 22:11
To: [email protected]
Cc: [email protected]; [email protected]; [email protected]; Burakov, Anatoly <[email protected]>; [email protected]; Richardson, Bruce

<[email protected]>;

Quoted 35 lines
Quoted 35 lines

[email protected]; [email protected]
Subject: [PATCH] eal: allow worker lcore stacks to be allocated from hugepage memory

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore.

EAL option '--huge-worker-stack [stack-size-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

---
  lib/eal/common/eal_common_options.c | 31 ++++++++++++++
  lib/eal/common/eal_internal_cfg.h   |  4 ++
  lib/eal/common/eal_options.h        |  2 +
  lib/eal/linux/eal.c                 | 65 ++++++++++++++++++++++++++++-
  4 files changed, 100 insertions(+), 2 deletions(-)
lib/eal/common/eal_common_options.c +1 -0
index f247a42455..be9db9ee37 100644
@@ -103,6 +103,7 @@ eal_long_options[] = {
  	{OPT_TELEMETRY,         0, NULL, OPT_TELEMETRY_NUM        },
  	{OPT_NO_TELEMETRY,      0, NULL, OPT_NO_TELEMETRY_NUM     },
  	{OPT_FORCE_MAX_SIMD_BITWIDTH, 1, NULL, OPT_FORCE_MAX_SIMD_BITWIDTH_NUM},
+	{OPT_HUGE_WORKER_STACK, 2, NULL, OPT_HUGE_WORKER_STACK_NUM     },
 
  	{0,                     0, NULL, 0                        }
  };
@@ -1618,6 +1619,22 @@ eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out)
  	return -1;
  }
 
Quoted 12 lines

lib/eal/common/eal_common_options.c eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out) · line 1632

Quoted 11 lines
lib/eal/common/eal_common_options.c +11 -0
+static int
+eal_parse_huge_worker_stack(const char *arg, size_t *huge_worker_stack_size)
+{
+	size_t worker_stack_size;
+	if (arg == NULL) {
+		*huge_worker_stack_size = USE_OS_STACK_SIZE;
+		return 0;
+	}
+	worker_stack_size = atoi(arg);
+	if (worker_stack_size == 0)
+		return -1;

Should we also to check "worker_stack_size *1024 < PTHREAD_STACK_MIN" ?

Quoted 3 lines

This may be too restrictive in certain environments.  For example, memory constrained platforms may require a smaller worker stack size than this limit would allow.

Understood, thanks.

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
lib/eal/common/eal_common_options.c +5 -1
+
+	*huge_worker_stack_size = worker_stack_size * 1024;
+	return 0;
+}
+
 
--

2.17.1

#5 lore raw

PATCH v2 1/1 eal: allow worker lcore stacks to be allocated from hugepage memory

In reply to Don Wallwork

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore.

EAL option '--huge-worker-stack [stack-size-in-KiB]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

---
 doc/guides/linux_gsg/eal_args.include.rst     |  6 ++
 .../prog_guide/env_abstraction_layer.rst      | 21 ++++++
 lib/eal/common/eal_common_options.c           | 28 ++++++++
 lib/eal/common/eal_internal_cfg.h             |  4 ++
 lib/eal/common/eal_options.h                  |  2 +
 lib/eal/linux/eal.c                           | 65 ++++++++++++++++++-
 6 files changed, 124 insertions(+), 2 deletions(-)
doc/guides/linux_gsg/eal_args.include.rst +6 -0
index 3549a0cf56..d189109a55 100644
@@ -116,6 +116,12 @@ Memory-related options
 
     Force IOVA mode to a specific value.
 
+*   ``--huge-worker-stack[=size]``
+
+    Allocate worker stack memory from hugepage memory.  Stack size defaults
+    to system pthread stack size unless the optional size (in kbytes) is
+    specified.
+
 Debugging options
 ~~~~~~~~~~~~~~~~~
 
doc/guides/prog_guide/env_abstraction_layer.rst +21 -0
index 5f0748fba1..e74516f0cf 100644
@@ -329,6 +329,27 @@ Another option is to use bigger page sizes. Since fewer pages are required to
 cover the same memory area, fewer file descriptors will be stored internally
 by EAL.
 
+.. _huge-worker-stack:
+
+Hugepage Worker Stacks
+^^^^^^^^^^^^^^^^^^^^^^
+
+When the ``--huge-worker-stack[=size]`` EAL option is specified, worker
+thread stacks are allocated from hugepage memory local to the NUMA node
+of the thread. Worker stack size defaults to system pthread stack size
+if the optional size parameter is not specified.
+
+.. warning::
+    Stacks allocated from hugepage memory are not protected by guard
+    pages. Worker stacks must be sufficiently sized to prevent stack
+    overflow when this option is used.
+
+    As with normal thread stacks, hugepage worker thread stack size is
+    fixed and is not dynamically resized. Therefore, an application that
+    is free of stack page faults under a given load should be safe with
+    hugepage worker thread stacks given the same thread stack size and
+    loading conditions.
+
 Support for Externally Allocated Memory
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
lib/eal/common/eal_common_options.c +28 -0
index f247a42455..7fc5e10928 100644
@@ -103,6 +103,7 @@ eal_long_options[] = {
 	{OPT_TELEMETRY,         0, NULL, OPT_TELEMETRY_NUM        },
 	{OPT_NO_TELEMETRY,      0, NULL, OPT_NO_TELEMETRY_NUM     },
 	{OPT_FORCE_MAX_SIMD_BITWIDTH, 1, NULL, OPT_FORCE_MAX_SIMD_BITWIDTH_NUM},
+	{OPT_HUGE_WORKER_STACK, 2, NULL, OPT_HUGE_WORKER_STACK_NUM     },
 
 	{0,                     0, NULL, 0                        }
 };
@@ -1618,6 +1619,22 @@ eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out)
 	return -1;
 }
 
+static int
+eal_parse_huge_worker_stack(const char *arg, size_t *huge_worker_stack_size)
+{
+	size_t worker_stack_size;
+	if (arg == NULL) {
+		*huge_worker_stack_size = USE_OS_STACK_SIZE;
+		return 0;
+	}
+	worker_stack_size = atoi(arg);
+	if (worker_stack_size == 0)
+		return -1;
+
+	*huge_worker_stack_size = worker_stack_size * 1024;
+	return 0;
+}
+
 int
 eal_parse_common_option(int opt, const char *optarg,
 			struct internal_config *conf)
@@ -1921,6 +1938,17 @@ eal_parse_common_option(int opt, const char *optarg,
 		}
 		break;
 
+#ifndef RTE_EXEC_ENV_WINDOWS
+	case OPT_HUGE_WORKER_STACK_NUM:
+		if (eal_parse_huge_worker_stack(optarg,
+						&conf->huge_worker_stack_size) < 0) {
+			RTE_LOG(ERR, EAL, "invalid parameter for --"
+				OPT_HUGE_WORKER_STACK"\n");
+			return -1;
+		}
+		break;
+#endif /* !RTE_EXEC_ENV_WINDOWS */
+
 	/* don't know what to do, leave this to caller */
 	default:
 		return 1;
lib/eal/common/eal_internal_cfg.h +4 -0
index b71faadd18..8ac710da02 100644
@@ -48,6 +48,9 @@ struct hugepage_file_discipline {
 	bool unlink_existing;
 };
 
+/** Worker hugepage stack size should default to OS value. */
+#define USE_OS_STACK_SIZE ((size_t)~0)
+
 /**
  * internal configuration
  */
@@ -102,6 +105,7 @@ struct internal_config {
 	unsigned int no_telemetry; /**< true to disable Telemetry */
 	struct simd_bitwidth max_simd_bitwidth;
 	/**< max simd bitwidth path to use */
+	size_t huge_worker_stack_size; /**< worker thread stack size in KiB */
 };
 
 void eal_reset_internal_config(struct internal_config *internal_cfg);
lib/eal/common/eal_options.h +2 -0
index 8e4f7202a2..3cc9cb6412 100644
@@ -87,6 +87,8 @@ enum {
 	OPT_NO_TELEMETRY_NUM,
 #define OPT_FORCE_MAX_SIMD_BITWIDTH  "force-max-simd-bitwidth"
 	OPT_FORCE_MAX_SIMD_BITWIDTH_NUM,
+#define OPT_HUGE_WORKER_STACK  "huge-worker-stack"
+	OPT_HUGE_WORKER_STACK_NUM,
 
 	OPT_LONG_MAX_NUM
 };
lib/eal/linux/eal.c +63 -2

71 lines not on this page · raw message

Signature · 1 line
2.17.1
#6 lore raw

lib/eal/common/eal_common_options.c eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out) · line 1633

Quoted 12 lines · On Fri, 13 May 2022 13:58:22 -0400 Don Wallwork <[email protected]> wrote:
lib/eal/common/eal_common_options.c +12 -0
+static int
+eal_parse_huge_worker_stack(const char *arg, size_t *huge_worker_stack_size)
+{
+	size_t worker_stack_size;
+	if (arg == NULL) {
+		*huge_worker_stack_size = USE_OS_STACK_SIZE;
+		return 0;
+	}
+	worker_stack_size = atoi(arg);
+	if (worker_stack_size == 0)
+		return -1;
+

Since worker_stack_size is size_t you are better off using something like strtoul() and check for more errors from that

#7 lore raw
Quoted 17 lines · Stephen Hemminger

lib/eal/common/eal_common_options.c eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out) · line 1633

Quoted 12 lines · On Fri, 13 May 2022 13:58:22 -0400 Don Wallwork <[email protected]> wrote:
lib/eal/common/eal_common_options.c +12 -0
+static int
+eal_parse_huge_worker_stack(const char *arg, size_t *huge_worker_stack_size)
+{
+	size_t worker_stack_size;
+	if (arg == NULL) {
+		*huge_worker_stack_size = USE_OS_STACK_SIZE;
+		return 0;
+	}
+	worker_stack_size = atoi(arg);
+	if (worker_stack_size == 0)
+		return -1;
+

Since worker_stack_size is size_t you are better off using something like strtoul() and check for more errors from that

This and your other comment are addressed in the v3 patch.

#8 lore raw
In reply to Don Wallwork
Quoted 52 lines · On Fri, 13 May 2022 13:58:22 -0400 Don Wallwork <[email protected]> wrote:
lib/eal/linux/eal.c +52 -0
+		if (internal_conf->huge_worker_stack_size == 0) {
+			ret = pthread_create(&lcore_config[i].thread_id, NULL,
+					     eal_thread_loop,
+					     (void *)(uintptr_t)i);
+		} else {
+			/* Allocate NUMA aware stack memory and set
+			 * pthread attributes
+			 */
+			pthread_attr_t attr;
+			size_t stack_size;
+			void *stack_ptr;
+
+			if (pthread_attr_init(&attr) != 0) {
+				rte_eal_init_alert("Cannot init pthread "
+						   "attributes");
+				rte_errno = EFAULT;
+				return -1;
+			}
+			if (internal_conf->huge_worker_stack_size ==
+			    USE_OS_STACK_SIZE) {
+				if (pthread_attr_getstacksize(&attr,
+							      &stack_size) != 0) {
+					rte_errno = EFAULT;
+					return -1;
+				}
+			} else {
+				stack_size =
+					internal_conf->huge_worker_stack_size;
+			}
+			stack_ptr =
+				rte_zmalloc_socket("lcore_stack",
+						   stack_size,
+						   stack_size,
+						   rte_lcore_to_socket_id(i));
+
+			if (stack_ptr == NULL) {
+				rte_eal_init_alert("Cannot allocate stack "
+						   "memory for worker lcore");
+				rte_errno = ENOMEM;
+				return -1;
+			}
+
+			if (pthread_attr_setstack(&attr,
+						  stack_ptr,
+						  stack_size) != 0) {
+				rte_eal_init_alert("Cannot set pthread "
+						   "stack attributes");
+				rte_errno = EFAULT;
+				return -1;
+			}
+
+			/* create a thread for each lcore */

lib/eal/linux/eal.c rte_eal_init(int argc, char **argv) · line 1208

Quoted 10 lines
lib/eal/linux/eal.c +10 -0
+			ret = pthread_create(&lcore_config[i].thread_id, &attr,
+					     eal_thread_loop,
+					     (void *)(uintptr_t)i);
+
+			if (pthread_attr_destroy(&attr) != 0) {
+				rte_eal_init_alert("Cannot destroy pthread "
+						   "attributes");
+				rte_errno = EFAULT;
+				return -1;
+			}

The indentation is getting kind of deep here, and to me that indicates a good place to split this into a helper function?

#9 lore raw
In reply to Don Wallwork
Quoted 24 lines · Don Wallwork

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore.

EAL option '--huge-worker-stack [stack-size-in-KiB]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

---
 doc/guides/linux_gsg/eal_args.include.rst     |  6 ++
 .../prog_guide/env_abstraction_layer.rst      | 21 ++++++
 lib/eal/common/eal_common_options.c           | 28 ++++++++
 lib/eal/common/eal_internal_cfg.h             |  4 ++
 lib/eal/common/eal_options.h                  |  2 +
 lib/eal/linux/eal.c                           | 65 ++++++++++++++++++-
 6 files changed, 124 insertions(+), 2 deletions(-)
doc/guides/linux_gsg/eal_args.include.rst +0 -0
index 3549a0cf56..d189109a55 100644

doc/guides/linux_gsg/eal_args.include.rst Memory-related options · line 121

Quoted 6 lines
doc/guides/linux_gsg/eal_args.include.rst +3 -0
@@ -116,6 +116,12 @@ Memory-related options
 
     Force IOVA mode to a specific value.
 
+*   ``--huge-worker-stack[=size]``
+
+    Allocate worker stack memory from hugepage memory.  Stack size defaults

Two consecutive spaces befor 'Stack' ?

Quoted 51 lines
doc/guides/linux_gsg/eal_args.include.rst +3 -0
+    to system pthread stack size unless the optional size (in kbytes) is
+    specified.
+
 Debugging options
 ~~~~~~~~~~~~~~~~~
 
doc/guides/prog_guide/env_abstraction_layer.rst +21 -0
index 5f0748fba1..e74516f0cf 100644
@@ -329,6 +329,27 @@ Another option is to use bigger page sizes. Since fewer pages are required to
 cover the same memory area, fewer file descriptors will be stored internally
 by EAL.
 
+.. _huge-worker-stack:
+
+Hugepage Worker Stacks
+^^^^^^^^^^^^^^^^^^^^^^
+
+When the ``--huge-worker-stack[=size]`` EAL option is specified, worker
+thread stacks are allocated from hugepage memory local to the NUMA node
+of the thread. Worker stack size defaults to system pthread stack size
+if the optional size parameter is not specified.
+
+.. warning::
+    Stacks allocated from hugepage memory are not protected by guard
+    pages. Worker stacks must be sufficiently sized to prevent stack
+    overflow when this option is used.
+
+    As with normal thread stacks, hugepage worker thread stack size is
+    fixed and is not dynamically resized. Therefore, an application that
+    is free of stack page faults under a given load should be safe with
+    hugepage worker thread stacks given the same thread stack size and
+    loading conditions.
+
 Support for Externally Allocated Memory
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
lib/eal/common/eal_common_options.c +1 -0
index f247a42455..7fc5e10928 100644
@@ -103,6 +103,7 @@ eal_long_options[] = {
 	{OPT_TELEMETRY,         0, NULL, OPT_TELEMETRY_NUM        },
 	{OPT_NO_TELEMETRY,      0, NULL, OPT_NO_TELEMETRY_NUM     },
 	{OPT_FORCE_MAX_SIMD_BITWIDTH, 1, NULL, OPT_FORCE_MAX_SIMD_BITWIDTH_NUM},
+	{OPT_HUGE_WORKER_STACK, 2, NULL, OPT_HUGE_WORKER_STACK_NUM     },
 
 	{0,                     0, NULL, 0                        }
 };

lib/eal/common/eal_common_options.c eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out) · line 1626

Quoted 8 lines
lib/eal/common/eal_common_options.c +5 -0
@@ -1618,6 +1619,22 @@ eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out)
 	return -1;
 }
 
+static int
+eal_parse_huge_worker_stack(const char *arg, size_t *huge_worker_stack_size)
+{
+	size_t worker_stack_size;
+	if (arg == NULL) {

Also consider arg[0] = '\0', maybe: if (arg == NULL || arg[0] == '\0')

lib/eal/common/eal_common_options.c eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out) · line 1630

Quoted 4 lines
lib/eal/common/eal_common_options.c +4 -0
+		*huge_worker_stack_size = USE_OS_STACK_SIZE;
+		return 0;
+	}
+	worker_stack_size = atoi(arg);

Suggest use strtoul because atoi does not detect errors. also suggest check for convert error.

Suggest refer eal_parse_simd_bitwidth()

lib/eal/common/eal_common_options.c eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out) · line 1634

Quoted 4 lines
lib/eal/common/eal_common_options.c +4 -0
+	if (worker_stack_size == 0)
+		return -1;
+
+	*huge_worker_stack_size = worker_stack_size * 1024;

Should consider overflow with multiple 1024 ?

Quoted 29 lines
lib/eal/common/eal_common_options.c +14 -0
+	return 0;
+}
+
 int
 eal_parse_common_option(int opt, const char *optarg,
 			struct internal_config *conf)
@@ -1921,6 +1938,17 @@ eal_parse_common_option(int opt, const char *optarg,
 		}
 		break;
 
+#ifndef RTE_EXEC_ENV_WINDOWS
+	case OPT_HUGE_WORKER_STACK_NUM:
+		if (eal_parse_huge_worker_stack(optarg,
+						&conf->huge_worker_stack_size) < 0) {
+			RTE_LOG(ERR, EAL, "invalid parameter for --"
+				OPT_HUGE_WORKER_STACK"\n");
+			return -1;
+		}
+		break;
+#endif /* !RTE_EXEC_ENV_WINDOWS */
+
 	/* don't know what to do, leave this to caller */
 	default:
 		return 1;
lib/eal/common/eal_internal_cfg.h +0 -0
index b71faadd18..8ac710da02 100644

lib/eal/common/eal_internal_cfg.h struct hugepage_file_discipline { · line 52

Quoted 5 lines
lib/eal/common/eal_internal_cfg.h +2 -0
@@ -48,6 +48,9 @@ struct hugepage_file_discipline {
 	bool unlink_existing;
 };
 
+/** Worker hugepage stack size should default to OS value. */
+#define USE_OS_STACK_SIZE ((size_t)~0)

the USE is verb, suggest HUGE_WORKER_STACK_DEFAULT_SIZE or HUGE_WORKER_STACK_DEFAULT_OS_SIZE

lib/eal/common/eal_internal_cfg.h struct internal_config { · line 108

Quoted 9 lines
lib/eal/common/eal_internal_cfg.h +2 -0
+
 /**
  * internal configuration
  */
@@ -102,6 +105,7 @@ struct internal_config {
 	unsigned int no_telemetry; /**< true to disable Telemetry */
 	struct simd_bitwidth max_simd_bitwidth;
 	/**< max simd bitwidth path to use */
+	size_t huge_worker_stack_size; /**< worker thread stack size in KiB */

the huge_worker_stack_size already multi 1024, so it unit is byte not KiB.

Quoted 81 lines
lib/eal/common/eal_internal_cfg.h +0 -0
 };
 
 void eal_reset_internal_config(struct internal_config *internal_cfg);
lib/eal/common/eal_options.h +2 -0
index 8e4f7202a2..3cc9cb6412 100644
@@ -87,6 +87,8 @@ enum {
 	OPT_NO_TELEMETRY_NUM,
 #define OPT_FORCE_MAX_SIMD_BITWIDTH  "force-max-simd-bitwidth"
 	OPT_FORCE_MAX_SIMD_BITWIDTH_NUM,
+#define OPT_HUGE_WORKER_STACK  "huge-worker-stack"
+	OPT_HUGE_WORKER_STACK_NUM,
 
 	OPT_LONG_MAX_NUM
 };
lib/eal/linux/eal.c +55 -2
index 1ef263434a..e8c872ef7b 100644
@@ -1144,8 +1144,69 @@ rte_eal_init(int argc, char **argv)
 		lcore_config[i].state = WAIT;
 
 		/* create a thread for each lcore */
-		ret = pthread_create(&lcore_config[i].thread_id, NULL,
-				     eal_thread_loop, (void *)(uintptr_t)i);
+		if (internal_conf->huge_worker_stack_size == 0) {
+			ret = pthread_create(&lcore_config[i].thread_id, NULL,
+					     eal_thread_loop,
+					     (void *)(uintptr_t)i);
+		} else {
+			/* Allocate NUMA aware stack memory and set
+			 * pthread attributes
+			 */
+			pthread_attr_t attr;
+			size_t stack_size;
+			void *stack_ptr;
+
+			if (pthread_attr_init(&attr) != 0) {
+				rte_eal_init_alert("Cannot init pthread "
+						   "attributes");
+				rte_errno = EFAULT;
+				return -1;
+			}
+			if (internal_conf->huge_worker_stack_size ==
+			    USE_OS_STACK_SIZE) {
+				if (pthread_attr_getstacksize(&attr,
+							      &stack_size) != 0) {
+					rte_errno = EFAULT;
+					return -1;
+				}
+			} else {
+				stack_size =
+					internal_conf->huge_worker_stack_size;
+			}
+			stack_ptr =
+				rte_zmalloc_socket("lcore_stack",
+						   stack_size,
+						   stack_size,
+						   rte_lcore_to_socket_id(i));
+
+			if (stack_ptr == NULL) {
+				rte_eal_init_alert("Cannot allocate stack "
+						   "memory for worker lcore");
+				rte_errno = ENOMEM;
+				return -1;
+			}
+
+			if (pthread_attr_setstack(&attr,
+						  stack_ptr,
+						  stack_size) != 0) {
+				rte_eal_init_alert("Cannot set pthread "
+						   "stack attributes");
+				rte_errno = EFAULT;
+				return -1;
+			}
+
+			/* create a thread for each lcore */
+			ret = pthread_create(&lcore_config[i].thread_id, &attr,
+					     eal_thread_loop,
+					     (void *)(uintptr_t)i);

lib/eal/linux/eal.c rte_eal_init(int argc, char **argv) · line 1211

Quoted 10 lines
lib/eal/linux/eal.c +8 -0
+
+			if (pthread_attr_destroy(&attr) != 0) {
+				rte_eal_init_alert("Cannot destroy pthread "
+						   "attributes");
+				rte_errno = EFAULT;
+				return -1;
+			}
+		}
 		if (ret != 0)
 			rte_panic("Cannot create thread\n");

it's recommended that the function be independent.

Quoted 2 lines

Also, this patch seem only adapt linux, what about freebsd/windows?

#10 lore raw
Quoted 1 line · fengchengwen

Also, this patch seem only adapt linux, what about freebsd/windows?

The intent was to add this support for this optimization for Linix only initially.  Support for other OSes can be added later.  I currently don't have a means to test the other environments.

All of your other comments are addressed by the v3 patch.

#11 lore raw
Quoted 9 lines

From: Don Wallwork [mailto:[email protected]]
Sent: Monday, 16 May 2022 21.48

Quoted 1 line · fengchengwen

Also, this patch seem only adapt linux, what about freebsd/windows?

The intent was to add this support for this optimization for Linix only initially.  Support for other OSes can be added later.  I currently don't have a means to test the other environments.

I agree with this approach.

And it should suffice if the EAL aborts with an error message if the OPT_HUGE_WORKER_STACK parameter is used in a non-supported environment.

#12 lore raw

PATCH v3 1/1 eal: allow worker lcore stacks to be allocated from hugepage memory

In reply to Don Wallwork

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore.

EAL option '--huge-worker-stack [stack-size-in-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

---
 doc/guides/linux_gsg/eal_args.include.rst     |  6 ++
 .../prog_guide/env_abstraction_layer.rst      | 21 +++++++
 lib/eal/common/eal_common_options.c           | 36 +++++++++++
 lib/eal/common/eal_internal_cfg.h             |  4 ++
 lib/eal/common/eal_options.h                  |  2 +
 lib/eal/linux/eal.c                           | 61 ++++++++++++++++++-
 6 files changed, 128 insertions(+), 2 deletions(-)
doc/guides/linux_gsg/eal_args.include.rst +6 -0
index 3549a0cf56..9cfbf7de84 100644
@@ -116,6 +116,12 @@ Memory-related options
 
     Force IOVA mode to a specific value.
 
+*   ``--huge-worker-stack[=size]``
+
+    Allocate worker stack memory from hugepage memory. Stack size defaults
+    to system pthread stack size unless the optional size (in kbytes) is
+    specified.
+
 Debugging options
 ~~~~~~~~~~~~~~~~~
 
doc/guides/prog_guide/env_abstraction_layer.rst +21 -0
index 5f0748fba1..e74516f0cf 100644
@@ -329,6 +329,27 @@ Another option is to use bigger page sizes. Since fewer pages are required to
 cover the same memory area, fewer file descriptors will be stored internally
 by EAL.
 
+.. _huge-worker-stack:
+
+Hugepage Worker Stacks
+^^^^^^^^^^^^^^^^^^^^^^
+
+When the ``--huge-worker-stack[=size]`` EAL option is specified, worker
+thread stacks are allocated from hugepage memory local to the NUMA node
+of the thread. Worker stack size defaults to system pthread stack size
+if the optional size parameter is not specified.
+
+.. warning::
+    Stacks allocated from hugepage memory are not protected by guard
+    pages. Worker stacks must be sufficiently sized to prevent stack
+    overflow when this option is used.
+
+    As with normal thread stacks, hugepage worker thread stack size is
+    fixed and is not dynamically resized. Therefore, an application that
+    is free of stack page faults under a given load should be safe with
+    hugepage worker thread stacks given the same thread stack size and
+    loading conditions.
+
 Support for Externally Allocated Memory
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
lib/eal/common/eal_common_options.c +36 -0
index f247a42455..b0d429ed34 100644
@@ -103,6 +103,7 @@ eal_long_options[] = {
 	{OPT_TELEMETRY,         0, NULL, OPT_TELEMETRY_NUM        },
 	{OPT_NO_TELEMETRY,      0, NULL, OPT_NO_TELEMETRY_NUM     },
 	{OPT_FORCE_MAX_SIMD_BITWIDTH, 1, NULL, OPT_FORCE_MAX_SIMD_BITWIDTH_NUM},
+	{OPT_HUGE_WORKER_STACK, 2, NULL, OPT_HUGE_WORKER_STACK_NUM     },
 
 	{0,                     0, NULL, 0                        }
 };
@@ -1618,6 +1619,25 @@ eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out)
 	return -1;
 }
 
+static int
+eal_parse_huge_worker_stack(const char *arg, size_t *huge_worker_stack_size)
+{
+	size_t worker_stack_size;
+	char *end;
+	if (arg == NULL || arg[0] == '\0') {
+		*huge_worker_stack_size = WORKER_STACK_SIZE_FROM_OS;
+		return 0;
+	}
+	errno = 0;
+	worker_stack_size = strtoul(arg, &end, 10);
+	if (errno || end == NULL || worker_stack_size == 0 ||
+	    worker_stack_size >= (size_t)-1 / 1024)
+		return -1;
+
+	*huge_worker_stack_size = worker_stack_size * 1024;
+	return 0;
+}
+
 int
 eal_parse_common_option(int opt, const char *optarg,
 			struct internal_config *conf)
@@ -1921,6 +1941,17 @@ eal_parse_common_option(int opt, const char *optarg,
 		}
 		break;
 
+#ifndef RTE_EXEC_ENV_WINDOWS
+	case OPT_HUGE_WORKER_STACK_NUM:
+		if (eal_parse_huge_worker_stack(optarg,
+						&conf->huge_worker_stack_size) < 0) {
+			RTE_LOG(ERR, EAL, "invalid parameter for --"
+				OPT_HUGE_WORKER_STACK"\n");
+			return -1;
+		}
+		break;
+#endif /* !RTE_EXEC_ENV_WINDOWS */
+
 	/* don't know what to do, leave this to caller */
 	default:
 		return 1;
@@ -2235,5 +2266,10 @@ eal_common_usage(void)
 	       "  --"OPT_NO_PCI"            Disable PCI\n"
 	       "  --"OPT_NO_HPET"           Disable HPET\n"
 	       "  --"OPT_NO_SHCONF"         No shared config (mmap'd files)\n"
+	       "  --"OPT_HUGE_WORKER_STACK"[=size]\n"
+	       "                      Allocate worker thread stacks from\n"
+	       "                      hugepage memory. Size is in units of\n"
+	       "                      kbytes and defaults to system thread\n"
+	       "                      stack size if not specified.\n"
 	       "\n", RTE_MAX_LCORE);
 }
lib/eal/common/eal_internal_cfg.h +4 -0
index b71faadd18..5e154967e4 100644
@@ -48,6 +48,9 @@ struct hugepage_file_discipline {
 	bool unlink_existing;
 };
 
+/** Worker hugepage stack size should default to OS value. */
+#define WORKER_STACK_SIZE_FROM_OS ((size_t)~0)
+
 /**
  * internal configuration
  */
@@ -102,6 +105,7 @@ struct internal_config {
 	unsigned int no_telemetry; /**< true to disable Telemetry */
 	struct simd_bitwidth max_simd_bitwidth;
 	/**< max simd bitwidth path to use */
+	size_t huge_worker_stack_size; /**< worker thread stack size */
 };
 
 void eal_reset_internal_config(struct internal_config *internal_cfg);
lib/eal/common/eal_options.h +2 -0
index 8e4f7202a2..3cc9cb6412 100644
@@ -87,6 +87,8 @@ enum {
 	OPT_NO_TELEMETRY_NUM,
 #define OPT_FORCE_MAX_SIMD_BITWIDTH  "force-max-simd-bitwidth"
 	OPT_FORCE_MAX_SIMD_BITWIDTH_NUM,
+#define OPT_HUGE_WORKER_STACK  "huge-worker-stack"
+	OPT_HUGE_WORKER_STACK_NUM,
 
 	OPT_LONG_MAX_NUM
 };
lib/eal/linux/eal.c +59 -2

73 lines not on this page · raw message

Signature · 1 line
2.17.1
#13 lore raw

lib/eal/common/eal_common_options.c eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out) · line 1630

Quoted 9 lines · On Mon, 16 May 2022 15:50:04 -0400 Don Wallwork <[email protected]> wrote:
lib/eal/common/eal_common_options.c +9 -0
+static int
+eal_parse_huge_worker_stack(const char *arg, size_t *huge_worker_stack_size)
+{
+	size_t worker_stack_size;
+	char *end;
+	if (arg == NULL || arg[0] == '\0') {
+		*huge_worker_stack_size = WORKER_STACK_SIZE_FROM_OS;
+		return 0;
+	}

Looks good. Minor nit if you do another version.
Please put blank line after declarations.

#14 lore raw
Quoted 4 lines · Stephen Hemminger

On Mon, 16 May 2022 15:50:04 -0400
Don Wallwork <[email protected]> wrote:

Quoted 11 lines

lib/eal/common/eal_common_options.c eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out) · line 1630

Quoted 9 lines
lib/eal/common/eal_common_options.c +9 -0
+static int
+eal_parse_huge_worker_stack(const char *arg, size_t *huge_worker_stack_size)
+{
+	size_t worker_stack_size;
+	char *end;
+	if (arg == NULL || arg[0] == '\0') {
+		*huge_worker_stack_size = WORKER_STACK_SIZE_FROM_OS;
+		return 0;
+	}

Looks good. Minor nit if you do another version.
Please put blank line after declarations.

Thanks.  Hopefully another version won't be required, but if so I'll make that change.

#15 lore raw

PATCH v4 1/1 eal: allow worker lcore stacks to be allocated from hugepage memory

In reply to Don Wallwork

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore.

EAL option '--huge-worker-stack [stack-size-in-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

---
 doc/guides/linux_gsg/eal_args.include.rst     |  6 ++
 .../prog_guide/env_abstraction_layer.rst      | 21 +++++++
 lib/eal/common/eal_common_options.c           | 41 +++++++++++++
 lib/eal/common/eal_internal_cfg.h             |  4 ++
 lib/eal/common/eal_options.h                  |  2 +
 lib/eal/linux/eal.c                           | 61 ++++++++++++++++++-
 6 files changed, 133 insertions(+), 2 deletions(-)
doc/guides/linux_gsg/eal_args.include.rst +6 -0
index 3549a0cf56..9cfbf7de84 100644
@@ -116,6 +116,12 @@ Memory-related options
 
     Force IOVA mode to a specific value.
 
+*   ``--huge-worker-stack[=size]``
+
+    Allocate worker stack memory from hugepage memory. Stack size defaults
+    to system pthread stack size unless the optional size (in kbytes) is
+    specified.
+
 Debugging options
 ~~~~~~~~~~~~~~~~~
 
doc/guides/prog_guide/env_abstraction_layer.rst +21 -0
index 5f0748fba1..e74516f0cf 100644
@@ -329,6 +329,27 @@ Another option is to use bigger page sizes. Since fewer pages are required to
 cover the same memory area, fewer file descriptors will be stored internally
 by EAL.
 
+.. _huge-worker-stack:
+
+Hugepage Worker Stacks
+^^^^^^^^^^^^^^^^^^^^^^
+
+When the ``--huge-worker-stack[=size]`` EAL option is specified, worker
+thread stacks are allocated from hugepage memory local to the NUMA node
+of the thread. Worker stack size defaults to system pthread stack size
+if the optional size parameter is not specified.
+
+.. warning::
+    Stacks allocated from hugepage memory are not protected by guard
+    pages. Worker stacks must be sufficiently sized to prevent stack
+    overflow when this option is used.
+
+    As with normal thread stacks, hugepage worker thread stack size is
+    fixed and is not dynamically resized. Therefore, an application that
+    is free of stack page faults under a given load should be safe with
+    hugepage worker thread stacks given the same thread stack size and
+    loading conditions.
+
 Support for Externally Allocated Memory
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
lib/eal/common/eal_common_options.c +41 -0

64 lines not on this page · raw message

lib/eal/common/eal_internal_cfg.h +4 -0
index b71faadd18..5e154967e4 100644
@@ -48,6 +48,9 @@ struct hugepage_file_discipline {
 	bool unlink_existing;
 };
 
+/** Worker hugepage stack size should default to OS value. */
+#define WORKER_STACK_SIZE_FROM_OS ((size_t)~0)
+
 /**
  * internal configuration
  */
@@ -102,6 +105,7 @@ struct internal_config {
 	unsigned int no_telemetry; /**< true to disable Telemetry */
 	struct simd_bitwidth max_simd_bitwidth;
 	/**< max simd bitwidth path to use */
+	size_t huge_worker_stack_size; /**< worker thread stack size */
 };
 
 void eal_reset_internal_config(struct internal_config *internal_cfg);
lib/eal/common/eal_options.h +2 -0
index 8e4f7202a2..3cc9cb6412 100644
@@ -87,6 +87,8 @@ enum {
 	OPT_NO_TELEMETRY_NUM,
 #define OPT_FORCE_MAX_SIMD_BITWIDTH  "force-max-simd-bitwidth"
 	OPT_FORCE_MAX_SIMD_BITWIDTH_NUM,
+#define OPT_HUGE_WORKER_STACK  "huge-worker-stack"
+	OPT_HUGE_WORKER_STACK_NUM,
 
 	OPT_LONG_MAX_NUM
 };
lib/eal/linux/eal.c +59 -2

73 lines not on this page · raw message

Signature · 1 line
2.17.1
#16 lore raw
Quoted 11 lines · On Tue, 17 May 2022 11:31:36 -0400 Don Wallwork <[email protected]> wrote:

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore.

EAL option '--huge-worker-stack [stack-size-in-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

---

This looks great, just thinking a little more about what the impact of using it would be.

Since the memory region for the stack is never freed, it will cause complaints from address sanitizer and maybe from valgrind.

One way to workaround that would be to use the lower level allocation routine to get the memory segments. This would make stacks a multiple of page size which would not be bad idea anyway.
Plus you could use eal_memalloc_seg_bulk.

#17 lore raw
Quoted 17 lines · Stephen Hemminger
Quoted 11 lines · On Tue, 17 May 2022 11:31:36 -0400 Don Wallwork <[email protected]> wrote:

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore.

EAL option '--huge-worker-stack [stack-size-in-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

---

This looks great, just thinking a little more about what the impact of using it would be.

Quoted 8 lines

Since the memory region for the stack is never freed, it will cause complaints from address sanitizer and maybe from valgrind.

One way to workaround that would be to use the lower level allocation routine to get the memory segments. This would make stacks a multiple of page size which would not be bad idea anyway.
Plus you could use eal_memalloc_seg_bulk.

The problem with using this API is that it requires allocating page sized stacks which would be undesirable in memory constrained environments or when the huge page size is 1GB.

We looked for a place to free this memory, but could not find any place in DPDK where the worker threads are canceled.  Obviously the worker threads have to be stopped before we can free this memory.

Acked-by on v4 1/1
#18 lore raw
In reply to Don Wallwork
Quoted 11 lines · Don Wallwork

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore.

EAL option '--huge-worker-stack [stack-size-in-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

---

snip

#19 lore raw
In reply to Don Wallwork

In this section of the code:

stack_ptr = rte_zmalloc_socket("lcore_stack",

				       stack_size,
				       stack_size,
				       rte_lcore_to_socket_id(lcore_id));

stack memory is aligned to the stack_size. According to the implementation of rte_zmalloc_socket, the alignment must be a power of two. If the user inputs a number of KBs that is not a power of two, this will fail with a generic error message of " EAL: Cannot allocate worker lcore stack memory." A check for this occurrence with a more descriptive error message and a note in the documentation would be good to include.

Quoted 279 lines

-----Original Message-----
From: Don Wallwork <[email protected]>
Sent: Tuesday, May 17, 2022 10:32 AM
To: [email protected]
Cc: [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; Honnappa Nagarahalli <[email protected]>; nd <[email protected]>; [email protected]
Subject: [PATCH v4] eal: allow worker lcore stacks to be allocated from hugepage memory

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore.

EAL option '--huge-worker-stack [stack-size-in-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

---
 doc/guides/linux_gsg/eal_args.include.rst     |  6 ++
 .../prog_guide/env_abstraction_layer.rst      | 21 +++++++
 lib/eal/common/eal_common_options.c           | 41 +++++++++++++
 lib/eal/common/eal_internal_cfg.h             |  4 ++
 lib/eal/common/eal_options.h                  |  2 +
 lib/eal/linux/eal.c                           | 61 ++++++++++++++++++-
 6 files changed, 133 insertions(+), 2 deletions(-)
doc/guides/linux_gsg/eal_args.include.rst +3 -0
index 3549a0cf56..9cfbf7de84 100644
@@ -116,6 +116,12 @@ Memory-related options
 
     Force IOVA mode to a specific value.
 
+*   ``--huge-worker-stack[=size]``
+
+    Allocate worker stack memory from hugepage memory. Stack size

defaults

doc/guides/linux_gsg/eal_args.include.rst +3 -0
+    to system pthread stack size unless the optional size (in kbytes) is
+    specified.
+
 Debugging options
 ~~~~~~~~~~~~~~~~~
doc/guides/prog_guide/env_abstraction_layer.rst +0 -0
index 5f0748fba1..e74516f0cf 100644
@@ -329,6 +329,27 @@ Another option is to use bigger page sizes. Since

fewer pages are required to cover the same memory area, fewer file descriptors will be stored internally by EAL.

+.. _huge-worker-stack:

doc/guides/prog_guide/env_abstraction_layer.rst +20 -0
+
+Hugepage Worker Stacks
+^^^^^^^^^^^^^^^^^^^^^^
+
+When the ``--huge-worker-stack[=size]`` EAL option is specified, worker
+thread stacks are allocated from hugepage memory local to the NUMA node
+of the thread. Worker stack size defaults to system pthread stack size
+if the optional size parameter is not specified.
+
+.. warning::
+    Stacks allocated from hugepage memory are not protected by guard
+    pages. Worker stacks must be sufficiently sized to prevent stack
+    overflow when this option is used.
+
+    As with normal thread stacks, hugepage worker thread stack size is
+    fixed and is not dynamically resized. Therefore, an application that
+    is free of stack page faults under a given load should be safe with
+    hugepage worker thread stacks given the same thread stack size and
+    loading conditions.
+
 Support for Externally Allocated Memory

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

lib/eal/common/eal_common_options.c +1 -0
index f247a42455..370801f19b 100644
@@ -103,6 +103,7 @@ eal_long_options[] = {
 	{OPT_TELEMETRY,         0, NULL, OPT_TELEMETRY_NUM        },
 	{OPT_NO_TELEMETRY,      0, NULL, OPT_NO_TELEMETRY_NUM     },
 	{OPT_FORCE_MAX_SIMD_BITWIDTH, 1, NULL,
 OPT_FORCE_MAX_SIMD_BITWIDTH_NUM},
+	{OPT_HUGE_WORKER_STACK, 2, NULL,
 OPT_HUGE_WORKER_STACK_NUM     },
 
lib/eal/common/eal_common_options.c +22 -0
 	{0,                     0, NULL, 0                        }
 };
@@ -1618,6 +1619,28 @@ eal_parse_huge_unlink(const char *arg, struct
 hugepage_file_discipline *out)
 	return -1;
 }
 
+#ifndef RTE_EXEC_ENV_WINDOWS
+static int
+eal_parse_huge_worker_stack(const char *arg, size_t
+*huge_worker_stack_size) {
+	size_t worker_stack_size;
+	char *end;
+
+	if (arg == NULL || arg[0] == '\0') {
+		*huge_worker_stack_size = WORKER_STACK_SIZE_FROM_OS;
+		return 0;
+	}
+	errno = 0;
+	worker_stack_size = strtoul(arg, &end, 10);
+	if (errno || end == NULL || worker_stack_size == 0 ||
+	    worker_stack_size >= (size_t)-1 / 1024)
+		return -1;
+
+	*huge_worker_stack_size = worker_stack_size * 1024;
+	return 0;
+}
+#endif
+
 int
 eal_parse_common_option(int opt, const char *optarg,
lib/eal/common/eal_common_options.c +11 -0
 			struct internal_config *conf)
@@ -1921,6 +1944,17 @@ eal_parse_common_option(int opt, const char
 *optarg,
 		}
 		break;
 
+#ifndef RTE_EXEC_ENV_WINDOWS
+	case OPT_HUGE_WORKER_STACK_NUM:
+		if (eal_parse_huge_worker_stack(optarg,
+						&conf-
 >huge_worker_stack_size) < 0) {
+			RTE_LOG(ERR, EAL, "invalid parameter for --"
+				OPT_HUGE_WORKER_STACK"\n");
+			return -1;
+		}
+		break;
+#endif /* !RTE_EXEC_ENV_WINDOWS */
+
 	/* don't know what to do, leave this to caller */
lib/eal/common/eal_common_options.c +7 -0
 	default:
 		return 1;
@@ -2235,5 +2269,12 @@ eal_common_usage(void)
 	       "  --"OPT_NO_PCI"            Disable PCI\n"
 	       "  --"OPT_NO_HPET"           Disable HPET\n"
 	       "  --"OPT_NO_SHCONF"         No shared config (mmap'd files)\n"
+#ifndef RTE_EXEC_ENV_WINDOWS
+	       "  --"OPT_HUGE_WORKER_STACK"[=size]\n"
+	       "                      Allocate worker thread stacks from\n"
+	       "                      hugepage memory. Size is in units of\n"
+	       "                      kbytes and defaults to system thread\n"
+	       "                      stack size if not specified.\n"
+#endif
 	       "\n", RTE_MAX_LCORE);
 }
lib/eal/common/eal_internal_cfg.h +4 -0
index b71faadd18..5e154967e4 100644
@@ -48,6 +48,9 @@ struct hugepage_file_discipline {
 	bool unlink_existing;
 };
 
+/** Worker hugepage stack size should default to OS value. */ #define
+WORKER_STACK_SIZE_FROM_OS ((size_t)~0)
+
 /**
  * internal configuration
  */
@@ -102,6 +105,7 @@ struct internal_config {
 	unsigned int no_telemetry; /**< true to disable Telemetry */
 	struct simd_bitwidth max_simd_bitwidth;
 	/**< max simd bitwidth path to use */
+	size_t huge_worker_stack_size; /**< worker thread stack size */
 };
 
 void eal_reset_internal_config(struct internal_config *internal_cfg); diff --git

a/lib/eal/common/eal_options.h b/lib/eal/common/eal_options.h index 8e4f7202a2..3cc9cb6412 100644

lib/eal/common/eal_options.h +2 -0
@@ -87,6 +87,8 @@ enum {
 	OPT_NO_TELEMETRY_NUM,
 #define OPT_FORCE_MAX_SIMD_BITWIDTH  "force-max-simd-bitwidth"
 	OPT_FORCE_MAX_SIMD_BITWIDTH_NUM,
+#define OPT_HUGE_WORKER_STACK  "huge-worker-stack"
+	OPT_HUGE_WORKER_STACK_NUM,
 
 	OPT_LONG_MAX_NUM
 };
lib/eal/linux/eal.c index renamed from lib/eal/linux/eal.c +0 -0

1ef263434a..2bee66577e 100644

lib/eal/linux/eal.c +58 -0
@@ -857,6 +857,64 @@ is_iommu_enabled(void)
 	return n > 2;
 }
 
+static int
+eal_worker_thread_create(struct internal_config *internal_conf,
+			 int lcore_id)
+{
+	pthread_attr_t attr;
+	size_t stack_size;
+	void *stack_ptr;
+	int ret;
+
+	if (internal_conf->huge_worker_stack_size == 0)
+		return pthread_create(&lcore_config[lcore_id].thread_id,
+				      NULL,
+				      eal_thread_loop,
+				      (void *)(uintptr_t)lcore_id);
+
+	/* Allocate NUMA aware stack memory and set pthread attributes */
+	if (pthread_attr_init(&attr) != 0) {
+		rte_eal_init_alert("Cannot init pthread attributes");
+		rte_errno = EFAULT;
+		return -1;
+	}
+	if (internal_conf->huge_worker_stack_size ==
 WORKER_STACK_SIZE_FROM_OS) {
+		if (pthread_attr_getstacksize(&attr, &stack_size) != 0) {
+			rte_errno = EFAULT;
+			return -1;
+		}
+	} else {
+		stack_size = internal_conf->huge_worker_stack_size;
+	}
+	stack_ptr = rte_zmalloc_socket("lcore_stack",
+				       stack_size,
+				       stack_size,
+				       rte_lcore_to_socket_id(lcore_id));
+
+	if (stack_ptr == NULL) {
+		rte_eal_init_alert("Cannot allocate worker lcore stack
 memory");
+		rte_errno = ENOMEM;
+		return -1;
+	}
+
+	if (pthread_attr_setstack(&attr, stack_ptr, stack_size) != 0) {
+		rte_eal_init_alert("Cannot set pthread stack attributes");
+		rte_errno = EFAULT;
+		return -1;
+	}
+
+	ret = pthread_create(&lcore_config[lcore_id].thread_id, &attr,
+			     eal_thread_loop,
+			     (void *)(uintptr_t)lcore_id);
+
+	if (pthread_attr_destroy(&attr) != 0) {
+		rte_eal_init_alert("Cannot destroy pthread attributes");
+		rte_errno = EFAULT;
+		return -1;
+	}
+	return ret;
+}
+
 /* Launch threads, called at application init(). */  int  rte_eal_init(int argc,

char **argv) @@ -1144,8 +1202,7 @@ rte_eal_init(int argc, char **argv)

lib/eal/linux/eal.c +1 -3
 		lcore_config[i].state = WAIT;
 
 		/* create a thread for each lcore */
-		ret = pthread_create(&lcore_config[i].thread_id, NULL,
-				     eal_thread_loop, (void *)(uintptr_t)i);
+		ret = eal_worker_thread_create(internal_conf, i);
 		if (ret != 0)
 			rte_panic("Cannot create thread\n");
 
--

2.17.1

#20 lore raw
Quoted 8 lines · Kathleen Capella

In this section of the code:

stack_ptr = rte_zmalloc_socket("lcore_stack",

				       stack_size,
				       stack_size,
				       rte_lcore_to_socket_id(lcore_id));

stack memory is aligned to the stack_size. According to the implementation of rte_zmalloc_socket, the alignment must be a power of two. If the user inputs a number of KBs that is not a power of two, this will fail with a generic error message of " EAL: Cannot allocate worker lcore stack memory." A check for this occurrence with a more descriptive error message and a note in the documentation would be good to include.

Good point.  Alignment to stack size is not necessary.  I'll post a new version that only requires cache line alignment.

#21 lore raw
In reply to Don Wallwork
Quoted 11 lines · Don Wallwork

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore.

EAL option '--huge-worker-stack [stack-size-in-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

---

<snip>

Quoted 10 lines

+++ b/lib/eal/common/eal_common_options.c

lib/eal/common/eal_common_options.c +1 -0
@@ -103,6 +103,7 @@ eal_long_options[] = {
  	{OPT_TELEMETRY,         0, NULL, OPT_TELEMETRY_NUM        },
  	{OPT_NO_TELEMETRY,      0, NULL, OPT_NO_TELEMETRY_NUM     },
  	{OPT_FORCE_MAX_SIMD_BITWIDTH, 1, NULL, OPT_FORCE_MAX_SIMD_BITWIDTH_NUM},
+	{OPT_HUGE_WORKER_STACK, 2, NULL, OPT_HUGE_WORKER_STACK_NUM     },
 
  	{0,                     0, NULL, 0                        }
  };

lib/eal/common/eal_common_options.c eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out) · line 1622

Quoted 4 lines
lib/eal/common/eal_common_options.c +1 -0
@@ -1618,6 +1619,28 @@ eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out)
  	return -1;
  }
 
+#ifndef RTE_EXEC_ENV_WINDOWS

Why the #ifdef-ery? This is common code, I think we can just leave it there? You could just add a check for huge_worker_stack_size in Windows EAL to guard against using this setting for Windows, but otherwise I see no need for an #ifdef here.

Signature · 2 lines
Thanks,
Anatoly
#22 lore raw
Quoted 15 lines · Anatoly
Quoted 11 lines · Don Wallwork

Add support for using hugepages for worker lcore stack memory.  The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore.

EAL option '--huge-worker-stack [stack-size-in-kbytes]' is added to allow the feature to be enabled at runtime.  If the size is not specified, the system pthread stack size will be used.

---

<snip>

Quoted 16 lines
Quoted 12 lines

+++ b/lib/eal/common/eal_common_options.c

lib/eal/common/eal_common_options.c +1 -0
@@ -103,6 +103,7 @@ eal_long_options[] = {
       {OPT_TELEMETRY,         0, NULL, OPT_TELEMETRY_NUM },
       {OPT_NO_TELEMETRY,      0, NULL, OPT_NO_TELEMETRY_NUM },
       {OPT_FORCE_MAX_SIMD_BITWIDTH, 1, NULL, OPT_FORCE_MAX_SIMD_BITWIDTH_NUM},
+    {OPT_HUGE_WORKER_STACK, 2, NULL, OPT_HUGE_WORKER_STACK_NUM     },
         {0,                     0, NULL, 0                        }
   };
@@ -1618,6 +1619,28 @@ eal_parse_huge_unlink(const char *arg, struct 
 hugepage_file_discipline *out)
       return -1;
   }
Quoted 1 line

  +#ifndef RTE_EXEC_ENV_WINDOWS

Why the #ifdef-ery? This is common code, I think we can just leave it there? You could just add a check for huge_worker_stack_size in Windows EAL to guard against using this setting for Windows, but otherwise I see no need for an #ifdef here.

Was trying to follow the convention used in other cases, but I will post a new version that eliminates the ifdefs and checks huge_worker_stack_size in FreeBSD and Windows EAL.

#23 lore raw

PATCH v5 1/1 eal: allow worker lcore stacks to be allocated from hugepage memory

In reply to Don Wallwork

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore.

EAL option '--huge-worker-stack [stack-size-in-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

---
 doc/guides/linux_gsg/eal_args.include.rst     |  6 ++
 .../prog_guide/env_abstraction_layer.rst      | 21 +++++++
 lib/eal/common/eal_common_options.c           | 41 +++++++++++++
 lib/eal/common/eal_internal_cfg.h             |  4 ++
 lib/eal/common/eal_options.h                  |  2 +
 lib/eal/linux/eal.c                           | 61 ++++++++++++++++++-
 6 files changed, 133 insertions(+), 2 deletions(-)
doc/guides/linux_gsg/eal_args.include.rst +6 -0
index 3549a0cf56..9cfbf7de84 100644
@@ -116,6 +116,12 @@ Memory-related options
 
     Force IOVA mode to a specific value.
 
+*   ``--huge-worker-stack[=size]``
+
+    Allocate worker stack memory from hugepage memory. Stack size defaults
+    to system pthread stack size unless the optional size (in kbytes) is
+    specified.
+
 Debugging options
 ~~~~~~~~~~~~~~~~~
 
doc/guides/prog_guide/env_abstraction_layer.rst +21 -0
index 5f0748fba1..e74516f0cf 100644
@@ -329,6 +329,27 @@ Another option is to use bigger page sizes. Since fewer pages are required to
 cover the same memory area, fewer file descriptors will be stored internally
 by EAL.
 
+.. _huge-worker-stack:
+
+Hugepage Worker Stacks
+^^^^^^^^^^^^^^^^^^^^^^
+
+When the ``--huge-worker-stack[=size]`` EAL option is specified, worker
+thread stacks are allocated from hugepage memory local to the NUMA node
+of the thread. Worker stack size defaults to system pthread stack size
+if the optional size parameter is not specified.
+
+.. warning::
+    Stacks allocated from hugepage memory are not protected by guard
+    pages. Worker stacks must be sufficiently sized to prevent stack
+    overflow when this option is used.
+
+    As with normal thread stacks, hugepage worker thread stack size is
+    fixed and is not dynamically resized. Therefore, an application that
+    is free of stack page faults under a given load should be safe with
+    hugepage worker thread stacks given the same thread stack size and
+    loading conditions.
+
 Support for Externally Allocated Memory
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
lib/eal/common/eal_common_options.c +41 -0

64 lines not on this page · raw message

lib/eal/common/eal_internal_cfg.h +4 -0
index b71faadd18..5e154967e4 100644
@@ -48,6 +48,9 @@ struct hugepage_file_discipline {
 	bool unlink_existing;
 };
 
+/** Worker hugepage stack size should default to OS value. */
+#define WORKER_STACK_SIZE_FROM_OS ((size_t)~0)
+
 /**
  * internal configuration
  */
@@ -102,6 +105,7 @@ struct internal_config {
 	unsigned int no_telemetry; /**< true to disable Telemetry */
 	struct simd_bitwidth max_simd_bitwidth;
 	/**< max simd bitwidth path to use */
+	size_t huge_worker_stack_size; /**< worker thread stack size */
 };
 
 void eal_reset_internal_config(struct internal_config *internal_cfg);
lib/eal/common/eal_options.h +2 -0
index 8e4f7202a2..3cc9cb6412 100644
@@ -87,6 +87,8 @@ enum {
 	OPT_NO_TELEMETRY_NUM,
 #define OPT_FORCE_MAX_SIMD_BITWIDTH  "force-max-simd-bitwidth"
 	OPT_FORCE_MAX_SIMD_BITWIDTH_NUM,
+#define OPT_HUGE_WORKER_STACK  "huge-worker-stack"
+	OPT_HUGE_WORKER_STACK_NUM,
 
 	OPT_LONG_MAX_NUM
 };
lib/eal/linux/eal.c +59 -2

73 lines not on this page · raw message

Signature · 1 line
2.17.1
#24 lore raw

PATCH v6 1/1 eal: allow worker lcore stacks to be allocated from hugepage memory

In reply to Don Wallwork

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore.

EAL option '--huge-worker-stack [stack-size-in-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

---
 doc/guides/linux_gsg/eal_args.include.rst     |  6 ++
 .../prog_guide/env_abstraction_layer.rst      | 21 +++++++
 lib/eal/common/eal_common_options.c           | 35 +++++++++++
 lib/eal/common/eal_internal_cfg.h             |  4 ++
 lib/eal/common/eal_options.h                  |  2 +
 lib/eal/freebsd/eal.c                         |  6 ++
 lib/eal/linux/eal.c                           | 61 ++++++++++++++++++-
 lib/eal/windows/eal.c                         |  6 ++
 8 files changed, 139 insertions(+), 2 deletions(-)
doc/guides/linux_gsg/eal_args.include.rst +6 -0
index 3549a0cf56..9cfbf7de84 100644
@@ -116,6 +116,12 @@ Memory-related options
 
     Force IOVA mode to a specific value.
 
+*   ``--huge-worker-stack[=size]``
+
+    Allocate worker stack memory from hugepage memory. Stack size defaults
+    to system pthread stack size unless the optional size (in kbytes) is
+    specified.
+
 Debugging options
 ~~~~~~~~~~~~~~~~~
 
doc/guides/prog_guide/env_abstraction_layer.rst +21 -0
index 5f0748fba1..e74516f0cf 100644
@@ -329,6 +329,27 @@ Another option is to use bigger page sizes. Since fewer pages are required to
 cover the same memory area, fewer file descriptors will be stored internally
 by EAL.
 
+.. _huge-worker-stack:
+
+Hugepage Worker Stacks
+^^^^^^^^^^^^^^^^^^^^^^
+
+When the ``--huge-worker-stack[=size]`` EAL option is specified, worker
+thread stacks are allocated from hugepage memory local to the NUMA node
+of the thread. Worker stack size defaults to system pthread stack size
+if the optional size parameter is not specified.
+
+.. warning::
+    Stacks allocated from hugepage memory are not protected by guard
+    pages. Worker stacks must be sufficiently sized to prevent stack
+    overflow when this option is used.
+
+    As with normal thread stacks, hugepage worker thread stack size is
+    fixed and is not dynamically resized. Therefore, an application that
+    is free of stack page faults under a given load should be safe with
+    hugepage worker thread stacks given the same thread stack size and
+    loading conditions.
+
 Support for Externally Allocated Memory
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
lib/eal/common/eal_common_options.c +35 -0
index f247a42455..02e59051e8 100644
@@ -103,6 +103,7 @@ eal_long_options[] = {
 	{OPT_TELEMETRY,         0, NULL, OPT_TELEMETRY_NUM        },
 	{OPT_NO_TELEMETRY,      0, NULL, OPT_NO_TELEMETRY_NUM     },
 	{OPT_FORCE_MAX_SIMD_BITWIDTH, 1, NULL, OPT_FORCE_MAX_SIMD_BITWIDTH_NUM},
+	{OPT_HUGE_WORKER_STACK, 2, NULL, OPT_HUGE_WORKER_STACK_NUM     },
 
 	{0,                     0, NULL, 0                        }
 };
@@ -1618,6 +1619,26 @@ eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out)
 	return -1;
 }
 
+static int
+eal_parse_huge_worker_stack(const char *arg, size_t *huge_worker_stack_size)
+{
+	size_t worker_stack_size;
+	char *end;
+
+	if (arg == NULL || arg[0] == '\0') {
+		*huge_worker_stack_size = WORKER_STACK_SIZE_FROM_OS;
+		return 0;
+	}
+	errno = 0;
+	worker_stack_size = strtoul(arg, &end, 10);
+	if (errno || end == NULL || worker_stack_size == 0 ||
+	    worker_stack_size >= (size_t)-1 / 1024)
+		return -1;
+
+	*huge_worker_stack_size = worker_stack_size * 1024;
+	return 0;
+}
+
 int
 eal_parse_common_option(int opt, const char *optarg,
 			struct internal_config *conf)
@@ -1921,6 +1942,15 @@ eal_parse_common_option(int opt, const char *optarg,
 		}
 		break;
 
+	case OPT_HUGE_WORKER_STACK_NUM:
+		if (eal_parse_huge_worker_stack(optarg,
+						&conf->huge_worker_stack_size) < 0) {
+			RTE_LOG(ERR, EAL, "invalid parameter for --"
+				OPT_HUGE_WORKER_STACK"\n");
+			return -1;
+		}
+		break;
+
 	/* don't know what to do, leave this to caller */
 	default:
 		return 1;
@@ -2235,5 +2265,10 @@ eal_common_usage(void)
 	       "  --"OPT_NO_PCI"            Disable PCI\n"
 	       "  --"OPT_NO_HPET"           Disable HPET\n"
 	       "  --"OPT_NO_SHCONF"         No shared config (mmap'd files)\n"
+	       "  --"OPT_HUGE_WORKER_STACK"[=size]\n"
+	       "                      Allocate worker thread stacks from\n"
+	       "                      hugepage memory. Size is in units of\n"
+	       "                      kbytes and defaults to system thread\n"
+	       "                      stack size if not specified.\n"
 	       "\n", RTE_MAX_LCORE);
 }
lib/eal/common/eal_internal_cfg.h +4 -0
index b71faadd18..5e154967e4 100644
@@ -48,6 +48,9 @@ struct hugepage_file_discipline {
 	bool unlink_existing;
 };
 
+/** Worker hugepage stack size should default to OS value. */
+#define WORKER_STACK_SIZE_FROM_OS ((size_t)~0)
+
 /**
  * internal configuration
  */
@@ -102,6 +105,7 @@ struct internal_config {
 	unsigned int no_telemetry; /**< true to disable Telemetry */
 	struct simd_bitwidth max_simd_bitwidth;
 	/**< max simd bitwidth path to use */
+	size_t huge_worker_stack_size; /**< worker thread stack size */
 };
 
 void eal_reset_internal_config(struct internal_config *internal_cfg);
lib/eal/common/eal_options.h +2 -0
index 8e4f7202a2..3cc9cb6412 100644
@@ -87,6 +87,8 @@ enum {
 	OPT_NO_TELEMETRY_NUM,
 #define OPT_FORCE_MAX_SIMD_BITWIDTH  "force-max-simd-bitwidth"
 	OPT_FORCE_MAX_SIMD_BITWIDTH_NUM,
+#define OPT_HUGE_WORKER_STACK  "huge-worker-stack"
+	OPT_HUGE_WORKER_STACK_NUM,
 
 	OPT_LONG_MAX_NUM
 };
lib/eal/freebsd/eal.c +6 -0
index a6b20960f2..7368956649 100644
@@ -795,6 +795,12 @@ rte_eal_init(int argc, char **argv)
 		config->main_lcore, (uintptr_t)pthread_self(), cpuset,
 		ret == 0 ? "" : "...");
 
+	if (internal_conf->huge_worker_stack_size != 0) {
+		rte_eal_init_alert("Hugepage worker stacks not supported");
+		rte_errno = ENOTSUP;
+		return -1;
+	}
+
 	RTE_LCORE_FOREACH_WORKER(i) {
 
 		/*
lib/eal/linux/eal.c +59 -2

73 lines not on this page · raw message

lib/eal/windows/eal.c +6 -0
index 122de2a319..5cd4a45872 100644
@@ -416,6 +416,12 @@ rte_eal_init(int argc, char **argv)
 		config->main_lcore, (uintptr_t)pthread_self(), cpuset,
 		ret == 0 ? "" : "...");
 
+	if (internal_conf->huge_worker_stack_size != 0) {
+		rte_eal_init_alert("Hugepage worker stacks not supported");
+		rte_errno = ENOTSUP;
+		return -1;
+	}
+
 	RTE_LCORE_FOREACH_WORKER(i) {
 
 		/*
Signature · 1 line
2.17.1
Tested-by on v6 1/1
#25 lore raw

Tested okay on N1SDP platform with testpmd (mac and io fwd) and l3fwd.

Quoted 309 lines

-----Original Message-----
From: Don Wallwork <[email protected]>
Sent: Tuesday, May 24, 2022 2:52 PM
To: [email protected]
Cc: [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; Honnappa Nagarahalli <[email protected]>; nd <[email protected]>; [email protected]; Kathleen Capella <[email protected]>
Subject: [PATCH v6] eal: allow worker lcore stacks to be allocated from hugepage memory

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore.

EAL option '--huge-worker-stack [stack-size-in-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

---
 doc/guides/linux_gsg/eal_args.include.rst     |  6 ++
 .../prog_guide/env_abstraction_layer.rst      | 21 +++++++
 lib/eal/common/eal_common_options.c           | 35 +++++++++++
 lib/eal/common/eal_internal_cfg.h             |  4 ++
 lib/eal/common/eal_options.h                  |  2 +
 lib/eal/freebsd/eal.c                         |  6 ++
 lib/eal/linux/eal.c                           | 61 ++++++++++++++++++-
 lib/eal/windows/eal.c                         |  6 ++
 8 files changed, 139 insertions(+), 2 deletions(-)
doc/guides/linux_gsg/eal_args.include.rst +6 -0
index 3549a0cf56..9cfbf7de84 100644
@@ -116,6 +116,12 @@ Memory-related options
 
     Force IOVA mode to a specific value.
 
+*   ``--huge-worker-stack[=size]``
+
+    Allocate worker stack memory from hugepage memory. Stack size defaults
+    to system pthread stack size unless the optional size (in kbytes) is
+    specified.
+
 Debugging options
 ~~~~~~~~~~~~~~~~~
 
doc/guides/prog_guide/env_abstraction_layer.rst +0 -0
index 5f0748fba1..e74516f0cf 100644
@@ -329,6 +329,27 @@ Another option is to use bigger page sizes. Since fewer

pages are required to cover the same memory area, fewer file descriptors will be stored internally by EAL.

+.. _huge-worker-stack:

doc/guides/prog_guide/env_abstraction_layer.rst +20 -0
+
+Hugepage Worker Stacks
+^^^^^^^^^^^^^^^^^^^^^^
+
+When the ``--huge-worker-stack[=size]`` EAL option is specified, worker
+thread stacks are allocated from hugepage memory local to the NUMA node
+of the thread. Worker stack size defaults to system pthread stack size
+if the optional size parameter is not specified.
+
+.. warning::
+    Stacks allocated from hugepage memory are not protected by guard
+    pages. Worker stacks must be sufficiently sized to prevent stack
+    overflow when this option is used.
+
+    As with normal thread stacks, hugepage worker thread stack size is
+    fixed and is not dynamically resized. Therefore, an application that
+    is free of stack page faults under a given load should be safe with
+    hugepage worker thread stacks given the same thread stack size and
+    loading conditions.
+
 Support for Externally Allocated Memory

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

lib/eal/common/eal_common_options.c +1 -0
index f247a42455..02e59051e8 100644
@@ -103,6 +103,7 @@ eal_long_options[] = {
 	{OPT_TELEMETRY,         0, NULL, OPT_TELEMETRY_NUM        },
 	{OPT_NO_TELEMETRY,      0, NULL, OPT_NO_TELEMETRY_NUM     },
 	{OPT_FORCE_MAX_SIMD_BITWIDTH, 1, NULL,
 OPT_FORCE_MAX_SIMD_BITWIDTH_NUM},
+	{OPT_HUGE_WORKER_STACK, 2, NULL,
 OPT_HUGE_WORKER_STACK_NUM     },
 
lib/eal/common/eal_common_options.c +20 -0
 	{0,                     0, NULL, 0                        }
 };
@@ -1618,6 +1619,26 @@ eal_parse_huge_unlink(const char *arg, struct
 hugepage_file_discipline *out)
 	return -1;
 }
 
+static int
+eal_parse_huge_worker_stack(const char *arg, size_t
+*huge_worker_stack_size) {
+	size_t worker_stack_size;
+	char *end;
+
+	if (arg == NULL || arg[0] == '\0') {
+		*huge_worker_stack_size = WORKER_STACK_SIZE_FROM_OS;
+		return 0;
+	}
+	errno = 0;
+	worker_stack_size = strtoul(arg, &end, 10);
+	if (errno || end == NULL || worker_stack_size == 0 ||
+	    worker_stack_size >= (size_t)-1 / 1024)
+		return -1;
+
+	*huge_worker_stack_size = worker_stack_size * 1024;
+	return 0;
+}
+
 int
 eal_parse_common_option(int opt, const char *optarg,
lib/eal/common/eal_common_options.c +9 -0
 			struct internal_config *conf)
@@ -1921,6 +1942,15 @@ eal_parse_common_option(int opt, const char
 *optarg,
 		}
 		break;
 
+	case OPT_HUGE_WORKER_STACK_NUM:
+		if (eal_parse_huge_worker_stack(optarg,
+						&conf-
 >huge_worker_stack_size) < 0) {
+			RTE_LOG(ERR, EAL, "invalid parameter for --"
+				OPT_HUGE_WORKER_STACK"\n");
+			return -1;
+		}
+		break;
+
 	/* don't know what to do, leave this to caller */
lib/eal/common/eal_common_options.c +5 -0
 	default:
 		return 1;
@@ -2235,5 +2265,10 @@ eal_common_usage(void)
 	       "  --"OPT_NO_PCI"            Disable PCI\n"
 	       "  --"OPT_NO_HPET"           Disable HPET\n"
 	       "  --"OPT_NO_SHCONF"         No shared config (mmap'd files)\n"
+	       "  --"OPT_HUGE_WORKER_STACK"[=size]\n"
+	       "                      Allocate worker thread stacks from\n"
+	       "                      hugepage memory. Size is in units of\n"
+	       "                      kbytes and defaults to system thread\n"
+	       "                      stack size if not specified.\n"
 	       "\n", RTE_MAX_LCORE);
 }
lib/eal/common/eal_internal_cfg.h +4 -0
index b71faadd18..5e154967e4 100644
@@ -48,6 +48,9 @@ struct hugepage_file_discipline {
 	bool unlink_existing;
 };
 
+/** Worker hugepage stack size should default to OS value. */ #define
+WORKER_STACK_SIZE_FROM_OS ((size_t)~0)
+
 /**
  * internal configuration
  */
@@ -102,6 +105,7 @@ struct internal_config {
 	unsigned int no_telemetry; /**< true to disable Telemetry */
 	struct simd_bitwidth max_simd_bitwidth;
 	/**< max simd bitwidth path to use */
+	size_t huge_worker_stack_size; /**< worker thread stack size */
 };
 
 void eal_reset_internal_config(struct internal_config *internal_cfg); diff --git

a/lib/eal/common/eal_options.h b/lib/eal/common/eal_options.h index 8e4f7202a2..3cc9cb6412 100644

lib/eal/common/eal_options.h +2 -0
@@ -87,6 +87,8 @@ enum {
 	OPT_NO_TELEMETRY_NUM,
 #define OPT_FORCE_MAX_SIMD_BITWIDTH  "force-max-simd-bitwidth"
 	OPT_FORCE_MAX_SIMD_BITWIDTH_NUM,
+#define OPT_HUGE_WORKER_STACK  "huge-worker-stack"
+	OPT_HUGE_WORKER_STACK_NUM,
 
 	OPT_LONG_MAX_NUM
 };
lib/eal/freebsd/eal.c index renamed from lib/eal/freebsd/eal.c +0 -0

a6b20960f2..7368956649 100644

lib/eal/freebsd/eal.c +6 -0
@@ -795,6 +795,12 @@ rte_eal_init(int argc, char **argv)
 		config->main_lcore, (uintptr_t)pthread_self(), cpuset,
 		ret == 0 ? "" : "...");
 
+	if (internal_conf->huge_worker_stack_size != 0) {
+		rte_eal_init_alert("Hugepage worker stacks not supported");
+		rte_errno = ENOTSUP;
+		return -1;
+	}
+
 	RTE_LCORE_FOREACH_WORKER(i) {
 
 		/*
lib/eal/linux/eal.c index renamed from lib/eal/linux/eal.c +0 -0

1ef263434a..d28a0fdb78 100644

lib/eal/linux/eal.c +58 -0
@@ -857,6 +857,64 @@ is_iommu_enabled(void)
 	return n > 2;
 }
 
+static int
+eal_worker_thread_create(struct internal_config *internal_conf,
+			 int lcore_id)
+{
+	pthread_attr_t attr;
+	size_t stack_size;
+	void *stack_ptr;
+	int ret;
+
+	if (internal_conf->huge_worker_stack_size == 0)
+		return pthread_create(&lcore_config[lcore_id].thread_id,
+				      NULL,
+				      eal_thread_loop,
+				      (void *)(uintptr_t)lcore_id);
+
+	/* Allocate NUMA aware stack memory and set pthread attributes */
+	if (pthread_attr_init(&attr) != 0) {
+		rte_eal_init_alert("Cannot init pthread attributes");
+		rte_errno = EFAULT;
+		return -1;
+	}
+	if (internal_conf->huge_worker_stack_size ==
 WORKER_STACK_SIZE_FROM_OS) {
+		if (pthread_attr_getstacksize(&attr, &stack_size) != 0) {
+			rte_errno = EFAULT;
+			return -1;
+		}
+	} else {
+		stack_size = internal_conf->huge_worker_stack_size;
+	}
+	stack_ptr = rte_zmalloc_socket("lcore_stack",
+				       stack_size,
+				       RTE_CACHE_LINE_SIZE,
+				       rte_lcore_to_socket_id(lcore_id));
+
+	if (stack_ptr == NULL) {
+		rte_eal_init_alert("Cannot allocate worker lcore stack
 memory");
+		rte_errno = ENOMEM;
+		return -1;
+	}
+
+	if (pthread_attr_setstack(&attr, stack_ptr, stack_size) != 0) {
+		rte_eal_init_alert("Cannot set pthread stack attributes");
+		rte_errno = EFAULT;
+		return -1;
+	}
+
+	ret = pthread_create(&lcore_config[lcore_id].thread_id, &attr,
+			     eal_thread_loop,
+			     (void *)(uintptr_t)lcore_id);
+
+	if (pthread_attr_destroy(&attr) != 0) {
+		rte_eal_init_alert("Cannot destroy pthread attributes");
+		rte_errno = EFAULT;
+		return -1;
+	}
+	return ret;
+}
+
 /* Launch threads, called at application init(). */  int  rte_eal_init(int argc, char

**argv) @@ -1144,8 +1202,7 @@ rte_eal_init(int argc, char **argv)

lib/eal/linux/eal.c +1 -2
 		lcore_config[i].state = WAIT;
 
 		/* create a thread for each lcore */
-		ret = pthread_create(&lcore_config[i].thread_id, NULL,
-				     eal_thread_loop, (void *)(uintptr_t)i);
+		ret = eal_worker_thread_create(internal_conf, i);
 		if (ret != 0)
 			rte_panic("Cannot create thread\n");
lib/eal/windows/eal.c index renamed from lib/eal/windows/eal.c +0 -0

122de2a319..5cd4a45872 100644

lib/eal/windows/eal.c +6 -1
@@ -416,6 +416,12 @@ rte_eal_init(int argc, char **argv)
 		config->main_lcore, (uintptr_t)pthread_self(), cpuset,
 		ret == 0 ? "" : "...");
 
+	if (internal_conf->huge_worker_stack_size != 0) {
+		rte_eal_init_alert("Hugepage worker stacks not supported");
+		rte_errno = ENOTSUP;
+		return -1;
+	}
+
 	RTE_LCORE_FOREACH_WORKER(i) {
 
 		/*
--

2.17.1

#26 lore raw
In reply to Don Wallwork
Quoted 7 lines · Don Wallwork

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore. EAL option '--huge-worker-stack [stack-size-in-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

- About the name of the option... I don't have a better name.

Just want to highlight, that what this patch does is use the DPDK memory allocator for the stack memory.
It happens that DPDK memory allocator is primarily used with hugepages, but this is not systematic for example with the "no-huge" mode of the DPDK memory allocator.

IOW, in this patch current form, you can still run as:

# dpdk-testpmd -c 3 --no-huge --huge-worker-stack=16 -m 40 -- etc...

Opinions?

- This patch adds one more EAL flag, we need some unit test (even if basic).

Comments below:

Quoted 37 lines
---
 doc/guides/linux_gsg/eal_args.include.rst     |  6 ++
 .../prog_guide/env_abstraction_layer.rst      | 21 +++++++
 lib/eal/common/eal_common_options.c           | 35 +++++++++++
 lib/eal/common/eal_internal_cfg.h             |  4 ++
 lib/eal/common/eal_options.h                  |  2 +
 lib/eal/freebsd/eal.c                         |  6 ++
 lib/eal/linux/eal.c                           | 61 ++++++++++++++++++-
 lib/eal/windows/eal.c                         |  6 ++
 8 files changed, 139 insertions(+), 2 deletions(-)
doc/guides/linux_gsg/eal_args.include.rst +6 -0
index 3549a0cf56..9cfbf7de84 100644
@@ -116,6 +116,12 @@ Memory-related options
 
     Force IOVA mode to a specific value.
 
+*   ``--huge-worker-stack[=size]``
+
+    Allocate worker stack memory from hugepage memory. Stack size defaults
+    to system pthread stack size unless the optional size (in kbytes) is
+    specified.
+
 Debugging options
 ~~~~~~~~~~~~~~~~~
 
doc/guides/prog_guide/env_abstraction_layer.rst +0 -0
index 5f0748fba1..e74516f0cf 100644

doc/guides/prog_guide/env_abstraction_layer.rst Another option is to use bigger page sizes. Since fewer pages are required to · line 332

Quoted 4 lines
doc/guides/prog_guide/env_abstraction_layer.rst +1 -0
@@ -329,6 +329,27 @@ Another option is to use bigger page sizes. Since fewer pages are required to
 cover the same memory area, fewer file descriptors will be stored internally
 by EAL.
 
+.. _huge-worker-stack:

There is nothing pointing to this reference.
It can be removed.

Quoted 36 lines
doc/guides/prog_guide/env_abstraction_layer.rst +20 -0
+
+Hugepage Worker Stacks
+^^^^^^^^^^^^^^^^^^^^^^
+
+When the ``--huge-worker-stack[=size]`` EAL option is specified, worker
+thread stacks are allocated from hugepage memory local to the NUMA node
+of the thread. Worker stack size defaults to system pthread stack size
+if the optional size parameter is not specified.
+
+.. warning::
+    Stacks allocated from hugepage memory are not protected by guard
+    pages. Worker stacks must be sufficiently sized to prevent stack
+    overflow when this option is used.
+
+    As with normal thread stacks, hugepage worker thread stack size is
+    fixed and is not dynamically resized. Therefore, an application that
+    is free of stack page faults under a given load should be safe with
+    hugepage worker thread stacks given the same thread stack size and
+    loading conditions.
+
 Support for Externally Allocated Memory
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
lib/eal/common/eal_common_options.c +1 -0
index f247a42455..02e59051e8 100644
@@ -103,6 +103,7 @@ eal_long_options[] = {
        {OPT_TELEMETRY,         0, NULL, OPT_TELEMETRY_NUM        },
        {OPT_NO_TELEMETRY,      0, NULL, OPT_NO_TELEMETRY_NUM     },
        {OPT_FORCE_MAX_SIMD_BITWIDTH, 1, NULL, OPT_FORCE_MAX_SIMD_BITWIDTH_NUM},
+       {OPT_HUGE_WORKER_STACK, 2, NULL, OPT_HUGE_WORKER_STACK_NUM     },
 
        {0,                     0, NULL, 0                        }
 };

lib/eal/common/eal_common_options.c eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out) · line 1625

Quoted 7 lines
lib/eal/common/eal_common_options.c +4 -0
@@ -1618,6 +1619,26 @@ eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out)
        return -1;
 }
 
+static int
+eal_parse_huge_worker_stack(const char *arg, size_t *huge_worker_stack_size)
+{
+       size_t worker_stack_size;

Nit: strtoul returns an unsigned long int.
POSIX defines size_t as an unsigned integer.
It does not specify though that size_t can handle a long unsigned integer.

lib/eal/common/eal_common_options.c eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out) · line 1629

Quoted 4 lines
lib/eal/common/eal_common_options.c +4 -0
+       char *end;
+
+       if (arg == NULL || arg[0] == '\0') {
+               *huge_worker_stack_size = WORKER_STACK_SIZE_FROM_OS;

We should resolve (in theory, via a OS-specific helper, but this is overkill if we move this to Linux EAL) the default stack size here, once and for all.
That simplifies the EAL worker thread create helper. WORKER_STACK_SIZE_FROM_OS is then unneeded.

And this parser needs some debug level EAL log, so that users know the feature is engaged.

lib/eal/common/eal_common_options.c eal_parse_huge_unlink(const char *arg, struct hugepage_file_discipline *out) · line 1638

Quoted 9 lines
lib/eal/common/eal_common_options.c +9 -0
+               return 0;
+       }
+       errno = 0;
+       worker_stack_size = strtoul(arg, &end, 10);
+       if (errno || end == NULL || worker_stack_size == 0 ||
+           worker_stack_size >= (size_t)-1 / 1024)
+               return -1;
+
+       *huge_worker_stack_size = worker_stack_size * 1024;

With previous comments applied, this could look like:

+static int
+eal_parse_huge_worker_stack(const char *arg)
+{
+ struct internal_config *cfg = eal_get_internal_configuration();
+
+ if (arg == NULL || arg[0] == '\0') {
+ pthread_attr_t attr;
+ int ret;
+
+ if (pthread_attr_init(&attr) != 0) {
+ RTE_LOG(ERR, EAL, "Could not retrieve default
stack size\n");
+ return -1;
+ }
+ ret = pthread_attr_getstacksize(&attr,
&cfg->huge_worker_stack_size);
+ pthread_attr_destroy(&attr);
+ if (ret != 0) {
+ RTE_LOG(ERR, EAL, "Could not retrieve default
stack size\n");
+ return -1;
+ }
+ } else {
+ unsigned long int stack_size;
+ char *end;
+

+               errno = 0;
+               stack_size = strtoul(arg, &end, 10);
+               if (errno || end == NULL || stack_size == 0 ||

+ stack_size >= (size_t)-1 / 1024)
+ return -1;
+
+ cfg->huge_worker_stack_size = stack_size * 1024;
+ }
+
+ RTE_LOG(DEBUG, EAL, "EAL worker threads will use %zu kB of
DPDK memory as stack.\n",
+ cfg->huge_worker_stack_size / 1024);
+ return 0;
+}

Quoted 9 lines
lib/eal/common/eal_common_options.c +3 -0
+       return 0;
+}
+
 int
 eal_parse_common_option(int opt, const char *optarg,
                        struct internal_config *conf)
@@ -1921,6 +1942,15 @@ eal_parse_common_option(int opt, const char *optarg,
                }
                break;

lib/eal/common/eal_common_options.c eal_parse_common_option(int opt, const char *optarg, · line 1953

Quoted 10 lines
lib/eal/common/eal_common_options.c +9 -0
 
+       case OPT_HUGE_WORKER_STACK_NUM:
+               if (eal_parse_huge_worker_stack(optarg,
+                                               &conf->huge_worker_stack_size) < 0) {
+                       RTE_LOG(ERR, EAL, "invalid parameter for --"
+                               OPT_HUGE_WORKER_STACK"\n");
+                       return -1;
+               }
+               break;
+

This parser and calling it should be moved out of the common options, and moved to the Linux implementation (around
https://git.dpdk.org/dpdk/tree/lib/eal/linux/eal.c#n715) as it is a Linux-only option at the moment.
Doing so, there is nothing to add to FreeBSD and Windows EAL.

Quoted 19 lines
lib/eal/common/eal_common_options.c +5 -0
        /* don't know what to do, leave this to caller */
        default:
                return 1;
@@ -2235,5 +2265,10 @@ eal_common_usage(void)
               "  --"OPT_NO_PCI"            Disable PCI\n"
               "  --"OPT_NO_HPET"           Disable HPET\n"
               "  --"OPT_NO_SHCONF"         No shared config (mmap'd files)\n"
+              "  --"OPT_HUGE_WORKER_STACK"[=size]\n"
+              "                      Allocate worker thread stacks from\n"
+              "                      hugepage memory. Size is in units of\n"
+              "                      kbytes and defaults to system thread\n"
+              "                      stack size if not specified.\n"
               "\n", RTE_MAX_LCORE);
 }
lib/eal/common/eal_internal_cfg.h +0 -0
index b71faadd18..5e154967e4 100644

lib/eal/common/eal_internal_cfg.h struct hugepage_file_discipline { · line 52

Quoted 5 lines
lib/eal/common/eal_internal_cfg.h +2 -0
@@ -48,6 +48,9 @@ struct hugepage_file_discipline {
        bool unlink_existing;
 };
 
+/** Worker hugepage stack size should default to OS value. */
+#define WORKER_STACK_SIZE_FROM_OS ((size_t)~0)

No need for this limit, as per previous comment.

Quoted 30 lines
lib/eal/common/eal_internal_cfg.h +2 -0
+
 /**
  * internal configuration
  */
@@ -102,6 +105,7 @@ struct internal_config {
        unsigned int no_telemetry; /**< true to disable Telemetry */
        struct simd_bitwidth max_simd_bitwidth;
        /**< max simd bitwidth path to use */
+       size_t huge_worker_stack_size; /**< worker thread stack size */
 };
 
 void eal_reset_internal_config(struct internal_config *internal_cfg);
lib/eal/common/eal_options.h +2 -0
index 8e4f7202a2..3cc9cb6412 100644
@@ -87,6 +87,8 @@ enum {
        OPT_NO_TELEMETRY_NUM,
 #define OPT_FORCE_MAX_SIMD_BITWIDTH  "force-max-simd-bitwidth"
        OPT_FORCE_MAX_SIMD_BITWIDTH_NUM,
+#define OPT_HUGE_WORKER_STACK  "huge-worker-stack"
+       OPT_HUGE_WORKER_STACK_NUM,
 
        OPT_LONG_MAX_NUM
 };
lib/eal/freebsd/eal.c +0 -0
index a6b20960f2..7368956649 100644

lib/eal/freebsd/eal.c rte_eal_init(int argc, char **argv) · line 803

Quoted 9 lines
lib/eal/freebsd/eal.c +6 -0
@@ -795,6 +795,12 @@ rte_eal_init(int argc, char **argv)
                config->main_lcore, (uintptr_t)pthread_self(), cpuset,
                ret == 0 ? "" : "...");
 
+       if (internal_conf->huge_worker_stack_size != 0) {
+               rte_eal_init_alert("Hugepage worker stacks not supported");
+               rte_errno = ENOTSUP;
+               return -1;
+       }
+

As previously mentionned, this is unneeded if option is parsed only in lib/eal/linux/eal.c.

Quoted 15 lines
lib/eal/freebsd/eal.c +0 -0
        RTE_LCORE_FOREACH_WORKER(i) {
 
                /*
lib/eal/linux/eal.c +4 -0
index 1ef263434a..d28a0fdb78 100644
@@ -857,6 +857,64 @@ is_iommu_enabled(void)
        return n > 2;
 }
 
+static int
+eal_worker_thread_create(struct internal_config *internal_conf,
+                        int lcore_id)
+{

lib/eal/linux/eal.c is_iommu_enabled(void) · line 873

Quoted 10 lines
lib/eal/linux/eal.c +10 -0
+       pthread_attr_t attr;
+       size_t stack_size;
+       void *stack_ptr;
+       int ret;
+
+       if (internal_conf->huge_worker_stack_size == 0)
+               return pthread_create(&lcore_config[lcore_id].thread_id,
+                                     NULL,
+                                     eal_thread_loop,
+                                     (void *)(uintptr_t)lcore_id);

If you invert the branch here (checking that stack_size != 0), all the stack setup can then be put under a branch and we have a more readable unified call to pthread_create.
If more pthread attributes were to be added in the future, the code would be ready too.

Quoted 9 lines
lib/eal/linux/eal.c +9 -0
+
+       /* Allocate NUMA aware stack memory and set pthread attributes */
+       if (pthread_attr_init(&attr) != 0) {
+               rte_eal_init_alert("Cannot init pthread attributes");
+               rte_errno = EFAULT;
+               return -1;
+       }
+       if (internal_conf->huge_worker_stack_size == WORKER_STACK_SIZE_FROM_OS) {
+               if (pthread_attr_getstacksize(&attr, &stack_size) != 0) {

lib/eal/linux/eal.c is_iommu_enabled(void) · line 892

Quoted 10 lines
lib/eal/linux/eal.c +10 -0
+                       rte_errno = EFAULT;
+                       return -1;
+               }
+       } else {
+               stack_size = internal_conf->huge_worker_stack_size;
+       }
+       stack_ptr = rte_zmalloc_socket("lcore_stack",
+                                      stack_size,
+                                      RTE_CACHE_LINE_SIZE,
+                                      rte_lcore_to_socket_id(lcore_id));

This stack_ptr is "leaked" if any later branch in this function ends up in failure.

Quoted 14 lines
lib/eal/linux/eal.c +14 -0
+
+       if (stack_ptr == NULL) {
+               rte_eal_init_alert("Cannot allocate worker lcore stack memory");
+               rte_errno = ENOMEM;
+               return -1;
+       }
+
+       if (pthread_attr_setstack(&attr, stack_ptr, stack_size) != 0) {
+               rte_eal_init_alert("Cannot set pthread stack attributes");
+               rte_errno = EFAULT;
+               return -1;
+       }
+
+       ret = pthread_create(&lcore_config[lcore_id].thread_id, &attr,

lib/eal/linux/eal.c is_iommu_enabled(void) · line 916

Quoted 10 lines
lib/eal/linux/eal.c +10 -0
+                            eal_thread_loop,
+                            (void *)(uintptr_t)lcore_id);
+
+       if (pthread_attr_destroy(&attr) != 0) {
+               rte_eal_init_alert("Cannot destroy pthread attributes");
+               rte_errno = EFAULT;
+               return -1;
+       }
+       return ret;
+}

With previous comments applied, this could look like:

+static int
+eal_worker_thread_create(unsigned int lcore_id)
+{

+       pthread_attr_t *attrp = NULL;
+       void *stack_ptr = NULL;
+       pthread_attr_t attr;
+       size_t stack_size;
+       int ret = -1;

+
+ stack_size = eal_get_internal_configuration()->huge_worker_stack_size;
+ if (stack_size != 0) {
+
+ /* Allocate NUMA aware stack memory and set pthread
attributes */
+ stack_ptr = rte_zmalloc_socket("lcore_stack", stack_size,
+ RTE_CACHE_LINE_SIZE, rte_lcore_to_socket_id(lcore_id));
+ if (stack_ptr == NULL) {
+ rte_eal_init_alert("Cannot allocate worker
lcore stack memory");
+ rte_errno = ENOMEM;
+ goto out;
+ }
+
+ if (pthread_attr_init(&attr) != 0) {

+                       rte_eal_init_alert("Cannot init pthread attributes");
+                       rte_errno = EFAULT;
+                       goto out;

+ }
+ attrp = &attr;
+
+ if (pthread_attr_setstack(attrp, stack_ptr, stack_size) != 0) {
+ rte_eal_init_alert("Cannot set pthread stack
attributes");
+ rte_errno = EFAULT;
+ goto out;
+ }
+ }
+
+ if (pthread_create(&lcore_config[lcore_id].thread_id, attrp,
+ eal_thread_loop, (void *)(uintptr_t)lcore_id) == 0)
+ ret = 0;
+
+out:
+ if (ret != 0)
+ rte_free(stack_ptr);
+ if (attrp != NULL)
+ pthread_attr_destroy(attrp);
+ return ret;
+}

Quoted 19 lines
lib/eal/linux/eal.c +2 -2
+
 /* Launch threads, called at application init(). */
 int
 rte_eal_init(int argc, char **argv)
@@ -1144,8 +1202,7 @@ rte_eal_init(int argc, char **argv)
                lcore_config[i].state = WAIT;
 
                /* create a thread for each lcore */
-               ret = pthread_create(&lcore_config[i].thread_id, NULL,
-                                    eal_thread_loop, (void *)(uintptr_t)i);
+               ret = eal_worker_thread_create(internal_conf, i);
                if (ret != 0)
                        rte_panic("Cannot create thread\n");
 
lib/eal/windows/eal.c +0 -0
index 122de2a319..5cd4a45872 100644

lib/eal/windows/eal.c rte_eal_init(int argc, char **argv) · line 424

Quoted 9 lines
lib/eal/windows/eal.c +6 -0
@@ -416,6 +416,12 @@ rte_eal_init(int argc, char **argv)
                config->main_lcore, (uintptr_t)pthread_self(), cpuset,
                ret == 0 ? "" : "...");
 
+       if (internal_conf->huge_worker_stack_size != 0) {
+               rte_eal_init_alert("Hugepage worker stacks not supported");
+               rte_errno = ENOTSUP;
+               return -1;
+       }
+

Same as FreeBSD, this is unneeded if option is parsed only in lib/eal/linux/eal.c.

Quoted 6 lines
lib/eal/windows/eal.c +0 -1
        RTE_LCORE_FOREACH_WORKER(i) {
 
                /*
--

2.17.1

Signature · 1 line
David Marchand
#27 lore raw

20/06/2022 10:35, David Marchand:

Quoted 17 lines · Don Wallwork
Quoted 7 lines

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore. EAL option '--huge-worker-stack [stack-size-in-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

- About the name of the option... I don't have a better name.

Just want to highlight, that what this patch does is use the DPDK memory allocator for the stack memory.
It happens that DPDK memory allocator is primarily used with hugepages, but this is not systematic for example with the "no-huge" mode of the DPDK memory allocator.

Quoted 5 lines

IOW, in this patch current form, you can still run as:

# dpdk-testpmd -c 3 --no-huge --huge-worker-stack=16 -m 40 -- etc...

Opinions?

The name of the option should not include "huge".
What about "--worker-stack" ?
If disabled (equal zero), the workers should use the default stack memory.

#28 lore raw
Quoted 16 lines · Thomas Monjalon

20/06/2022 10:35, David Marchand:

Quoted 15 lines · Don Wallwork
Quoted 6 lines

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore. EAL option '--huge-worker-stack [stack-size-in-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

- About the name of the option... I don't have a better name.

Just want to highlight, that what this patch does is use the DPDK memory allocator for the stack memory.
It happens that DPDK memory allocator is primarily used with hugepages, but this is not systematic for example with the "no-huge" mode of the DPDK memory allocator.

Quoted 10 lines
Quoted 5 lines

IOW, in this patch current form, you can still run as:

# dpdk-testpmd -c 3 --no-huge --huge-worker-stack=16 -m 40 -- etc...

Opinions?

The name of the option should not include "huge".
What about "--worker-stack" ?
If disabled (equal zero), the workers should use the default stack memory.

Wouldn't that have the potential to create confusion?  The point of this change is to allocate worker stacks from hugepages.  Removing huge from the option name could give the impression that the command is simply to control worker stack size.

Regarding your other comments, I'm working on another patch that will address those.

#29 lore raw

21/06/2022 14:31, Don Wallwork:

Quoted 27 lines · Thomas Monjalon
Quoted 16 lines

20/06/2022 10:35, David Marchand:

Quoted 15 lines · Don Wallwork
Quoted 6 lines

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore. EAL option '--huge-worker-stack [stack-size-in-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

- About the name of the option... I don't have a better name.

Just want to highlight, that what this patch does is use the DPDK memory allocator for the stack memory.
It happens that DPDK memory allocator is primarily used with hugepages, but this is not systematic for example with the "no-huge" mode of the DPDK memory allocator.

Quoted 10 lines
Quoted 5 lines

IOW, in this patch current form, you can still run as:

# dpdk-testpmd -c 3 --no-huge --huge-worker-stack=16 -m 40 -- etc...

Opinions?

The name of the option should not include "huge".
What about "--worker-stack" ?
If disabled (equal zero), the workers should use the default stack memory.

Quoted 4 lines

Wouldn't that have the potential to create confusion? The point of this change is to allocate worker stacks from hugepages. Removing huge from the option name could give the impression that the command is simply to control worker stack size.

It means if we control the worker stack size with a DPDK option, DPDK memory will be used.
But we cannot force hugepage with this option. Hugepage is not always available and it can be disabled in DPDK.

Quoted 2 lines

Regarding your other comments, I'm working on another patch that will address those.

#30 lore raw
Quoted 28 lines · Thomas Monjalon

21/06/2022 14:31, Don Wallwork:

Quoted 27 lines · Thomas Monjalon
Quoted 26 lines

20/06/2022 10:35, David Marchand:

Quoted 15 lines · Don Wallwork
Quoted 6 lines

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore. EAL option '--huge-worker-stack [stack-size-in-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

- About the name of the option... I don't have a better name.

Just want to highlight, that what this patch does is use the DPDK memory allocator for the stack memory.
It happens that DPDK memory allocator is primarily used with hugepages, but this is not systematic for example with the "no-huge" mode of the DPDK memory allocator.

Quoted 5 lines

IOW, in this patch current form, you can still run as:

# dpdk-testpmd -c 3 --no-huge --huge-worker-stack=16 -m 40 -- etc...

Opinions?

The name of the option should not include "huge".
What about "--worker-stack" ?
If disabled (equal zero), the workers should use the default stack memory.

Quoted 8 lines
Quoted 4 lines

Wouldn't that have the potential to create confusion? The point of this change is to allocate worker stacks from hugepages. Removing huge from the option name could give the impression that the command is simply to control worker stack size.

It means if we control the worker stack size with a DPDK option, DPDK memory will be used.
But we cannot force hugepage with this option. Hugepage is not always available and it can be disabled in DPDK.

The command could be rejected if hugepages are not available. That's not in the patch currently, but can be added.

#31 lore raw

21/06/2022 16:52, Don Wallwork:

Quoted 33 lines · Thomas Monjalon
Quoted 32 lines

21/06/2022 14:31, Don Wallwork:

Quoted 31 lines · Thomas Monjalon
Quoted 16 lines

20/06/2022 10:35, David Marchand:

Quoted 15 lines · Don Wallwork
Quoted 6 lines

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore. EAL option '--huge-worker-stack [stack-size-in-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

- About the name of the option... I don't have a better name.

Just want to highlight, that what this patch does is use the DPDK memory allocator for the stack memory.
It happens that DPDK memory allocator is primarily used with hugepages, but this is not systematic for example with the "no-huge" mode of the DPDK memory allocator.

Quoted 10 lines
Quoted 5 lines

IOW, in this patch current form, you can still run as:

# dpdk-testpmd -c 3 --no-huge --huge-worker-stack=16 -m 40 -- etc...

Opinions?

The name of the option should not include "huge".
What about "--worker-stack" ?
If disabled (equal zero), the workers should use the default stack memory.

Wouldn't that have the potential to create confusion? The point of this change is to allocate worker stacks from hugepages. Removing huge from the option name could give the impression that the command is simply to control worker stack size.

Quoted 7 lines
Quoted 4 lines

It means if we control the worker stack size with a DPDK option, DPDK memory will be used.
But we cannot force hugepage with this option. Hugepage is not always available and it can be disabled in DPDK.

The command could be rejected if hugepages are not available. That's not in the patch currently, but can be added.

David, Anatoly, Dmitry, what do you think?

#32 lore raw

<snip>

Quoted 42 lines

21/06/2022 16:52, Don Wallwork:

Quoted 5 lines · Thomas Monjalon
Quoted 4 lines

21/06/2022 14:31, Don Wallwork:

Quoted 3 lines · Thomas Monjalon
Quoted 2 lines

20/06/2022 10:35, David Marchand:

Quoted 1 line

On Tue, May 24, 2022 at 9:52 PM Don Wallwork

Quoted 3 lines · <[email protected]> wrote:
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node

of each lcore.

Quoted 30 lines
Quoted 29 lines
Quoted 21 lines
Quoted 11 lines
Quoted 11 lines
Quoted 3 lines

EAL option '--huge-worker-stack [stack-size-in-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

- About the name of the option... I don't have a better name.

Just want to highlight, that what this patch does is use the DPDK memory allocator for the stack memory.
It happens that DPDK memory allocator is primarily used with hugepages, but this is not systematic for example with the "no-huge" mode of the DPDK memory allocator.

Quoted 10 lines
Quoted 5 lines

IOW, in this patch current form, you can still run as:

# dpdk-testpmd -c 3 --no-huge --huge-worker-stack=16 -m 40 -- etc...

Opinions?

The name of the option should not include "huge".
What about "--worker-stack" ?
If disabled (equal zero), the workers should use the default stack memory.

Quoted 4 lines

Wouldn't that have the potential to create confusion? The point of this change is to allocate worker stacks from hugepages. Removing huge from the option name could give the impression that the command is simply to control worker stack size.

It means if we control the worker stack size with a DPDK option, DPDK memory will be used.
But we cannot force hugepage with this option. Hugepage is not always available and it can be disabled in DPDK.

Quoted 5 lines
Quoted 2 lines

The command could be rejected if hugepages are not available. That's not in the patch currently, but can be added.

David, Anatoly, Dmitry, what do you think?

It should be a warning, but the application can continue to run

Quoted 2 lines
#33 lore raw
In reply to Thomas Monjalon
Quoted 14 lines · Thomas Monjalon
Quoted 14 lines
Quoted 13 lines
Quoted 9 lines
Quoted 5 lines

The name of the option should not include "huge".
What about "--worker-stack" ?
If disabled (equal zero), the workers should use the default stack memory.

Wouldn't that have the potential to create confusion? The point of this change is to allocate worker stacks from hugepages. Removing huge from the option name could give the impression that the command is simply to control worker stack size.

It means if we control the worker stack size with a DPDK option, DPDK memory will be used.
But we cannot force hugepage with this option. Hugepage is not always available and it can be disabled in DPDK.

Quoted 4 lines
Quoted 2 lines

The command could be rejected if hugepages are not available. That's not in the patch currently, but can be added.

David, Anatoly, Dmitry, what do you think?

We have other non compatible EAL options for which combining them trigger an init failure.
This is acceptable for me.

Signature · 1 line
David Marchand
#34 lore raw

PATCH v7 1/1 eal: allow worker lcore stacks to be allocated from hugepage memory

In reply to Don Wallwork

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore.

EAL option '--huge-worker-stack [stack-size-in-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

---
 app/test/test_eal_flags.c                     |  36 ++++++
 doc/guides/linux_gsg/eal_args.include.rst     |   6 +
 .../prog_guide/env_abstraction_layer.rst      |  19 ++++
 lib/eal/common/eal_common_options.c           |   7 ++
 lib/eal/common/eal_internal_cfg.h             |   1 +
 lib/eal/common/eal_options.h                  |   2 +
 lib/eal/linux/eal.c                           | 105 +++++++++++++++++-
 7 files changed, 174 insertions(+), 2 deletions(-)
app/test/test_eal_flags.c +36 -0
index 68deb86aab..624379d49e 100644
@@ -859,6 +859,14 @@ test_no_huge_flag(void)
 	/* With --no-huge, -m and --socket-mem */
 	const char *argv4[] = {prgname, prefix, no_huge,
 			"-m", DEFAULT_MEM_SIZE, "--socket-mem=" DEFAULT_MEM_SIZE};
+
+	/* With --no-huge and --huge-worker-stack (should fail) */
+	const char * const argv5[] = {prgname, prefix, no_huge,
+			"--huge-worker-stack"};
+	/* With --no-huge and --huge-worker-stack=512 (should fail) */
+	const char * const argv6[] = {prgname, prefix, no_huge,
+			"--huge-worker-stack=512"};
+
 	if (launch_proc(argv1) != 0) {
 		printf("Error - process did not run ok with --no-huge flag\n");
 		return -1;
@@ -882,6 +890,16 @@ test_no_huge_flag(void)
 				"--socket-mem flags\n");
 		return -1;
 	}
+	if (launch_proc(argv5) == 0) {
+		printf("Error - process run ok with --no-huge and "
+		       "--huge-worker-stack flags");
+		return -1;
+	}
+	if (launch_proc(argv6) == 0) {
+		printf("Error - process run ok with --no-huge and "
+		       "--huge-worker-stack=size flags");
+		return -1;
+	}
 	return 0;
 }
 
@@ -1031,6 +1049,14 @@ test_misc_flags(void)
 	const char * const argv20[] = {prgname, "--file-prefix=uiodev",
 			"--create-uio-dev"};
 
+	/* Try running with --huge-worker-stack flag */
+	const char * const argv21[] = {prgname, prefix, mp_flag,
+				       "--huge-worker-stack"};
+
+	/* Try running with --huge-worker-stack=512 flag */
+	const char * const argv22[] = {prgname, prefix, mp_flag,
+				       "--huge-worker-stack=512"};
+
 	/* run all tests also applicable to FreeBSD first */
 
 	if (launch_proc(argv0) == 0) {
@@ -1130,6 +1156,16 @@ test_misc_flags(void)
 				"--create-uio-dev parameter\n");
 		goto fail;
 	}
+	if (launch_proc(argv21) != 0) {
+		printf("Error - process did not run ok with "
+				"--huge-worker-stack parameter\n");
+		goto fail;
+	}
+	if (launch_proc(argv22) != 0) {
+		printf("Error - process did not run ok with "
+				"--huge-worker-stack=size parameter\n");
+		goto fail;
+	}
 
 	rmdir(hugepath_dir3);
 	rmdir(hugepath_dir2);
doc/guides/linux_gsg/eal_args.include.rst +6 -0
index 3549a0cf56..9cfbf7de84 100644
@@ -116,6 +116,12 @@ Memory-related options
 
     Force IOVA mode to a specific value.
 
+*   ``--huge-worker-stack[=size]``
+
+    Allocate worker stack memory from hugepage memory. Stack size defaults
+    to system pthread stack size unless the optional size (in kbytes) is
+    specified.
+
 Debugging options
 ~~~~~~~~~~~~~~~~~
 
doc/guides/prog_guide/env_abstraction_layer.rst +19 -0
index 5f0748fba1..42def41e61 100644
@@ -329,6 +329,25 @@ Another option is to use bigger page sizes. Since fewer pages are required to
 cover the same memory area, fewer file descriptors will be stored internally
 by EAL.
 
+Hugepage Worker Stacks
+^^^^^^^^^^^^^^^^^^^^^^
+
+When the ``--huge-worker-stack[=size]`` EAL option is specified, worker
+thread stacks are allocated from hugepage memory local to the NUMA node
+of the thread. Worker stack size defaults to system pthread stack size
+if the optional size parameter is not specified.
+
+.. warning::
+    Stacks allocated from hugepage memory are not protected by guard
+    pages. Worker stacks must be sufficiently sized to prevent stack
+    overflow when this option is used.
+
+    As with normal thread stacks, hugepage worker thread stack size is
+    fixed and is not dynamically resized. Therefore, an application that
+    is free of stack page faults under a given load should be safe with
+    hugepage worker thread stacks given the same thread stack size and
+    loading conditions.
+
 Support for Externally Allocated Memory
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
lib/eal/common/eal_common_options.c +7 -0
index f247a42455..726ee5a5d5 100644
@@ -103,6 +103,7 @@ eal_long_options[] = {
 	{OPT_TELEMETRY,         0, NULL, OPT_TELEMETRY_NUM        },
 	{OPT_NO_TELEMETRY,      0, NULL, OPT_NO_TELEMETRY_NUM     },
 	{OPT_FORCE_MAX_SIMD_BITWIDTH, 1, NULL, OPT_FORCE_MAX_SIMD_BITWIDTH_NUM},
+	{OPT_HUGE_WORKER_STACK, 2, NULL, OPT_HUGE_WORKER_STACK_NUM     },
 
 	{0,                     0, NULL, 0                        }
 };
@@ -2079,6 +2080,12 @@ eal_check_common_options(struct internal_config *internal_cfg)
 			"be specified together with --"OPT_NO_HUGE"\n");
 		return -1;
 	}
+	if (internal_cfg->no_hugetlbfs &&
+	    internal_cfg->huge_worker_stack_size != 0) {
+		RTE_LOG(ERR, EAL, "Option --"OPT_HUGE_WORKER_STACK" cannot "
+			"be specified together with --"OPT_NO_HUGE"\n");
+		return -1;
+	}
 	if (internal_conf->force_socket_limits && internal_conf->legacy_mem) {
 		RTE_LOG(ERR, EAL, "Option --"OPT_SOCKET_LIMIT
 			" is only supported in non-legacy memory mode\n");
lib/eal/common/eal_internal_cfg.h +1 -0
index b71faadd18..167ec501fa 100644
@@ -102,6 +102,7 @@ struct internal_config {
 	unsigned int no_telemetry; /**< true to disable Telemetry */
 	struct simd_bitwidth max_simd_bitwidth;
 	/**< max simd bitwidth path to use */
+	size_t huge_worker_stack_size; /**< worker thread stack size */
 };
 
 void eal_reset_internal_config(struct internal_config *internal_cfg);
lib/eal/common/eal_options.h +2 -0
index 8e4f7202a2..3cc9cb6412 100644
@@ -87,6 +87,8 @@ enum {
 	OPT_NO_TELEMETRY_NUM,
 #define OPT_FORCE_MAX_SIMD_BITWIDTH  "force-max-simd-bitwidth"
 	OPT_FORCE_MAX_SIMD_BITWIDTH_NUM,
+#define OPT_HUGE_WORKER_STACK  "huge-worker-stack"
+	OPT_HUGE_WORKER_STACK_NUM,
 
 	OPT_LONG_MAX_NUM
 };
lib/eal/linux/eal.c +103 -2

135 lines not on this page · raw message

Signature · 1 line
2.17.1
#35 lore raw
Quoted 5 lines · Don Wallwork

Add support for using hugepages for worker lcore stack memory. The intent is to improve performance by reducing stack memory related TLB misses and also by using memory local to the NUMA node of each lcore.

Quoted 7 lines

EAL option '--huge-worker-stack[=stack-size-in-kbytes]' is added to allow the feature to be enabled at runtime. If the size is not specified, the system pthread stack size will be used.

Applied, thanks Don.

Signature · 1 line
David Marchand