ExternalVendorCode/corda
1
0
Fork 0
mirror of https://github.com/corda/corda.git synced 2025-01-07 13:38:47 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

add Slice::resize and Slice::alloc

Browse Source
This commit is contained in:
Joshua Warner 2014-02-25 20:17:12 -07:00
parent 892d359ba0
commit db19c7b3a2
3 changed files with 31 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
include/avian/util/slice.h
View File

@ -46,12 +46,26 @@ class Slice {
return items + count; return items + count;
} }
static Slice<T> alloc(Allocator* a, size_t count)
{
return Slice<T>((T*)a->allocate(sizeof(T) * count), count);
}
Slice<T> clone(Allocator* a) Slice<T> clone(Allocator* a)
{ {
Slice<T> ret((T*)a->allocate(count * sizeof(T)), count); Slice<T> ret((T*)a->allocate(count * sizeof(T)), count);
memcpy(ret.items, items, count * sizeof(T)); memcpy(ret.items, items, count * sizeof(T));
return ret; return ret;
} }
void resize(Allocator* a, size_t newCount)
{
T* newItems = (T*)a->allocate(newCount * sizeof(T));
memcpy(newItems, items, min(count, newCount));
a->free(items, count);
items = newItems;
count = newCount;
}
}; };
} // namespace util } // namespace util

18
src/avian/alloc-vector.h
View File

@ -47,15 +47,6 @@ class Vector {
} }
} }
void wrap(avian::util::Slice<uint8_t> data)
{
dispose();
this->data = data;
this->position = 0;
this->minimumCapacity = 0;
}
void ensure(size_t space) void ensure(size_t space)
{ {
if (position + space > data.count) { if (position + space > data.count) {
@ -63,14 +54,11 @@ class Vector {
size_t newCapacity = avian::util::max( size_t newCapacity = avian::util::max(
position + space, avian::util::max(minimumCapacity, data.count * 2)); position + space, avian::util::max(minimumCapacity, data.count * 2));
uint8_t* newData = static_cast<uint8_t*>
(allocator->allocate(newCapacity));
if (data.begin()) { if (data.begin()) {
memcpy(newData, data.begin(), position); data.resize(allocator, newCapacity);
allocator->free(data.begin(), data.count); } else {
data = avian::util::Slice<uint8_t>::alloc(allocator, newCapacity);
} }
data.items = newData;
data.count = newCapacity;
} }
} }

30
src/tools/bootimage-generator/main.cpp
View File

@ -1917,9 +1917,9 @@ main(int ac, const char** av)
const unsigned CodeCapacity = 30 * 1024 * 1024; const unsigned CodeCapacity = 30 * 1024 * 1024;
#endif #endif
uint8_t* code = static_cast<uint8_t*>(h->allocate(CodeCapacity)); Slice<uint8_t> code = Slice<uint8_t>::alloc(h, CodeCapacity);
BootImage image; BootImage image;
p->initialize(&image, Slice<uint8_t>(code, CodeCapacity)); p->initialize(&image, code);
Machine* m = new (h->allocate(sizeof(Machine))) Machine Machine* m = new (h->allocate(sizeof(Machine))) Machine
(s, h, f, 0, p, c, 0, 0, 0, 0, 128 * 1024); (s, h, f, 0, p, c, 0, 0, 0, 0, 128 * 1024);
@ -1940,20 +1940,18 @@ main(int ac, const char** av)
return -1; return -1;
} }
uintptr_t arguments[] = { uintptr_t arguments[] = {reinterpret_cast<uintptr_t>(&bootimageOutput),
reinterpret_cast<uintptr_t>(&bootimageOutput), reinterpret_cast<uintptr_t>(&codeOutput),
reinterpret_cast<uintptr_t>(&codeOutput), reinterpret_cast<uintptr_t>(&image),
reinterpret_cast<uintptr_t>(&image), reinterpret_cast<uintptr_t>(code.begin()),
reinterpret_cast<uintptr_t>(code), reinterpret_cast<uintptr_t>(args.entryClass),
reinterpret_cast<uintptr_t>(args.entryClass), reinterpret_cast<uintptr_t>(args.entryMethod),
reinterpret_cast<uintptr_t>(args.entryMethod), reinterpret_cast<uintptr_t>(args.entrySpec),
reinterpret_cast<uintptr_t>(args.entrySpec), reinterpret_cast<uintptr_t>(args.bootimageStart),
reinterpret_cast<uintptr_t>(args.bootimageStart), reinterpret_cast<uintptr_t>(args.bootimageEnd),
reinterpret_cast<uintptr_t>(args.bootimageEnd), reinterpret_cast<uintptr_t>(args.codeimageStart),
reinterpret_cast<uintptr_t>(args.codeimageStart), reinterpret_cast<uintptr_t>(args.codeimageEnd),
reinterpret_cast<uintptr_t>(args.codeimageEnd), static_cast<uintptr_t>(args.useLZMA)};
static_cast<uintptr_t>(args.useLZMA)
};
run(t, writeBootImage, arguments); run(t, writeBootImage, arguments);