static os_index_t
memzone_find_unused(struct memzone *mz, size_t nchunks)
{
ssize_t err;
os_index_t chunk;
if ((chunk = memzone_search_unused(mz, nchunks)) < 0)
{
const struct vmem_area *area;
size_t pgcount;
ssize_t pgindex;
size_t pgnchunks;
size_t i;
if (chunk != -EAGAIN)
{
err = chunk;
goto err_memzone_search_unused;
}
pgcount = page_count(0, nchunks * mz->chunksize);
pgindex = vmem_helper_alloc_pages_in_area(mz->as,
mz->areaname,
pgcount,
PTE_FLAG_PRESENT |
PTE_FLAG_WRITEABLE);
if (pgindex < 0)
{
err = pgindex;
goto err_memzone_search_unused;
}
area = vmem_area_get_by_name(mz->areaname);
chunk = page_memory(pgindex - area->pgindex) / mz->chunksize;
pgnchunks = pgcount / mz->chunksize;
for (i = chunk; pgnchunks; --pgnchunks)
{
memzone_set_flags(mz, i, MEMZONE_FLAG_ALLOCED);
}
}
return chunk;
err_memzone_search_unused:
return err;
}
int
memzone_init(struct memzone *mz,
struct vmem *as, enum vmem_area_name areaname)
{
const struct vmem_area *area;
int err;
ssize_t pgindex;
size_t memsz; /* size of memory */
area = vmem_area_get_by_name(areaname);
memsz = page_memory(area->npages);
pgindex = vmem_helper_alloc_pages_in_area(as, areaname, 1024, /* one largepage */
PTE_FLAG_PRESENT |
PTE_FLAG_WRITEABLE);
if (pgindex < 0)
{
err = pgindex;
goto err_vmem_helper_alloc_page_in_area;
}
mz->flagslen = 1024 * PAGE_SIZE;
mz->flags = page_address(pgindex);
mz->nchunks = BITS_PER_LARGEPAGE / BITS_PER_PAGE;
mz->chunksize = 1 << (logbase2(memsz / mz->nchunks) + 1);
mz->nchunks = memsz / mz->chunksize;
mz->as = as;
mz->areaname = areaname;
memset(mz->flags, 0, mz->flagslen);
console_printf("%s:%x mz->chunksize=%x\n", __FILE__, __LINE__,
mz->chunksize);
return 0;
err_vmem_helper_alloc_page_in_area:
return err;
}
ErrorStack execute(
Engine* engine,
storage::StorageId id,
double* elapsed_ms,
std::vector<std::string>* papi_results) {
storage::Composer composer(engine, id);
cache::SnapshotFileSet dummy_files(engine);
CHECK_ERROR(dummy_files.initialize());
LOG(INFO) << "Allocating memories...";
debugging::StopWatch alloc_watch;
memory::AlignedMemory::AllocType kAlloc = memory::AlignedMemory::kNumaAllocOnnode;
memory::AlignedMemory work_memory(1ULL << 23, 1U << 21, kAlloc, 0);
memory::AlignedMemory root_page_memory(1ULL << 12, 1U << 12, kAlloc, 0);
uint64_t full_size = kRecords * kPayloadSize * 2ULL;
memory::AlignedMemory page_memory(full_size, 1U << 21, kAlloc, 0);
memory::AlignedMemory intermediate_memory(1ULL << 24, 1U << 21, kAlloc, 0);
memory::AlignedMemory log_memory(full_size, 1U << 21, kAlloc, 0);
alloc_watch.stop();
LOG(INFO) << "Allocated memories in " << alloc_watch.elapsed_ms() << "ms";
LOG(INFO) << "Populating logs to process...";
debugging::StopWatch log_watch;
char* log_buffer = reinterpret_cast<char*>(log_memory.get_block());
uint64_t log_size = 0;
populate_logs(id, log_buffer, &log_size);
InMemorySortedBuffer buffer(log_buffer, log_size);
uint16_t key_len = sizeof(storage::array::ArrayOffset);
buffer.set_current_block(id, kRecords, 0, log_size, key_len, key_len);
log_watch.stop();
LOG(INFO) << "Populated logs to process in " << log_watch.elapsed_ms() << "ms";
// we need at least a dummy partitioning information because array composer uses it.
storage::PartitionerMetadata* metadata = storage::PartitionerMetadata::get_metadata(engine, id);
make_dummy_partitions(engine, id, metadata);
SnapshotWriter writer(engine, 0, kSnapshotId, &page_memory, &intermediate_memory);
CHECK_ERROR(writer.open());
storage::Page* root_page = reinterpret_cast<storage::Page*>(root_page_memory.get_block());
snapshot::SortedBuffer* log_array[1];
log_array[0] = &buffer;
storage::Composer::ComposeArguments args = {
&writer,
&dummy_files,
log_array,
1,
&work_memory,
Epoch(1),
root_page
};
if (FLAGS_profile) {
COERCE_ERROR(engine->get_debug()->start_profile("compose_experiment.prof"));
engine->get_debug()->start_papi_counters();
}
LOG(INFO) << "experiment's main part has started";
debugging::StopWatch watch;
CHECK_ERROR(composer.compose(args));
watch.stop();
*elapsed_ms = watch.elapsed_ms();
LOG(INFO) << "experiment's main part has ended. Took " << *elapsed_ms << "ms";
if (FLAGS_profile) {
engine->get_debug()->stop_profile();
engine->get_debug()->stop_papi_counters();
if (FLAGS_papi) {
*papi_results = debugging::DebuggingSupports::describe_papi_counters(
engine->get_debug()->get_papi_counters());
}
}
writer.close();
CHECK_ERROR(dummy_files.uninitialize());
return kRetOk;
}
