Hi,
v1 -> v2: rewrite the overcommit_memory_test() functions.
please review it, any comments are welcome.
The case is designed to test overcommit_meory and overcommit_ratio
tunable's performance under /proc/sys/vm
/proc/sys/vm/overcommit_memory contains a flag that control memory
overcommitment.
- When this flag is 0, the kernel attempts to estimate the amount
of free memory left when userspace requests more memory.
- When this flag is 1, the kernel pretends there is always enough
memory until it actually runs out.
- When this flag is 2, the kernel uses a "never overcommit" policy
that attempts to prevent any overcommit of memory.
When overcommit_memoy is set to 2, the committed address space is
not permitted to exceed swap plus overcommit_ratio percentage of
physical RAM. the committed address limit can calculate by the
following equation:
commit_limit = swap_total + overcommit_ratio * physical_total
it can read from /proc/meminfo:CommitLimit
in the equation, swap_total and physical_total are constant,
overcommit_ratio is a val, so we can tune commit_limit by
overcommit_ratio.
Signed-off-by: Zhouping Liu <[email protected]>
---
runtest/mm | 7 +
testcases/kernel/mem/tunable/Makefile | 42 ++++
testcases/kernel/mem/tunable/overcommit_memory.c | 260 ++++++++++++++++++++++
3 files changed, 309 insertions(+), 0 deletions(-)
create mode 100644 testcases/kernel/mem/tunable/Makefile
create mode 100644 testcases/kernel/mem/tunable/overcommit_memory.c
--
Thanks,
Zhouping Liu
From 80a37fc6ee638d5a5e70f7aa8b22487378bc24f4 Mon Sep 17 00:00:00 2001
From: Zhouping Liu <[email protected]>
Date: Mon, 29 Aug 2011 12:45:48 +0800
Subject: [PATCH 2/2] mem/tunable: new testcase of memory overcommit
The case is designed to test overcommit_meory and overcommit_ratio
tunable's performance under /proc/sys/vm
/proc/sys/vm/overcommit_memory contains a flag that control memory
overcommitment.
- When this flag is 0, the kernel attempts to estimate the amount
of free memory left when userspace requests more memory.
- When this flag is 1, the kernel pretends there is always enough
memory until it actually runs out.
- When this flag is 2, the kernel uses a "never overcommit" policy
that attempts to prevent any overcommit of memory.
When overcommit_memoy is set to 2, the committed address space is
not permitted to exceed swap plus overcommit_ratio percentage of
physical RAM. the committed address limit can calculate by the
following equation:
commit_limit = swap_total + overcommit_ratio * physical_total
it can read from /proc/meminfo:CommitLimit
in the equation, swap_total and physical_total are constant,
overcommit_ratio is a val, so we can tune commit_limit by
overcommit_ratio.
Signed-off-by: Zhouping Liu <[email protected]>
---
runtest/mm | 7 +
testcases/kernel/mem/tunable/Makefile | 42 ++++
testcases/kernel/mem/tunable/overcommit_memory.c | 260 ++++++++++++++++++++++
3 files changed, 309 insertions(+), 0 deletions(-)
create mode 100644 testcases/kernel/mem/tunable/Makefile
create mode 100644 testcases/kernel/mem/tunable/overcommit_memory.c
diff --git a/runtest/mm b/runtest/mm
index 615f1f1..fb71189 100644
--- a/runtest/mm
+++ b/runtest/mm
@@ -82,3 +82,10 @@ thp01 thp01 -I 120
vma01 vma01
vma02 vma02
+
+overcommit_memory overcommit_memory
+overcommit_memory_1 overcommit_memory -R 0
+overcommit_memory_2 overcommit_memory -R 30
+overcommit_memory_3 overcommit_memory -R 80
+overcommit_memory_4 overcommit_memory -R 100
+overcommit_memory_5 overcommit_memory -R 200
diff --git a/testcases/kernel/mem/tunable/Makefile b/testcases/kernel/mem/tunable/Makefile
new file mode 100644
index 0000000..8ab52da
--- /dev/null
+++ b/testcases/kernel/mem/tunable/Makefile
@@ -0,0 +1,42 @@
+#
+# Copyright (C) 2011 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+# the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+
+top_srcdir ?= ../../../..
+
+include $(top_srcdir)/include/mk/testcases.mk
+
+LDLIBS += $(NUMA_LIBS) -lmem
+LIBDIR := ../lib
+LIB := $(LIBDIR)/libmem.a
+FILTER_OUT_DIRS := $(LIBDIR)
+LDFLAGS += -L$(LIBDIR)
+
+$(LIBDIR):
+ mkdir -p "$@"
+
+$(LIB): $(LIBDIR)
+ $(MAKE) -C $^ -f "$(abs_srcdir)/$^/Makefile" all
+
+MAKE_DEPS := $(LIB)
+
+trunk-clean:: | lib-clean
+
+lib-clean:: $(LIBDIR)
+ $(MAKE) -C $^ -f "$(abs_srcdir)/$^/Makefile" clean
+
+include $(top_srcdir)/include/mk/generic_leaf_target.mk
diff --git a/testcases/kernel/mem/tunable/overcommit_memory.c b/testcases/kernel/mem/tunable/overcommit_memory.c
new file mode 100644
index 0000000..cc04a71
--- /dev/null
+++ b/testcases/kernel/mem/tunable/overcommit_memory.c
@@ -0,0 +1,260 @@
+/*
+ * The case is designed to test overcommit_meory and overcommit_ratio
+ * tunable's performance under /proc/sys/vm
+ *
+ * Author: Zhouping Liu <[email protected]>
+ * Description:
+ * /proc/sys/vm/overcommit_memory contains a flag that control memory
+ * overcommitment.
+ * - When this flag is 0, the kernel attempts to estimate the amount
+ * of free memory left when userspace requests more memory.
+ * - When this flag is 1, the kernel pretends there is always enough
+ * memory until it actually runs out.
+ * - When this flag is 2, the kernel uses a "never overcommit" policy
+ * that attempts to prevent any overcommit of memory.
+ *
+ * When overcommit_memoy is set to 2, the committed address space is
+ * not permitted to exceed swap plus overcommit_ratio percentage of
+ * physical RAM. the committed address limit can calculate by the
+ * following equation:
+ * commit_limit = swap_total + overcommit_ratio * physical_total
+ * it can read from /proc/meminfo:CommitLimit
+ * in the equation, swap_total and physical_total are constant,
+ * overcommit_ratio is a val, so we can tune commit_limit by
+ * overcommit_ratio.
+ *
+ * ********************************************************************
+ * Copyright (C) 2011 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * Further, this software is distributed without any warranty that it
+ * is free of the rightful claim of any third person regarding
+ * infringement or the like. Any license provided herein, whether
+ * implied or otherwise, applies only to this software file. Patent
+ * licenses, if any, provided herein do not apply to combinations of
+ * this program with other software, or any other product whatsoever.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ * ********************************************************************
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include "test.h"
+#include "usctest.h"
+#include "../include/mem.h"
+
+#define FILE_OVER_MEM PATH_SYSVM "overcommit_memory"
+#define FILE_OVER_RATIO PATH_SYSVM "overcommit_ratio"
+#define DEFAULT_OVER_RATIO 50UL
+#define NORMAL_OVERCOMMIT 0
+#define ENOUGH_OVERCOMMIT 1
+#define NEVER_OVERCOMMIT 2
+#define EXPECT_PASS 0
+#define EXPECT_FAIL 1
+
+char *TCID = "overcommit_memory";
+static long old_overcommit_memory;
+static long old_overcommit_ratio;
+static long overcommit_ratio;
+
+static void overcommit_memory_test(void);
+static int heavy_malloc(unsigned long size);
+static void alloc_and_check(unsigned long size, int expect_result);
+static void ratio_usage(void);
+
+int main(int argc, char *argv[])
+{
+ char *msg, *R_opt;
+ int lc, R_flag;
+
+ option_t options[] = {
+ { "R:", &R_flag, &R_opt },
+ { NULL, NULL, NULL }
+ };
+
+ overcommit_ratio = DEFAULT_OVER_RATIO;
+
+ msg = parse_opts(argc, argv, options, &ratio_usage);
+ if (msg != NULL) {
+ tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s,"
+ "use -help", msg);
+ tst_exit();
+ }
+
+#if __WORDSIZE == 32
+ tst_brkm(TCONF, NULL, "test is not designed for 32-bit system.");
+#endif
+
+ if (R_flag) {
+ overcommit_ratio = atol(R_opt);
+ if (overcommit_ratio < 0) {
+ tst_brkm(TBROK, NULL, "-R option is required a"
+ "Non-negative");
+ tst_exit();
+ }
+ }
+
+ setup();
+
+ for (lc = 0; TEST_LOOPING(lc); lc++) {
+ Tst_count = 0;
+
+ overcommit_memory_test();
+ }
+
+ cleanup();
+
+ tst_exit();
+}
+
+void setup(void)
+{
+ tst_require_root(NULL);
+
+ tst_sig(NOFORK, DEF_HANDLER, cleanup);
+
+ TEST_PAUSE;
+
+ if (access(FILE_OVER_MEM, F_OK) != 0 ||
+ access(FILE_OVER_RATIO, F_OK) != 0)
+ tst_brkm(TCONF, NULL, "The system "
+ "can't support to test %s", TCID);
+
+ old_overcommit_memory = get_sys_tune(FILE_OVER_MEM);
+ old_overcommit_ratio = get_sys_tune(FILE_OVER_RATIO);
+
+ set_sys_tune(FILE_OVER_RATIO, overcommit_ratio);
+ check_sys_tune(FILE_OVER_RATIO, overcommit_ratio);
+}
+
+void cleanup(void)
+{
+ set_sys_tune(FILE_OVER_MEM, old_overcommit_memory);
+ set_sys_tune(FILE_OVER_RATIO, old_overcommit_ratio);
+
+ TEST_CLEANUP;
+}
+
+static void ratio_usage(void)
+{
+ printf(" -R n Percentage of overcommitting memory\n");
+}
+
+static void overcommit_memory_test(void)
+{
+ unsigned long mem_total, swap_total, free_total;
+ unsigned long commit_limit, committed, left_commit, sum_total;
+ unsigned long mem_free, swap_free;
+
+ mem_total = read_meminfo("MemTotal:");
+ swap_total = read_meminfo("SwapTotal:");
+ commit_limit = read_meminfo("CommitLimit:");
+ tst_resm(TINFO, "MemTotal is %lukB", mem_total);
+ tst_resm(TINFO, "SwapTotal is %lukB", swap_total);
+ tst_resm(TINFO, "CommitLimit is %lukB", commit_limit);
+
+ /*
+ * set overcommit_memory 0 <NORMAL OVERCOMMIT>
+ * in this mode, kernel attempts to estimate
+ * the amount of free memory left, that's to say
+ * it can't exceed the total of free memory.
+ */
+ set_sys_tune(FILE_OVER_MEM, NORMAL_OVERCOMMIT);
+ check_sys_tune(FILE_OVER_MEM, NORMAL_OVERCOMMIT);
+ tst_resm(TINFO, "starting test overcommit_memory = %d "
+ "<NORMAL OVERCOMMIT>", NORMAL_OVERCOMMIT);
+
+ mem_free = read_meminfo("MemFree:");
+ swap_free = read_meminfo("SwapFree:");
+ free_total = mem_free + swap_free;
+ alloc_and_check(free_total, EXPECT_PASS);
+
+ alloc_and_check(free_total * 2, EXPECT_FAIL);
+
+ /*
+ * set overcommit_memory 1 <ENOUGH OVERCOMMIT>
+ * in this mode, you can alloc over the limit of memory,
+ * because the kernel pretends there is always enough memory
+ * until it actually runs out.
+ */
+ set_sys_tune(FILE_OVER_MEM, ENOUGH_OVERCOMMIT);
+ check_sys_tune(FILE_OVER_MEM, ENOUGH_OVERCOMMIT);
+ tst_resm(TINFO, "starting test overcommit_memory = %d "
+ "<ENOUGH OVERCOMMIT>", ENOUGH_OVERCOMMIT);
+ sum_total = mem_total + swap_total;
+ alloc_and_check(sum_total, EXPECT_PASS);
+
+ alloc_and_check(commit_limit * 2, EXPECT_PASS);
+
+ /*
+ * set overcommit_memory 2 <NEVER OVERCOMMIT>
+ * in this mode, the kernle uses a "never overcommit" policy
+ * that attempts to prevent any overcomit of memory.
+ */
+ set_sys_tune(FILE_OVER_MEM, NEVER_OVERCOMMIT);
+ check_sys_tune(FILE_OVER_MEM, NEVER_OVERCOMMIT);
+ tst_resm(TINFO, "starting test overcommit_memory = %d "
+ "<NEVER OVERCOMMIT>", NEVER_OVERCOMMIT);
+
+ committed = read_meminfo("Committed_AS:");
+ if (commit_limit < committed)
+ tst_brkm(TCONF, cleanup, "unexpected error: commit_limit(%lukB)"
+ " < committed(%lukB)", commit_limit, committed);
+ left_commit = commit_limit - committed;
+ alloc_and_check(left_commit / 2, EXPECT_PASS);
+
+ alloc_and_check(commit_limit, EXPECT_FAIL);
+}
+
+static int heavy_malloc(unsigned long size)
+{
+ char *p;
+
+ p = (char *)malloc(size);
+ if (p != NULL) {
+ tst_resm(TINFO, "malloc %lu Bytes successfully", size);
+ free(p);
+ return 0;
+ } else {
+ tst_resm(TINFO, "malloc %lu Bytes failed", size);
+ return 1;
+ }
+}
+
+static void alloc_and_check(unsigned long size, int expect_result)
+{
+ int result;
+
+ tst_resm(TINFO, "try to alloc memory = %lu kB", size);
+ result = heavy_malloc(size * KB);
+
+ switch (expect_result) {
+ case EXPECT_PASS:
+ if (result == 0)
+ tst_resm(TPASS, "alloc passed as expected");
+ else
+ tst_resm(TFAIL, "alloc failed, expected to pass");
+ break;
+ case EXPECT_FAIL:
+ if (result != 0)
+ tst_resm(TPASS, "alloc failed as expected");
+ else
+ tst_resm(TFAIL, "alloc passed, expected to fail");
+ break;
+ default:
+ tst_brkm(TBROK, cleanup, "Invaild numbler parameter: %d",
+ expect_result);
+ }
+}
--
1.7.6
------------------------------------------------------------------------------
EMC VNX: the world's simplest storage, starting under $10K
The only unified storage solution that offers unified management
Up to 160% more powerful than alternatives and 25% more efficient.
Guaranteed. http://p.sf.net/sfu/emc-vnx-dev2dev
_______________________________________________
Ltp-list mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/ltp-list
