From: Amit Prakash Shukla <amitprakashs@marvell.com>
To: Anatoly Burakov <anatoly.burakov@intel.com>
Cc: <dev@dpdk.org>, <jerinj@marvell.com>,
<bruce.richardson@intel.com>,
"Amit Prakash Shukla" <amitprakashs@marvell.com>
Subject: [PATCH v4 1/2] mem: telemetry support for memseg and element information
Date: Wed, 25 May 2022 16:03:51 +0530 [thread overview]
Message-ID: <20220525103352.1806937-1-amitprakashs@marvell.com> (raw)
In-Reply-To: <20220519063038.637836-1-amitprakashs@marvell.com>
Changes adds telemetry support to display memory occupancy
in memseg and the information of the elements allocated from
a memseg based on arguments provided by user. This patch
adds following endpoints:
1. /eal/memseg_list_array
The command displays the memseg list from which the memory
has been allocated.
Example:
--> /eal/memseg_list_array
{"/eal/memseg_list_array": [0, 1]}
2. /eal/memseg_list_info,<memseg-list-id>
The command outputs the memsegs, from which the memory is
allocated, for the memseg_list given as input. Command also
supports help.
Example:
--> /eal/memseg_list_info,help
{"/eal/memseg_list_info": "/eal/memseg_list_info,<memseg-list-id>"}
--> /eal/memseg_list_info,1
{"/eal/memseg_list_info": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, \
12, 13, 14, 15]}
3. /eal/memseg_info,<memseg-list-id>,<memseg-id>
The command outputs the memseg information based on the
memseg-list and the memseg-id given as input. Command also
supports help.
Example:
--> /eal/memseg_info,help
{"/eal/memseg_info": "/eal/memseg_info,<memseg-list-id>, \
<memseg-id>"}
--> /eal/memseg_info,0,10
{"/eal/memseg_info": {"Memseg_list_index": 0, \
"Memseg_index": 10, "Memseg_list_len": 64, \
"Start_addr": "0x260000000", "End_addr": "0x280000000", \
"Size": 536870912}}
--> /eal/memseg_info,1,15
{"/eal/memseg_info": {"Memseg_list_index": 1, \
"Memseg_index": 15, "Memseg_list_len": 64, \
"Start_addr": "0xb20000000", "End_addr": "0xb40000000", \
"Size": 536870912}}
4. /eal/element_list,<heap-id>,<memseg-list-id>,<memseg-id>
The command outputs number of elements in a memseg based
on the heap-id, memseg-list-id and memseg-id given as input.
Command also supports help.
Example:
--> /eal/element_list,help
{"/eal/element_list": "/eal/element_list,<heap-id>, \
<memseg-list-id>,<memseg-id>"}
--> /eal/element_list,0,0,63
{"/eal/element_list": {"Element_count": 52}}
--> /eal/element_list,0,1,15
{"/eal/element_list": {"Element_count": 52}}
5. /eal/element_info,<heap-id>,<memseg-list-id>,<memseg-id>, \
<elem-start-id>,<elem-end-id>
The command outputs element information like element start
address, end address, to which memseg it belongs, element
state, element size. User can give a range of elements to be
printed. Command also supports help.
Example:
--> /eal/element_info,help
{"/eal/element_info": "/eal/element_info,<heap-id>, \
<memseg-list-id>,<memseg-id>,<elem-start-id>,<elem-end-id>"}
--> /eal/element_info,0,1,15,1,2
{"/eal/element_info": {"element.1": {"msl_id": 1, \
"ms_id": 15, "memseg_start_addr": "0xb20000000", \
"memseg_end_addr": "0xb40000000", \
"element_start_addr": "0xb201fe680", \
"element_end_addr": "0xb20bfe700", \
"element_size": 10485888, "element_state": "Busy"}, \
"element.2": {"msl_id": 1, "ms_id": 15, \
"memseg_start_addr": "0xb20000000", \
"memseg_end_addr": "0xb40000000", \
"element_start_addr": "0xb20bfe700", \
"element_end_addr": "0xb215fe780", "element_size": 10485888, \
"element_state": "Busy"}, "Element_count": 2}}
Signed-off-by: Amit Prakash Shukla <amitprakashs@marvell.com>
---
v2:
- Fixed compilation error related int-to-pointer-cast
- Changes for code review suggestions
v3:
- Commit message changes
- Renaming end-points
- Changing input parameters to comma-seperated
- Reverting telemetry output buffer size
v4:
- Patch-2 adds telemetry support to display system memory
lib/eal/common/eal_common_memory.c | 482 ++++++++++++++++++++++++++++-
1 file changed, 477 insertions(+), 5 deletions(-)
diff --git a/lib/eal/common/eal_common_memory.c b/lib/eal/common/eal_common_memory.c
index 688dc615d7..e66de6a872 100644
--- a/lib/eal/common/eal_common_memory.c
+++ b/lib/eal/common/eal_common_memory.c
@@ -26,6 +26,7 @@
#include "eal_memcfg.h"
#include "eal_options.h"
#include "malloc_heap.h"
+#include "malloc_elem.h"
/*
* Try to mmap *size bytes in /dev/zero. If it is successful, return the
@@ -1113,11 +1114,17 @@ rte_eal_memory_init(void)
}
#ifndef RTE_EXEC_ENV_WINDOWS
-#define EAL_MEMZONE_LIST_REQ "/eal/memzone_list"
-#define EAL_MEMZONE_INFO_REQ "/eal/memzone_info"
-#define EAL_HEAP_LIST_REQ "/eal/heap_list"
-#define EAL_HEAP_INFO_REQ "/eal/heap_info"
-#define ADDR_STR 15
+#define EAL_MEMZONE_LIST_REQ "/eal/memzone_list"
+#define EAL_MEMZONE_INFO_REQ "/eal/memzone_info"
+#define EAL_HEAP_LIST_REQ "/eal/heap_list"
+#define EAL_HEAP_INFO_REQ "/eal/heap_info"
+#define EAL_MEMSEG_LIST_ARR_REQ "/eal/memseg_list_array"
+#define EAL_MEMSEG_LIST_INFO_REQ "/eal/memseg_list_info"
+#define EAL_MEMSEG_INFO_REQ "/eal/memseg_info"
+#define EAL_ELEMENT_LIST_REQ "/eal/element_list"
+#define EAL_ELEMENT_INFO_REQ "/eal/element_info"
+#define ADDR_STR 15
+
/* Telemetry callback handler to return heap stats for requested heap id. */
static int
@@ -1265,6 +1272,454 @@ handle_eal_memzone_list_request(const char *cmd __rte_unused,
return 0;
}
+static int
+handle_eal_memseg_list_array_request(const char *cmd __rte_unused,
+ const char *params __rte_unused,
+ struct rte_tel_data *d)
+{
+ struct rte_mem_config *mcfg;
+ int i;
+
+ rte_tel_data_start_array(d, RTE_TEL_INT_VAL);
+
+ rte_mcfg_mem_read_lock();
+ mcfg = rte_eal_get_configuration()->mem_config;
+
+ for (i = 0; i < RTE_MAX_MEMSEG_LISTS; i++) {
+ struct rte_memseg_list *msl = &mcfg->memsegs[i];
+ if (msl->memseg_arr.count == 0)
+ continue;
+
+ rte_tel_data_add_array_int(d, i);
+ }
+ rte_mcfg_mem_read_unlock();
+
+ return 0;
+}
+
+static int
+handle_eal_memseg_list_info_request(const char *cmd __rte_unused,
+ const char *params, struct rte_tel_data *d)
+{
+ struct rte_mem_config *mcfg;
+ struct rte_memseg_list *msl;
+ struct rte_fbarray *arr;
+ uint32_t ms_list_idx;
+ int ms_idx;
+
+ if (params == NULL || strlen(params) == 0)
+ return -1;
+
+ if (strncasecmp(params, "help", strlen(params)) == 0) {
+ char buff[RTE_TEL_MAX_SINGLE_STRING_LEN];
+ snprintf(buff, RTE_TEL_MAX_SINGLE_STRING_LEN,
+ "%s,<memseg-list-id>", EAL_MEMSEG_LIST_INFO_REQ);
+ rte_tel_data_string(d, buff);
+ return 0;
+ }
+
+ if (!isdigit(*params))
+ return -1;
+
+ ms_list_idx = strtoul(params, NULL, 10);
+ if (ms_list_idx >= RTE_MAX_MEMSEG_LISTS)
+ return -1;
+
+ rte_tel_data_start_array(d, RTE_TEL_INT_VAL);
+
+ rte_mcfg_mem_read_lock();
+ mcfg = rte_eal_get_configuration()->mem_config;
+ msl = &mcfg->memsegs[ms_list_idx];
+ if (msl->memseg_arr.count == 0)
+ goto done;
+
+ arr = &msl->memseg_arr;
+
+ ms_idx = rte_fbarray_find_next_used(arr, 0);
+ while (ms_idx >= 0) {
+ rte_tel_data_add_array_int(d, ms_idx);
+ ms_idx = rte_fbarray_find_next_used(arr, ms_idx + 1);
+ }
+
+done:
+ rte_mcfg_mem_read_unlock();
+
+ return 0;
+}
+
+static int
+handle_eal_memseg_info_request(const char *cmd __rte_unused,
+ const char *params, struct rte_tel_data *d)
+{
+ struct rte_mem_config *mcfg;
+ uint64_t ms_start_addr, ms_end_addr, ms_size;
+ struct rte_memseg_list *msl;
+ const struct rte_memseg *ms;
+ struct rte_fbarray *arr;
+ char addr[ADDR_STR];
+ uint32_t ms_list_idx = 0;
+ uint32_t ms_idx = 0;
+ uint32_t msl_len;
+ char dlim[2] = ",";
+ char *token;
+ char *params_args;
+
+ if (params == NULL || strlen(params) == 0)
+ return -1;
+
+ if (strncasecmp(params, "help", strlen(params)) == 0) {
+ char buff[RTE_TEL_MAX_SINGLE_STRING_LEN];
+ snprintf(buff, RTE_TEL_MAX_SINGLE_STRING_LEN,
+ "%s,<memseg-list-id>,<memseg-id>",
+ EAL_MEMSEG_INFO_REQ);
+ rte_tel_data_string(d, buff);
+ return 0;
+ }
+
+ /* strtok expects char * and param is const char *. Hence on using
+ * params as "const char *" compiler throws warning.
+ */
+ params_args = strdup(params);
+ token = strtok(params_args, dlim);
+ if (token == NULL || !isdigit(*token)) {
+ free(params_args);
+ return -1;
+ }
+
+ ms_list_idx = strtoul(token, NULL, 10);
+ if (ms_list_idx >= RTE_MAX_MEMSEG_LISTS) {
+ free(params_args);
+ return -1;
+ }
+
+ token = strtok(NULL, dlim);
+ if (token == NULL || !isdigit(*token)) {
+ free(params_args);
+ return -1;
+ }
+ ms_idx = strtoul(token, NULL, 10);
+
+ free(params_args);
+
+ rte_mcfg_mem_read_lock();
+
+ mcfg = rte_eal_get_configuration()->mem_config;
+ msl = &mcfg->memsegs[ms_list_idx];
+ if (msl->memseg_arr.count == 0) {
+ rte_mcfg_mem_read_unlock();
+ return -1;
+ }
+
+ arr = &msl->memseg_arr;
+ msl_len = arr->len;
+
+ ms = rte_fbarray_get(arr, ms_idx);
+ if (ms == NULL) {
+ rte_mcfg_mem_read_unlock();
+ RTE_LOG(DEBUG, EAL, "Error fetching requested memseg.\n");
+ return -1;
+ }
+
+ ms_start_addr = ms->addr_64;
+ ms_end_addr = (uint64_t)RTE_PTR_ADD(ms_start_addr, ms->len);
+ ms_size = ms->hugepage_sz;
+
+ rte_mcfg_mem_read_unlock();
+
+ rte_tel_data_start_dict(d);
+ rte_tel_data_add_dict_int(d, "Memseg_list_index", ms_list_idx);
+ rte_tel_data_add_dict_int(d, "Memseg_index", ms_idx);
+ rte_tel_data_add_dict_int(d, "Memseg_list_len", msl_len);
+ snprintf(addr, ADDR_STR, "0x%"PRIx64, ms_start_addr);
+ rte_tel_data_add_dict_string(d, "Start_addr", addr);
+ snprintf(addr, ADDR_STR, "0x%"PRIx64, ms_end_addr);
+ rte_tel_data_add_dict_string(d, "End_addr", addr);
+ rte_tel_data_add_dict_int(d, "Size", ms_size);
+
+ return 0;
+}
+
+static int
+handle_eal_element_list_request(const char *cmd __rte_unused,
+ const char *params, struct rte_tel_data *d)
+{
+ struct rte_mem_config *mcfg;
+ struct rte_memseg_list *msl;
+ const struct rte_memseg *ms;
+ struct malloc_elem *elem;
+ struct malloc_heap *heap;
+ uint64_t ms_start_addr, ms_end_addr;
+ uint64_t elem_start_addr, elem_end_addr;
+ uint32_t ms_list_idx = 0;
+ uint32_t heap_id = 0;
+ uint32_t ms_idx = 0;
+ char dlim[2] = ",";
+ int elem_count = 0;
+ char *token;
+ char *params_args;
+
+ if (params == NULL || strlen(params) == 0)
+ return -1;
+
+ if (strncasecmp(params, "help", strlen(params)) == 0) {
+ char buff[RTE_TEL_MAX_SINGLE_STRING_LEN];
+ snprintf(buff, RTE_TEL_MAX_SINGLE_STRING_LEN,
+ "%s,<heap-id>,<memseg-list-id>,<memseg-id>",
+ EAL_ELEMENT_LIST_REQ);
+ rte_tel_data_string(d, buff);
+ return 0;
+ }
+
+ /* strtok expects char * and param is const char *. Hence on using
+ * params as "const char *" compiler throws warning.
+ */
+ params_args = strdup(params);
+ token = strtok(params_args, dlim);
+ if (token == NULL || !isdigit(*token)) {
+ free(params_args);
+ return -1;
+ }
+
+ heap_id = strtoul(token, NULL, 10);
+ if (heap_id >= RTE_MAX_HEAPS) {
+ free(params_args);
+ return -1;
+ }
+
+ token = strtok(NULL, dlim);
+ if (token == NULL || !isdigit(*token)) {
+ free(params_args);
+ return -1;
+ }
+
+ ms_list_idx = strtoul(token, NULL, 10);
+ if (ms_list_idx >= RTE_MAX_MEMSEG_LISTS) {
+ free(params_args);
+ return -1;
+ }
+
+ token = strtok(NULL, dlim);
+ if (token == NULL || !isdigit(*token)) {
+ free(params_args);
+ return -1;
+ }
+
+ ms_idx = strtoul(token, NULL, 10);
+
+ free(params_args);
+
+ rte_mcfg_mem_read_lock();
+
+ mcfg = rte_eal_get_configuration()->mem_config;
+ msl = &mcfg->memsegs[ms_list_idx];
+ ms = rte_fbarray_get(&msl->memseg_arr, ms_idx);
+ if (ms == NULL) {
+ rte_mcfg_mem_read_unlock();
+ RTE_LOG(DEBUG, EAL, "Error fetching requested memseg.\n");
+ return -1;
+ }
+
+ ms_start_addr = ms->addr_64;
+ ms_end_addr = (uint64_t)RTE_PTR_ADD(ms_start_addr, ms->len);
+ rte_mcfg_mem_read_unlock();
+
+ rte_tel_data_start_dict(d);
+
+ heap = &mcfg->malloc_heaps[heap_id];
+ rte_spinlock_lock(&heap->lock);
+
+ elem = heap->first;
+ while (elem) {
+ elem_start_addr = (uint64_t)elem;
+ elem_end_addr =
+ (uint64_t)RTE_PTR_ADD(elem_start_addr, elem->size);
+
+ if ((uint64_t)elem_start_addr >= ms_start_addr &&
+ (uint64_t)elem_end_addr <= ms_end_addr)
+ elem_count++;
+ elem = elem->next;
+ }
+
+ rte_spinlock_unlock(&heap->lock);
+
+ rte_tel_data_add_dict_int(d, "Element_count", elem_count);
+
+ return 0;
+}
+
+static int
+handle_eal_element_info_request(const char *cmd __rte_unused,
+ const char *params, struct rte_tel_data *d)
+{
+ struct rte_mem_config *mcfg;
+ struct rte_memseg_list *msl;
+ const struct rte_memseg *ms;
+ struct malloc_elem *elem;
+ struct malloc_heap *heap;
+ struct rte_tel_data *c;
+ uint64_t ms_start_addr, ms_end_addr;
+ uint64_t elem_start_addr, elem_end_addr;
+ uint32_t ms_list_idx = 0;
+ uint32_t heap_id = 0;
+ uint32_t ms_idx = 0;
+ uint32_t start_elem = 0, end_elem = 0;
+ uint32_t count = 0, elem_count = 0;
+ char dlim[2] = ",";
+ char str[ADDR_STR];
+ char *params_args;
+ char *token;
+
+ if (params == NULL || strlen(params) == 0)
+ return -1;
+
+ if (strncasecmp(params, "help", strlen(params)) == 0) {
+ char buff[RTE_TEL_MAX_SINGLE_STRING_LEN];
+ snprintf(buff, RTE_TEL_MAX_SINGLE_STRING_LEN,
+ "%s,<heap-id>,<memseg-list-id>,<memseg-id>,"
+ "<elem-start-id>,<elem-end-id>",
+ EAL_ELEMENT_INFO_REQ);
+ rte_tel_data_string(d, buff);
+ return 0;
+ }
+
+ /* strtok expects char * and param is const char *. Hence on using
+ * params as "const char *" compiler throws warning.
+ */
+ params_args = strdup(params);
+ token = strtok(params_args, dlim);
+ if (token == NULL || !isdigit(*token)) {
+ free(params_args);
+ return -1;
+ }
+
+ heap_id = strtoul(token, NULL, 10);
+ if (heap_id >= RTE_MAX_HEAPS) {
+ free(params_args);
+ return -1;
+ }
+
+ token = strtok(NULL, dlim);
+ if (token == NULL || !isdigit(*token)) {
+ free(params_args);
+ return -1;
+ }
+
+ ms_list_idx = strtoul(token, NULL, 10);
+ if (ms_list_idx >= RTE_MAX_MEMSEG_LISTS) {
+ free(params_args);
+ return -1;
+ }
+
+ token = strtok(NULL, dlim);
+ if (token == NULL || !isdigit(*token)) {
+ free(params_args);
+ return -1;
+ }
+
+ ms_idx = strtoul(token, NULL, 10);
+
+ token = strtok(NULL, dlim);
+ if (token == NULL || !isdigit(*token)) {
+ free(params_args);
+ return -1;
+ }
+
+ start_elem = strtoul(token, NULL, 10);
+
+ token = strtok(NULL, dlim);
+ if (token == NULL || !isdigit(*token)) {
+ free(params_args);
+ return -1;
+ }
+
+ end_elem = strtoul(token, NULL, 10);
+
+ free(params_args);
+
+ if (end_elem < start_elem)
+ return -1;
+
+ rte_mcfg_mem_read_lock();
+
+ mcfg = rte_eal_get_configuration()->mem_config;
+ msl = &mcfg->memsegs[ms_list_idx];
+ ms = rte_fbarray_get(&msl->memseg_arr, ms_idx);
+ if (ms == NULL) {
+ rte_mcfg_mem_read_unlock();
+ RTE_LOG(DEBUG, EAL, "Error fetching requested memseg.\n");
+ return -1;
+ }
+
+ ms_start_addr = ms->addr_64;
+ ms_end_addr = (uint64_t)RTE_PTR_ADD(ms_start_addr, ms->len);
+
+ rte_mcfg_mem_read_unlock();
+
+ rte_tel_data_start_dict(d);
+
+ heap = &mcfg->malloc_heaps[heap_id];
+ rte_spinlock_lock(&heap->lock);
+
+ elem = heap->first;
+ while (elem) {
+ elem_start_addr = (uint64_t)elem;
+ elem_end_addr =
+ (uint64_t)RTE_PTR_ADD(elem_start_addr, elem->size);
+
+ if (elem_start_addr < ms_start_addr ||
+ elem_end_addr > ms_end_addr) {
+ elem = elem->next;
+ continue;
+ }
+
+ if (count < start_elem) {
+ elem = elem->next;
+ count++;
+ continue;
+ }
+
+ c = rte_tel_data_alloc();
+ if (c == NULL)
+ break;
+
+ rte_tel_data_start_dict(c);
+ rte_tel_data_add_dict_int(c, "msl_id", ms_list_idx);
+ rte_tel_data_add_dict_int(c, "ms_id", ms_idx);
+ snprintf(str, ADDR_STR, "0x%"PRIx64, ms_start_addr);
+ rte_tel_data_add_dict_string(c, "memseg_start_addr", str);
+ snprintf(str, ADDR_STR, "0x%"PRIx64, ms_end_addr);
+ rte_tel_data_add_dict_string(c, "memseg_end_addr", str);
+ snprintf(str, ADDR_STR, "0x%"PRIx64, elem_start_addr);
+ rte_tel_data_add_dict_string(c, "element_start_addr", str);
+ snprintf(str, ADDR_STR, "0x%"PRIx64, elem_end_addr);
+ rte_tel_data_add_dict_string(c, "element_end_addr", str);
+ rte_tel_data_add_dict_int(c, "element_size", elem->size);
+ snprintf(str, ADDR_STR, "%s", elem->state == 0 ? "Free" :
+ elem->state == 1 ? "Busy" : elem->state == 2 ?
+ "Pad" : "Error");
+ rte_tel_data_add_dict_string(c, "element_state", str);
+
+ snprintf(str, ADDR_STR, "%s.%u", "element", count);
+ if (rte_tel_data_add_dict_container(d, str, c, 0) != 0) {
+ rte_tel_data_free(c);
+ break;
+ }
+
+ elem_count++;
+ count++;
+ if (count > end_elem)
+ break;
+
+ elem = elem->next;
+ }
+
+ rte_spinlock_unlock(&heap->lock);
+
+ rte_tel_data_add_dict_int(d, "Element_count", elem_count);
+
+ return 0;
+}
+
RTE_INIT(memory_telemetry)
{
rte_telemetry_register_cmd(
@@ -1279,5 +1734,22 @@ RTE_INIT(memory_telemetry)
rte_telemetry_register_cmd(
EAL_HEAP_INFO_REQ, handle_eal_heap_info_request,
"Returns malloc heap stats. Parameters: int heap_id");
+ rte_telemetry_register_cmd(
+ EAL_MEMSEG_LIST_ARR_REQ,
+ handle_eal_memseg_list_array_request,
+ "Returns hugepage list. Takes no parameters");
+ rte_telemetry_register_cmd(
+ EAL_MEMSEG_LIST_INFO_REQ,
+ handle_eal_memseg_list_info_request,
+ "Returns memseg list. Parameters: int memseg_list_id");
+ rte_telemetry_register_cmd(
+ EAL_MEMSEG_INFO_REQ, handle_eal_memseg_info_request,
+ "Returns memseg info. Parameter: int memseg_list_id,int memseg_id");
+ rte_telemetry_register_cmd(EAL_ELEMENT_LIST_REQ,
+ handle_eal_element_list_request,
+ "Returns element info. Parameters: int heap_id, int memseg_list_id, int memseg_id");
+ rte_telemetry_register_cmd(EAL_ELEMENT_INFO_REQ,
+ handle_eal_element_info_request,
+ "Returns element info. Parameters: int heap_id, memseg_list_id, memseg_id, start_elem_id, end_elem_id");
}
#endif
--
2.25.1
next prev parent reply other threads:[~2022-05-25 10:34 UTC|newest]
Thread overview: 42+ messages / expand[flat|nested] mbox.gz Atom feed top
2022-05-19 6:30 [PATCH] " Amit Prakash Shukla
2022-05-19 12:42 ` David Marchand
2022-05-19 18:57 ` [PATCH v2] " Amit Prakash Shukla
2022-05-23 11:14 ` Bruce Richardson
2022-05-23 13:35 ` [EXT] " Amit Prakash Shukla
2022-05-23 13:43 ` Bruce Richardson
2022-05-24 10:30 ` Amit Prakash Shukla
2022-05-24 10:33 ` [PATCH v3] " Amit Prakash Shukla
2022-05-25 10:33 ` Amit Prakash Shukla [this message]
2022-05-25 10:33 ` [PATCH v4 2/2] mem: telemetry support for system memory information Amit Prakash Shukla
2022-06-30 5:54 ` Amit Prakash Shukla
2022-07-21 11:21 ` Amit Prakash Shukla
2022-06-14 12:50 ` [PATCH v4 1/2] mem: telemetry support for memseg and element information Amit Prakash Shukla
2022-06-30 5:52 ` Amit Prakash Shukla
2022-07-21 11:20 ` Amit Prakash Shukla
2022-09-29 8:29 ` David Marchand
2022-09-29 11:30 ` [EXT] " Amit Prakash Shukla
2022-09-29 11:43 ` [PATCH v5 " Amit Prakash Shukla
2022-09-29 11:43 ` [PATCH v5 2/2] mem: telemetry support for system memory information Amit Prakash Shukla
2022-10-07 19:46 ` David Marchand
2022-10-11 7:10 ` [EXT] " Amit Prakash Shukla
2022-10-20 19:18 ` Dmitry Kozlyuk
2022-10-20 19:50 ` Stephen Hemminger
2022-10-06 7:07 ` [PATCH v5 1/2] mem: telemetry support for memseg and element information Amit Prakash Shukla
2022-10-07 19:52 ` David Marchand
2022-10-07 19:48 ` David Marchand
2022-10-11 7:22 ` [EXT] " Amit Prakash Shukla
2022-10-20 11:40 ` Dmitry Kozlyuk
2022-10-21 19:26 ` [EXT] " Amit Prakash Shukla
2022-10-21 20:07 ` Dmitry Kozlyuk
2022-10-25 7:25 ` Amit Prakash Shukla
2022-10-25 11:51 ` [PATCH v6] " Amit Prakash Shukla
2022-10-25 13:02 ` [PATCH v7] " Amit Prakash Shukla
2022-12-06 11:46 ` Amit Prakash Shukla
2023-01-30 10:18 ` Amit Prakash Shukla
2023-02-20 11:10 ` Thomas Monjalon
2023-02-28 7:30 ` [EXT] " Amit Prakash Shukla
2023-05-15 11:51 ` Amit Prakash Shukla
2023-05-16 10:47 ` Burakov, Anatoly
2023-05-17 9:08 ` [EXT] " Amit Prakash Shukla
2023-05-17 9:21 ` [PATCH v8] " Amit Prakash Shukla
2023-06-07 20:40 ` David Marchand
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20220525103352.1806937-1-amitprakashs@marvell.com \
--to=amitprakashs@marvell.com \
--cc=anatoly.burakov@intel.com \
--cc=bruce.richardson@intel.com \
--cc=dev@dpdk.org \
--cc=jerinj@marvell.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).