Improve particle_engine performance

Introduced a profiling lib (from computerenhance). Profiled the particle
engine code in the update loop and implemented a more cpu-cache friendly
solution that doesn't rely on linked lists.

Author: LiquidityC

.gitignore

@@ -17,3 +17,4 @@
 /breakhack*.run
 /compile_commands.json
 /.cache
+/profile.txt

CMakeLists.txt

@@ -10,6 +10,7 @@ set(breakhack_GAME_TITLE "BreakHack")
 set(DISABLE_STEAM_BUILD OFF CACHE BOOL "Disable Steam build")
 set(RELEASE_TYPE "" CACHE STRING "Release type")
 set(STEAM_BUILD OFF CACHE STRING "Steam build")
+set(PROFILER OFF CACHE STRING "Enable profiler")
 
 # Checksums, Disabled until further notice
 # set(breakhack_STEAMAPI_DLL_CHECKSUM 0x1a4691a)
@@ -50,6 +51,9 @@ if (STEAM_BUILD)
 endif()
 add_subdirectory(lib/bh_random)
 add_subdirectory(lib/checksum)
+if (PROFILER)
+	add_subdirectory(lib/profiler)
+endif()
 
 if ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
 	set(CLANG 1)
@@ -216,6 +220,12 @@ add_subdirectory(lib/sqlite3)
 set_property(TARGET ${PROJECT_NAME} PROPERTY C_STANDARD 11)
 target_include_directories(${PROJECT_NAME} PRIVATE ${INCLUDE_DIRS})
 
+if (PROFILER)
+	add_definitions("-DPROFILER")
+	target_link_libraries(${PROJECT_NAME} profiler)
+	target_include_directories(${PROJECT_NAME} PRIVATE lib/profiler/include)
+endif ()
+
 if (NOT MSVC)
 	set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wall -Wextra -Wshadow -Wpointer-arith -Wcast-qual -Wstrict-prototypes -Wmissing-prototypes -Wconversion -Wno-sign-conversion")
 	if (NOT APPLE)

lib/profiler/CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.7)
+
+project(profiler LANGUAGES C VERSION 0.1.0)
+
+add_library(profiler
+	src/rdtsc.c
+	src/profiler.c
+	src/repetition_tester.c
+	src/perf.c
+	)
+
+target_include_directories(profiler
+	PUBLIC include
+	PRIVATE include/internal
+	)

lib/profiler/README.md

@@ -0,0 +1,71 @@
+# Benchmark
+
+A simple library to benchmark your code.
+
+## Compiling
+
+- `mkdir build`
+- `cd build`
+- `cmake ..`
+- `make`
+
+## Usage example
+
+```c
+#include <stdio.h>
+#include "benchmark.h"
+
+int main(int argc, char **argv)
+{
+    (void) argc;
+    (void) argv;
+
+    /* Create an initate the stopclock */
+    StopClock sclock;
+    sclock_init(&sclock);
+
+    sclock_start(&sclock);
+
+    /* Execute some code */
+
+    sclock_checkpoint(&sclock, "First part");
+
+    /* Execute some more code */
+
+    sclock_checkpoint(&sclock, "Second part");
+
+    /* Execute even more code */
+
+    sclock_checkpoint(&sclock, "Third part");
+
+    /* Stop the clock */
+    sclock_stop(&sclock);
+
+    /* Output the results */
+    sclock_print(&sclock, stdout);
+
+    /* Clean up */
+    sclock_destroy(&sclock);
+}
+```
+
+### Example output
+
+```
+         =====   Benchmarks :   =====
+                 First part : 5916119358   95.54%
+                Second part : 6940092       0.17%
+                 Third part : 265775256     4.29%
+             Remaining time : 3478810       0.00%
+```
+
+## How it works
+
+Under the hood `benchmark` is using the `RDTSC` assembly instruction to time
+things. During the `sclock_init` the number of pseudo clocks used in `RDTSC`
+occur in one second (over 300ms). This is a rough estimate but usually aligns
+well with the Ghz number specified on the running computers cpu.
+
+## API
+
+> TODO: Generate API and link to it here

lib/profiler/include/internal/common.h

@@ -0,0 +1,14 @@
+#ifndef COMMON_H_
+#define COMMON_H_
+
+#define C_RED       "\x1b[31m"
+#define C_GREEN     "\x1b[32m"
+#define C_YELLOW    "\x1b[33m"
+#define C_BLUE      "\x1b[34m"
+#define C_MAGENTA   "\x1b[35m"
+#define C_CYAN      "\x1b[36m"
+#define C_WHITE     "\x1b[37m"
+#define C_RESET     "\x1b[0m"
+
+#endif  // COMMON_H_
+

lib/profiler/include/internal/profiler_c.h

@@ -0,0 +1,46 @@
+#ifndef _STOP_CLOCK_H_
+#define _STOP_CLOCK_H_
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdio.h>
+
+#define ANCHOR_CAPACITY 4096
+
+typedef struct ProfileAnchor {
+    const char *label;
+    size_t hits;
+    uint64_t elapsed_exclusive;
+    uint64_t elapsed_inclusive;
+    size_t processed_byte_count;
+} ProfileAnchor;
+
+typedef struct Profiler {
+    uint64_t start, stop;
+    size_t len;
+    ProfileAnchor anchors[ANCHOR_CAPACITY];
+} Profiler;
+
+typedef struct AnchorBlock {
+    const char *label;
+    uint64_t start;
+    uint64_t old_elapsed_inclusive;
+    size_t processed_byte_count;
+    char *parent_anchor;
+} AnchorBlock;
+
+void prof_init(void);
+
+void prof_start(void);
+
+void prof_stop(void);
+
+void prof_add_anchor(const AnchorBlock *anchor, uint64_t elapsed);
+
+void prof_print(FILE *fp);
+
+AnchorBlock make_anchor_block(const char *label, size_t used_bytes);
+void read_anchor_block(const AnchorBlock *anchor);
+
+#endif // _STOP_CLOCK_H_
+

lib/profiler/include/macros.h

@@ -0,0 +1,47 @@
+#ifndef __MACROS_H_
+#define __MACROS_H_
+
+#include "internal/profiler_c.h"
+#include "rdtsc.h"
+
+#ifdef PROFILER
+
+#define PROFILER_SETUP() \
+    prof_start();
+
+#define PROFILER_STOP(fp) \
+    prof_stop(); \
+    prof_print(fp);
+
+#define _NameConcat(A, B) A##B
+#define NameConcat(A, B) _NameConcat(A, B)
+
+#define TIME_BANDWIDTH_BEGIN(label, bytes) \
+    AnchorBlock NameConcat(Block, label) = make_anchor_block(#label, bytes);
+
+#define TIME_BANDWIDTH_END(label) \
+    read_anchor_block( &Block##label );
+
+#define TIME_BLOCK_BEGIN(label) TIME_BANDWIDTH_BEGIN(label, 0)
+#define TIME_BLOCK_END(label) TIME_BANDWIDTH_END(label)
+
+#define TIME_FUNC_BEGIN() \
+    AnchorBlock NameConcat(Block, __func__) = make_anchor_block(__func__, 0);
+
+#define TIME_FUNC_END() \
+    read_anchor_block( &Block##__func__ );
+
+#else
+#define PROFILER_SETUP()
+#define PROFILER_STOP(fp)
+#define TIME_BLOCK_BEGIN(label)
+#define TIME_BLOCK_END(label)
+#define TIME_BANDWIDTH_BEGIN(label)
+#define TIME_BANDWIDTH_END(label)
+#define TIME_FUNC_BEGIN()
+#define TIME_FUNC_END()
+#endif
+
+
+#endif // __MACROS_H_
+

lib/profiler/include/perf.h

@@ -0,0 +1,15 @@
+#ifndef _PERF_H_
+#define _PERF_H_
+
+#include <stdint.h>
+
+void perf_setup(void);
+
+void perf_reset_page_fault_count(void);
+
+uint64_t perf_read_page_fault_count(void);
+
+void perf_close(void);
+
+#endif  // _PERF_H_
+

lib/profiler/include/profiler.h

@@ -0,0 +1,22 @@
+#ifndef _PROFILER_H_
+#define _PROFILER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef PROFILER
+
+#include "rdtsc.h"
+#include "internal/profiler_c.h"
+#include "macros.h"
+#include "perf.h"
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _PROFILER_H_
+

lib/profiler/include/rdtsc.h

@@ -0,0 +1,20 @@
+#ifndef _RDTSC_H_
+#define _RDTSC_H_
+
+#ifdef PROFILER
+
+#include <stdint.h>
+#include <stddef.h>
+
+uint64_t get_os_time_freq(void);
+
+uint64_t read_os_timer(void);
+
+uint64_t read_cpu_timer(void);
+
+uint64_t estimate_cpu_freq(uint64_t test_time);
+
+#endif
+
+#endif // _RDTSC_H_
+