tursom/memgraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add initial version of extent_hooks

Browse Source
This commit is contained in:
antoniofilipovic
2023-09-11 16:58:49 +02:00
parent bd1852f407
commit 0f8ef3cdb2
2 changed files with 181 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

153
src/memory/memory_control.cpp
View File

@@ -1,4 +1,4 @@
// Copyright 2022 Memgraph Ltd.
// Copyright 2023 Memgraph Ltd.
//
// Use of this software is governed by the Business Source License
// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -10,11 +10,16 @@
// licenses/APL.txt.
#include "memory_control.hpp"
#include <fmt/core.h>
#include "utils/logging.hpp"
#if USE_JEMALLOC
#include <jemalloc/jemalloc.h>
#endif
#include <iostream>
#include <vector>
namespace memgraph::memory {
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
@@ -22,12 +27,158 @@ namespace memgraph::memory {
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define STRINGIFY(x) STRINGIFY_HELPER(x)
// static std::vector<extent_hooks_t*> original_hooks_vec;
extent_hooks_t *old_hooks;
static void *my_alloc(extent_hooks_t *extent_hooks, void *new_addr, size_t size, size_t alignment, bool *zero,
bool *commit, unsigned arena_ind) {
// std::cout << fmt::format("In wrapper alloc_hook: new_addr: {}, size: {}, alignment: {}, arena_ind: {}", new_addr,
// size, alignment, arena_ind);
// printf("In wrapper alloc_hook: new_addr:%p "
// "size:%lu(%lu pages) alignment:%lu "
// "zero:%s commit:%s arena_ind:%u\n",
// new_addr, size, size / 4096, alignment,
// (*zero) ? "true" : "false",
// (*commit) ? "true" : "false",
// arena_ind);
// Default behavior using original hooks
MG_ASSERT(old_hooks && old_hooks->alloc);
return old_hooks->alloc(old_hooks, new_addr, size, alignment, zero, commit, arena_ind);
}
static bool my_dalloc(extent_hooks_t *extent_hooks, void *addr, size_t size, bool committed, unsigned arena_ind) {
// std::cout << fmt::format("In wrapper my_dalloc: new_addr: {}, size: {}, arena_ind: {}", addr, size, arena_ind);
// extent_hooks_t *old_hooks = original_hooks_vec[arena_ind];
return old_hooks->dalloc(extent_hooks, addr, size, committed, arena_ind);
}
static void my_destroy(extent_hooks_t *extent_hooks, void *addr, size_t size, bool committed, unsigned arena_ind) {
// std::cout << fmt::format("In wrapper my_destroy: new_addr: {}, size: {}, arena_ind: {}", addr, size, arena_ind);
// extent_hooks_t *old_hooks = original_hooks_vec[arena_ind];
old_hooks->destroy(extent_hooks, addr, size, committed, arena_ind);
}
static bool my_commit(extent_hooks_t *extent_hooks, void *addr, size_t size, size_t offset, size_t length,
unsigned arena_ind) {
// std::cout << fmt::format("In wrapper my_commit: new_addr: {}, size: {}, arena_ind: {}", addr, size, arena_ind);
// extent_hooks_t *old_hooks = original_hooks_vec[arena_ind];
return old_hooks->commit(extent_hooks, addr, size, offset, length, arena_ind);
}
static bool my_decommit(extent_hooks_t *extent_hooks, void *addr, size_t size, size_t offset, size_t length,
unsigned arena_ind) {
// std::cout << fmt::format("In wrapper my_decommit: new_addr: {}, size: {}, arena_ind: {}", addr, size, arena_ind);
// extent_hooks_t *old_hooks = original_hooks_vec[arena_ind];
return old_hooks->decommit(extent_hooks, addr, size, offset, length, arena_ind);
}
static bool my_purge_forced(extent_hooks_t *extent_hooks, void *addr, size_t size, size_t offset, size_t length,
unsigned arena_ind) {
// std::cout << fmt::format("In wrapper purge_forced: new_addr: {}, size: {}, arena_ind: {}", addr, size, arena_ind);
// extent_hooks_t *old_hooks = original_hooks_vec[arena_ind];
return old_hooks->purge_forced(extent_hooks, addr, size, offset, length, arena_ind);
}
static bool my_purge_lazy(extent_hooks_t *extent_hooks, void *addr, size_t size, size_t offset, size_t length,
unsigned arena_ind) {
// std::cout << fmt::format("In wrapper purge_lazy: new_addr: {}, size: {}, arena_ind: {}", addr, size, arena_ind);
// extent_hooks_t *old_hooks = original_hooks_vec[arena_ind];
return old_hooks->purge_lazy(extent_hooks, addr, size, offset, length, arena_ind);
}
static bool my_split(extent_hooks_t *extent_hooks, void *addr, size_t size, size_t size_a, size_t size_b,
bool committed, unsigned arena_ind) {
// std::cout << fmt::format("In wrapper my_split: new_addr: {}, size: {}, arena_ind: {}", addr, size, arena_ind);
// extent_hooks_t *old_hooks = original_hooks_vec[arena_ind];
MG_ASSERT(old_hooks && old_hooks->split);
return old_hooks->split(extent_hooks, addr, size, size_a, size_b, committed, arena_ind);
}
static bool my_merge(extent_hooks_t *extent_hooks, void *addr_a, size_t size_a, void *addr_b, size_t size_b,
bool committed, unsigned arena_ind) {
// std::cout << fmt::format("In wrapper my_merge: addr_a: {}, size_a: {}, arena_ind: {}", addr_a, size_a, arena_ind);
// extent_hooks_t *old_hooks = original_hooks_vec[arena_ind];
return old_hooks->merge(extent_hooks, addr_a, size_a, addr_b, size_b, committed, arena_ind);
}
static extent_hooks_t custom_hooks = {
.alloc = &my_alloc,
.dalloc = &my_dalloc,
.destroy = &my_destroy,
.commit = &my_commit,
.decommit = &my_decommit,
.purge_lazy = &my_purge_lazy,
.purge_forced = &my_purge_forced,
.split = &my_split,
.merge = &my_merge,
};
extent_hooks_t *new_hooks = &custom_hooks;
void PrintStats() {
#if USE_JEMALLOC
uint64_t allocated{0};
uint64_t sz{sizeof(allocated)};
mallctl("stats.allocated", &allocated, &sz, nullptr, 0);
std::cout << "stats allocated:" << allocated << ", sz: " << std::endl;
mallctl("stats.arenas." STRINGIFY(MALLCTL_ARENAS_ALL) ".pactive", &allocated, &sz, nullptr, 0);
std::cout << "stats allocated:" << allocated << ", sz: " << std::endl;
sz = sizeof(unsigned);
unsigned narenas{0};
int success = mallctl("opt.narenas", (void *)&narenas, &sz, nullptr, 0);
std::cout << narenas << " : n arenas" << std::endl;
if (nullptr != old_hooks) {
return;
}
// get original hooks
// original_hooks_vec.reserve(narenas);
for (int i = 0; i < narenas; i++) {
std::string func_name = "arena." + std::to_string(i) + ".extent_hooks";
size_t hooks_len = sizeof(old_hooks);
mallctlRead<extent_hooks_t *, true>(func_name.c_str(), &old_hooks);
custom_hooks = {.alloc = old_hooks->alloc,
.dalloc = old_hooks->dalloc,
.commit = old_hooks->commit,
.decommit = old_hooks->decommit,
.destroy = old_hooks->destroy,
.merge = old_hooks->merge,
.purge_forced = old_hooks->purge_forced,
.purge_lazy = old_hooks->purge_lazy,
.split = old_hooks->split};
if (mallctlWrite<extent_hooks_t *, true>(func_name.c_str(), &custom_hooks)) {
std::cout << "error writting hook" << std::endl;
}
}
// for(int i=0;i<narenas;i++){
// std::string arena_str = "arena."+std::to_string(i) + ".extent_hooks";
// extent_hooks_t *ptr = original_hooks_vec[i];
// size_t hooks_len = sizeof(ptr);
// if (mallctl(arena_str.c_str(), nullptr, nullptr, &new_hooks, hooks_len)) {
// std::cout<< "error setting new hook" << std::endl;
// }
// }
#endif
}
void PurgeUnusedMemory() {
#if USE_JEMALLOC
mallctl("arena." STRINGIFY(MALLCTL_ARENAS_ALL) ".purge", nullptr, nullptr, nullptr, 0);
#endif
PrintStats();
}
#undef STRINGIFY
#undef STRINGIFY_HELPER
} // namespace memgraph::memory

30
src/memory/memory_control.hpp
View File

@@ -1,4 +1,4 @@
// Copyright 2022 Memgraph Ltd.
// Copyright 2023 Memgraph Ltd.
//
// Use of this software is governed by the Business Source License
// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -11,6 +11,34 @@
#pragma once
#include <cstddef>
#include "utils/logging.hpp"
namespace memgraph::memory {
template <typename T, bool ErrOK>
int mallctlHelper(const char *cmd, T *out, T *in) {
size_t out_len = sizeof(T);
int err = mallctl(cmd, out, out ? &out_len : nullptr, in, in ? sizeof(T) : 0);
MG_ASSERT(err != 0 || out_len == sizeof(T));
return err;
}
template <typename T, bool ErrOK = false>
int mallctlReadWrite(const char *cmd, T *out, T in) {
return mallctlHelper<T, ErrOK>(cmd, out, &in);
}
template <typename T, bool ErrOK = false>
int mallctlRead(const char *cmd, T *out) {
return mallctlHelper<T, ErrOK>(cmd, out, static_cast<T *>(nullptr));
}
template <typename T, bool ErrOK = false>
int mallctlWrite(const char *cmd, T in) {
return mallctlHelper<T, ErrOK>(cmd, static_cast<T *>(nullptr), &in);
}
void PurgeUnusedMemory();
void PrintStats();
} // namespace memgraph::memory