Initial commit

Author: Saalvage

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

.gitignore

@@ -0,0 +1,13 @@
+CMakeLists.txt.user
+CMakeCache.txt
+CMakeFiles
+CMakeScripts
+Testing
+Makefile
+cmake_install.cmake
+install_manifest.txt
+compile_commands.json
+CTestTestfile.cmake
+_deps
+.vs/
+out/

CMakeLists.txt

@@ -0,0 +1,15 @@
+# CMakeList.txt : Top-level CMake project file, do global configuration
+# and include sub-projects here.
+#
+cmake_minimum_required (VERSION 3.8)
+
+# Enable Hot Reload for MSVC compilers if supported.
+if (POLICY CMP0141)
+  cmake_policy(SET CMP0141 NEW)
+  set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "$<IF:$<AND:$<C_COMPILER_ID:MSVC>,$<CXX_COMPILER_ID:MSVC>>,$<$<CONFIG:Debug,RelWithDebInfo>:EditAndContinue>,$<$<CONFIG:Debug,RelWithDebInfo>:ProgramDatabase>>")
+endif()
+
+project ("relaxed_concurrent_fifo")
+
+# Include sub-projects.
+add_subdirectory ("relaxed_concurrent_fifo")

CMakePresets.json

@@ -0,0 +1,61 @@
+{
+    "version": 3,
+    "configurePresets": [
+        {
+            "name": "windows-base",
+            "hidden": true,
+            "generator": "Ninja",
+            "binaryDir": "${sourceDir}/out/build/${presetName}",
+            "installDir": "${sourceDir}/out/install/${presetName}",
+            "cacheVariables": {
+                "CMAKE_C_COMPILER": "cl.exe",
+                "CMAKE_CXX_COMPILER": "cl.exe"
+            },
+            "condition": {
+                "type": "equals",
+                "lhs": "${hostSystemName}",
+                "rhs": "Windows"
+            }
+        },
+        {
+            "name": "x64-debug",
+            "displayName": "x64 Debug",
+            "inherits": "windows-base",
+            "architecture": {
+                "value": "x64",
+                "strategy": "external"
+            },
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Debug"
+            }
+        },
+        {
+            "name": "x64-release",
+            "displayName": "x64 Release",
+            "inherits": "x64-debug",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Release"
+            }
+        },
+        {
+            "name": "x86-debug",
+            "displayName": "x86 Debug",
+            "inherits": "windows-base",
+            "architecture": {
+                "value": "x86",
+                "strategy": "external"
+            },
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Debug"
+            }
+        },
+        {
+            "name": "x86-release",
+            "displayName": "x86 Release",
+            "inherits": "x86-debug",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Release"
+            }
+        }
+    ]
+}

relaxed_concurrent_fifo/CMakeLists.txt

@@ -0,0 +1,12 @@
+# CMakeList.txt : CMake project for relaxed_concurrent_fifo, include source and define
+# project specific logic here.
+#
+
+# Add source to this project's executable.
+add_executable (relaxed_concurrent_fifo "relaxed_concurrent_fifo.cpp" "relaxed_concurrent_fifo.h")
+
+if (CMAKE_VERSION VERSION_GREATER 3.12)
+  set_property(TARGET relaxed_concurrent_fifo PROPERTY CXX_STANDARD 20)
+endif()
+
+# TODO: Add tests and install targets if needed.

relaxed_concurrent_fifo/relaxed_concurrent_fifo.cpp

@@ -0,0 +1,52 @@
+#include "relaxed_concurrent_fifo.h"
+
+#include <ranges>
+#include <cassert>
+
+static constexpr int COUNT = 512;
+
+template <template <typename, size_t> typename T>
+void test_full_capacity() {
+	T<int, COUNT + 1> buf;
+	for (int i : std::views::iota(0, COUNT)) {
+		buf.push(i);
+	}
+	for (int i : std::views::iota(0, COUNT)) {
+		assert(buf.pop() == i);
+	}
+}
+
+template <template <typename, size_t> typename T>
+void test_single_element() {
+	T<int, COUNT + 1> buf;
+	for (int i : std::views::iota(0, COUNT * 10)) {
+		buf.push(i);
+		assert(buf.pop() == i);
+	}
+}
+
+template <template <typename, size_t> typename T>
+void test_empty_pop() {
+	T<int, COUNT + 1> buf;
+	assert(!buf.pop().has_value());
+	buf.push(1);
+	buf.pop();
+	assert(!buf.pop().has_value());
+	for (int i : std::views::iota(0, COUNT * 10)) {
+		buf.push(i);
+		buf.pop();
+	}
+	assert(!buf.pop().has_value());
+}
+
+template <template <typename, size_t> typename T>
+void test_all() {
+	test_full_capacity<T>();
+	test_single_element<T>();
+	test_empty_pop<T>();
+}
+
+int main() {
+	test_all<circular_buffer>();
+	return 0;
+}

relaxed_concurrent_fifo/relaxed_concurrent_fifo.h

@@ -0,0 +1,37 @@
+#ifndef RELAXED_CONCURRENT_FIFO_H_INCLUDED
+#define RELAXED_CONCURRENT_FIFO_H_INCLUDED
+
+#include <utility>
+#include <optional>
+
+// TODO: How should a full queue be handled?
+// Currently popping from a full queue is not possible.
+template <typename T, size_t SIZE>
+class circular_buffer {
+private:
+	T buffer[SIZE];
+
+	size_t head = 0;
+	size_t tail = 0;
+
+	inline size_t next(size_t curr) {
+		return (curr + 1) % SIZE;
+	}
+
+public:
+	void push(T t) {
+		head = next(head);
+		buffer[head] = std::move(t);
+	}
+
+	std::optional<T> pop() {
+		if (head == tail) {
+			return std::nullopt;
+		}
+
+		tail = next(tail);
+		return std::move(buffer[tail]);
+	}
+};
+
+#endif // RELAXED_CONCURRENT_FIFO_H_INCLUDED