ogl_beamforming

util.c (26922B)

---

 /* See LICENSE for license details. */
 #if   COMPILER_CLANG
   #pragma GCC diagnostic ignored "-Winitializer-overrides"
 #elif COMPILER_GCC
   #pragma GCC diagnostic ignored "-Woverride-init"
 #endif
 
 #define zero_struct(s) memory_clear((s), 0, sizeof(*(s)))
 function void *
 memory_clear(void *restrict p_, u8 c, u64 size)
 {
 	u8 *p = p_;
 	while (size > 0) p[--size] = c;
 	return p;
 }
 
 function b32
 memory_equal(void *restrict left, void *restrict right, u64 n)
 {
 	u8 *a = left, *b = right;
 	b32 result = 1;
 	for (; result && n; n--)
 		result &= *a++ == *b++;
 	return result;
 }
 
 function void
 memory_copy(void *restrict dest, const void *restrict src, u64 n)
 {
 	u8 *s = (u8 *)src, *d = dest;
 	#ifdef __AVX512BW__
 	{
 		for (; n >= 64; n -= 64, s += 64, d += 64)
 			_mm512_storeu_epi8(d, _mm512_loadu_epi8(s));
 		__mmask64 k = _cvtu64_mask64(_bzhi_u64(-1ULL, n));
 		_mm512_mask_storeu_epi8(d, k, _mm512_maskz_loadu_epi8(k, s));
 	}
 	#else
 		for (; n; n--) *d++ = *s++;
 	#endif
 }
 
 /* IMPORTANT: this function may fault if dest, src, and n are not multiples of 64 */
 function void
 memory_copy_non_temporal(void *restrict dest, void *restrict src, u64 n)
 {
 	assume(((u64)dest & 63) == 0);
 	assume(((u64)src  & 63) == 0);
 	assume(((u64)n    & 63) == 0);
 	u8 *s = src, *d = dest;
 
 	#if defined(__AVX512BW__)
 	{
 		for (; n >= 64; n -= 64, s += 64, d += 64)
 			_mm512_stream_si512((__m512i *)d, _mm512_stream_load_si512((__m512i *)s));
 	}
 	#elif defined(__AVX2__)
 	{
 		for (; n >= 32; n -= 32, s += 32, d += 32)
 			_mm256_stream_si256((__m256i *)d, _mm256_stream_load_si256((__m256i *)s));
 	}
 	#elif ARCH_ARM64 && !COMPILER_MSVC
 	{
 		asm volatile (
 			"cbz  %2, 2f\n"
 			"1: ldnp q0, q1, [%1]\n"
 			"subs %2, %2, #32\n"
 			"add  %1, %1, #32\n"
 			"stnp q0, q1, [%0]\n"
 			"add  %0, %0, #32\n"
 			"b.ne 1b\n"
 			"2:"
 			:  "+r"(d), "+r"(s), "+r"(n)
 			:: "memory", "v0", "v1"
 		);
 	}
 	#else
 		memory_copy(d, s, n);
 	#endif
 }
 
 function void
 memory_move(void *dest, void *src, u64 n)
 {
 	u8 *d = dest, *s = src;
 	if (d < s) memory_copy(d, s, n);
 	else            while (n) { n--; d[n] = s[n]; }
 }
 
 function void *
 memory_scan_backwards(void *memory, u8 byte, i64 n)
 {
 	void *result = 0;
 	u8   *s      = memory;
 	while (n > 0) if (s[--n] == byte) { result = s + n; break; }
 	return result;
 }
 
 /* NOTE(rnp): from Hacker's Delight */
 function force_inline u64
 round_down_power_of_two(u64 a)
 {
 	u64 result = 0x8000000000000000ULL >> clz_u64(a);
 	return result;
 }
 
 function force_inline u64
 round_up_power_of_two(u64 a)
 {
 	u64 result = 0x8000000000000000ULL >> (clz_u64(a - 1) - 1);
 	return result;
 }
 
 function force_inline i64
 round_up_to(i64 value, i64 multiple)
 {
 	i64 result = value;
 	if (value % multiple != 0)
 		result += multiple - value % multiple;
 	return result;
 }
 
 typedef enum {
 	ArenaAllocateFlags_NoZero = 1 << 0,
 } ArenaAllocateFlags;
 
 typedef struct {
 	i64 size;
 	u64 align;
 	i64 count;
 	ArenaAllocateFlags flags;
 } ArenaAllocateInfo;
 
 function u8 *
 arena_commit(Arena *a, i64 size)
 {
 	Arena *current = a->current;
 	assert(current->committed - current->position >= (u64)size);
 	u8 *result = (u8 *)current + current->position;
 	current->position += size;
 	return result;
 }
 
 #define arena_create(...) arena_create_((ArenaParameters){\
 	.reserve_size = MB(64),\
 	.commit_size  = KB(64),\
 	.flags        = 0,\
 	.allocation_site_file = __FILE__,\
 	.allocation_site_line = __LINE__,\
 	__VA_ARGS__})
 
 function Arena *
 arena_create_(ArenaParameters ap)
 {
 	void *base = ap.optional_backing_store;
 	if (base == 0) {
 		ap.commit_size  = round_up_to(ap.commit_size,  os_system_info()->page_size);
 		ap.reserve_size = round_up_to(ap.reserve_size, os_system_info()->page_size);
 
 		base = os_memory_reserve(ap.reserve_size);
 		os_memory_commit(base, ap.commit_size);
 	}
 
 	Arena *result     = base;
 	result->current   = result;
 	result->position  = sizeof(*result);
 	result->reserved  = ap.reserve_size;
 	result->committed = ap.commit_size;
 	result->flags     = ap.flags;
 
 	result->reserve_size = ap.reserve_size;
 	result->commit_size  = ap.commit_size;
 
 	result->name                 = ap.name;
 	result->allocation_site_file = ap.allocation_site_file;
 	result->allocation_site_line = ap.allocation_site_line;
 
 	return result;
 }
 
 function void
 arena_destroy(Arena *arena)
 {
 	for (Arena *a = arena->current, *prev = 0; a; a = prev) {
 		prev = a->prev;
 		os_memory_release(a, a->reserved);
 	}
 }
 
 #define arena_alloc(a, ...)              arena_alloc_(a, (ArenaAllocateInfo){.align = 8, .count = 1, __VA_ARGS__})
 #define push_array(a, t, n, ...)         (t *)arena_alloc(a, .size = sizeof(t), .align = alignof(t), .count = n, __VA_ARGS__)
 #define push_array_no_zero(a, t, n, ...) (t *)arena_alloc(a, .size = sizeof(t), .align = alignof(t), .count = n, .flags = ArenaAllocateFlags_NoZero, __VA_ARGS__)
 #define push_struct(a, t, ...)           push_array(a, t, 1, __VA_ARGS__)
 #define push_struct_no_zero(a, t, ...)   push_array_no_zero(a, t, 1, __VA_ARGS__)
 
 function void *
 arena_alloc_(Arena *arena, ArenaAllocateInfo info)
 {
 	Arena *current = arena->current;
 	u64 size          = info.count * info.size;
 	u64 pre_position  = AlignUpPowerOfTwo(current->position, info.align);
 	u64 post_position = pre_position + size;
 	u64 zero_size     = Min(current->committed, post_position) - pre_position;
 
 	if (current->reserved < post_position && (current->flags & ArenaFlag_NoChain) == 0) {
 		u64 reserve_size = current->reserve_size;
 		u64 commit_size  = current->commit_size;
 		if (size + AlignUpPowerOfTwo(sizeof(*arena), info.align) > reserve_size) {
 			reserve_size = size + AlignUpPowerOfTwo(sizeof(*arena), info.align);
 			commit_size  = size + AlignUpPowerOfTwo(sizeof(*arena), info.align);
 		}
 		Arena *new_arena = arena_create(.reserve_size         = reserve_size,
 		                                .commit_size          = commit_size,
 		                                .flags                = current->flags,
 		                                .allocation_site_file = current->allocation_site_file,
 		                                .allocation_site_line = current->allocation_site_line,
 		                                .name                 = current->name);
 		zero_size = 0;
 
 		new_arena->base_position = current->base_position + current->reserved;
 		SLLStackPush(arena->current, new_arena, prev);
 		current = new_arena;
 		pre_position  = AlignUpPowerOfTwo(current->position, info.align);
 		post_position = pre_position + size;
 	}
 
 	if (current->committed < post_position) {
 		u64 commit_post = post_position + current->commit_size - 1;
 		commit_post -= commit_post % current->commit_size;
 		commit_post  = Min(commit_post, current->reserved);
 		os_memory_commit((u8 *)current + current->committed, commit_post - current->committed);
 		current->committed = commit_post;
 	}
 
 	void *result = 0;
 	if (current->committed >= post_position) {
 		result = (u8 *)current + pre_position;
 		current->position = post_position;
 		if ((info.flags & ArenaAllocateFlags_NoZero) == 0)
 			result = memory_clear(result, 0, zero_size);
 	}
 
 	assert(result);
 
 	return result;
 }
 
 function u64
 arena_position(Arena *arena)
 {
 	Arena *current = arena->current;
 	u64 result = current->base_position + current->position;
 	return result;
 }
 
 function void
 arena_pop_to(Arena *arena, u64 position)
 {
 	position = Max(position, sizeof(*arena));
 	Arena *current = arena->current;
 	for (Arena *prev = 0; current->base_position >= position; current = prev) {
 		prev = current->prev;
 		os_memory_release(current, current->reserved);
 	}
 	arena->current = current;
 	u64 new_position = position - current->base_position;
 	assert(new_position <= current->position);
 	current->position = new_position;
 }
 
 function void
 arena_pop(Arena *arena, u64 size)
 {
 	u64 old_position = arena_position(arena);
 	u64 new_position = old_position;
 	if (size < old_position)
 		new_position = old_position - size;
 	arena_pop_to(arena, new_position);
 }
 
 function void
 arena_clear(Arena *arena)
 {
 	arena_pop_to(arena, 0);
 }
 
 function void
 arena_pre_align(Arena *arena, u64 align)
 {
 	assert(IsPowerOfTwo(align));
 	Arena *current = arena->current;
 	u8 *start = (u8 *)current + current->position;
 	u8 *desired_start = (u8 *)AlignUpPowerOfTwo((u64)start, align);
 	current->position += (u64)(desired_start - start);
 }
 
 function Temp
 temp_begin(Arena *arena)
 {
 	Temp result = {.arena = arena, .position = arena_position(arena)};
 	return result;
 }
 
 function void
 temp_end(Temp t)
 {
 	arena_pop_to(t.arena, t.position);
 }
 
 enum { DA_INITIAL_CAP = 16 };
 
 #define da_index(it, s) ((it) - (s)->data)
 #define da_reserve(a, s, n) \
   (s)->data = da_reserve_((a), (s)->data, &(s)->capacity, (s)->count + n, \
                           _Alignof(typeof(*(s)->data)), sizeof(*(s)->data))
 
 #define da_append_count(a, s, items, item_count) do { \
 	da_reserve((a), (s), (item_count)); \
 	memory_copy((s)->data + (s)->count, (items), sizeof(*(items)) * (u64)(item_count)); \
 	(s)->count += (item_count); \
 } while (0)
 
 #define da_push(a, s) \
   ((typeof((s)->data))memory_clear((s)->count == (s)->capacity  \
     ? da_reserve(a, s, 1),      \
       (s)->data + (s)->count++  \
     : (s)->data + (s)->count++, 0, sizeof(*(s)->data)))
 
 
 /* NOTE(rnp): handles both 0 initialized DAs and DAs that need to be moved (they started
  * on the stack or someone allocated something in the middle of the arena during usage) */
 function void *
 da_reserve_(Arena *a, void *data, da_count *capacity, da_count needed, u64 align, i64 size)
 {
 	da_count cap = *capacity;
 	if (!cap) cap = DA_INITIAL_CAP;
 	while (cap < needed) cap *= 2;
 
 	Arena *current = a->current;
 	u64 needed_size = cap * size;
 	u64 old_size    = *capacity * size;
 	b32 can_extend  = data && (u8 *)current + current->position == (u8 *)data + old_size &&
 	                  (current->reserved - current->position) >= (needed_size - old_size);
 	b32 needs_copy  = data && !can_extend;
 
 	u64 alloc_cap = cap;
 	if (can_extend) alloc_cap -= *capacity;
 
 	void *new = arena_alloc(a, .size = size, .align = align, .count = alloc_cap);
 
 	if (needs_copy)
 		memory_copy(new, data, (u64)(*capacity * size));
 
 	if (!can_extend)
 		data = new;
 
 	*capacity = cap;
 
 	return data;
 }
 
 function u32
 utf8_encode(u8 *out, u32 cp)
 {
 	u32 result = 1;
 	if (cp <= 0x7F) {
 		out[0] = cp & 0x7F;
 	} else if (cp <= 0x7FF) {
 		result = 2;
 		out[0] = ((cp >>  6) & 0x1F) | 0xC0;
 		out[1] = ((cp >>  0) & 0x3F) | 0x80;
 	} else if (cp <= 0xFFFF) {
 		result = 3;
 		out[0] = ((cp >> 12) & 0x0F) | 0xE0;
 		out[1] = ((cp >>  6) & 0x3F) | 0x80;
 		out[2] = ((cp >>  0) & 0x3F) | 0x80;
 	} else if (cp <= 0x10FFFF) {
 		result = 4;
 		out[0] = ((cp >> 18) & 0x07) | 0xF0;
 		out[1] = ((cp >> 12) & 0x3F) | 0x80;
 		out[2] = ((cp >>  6) & 0x3F) | 0x80;
 		out[3] = ((cp >>  0) & 0x3F) | 0x80;
 	} else {
 		out[0] = '?';
 	}
 	return result;
 }
 
 function UnicodeDecode
 utf16_decode(u16 *data, i64 length)
 {
 	UnicodeDecode result = {.cp = U32_MAX};
 	if (length) {
 		result.consumed = 1;
 		result.cp = data[0];
 		if (length > 1 && Between(data[0], 0xD800u, 0xDBFFu)
 		               && Between(data[1], 0xDC00u, 0xDFFFu))
 		{
 			result.consumed = 2;
 			result.cp = ((data[0] - 0xD800u) << 10u) | ((data[1] - 0xDC00u) + 0x10000u);
 		}
 	}
 	return result;
 }
 
 function u32
 utf16_encode(u16 *out, u32 cp)
 {
 	u32 result = 1;
 	if (cp == U32_MAX) {
 		out[0] = '?';
 	} else if (cp < 0x10000u) {
 		out[0] = (u16)cp;
 	} else {
 		u32 value = cp - 0x10000u;
 		out[0] = (u16)(0xD800u + (value >> 10u));
 		out[1] = (u16)(0xDC00u + (value & 0x3FFu));
 		result = 2;
 	}
 	return result;
 }
 
 function Stream
 stream_from_buffer(u8 *buffer, u32 capacity)
 {
 	Stream result = {.data = buffer, .cap = (i32)capacity};
 	return result;
 }
 
 function Stream
 stream_alloc(Arena *a, i32 cap)
 {
 	Stream result = stream_from_buffer(push_array_no_zero(a, u8, cap), (u32)cap);
 	return result;
 }
 
 function str8
 stream_to_str8(Stream *s)
 {
 	str8 result = str8("");
 	if (!s->errors) result = (str8){.length = s->widx, .data = s->data};
 	return result;
 }
 
 function void
 stream_reset(Stream *s, i32 index)
 {
 	s->errors = s->cap <= index;
 	if (!s->errors)
 		s->widx = index;
 }
 
 function void
 stream_append(Stream *s, void *data, i64 count)
 {
 	s->errors |= (s->cap - s->widx) < count;
 	if (!s->errors) {
 		memory_copy(s->data + s->widx, data, (u64)count);
 		s->widx += (i32)count;
 	}
 }
 
 function void
 stream_append_codepoint(Stream *s, u32 codepoint)
 {
 	u8 buffer[4];
 	stream_append(s, buffer, utf8_encode(buffer, codepoint));
 }
 
 // TODO(rnp): replace with handwritten version
 #include <stdarg.h>
 #include <stdio.h>
 function void
 stream_appendfv(Stream *s, const char *format, va_list args)
 {
 	i32 written = vsnprintf((char *)s->data + s->widx, s->cap - s->widx, format, args);
 	s->errors |= written > (s->cap - s->widx);
 	if (!s->errors) s->widx += written;
 }
 
 function print_format(2, 3) void
 stream_appendf(Stream *s, const char *format, ...)
 {
 	va_list args;
 	va_start(args, format);
 	stream_appendfv(s, format, args);
 	va_end(args);
 }
 
 function void
 stream_append_byte(Stream *s, u8 b)
 {
 	stream_append(s, &b, 1);
 }
 
 function void
 stream_pad(Stream *s, u8 b, i32 n)
 {
 	while (n > 0) stream_append_byte(s, b), n--;
 }
 
 function void
 stream_append_str8(Stream *s, str8 str)
 {
 	stream_append(s, str.data, str.length);
 }
 
 #define stream_append_str8s(s, ...) stream_append_str8s_(s, arg_list(str8, ##__VA_ARGS__))
 function void
 stream_append_str8s_(Stream *s, str8 *strs, i64 count)
 {
 	for (i64 i = 0; i < count; i++)
 		stream_append(s, strs[i].data, strs[i].length);
 }
 
 function void
 stream_append_u64_width(Stream *s, u64 n, u64 min_width)
 {
 	u8 tmp[64];
 	u8 *end = tmp + sizeof(tmp);
 	u8 *beg = end;
 	min_width = Min(sizeof(tmp), min_width);
 
 	do { *--beg = (u8)('0' + (n % 10)); } while (n /= 10);
 	while (end - beg > 0 && (u64)(end - beg) < min_width)
 		*--beg = '0';
 
 	stream_append(s, beg, end - beg);
 }
 
 function void
 stream_append_u64(Stream *s, u64 n)
 {
 	stream_append_u64_width(s, n, 0);
 }
 
 function void
 stream_append_hex_u64_width(Stream *s, u64 n, i64 width)
 {
 	assert(width <= 16);
 	if (!s->errors) {
 		u8  buf[16];
 		u8 *end = buf + sizeof(buf);
 		u8 *beg = end;
 		while (n) {
 			*--beg = (u8)"0123456789abcdef"[n & 0x0F];
 			n >>= 4;
 		}
 		while (end - beg < width)
 			*--beg = '0';
 		stream_append(s, beg, end - beg);
 	}
 }
 
 function void
 stream_append_hex_u64(Stream *s, u64 n)
 {
 	stream_append_hex_u64_width(s, n, 2);
 }
 
 function void
 stream_append_i64(Stream *s, i64 n)
 {
 	if (n < 0) {
 		stream_append_byte(s, '-');
 		n *= -1;
 	}
 	stream_append_u64(s, (u64)n);
 }
 
 function void
 stream_append_f64(Stream *s, f64 f, u64 prec)
 {
 	if (f < 0) {
 		stream_append_byte(s, '-');
 		f *= -1;
 	}
 
 	/* NOTE: round last digit */
 	f += 0.5f / (f64)prec;
 
 	if (f >= (f64)(-1UL >> 1)) {
 		stream_append_str8(s, str8("inf"));
 	} else {
 		u64 integral = (u64)f;
 		u64 fraction = (u64)((f - (f64)integral) * (f64)prec);
 		stream_append_u64(s, integral);
 		stream_append_byte(s, '.');
 		for (u64 i = prec / 10; i > 1; i /= 10) {
 			if (i > fraction)
 				stream_append_byte(s, '0');
 		}
 		stream_append_u64(s, fraction);
 	}
 }
 
 function void
 stream_append_f64_e(Stream *s, f64 f)
 {
 	/* TODO: there should be a better way of doing this */
 	#if 0
 	/* NOTE: we ignore subnormal numbers for now */
 	union { f64 f; u64 u; } u = {.f = f};
 	i32 exponent = ((u.u >> 52) & 0x7ff) - 1023;
 	f32 log_10_of_2 = 0.301f;
 	i32 scale       = (exponent * log_10_of_2);
 	/* NOTE: normalize f */
 	for (i32 i = ABS(scale); i > 0; i--)
 		f *= (scale > 0)? 0.1f : 10.0f;
 	#else
 	f32 sign = Sign(f);
 	f *= sign;
 	i32 scale = 0;
 	if (f != 0) {
 		while (f > 1) {
 			f *= 0.1f;
 			scale++;
 		}
 		while (f < 1) {
 			f *= 10.0f;
 			scale--;
 		}
 	}
 	#endif
 
 	u32 prec = 100;
 	stream_append_f64(s, sign * f, prec);
 	stream_append_byte(s, 'e');
 	stream_append_byte(s, scale >= 0? '+' : '-');
 	for (u32 i = prec / 10; i > 1; i /= 10)
 		stream_append_byte(s, '0');
 	stream_append_u64(s, (u64)Abs(scale));
 }
 
 function void
 stream_append_struct_member(Stream *s, const MetaStructMember *m, const void *struct_base)
 {
 	switch (m->type_id) {
 	InvalidDefaultCase;
 	case MetaKind_F32:{
 		f32 value;
 		memory_copy(&value, ((u8 *)struct_base + m->offset), sizeof(value));
 		stream_append_f64_e(s, value);
 	}break;
 	case MetaKind_B32:{
 		b32 value;
 		memory_copy(&value, ((u8 *)struct_base + m->offset), sizeof(value));
 		stream_append_str8(s, value ? str8("True") : str8("False"));
 	}break;
 	case MetaKind_U32:{
 		u32 value;
 		memory_copy(&value, ((u8 *)struct_base + m->offset), sizeof(value));
 		stream_append_u64(s, value);
 	}break;
 	case MetaKind_U64:{
 		u64 value;
 		memory_copy(&value, ((u8 *)struct_base + m->offset), sizeof(value));
 		stream_append_str8(s, str8("0x"));
 		stream_append_hex_u64(s, value);
 	}break;
 	case MetaKind_S32:{
 		i32 value;
 		memory_copy(&value, ((u8 *)struct_base + m->offset), sizeof(value));
 		stream_append_i64(s, value);
 	}break;
 	}
 }
 
 function Stream
 arena_stream(Arena *a)
 {
 	Arena *current = a->current;
 	Stream result = {0};
 	result.data   = (u8 *)current + current->position;
 	result.cap    = (i32)(current->committed - current->position);
 
 	/* TODO(rnp): no idea what to do here if we want to maintain the ergonomics */
 	asan_unpoison_region(result.data, result.cap);
 
 	return result;
 }
 
 function str8
 arena_stream_commit(Arena *a, Stream *s)
 {
 	Arena *current = a->current;
 	assert(s->data == (u8 *)current + current->position);
 	str8 result = stream_to_str8(s);
 	arena_commit(a, result.length);
 	return result;
 }
 
 function str8
 arena_stream_commit_zero(Arena *a, Stream *s)
 {
 	b32 error = s->errors || s->widx == s->cap;
 	if (!error)
 		s->data[s->widx] = 0;
 	str8 result = stream_to_str8(s);
 	arena_commit(a, result.length + 1);
 	return result;
 }
 
 function str8
 arena_stream_commit_and_reset(Arena *arena, Stream *s)
 {
 	str8 result = arena_stream_commit_zero(arena, s);
 	*s = arena_stream(arena);
 	return result;
 }
 
 #if !defined(XXH_IMPLEMENTATION)
 # define XXH_INLINE_ALL
 # define XXH_IMPLEMENTATION
 # define XXH_STATIC_LINKING_ONLY
 # include "external/xxhash.h"
 #endif
 
 function u128
 u128_hash_from_data(void *data, u64 size)
 {
 	u128 result = {0};
 	XXH128_hash_t hash = XXH3_128bits_withSeed(data, size, 4969);
 	memory_copy(&result, &hash, sizeof(result));
 	return result;
 }
 
 function u64
 u64_hash_from_str8_seed(str8 string, u64 seed)
 {
 	u64 result = XXH3_64bits_withSeed(string.data, (u64)string.length, seed);
 	return result;
 }
 
 function u64
 u64_hash_from_str8(str8 v)
 {
 	u64 result = u64_hash_from_str8_seed(v, 4969);
 	return result;
 }
 
 function str8
 str8_from_c_str(char *cstr)
 {
 	str8 result = {.data = (u8 *)cstr};
 	if (cstr) while (*cstr) cstr++;
 	result.length = (u8 *)cstr - result.data;
 	return result;
 }
 
 function str8
 str8_range(u8 *start, u8 *one_past_last)
 {
 	str8 result;
 	result.data   = start;
 	result.length = one_past_last - start;
 	return result;
 }
 
 function str8
 str8_skip(str8 s, i64 count)
 {
 	str8 result = s;
 	if (count > 0) {
 		result.data   += count;
 		result.length -= count;
 	}
 	return result;
 }
 
 function b32
 str8_equal(str8 a, str8 b)
 {
 	b32 result = a.length == b.length;
 	for (i64 i = 0; result && i < a.length; i++)
 		result = a.data[i] == b.data[i];
 	return result;
 }
 
 /* NOTE(rnp): returns < 0 if byte is not found */
 function i64
 str8_scan_backwards(str8 s, u8 byte)
 {
 	i64 result = (u8 *)memory_scan_backwards(s.data, byte, s.length) - s.data;
 	return result;
 }
 
 function str8
 str8_cut_head(str8 s, i64 cut)
 {
 	str8 result = s;
 	if (cut > 0) {
 		result.data   += cut;
 		result.length -= cut;
 	}
 	result.length = Max(0, result.length);
 	return result;
 }
 
 function i64
 str8_word_boundary_before(str8 s, i64 p)
 {
 	p = Max(p - 1, 0);
 	b32 negate = IsWordBoundary(s.data[p]);
 	while (p >= 0 && (negate ^ !IsWordBoundary(s.data[p])))
 		p -= 1;
 	p++;
 	return p;
 }
 
 function i64
 str8_word_boundary_after(str8 s, i64 p)
 {
 	b32 negate = IsWordBoundary(s.data[p]);
 	while (p != s.length && (negate ^ !IsWordBoundary(s.data[p])))
 		p += 1;
 	return p;
 }
 
 function i64
 str8_word_boundary(str8 s, i64 p, i64 count)
 {
 	i64 sign  = Sign(count);
 	i64 end_p = sign > 0 ? s.length : 0;
 	count = Abs(count);
 	p     = Clamp(p, 0, s.length);
 
 	for (i64 word_count = 0; word_count < count && p != end_p; word_count++)
 		p = sign > 0 ? str8_word_boundary_after(s, p) : str8_word_boundary_before(s, p);
 
 	return p;
 }
 
 function b32
 str8_match(str8 a, str8 b, StringMatchFlags flags)
 {
 	b32 result = 0;
 	if (flags == 0) {
 		result = str8_equal(a, b);
 	} else if (a.length == b.length || (flags & StringMatchFlag_SloppySize)) {
 		result = 1;
 		i64 length = Min(a.length, b.length);
 		for (i64 it = 0; it < length && result; it++) {
 			u8 ab = a.data[it], bb = b.data[it];
 			if (flags & StringMatchFlag_CaseInsensitive) {
 				ab |= 0x20;
 				bb |= 0x20;
 			}
 			result &= ab == bb;
 		}
 	}
 	return result;
 }
 
 function i64
 str8_find_needle(str8 string, str8 needle, StringMatchFlags flags)
 {
 	u8 *s  = string.data;
 	u8 *se = string.data + Max(string.length + 1, needle.length) - needle.length;
 	if (needle.length > 0) {
 		flags |= StringMatchFlag_SloppySize;
 
 		u8 nb = needle.data[0];
 		if (flags & StringMatchFlag_CaseInsensitive)
 			nb |= 0x20;
 
 		str8 needle_tail = str8_skip(needle, 1);
 		u8 *s_opl = string.data + string.length;
 		for (; s < se; s++) {
 			u8 sb = *s;
 			if (flags & StringMatchFlag_CaseInsensitive)
 				sb |= 0x20;
 
 			if (sb == nb && str8_match(str8_range(s + 1, s_opl), needle_tail, flags))
 				break;
 		}
 	}
 
 	i64 result = string.length;
 	if (s < se)
 		result = s - string.data;
 	return result;
 }
 
 
 function str8
 str8_alloc(Arena *a, i64 length)
 {
 	str8 result = {.data = push_array(a, u8, length), .length = length};
 	return result;
 }
 
 function str8
 str8_from_str16(Arena *a, str16 in)
 {
 	str8 result = str8("");
 	if (in.length) {
 		i64 commit = in.length * 4;
 		i64 length = 0;
 		u8  *data = push_array_no_zero(a, u8, commit + 1);
 		u16 *beg  = in.data;
 		u16 *end  = in.data + in.length;
 		while (beg < end) {
 			UnicodeDecode decode = utf16_decode(beg, end - beg);
 			length += utf8_encode(data + length, decode.cp);
 			beg    += decode.consumed;
 		}
 		data[length] = 0;
 		result = (str8){.length = length, .data = data};
 		arena_pop(a, commit - length);
 	}
 	return result;
 }
 
 function str16
 str16_from_str8(Arena *a, str8 in)
 {
 	str16 result = {0};
 	if (in.length) {
 		i64  length   = 0;
 		i64  required = 2 * in.length + 1;
 		u16 *data     = push_array(a, u16, required);
 		/* TODO(rnp): utf8_decode */
 		for (i64 i = 0; i < in.length; i++) {
 			u32 cp  = in.data[i];
 			length += utf16_encode(data + length, cp);
 		}
 		result = (str16){.length = length, .data = data};
 		arena_pop(a, required - length);
 	}
 	return result;
 }
 
 #define push_str8_from_parts(a, j, ...) push_str8_from_parts_((a), (j), arg_list(str8, __VA_ARGS__))
 function str8
 push_str8_from_parts_(Arena *arena, str8 joiner, str8 *parts, i64 count)
 {
 	i64 length = joiner.length * (count - 1);
 	for (i64 i = 0; i < count; i++)
 		length += parts[i].length;
 
 	str8 result = {.length = length, .data = push_array_no_zero(arena, u8, length + 1)};
 
 	i64 offset = 0;
 	for (i64 i = 0; i < count; i++) {
 		if (i != 0) {
 			memory_copy(result.data + offset, joiner.data, (u64)joiner.length);
 			offset += joiner.length;
 		}
 		memory_copy(result.data + offset, parts[i].data, (u64)parts[i].length);
 		offset += parts[i].length;
 	}
 	result.data[result.length] = 0;
 
 	return result;
 }
 
 function str8
 push_str8(Arena *a, str8 str)
 {
 	str8 result    = str8_alloc(a, str.length + 1);
 	result.length -= 1;
 	memory_copy(result.data, str.data, (u64)result.length);
 	return result;
 }
 
 // TODO(rnp): replace with handwritten version
 function str8
 push_str8_fv(Arena *arena, const char *format, va_list args)
 {
 	va_list args2;
 	va_copy(args2, args);
 	i64  size    = vsnprintf(0, 0, format, args2);
 	va_end(args2);
 	str8 result  = str8_alloc(arena, size + 1);
 	i64  written = vsnprintf((char *)result.data, result.length, format, args);
 	assert(written == size);
 	result.length -= 1;
 	return result;
 }
 
 function print_format(2, 3) str8
 push_str8_f(Arena *arena, const char *format, ...)
 {
 	va_list args;
 	va_start(args, format);
 	str8 result = push_str8_fv(arena, format, args);
 	va_end(args);
 	return result;
 }
 
 function NumberConversion
 integer_from_str8(str8 raw)
 {
 	read_only alignas(64) i8 lut[64] = {
 		 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,
 		-1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 		-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 		-1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 	};
 
 	NumberConversion result = {.unparsed = raw};
 
 	i64 i     = 0;
 	i64 scale = 1;
 	if (raw.length > 0 && raw.data[0] == '-') {
 		scale = -1;
 		i     =  1;
 	}
 
 	b32 hex = 0;
 	if (raw.length - i > 2 && raw.data[i] == '0' && (raw.data[1] == 'x' || raw.data[1] == 'X')) {
 		hex = 1;
 		i += 2;
 	}
 
 	#define integer_conversion_body(radix, clamp) do {\
 		for (; i < raw.length; i++) {\
 			i64 value = lut[Min((u8)(raw.data[i] - (u8)'0'), clamp)];\
 			if (value >= 0) {\
 				if (result.U64 > (U64_MAX - (u64)value) / radix) {\
 					result.result = NumberConversionResult_OutOfRange;\
 					result.U64    = U64_MAX;\
 					return result;\
 				} else {\
 					result.U64 = radix * result.U64 + (u64)value;\
 				}\
 			} else {\
 				break;\
 			}\
 		}\
 	} while (0)
 
 	if (hex) integer_conversion_body(16u, 63u);
 	else     integer_conversion_body(10u, 15u);
 
 	#undef integer_conversion_body
 
 	result.unparsed = (str8){.length = raw.length - i, .data = raw.data + i};
 	result.result   = i > 0 ? NumberConversionResult_Success : NumberConversionResult_Invalid;
 	result.kind     = NumberConversionKind_Integer;
 	if (scale < 0) result.U64 = 0 - result.U64;
 
 	return result;
 }
 
 function NumberConversion
 number_from_str8(str8 s)
 {
 	NumberConversion result  = {.unparsed = s};
 	NumberConversion integer = integer_from_str8(s);
 	if (integer.result == NumberConversionResult_Success) {
 		if (integer.unparsed.length != 0 && integer.unparsed.data[0] == '.') {
 			s = integer.unparsed;
 			s.data++;
 			s.length--;
 
 			while (s.length > 0 && s.data[s.length - 1] == '0') s.length--;
 
 			NumberConversion fractional = integer_from_str8(s);
 			if (fractional.result == NumberConversionResult_Success || s.length == 0) {
 				result.F64 = (f64)fractional.U64;
 
 				u64 divisor = (u64)(fractional.unparsed.data - s.data);
 				while (divisor > 0) { result.F64 /= 10.0; divisor--; }
 
 				result.F64 += (f64)integer.S64;
 
 				result.result   = NumberConversionResult_Success;
 				result.kind     = NumberConversionKind_Float;
 				result.unparsed = fractional.unparsed;
 			}
 		} else {
 			result = integer;
 		}
 	}
 	return result;
 }
 
 function b32
 take_lock(i32 *lock, i32 timeout_ms)
 {
 	b32 result = 0;
 	for (;;) {
 		i32 current = 0;
 		if (atomic_cas_u32(lock, &current, 1))
 			result = 1;
 		if (result || !timeout_ms || (!os_wait_on_address(lock, current, (u32)timeout_ms) && timeout_ms != -1))
 			break;
 	}
 	return result;
 }
 
 function void
 release_lock(i32 *lock)
 {
 	assert(atomic_load_u32(lock));
 	atomic_store_u32(lock, 0);
 	os_wake_all_waiters(lock);
 }