Skip to contentSkip to conversation

lib: add a function to lock memory into RAM

PATCH Superseded Thomas Wood 2 participants 3 messages Dec 8, 2014 – Dec 10, 2014 Library code

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 lib: add a function to lock memory into RAM

Add a function to lock memory into RAM and use it in the gem_tiled_swapping test to reduce the amount of allocated memory required to force swapping. This also reduces the amount of time required for the test to complete, since the data set is smaller.

---
 lib/igt_aux.c              | 48 ++++++++++++++++++++++++++++++++++++++++++++++
 lib/igt_aux.h              |  3 +++
 tests/gem_tiled_swapping.c |  7 ++++++-
 3 files changed, 57 insertions(+), 1 deletion(-)
lib/igt_aux.c +48 -0
index 3051d84..a98aa8f 100644
@@ -601,3 +601,51 @@ struct type_name connector_type_names[] = {
 };
 
 type_name_fn(connector_type)
+
+
+/**
+ * igt_lock_mem: @size: the amount of memory to lock into RAM, in MB
+ *
+ * Allocate @size MB of memory and lock it into RAM. This releases any
+ * previously locked memory.
+ *
+ * Use #igt_unlock_mem to release the currently locked memory.
+ */
+static char *locked_mem;
+static size_t locked_size;
+
+void igt_lock_mem(size_t size)
+{
+	long pagesize = sysconf(_SC_PAGESIZE);
+	size_t i;
+
+	if (locked_mem)
+		igt_unlock_mem();
+
+	locked_size = size * 1024 * 1024;
+
+	locked_mem = malloc(locked_size);
+	igt_assert(locked_mem);
+
+	/* write into each page to ensure it is allocated */
+	for (i = 0; i < locked_size; i += pagesize)
+		locked_mem[i] = i;
+
+	mlock(locked_mem, locked_size);
+}
+
+/**
+ * igt_unlock_mem:
+ *
+ * Release and free the RAM used by #igt_lock_mem.
+ */
+void igt_unlock_mem(void)
+{
+	if (!locked_mem)
+		return;
+
+	munlock(locked_mem, locked_size);
+
+	free(locked_mem);
+	locked_mem = NULL;
+}
lib/igt_aux.h +3 -0
index 6c83c53..b61555b 100644
@@ -90,4 +90,7 @@ void intel_require_memory(uint32_t count, uint32_t size, unsigned mode);
 #define min(a, b) ((a) < (b) ? (a) : (b))
 #define max(a, b) ((a) > (b) ? (a) : (b))
 
+void igt_lock_mem(size_t size);
+void igt_unlock_mem(void);
+
 #endif /* IGT_AUX_H */
tests/gem_tiled_swapping.c +6 -1
index 3fac52f..0684ab2 100644
@@ -70,6 +70,7 @@ IGT_TEST_DESCRIPTION("Exercise swizzle code for swapping.");
 static uint32_t current_tiling_mode;
 
 #define PAGE_SIZE 4096
+#define AVAIL_RAM 512
 
 static uint32_t
 create_bo_and_fill(int fd)
@@ -156,8 +157,12 @@ igt_main
 		intel_purge_vm_caches();
 
 		fd = drm_open_any();
+
+		/* lock RAM, leaving only 512MB available */
+		igt_lock_mem(intel_get_total_ram_mb() - AVAIL_RAM);
+
 		/* need slightly more than available memory */
-		count = intel_get_total_ram_mb() + intel_get_total_swap_mb() / 4;
+		count = AVAIL_RAM * 1.25;
 		bo_handles = calloc(count, sizeof(uint32_t));
 		igt_assert(bo_handles);
 
Signature · 6 lines
2.1.0

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#1 lore raw
Quoted 6 lines · Thomas Wood

Add a function to lock memory into RAM and use it in the gem_tiled_swapping test to reduce the amount of allocated memory required to force swapping. This also reduces the amount of time required for the test to complete, since the data set is smaller.

Some nitpicks below. Also please mention in the commit message how much this speeds up the testcase.

btw as long as you still see lots of swapping going on with vmstat 1 then the test still works.

Cheers, Daniel

Quoted 23 lines
---
 lib/igt_aux.c              | 48 ++++++++++++++++++++++++++++++++++++++++++++++
 lib/igt_aux.h              |  3 +++
 tests/gem_tiled_swapping.c |  7 ++++++-
 3 files changed, 57 insertions(+), 1 deletion(-)
lib/igt_aux.c +9 -0
index 3051d84..a98aa8f 100644
@@ -601,3 +601,51 @@ struct type_name connector_type_names[] = {
 };
 
 type_name_fn(connector_type)
+
+
+/**
+ * igt_lock_mem: @size: the amount of memory to lock into RAM, in MB
+ *
+ * Allocate @size MB of memory and lock it into RAM. This releases any
+ * previously locked memory.
+ *
+ * Use #igt_unlock_mem to release the currently locked memory.

lib/igt_aux.c struct type_name connector_type_names[] = { · line 622

Quoted 10 lines
lib/igt_aux.c +10 -0
+ */
+static char *locked_mem;
+static size_t locked_size;
+
+void igt_lock_mem(size_t size)
+{
+	long pagesize = sysconf(_SC_PAGESIZE);
+	size_t i;
+
+	if (locked_mem)

Imo this should be an igt_warn_on since if we leak mlocked memory until the next test that needs it there's a good chance we've locked a bit too much.

lib/igt_aux.c struct type_name connector_type_names[] = { · line 628

Quoted 6 lines
lib/igt_aux.c +6 -0
+		igt_unlock_mem();
+
+	locked_size = size * 1024 * 1024;
+
+	locked_mem = malloc(locked_size);
+	igt_assert(locked_mem);

Imo this should be an igt_require: On 32bit platforms with lots of memory there might not be enough virtual address space for mlocking.

lib/igt_aux.c struct type_name connector_type_names[] = { · line 634

Quoted 6 lines
lib/igt_aux.c +6 -0
+
+	/* write into each page to ensure it is allocated */
+	for (i = 0; i < locked_size; i += pagesize)
+		locked_mem[i] = i;
+
+	mlock(locked_mem, locked_size);

This should have an igt_assert to make sure we still do a useful test.

Quoted 42 lines
lib/igt_aux.c +17 -0
+}
+
+/**
+ * igt_unlock_mem:
+ *
+ * Release and free the RAM used by #igt_lock_mem.
+ */
+void igt_unlock_mem(void)
+{
+	if (!locked_mem)
+		return;
+
+	munlock(locked_mem, locked_size);
+
+	free(locked_mem);
+	locked_mem = NULL;
+}
lib/igt_aux.h +3 -0
index 6c83c53..b61555b 100644
@@ -90,4 +90,7 @@ void intel_require_memory(uint32_t count, uint32_t size, unsigned mode);
 #define min(a, b) ((a) < (b) ? (a) : (b))
 #define max(a, b) ((a) > (b) ? (a) : (b))
 
+void igt_lock_mem(size_t size);
+void igt_unlock_mem(void);
+
 #endif /* IGT_AUX_H */
tests/gem_tiled_swapping.c +1 -0
index 3fac52f..0684ab2 100644
@@ -70,6 +70,7 @@ IGT_TEST_DESCRIPTION("Exercise swizzle code for swapping.");
 static uint32_t current_tiling_mode;
 
 #define PAGE_SIZE 4096
+#define AVAIL_RAM 512
 
 static uint32_t
 create_bo_and_fill(int fd)

tests/gem_tiled_swapping.c igt_main · line 162

Quoted 6 lines
tests/gem_tiled_swapping.c +3 -0
@@ -156,8 +157,12 @@ igt_main
 		intel_purge_vm_caches();
 
 		fd = drm_open_any();
+
+		/* lock RAM, leaving only 512MB available */
+		igt_lock_mem(intel_get_total_ram_mb() - AVAIL_RAM);

We have machines with less than 512MB of memory (vpg has some underpowered baytrails like that). So this needs a min(..., 0). And the calculation below needs to substract that from the total ram.

Quoted 14 lines
tests/gem_tiled_swapping.c +2 -1
+
 		/* need slightly more than available memory */
-		count = intel_get_total_ram_mb() + intel_get_total_swap_mb() / 4;
+		count = AVAIL_RAM * 1.25;
 		bo_handles = calloc(count, sizeof(uint32_t));
 		igt_assert(bo_handles);
 
Signature · 6 lines
2.1.0

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
+41 (0) 79 365 57 48 - http://blog.ffwll.ch
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#2 lore raw

PATCH v2 1/1 lib: add a function to lock memory into RAM

Add a function to lock memory into RAM and use it in the gem_tiled_swapping test to reduce the amount of allocated memory required to force swapping. This also reduces the amount of time required for the test to complete, since the data set is smaller.

The following durations were recorded on a haswell system before this change:

Subtest non-threaded: SUCCESS (55.889s)
Subtest threaded: SUCCESS (810.532s)

and after:

Subtest non-threaded: SUCCESS (11.804s)
Subtest threaded: SUCCESS (268.336s)

v2: add various assertions and requirements and make sure
gem_tiled_swapping works on systems with less RAM (Daniel Vetter)

---
 lib/igt_aux.c              | 57 ++++++++++++++++++++++++++++++++++++++++++++++
 lib/igt_aux.h              |  3 +++
 tests/gem_tiled_swapping.c | 10 +++++++-
 3 files changed, 69 insertions(+), 1 deletion(-)
lib/igt_aux.c +57 -0
index 3051d84..d8d8577 100644
@@ -601,3 +601,60 @@ struct type_name connector_type_names[] = {
 };
 
 type_name_fn(connector_type)
+
+
+/**
+ * igt_lock_mem: @size: the amount of memory to lock into RAM, in MB
+ *
+ * Allocate @size MB of memory and lock it into RAM. This releases any
+ * previously locked memory.
+ *
+ * Use #igt_unlock_mem to release the currently locked memory.
+ */
+static char *locked_mem;
+static size_t locked_size;
+
+void igt_lock_mem(size_t size)
+{
+	long pagesize = sysconf(_SC_PAGESIZE);
+	size_t i;
+	int ret;
+
+	if (size == 0) {
+		return;
+	}
+
+	if (locked_mem) {
+		igt_unlock_mem();
+		igt_warn("Unlocking previously locked memory.\n");
+	}
+
+	locked_size = size * 1024 * 1024;
+
+	locked_mem = malloc(locked_size);
+	igt_require_f(locked_mem,
+		      "Could not allocate enough memory to lock.\n");
+
+	/* write into each page to ensure it is allocated */
+	for (i = 0; i < locked_size; i += pagesize)
+		locked_mem[i] = i;
+
+	ret = mlock(locked_mem, locked_size);
+	igt_assert_f(ret == 0, "Could not lock memory into RAM.\n");
+}
+
+/**
+ * igt_unlock_mem:
+ *
+ * Release and free the RAM used by #igt_lock_mem.
+ */
+void igt_unlock_mem(void)
+{
+	if (!locked_mem)
+		return;
+
+	munlock(locked_mem, locked_size);
+
+	free(locked_mem);
+	locked_mem = NULL;
+}
lib/igt_aux.h +3 -0
index 63e1b06..c420b3f 100644
@@ -96,4 +96,7 @@ void intel_require_memory(uint32_t count, uint32_t size, unsigned mode);
 	(b) = _tmp;		\
 } while (0)
 
+void igt_lock_mem(size_t size);
+void igt_unlock_mem(void);
+
 #endif /* IGT_AUX_H */
tests/gem_tiled_swapping.c +9 -1
index 3fac52f..1637ec7 100644
@@ -70,6 +70,7 @@ IGT_TEST_DESCRIPTION("Exercise swizzle code for swapping.");
 static uint32_t current_tiling_mode;
 
 #define PAGE_SIZE 4096
+#define AVAIL_RAM 512
 
 static uint32_t
 create_bo_and_fill(int fd)
@@ -151,13 +152,20 @@ igt_main
 	int fd, n, count, num_threads;
 
 	igt_fixture {
+		size_t lock_size;
+
 		current_tiling_mode = I915_TILING_X;
 
 		intel_purge_vm_caches();
 
 		fd = drm_open_any();
+
+		/* lock RAM, leaving only 512MB available */
+		lock_size = min(0, intel_get_total_ram_mb() - AVAIL_RAM);
+		igt_lock_mem(lock_size);
+
 		/* need slightly more than available memory */
-		count = intel_get_total_ram_mb() + intel_get_total_swap_mb() / 4;
+		count = lock_size * 1.25;
 		bo_handles = calloc(count, sizeof(uint32_t));
 		igt_assert(bo_handles);
 
Signature · 6 lines
2.1.0

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx