gpu: nvgpu: unit: mm: add coverage & traceability

This patch adds new tests to improve test coverage. Also, updating test target tags to increase traceability. Jira NVGPU-4780 Change-Id: I87341efa3fa7d741f7abb611ff28ad6d5e1c6880 Signed-off-by: Vedashree Vidwans <vvidwans@nvidia.com> Reviewed-on: https://git-master.nvidia.com/r/c/linux-nvgpu/+/2279644 Tested-by: mobile promotions <svcmobile_promotions@nvidia.com> Reviewed-by: mobile promotions <svcmobile_promotions@nvidia.com>
2025-12-23 09:57:08 +03:00 · 2019-12-31 11:00:24 -08:00
parent 4bcd419a0b
commit f46c3064ed
27 changed files with 934 additions and 240 deletions
--- a/userspace/units/mm/allocators/nvgpu_allocator/nvgpu_allocator.c
+++ b/userspace/units/mm/allocators/nvgpu_allocator/nvgpu_allocator.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2019, NVIDIA CORPORATION.  All rights reserved.
+ * Copyright (c) 2018-2020, NVIDIA CORPORATION.  All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
@@ -24,8 +24,11 @@
 #include <unit/unit.h>

 #include <nvgpu/types.h>
+#include <nvgpu/sizes.h>
 #include <nvgpu/allocator.h>

+#include "nvgpu_allocator.h"
+
 #define OP_ALLOC		0
 #define OP_FREE			1
 #define OP_ALLOC_PTE		2
@@ -149,18 +152,7 @@ static struct nvgpu_allocator_ops dummy_ops = {
 	.fini             = dummy_fini
 };

-/*
- * Make sure the op functions are called and that's it. Verifying that the ops
- * actually do what they are supposed to do is the responsibility of the unit
- * tests for the actual allocator implementations.
- *
- * In this unit test the meaning of these ops can't really be assumed. But we
- * can test that the logic for only calling present ops is tested.
- *
- * Also note: we don't test the fini op here; instead we test it separately as
- * part of the init/destroy functionality.
- */
-static int test_nvgpu_alloc_ops_present(struct unit_module *m,
+int test_nvgpu_alloc_ops_present(struct unit_module *m,
 					struct gk20a *g, void *args)
 {
 	u32 i;
@@ -243,13 +235,7 @@ static int test_nvgpu_alloc_ops_present(struct unit_module *m,
 	return UNIT_SUCCESS;
 }

-/*
- * Test the common_init() function used by all allocator implementations. The
- * test here is to simply catch that the various invalid input checks are
- * exercised and that the parameters passed into the common_init() make their
- * way into the allocator struct.
- */
-static int test_nvgpu_alloc_common_init(struct unit_module *m,
+int test_nvgpu_alloc_common_init(struct unit_module *m,
 					struct gk20a *g, void *args)
 {
 	struct nvgpu_allocator a;
@@ -294,11 +280,7 @@ static int test_nvgpu_alloc_common_init(struct unit_module *m,
 	return UNIT_SUCCESS;
 }

-/*
- * Test that the destroy function works. This just calls the fini() op and
- * expects the allocator to have been completely zeroed.
- */
-static int test_nvgpu_alloc_destroy(struct unit_module *m,
+int test_nvgpu_alloc_destroy(struct unit_module *m,
 					struct gk20a *g, void *args)
 {
 	struct nvgpu_allocator a;
@@ -322,10 +304,53 @@ static int test_nvgpu_alloc_destroy(struct unit_module *m,
 	return UNIT_SUCCESS;
 }

+int test_nvgpu_allocator_init(struct unit_module *m,
+						struct gk20a *g, void *args)
+{
+	struct nvgpu_allocator a;
+	u64 base = SZ_4K;
+	u64 size = SZ_64K;
+	u64 blk_size = SZ_4K;
+	u64 max_order = 0;
+	u64 flags = 0ULL;
+
+	if (nvgpu_allocator_init(g, &a, NULL, "buddy", base, size, blk_size,
+				max_order, flags, BUDDY_ALLOCATOR) != 0) {
+		unit_return_fail(m, "failed to init buddy_allocator\n");
+	} else {
+		a.ops->fini(&a);
+	}
+
+#ifdef CONFIG_NVGPU_DGPU
+	if (nvgpu_allocator_init(g, &a, NULL, "page", base, size, blk_size,
+				max_order, flags, PAGE_ALLOCATOR) != 0) {
+		unit_return_fail(m, "failed to init page_allocator\n");
+	} else {
+		a.ops->fini(&a);
+	}
+#endif
+
+	if (nvgpu_allocator_init(g, &a, NULL, "bitmap", base, size, blk_size,
+				max_order, flags, BITMAP_ALLOCATOR) != 0) {
+		unit_return_fail(m, "failed to init bitmap_allocator\n");
+	} else {
+		a.ops->fini(&a);
+	}
+
+	/* Initialize invalid allocator */
+	if (nvgpu_allocator_init(g, &a, NULL, "invalid", base, size, blk_size,
+				max_order, flags, -1) != -EINVAL) {
+		unit_return_fail(m, "initialized invalid allocator\n");
+	}
+
+	return UNIT_SUCCESS;
+}
+
 struct unit_module_test nvgpu_allocator_tests[] = {
 	UNIT_TEST(common_init,      test_nvgpu_alloc_common_init,  NULL, 0),
 	UNIT_TEST(alloc_destroy,    test_nvgpu_alloc_destroy,      NULL, 0),
 	UNIT_TEST(alloc_ops,        test_nvgpu_alloc_ops_present,  NULL, 0),
+	UNIT_TEST(allocator_init,   test_nvgpu_allocator_init,     NULL, 0),
 };

 UNIT_MODULE(nvgpu_allocator, nvgpu_allocator_tests, UNIT_PRIO_NVGPU_TEST);
--- a/userspace/units/mm/allocators/nvgpu_allocator/nvgpu_allocator.h
+++ b/userspace/units/mm/allocators/nvgpu_allocator/nvgpu_allocator.h
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef UNIT_NVGPU_ALLOCATOR_H
+#define UNIT_NVGPU_ALLOCATOR_H
+
+struct gk20a;
+struct unit_module;
+
+/** @addtogroup SWUTS-mm-allocators-nvgpu-allocator
+ *  @{
+ *
+ * Software Unit Test Specification for mm.allocators.nvgpu_allocator
+ */
+
+/**
+ * Test specification for: test_nvgpu_alloc_common_init
+ *
+ * Description: Test common_init() function
+ *
+ * Test Type: Feature
+ *
+ * Targets: nvgpu_alloc_common_init
+ *
+ * Input: None
+ *
+ * Steps:
+ * - Initialize nvgpu allocator with default ops values.
+ *   - Confirm that the parameters passed to the function make their way into
+ *     allocator struct.
+ * - Initialize nvgpu allocator for various invalid input cases.
+ *
+ * Output: Returns SUCCESS if the steps above were executed successfully. FAIL
+ * otherwise.
+ */
+int test_nvgpu_alloc_common_init(struct unit_module *m,
+						struct gk20a *g, void *args);
+
+/**
+ * Test specification for: test_nvgpu_alloc_destroy
+ *
+ * Description: Test allocator destroy function
+ *
+ * Test Type: Feature
+ *
+ * Targets: nvgpu_alloc_common_init, nvgpu_alloc_destroy
+ *
+ * Input: None
+ *
+ * Steps:
+ * - Trigger allocator destroy function which further invokes fini() op.
+ * - Allocator struct should be completely zeroed after this function.
+ *
+ * Output: Returns SUCCESS if the steps above were executed successfully. FAIL
+ * otherwise.
+ */
+int test_nvgpu_alloc_destroy(struct unit_module *m,
+						struct gk20a *g, void *args);
+
+/**
+ * Test specification for: test_nvgpu_alloc_ops_present
+ *
+ * Description: Test allocator destroy function
+ *
+ * Test Type: Feature
+ *
+ * Targets: nvgpu_alloc, nvgpu_alloc_pte, nvgpu_alloc_fixed, nvgpu_free_fixed,
+ *          nvgpu_alloc_reserve_carveout, nvgpu_alloc_release_carveout,
+ *          nvgpu_alloc_base, nvgpu_alloc_length, nvgpu_alloc_end, nvgpu_free,
+ *          nvgpu_alloc_initialized, nvgpu_alloc_space
+ *
+ * Input: None
+ *
+ * Steps:
+ * - Test the logic for calling present ops.
+ * - Actual functionality of the ops should be verified by the respective
+ *   allocator unit tests.
+ *
+ * Output: Returns SUCCESS if the steps above were executed successfully. FAIL
+ * otherwise.
+ */
+int test_nvgpu_alloc_ops_present(struct unit_module *m,
+						struct gk20a *g, void *args);
+
+/**
+ * Test specification for: test_nvgpu_allocator_init
+ *
+ * Description: Test allocator init function
+ *
+ * Test Type: Feature
+ *
+ * Targets: nvgpu_allocator_init, nvgpu_alloc_destroy
+ *
+ * Input: None
+ *
+ * Steps:
+ * - Initialize each allocator and check that the allocator is created
+ *   successfully.
+ *
+ * Output: Returns SUCCESS if the steps above were executed successfully. FAIL
+ * otherwise.
+ */
+int test_nvgpu_allocator_init(struct unit_module *m,
+						struct gk20a *g, void *args);
+
+#endif /* UNIT_NVGPU_ALLOCATOR_H */