Cr8-xyz/blender
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
aa32121174711acd341d29cd93d35c5560c5eedc
blender/intern/guardedalloc/tests/guardedalloc_alignment_test.cc

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

59 lines
1.3 KiB
C++
Raw Normal View History

Add brief license headers to tests These are effectively public-domain, but use apache2.0 to avoid adding new licenses
2014-06-19 18:48:41 +10:00
/* Apache License, Version 2.0 */
Add unit tests for aligned alloc This was really handy on initial work of aligned alloc and would be handy as well when we'll need to support arbitrary alignment on Apple platforms.
2014-06-19 12:45:00 +06:00
#include "testing/testing.h"
Fix gtests on Windows/MSVC There were some missing stubs and some tests were specifically written for Linux. Also, apparently MSVC has a limit of 64K for the insource strings..
2016-02-06 21:19:47 +05:00
#include "BLI_utildefines.h"
Add unit tests for aligned alloc This was really handy on initial work of aligned alloc and would be handy as well when we'll need to support arbitrary alignment on Apple platforms.
2014-06-19 12:45:00 +06:00
#include "MEM_guardedalloc.h"
Guarded allocator: Fix lock-free allocator tests Previously the lock-free tests were actually testing guarded allocator because the main entry point of tests was switching allocator to the guarded one. There seems to be no allocations happening between the initialization sequence and the fixture's SetUp(), so easiest seems to be just to switch to lockfree implementation in the fixture's SetUp(). The test are passing locally, so the "should work" has high chance of actually being truth :) Differential Revision: https://developer.blender.org/D9584
2020-11-17 11:38:42 +01:00
#include "guardedalloc_test_base.h"
Add unit tests for aligned alloc This was really handy on initial work of aligned alloc and would be handy as well when we'll need to support arbitrary alignment on Apple platforms.
2014-06-19 12:45:00 +06:00
Tests: Use proper order for EXPECT_EQ()
2017-02-03 12:03:59 +01:00
#define CHECK_ALIGNMENT(ptr, align) EXPECT_EQ((size_t)ptr % align, 0)
Add unit tests for aligned alloc This was really handy on initial work of aligned alloc and would be handy as well when we'll need to support arbitrary alignment on Apple platforms.
2014-06-19 12:45:00 +06:00
namespace {
Use Blender codestyle, not Google's one!
2014-06-19 12:47:56 +06:00
void DoBasicAlignmentChecks(const int alignment)
{
int *foo, *bar;
Add unit tests for aligned alloc This was really handy on initial work of aligned alloc and would be handy as well when we'll need to support arbitrary alignment on Apple platforms.
2014-06-19 12:45:00 +06:00
Use Blender codestyle, not Google's one!
2014-06-19 12:47:56 +06:00
foo = (int *)MEM_mallocN_aligned(sizeof(int) * 10, alignment, "test");
CHECK_ALIGNMENT(foo, alignment);
Add unit tests for aligned alloc This was really handy on initial work of aligned alloc and would be handy as well when we'll need to support arbitrary alignment on Apple platforms.
2014-06-19 12:45:00 +06:00
Use Blender codestyle, not Google's one!
2014-06-19 12:47:56 +06:00
bar = (int *)MEM_dupallocN(foo);
CHECK_ALIGNMENT(bar, alignment);
MEM_freeN(bar);
Add unit tests for aligned alloc This was really handy on initial work of aligned alloc and would be handy as well when we'll need to support arbitrary alignment on Apple platforms.
2014-06-19 12:45:00 +06:00
Use Blender codestyle, not Google's one!
2014-06-19 12:47:56 +06:00
foo = (int *)MEM_reallocN(foo, sizeof(int) * 5);
CHECK_ALIGNMENT(foo, alignment);
Add unit tests for aligned alloc This was really handy on initial work of aligned alloc and would be handy as well when we'll need to support arbitrary alignment on Apple platforms.
2014-06-19 12:45:00 +06:00
Use Blender codestyle, not Google's one!
2014-06-19 12:47:56 +06:00
foo = (int *)MEM_recallocN(foo, sizeof(int) * 5);
CHECK_ALIGNMENT(foo, alignment);
Add unit tests for aligned alloc This was really handy on initial work of aligned alloc and would be handy as well when we'll need to support arbitrary alignment on Apple platforms.
2014-06-19 12:45:00 +06:00
Use Blender codestyle, not Google's one!
2014-06-19 12:47:56 +06:00
MEM_freeN(foo);
Add unit tests for aligned alloc This was really handy on initial work of aligned alloc and would be handy as well when we'll need to support arbitrary alignment on Apple platforms.
2014-06-19 12:45:00 +06:00
}
} // namespace
Guarded allocator: Fix lock-free allocator tests Previously the lock-free tests were actually testing guarded allocator because the main entry point of tests was switching allocator to the guarded one. There seems to be no allocations happening between the initialization sequence and the fixture's SetUp(), so easiest seems to be just to switch to lockfree implementation in the fixture's SetUp(). The test are passing locally, so the "should work" has high chance of actually being truth :) Differential Revision: https://developer.blender.org/D9584
2020-11-17 11:38:42 +01:00
TEST_F(LockFreeAllocatorTest, MEM_mallocN_aligned)
Fix: Use a minimal alignment of 8 in MEM_lockfree_mallocN_aligned `posix_memalign` requires the `alignment` to be at least `sizeof(void *)`. Previously, `MEM_mallocN_aligned` would simply return `NULL` if a too small `alignment` was used. This was an OS specific issue. The solution is to use a minimal alignment of `8` for all aligned allocations. The unit tests have been extended to test more possible alignments (some of which were broken before). Reviewers: brecht Differential Revision: https://developer.blender.org/D6660
2020-01-23 14:17:13 +01:00
{
DoBasicAlignmentChecks(1);
DoBasicAlignmentChecks(2);
DoBasicAlignmentChecks(4);
DoBasicAlignmentChecks(8);
Use Blender codestyle, not Google's one!
2014-06-19 12:47:56 +06:00
DoBasicAlignmentChecks(16);
Fix: Use a minimal alignment of 8 in MEM_lockfree_mallocN_aligned `posix_memalign` requires the `alignment` to be at least `sizeof(void *)`. Previously, `MEM_mallocN_aligned` would simply return `NULL` if a too small `alignment` was used. This was an OS specific issue. The solution is to use a minimal alignment of `8` for all aligned allocations. The unit tests have been extended to test more possible alignments (some of which were broken before). Reviewers: brecht Differential Revision: https://developer.blender.org/D6660
2020-01-23 14:17:13 +01:00
DoBasicAlignmentChecks(32);
DoBasicAlignmentChecks(256);
DoBasicAlignmentChecks(512);
}
Guarded allocator: Fix lock-free allocator tests Previously the lock-free tests were actually testing guarded allocator because the main entry point of tests was switching allocator to the guarded one. There seems to be no allocations happening between the initialization sequence and the fixture's SetUp(), so easiest seems to be just to switch to lockfree implementation in the fixture's SetUp(). The test are passing locally, so the "should work" has high chance of actually being truth :) Differential Revision: https://developer.blender.org/D9584
2020-11-17 11:38:42 +01:00
TEST_F(GuardedAllocatorTest, MEM_mallocN_aligned)
Fix: Use a minimal alignment of 8 in MEM_lockfree_mallocN_aligned `posix_memalign` requires the `alignment` to be at least `sizeof(void *)`. Previously, `MEM_mallocN_aligned` would simply return `NULL` if a too small `alignment` was used. This was an OS specific issue. The solution is to use a minimal alignment of `8` for all aligned allocations. The unit tests have been extended to test more possible alignments (some of which were broken before). Reviewers: brecht Differential Revision: https://developer.blender.org/D6660
2020-01-23 14:17:13 +01:00
{
Guarded allocator: Fix lock-free allocator tests Previously the lock-free tests were actually testing guarded allocator because the main entry point of tests was switching allocator to the guarded one. There seems to be no allocations happening between the initialization sequence and the fixture's SetUp(), so easiest seems to be just to switch to lockfree implementation in the fixture's SetUp(). The test are passing locally, so the "should work" has high chance of actually being truth :) Differential Revision: https://developer.blender.org/D9584
2020-11-17 11:38:42 +01:00
DoBasicAlignmentChecks(1);
DoBasicAlignmentChecks(2);
DoBasicAlignmentChecks(4);
DoBasicAlignmentChecks(8);
DoBasicAlignmentChecks(16);
DoBasicAlignmentChecks(32);
DoBasicAlignmentChecks(256);
Fix: Use a minimal alignment of 8 in MEM_lockfree_mallocN_aligned `posix_memalign` requires the `alignment` to be at least `sizeof(void *)`. Previously, `MEM_mallocN_aligned` would simply return `NULL` if a too small `alignment` was used. This was an OS specific issue. The solution is to use a minimal alignment of `8` for all aligned allocations. The unit tests have been extended to test more possible alignments (some of which were broken before). Reviewers: brecht Differential Revision: https://developer.blender.org/D6660
2020-01-23 14:17:13 +01:00
DoBasicAlignmentChecks(512);
}
Reference in New Issue Copy Permalink