91 lines
No EOL
3.2 KiB
C++
91 lines
No EOL
3.2 KiB
C++
#include <cstring>
|
|
#include <iostream>
|
|
|
|
#include "heap.hpp"
|
|
|
|
GC::Heap *singleton_test();
|
|
void init_gc(GC::Heap *heap);
|
|
void frame_test(GC::Heap *heap);
|
|
|
|
int main() {
|
|
std::cout << "in main" << std::endl;
|
|
auto heap = singleton_test();
|
|
|
|
init_gc(heap);
|
|
frame_test(heap);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* This test is supposed to determine if the singleton pattern
|
|
* implementation is working correctly. This test passes if the
|
|
* first and second call prints the same memory address.
|
|
*
|
|
* Result: pass
|
|
*
|
|
* @return Pointer to the Heap singleton instance
|
|
*/
|
|
GC::Heap *singleton_test() {
|
|
std::cout << "TESTING SINGLETON INSTANCES" << std::endl;
|
|
std::cout << "===========================" << std::endl;
|
|
std::cout << "Call 1:\t" << GC::Heap::the() << std::endl; // First call which initializes the singleton instance
|
|
GC::Heap *heap = GC::Heap::the(); // Second call which should return the initialized instance
|
|
std::cout << "Call 2:\t" << heap << std::endl;
|
|
std::cout << "===========================" << std::endl;
|
|
return heap;
|
|
}
|
|
|
|
|
|
/**
|
|
* This test calls Heap::init() which saves the stack-frame
|
|
* address from the calling function (this function).
|
|
* Heap::init() is supposed to be called at the absolute
|
|
* start of the program to save the address of the
|
|
* topmost stack frame. This test doesn't do anything
|
|
* but prepares for the next test(s).
|
|
*
|
|
* @param heap The Heap pointer to the singleton instance.
|
|
*
|
|
*/
|
|
void init_gc(GC::Heap *heap){
|
|
std::cout << "\n\n INITIALIZING THE HEAP" << std::endl;
|
|
std::cout << "===========================" << std::endl;
|
|
heap->init();
|
|
std::cout << "===========================" << std::endl;
|
|
}
|
|
|
|
/**
|
|
* This function tests the functionality of the intrinsic
|
|
* function `__builtin_frame_address` which returns the
|
|
* address of the corresponding level of stack frame.
|
|
* When given a param of 0, it returns the current stack frame.
|
|
* When given a param of 1, it returns the previous stack
|
|
* frame, and so on.
|
|
*
|
|
* This test passes on two conditions:
|
|
* 1) if the address of the current frame is smaller than
|
|
* the address of the previous frame (assumed).
|
|
* 2) if the previous frame has the same address as the one
|
|
* saved in the Heap instance after running Heap::init().
|
|
*
|
|
* Result: pass
|
|
*
|
|
* @param heap The Heap instance
|
|
*/
|
|
void frame_test(GC::Heap *heap) {
|
|
std::cout << "\n\n TESTING FRAME ADDRESSES" << std::endl;
|
|
std::cout << "===========================" << std::endl;
|
|
|
|
#pragma clang diagnostic ignored "-Wframe-address" // clang++ directive to ignore warnings about __b_f_a
|
|
auto curr_frame = reinterpret_cast<uintptr_t *>(__builtin_frame_address(0)); // addr of curr stack frame
|
|
std::cout << "Current stack frame:\t" << curr_frame << std::endl;
|
|
#pragma clang diagnostic ignored "-Wframe-address"
|
|
auto prev_frame = reinterpret_cast<uintptr_t *>(__builtin_frame_address(1)); // addr of prev stack frame
|
|
std::cout << "Previous stack frame:\t" << prev_frame << std::endl;
|
|
|
|
heap->check_init(); // prints the saved absolute top of the stack
|
|
// auto alloced = heap->alloc(sizeof(unsigned long));
|
|
|
|
std::cout << "===========================" << std::endl;
|
|
} |