#pragma once /* * Copyright (C) 2024 Brett Terpstra * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #ifndef BLT_GP_PROGRAM_H #define BLT_GP_PROGRAM_H #include #include #include #include #include #include #include #include #include #include namespace blt::gp { class identifier { }; class type { public: template static type make_type(blt::size_t id) { return type(sizeof(T), id, blt::type_string()); } [[nodiscard]] blt::size_t size() const { return size_; } [[nodiscard]] blt::size_t id() const { return id_; } [[nodiscard]] std::string_view name() const { return name_; } private: type(size_t size, size_t id, std::string_view name): size_(size), id_(id), name_(name) {} blt::size_t size_; blt::size_t id_; std::string name_; }; class type_system { public: type_system() = default; template inline type register_type() { types.push_back(type::make_type(types.size())); return types.back(); } private: std::vector types; }; class stack_allocator { constexpr static blt::size_t PAGE_SIZE = 0x1000; constexpr static blt::size_t MAX_ALIGNMENT = 8; public: /** * Pushes an instance of an object on to the stack * @tparam T type to push * @param value universal reference to the object to push */ template void push(T&& value) { auto ptr = allocate_bytes(); head->metadata.offset = static_cast(ptr) + sizeof(T); new(ptr) T(std::forward(value)); } template T pop() { constexpr auto offset = std::max(sizeof(T), MAX_ALIGNMENT); if (head == nullptr) throw std::runtime_error("Silly boi the stack is empty!"); if (head->used_bytes_in_block() < static_cast(sizeof(T))) throw std::runtime_error("Mismatched Types! Not enough space left in block!"); T t = *reinterpret_cast(head->metadata.offset - offset); head->metadata.offset -= offset; if (head->used_bytes_in_block() == static_cast(head->storage_size())) { auto ptr = head; head = head->metadata.prev; std::free(ptr); } return t; } template T& from(blt::size_t bytes) { constexpr auto offset = std::max(sizeof(T), MAX_ALIGNMENT); auto remaining_bytes = static_cast(bytes); blt::i64 bytes_into_block = 0; block* blk = head; while (remaining_bytes > 0) { if (blk == nullptr) throw std::runtime_error("Requested size is beyond the scope of this stack!"); auto bytes_available = blk->used_bytes_in_block() - remaining_bytes; bytes_into_block = remaining_bytes; if (bytes_available < 0) { remaining_bytes = -bytes_available; blk = head->metadata.prev; } else break; } if (blk == nullptr) throw std::runtime_error("Some nonsense is going on. This function already smells"); return *reinterpret_cast((blk->metadata.offset - bytes_into_block) - offset); } [[nodiscard]] bool empty() const { if (head == nullptr) return true; if (head->metadata.prev != nullptr) return false; return head->used_bytes_in_block() == static_cast(head->storage_size()); } stack_allocator() = default; stack_allocator(const stack_allocator& copy) = delete; stack_allocator& operator=(const stack_allocator& copy) = delete; stack_allocator(stack_allocator&& move) noexcept { head = move.head; move.head = nullptr; } stack_allocator& operator=(stack_allocator&& move) noexcept { head = move.head; move.head = nullptr; return *this; } ~stack_allocator() { block* current = head; while (current != nullptr) { block* ptr = current; current = current->metadata.prev; std::free(ptr); } } private: struct block { struct block_metadata_t { blt::size_t size = 0; block* next = nullptr; block* prev = nullptr; blt::u8* offset = nullptr; } metadata; blt::u8 buffer[8]{}; explicit block(blt::size_t size) { metadata.size = size; metadata.offset = buffer; } [[nodiscard]] blt::ptrdiff_t storage_size() const { return static_cast(metadata.size - sizeof(typename block::block_metadata_t)); } [[nodiscard]] blt::ptrdiff_t used_bytes_in_block() const { return static_cast(metadata.offset - buffer); } [[nodiscard]] blt::ptrdiff_t remaining_bytes_in_block() const { return storage_size() - used_bytes_in_block(); } }; template void* allocate_bytes() { auto ptr = get_aligned_pointer(sizeof(T)); if (ptr == nullptr) push_block_for(); ptr = get_aligned_pointer(sizeof(T)); if (ptr == nullptr) throw std::bad_alloc(); return ptr; } void* get_aligned_pointer(blt::size_t bytes) { if (head == nullptr) return nullptr; blt::size_t remaining_bytes = head->remaining_bytes_in_block(); auto* pointer = static_cast(head->metadata.offset); return std::align(MAX_ALIGNMENT, bytes, pointer, remaining_bytes); } template void push_block_for() { push_block(std::max(PAGE_SIZE, to_nearest_page_size(sizeof(T)))); } void push_block(blt::size_t size) { auto blk = allocate_block(size); if (head == nullptr) { head = blk; return; } head->metadata.next = blk; blk->metadata.prev = head; head = blk; } static size_t to_nearest_page_size(blt::size_t bytes) { constexpr static blt::size_t MASK = ~(PAGE_SIZE - 1); return (bytes & MASK) + PAGE_SIZE; } static block* allocate_block(blt::size_t bytes) { auto size = to_nearest_page_size(bytes); auto* data = std::aligned_alloc(PAGE_SIZE, size); new(data) block{size}; return reinterpret_cast(data); } private: block* head = nullptr; }; template class operation { public: using function_t = std::function; operation(const operation& copy) = default; operation(operation&& move) = default; template, void>> explicit operation(const T& functor): func(functor) {} template, void>> explicit operation(const T& functor) { func = [&functor](Args... args) { return functor(args...); }; } explicit operation(function_t&& functor): func(std::move(functor)) {} inline Return operator()(Args... args) { return func(args...); } Return operator()(blt::span args) { auto pack_sequence = std::make_integer_sequence(); return function_evaluator(args, pack_sequence); } std::function)> to_functor() { return [this](blt::span args) { return this->operator()(args); }; } private: template static inline T& access_pack_index(blt::span args) { return *reinterpret_cast(args[index]); } template Return function_evaluator(blt::span args, std::integer_sequence) { return func(access_pack_index(args)...); } function_t func; }; } #endif //BLT_GP_PROGRAM_H