mirror of
git://nv-tegra.nvidia.com/linux-nvgpu.git
synced 2025-12-23 01:50:07 +03:00
gpu: nvgpu: unit: Shuffle the paths of tests around a bit
We will need to organize the unit tests in order to keep the units/ directory managable. The basic idea here is to mirror the common/ structure in nvgpu proper under units/. There's one additrion at the moment though: posix. This is for posix environment related tests. Also added a fix for the runlist unit test. Add it to the tmake sources and move the nvgpu-runlist/ directory to just runlist/. Change-Id: I1f4163d0e33c3af70376cfeb3441d277d559e05a Signed-off-by: Alex Waterman <alexw@nvidia.com> Reviewed-on: https://git-master.nvidia.com/r/1935710 Reviewed-by: mobile promotions <svcmobile_promotions@nvidia.com> Tested-by: mobile promotions <svcmobile_promotions@nvidia.com>
This commit is contained in:
Alex Waterman
committed by
mobile promotions
mobile promotions
parent
1023c6af14
commit
63da5366a6
198
userspace/units/posix/env/posix-env.c
vendored
Normal file
198
userspace/units/posix/env/posix-env.c
vendored
Normal file
@@ -0,0 +1,198 @@
|
||||
/*
|
||||
* Copyright (c) 2018, 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.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include <unit/io.h>
|
||||
#include <unit/unit.h>
|
||||
|
||||
#include <nvgpu/types.h>
|
||||
|
||||
/*
|
||||
* Test if the passed type is signed. In the signed case this expression becomes
|
||||
*
|
||||
* x = 0;
|
||||
* y = x - 1 = -1
|
||||
*
|
||||
* And -1 < 0 will be true. In the unsigned case, we rely on wrap around. We
|
||||
* have the following
|
||||
*
|
||||
* x = 0U
|
||||
* y = x - 1 = ~0 (i.e <TYPE>_MAX)
|
||||
*
|
||||
* Thus the expression y < x is false.
|
||||
*/
|
||||
#define IS_SIGNED_TYPE(__type__) \
|
||||
({ \
|
||||
__type__ x = (__type__)0; \
|
||||
__type__ y = x - (__type__)1; \
|
||||
y < x; \
|
||||
})
|
||||
|
||||
/*
|
||||
* Ensure that our sized types are of the correct size. Assumes an 8bit byte of
|
||||
* course.
|
||||
*/
|
||||
static int sanity_test_sizes(struct unit_module *m,
|
||||
struct gk20a *g, void *args)
|
||||
{
|
||||
size_t size_u8 = sizeof(u8);
|
||||
size_t size_u16 = sizeof(u16);
|
||||
size_t size_u32 = sizeof(u32);
|
||||
size_t size_u64 = sizeof(u64);
|
||||
size_t size_s8 = sizeof(s8);
|
||||
size_t size_s16 = sizeof(s16);
|
||||
size_t size_s32 = sizeof(s32);
|
||||
size_t size_s64 = sizeof(s64);
|
||||
|
||||
/* Unsigned. */
|
||||
if (size_u8 != 1U)
|
||||
unit_return_fail(m,
|
||||
"sizeof(u8) != 1 byte! (Actual size: %zu)\n",
|
||||
size_u8);
|
||||
if (size_u16 != 2U)
|
||||
unit_return_fail(m,
|
||||
"sizeof(u16) != 2 bytes! (Actual size: %zu)\n",
|
||||
size_u16);
|
||||
if (size_u32 != 4U)
|
||||
unit_return_fail(m,
|
||||
"sizeof(u32) != 4 bytes! (Actual size: %zu)\n",
|
||||
size_u32);
|
||||
if (size_u64 != 8U)
|
||||
unit_return_fail(m,
|
||||
"sizeof(u64) != 8 bytes! (Actual size: %zu)\n",
|
||||
size_u64);
|
||||
|
||||
/* Signed. */
|
||||
if (size_s8 != 1U)
|
||||
unit_return_fail(m,
|
||||
"sizeof(s8) != 1 byte! (Actual size: %zu)\n",
|
||||
size_s8);
|
||||
if (size_s16 != 2U)
|
||||
unit_return_fail(m,
|
||||
"sizeof(s16) != 2 bytes! (Actual size: %zu)\n",
|
||||
size_s16);
|
||||
if (size_s32 != 4U)
|
||||
unit_return_fail(m,
|
||||
"sizeof(s32) != 4 bytes! (Actual size: %zu)\n",
|
||||
size_s32);
|
||||
if (size_s64 != 8U)
|
||||
unit_return_fail(m,
|
||||
"sizeof(s64) != 8 bytes! (Actual size: %zu)\n",
|
||||
size_s64);
|
||||
|
||||
return UNIT_SUCCESS;
|
||||
}
|
||||
|
||||
/*
|
||||
* Make sure that the signed types really are signed and that the unsigned types
|
||||
* really are not.
|
||||
*/
|
||||
static int sanity_test_signage(struct unit_module *m,
|
||||
struct gk20a *g, void *args)
|
||||
{
|
||||
|
||||
if (!IS_SIGNED_TYPE(s8))
|
||||
unit_return_fail(m, "s8 is not signed!\n");
|
||||
if (!IS_SIGNED_TYPE(s16))
|
||||
unit_return_fail(m, "s16 is not signed!\n");
|
||||
if (!IS_SIGNED_TYPE(s32))
|
||||
unit_return_fail(m, "s32 is not signed!\n");
|
||||
if (!IS_SIGNED_TYPE(s64))
|
||||
unit_return_fail(m, "s64 is not signed!\n");
|
||||
|
||||
if (IS_SIGNED_TYPE(u8))
|
||||
unit_return_fail(m, "u8 is signed!\n");
|
||||
if (IS_SIGNED_TYPE(u16))
|
||||
unit_return_fail(m, "u16 is signed!\n");
|
||||
if (IS_SIGNED_TYPE(u32))
|
||||
unit_return_fail(m, "u32 is signed!\n");
|
||||
if (IS_SIGNED_TYPE(u64))
|
||||
unit_return_fail(m, "u64 is signed!\n");
|
||||
|
||||
return UNIT_SUCCESS;
|
||||
}
|
||||
|
||||
/*
|
||||
* Ensure that a u64 can hold a pointer since in some places we use a u64 to
|
||||
* pass back a pointer value.
|
||||
*/
|
||||
static int sanity_test_ptr_in_u64(struct unit_module *m,
|
||||
struct gk20a *g, void *args)
|
||||
{
|
||||
if (sizeof(u64) < sizeof(uintptr_t))
|
||||
unit_return_fail(m,
|
||||
"u64 size (%zu b) less than pointer size (%zu b)",
|
||||
sizeof(u64), sizeof(uintptr_t));
|
||||
|
||||
return UNIT_SUCCESS;
|
||||
}
|
||||
|
||||
static int sanity_test_endianness(struct unit_module *m,
|
||||
struct gk20a *g, void *args)
|
||||
{
|
||||
u32 i;
|
||||
u32 x = 0x12345678;
|
||||
u8 *ptr_x_u8 = (u8 *)&x;
|
||||
u16 *ptr_x_u16 = (u16 *)&x;
|
||||
|
||||
/*
|
||||
* Print what endianness we have. For now we have not explicitly decided
|
||||
* to support one or the other, but this will have to be determined
|
||||
* eventually.
|
||||
*
|
||||
* We have just been lucky so far.
|
||||
*/
|
||||
unit_info(m, "u32 x = 0x%x\n", x);
|
||||
for (i = 0; i < sizeof(u32) / sizeof(u16); i++) {
|
||||
unit_info(m, " &x + %zu: 0x%04hx\n",
|
||||
i * sizeof(u16), ptr_x_u16[i]);
|
||||
}
|
||||
|
||||
unit_info(m, "u32 x = 0x%x\n", x);
|
||||
for (i = 0; i < sizeof(u32); i++) {
|
||||
unit_info(m, " &x + %u: 0x%02hhx\n", i, ptr_x_u8[i]);
|
||||
}
|
||||
|
||||
switch (ptr_x_u8[0]) {
|
||||
case 0x12:
|
||||
unit_info(m, "Machine endianness: big\n");
|
||||
break;
|
||||
case 0x78:
|
||||
unit_info(m, "Machine endianness: little\n");
|
||||
break;
|
||||
default:
|
||||
unit_return_fail(m, "Machine endianness: middle/unknown ??\n");
|
||||
}
|
||||
|
||||
return UNIT_SUCCESS;
|
||||
}
|
||||
|
||||
struct unit_module_test posix_env_tests[] = {
|
||||
UNIT_TEST(sizes, sanity_test_sizes, NULL),
|
||||
UNIT_TEST(signage, sanity_test_signage, NULL),
|
||||
UNIT_TEST(endianness, sanity_test_endianness, NULL),
|
||||
UNIT_TEST(ptr_in_u64, sanity_test_ptr_in_u64, NULL),
|
||||
};
|
||||
|
||||
UNIT_MODULE(posix_env, posix_env_tests, UNIT_PRIO_POSIX_TEST);
|
||||
Reference in New Issue
Block a user