symbol server abstraction layer; http layer; fix to 'prefer_disasm' rule when no disassembly tabs are open; small fixes / cleanup

src/base/base_core.c

@@ -623,10 +623,10 @@ date_time_from_unix_time(U64 unix_time)
 }
 
 ////////////////////////////////
-//~ rjf: Non-Fancy Ring Buffer Reads/Writes
+//~ rjf: Wrapped Ring Buffer Reads/Writes
 
 internal U64
-ring_write(U8 *ring_base, U64 ring_size, U64 ring_pos, void *src_data, U64 src_data_size)
+wrapped_write(U8 *ring_base, U64 ring_size, U64 ring_pos, void *src_data, U64 src_data_size)
 {
   Assert(src_data_size <= ring_size);
   {
@@ -643,7 +643,7 @@ ring_write(U8 *ring_base, U64 ring_size, U64 ring_pos, void *src_data, U64 src_d
 }
 
 internal U64
-ring_read(U8 *ring_base, U64 ring_size, U64 ring_pos, void *dst_data, U64 read_size)
+wrapped_read(U8 *ring_base, U64 ring_size, U64 ring_pos, void *dst_data, U64 read_size)
 {
   Assert(read_size <= ring_size);
   {

src/base/base_core.h

@@ -1107,12 +1107,12 @@ internal void sleep_ms(U32 ms);
 internal Guid make_guid(void);
 
 ////////////////////////////////
-//~ rjf: Non-Fancy Ring Buffer Reads/Writes
+//~ rjf: Wrapped Ring Buffer Reads/Writes
 
-internal U64 ring_write(U8 *ring_base, U64 ring_size, U64 ring_pos, void *src_data, U64 src_data_size);
-internal U64 ring_read(U8 *ring_base, U64 ring_size, U64 ring_pos, void *dst_data, U64 read_size);
-#define ring_write_struct(ring_base, ring_size, ring_pos, ptr) ring_write((ring_base), (ring_size), (ring_pos), (ptr), sizeof(*(ptr)))
-#define ring_read_struct(ring_base, ring_size, ring_pos, ptr) ring_read((ring_base), (ring_size), (ring_pos), (ptr), sizeof(*(ptr)))
+internal U64 wrapped_write(U8 *ring_base, U64 ring_size, U64 ring_pos, void *src_data, U64 src_data_size);
+internal U64 wrapped_read(U8 *ring_base, U64 ring_size, U64 ring_pos, void *dst_data, U64 read_size);
+#define wrapped_write_struct(ring_base, ring_size, ring_pos, ptr) wrapped_write((ring_base), (ring_size), (ring_pos), (ptr), sizeof(*(ptr)))
+#define wrapped_read_struct(ring_base, ring_size, ring_pos, ptr) wrapped_read((ring_base), (ring_size), (ring_pos), (ptr), sizeof(*(ptr)))
 
 ////////////////////////////////
 //~ rjf: Sorts

src/base/base_entry_point.c

@@ -58,6 +58,12 @@ main_thread_base_entry_point(int arguments_count, char **arguments)
   }
   
   //- rjf: initialize all included layers
+#if defined(HTTP_H) && !defined(HTTP_INIT_MANUAL)
+  http_init();
+#endif
+#if defined(SYMBOL_SERVER_H) && !defined(SMSV_INIT_MANUAL)
+  smsv_init();
+#endif
 #if defined(ARTIFACT_CACHE_H) && !defined(AC_INIT_MANUAL)
   ac_init();
 #endif
@@ -215,6 +221,9 @@ async_thread_entry_point(void *params)
 #if defined(FILE_STREAM_H)
       fs_async_tick();
 #endif
+#if defined(HTTP_H)
+      http_async_tick();
+#endif
 #if defined(DBG_INFO_H)
       di_async_tick();
 #endif

src/base/base_files.c

@@ -78,7 +78,7 @@ write_data_list_to_file_path(String8 path, String8List list)
           else
           {
             U64 bytes_to_copy = Min(write_buffer_available_size, n->string.size - n_off);
-            write_buffer_write_pos += ring_write(write_buffer, write_buffer_size, write_buffer_write_pos, n->string.str + n_off, bytes_to_copy);
+            write_buffer_write_pos += wrapped_write(write_buffer, write_buffer_size, write_buffer_write_pos, n->string.str + n_off, bytes_to_copy);
             n_off += bytes_to_copy;
           }
         }

src/base/base_inc.c

@@ -17,6 +17,7 @@
 #include "base_hash.c"
 #include "base_system.c"
 #include "base_threads.c"
+#include "base_ring.c"
 #include "base_thread_context.c"
 #include "base_files.c"
 #include "base_shared_memory.c"

src/base/base_inc.h

@@ -19,6 +19,7 @@
 #include "base_hash.h"
 #include "base_system.h"
 #include "base_threads.h"
+#include "base_ring.h"
 #include "base_thread_context.h"
 #include "base_files.h"
 #include "base_shared_memory.h"

src/base/base_processes.h

@@ -15,7 +15,6 @@ struct ProcessInfo
   String8 user_program_config_data_path;
   String8 user_program_cache_data_path;
   String8 user_program_logs_data_path;
-  String8 symbol_cache_path;
   String8List module_load_paths;
   String8List environment;
 };

src/base/base_ring.c

@@ -0,0 +1,135 @@
+// Copyright (c) Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+////////////////////////////////
+//~ rjf: Ring Functions
+
+internal Ring *
+make_ring(Arena *arena, U64 size)
+{
+  Ring *ring = push_array(arena, Ring, 1);
+  ring->size = size;
+  ring->base = push_array(arena, U8, ring->size);
+  return ring;
+}
+
+internal B32
+ring_try_write(Ring *ring, U64 size, void *ptr)
+{
+  U64 bytes_unconsumed = (ring->write_pos - ring->read_pos);
+  U64 bytes_available = ring->size - bytes_unconsumed;
+  B32 result = 0;
+  if(bytes_available >= size)
+  {
+    result = 1;
+    ring->write_pos += wrapped_write(ring->base, ring->size, ring->write_pos, ptr, size);
+  }
+  return result;
+}
+
+internal B32
+ring_try_read(Ring *ring, U64 size, void *ptr)
+{
+  U64 bytes_unconsumed = (ring->write_pos - ring->read_pos);
+  B32 result = 0;
+  if(bytes_unconsumed >= size)
+  {
+    result = 1;
+    ring->read_pos += wrapped_read(ring->base, ring->size, ring->read_pos, ptr, size);
+  }
+  return result;
+}
+
+////////////////////////////////
+//~ rjf: Guarded Ring Functions
+
+internal GuardedRing *
+guarded_ring_alloc(Arena *arena, U64 size)
+{
+  GuardedRing *gr = push_array(arena, GuardedRing, 1);
+  gr->ring = make_ring(arena, size);
+  gr->mutex = mutex_alloc();
+  gr->cv = cond_var_alloc();
+  return gr;
+}
+
+internal void
+guarded_ring_release(GuardedRing *ring)
+{
+  mutex_release(ring->mutex);
+  cond_var_release(ring->cv);
+}
+
+internal RingGuard
+guarded_ring_open(GuardedRing *ring)
+{
+  RingGuard guard = {ring};
+  mutex_take(ring->mutex);
+  return guard;
+}
+
+internal void
+guarded_ring_close(RingGuard *guard)
+{
+  mutex_drop(guard->r->mutex);
+}
+
+internal B32
+guarded_ring_try_write(RingGuard *guard, U64 size, void *ptr)
+{
+  B32 result = ring_try_write(guard->r->ring, size, ptr);
+  if(result)
+  {
+    cond_var_broadcast(guard->r->cv);
+  }
+  return result;
+}
+
+internal B32
+guarded_ring_try_read(RingGuard *guard, U64 size, void *ptr)
+{
+  B32 result = ring_try_read(guard->r->ring, size, ptr);
+  if(result)
+  {
+    cond_var_broadcast(guard->r->cv);
+  }
+  return result;
+}
+
+internal B32
+guarded_ring_write_or_wait(RingGuard *guard, U64 size, void *ptr, U64 endt_us)
+{
+  B32 write_good = 0;
+  for(;!write_good;)
+  {
+    write_good = guarded_ring_try_write(guard, size, ptr);
+    if(now_time_us() >= endt_us)
+    {
+      break;
+    }
+    if(!write_good)
+    {
+      cond_var_wait(guard->r->cv, guard->r->mutex, endt_us);
+    }
+  }
+  return write_good;
+}
+
+internal B32
+guarded_ring_read_or_wait(RingGuard *guard, U64 size, void *ptr, U64 endt_us)
+{
+  B32 read_good = 0;
+  for(;!read_good;)
+  {
+    read_good = guarded_ring_try_read(guard, size, ptr);
+    if(now_time_us() >= endt_us)
+    {
+      break;
+    }
+    if(!read_good)
+    {
+      cond_var_wait(guard->r->cv, guard->r->mutex, endt_us);
+    }
+  }
+  return read_good;
+}

src/base/base_ring.h

@@ -0,0 +1,56 @@
+// Copyright (c) Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+#ifndef BASE_RING_H
+#define BASE_RING_H
+
+typedef struct Ring Ring;
+struct Ring
+{
+  U8 *base;
+  U64 size;
+  U64 write_pos;
+  U64 read_pos;
+};
+
+typedef struct GuardedRing GuardedRing;
+struct GuardedRing
+{
+  Ring *ring;
+  Mutex mutex;
+  CondVar cv;
+};
+
+typedef struct RingGuard RingGuard;
+struct RingGuard
+{
+  GuardedRing *r;
+};
+
+////////////////////////////////
+//~ rjf: Ring Functions
+
+internal Ring *make_ring(Arena *arena, U64 size);
+internal B32 ring_try_write(Ring *ring, U64 size, void *ptr);
+internal B32 ring_try_read(Ring *ring, U64 size, void *ptr);
+#define ring_try_write_struct(ring, ptr) ring_try_write((ring), sizeof(*(ptr)), (ptr))
+#define ring_try_read_struct(ring, ptr) ring_try_read((ring), sizeof(*(ptr)), (ptr))
+
+////////////////////////////////
+//~ rjf: Guarded Ring Functions
+
+internal GuardedRing *guarded_ring_alloc(Arena *arena, U64 size);
+internal void guarded_ring_release(GuardedRing *ring);
+internal RingGuard guarded_ring_open(GuardedRing *ring);
+internal void guarded_ring_close(RingGuard *guard);
+internal B32 guarded_ring_try_write(RingGuard *guard, U64 size, void *ptr);
+internal B32 guarded_ring_try_read(RingGuard *guard, U64 size, void *ptr);
+#define guarded_ring_try_write_struct(ring, ptr) guarded_ring_try_write((ring), sizeof(*(ptr)), (ptr))
+#define guarded_ring_try_read_struct(ring, ptr) guarded_ring_try_read((ring), sizeof(*(ptr)), (ptr))
+internal B32 guarded_ring_write_or_wait(RingGuard *guard, U64 size, void *ptr, U64 endt_us);
+internal B32 guarded_ring_read_or_wait(RingGuard *guard, U64 size, void *ptr, U64 endt_us);
+#define guarded_ring_write_struct_or_wait(ring, ptr, endt_us) guarded_ring_write_or_wait((ring), sizeof(*(ptr)), (ptr), (endt_us))
+#define guarded_ring_read_struct_or_wait(ring, ptr, endt_us) guarded_ring_read_or_wait((ring), sizeof(*(ptr)), (ptr), (endt_us))
+#define guarded_ring_write_string_or_wait(ring, string, endt_us) guarded_ring_write_or_wait((ring), (string).size, (string).str, (endt_us))
+
+#endif // BASE_RING_H