Update README.md

.gitignore

@@ -7,3 +7,5 @@ raylib-build
 *_stats
 *.data
 *.ods
+*.dSYM
+*.out

.gitmodules

@@ -1,6 +1,6 @@
 [submodule "wapp"]
 	path = wapp
-	url = git@git.thewizardapprentice.com:abdelrahman/wizapp-stdlib
+	url = https://git.thewizardapprentice.com/abdelrahman/wizapp-stdlib
 [submodule "raylib-src"]
 	path = raylib-src
-	url = git@github.com:raysan5/raylib
+	url = https://github.com/raysan5/raylib

Makefile

@@ -1,15 +1,30 @@
 CC            = clang
 CFLAGS        = -g -O3 -Iraylib/include -Iwapp/src
-LDFLAGS    = '-Wl,-rpath,$$ORIGIN/raylib/lib' -Lraylib/lib -lraylib
+LDFLAGS       = '-Wl,-rpath,$$ORIGIN/raylib/lib' -Lraylib/lib -lraylib -lm -lpthread
+BASEDIR       = $(shell realpath ./)
+RL_SRCDIR     = ${BASEDIR}/raylib-src/src
+RL_BUILDDIR   = ${BASEDIR}/raylib-build
+RL_DESTDIR    = ${BASEDIR}/raylib
+RL_LIBDIR     = ${RL_DESTDIR}/lib
+RL_INCLUDEDIR = ${RL_DESTDIR}/include
+PLATFORM      = $(shell uname)
 
-.PHONY: all raylib wapp no_dod dod
+.PHONY: all raylib wapp no_dod dod clean
 
 all: no_dod dod
 
 raylib:
+ifeq ($(PLATFORM), Linux)
 	cmake -S raylib-src -B raylib-build -DCMAKE_INSTALL_PREFIX=raylib -DCMAKE_CONFIGURATION_TYPES=Release -DBUILD_SHARED_LIBS=ON -G "Ninja Multi-Config"
 	cmake --build raylib-build --config=Release
 	cmake --install raylib-build --config=Release
+else
+	mkdir -p ${RL_BUILDDIR} ${RL_LIBDIR} ${RL_INCLUDEDIR}
+	cd ${RL_SRCDIR} && \
+		make PLATFORM=PLATFORM_DESKTOP RAYLIB_RELEASE_PATH=${RL_BUILDDIR} RAYLIB_LIBTYPE=SHARED && \
+		cp ${RL_BUILDDIR}/* ${RL_LIBDIR} && \
+		cp ${RL_SRCDIR}/*.h ${RL_INCLUDEDIR}
+endif
 
 wapp:
 	cd wapp && python3 -m codegen
@@ -19,3 +34,6 @@ no_dod: raylib wapp
 
 dod: raylib wapp
 	$(CC) $(CFLAGS) $(LDFLAGS) dod.c wapp/src/wapp.c -o dod
+
+clean:
+	rm -rf ${RL_BUILDDIR} ${RL_DESTDIR}

README.md

@@ -0,0 +1,3 @@
+# Data-Oriented Design Test
+
+Playing around with [DOD](https://en.wikipedia.org/wiki/Data-oriented_design) concepts and comparing performance of resulting applications.

common.h

@@ -7,6 +7,8 @@
 #define MAX_WANDERER_DIM 8
 #define MIN_WANDERER_DIM 3
 #define MIN_ZONE_DIM 30
+#define MIN_ABS_VELOCITY 200
+#define MAX_ABS_VELOCITY 600
 #define BG_COLOR (Color){.r = 0xea, .g = 0xf2, .b = 0xe3, .a = 0xff}
 #define FG_COLOR (Color){.r = 0x42, .g = 0x4C, .b = 0x55, .a = 0xff}
 #define ZONE_COLOR (Color){.r = 0xb4, .g = 0x65, .b = 0x4a, .a = 0xff}
@@ -15,6 +17,7 @@
 #define WANDERER_SLOWDOWN_FACTOR 0.5f
 #define WANDERER_SPEEDUP_FACTOR 2.0f
 #define MSG_BUF_LEN 4096
+
 #define abs(A) (A < 0 ? A * -1 : A)
 #define min(A, B) (A < B ? A : B)
 #define max(A, B) (A > B ? A : B)

dod.c

@@ -1,10 +1,14 @@
 #include "wapp.h"
 #include "common.h"
 #include "raylib.h"
+#include <math.h>
 #include <stdint.h>
 #include <stdbool.h>
 #include <assert.h>
 #include <string.h>
+#include <pthread.h>
+
+#define THREAD_COUNT 4
 
 #define MOVABLE_TAG_SHIFT     0
 #define RENDERABLE_TAG_SHIFT  1
@@ -20,19 +24,19 @@ enum EntityTag {
 
 typedef struct Entity Entity;
 struct Entity {
-  u16 id;
+  u32 id;
 };
 
 typedef struct Position Position;
 struct Position {
-  f32 x;
-  f32 y;
+  i16 x;
+  i16 y;
 };
 
 typedef struct Scale Scale;
 struct Scale {
-  f32 width;
-  f32 height;
+  i16 width;
+  i16 height;
 };
 
 typedef struct Rect Rect;
@@ -43,8 +47,8 @@ struct Rect {
 
 typedef struct Velocity Velocity;
 struct Velocity {
-  f32 x;
-  f32 y;
+  i16 x;
+  i16 y;
 };
 
 typedef struct Manager Manager;
@@ -56,6 +60,17 @@ struct Manager {
   u64      count;
 };
 
+typedef struct PositionThreadArgs PositionThreadArgs;
+struct PositionThreadArgs {
+  const Rect *zones;
+  Rect       *rects;
+  Velocity   *velocities;
+  u8         *tags;
+  u64        count;
+  f32        delta;
+};
+
+typedef void *(*PThreadRoutine)(void *);
 typedef void (*ScaleInitialiser)(Scale *scale, XOR256State *state);
 typedef void (*VelocityInitialiser)(Velocity *velocity, XOR256State *state);
 typedef void (*RaylibDrawRectFunc)(int posX, int posY, int width, int height, Color color);
@@ -66,15 +81,18 @@ void init_scale_wanderer(Scale *scale, XOR256State *state);
 void init_scale_zone(Scale *scale, XOR256State *state);
 void init_velocity(Velocity *velocity, XOR256State *state);
 void zero_velocity(Velocity *velocity, XOR256State *state);
-void update_positions(u8 *tags, Rect *rects, Velocity *velocities, u64 count);
+void update_positions(u8 *tags, Rect *rects, Velocity *velocities, u64 count, f32 delta);
+void *update_position_thread(PositionThreadArgs *args);
 void render_entities(const u8 *tags, const Rect *rects, u64 count);
-u64 collides(const Rect *rect, const Rect *collider);
-f32 get_random_float(XOR256State *state);
+u8 collides(const Rect *rect, const Rect *collider);
+i16 get_random_velocity(XOR256State *state);
 
 int main(void) {
+  i32 target_fps = 120;
+
   SetTraceLogLevel(LOG_NONE);
   InitWindow(WIDTH, HEIGHT, "DOD test");
-  // SetTargetFPS(120);
+  SetTargetFPS(target_fps);
 
   Allocator arena = wapp_mem_arena_allocator_init(MB(20));
   assert(!wapp_mem_allocator_invalid(&arena));
@@ -98,19 +116,25 @@ int main(void) {
     velocity_initialisers[is_zone](&(manager.velocities[i]), &state);
   }
 
+  f32 last_time = GetFrameTime();
+  f32 delta, cur_time;
+
   while (!WindowShouldClose()) {
     f64 time = GetTime();
     if (time >= 20.0) {
       break;
     }
 
-    update_positions(manager.tags, manager.rects, manager.velocities, manager.count);
+    cur_time = GetFrameTime();
+    delta    = cur_time - last_time;
+
+    update_positions(manager.tags, manager.rects, manager.velocities, manager.count, delta);
 
     BeginDrawing();
 
     ClearBackground(BG_COLOR);
 
-    // render_entities(manager.tags, manager.rects, manager.count);
+    render_entities(manager.tags, manager.rects, manager.count);
 
     DrawFPS(10, 10);
 
@@ -128,6 +152,8 @@ void init_manager(const Allocator *allocator, Manager *manager) {
   assert(allocator != NULL && manager != NULL);
 
   u64 total_count = (u64)WANDERER_COUNT + (u64)ZONE_COUNT;
+  assert(total_count < (1lu << 32)); // Ensure we're not exceeding the maximum limit of entities
+
   u64 entities_size   = sizeof(Entity)   * total_count;
   u64 rects_size      = sizeof(Rect)     * total_count;
   u64 velocities_size = sizeof(Velocity) * total_count;
@@ -147,24 +173,24 @@ void init_manager(const Allocator *allocator, Manager *manager) {
 }
 
 void init_position(Position *position, XOR256State *state) {
-  position->x = wapp_prng_xorshift_256(state) % WIDTH;
-  position->y = wapp_prng_xorshift_256(state) % HEIGHT;
+  position->x = wapp_prng_xorshift_256ss(state) % WIDTH;
+  position->y = wapp_prng_xorshift_256ss(state) % HEIGHT;
 }
 
 void init_scale_wanderer(Scale *scale, XOR256State *state) {
-  f32 value = (f32)((wapp_prng_xorshift_256(state) % (MAX_WANDERER_DIM + 1 - MIN_WANDERER_DIM)) + MIN_WANDERER_DIM);
+  i16 value = (i16)((wapp_prng_xorshift_256p(state) % (MAX_WANDERER_DIM + 1 - MIN_WANDERER_DIM)) + MIN_WANDERER_DIM);
   scale->width  = value;
   scale->height = value;
 }
 
 void init_scale_zone(Scale *scale, XOR256State *state) {
-  scale->width  = wapp_prng_xorshift_256(state) % ((u64)HALF_WIDTH - MIN_ZONE_DIM) + MIN_ZONE_DIM;
-  scale->height = wapp_prng_xorshift_256(state) % ((u64)HALF_HEIGHT - MIN_ZONE_DIM) + MIN_ZONE_DIM;
+  scale->width  = wapp_prng_xorshift_256p(state) % ((u64)HALF_WIDTH  - MIN_ZONE_DIM) + MIN_ZONE_DIM;
+  scale->height = wapp_prng_xorshift_256p(state) % ((u64)HALF_HEIGHT - MIN_ZONE_DIM) + MIN_ZONE_DIM;
 }
 
 void init_velocity(Velocity *velocity, XOR256State *state) {
-  velocity->x = get_random_float(state);
-  velocity->y = get_random_float(state);
+  velocity->x = get_random_velocity(state);
+  velocity->y = get_random_velocity(state);
 }
 
 void zero_velocity(Velocity *velocity, XOR256State *state) {
@@ -172,35 +198,83 @@ void zero_velocity(Velocity *velocity, XOR256State *state) {
   velocity->y = 0.0f;
 }
 
-void update_positions(u8 *tags, Rect *rects, Velocity *velocities, u64 count) {
-  u8 index = 0;
-  f32 multipliers[2] = {1.0f, 0.5f};
+void update_positions(u8 *tags, Rect *rects, Velocity *velocities, u64 count, f32 delta) {
+  persistent pthread_t threads[THREAD_COUNT]       = {0};
+  persistent PositionThreadArgs args[THREAD_COUNT] = {0};
+
+  u64 total_entities_count  = count - ZONE_COUNT;
+  u64 thread_entities_count = (u64)(ceil((f64)total_entities_count / THREAD_COUNT));
+
+  i32 result;
+  u64 start = ZONE_COUNT;
+  u64 end, args_count;
+
+  for (u64 i = 0; i < THREAD_COUNT; ++i) {
+    if (total_entities_count > thread_entities_count) {
+      end = start + thread_entities_count;
+      total_entities_count -= thread_entities_count;
+    } else {
+      end = start + total_entities_count;
+      total_entities_count = 0;
+    }
+
+    args_count = end - start;
+
+    args[i].zones      = &(rects[0]);
+    args[i].tags       = &(tags[start]);
+    args[i].rects      = &(rects[start]);
+    args[i].velocities = &(velocities[start]);
+    args[i].count      = args_count;
+    args[i].delta      = delta;
+
+    start += args_count;
+
+    result = pthread_create(&(threads[i]), NULL, (PThreadRoutine)update_position_thread, (void *)&(args[i]));
+    assert(result == 0);
+  }
+
+  for (u64 i = 0; i < THREAD_COUNT; ++i) {
+    pthread_join(threads[i], NULL);
+  }
+}
+
+void *update_position_thread(PositionThreadArgs *args) {
+  persistent f32 multipliers[2] = {1.0f, 0.5f};
   persistent u64 inside_zone_mask = 0x7;
 
-  for (u64 i = ZONE_COUNT; i < count; ++i) {
-    tags[i] &= inside_zone_mask;
+  u8 index = 0;
+  f32 pos_x, pos_y;
+  f32 max_x, max_y;
+
+  for (u64 i = 0; i < args->count; ++i) {
+    args->tags[i] &= inside_zone_mask;
     for (u64 j = 0; j < ZONE_COUNT; ++j) {
-      tags[i] |= collides(&rects[i], &rects[j]) << INSIDE_ZONE_TAG_SHIFT;
+      args->tags[i] |= collides(&args->rects[i], &args->zones[j]) << INSIDE_ZONE_TAG_SHIFT;
     }
 
-    index = (tags[i] & ENTITY_TAG_INSIDE_ZONE) >> INSIDE_ZONE_TAG_SHIFT;
+    index = (args->tags[i] & ENTITY_TAG_INSIDE_ZONE) >> INSIDE_ZONE_TAG_SHIFT;
 
-    rects[i].position.x += velocities[i].x * multipliers[index];
-    rects[i].position.y += velocities[i].y * multipliers[index];
+    max_x = WIDTH - args->rects[i].scale.width;
+    max_y = HEIGHT - args->rects[i].scale.height;
 
-    f32 max_x = WIDTH - rects[i].scale.width;
-    f32 max_y = HEIGHT - rects[i].scale.height;
+    pos_x = args->rects[i].position.x + args->velocities[i].x * multipliers[index] * args->delta;
+    pos_y = args->rects[i].position.y + args->velocities[i].y * multipliers[index] * args->delta;
 
-    if (rects[i].position.x < 0 || rects[i].position.x >= max_x) {
-      rects[i].position.x = min(max(rects[i].position.x, 0), max_x);
-      velocities[i].x *= -1;
+    if (pos_x < 0 || pos_x >= max_x) {
+      pos_x = min(max(pos_x, 0), max_x);
+      args->velocities[i].x *= -1;
     }
 
-    if (rects[i].position.y < 0 || rects[i].position.y >= max_y) {
-      rects[i].position.y = min(max(rects[i].position.y, 0), max_y);
-      velocities[i].y *= -1;
+    if (pos_y < 0 || pos_y >= max_y) {
+      pos_y = min(max(pos_y, 0), max_y);
+      args->velocities[i].y *= -1;
     }
+
+    args->rects[i].position.x = roundf(pos_x);
+    args->rects[i].position.y = roundf(pos_y);
   }
+
+  return args;
 }
 
 void render_entities(const u8 *tags, const Rect *rects, u64 count) {
@@ -221,22 +295,21 @@ void render_entities(const u8 *tags, const Rect *rects, u64 count) {
   }
 }
 
-u64 collides(const Rect *rect, const Rect *collider) {
-  f32 rect_min_x = rect->position.x + rect->scale.width;
-  f32 rect_min_y = rect->position.y + rect->scale.height;
-  f32 rect_max_x = rect->position.x;
-  f32 rect_max_y = rect->position.y;
+u8 collides(const Rect *rect, const Rect *collider) {
+  i16 rect_min_x = rect->position.x + rect->scale.width;
+  i16 rect_min_y = rect->position.y + rect->scale.height;
+  i16 rect_max_x = rect->position.x;
+  i16 rect_max_y = rect->position.y;
 
-  f32 zone_x0 = collider->position.x;
-  f32 zone_y0 = collider->position.y;
-  f32 zone_x1 = collider->position.x + collider->scale.width;
-  f32 zone_y1 = collider->position.y + collider->scale.height;
+  i16 zone_x0 = collider->position.x;
+  i16 zone_y0 = collider->position.y;
+  i16 zone_x1 = collider->position.x + collider->scale.width;
+  i16 zone_y1 = collider->position.y + collider->scale.height;
 
-  return (u64)(rect_min_x > zone_x0 && rect_min_y > zone_y0 &&
+  return (u8)(rect_min_x > zone_x0 && rect_min_y > zone_y0 &&
           rect_max_x < zone_x1 && rect_max_y < zone_y1);
 }
 
-f32 get_random_float(XOR256State *state) {
-  i64 random = (i64)wapp_prng_xorshift_256(state) - INT64_MAX;
-  return (f32)(random) / (f32)(INT64_MAX);
+i16 get_random_velocity(XOR256State *state) {
+  return (wapp_prng_xorshift_256(state) % (MAX_ABS_VELOCITY + 1 - MIN_ABS_VELOCITY)) + MIN_ABS_VELOCITY;
 }

no_dod.c

@@ -50,7 +50,7 @@ f32 get_random_float(XOR256State *state);
 int main(void) {
   SetTraceLogLevel(LOG_NONE);
   InitWindow(WIDTH, HEIGHT, "No-DOD test");
-  // SetTargetFPS(120);
+  SetTargetFPS(120);
 
   Allocator arena       = wapp_mem_arena_allocator_init(MB(20));
   XOR256State state     = wapp_prng_xorshift_init_state();
@@ -84,13 +84,13 @@ int main(void) {
 
     ClearBackground(BG_COLOR);
 
-    // for (u64 i = 0; i < ZONE_COUNT; ++i) {
-    //   render_slow_zone(&(zones[i]));
-    // }
-    //
-    // for (u64 i = 0; i < WANDERER_COUNT; ++i) {
-    //   render_wanderer(&(wanderers[i]));
-    // }
+    for (u64 i = 0; i < ZONE_COUNT; ++i) {
+      render_slow_zone(&(zones[i]));
+    }
+
+    for (u64 i = 0; i < WANDERER_COUNT; ++i) {
+      render_wanderer(&(wanderers[i]));
+    }
 
     DrawFPS(10, 10);