526525a37c
This reverts commit 1ee70359a1.
Reason for revert: breaking my various rolls.
Original change's description:
> While we can, restrict SkFixedAlloc/SkFallbackAlloc to POD.
>
> This trims the overhead down to a uniform 4 bytes.
>
> BUG=skia:
>
> GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=4786
>
> Change-Id: I92127a0c2d6c23a4a372eca39842e22195d2dc99
> Reviewed-on: https://skia-review.googlesource.com/4786
> Reviewed-by: Herb Derby <herb@google.com>
> Commit-Queue: Mike Klein <mtklein@chromium.org>
>
TBR=mtklein@chromium.org,herb@google.com,reviews@skia.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
Change-Id: Iae9ef553422352a1abf95b709fccd014d468da86
Reviewed-on: https://skia-review.googlesource.com/4829
Commit-Queue: Mike Klein <mtklein@chromium.org>
Reviewed-by: Mike Klein <mtklein@chromium.org>
114 lines
3.0 KiB
C++
114 lines
3.0 KiB
C++
/*
|
|
* Copyright 2016 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#include "Test.h"
|
|
#include "SkFixedAlloc.h"
|
|
|
|
namespace {
|
|
|
|
static int created, destroyed;
|
|
|
|
struct Foo {
|
|
Foo(int X, float Y) : x(X), y(Y) { created++; }
|
|
~Foo() { destroyed++; }
|
|
|
|
int x;
|
|
float y;
|
|
};
|
|
|
|
struct Big {
|
|
Big() {}
|
|
uint32_t array[128];
|
|
};
|
|
|
|
}
|
|
|
|
DEF_TEST(FixedAlloc, r) {
|
|
// Basic mechanics.
|
|
{
|
|
uint8_t buf[128];
|
|
SkFixedAlloc fa(buf, sizeof(buf));
|
|
|
|
Foo* foo = fa.make<Foo>(3, 4.0f);
|
|
REPORTER_ASSERT(r, foo);
|
|
REPORTER_ASSERT(r, foo->x == 3);
|
|
REPORTER_ASSERT(r, foo->y == 4.0f);
|
|
REPORTER_ASSERT(r, created == 1);
|
|
REPORTER_ASSERT(r, destroyed == 0);
|
|
|
|
Foo* bar = fa.make<Foo>(8, 1.0f);
|
|
REPORTER_ASSERT(r, bar);
|
|
REPORTER_ASSERT(r, bar->x == 8);
|
|
REPORTER_ASSERT(r, bar->y == 1.0f);
|
|
REPORTER_ASSERT(r, created == 2);
|
|
REPORTER_ASSERT(r, destroyed == 0);
|
|
|
|
fa.undo();
|
|
REPORTER_ASSERT(r, created == 2);
|
|
REPORTER_ASSERT(r, destroyed == 1);
|
|
}
|
|
REPORTER_ASSERT(r, created == 2);
|
|
REPORTER_ASSERT(r, destroyed == 2);
|
|
|
|
{
|
|
// Test alignment gurantees.
|
|
uint8_t buf[64];
|
|
SkFixedAlloc fa(buf+3, sizeof(buf)-3);
|
|
|
|
Foo* foo = fa.make<Foo>(3, 4.0f);
|
|
REPORTER_ASSERT(r, SkIsAlign4((uintptr_t)foo));
|
|
REPORTER_ASSERT(r, created == 3);
|
|
REPORTER_ASSERT(r, destroyed == 2);
|
|
|
|
// Might as well test reset() while we're at it.
|
|
fa.reset();
|
|
REPORTER_ASSERT(r, created == 3);
|
|
REPORTER_ASSERT(r, destroyed == 3);
|
|
}
|
|
REPORTER_ASSERT(r, created == 3);
|
|
REPORTER_ASSERT(r, destroyed == 3);
|
|
}
|
|
|
|
DEF_TEST(FallbackAlloc, r) {
|
|
// SkFixedAlloc will eventually fail when it runs out of space in its buffer.
|
|
int buf[32];
|
|
SkFixedAlloc fixed(buf, sizeof(buf));
|
|
bool fixed_failed = false;
|
|
for (int i = 0; i < 32; i++) {
|
|
// (Remember, there is some overhead to each make() call.)
|
|
fixed_failed = fixed_failed || (fixed.make<int>(i) == nullptr);
|
|
}
|
|
REPORTER_ASSERT(r, fixed_failed);
|
|
|
|
|
|
// SkFallbackAlloc will always succeed, using the heap as required.
|
|
fixed.reset();
|
|
SkFallbackAlloc fallback(&fixed);
|
|
|
|
bool fallback_failed = false;
|
|
for (int i = 0; i < 32; i++) {
|
|
fallback_failed = fallback_failed || (fallback.make<int>(i) == nullptr);
|
|
}
|
|
REPORTER_ASSERT(r, !fallback_failed);
|
|
|
|
|
|
// Test small, big, small allocations to make sure once we go to the heap we stay there.
|
|
fallback.reset();
|
|
auto smallA = fallback.make<int>(2);
|
|
auto big = fallback.make<Big>();
|
|
auto smallB = fallback.make<int>(3);
|
|
|
|
auto in_buf = [&](void* ptr) {
|
|
return (uintptr_t)(buf+0 ) <= (uintptr_t)ptr
|
|
&& (uintptr_t)(buf+32) > (uintptr_t)ptr;
|
|
};
|
|
|
|
REPORTER_ASSERT(r, in_buf(smallA));
|
|
REPORTER_ASSERT(r, !in_buf(big));
|
|
REPORTER_ASSERT(r, !in_buf(smallB));
|
|
}
|