profiler improvement
This commit is contained in:
Victor Olin
parent
d7ea27e9cd
commit
1741281fd8
7 changed files with 61 additions and 153 deletions
|
|
@ -18,7 +18,7 @@ file:
|
|||
heap:
|
||||
$(CC) $(WFLAGS) $(STDFLAGS) $(LIB_INCL) lib/heap.cpp
|
||||
|
||||
h_test:
|
||||
h_test: static_lib
|
||||
rm -f tests/h_test.out
|
||||
# $(CC) $(WFLAGS) $(STDFLAGS) $(LIB_INCL) tests/h_test.cpp lib/heap.cpp lib/profiler.cpp lib/event.cpp -o tests/h_test.out
|
||||
$(CC) $(STDFLAGS) $(WFLAGS) $(LIB_INCL) -O3 -g -o tests/h_test.out tests/h_test.cpp lib/gcoll.a
|
||||
|
|
|
|||
|
|
@ -7,8 +7,8 @@
|
|||
#include "chunk.hpp"
|
||||
#include "profiler.hpp"
|
||||
|
||||
#define HEAP_SIZE 160 //65536
|
||||
#define FREE_THRESH (uint) 0
|
||||
#define HEAP_SIZE 65536
|
||||
#define FREE_THRESH (uint) 100
|
||||
#define HEAP_DEBUG
|
||||
|
||||
namespace GC
|
||||
|
|
@ -69,9 +69,6 @@ namespace GC
|
|||
// Temporary
|
||||
Chunk *try_recycle_chunks_new(size_t size);
|
||||
void free_overlap_new(Heap &heap);
|
||||
#ifndef HEAP_DEBUG
|
||||
void add_to_free_list(Chunk *chunk);
|
||||
#endif
|
||||
public:
|
||||
/**
|
||||
* These are the only five functions which are exposed
|
||||
|
|
@ -85,7 +82,6 @@ namespace GC
|
|||
static void init();
|
||||
static void dispose();
|
||||
static void *alloc(size_t size);
|
||||
static void *alloc_free_list(size_t size);
|
||||
void set_profiler(bool mode);
|
||||
|
||||
// Stop the compiler from generating copy-methods
|
||||
|
|
@ -93,7 +89,6 @@ namespace GC
|
|||
Heap& operator=(Heap const&) = delete;
|
||||
|
||||
#ifdef HEAP_DEBUG
|
||||
void add_to_free_list(Chunk *chunk);
|
||||
void collect(CollectOption flags); // conditional collection
|
||||
void check_init(); // print dummy things
|
||||
void print_contents(); // print dummy things
|
||||
|
|
|
|||
|
|
@ -43,6 +43,11 @@ namespace GC {
|
|||
std::vector<ProfilerEvent *> m_prof_events;
|
||||
RecordOption flags;
|
||||
|
||||
std::chrono::microseconds alloc_time {0};
|
||||
// size_t alloc_counts {0};
|
||||
std::chrono::microseconds collect_time {0};
|
||||
// size_t collect_counts {0};
|
||||
|
||||
static void record_data(GCEvent *type);
|
||||
std::ofstream create_file_stream();
|
||||
std::string get_log_folder();
|
||||
|
|
@ -60,6 +65,7 @@ namespace GC {
|
|||
static void record(GCEventType type);
|
||||
static void record(GCEventType type, size_t size);
|
||||
static void record(GCEventType type, Chunk *chunk);
|
||||
static void record(GCEventType type, std::chrono::microseconds time);
|
||||
static void dispose();
|
||||
};
|
||||
}
|
||||
|
|
@ -2,9 +2,13 @@
|
|||
#include <stdexcept>
|
||||
#include <stdlib.h>
|
||||
#include <vector>
|
||||
#include <chrono>
|
||||
|
||||
#include "heap.hpp"
|
||||
|
||||
#define time_now std::chrono::high_resolution_clock::now()
|
||||
#define to_us std::chrono::duration_cast<std::chrono::microseconds>
|
||||
|
||||
using std::cout, std::endl, std::vector, std::hex, std::dec;
|
||||
|
||||
namespace GC
|
||||
|
|
@ -51,131 +55,6 @@ namespace GC
|
|||
Profiler::dispose();
|
||||
}
|
||||
|
||||
void *Heap::alloc_free_list(size_t size)
|
||||
{
|
||||
// Singleton
|
||||
Heap &heap = Heap::the();
|
||||
bool profiler_enabled = heap.profiler_enabled();
|
||||
|
||||
if (profiler_enabled)
|
||||
Profiler::record(AllocStart, size);
|
||||
|
||||
if (size == 0)
|
||||
{
|
||||
cout << "Heap: Cannot alloc 0B. No bytes allocated." << endl;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// Try to find a fragmented section to recycle
|
||||
Chunk *recycle = nullptr;
|
||||
auto iter = heap.m_free_list.begin();
|
||||
while (iter != heap.m_free_list.end())
|
||||
{
|
||||
if ((*iter)->m_size >= size)
|
||||
{
|
||||
recycle = *iter;
|
||||
heap.m_free_list.erase(++iter);
|
||||
break;
|
||||
}
|
||||
iter++;
|
||||
}
|
||||
|
||||
// If memory fragment was found
|
||||
if (recycle != nullptr)
|
||||
{
|
||||
heap.m_size += size;
|
||||
|
||||
// If fragment is larger than request, split it
|
||||
if (recycle->m_size > size)
|
||||
{
|
||||
auto new_part = new Chunk(size, recycle->m_start);
|
||||
auto complement = new Chunk(
|
||||
recycle->m_size - size,
|
||||
(recycle->m_start + size)
|
||||
);
|
||||
delete recycle;
|
||||
// TODO: add complement to free_list
|
||||
heap.add_to_free_list(complement);
|
||||
|
||||
heap.m_allocated_chunks.push_back(new_part);
|
||||
|
||||
return (void *)(new_part->m_start);
|
||||
}
|
||||
|
||||
heap.m_allocated_chunks.push_back(recycle);
|
||||
return (void *)(recycle->m_start);
|
||||
}
|
||||
|
||||
uintptr_t *max_size = (uintptr_t *)(heap.m_heap + HEAP_SIZE);
|
||||
uintptr_t *new_size = (uintptr_t *)(heap.m_heap_top + size);
|
||||
|
||||
if (new_size <= max_size)
|
||||
{
|
||||
auto new_chunk = new Chunk(size, (uintptr_t *)(heap.m_heap_top));
|
||||
heap.m_allocated_chunks.push_back(new_chunk);
|
||||
|
||||
if (profiler_enabled)
|
||||
Profiler::record(NewChunk, new_chunk);
|
||||
|
||||
heap.m_heap_top += size;
|
||||
heap.m_size += size;
|
||||
}
|
||||
|
||||
// Only throws if the allocation failed
|
||||
throw std::runtime_error(std::string("Error: Heap out of memory"));
|
||||
}
|
||||
|
||||
void Heap::add_to_free_list(Chunk *chunk)
|
||||
{
|
||||
Chunk *curr;
|
||||
auto iter = m_free_list.begin();
|
||||
uintptr_t *prev_start = nullptr;
|
||||
uintptr_t *prev_end = nullptr;
|
||||
|
||||
while (iter != m_free_list.end())
|
||||
{
|
||||
curr = *iter;
|
||||
|
||||
// If the curr chunk is aligned before param
|
||||
if (curr->m_start + curr->m_size == chunk->m_start)
|
||||
{
|
||||
Chunk *merged = new Chunk(
|
||||
curr->m_size + chunk->m_size,
|
||||
curr->m_start
|
||||
);
|
||||
iter = m_free_list.erase(iter);
|
||||
m_free_list.insert(iter, merged);
|
||||
return;
|
||||
}
|
||||
|
||||
// If the curr chunk is aligned after param
|
||||
if (chunk->m_start + chunk->m_size == curr->m_start)
|
||||
{
|
||||
Chunk *merged = new Chunk(
|
||||
curr->m_size + chunk->m_size,
|
||||
chunk->m_start
|
||||
);
|
||||
iter = m_free_list.erase(iter);
|
||||
m_free_list.insert(iter, merged);
|
||||
return;
|
||||
}
|
||||
|
||||
// If the first chunk starts after param
|
||||
if (prev_start == nullptr && curr->m_start > chunk->m_start)
|
||||
{
|
||||
m_free_list.insert(iter, chunk);
|
||||
return;
|
||||
}
|
||||
|
||||
prev_start = curr->m_start;
|
||||
prev_end = prev_start + curr->m_size;
|
||||
iter++;
|
||||
}
|
||||
|
||||
// This is only reachable if the chunk is at the end
|
||||
m_free_list.push_back(chunk);
|
||||
}
|
||||
|
||||
/**
|
||||
* Allocates a given amount of bytes on the heap.
|
||||
*
|
||||
|
|
@ -187,6 +66,7 @@ namespace GC
|
|||
*/
|
||||
void *Heap::alloc(size_t size)
|
||||
{
|
||||
auto a_start = time_now;
|
||||
// Singleton
|
||||
Heap &heap = Heap::the();
|
||||
bool profiler_enabled = heap.profiler_enabled();
|
||||
|
|
@ -202,6 +82,8 @@ namespace GC
|
|||
|
||||
if (heap.m_size + size > HEAP_SIZE)
|
||||
{
|
||||
// auto a_ms = to_us(c_start - a_start);
|
||||
// Profiler::record(AllocStart, a_ms);
|
||||
heap.collect();
|
||||
// If memory is not enough after collect, crash with OOM error
|
||||
if (heap.m_size + size > HEAP_SIZE)
|
||||
|
|
@ -218,6 +100,9 @@ namespace GC
|
|||
{
|
||||
if (profiler_enabled)
|
||||
Profiler::record(ReusedChunk, reused_chunk);
|
||||
auto a_end = time_now;
|
||||
auto a_ms = to_us(a_end - a_start);
|
||||
Profiler::record(AllocStart, a_ms);
|
||||
return static_cast<void *>(reused_chunk->m_start);
|
||||
}
|
||||
|
||||
|
|
@ -231,6 +116,9 @@ namespace GC
|
|||
if (profiler_enabled)
|
||||
Profiler::record(NewChunk, new_chunk);
|
||||
|
||||
auto a_end = time_now;
|
||||
auto a_ms = to_us(a_end - a_start);
|
||||
Profiler::record(AllocStart, a_ms);
|
||||
return new_chunk->m_start;
|
||||
}
|
||||
|
||||
|
|
@ -306,6 +194,8 @@ namespace GC
|
|||
*/
|
||||
void Heap::collect()
|
||||
{
|
||||
auto c_start = time_now;
|
||||
|
||||
Heap &heap = Heap::the();
|
||||
|
||||
if (heap.profiler_enabled())
|
||||
|
|
@ -325,6 +215,10 @@ namespace GC
|
|||
sweep(heap);
|
||||
|
||||
free(heap);
|
||||
|
||||
auto c_end = time_now;
|
||||
|
||||
Profiler::record(CollectStart, to_us(c_end - c_start));
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -114,12 +114,26 @@ namespace GC
|
|||
// profiler.m_events.push_back(event);
|
||||
}
|
||||
|
||||
void Profiler::record(GCEventType type, std::chrono::microseconds time)
|
||||
{
|
||||
Profiler &prof = Profiler::the();
|
||||
if (type == AllocStart)
|
||||
{
|
||||
prof.alloc_time += time;
|
||||
}
|
||||
else if (type == CollectStart)
|
||||
{
|
||||
prof.collect_time += time;
|
||||
}
|
||||
}
|
||||
|
||||
void Profiler::dump_prof_trace()
|
||||
{
|
||||
Profiler &prof = Profiler::the();
|
||||
prof.m_prof_events.push_back(prof.m_last_prof_event);
|
||||
auto start = prof.m_prof_events.begin();
|
||||
auto end = prof.m_prof_events.end();
|
||||
int allocs = 0, collects = 0;
|
||||
|
||||
char buffer[22];
|
||||
std::ofstream fstr = prof.create_file_stream();
|
||||
|
|
@ -128,11 +142,22 @@ namespace GC
|
|||
{
|
||||
auto event = *start++;
|
||||
|
||||
if (event->m_type == AllocStart)
|
||||
allocs += event->m_n;
|
||||
else if (event->m_type == CollectStart)
|
||||
collects += event->m_n;
|
||||
|
||||
fstr << "\n--------------------------------\n"
|
||||
<< Profiler::type_to_string(event->m_type)
|
||||
<< "\nTimes:\t" << event->m_n;
|
||||
<< Profiler::type_to_string(event->m_type) << " "
|
||||
<< event->m_n << " times:";
|
||||
}
|
||||
fstr << "\n--------------------------------";
|
||||
|
||||
fstr << "\n\nTime spent on allocations:\t" << prof.alloc_time.count() << " microseconds"
|
||||
<< "\nAllocation cycles:\t" << allocs
|
||||
<< "\nTime spent on collections:\t" << prof.collect_time.count() << " microseconds"
|
||||
<< "\nCollection cycles:\t" << collects
|
||||
<< "\n--------------------------------";
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -80,6 +80,7 @@ int main() {
|
|||
GC::Heap::init();
|
||||
GC::Heap &gc = GC::Heap::the();
|
||||
gc.set_profiler(true);
|
||||
GC::Profiler::set_log_options(GC::FunctionCalls);
|
||||
gc.check_init();
|
||||
auto stack_start = reinterpret_cast<uintptr_t *>(__builtin_frame_address(0));
|
||||
|
||||
|
|
|
|||
|
|
@ -52,22 +52,10 @@ void clear_list(Node *head)
|
|||
}
|
||||
}
|
||||
|
||||
void run_list_test1()
|
||||
void run_list_test()
|
||||
{
|
||||
Node *list_a = create_list(10);
|
||||
print_list(list_a);
|
||||
}
|
||||
|
||||
void run_list_test2()
|
||||
{
|
||||
Node *list_b = create_list(10);
|
||||
print_list(list_b);
|
||||
}
|
||||
|
||||
void run_list_test3()
|
||||
{
|
||||
Node *list_c = create_list(10);
|
||||
print_list(list_c);
|
||||
Node *list = create_list(10);
|
||||
print_list(list);
|
||||
}
|
||||
|
||||
int main()
|
||||
|
|
@ -77,9 +65,8 @@ int main()
|
|||
heap.set_profiler(true);
|
||||
GC::Profiler::set_log_options(GC::FunctionCalls);
|
||||
|
||||
run_list_test1();
|
||||
run_list_test2();
|
||||
run_list_test3();
|
||||
for (int i = 0; i < 10; i++)
|
||||
run_list_test();
|
||||
|
||||
GC::Heap::dispose();
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue