Skip to contentSkip to conversation

lib: add .request_hugepages to reserve hugepage

PATCH New Li Wang 3 participants 10 messages Feb 8, 2020 – Feb 24, 2020 Library code

lore
Share & tools
lore

Li Wang

author
#0 lore raw

PATCH v4 1/2 lib: add .request_hugepages to reserve hugepage

Many of the ltp tests need to use hugepage in their testing, this allows the test can reserve hpages from system only via .request_hugepages = xx.

If set non-zero number of request_hugepages, test will try to reserve the expected number of hugepage for testing in setup phase. If system does not have enough hpage for using, it will try the best to reserve 80% available number of hpages. For a system without hugetlb supporting, variable 'tst_hugepage' will be set to 0.

---

Notes:
v3 --> v4
* add doc to check the hpage number in setup()
* remove the TCONF print if hugepage is not supported
* check here that max_hpages * 0.8 > 1

 doc/test-writing-guidelines.txt | 58 ++++++++++++++++++++++++++++++++
 include/tst_hugepage.h          | 29 ++++++++++++++++
 include/tst_test.h              | 13 ++++++++
 lib/newlib_tests/.gitignore     |  1 +
 lib/newlib_tests/test20.c       | 45 +++++++++++++++++++++++++
 lib/tst_hugepage.c              | 59 +++++++++++++++++++++++++++++++++
 lib/tst_test.c                  |  6 ++--
 7 files changed, 209 insertions(+), 2 deletions(-)
 create mode 100644 include/tst_hugepage.h
 create mode 100644 lib/newlib_tests/test20.c
 create mode 100644 lib/tst_hugepage.c
doc/test-writing-guidelines.txt +58 -0
index 546bb7a49..fa7cb89c1 100644
@@ -1933,6 +1933,64 @@ specified by the user plus some other heuristics.
 
 For full documentation see the comments in 'include/tst_fuzzy_sync.h'.
 
+2.2.34 Reserving hugepages
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Many of the ltp tests need to use hugepage in their testing, this allows the
+test can reserve hugepages from system only via .request_hugepages = xx.
+
+If set non-zero number of request_hugepages, test will try to reserve the
+expected number of hugepage for testing in setup phase. If system does not
+have enough hpage for using, it will try the best to reserve 80% available
+number of hpages. With success test stores the reserved hugepage number in
+'tst_hugepages. For the system without hugetlb supporting, variable
+'tst_hugepages' will be set to 0.
+
+Also, we do cleanup and restore work for the hpages resetting automatically.
+
+[source,c]
+-------------------------------------------------------------------------------
+#include "tst_test.h"
+
+static void run(void)
+{
+	...
+
+	if (tst_hugepages == test.request_hugepages)
+		TEST(do_hpage_test);
+	else
+		...
+	...
+}
+
+struct tst_test test = {
+	.test_all = run,
+	.request_hugepages = 2,
+	...
+};
+
+or,
+
+#include "tst_test.h"
+
+static void run(void)
+{
+	...
+}
+
+static void setup(void)
+{
+?? ?? ?? ?? if (tst_hugepages != test.requested_hugepages)
+?? ?? ?? ?? ?? ?? ?? ?? tst_brk(TCONF, "...");
+}
+
+struct tst_test test = {
+	.test_all = run,
+	.request_hugepages = 2,
+	...
+};
+-------------------------------------------------------------------------------
+
 2.3 Writing a testcase in shell
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
include/tst_hugepage.h new file +29 -0
new file mode 100644
index 000000000..10e0eaf47
@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2019 Red Hat, Inc.
+ */
+
+#ifndef TST_HUGEPAGE__
+#define TST_HUGEPAGE__
+
+#define PATH_HUGEPAGES	"/sys/kernel/mm/hugepages/"
+#define PATH_NR_HPAGES	"/proc/sys/vm/nr_hugepages"
+
+/*
+ * Try the best to request a specified number of huge pages from system,
+ * it will store the reserved hpage number in tst_hugepages.
+ *
+ * Note: this depend on the status of system memory fragmentation.
+ */
+int tst_request_hugepages(int hpages);
+
+/*
+ * This variable is used for recording the number of hugepages which system can
+ * provides. It will be equal to 'hpages' if tst_request_hugepages on success,
+ * otherwise set it to a number of hugepages that we were able to reserve.
+ *
+ * If system does not support hugetlb, then it will be set to 0.
+ */
+extern unsigned int tst_hugepages;
+
+#endif /* TST_HUGEPAGE_H */
include/tst_test.h +13 -0
index 21c7dfbdb..1026a422a 100644
@@ -37,6 +37,7 @@
 #include "tst_coredump.h"
 #include "tst_buffers.h"
 #include "tst_capability.h"
+#include "tst_hugepage.h"
 
 /*
  * Reports testcase result.
@@ -148,6 +149,18 @@ struct tst_test {
 	 */
 	int all_filesystems:1;
 
+	/*
+	 * If set non-zero number of request_hugepages, test will try to reserve the
+	 * expected number of hugepage for testing in setup phase. If system does not
+	 * have enough hpage for using, it will try the best to reserve 80% available
+	 * number of hpages. With success test stores the reserved hugepage number in
+	 * 'tst_hugepages. For the system without hugetlb supporting, variable
+	 * 'tst_hugepages' will be set to 0.
+	 *
+	 * Also, we do cleanup and restore work for the hpages resetting automatically.
+	 */
+	unsigned int request_hugepages;
+
 	/*
 	 * If set non-zero denotes number of test variant, the test is executed
 	 * variants times each time with tst_variant set to different number.
lib/newlib_tests/.gitignore +1 -0
index d4aa4935f..ab3a92c4c 100644
@@ -23,6 +23,7 @@ tst_strstatus
 test17
 test18
 test19
+test20
 tst_expiration_timer
 test_exec
 test_exec_child
lib/newlib_tests/test20.c new file +45 -0

45 lines not on this page · raw message

lib/tst_hugepage.c new file +59 -0

59 lines not on this page · raw message

lib/tst_test.c +4 -2
index 8d7dee2cc..9a24cffc5 100644
@@ -890,6 +890,9 @@ static void do_setup(int argc, char *argv[])
 	if (tst_test->all_filesystems)
 		tst_test->needs_device = 1;
 
+	if (tst_test->request_hugepages)
+		tst_request_hugepages(tst_test->request_hugepages);
+
 	setup_ipc();
 
 	if (tst_test->bufs)
@@ -1006,8 +1009,7 @@ static void do_cleanup(void)
 		tst_rmdir();
 	}
 
-	if (tst_test->save_restore)
-		tst_sys_conf_restore(0);
+	tst_sys_conf_restore(0);
 
 	if (tst_test->restore_wallclock)
 		tst_wallclock_restore();
Signature · 1 line
2.20.1
author
#1 lore raw

PATCH v4 2/2 pkey01: disable hugetlb test if failed to reserve hugepage

To handle the false positive:
pkey01.c:69: BROK: nr_hugepages = 0, but expect 1

---
 testcases/kernel/syscalls/pkeys/pkey01.c | 29 ++++++------------------
 1 file changed, 7 insertions(+), 22 deletions(-)
testcases/kernel/syscalls/pkeys/pkey01.c +7 -22
index fa84e71f3..04f50924c 100644
@@ -36,12 +36,6 @@
 #define PATH_VM_NRHPS "/proc/sys/vm/nr_hugepages"
 
 static int size;
-static int no_hugepage;
-
-static const char * const save_restore[] = {
-	"?/proc/sys/vm/nr_hugepages",
-	NULL,
-};
 
 static struct tcase {
 	unsigned long flags;
@@ -56,22 +50,13 @@ static void setup(void)
 {
 	int i, fd;
 
-	if (access("/sys/kernel/mm/hugepages/", F_OK)) {
-		tst_res(TINFO, "Huge page is not supported");
-		size = getpagesize();
-		no_hugepage = 1;
-	} else {
-		int val;
-		SAFE_FILE_PRINTF(PATH_VM_NRHPS, "%d", 1);
-		SAFE_FILE_SCANF(PATH_VM_NRHPS, "%d", &val);
-		if (val != 1)
-			tst_brk(TBROK, "nr_hugepages = %d, but expect %d",
-					val, 1);
-		size = SAFE_READ_MEMINFO("Hugepagesize:") * 1024;
-	}
-
 	check_pkey_support();
 
+	if (tst_hugepages == test.request_hugepages)
+		size = SAFE_READ_MEMINFO("Hugepagesize:") * 1024;
+	else
+		size = getpagesize();
+
 	fd = SAFE_OPEN(TEST_FILE, O_RDWR | O_CREAT, 0664);
 	for (i = 0; i < 128; i++)
 		SAFE_WRITE(1, fd, STR, strlen(STR));
@@ -147,7 +132,7 @@ static void pkey_test(struct tcase *tc, struct mmap_param *mpa)
 	int pkey, status;
 	int fd = mpa->fd;
 
-	if (no_hugepage && (mpa->flags & MAP_HUGETLB)) {
+	if (!tst_hugepages && (mpa->flags & MAP_HUGETLB)) {
 		tst_res(TINFO, "Skip test on (%s) buffer", flag_to_str(mpa->flags));
 		return;
 	}
@@ -236,5 +221,5 @@ static struct tst_test test = {
 	.forks_child = 1,
 	.test = verify_pkey,
 	.setup = setup,
-	.save_restore = save_restore,
+	.request_hugepages = 1,
 };
Signature · 1 line
2.20.1
#2 lore raw

PATCH v4 2/2 pkey01: disable hugetlb test if failed to reserve hugepage

Hi,

Quoted 2 lines

To handle the false positive:
pkey01.c:69: BROK: nr_hugepages = 0, but expect 1

Kind regards,
Petr

#3 lore raw

PATCH v4 1/2 lib: add .request_hugepages to reserve hugepage

In reply to Li Wang

Hi Li,

Code looks good.
Minor issue: doc has broken formatting.

Review

Quoted 11 lines

+2.2.34 Reserving hugepages
+^^^^^^^^^^^^^^^^^^^^^^^^^^

(quoted diff) +9 -0
+
+Many of the ltp tests need to use hugepage in their testing, this allows the
+test can reserve hugepages from system only via .request_hugepages = xx.
+
+If set non-zero number of request_hugepages, test will try to reserve the
+expected number of hugepage for testing in setup phase. If system does not
+have enough hpage for using, it will try the best to reserve 80% available
+number of hpages. With success test stores the reserved hugepage number in
+'tst_hugepages. For the system without hugetlb supporting, variable

Missing ' here ^

Quoted 1 line

+'tst_hugepages' will be set to 0.

I propose these changes (+ strip this formatting from comments in C source - include/tst_test.h).

Kind regards,
Petr

test-writing-guidelines.txt +7 -4
index b9f8d5ab0..ae9a8b040 100644
@@ -1945,14 +1945,14 @@ For full documentation see the comments in 'include/tst_fuzzy_sync.h'.
 2.2.34 Reserving hugepages
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Many of the ltp tests need to use hugepage in their testing, this allows the
-test can reserve hugepages from system only via .request_hugepages = xx.
+Many of the LTP tests need to use hugepage in their testing, this allows the
+test can reserve hugepages from system only via '.request_hugepages = xx'.
 
-If set non-zero number of request_hugepages, test will try to reserve the
+If set non-zero number of 'request_hugepages', test will try to reserve the
 expected number of hugepage for testing in setup phase. If system does not
 have enough hpage for using, it will try the best to reserve 80% available
 number of hpages. With success test stores the reserved hugepage number in
-'tst_hugepages. For the system without hugetlb supporting, variable
+'tst_hugepages'. For the system without hugetlb supporting, variable
 'tst_hugepages' will be set to 0.
 
 Also, we do cleanup and restore work for the hpages resetting automatically.
@@ -1977,9 +1977,12 @@ struct tst_test test = {
 	.request_hugepages = 2,
 	...
 };
+[source,c]
+-------------------------------------------------------------------------------
 
 or,
 
+-------------------------------------------------------------------------------
 #include "tst_test.h"
 
 static void run(void)
author
#4 lore raw

PATCH v4 1/2 lib: add .request_hugepages to reserve hugepage

Hi Petr,

Quoted 5 lines · Petr Vorel

Hi Li,

Code looks good.

Thanks!

Quoted 7 lines

Minor issue: doc has broken formatting.
...

Quoted 1 line

+'tst_hugepages' will be set to 0.

I propose these changes (+ strip this formatting from comments in C source
- include/tst_test.h).

Thanks for this advice, I have done modifications in my local commit.

Before pushing I would give a bit more time to Cyril for a review, in case he has additional suggestions.

Signature · 5 lines
Regards,
Li Wang
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.linux.it/pipermail/ltp/attachments/20200218/7b4bfd7b/attachment.htm>
#5 lore raw

PATCH v4 1/2 lib: add .request_hugepages to reserve hugepage

In reply to Li Wang

Hi!

Quoted 260 lines

Many of the ltp tests need to use hugepage in their testing, this allows the test can reserve hpages from system only via .request_hugepages = xx.

If set non-zero number of request_hugepages, test will try to reserve the expected number of hugepage for testing in setup phase. If system does not have enough hpage for using, it will try the best to reserve 80% available number of hpages. For a system without hugetlb supporting, variable 'tst_hugepage' will be set to 0.

---

Notes:
v3 --> v4
* add doc to check the hpage number in setup()
* remove the TCONF print if hugepage is not supported
* check here that max_hpages * 0.8 > 1

 doc/test-writing-guidelines.txt | 58 ++++++++++++++++++++++++++++++++
 include/tst_hugepage.h          | 29 ++++++++++++++++
 include/tst_test.h              | 13 ++++++++
 lib/newlib_tests/.gitignore     |  1 +
 lib/newlib_tests/test20.c       | 45 +++++++++++++++++++++++++
 lib/tst_hugepage.c              | 59 +++++++++++++++++++++++++++++++++
 lib/tst_test.c                  |  6 ++--
 7 files changed, 209 insertions(+), 2 deletions(-)
 create mode 100644 include/tst_hugepage.h
 create mode 100644 lib/newlib_tests/test20.c
 create mode 100644 lib/tst_hugepage.c
doc/test-writing-guidelines.txt +58 -0
index 546bb7a49..fa7cb89c1 100644
@@ -1933,6 +1933,64 @@ specified by the user plus some other heuristics.
 
 For full documentation see the comments in 'include/tst_fuzzy_sync.h'.
 
+2.2.34 Reserving hugepages
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Many of the ltp tests need to use hugepage in their testing, this allows the
+test can reserve hugepages from system only via .request_hugepages = xx.
+
+If set non-zero number of request_hugepages, test will try to reserve the
+expected number of hugepage for testing in setup phase. If system does not
+have enough hpage for using, it will try the best to reserve 80% available
+number of hpages. With success test stores the reserved hugepage number in
+'tst_hugepages. For the system without hugetlb supporting, variable
+'tst_hugepages' will be set to 0.
+
+Also, we do cleanup and restore work for the hpages resetting automatically.
+
+[source,c]
+-------------------------------------------------------------------------------
+#include "tst_test.h"
+
+static void run(void)
+{
+	...
+
+	if (tst_hugepages == test.request_hugepages)
+		TEST(do_hpage_test);
+	else
+		...
+	...
+}
+
+struct tst_test test = {
+	.test_all = run,
+	.request_hugepages = 2,
+	...
+};
+
+or,
+
+#include "tst_test.h"
+
+static void run(void)
+{
+	...
+}
+
+static void setup(void)
+{
+?? ?? ?? ?? if (tst_hugepages != test.requested_hugepages)
+?? ?? ?? ?? ?? ?? ?? ?? tst_brk(TCONF, "...");
+}
+
+struct tst_test test = {
+	.test_all = run,
+	.request_hugepages = 2,
+	...
+};
+-------------------------------------------------------------------------------
+
 2.3 Writing a testcase in shell
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
include/tst_hugepage.h new file +29 -0
new file mode 100644
index 000000000..10e0eaf47
@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2019 Red Hat, Inc.
+ */
+
+#ifndef TST_HUGEPAGE__
+#define TST_HUGEPAGE__
+
+#define PATH_HUGEPAGES	"/sys/kernel/mm/hugepages/"
+#define PATH_NR_HPAGES	"/proc/sys/vm/nr_hugepages"
+
+/*
+ * Try the best to request a specified number of huge pages from system,
+ * it will store the reserved hpage number in tst_hugepages.
+ *
+ * Note: this depend on the status of system memory fragmentation.
+ */
+int tst_request_hugepages(int hpages);
+
+/*
+ * This variable is used for recording the number of hugepages which system can
+ * provides. It will be equal to 'hpages' if tst_request_hugepages on success,
+ * otherwise set it to a number of hugepages that we were able to reserve.
+ *
+ * If system does not support hugetlb, then it will be set to 0.
+ */
+extern unsigned int tst_hugepages;
+
+#endif /* TST_HUGEPAGE_H */
include/tst_test.h +13 -0
index 21c7dfbdb..1026a422a 100644
@@ -37,6 +37,7 @@
 #include "tst_coredump.h"
 #include "tst_buffers.h"
 #include "tst_capability.h"
+#include "tst_hugepage.h"
 
 /*
  * Reports testcase result.
@@ -148,6 +149,18 @@ struct tst_test {
 	 */
 	int all_filesystems:1;
 
+	/*
+	 * If set non-zero number of request_hugepages, test will try to reserve the
+	 * expected number of hugepage for testing in setup phase. If system does not
+	 * have enough hpage for using, it will try the best to reserve 80% available
+	 * number of hpages. With success test stores the reserved hugepage number in
+	 * 'tst_hugepages. For the system without hugetlb supporting, variable
+	 * 'tst_hugepages' will be set to 0.
+	 *
+	 * Also, we do cleanup and restore work for the hpages resetting automatically.
+	 */
+	unsigned int request_hugepages;
+
 	/*
 	 * If set non-zero denotes number of test variant, the test is executed
 	 * variants times each time with tst_variant set to different number.
lib/newlib_tests/.gitignore +1 -0
index d4aa4935f..ab3a92c4c 100644
@@ -23,6 +23,7 @@ tst_strstatus
 test17
 test18
 test19
+test20
 tst_expiration_timer
 test_exec
 test_exec_child
lib/newlib_tests/test20.c new file +45 -0
new file mode 100644
index 000000000..92e230976
@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2019 Li Wang <[email protected]>
+ */
+
+/*
+ * Tests .request_hugepages + .save_restore
+ */
+
+#include "tst_test.h"
+#include "tst_hugepage.h"
+#include "tst_sys_conf.h"
+
+static const char * const save_restore[] = {
+	"!/proc/sys/kernel/numa_balancing",
+	NULL,
+};
+
+static void do_test(void) {
+
+	int val, hpages;
+
+	tst_res(TINFO, "tst_hugepages = %u", tst_hugepages);
+	SAFE_FILE_PRINTF("/proc/sys/kernel/numa_balancing", "1");
+
+	hpages = test.request_hugepages;
+	SAFE_FILE_SCANF(PATH_NR_HPAGES, "%d", &val);
+	if (val != hpages)
+		tst_brk(TBROK, "nr_hugepages = %d, but expect %d", val, hpages);
+	else
+		tst_res(TPASS, "test .needs_hugepges");
+
+	hpages = tst_request_hugepages(3);
+	SAFE_FILE_SCANF(PATH_NR_HPAGES, "%d", &val);
+	if (val != hpages)
+		tst_brk(TBROK, "nr_hugepages = %d, but expect %d", val, hpages);
+	else
+		tst_res(TPASS, "tst_request_hugepages");
+}
+
+static struct tst_test test = {
+	.test_all = do_test,
+	.request_hugepages = 2,
+	.save_restore = save_restore,
+};
lib/tst_hugepage.c new file +26 -0
new file mode 100644
index 000000000..d37b45e3a
@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2019 Red Hat, Inc.
+ */
+
+#define TST_NO_DEFAULT_MAIN
+
+#include "tst_test.h"
+#include "tst_hugepage.h"
+
+unsigned int tst_hugepages;
+
+int tst_request_hugepages(int hpages)
+{
+	int val;
+	long mem_avail, max_hpages;
+
+	if (access(PATH_HUGEPAGES, F_OK)) {
+		tst_hugepages = 0;
+		goto out;
+	}
+
+	tst_hugepages = hpages;
+
+	SAFE_FILE_PRINTF("/proc/sys/vm/drop_caches", "3");
+

lib/tst_hugepage.c line 36

Quoted 10 lines
lib/tst_hugepage.c new file +10 -0
+	if (FILE_LINES_SCANF("/proc/meminfo",
+				"MemAvailable: %ld", &mem_avail)) {
+		/*
+		 * Using "MemFree:" on kernel that doesn't have
+		 * "MemAvailable:" in Meminfo
+		 */
+		tst_res(TINFO, "MemAvailable: not found in /proc/meminfo");
+
+		mem_avail = SAFE_READ_MEMINFO("MemFree:");
+	}

I guess that we don't have to bother with MemAvailable here, since we do drop the system caches the MemFree should be equal to MemAvailable. So I would be for reading just MemFree unconditionally here.

If you agree with this change I can change it before applying.

Quoted 53 lines
lib/tst_hugepage.c new file +22 -0
+	max_hpages = mem_avail / SAFE_READ_MEMINFO("Hugepagesize:");
+
+	if (hpages > max_hpages) {
+		tst_res(TINFO, "Requested number(%d) of hugepages is too large, "
+				"limiting to 80%% of the max hugepage count %ld",
+				hpages, max_hpages);
+		tst_hugepages = max_hpages * 0.8;
+
+		if (tst_hugepages < 1)
+			goto out;
+	}
+
+	tst_sys_conf_save("?/proc/sys/vm/nr_hugepages");
+	SAFE_FILE_PRINTF(PATH_NR_HPAGES, "%d", tst_hugepages);
+	SAFE_FILE_SCANF(PATH_NR_HPAGES, "%d", &val);
+	if (val != tst_hugepages)
+		tst_brk(TBROK, "nr_hugepages = %d, but expect %d", val, tst_hugepages);
+
+	tst_res(TINFO, "%d hugepage(s) reserved", tst_hugepages);
+out:
+	return tst_hugepages;
+}
lib/tst_test.c +4 -2
index 8d7dee2cc..9a24cffc5 100644
@@ -890,6 +890,9 @@ static void do_setup(int argc, char *argv[])
 	if (tst_test->all_filesystems)
 		tst_test->needs_device = 1;
 
+	if (tst_test->request_hugepages)
+		tst_request_hugepages(tst_test->request_hugepages);
+
 	setup_ipc();
 
 	if (tst_test->bufs)
@@ -1006,8 +1009,7 @@ static void do_cleanup(void)
 		tst_rmdir();
 	}
 
-	if (tst_test->save_restore)
-		tst_sys_conf_restore(0);
+	tst_sys_conf_restore(0);
 
 	if (tst_test->restore_wallclock)
 		tst_wallclock_restore();
Signature · 6 lines
2.20.1



-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
Signature · 2 lines
Cyril Hrubis
[email protected]
author
#6 lore raw

PATCH v4 1/2 lib: add .request_hugepages to reserve hugepage

Cyril Hrubis <[email protected]> wrote:

...

Quoted 8 lines

lib/tst_hugepage.c line 36

Quoted 3 lines
lib/tst_hugepage.c new file +3 -0
+
+             mem_avail = SAFE_READ_MEMINFO("MemFree:");
+     }

I guess that we don't have to bother with MemAvailable here, since we do drop the system caches the MemFree should be equal to MemAvailable. So I would be for reading just MemFree unconditionally here.

+1 yes, that's right.

Quoted 2 lines

If you agree with this change I can change it before applying.

Of course yes, feel free to do that (and remember to add the changes which Petr suggested).

Signature · 5 lines
Regards,
Li Wang
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.linux.it/pipermail/ltp/attachments/20200219/ecf02c99/attachment.htm>
#7 lore raw

PATCH v4 1/2 lib: add .request_hugepages to reserve hugepage

In reply to Cyril Hrubis

Hi Li, Cyril,

Quoted 15 lines

lib/tst_hugepage.c line 36

Quoted 10 lines
lib/tst_hugepage.c new file +10 -0
+	if (FILE_LINES_SCANF("/proc/meminfo",
+				"MemAvailable: %ld", &mem_avail)) {
+		/*
+		 * Using "MemFree:" on kernel that doesn't have
+		 * "MemAvailable:" in Meminfo
+		 */
+		tst_res(TINFO, "MemAvailable: not found in /proc/meminfo");
+
+		mem_avail = SAFE_READ_MEMINFO("MemFree:");
+	}

I guess that we don't have to bother with MemAvailable here, since we do drop the system caches the MemFree should be equal to MemAvailable. So I would be for reading just MemFree unconditionally here.

Quoted 1 line

If you agree with this change I can change it before applying.

Merged both patches with this change and my docs change.

Kind regards,
Petr

author
#8 lore raw

PATCH v4 1/2 lib: add .request_hugepages to reserve hugepage

Quoted 13 lines · Petr Vorel

Hi Li, Cyril,

Quoted 10 lines
Quoted 10 lines
lib/tst_hugepage.c new file +10 -0
+   if (FILE_LINES_SCANF("/proc/meminfo",
+                           "MemAvailable: %ld", &mem_avail)) {
+           /*
+            * Using "MemFree:" on kernel that doesn't have
+            * "MemAvailable:" in Meminfo
+            */
+           tst_res(TINFO, "MemAvailable: not found in /proc/meminfo");
+
+           mem_avail = SAFE_READ_MEMINFO("MemFree:");
+   }
Quoted 8 lines
Quoted 5 lines

I guess that we don't have to bother with MemAvailable here, since we do drop the system caches the MemFree should be equal to MemAvailable. So I would be for reading just MemFree unconditionally here.

If you agree with this change I can change it before applying.

Merged both patches with this change and my docs change.

Thanks very much Petr. Btw, I added a commit to remove the surplus variable 'mem_avail'.(It's a tiny issue so I pushed directly:)

Signature · 5 lines
Regards,
Li Wang
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.linux.it/pipermail/ltp/attachments/20200222/9598924f/attachment-0001.htm>
#9 lore raw

PATCH v4 1/2 lib: add .request_hugepages to reserve hugepage

Hi Li,

Quoted 5 lines
Quoted 2 lines
Quoted 1 line

If you agree with this change I can change it before applying.

Merged both patches with this change and my docs change.

Thanks very much Petr. Btw, I added a commit to remove the surplus variable 'mem_avail'.(It's a tiny issue so I pushed directly:)

Thanks for fixing it and sorry for not amending your commit correctly.

Kind regards,
Petr