bool SkColorShader::onAppendStages(SkRasterPipeline* p,
SkColorSpace* dst,
SkFallbackAlloc* scratch) const {
- auto color = scratch->copy(SkPM4f_from_SkColor(fColor, dst));
+ auto color = scratch->make<SkPM4f>(SkPM4f_from_SkColor(fColor, dst));
p->append(SkRasterPipeline::move_src_dst);
p->append(SkRasterPipeline::constant_color, color);
if (!append_gamut_transform(p, scratch,
bool SkColor4Shader::onAppendStages(SkRasterPipeline* p,
SkColorSpace* dst,
SkFallbackAlloc* scratch) const {
- auto color = scratch->copy(fColor4.premul());
+ auto color = scratch->make<SkPM4f>(fColor4.premul());
p->append(SkRasterPipeline::move_src_dst);
p->append(SkRasterPipeline::constant_color, color);
if (!append_gamut_transform(p, scratch, fColorSpace.get(), dst)) {
: fBuffer((char*)ptr), fUsed(0), fLimit(len) {}
void SkFixedAlloc::undo() {
- uint32_t skip_and_size;
- memcpy(&skip_and_size, fBuffer + fUsed - 4, 4);
- fUsed -= skip_and_size + 4;
-}
-
-void SkFixedAlloc::reset() {
- fUsed = 0;
-}
-
-void* SkFixedAlloc::alloc(size_t size, size_t align) {
- auto aligned = ((uintptr_t)(fBuffer+fUsed) + align-1) & ~(align-1);
- size_t skip = aligned - (uintptr_t)(fBuffer+fUsed);
+ // This function is essentially make() in reverse.
- if (!SkTFitsIn<uint32_t>(skip + size) ||
- fUsed + skip + size + 4 > fLimit) {
- return nullptr;
- }
+ // First, read the Footer we stamped at the end.
+ Footer footer;
+ memcpy(&footer, fBuffer + fUsed - sizeof(Footer), sizeof(Footer));
- // Skip ahead until aligned.
- fUsed += skip;
+ // That tells us where the T starts and how to destroy it.
+ footer.dtor(fBuffer + fUsed - sizeof(Footer) - footer.len);
- // Allocate size bytes.
- void* ptr = (fBuffer+fUsed);
- fUsed += size;
-
- // Stamp a footer that we can use to clean up.
- uint32_t skip_and_size = SkToU32(skip + size);
- memcpy(fBuffer+fUsed, &skip_and_size, 4);
- fUsed += 4;
+ // We can reuse bytes that stored the Footer, the T, and any that we skipped for alignment.
+ fUsed -= sizeof(Footer) + footer.len + footer.skip;
+}
- return ptr;
+void SkFixedAlloc::reset() {
+ while (fUsed) {
+ this->undo();
+ }
}
if (fHeapAllocs.empty()) {
return fFixedAlloc->undo();
}
- sk_free(fHeapAllocs.back());
+ HeapAlloc alloc = fHeapAllocs.back();
+ alloc.deleter(alloc.ptr);
fHeapAllocs.pop_back();
}
#include "SkTFitsIn.h"
#include "SkTypes.h"
#include <new>
-#include <type_traits>
#include <utility>
#include <vector>
-// Before GCC 5, is_trivially_copyable had a pre-standard name.
-#if defined(__GLIBCXX__) && (__GLIBCXX__ < 20150801)
- namespace std {
- template <typename T>
- using is_trivially_copyable = has_trivial_copy_constructor<T>;
- }
-#endif
-
-// SkFixedAlloc allocates POD objects out of a fixed-size buffer.
+// SkFixedAlloc allocates objects out of a fixed-size buffer and destroys them when destroyed.
class SkFixedAlloc {
public:
SkFixedAlloc(void* ptr, size_t len);
~SkFixedAlloc() { this->reset(); }
- // Allocates space suitable for a T. If we can't, returns nullptr.
- template <typename T>
- void* alloc() {
- static_assert(std::is_standard_layout <T>::value
- && std::is_trivially_copyable<T>::value, "");
- return this->alloc(sizeof(T), alignof(T));
- }
-
+ // Allocates a new T in the buffer if possible. If not, returns nullptr.
template <typename T, typename... Args>
T* make(Args&&... args) {
- if (auto ptr = this->alloc<T>()) {
- return new (ptr) T(std::forward<Args>(args)...);
+ auto aligned = ((uintptr_t)(fBuffer+fUsed) + alignof(T) - 1) & ~(alignof(T)-1);
+ size_t skip = aligned - (uintptr_t)(fBuffer+fUsed);
+
+ if (!SkTFitsIn<uint32_t>(skip) ||
+ !SkTFitsIn<uint32_t>(sizeof(T)) ||
+ fUsed + skip + sizeof(T) + sizeof(Footer) > fLimit) {
+ return nullptr;
}
- return nullptr;
- }
- template <typename T>
- T* copy(const T& src) { return this->make<T>(src); }
+ // Skip ahead until our buffer is aligned for T.
+ fUsed += skip;
+
+ // Create the T.
+ auto ptr = (T*)(fBuffer+fUsed);
+ new (ptr) T(std::forward<Args>(args)...);
+ fUsed += sizeof(T);
- // Frees the space of the last object allocated.
+ // Stamp a footer after the T that we can use to clean it up.
+ Footer footer = { [](void* ptr) { ((T*)ptr)->~T(); }, SkToU32(skip), SkToU32(sizeof(T)) };
+ memcpy(fBuffer+fUsed, &footer, sizeof(Footer));
+ fUsed += sizeof(Footer);
+
+ return ptr;
+ }
+
+ // Destroys the last object allocated and frees its space in the buffer.
void undo();
- // Frees all space in the buffer.
+ // Destroys all objects and frees all space in the buffer.
void reset();
private:
- void* alloc(size_t, size_t);
+ struct Footer {
+ void (*dtor)(void*);
+ uint32_t skip, len;
+ };
char* fBuffer;
size_t fUsed, fLimit;
explicit SkFallbackAlloc(SkFixedAlloc*);
~SkFallbackAlloc() { this->reset(); }
- template <typename T>
- void* alloc() {
- // Once we go heap we never go back to fixed. This keeps undo() working.
+ // Allocates a new T with the SkFixedAlloc if possible. If not, uses the heap.
+ template <typename T, typename... Args>
+ T* make(Args&&... args) {
+ // Once we go heap we never go back to fixed. This keeps destructor ordering sane.
if (fHeapAllocs.empty()) {
- if (void* ptr = fFixedAlloc->alloc<T>()) {
+ if (T* ptr = fFixedAlloc->make<T>(std::forward<Args>(args)...)) {
return ptr;
}
}
- void* ptr = sk_malloc_throw(sizeof(T));
- fHeapAllocs.push_back(ptr);
+ auto ptr = new T(std::forward<Args>(args)...);
+ fHeapAllocs.push_back({[](void* ptr) { delete (T*)ptr; }, ptr});
return ptr;
}
- template <typename T, typename... Args>
- T* make(Args&&... args) { return new (this->alloc<T>()) T(std::forward<Args>(args)...); }
-
- template <typename T>
- T* copy(const T& src) { return this->make<T>(src); }
-
- // Frees the last object allocated, including any space it used in the SkFixedAlloc.
+ // Destroys the last object allocated and frees any space it used in the SkFixedAlloc.
void undo();
- // Frees all objects and all space in the SkFixedAlloc.
+ // Destroys all objects and frees all space in the SkFixedAlloc.
void reset();
private:
- SkFixedAlloc* fFixedAlloc;
- std::vector<void*> fHeapAllocs;
+ struct HeapAlloc {
+ void (*deleter)(void*);
+ void* ptr;
+ };
+
+ SkFixedAlloc* fFixedAlloc;
+ std::vector<HeapAlloc> fHeapAllocs;
};
#endif//SkFixedAlloc_DEFINED
SkColorSpace* dst,
SkFallbackAlloc* scratch,
bool shaderIsOpaque) const {
- auto color = scratch->copy(SkPM4f_from_SkColor(fColor, dst));
+ auto color = scratch->make<SkPM4f>(SkPM4f_from_SkColor(fColor, dst));
p->append(SkRasterPipeline::move_src_dst);
p->append(SkRasterPipeline::constant_color, color);
namespace {
- static int created;
+ static int created, destroyed;
struct Foo {
Foo(int X, float Y) : x(X), y(Y) { created++; }
+ ~Foo() { destroyed++; }
int x;
float y;
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.
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 fixed(buf, sizeof(buf));
bool fixed_failed = false;
for (int i = 0; i < 32; i++) {
- // (Remember, there is some overhead to each copy() call.)
- fixed_failed = fixed_failed || (fixed.copy(i) == nullptr);
+ // (Remember, there is some overhead to each make() call.)
+ fixed_failed = fixed_failed || (fixed.make<int>(i) == nullptr);
}
REPORTER_ASSERT(r, fixed_failed);
bool fallback_failed = false;
for (int i = 0; i < 32; i++) {
- fallback_failed = fallback_failed || (fallback.copy(i) == nullptr);
+ fallback_failed = fallback_failed || (fallback.make<int>(i) == nullptr);
}
REPORTER_ASSERT(r, !fallback_failed);
projects / platform / upstream / libSkiaSharp.git / commitdiff