fennec-org/fennec
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- events tested and implemented multithreading support through mpscq

Browse Source
This commit is contained in:
Medusa Slockbower
2025-12-23 12:24:23 -05:00
parent 1f6637408d
commit 184bc7fcdf
12 changed files with 281 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
include/fennec/core/event.h
View File

@@ -39,6 +39,11 @@ public:
/// \brief event handler callback
/// \param event the event to handle
virtual void handle_event(event* event) = 0;
#ifndef FENNEC_DOXYGEN
FENNEC_RTTI_CLASS_ENABLE() {
}
#endif
};
///
@@ -46,36 +51,38 @@ public:
struct event {
virtual ~event() = default;
static void handle_events();
///
/// \brief Registers a listener for the event type
/// \tparam EventT the event type
/// \param listener the listener to register
template<typename EventT>
static void add_listener(event_listener* listener) {
event::add_listener(listener, typeuuid<EventT, event>());
event::_add_listener(listener, type::get<EventT>().id());
}
///
/// \brief Add a listener for an event type of \f$type\f$
/// \param listener the listener to add
/// \param type the event type to listen for
static void add_listener(event_listener* listener, uint64_t type);
///
/// \brief removes a listener from the event system
/// \param listener the listener to remove
static void remove_listener(event_listener* listener);
template<typename EventT, typename...ArgsT>
static void dispatch_immediate(ArgsT&&...args) {
static void dispatch(ArgsT&&...args) {
event::_dispatch(fennec::make_unique<EventT>(fennec::forward<ArgsT>(args)...));
}
template<typename EventT, typename...ArgsT>
static void dispatch_next_tick(ArgsT&&...args) {
static void dispatch_immediate(ArgsT&&...args) {
event::_dispatch_immediate(fennec::make_unique<EventT>(fennec::forward<ArgsT>(args)...));
}
private:
static void _add_listener(event_listener* listener, uint64_t type);
static void _handle_event(unique_ptr<event>& event);
static void _dispatch(unique_ptr<event>&& event);
static void _dispatch_immediate(unique_ptr<event>&& event);
#ifndef FENNEC_DOXYGEN
FENNEC_RTTI_CLASS_ENABLE() {
}

20
include/fennec/lang/assert.h
View File

@@ -31,6 +31,8 @@
#ifndef FENNEC_LANG_ASSERT_H
#define FENNEC_LANG_ASSERT_H
#include <fennec/lang/types.h>
///
/// \page fennec_lang_assert Assertions
///
@@ -69,7 +71,19 @@
#endif
#ifndef FENNEC_DOXYGEN
void _assert_impl(const char* expression, const char* file, int line, const char* function, const char* desc, bool halt);
void _assert_impl(const char* expr, size_t expr_l,
const char* file, size_t file_l, int line,
const char* func, size_t func_l,
const char* desc, bool halt);
template<size_t ExprL, size_t FileL, size_t FuncL>
void _assert(const char (&expr)[ExprL],
const char (&file)[FileL], int line,
const char (&func)[FuncL],
const char* desc,
bool halt) {
::_assert_impl(expr, ExprL, file, FileL, line, func, FuncL, desc, halt);
}
#endif
///
@@ -78,7 +92,7 @@ void _assert_impl(const char* expression, const char* file, int line, const char
/// \param description the description of the assertion
#define assert(expression, description) \
if(not(expression)) [[unlikely]] { \
_assert_impl(#expression, __FILE__, __LINE__, __PRETTY_FUNCTION__, description, not FENNEC_RELEASE); \
_assert(#expression, __FILE__, __LINE__, __PRETTY_FUNCTION__, description, not FENNEC_RELEASE); \
}
///
@@ -87,7 +101,7 @@ void _assert_impl(const char* expression, const char* file, int line, const char
/// \param description the description of the assertion
#define assertf(expression, description) \
if(not(expression)) [[unlikely]] { \
_assert_impl(#expression, __FILE__, __LINE__, __PRETTY_FUNCTION__, description, true); \
_assert(#expression, __FILE__, __LINE__, __PRETTY_FUNCTION__, description, true); \
}
///

14
include/fennec/memory/pointers.h
View File

@@ -117,13 +117,20 @@ public:
}
///
/// \brief Move Constructor, transfers ownership from \f$other\f$
/// \param other The unique_ptr to take ownership from
constexpr unique_ptr(unique_ptr&& other)
: _handle(other._handle) {
other._handle = nullptr;
}
///
/// \brief Move Constructor, transfers ownership from \f$other\f$
/// \param other The unique_ptr to take ownership from
template<typename DerivedT> requires(is_base_of_v<TypeT, DerivedT>)
constexpr unique_ptr(unique_ptr<DerivedT>&& other)
: _handle(other.release()) {
}
// Delete copy constructor
constexpr unique_ptr(const unique_ptr&) = delete;
@@ -225,6 +232,11 @@ unique_ptr<TypeT> make_unique(ArgsT&&...args) {
return unique_ptr<TypeT>(new TypeT(fennec::forward<ArgsT>(args)...));
}
template<typename TypeT>
unique_ptr<TypeT> make_unique(TypeT* ptr) {
return unique_ptr<TypeT>(ptr);
}
}
#endif // FENNEC_MEMORY_POINTERS_H

7
include/fennec/string/cstring.h
View File

@@ -81,9 +81,10 @@ public:
}
///
/// \brief Buffer Constructor, wraps the provided C-Style string
/// \param str the buffer to wrap
/// \param n the number of characters in the buffer plus the null terminator
///
/// \note If used with `::strlen`, the result should be incremented by 1 to include the null terminator
constexpr cstring(char* str, size_t n)
: _str(str)
, _size(n - 1)
@@ -94,7 +95,6 @@ public:
}
///
/// \brief Buffer Constructor, wraps the provided C-Style string
/// \param str the buffer to wrap
/// \tparam n the number of characters in the buffer plus the null terminator
template<size_t n>
@@ -108,9 +108,10 @@ public:
}
///
/// \brief Const Buffer Constructor, wraps the provided C-Style string
/// \param str the buffer to wrap
/// \param n the number of characters in the buffer plus the null terminator
///
/// \note If used with `::strlen`, the result should be incremented by 1 to include the null terminator
constexpr cstring(const char* str, size_t n)
: _cstr(str)
, _size(n - 1)

49
source/core/event.cpp
View File

@@ -19,14 +19,41 @@
#include <fennec/containers/dynarray.h>
#include <fennec/containers/set.h>
#include <fennec/core/event.h>
#include <fennec/threading/lock_guard.h>
#include <fennec/threading/mpscq.h>
#include <fennec/threading/mutex.h>
#define FENNEC_EVENT_QUEUE_SIZE 8192
namespace fennec
{
static mutex lock;
static dynarray<set<event_listener*>> listeners;
static mpscq<event> queue(FENNEC_EVENT_QUEUE_SIZE);
void event::handle_events() {
lock_guard guard(lock);
// if we don't copy into a temporary buffer, we could deadlock ourselves
// if someone unwittingly calls dispatch() in an event listener.
dynarray<unique_ptr<event>> dispatch(FENNEC_EVENT_QUEUE_SIZE);
// we query the size instead of empty just in case someone decides to run their own thread
// and send events from that thread.
size_t n = queue.size();
for (size_t i = 0; i < n; ++i) {
dispatch[i] = queue.pop();
}
for (size_t i = 0; i < n; ++i) {
_handle_event(dispatch[i]);
}
}
void event::_add_listener(event_listener* listener, uint64_t type) {
lock_guard guard(lock);
void event::add_listener(event_listener* listener, uint64_t type) {
if (listeners.size() <= type) {
listeners.resize(type + 1);
}
@@ -34,9 +61,29 @@ void event::add_listener(event_listener* listener, uint64_t type) {
}
void event::remove_listener(event_listener* listener) {
lock_guard guard(lock);
for (auto& it : listeners) {
it.erase(listener);
}
}
void event::_handle_event(unique_ptr<event>& event) {
auto type = event->get_type().id();
for (auto& listener : listeners[type]) {
listener->handle_event(event.get());
}
}
void event::_dispatch(unique_ptr<event>&& event) {
// queue is taking ownership of the resource
queue.emplace(event.release());
}
void event::_dispatch_immediate(unique_ptr<event>&& event) {
lock_guard guard(lock);
_handle_event(event);
}
}

15
source/debug/assert_impl.cpp
View File

@@ -16,17 +16,24 @@
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
#include <stdio.h>
#include <fennec/core/logger.h>
#include <cpptrace/cpptrace.hpp>
void _assert_callback(const char* expression, const char* file, int line, const char* function, const char* description)
void _assert_callback(const fennec::cstring& expr, const fennec::cstring& file, int line, const fennec::cstring& func, const fennec::cstring& desc)
{
// Skip
// __assert_callback
// __assert_impl
printf("Assert failed: \"%s\" \n"
fennec::logger::log(fennec::format(""
"Assert failed: \"{}\" \n"
"At {}:{} in {} \n"
"Description: {} \n"
"Stacktrace: \n",
expr, file, line, func, desc
));
/*printf("Assert failed: \"%s\" \n"
"At %s:%d in %s \n"
"Description: %s \n",
expression, file, line, function, description);
expression, file, line, function, description);*/
cpptrace::generate_trace(2).print();
}

15
source/lang/assert.cpp
View File

@@ -17,12 +17,21 @@
// =====================================================================================================================
#include <fennec/lang/detail/_stdlib.h>
#include <fennec/string/cstring.h>
void _assert_callback(const char* expression, const char* file, int line, const char* function, const char* description);
void _assert_callback(const fennec::cstring& expr, const fennec::cstring& file, int line, const fennec::cstring& func, const fennec::cstring& desc);
void _assert_impl(const char* expression, const char* file, int line, const char* function, const char* description, bool halt)
void _assert_impl(const char* expr, size_t expr_l,
const char* file, size_t file_l, int line,
const char* func, size_t func_l,
const char* desc, bool halt)
{
_assert_callback(expression, file, line, function, description);
_assert_callback(
fennec::cstring(expr, expr_l),
fennec::cstring(file, file_l), line,
fennec::cstring(func, func_l),
fennec::cstring(desc, ::strlen(desc) + 1)
);
if (halt) {
::abort();

25
source/platform/window_manager.cpp
View File

@@ -70,6 +70,7 @@ void window_manager::shutdown() {
}
assertf(_thread == thread::current(), "Attempted to shutdown Window Manager on a different thread!");
lock_guard guard(_lock);
// Cleanup Windows
for (auto& window : _windows) {
@@ -84,31 +85,47 @@ void window_manager::shutdown() {
}
void window_manager::dispatch() {
assertf(_thread == thread::current(), "Attempted to dispatch Window Manager on a different thread!");
if (not _display) {
return;
}
assertf(_thread == thread::current(), "Attempted to dispatch Window Manager on a different thread!");
lock_guard guard(_lock);
_display->dispatch();
}
window_manager::window_id window_manager::create_window(const window::config& config, window_id parent) {
assertf(_thread == thread::current(), "Attempted to create a window on a different thread!");
if (not _display) {
return nullid;
}
assertf(_thread == thread::current(), "Attempted to create a window on a different thread!");
lock_guard guard(_lock);
window* p = parent == nullid ? nullptr : _windows[parent].get();
return _windows.emplace(_display->create_window(config, p));
}
void window_manager::begin(window_id window) {
assertf(_thread == thread::current(), "Attempted to set window context on a different thread!");
if (not _display) {
return;
}
assertf(_thread == thread::current(), "Attempted to set window context on a different thread!");
lock_guard guard(_lock);
_windows[window]->begin_frame();
}
void window_manager::end(window_id window) {
assertf(_thread == thread::current(), "Attempted to set window context on a different thread!");
if (not _display) {
return;
}
assertf(_thread == thread::current(), "Attempted to set window context on a different thread!");
lock_guard guard(_lock);
_windows[window]->end_frame();
}
} // fennec

2
test/CMakeLists.txt
View File

@@ -9,6 +9,8 @@ add_executable(fennec-test
tests/lang/test_metaprogramming.h
tests/lang/test_function.h
tests/test_threading.h
tests/test_core.h
tests/core/test_event.h
)
target_compile_definitions(fennec-test PUBLIC FENNEC_TEST_CWD="${CMAKE_SOURCE_DIR}/bin/${FENNEC_BUILD_NAME}"

6
test/main.cpp
View File

@@ -22,6 +22,7 @@
#include "test.h"
#include "tests/test_containers.h"
#include "tests/test_core.h"
#include "tests/test_string.h"
#include "tests/test_format.h"
#include "tests/test_filesystem.h"
@@ -77,6 +78,11 @@ int main(int, char **)
fennec::test::fennec_test_rtti();
fennec_test_spacer(3);
fennec_test_header("core library");
fennec_test_spacer(2);
fennec::test::fennec_test_core();
fennec_test_spacer(3);
fennec_test_header("platform library");
fennec_test_spacer(2);
fennec::test::fennec_test_platform();

76
test/tests/core/test_event.h Normal file
View File

@@ -0,0 +1,76 @@
// =====================================================================================================================
// fennec, a free and open source game engine
// Copyright © 2025 Medusa Slockbower
//
// 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 <https://www.gnu.org/licenses/>.
// =====================================================================================================================
///
/// \file test_event.h
/// \brief
///
///
/// \details
/// \author Medusa Slockbower
///
/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
///
///
#ifndef FENNEC_TEST_CORE_EVENT_H
#define FENNEC_TEST_CORE_EVENT_H
#include "../../test.h"
#include <fennec/core/event.h>
namespace fennec::test
{
struct test_event : public event {
FENNEC_RTTI_CLASS_ENABLE(event) {
}
};
struct test_listener : public event_listener {
bool handled = { false };
void handle_event(event* event) override {
handled = true;
fennec_test_run(event->get_type(), type::get<test_event>());
}
FENNEC_RTTI_CLASS_ENABLE(event_listener) {
}
};
inline void fennec_test_core_event() {
test_listener listener;
event::add_listener<test_event>(&listener);
event::dispatch<test_event>();
event::handle_events();
fennec_test_run(listener.handled, true);
listener.handled = false;
event::dispatch_immediate<test_event>();
fennec_test_run(listener.handled, true);
}
}
#endif // FENNEC_TEST_CORE_EVENT_H

52
test/tests/test_core.h Normal file
View File

@@ -0,0 +1,52 @@
// =====================================================================================================================
// fennec, a free and open source game engine
// Copyright © 2025 Medusa Slockbower
//
// 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 <https://www.gnu.org/licenses/>.
// =====================================================================================================================
///
/// \file test_core.h
/// \brief
///
///
/// \details
/// \author Medusa Slockbower
///
/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
///
///
#ifndef FENNEC_TEST_CORE_H
#define FENNEC_TEST_CORE_H
#include "../test.h"
#include "core/test_event.h"
namespace fennec::test
{
inline void fennec_test_core() {
fennec_test_subheader("events");
fennec_test_spacer(2);
fennec_test_core_event();
fennec_test_spacer(3);
}
}
#endif // FENNEC_TEST_CORE_H