aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--base/runtime/internal.odin68
-rw-r--r--core/strings/strings.odin63
-rw-r--r--core/sys/wasm/js/odin.js10
-rw-r--r--src/build_settings.cpp72
-rw-r--r--src/check_builtin.cpp25
-rw-r--r--src/check_expr.cpp22
-rw-r--r--src/linker.cpp6
-rw-r--r--src/llvm_backend.cpp38
-rw-r--r--src/main.cpp10
-rw-r--r--tests/benchmark/all.odin1
-rw-r--r--tests/benchmark/strings/benchmark_strings.odin131
-rw-r--r--tests/core/strings/test_core_strings.odin51
12 files changed, 409 insertions, 88 deletions
diff --git a/base/runtime/internal.odin b/base/runtime/internal.odin
index a35dbff8a..907b187f1 100644
--- a/base/runtime/internal.odin
+++ b/base/runtime/internal.odin
@@ -405,6 +405,74 @@ memory_compare_zero :: proc "contextless" (a: rawptr, n: int) -> int #no_bounds_
return 0
}
+memory_prefix_length :: proc "contextless" (x, y: rawptr, n: int) -> (idx: int) #no_bounds_check {
+ switch {
+ case x == y: return n
+ case x == nil: return 0
+ case y == nil: return 0
+ }
+ a, b := cast([^]byte)x, cast([^]byte)y
+
+ n := uint(n)
+ i := uint(0)
+ m := uint(0)
+
+ when HAS_HARDWARE_SIMD {
+ when ODIN_ARCH == .amd64 && intrinsics.has_target_feature("avx2") {
+ m = n / 32 * 32
+ for /**/; i < m; i += 32 {
+ load_a := intrinsics.unaligned_load(cast(^#simd[32]u8)&a[i])
+ load_b := intrinsics.unaligned_load(cast(^#simd[32]u8)&b[i])
+ comparison := intrinsics.simd_lanes_ne(load_a, load_b)
+ if intrinsics.simd_reduce_or(comparison) != 0 {
+ sentinel: #simd[32]u8 = u8(0xFF)
+ indices := intrinsics.simd_indices(#simd[32]u8)
+ index_select := intrinsics.simd_select(comparison, indices, sentinel)
+ index_reduce := cast(uint)intrinsics.simd_reduce_min(index_select)
+ return int(i + index_reduce)
+ }
+ }
+ }
+ }
+
+ m = (n-i) / 16 * 16
+ for /**/; i < m; i += 16 {
+ load_a := intrinsics.unaligned_load(cast(^#simd[16]u8)&a[i])
+ load_b := intrinsics.unaligned_load(cast(^#simd[16]u8)&b[i])
+ comparison := intrinsics.simd_lanes_ne(load_a, load_b)
+ if intrinsics.simd_reduce_or(comparison) != 0 {
+ sentinel: #simd[16]u8 = u8(0xFF)
+ indices := intrinsics.simd_indices(#simd[16]u8)
+ index_select := intrinsics.simd_select(comparison, indices, sentinel)
+ index_reduce := cast(uint)intrinsics.simd_reduce_min(index_select)
+ return int(i + index_reduce)
+ }
+ }
+
+ // 64-bit SIMD is faster than using a `uintptr` to detect a difference then
+ // re-iterating with the byte-by-byte loop, at least on AMD64.
+ m = (n-i) / 8 * 8
+ for /**/; i < m; i += 8 {
+ load_a := intrinsics.unaligned_load(cast(^#simd[8]u8)&a[i])
+ load_b := intrinsics.unaligned_load(cast(^#simd[8]u8)&b[i])
+ comparison := intrinsics.simd_lanes_ne(load_a, load_b)
+ if intrinsics.simd_reduce_or(comparison) != 0 {
+ sentinel: #simd[8]u8 = u8(0xFF)
+ indices := intrinsics.simd_indices(#simd[8]u8)
+ index_select := intrinsics.simd_select(comparison, indices, sentinel)
+ index_reduce := cast(uint)intrinsics.simd_reduce_min(index_select)
+ return int(i + index_reduce)
+ }
+ }
+
+ for /**/; i < n; i += 1 {
+ if a[i] ~ b[i] != 0 {
+ return int(i)
+ }
+ }
+ return int(n)
+}
+
string_eq :: proc "contextless" (lhs, rhs: string) -> bool {
x := transmute(Raw_String)lhs
y := transmute(Raw_String)rhs
diff --git a/core/strings/strings.odin b/core/strings/strings.odin
index e15754dff..e45b177d7 100644
--- a/core/strings/strings.odin
+++ b/core/strings/strings.odin
@@ -2,6 +2,7 @@
package strings
import "base:intrinsics"
+import "base:runtime"
import "core:bytes"
import "core:io"
import "core:mem"
@@ -458,6 +459,7 @@ equal_fold :: proc(u, v: string) -> (res: bool) {
return s == t
}
+
/*
Returns the prefix length common between strings `a` and `b`
@@ -488,30 +490,57 @@ Output:
0
*/
-prefix_length :: proc(a, b: string) -> (n: int) {
- _len := min(len(a), len(b))
-
- // Scan for matches including partial codepoints.
- #no_bounds_check for n < _len && a[n] == b[n] {
- n += 1
- }
+prefix_length :: proc "contextless" (a, b: string) -> (n: int) {
+ RUNE_ERROR :: '\ufffd'
+ RUNE_SELF :: 0x80
+ UTF_MAX :: 4
- // Now scan to ignore partial codepoints.
- if n > 0 {
- s := a[:n]
- n = 0
- for {
- r0, w := utf8.decode_rune(s[n:])
- if r0 != utf8.RUNE_ERROR {
- n += w
- } else {
- break
+ n = runtime.memory_prefix_length(raw_data(a), raw_data(b), min(len(a), len(b)))
+ lim := max(n - UTF_MAX + 1, 0)
+ for l := n; l > lim; l -= 1 {
+ r, _ := runtime.string_decode_rune(a[l - 1:])
+ if r != RUNE_ERROR {
+ if l > 0 && (a[l - 1] & 0xc0 == 0xc0) {
+ return l - 1
}
+ return l
}
}
return
}
/*
+Returns the common prefix between strings `a` and `b`
+
+Inputs:
+- a: The first input string
+- b: The second input string
+
+Returns:
+- n: The string prefix common between strings `a` and `b`
+
+Example:
+
+ import "core:fmt"
+ import "core:strings"
+
+ common_prefix_example :: proc() {
+ fmt.println(strings.common_prefix("testing", "test"))
+ fmt.println(strings.common_prefix("testing", "te"))
+ fmt.println(strings.common_prefix("telephone", "te"))
+ }
+
+Output:
+
+ test
+ te
+ te
+
+
+*/
+common_prefix :: proc(a, b: string) -> string {
+ return a[:prefix_length(a, b)]
+}
+/*
Determines if a string `s` starts with a given `prefix`
Inputs:
diff --git a/core/sys/wasm/js/odin.js b/core/sys/wasm/js/odin.js
index d5faa5210..37a57a59d 100644
--- a/core/sys/wasm/js/odin.js
+++ b/core/sys/wasm/js/odin.js
@@ -110,16 +110,12 @@ class WasmMemoryInterface {
}
loadCstring(ptr) {
- return this.loadCstringDirect(this.loadPtr(ptr));
- }
-
- loadCstringDirect(start) {
- if (start == 0) {
+ if (ptr == 0) {
return null;
}
let len = 0;
- for (; this.mem.getUint8(start+len) != 0; len += 1) {}
- return this.loadString(start, len);
+ for (; this.mem.getUint8(ptr+len) != 0; len += 1) {}
+ return this.loadString(ptr, len);
}
storeU8(addr, value) { this.mem.setUint8 (addr, value); }
diff --git a/src/build_settings.cpp b/src/build_settings.cpp
index e46670528..05709902a 100644
--- a/src/build_settings.cpp
+++ b/src/build_settings.cpp
@@ -288,7 +288,7 @@ enum BuildPath : u8 {
BuildPath_VS_LIB, // vs_library_path
BuildPath_Output, // Output Path for .exe, .dll, .so, etc. Can be overridden with `-out:`.
- BuildPath_PDB, // Output Path for .pdb file, can be overridden with `-pdb-name:`.
+ BuildPath_Symbols, // Output Path for .pdb or .dSym file, can be overridden with `-pdb-name:`.
BuildPathCOUNT,
};
@@ -2023,6 +2023,39 @@ gb_internal bool check_target_feature_is_superset_of(String const &superset, Str
return true;
}
+gb_internal String infer_object_extension_from_build_context() {
+ String output_extension = {};
+ if (is_arch_wasm()) {
+ output_extension = STR_LIT("wasm.o");
+ } else {
+ switch (build_context.metrics.os) {
+ case TargetOs_windows:
+ output_extension = STR_LIT("obj");
+ break;
+ default:
+ case TargetOs_darwin:
+ case TargetOs_linux:
+ case TargetOs_essence:
+ output_extension = STR_LIT("o");
+ break;
+
+ case TargetOs_freestanding:
+ switch (build_context.metrics.abi) {
+ default:
+ case TargetABI_Default:
+ case TargetABI_SysV:
+ output_extension = STR_LIT("o");
+ break;
+ case TargetABI_Win64:
+ output_extension = STR_LIT("obj");
+ break;
+ }
+ break;
+ }
+ }
+ return output_extension;
+}
+
// NOTE(Jeroen): Set/create the output and other paths and report an error as appropriate.
// We've previously called `parse_build_flags`, so `out_filepath` should be set.
gb_internal bool init_build_paths(String init_filename) {
@@ -2155,13 +2188,8 @@ gb_internal bool init_build_paths(String init_filename) {
if (build_context.metrics.os == TargetOs_windows) {
output_extension = STR_LIT("lib");
}
- }else if (build_context.build_mode == BuildMode_Object) {
- // By default use a .o object extension.
- output_extension = STR_LIT("o");
-
- if (build_context.metrics.os == TargetOs_windows) {
- output_extension = STR_LIT("obj");
- }
+ } else if (build_context.build_mode == BuildMode_Object) {
+ output_extension = infer_object_extension_from_build_context();
} else if (build_context.build_mode == BuildMode_Assembly) {
// By default use a .S asm extension.
output_extension = STR_LIT("S");
@@ -2181,7 +2209,7 @@ gb_internal bool init_build_paths(String init_filename) {
return false;
} else if (bc->build_paths[BuildPath_Output].ext.len == 0) {
gb_printf_err("Output path %.*s must have an appropriate extension.\n", LIT(output_file));
- return false;
+ return false;
}
}
} else {
@@ -2264,15 +2292,23 @@ gb_internal bool init_build_paths(String init_filename) {
bc->build_paths[BuildPath_Output] = output_path;
}
- if (build_context.metrics.os == TargetOs_windows && build_context.ODIN_DEBUG) {
- if (bc->pdb_filepath.len > 0) {
- bc->build_paths[BuildPath_PDB] = path_from_string(ha, bc->pdb_filepath);
- } else {
- Path pdb_path;
- pdb_path.basename = copy_string(ha, bc->build_paths[BuildPath_Output].basename);
- pdb_path.name = copy_string(ha, bc->build_paths[BuildPath_Output].name);
- pdb_path.ext = copy_string(ha, STR_LIT("pdb"));
- bc->build_paths[BuildPath_PDB] = pdb_path;
+ if (build_context.ODIN_DEBUG) {
+ if (build_context.metrics.os == TargetOs_windows) {
+ if (bc->pdb_filepath.len > 0) {
+ bc->build_paths[BuildPath_Symbols] = path_from_string(ha, bc->pdb_filepath);
+ } else {
+ Path symbol_path;
+ symbol_path.basename = copy_string(ha, bc->build_paths[BuildPath_Output].basename);
+ symbol_path.name = copy_string(ha, bc->build_paths[BuildPath_Output].name);
+ symbol_path.ext = copy_string(ha, STR_LIT("pdb"));
+ bc->build_paths[BuildPath_Symbols] = symbol_path;
+ }
+ } else if (build_context.metrics.os == TargetOs_darwin) {
+ Path symbol_path;
+ symbol_path.basename = copy_string(ha, bc->build_paths[BuildPath_Output].basename);
+ symbol_path.name = copy_string(ha, bc->build_paths[BuildPath_Output].name);
+ symbol_path.ext = copy_string(ha, STR_LIT("dSYM"));
+ bc->build_paths[BuildPath_Symbols] = symbol_path;
}
}
diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp
index f384cb7e1..f8bf4b0ce 100644
--- a/src/check_builtin.cpp
+++ b/src/check_builtin.cpp
@@ -2871,8 +2871,6 @@ gb_internal bool check_builtin_procedure(CheckerContext *c, Operand *operand, As
// quaternion :: proc(imag, jmag, kmag, real: float_type) -> complex_type
Operand xyzw[4] = {};
- u32 first_index = 0;
-
// NOTE(bill): Invalid will be the default till fixed
operand->type = t_invalid;
operand->mode = Addressing_Invalid;
@@ -2917,6 +2915,7 @@ gb_internal bool check_builtin_procedure(CheckerContext *c, Operand *operand, As
if (fields_set[*index]) {
error(field->field, "Previously assigned field: '%.*s'", LIT(name));
+ return false;
}
fields_set[*index] = style;
@@ -2933,7 +2932,6 @@ gb_internal bool check_builtin_procedure(CheckerContext *c, Operand *operand, As
if (!ok || index < 0) {
return false;
}
- first_index = cast(u32)index;
*refs[index] = o;
}
@@ -2958,12 +2956,17 @@ gb_internal bool check_builtin_procedure(CheckerContext *c, Operand *operand, As
}
- for (u32 i = 0; i < 4; i++ ){
- u32 j = (i + first_index) % 4;
- if (j == first_index) {
- convert_to_typed(c, &xyzw[j], xyzw[(first_index+1)%4].type); if (xyzw[j].mode == Addressing_Invalid) return false;
- } else {
- convert_to_typed(c, &xyzw[j], xyzw[first_index].type); if (xyzw[j].mode == Addressing_Invalid) return false;
+ // The first typed value found, if any exist, will dictate the type for all untyped values.
+ for (u32 i = 0; i < 4; i++) {
+ if (is_type_typed(xyzw[i].type)) {
+ for (u32 j = 0; j < 4; j++) {
+ // `convert_to_typed` should check if it is typed already.
+ convert_to_typed(c, &xyzw[j], xyzw[i].type);
+ if (xyzw[j].mode == Addressing_Invalid) {
+ return false;
+ }
+ }
+ break;
}
}
if (xyzw[0].mode == Addressing_Constant &&
@@ -2987,7 +2990,7 @@ gb_internal bool check_builtin_procedure(CheckerContext *c, Operand *operand, As
gbString ty = type_to_string(xyzw[1].type);
gbString tz = type_to_string(xyzw[2].type);
gbString tw = type_to_string(xyzw[3].type);
- error(call, "Mismatched types to 'quaternion', 'x=%s' vs 'y=%s' vs 'z=%s' vs 'w=%s'", tx, ty, tz, tw);
+ error(call, "Mismatched types to 'quaternion', 'w=%s' vs 'x=%s' vs 'y=%s' vs 'z=%s'", tw, tx, ty, tz);
gb_string_free(tw);
gb_string_free(tz);
gb_string_free(ty);
@@ -3023,7 +3026,7 @@ gb_internal bool check_builtin_procedure(CheckerContext *c, Operand *operand, As
operand->mode = Addressing_Constant;
}
- BasicKind kind = core_type(xyzw[first_index].type)->Basic.kind;
+ BasicKind kind = core_type(xyzw[0].type)->Basic.kind;
switch (kind) {
case Basic_f16: operand->type = t_quaternion64; break;
case Basic_f32: operand->type = t_quaternion128; break;
diff --git a/src/check_expr.cpp b/src/check_expr.cpp
index 60a4d3a98..20918c8f9 100644
--- a/src/check_expr.cpp
+++ b/src/check_expr.cpp
@@ -7960,7 +7960,27 @@ gb_internal ExprKind check_call_expr(CheckerContext *c, Operand *operand, Ast *c
default:
{
gbString str = type_to_string(t);
- error(call, "Too many arguments in conversion to '%s'", str);
+ if (t->kind == Type_Basic) {
+ ERROR_BLOCK();
+ switch (t->Basic.kind) {
+ case Basic_complex32:
+ case Basic_complex64:
+ case Basic_complex128:
+ error(call, "Too many arguments in conversion to '%s'", str);
+ error_line("\tSuggestion: %s(1+2i) or construct with 'complex'\n", str);
+ break;
+ case Basic_quaternion64:
+ case Basic_quaternion128:
+ case Basic_quaternion256:
+ error(call, "Too many arguments in conversion to '%s'", str);
+ error_line("\tSuggestion: %s(1+2i+3j+4k) or construct with 'quaternion'\n", str);
+ break;
+ default:
+ error(call, "Too many arguments in conversion to '%s'", str);
+ }
+ } else {
+ error(call, "Too many arguments in conversion to '%s'", str);
+ }
gb_string_free(str);
} break;
case 1: {
diff --git a/src/linker.cpp b/src/linker.cpp
index f10e47ec3..2210c1306 100644
--- a/src/linker.cpp
+++ b/src/linker.cpp
@@ -281,9 +281,9 @@ try_cross_linking:;
link_settings = gb_string_append_fmt(link_settings, " /ENTRY:mainCRTStartup");
}
- if (build_context.build_paths[BuildPath_PDB].name != "") {
- String pdb_path = path_to_string(heap_allocator(), build_context.build_paths[BuildPath_PDB]);
- link_settings = gb_string_append_fmt(link_settings, " /PDB:\"%.*s\"", LIT(pdb_path));
+ if (build_context.build_paths[BuildPath_Symbols].name != "") {
+ String symbol_path = path_to_string(heap_allocator(), build_context.build_paths[BuildPath_Symbols]);
+ link_settings = gb_string_append_fmt(link_settings, " /PDB:\"%.*s\"", LIT(symbol_path));
}
if (build_context.build_mode != BuildMode_StaticLibrary) {
diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp
index a59440220..3cf77256b 100644
--- a/src/llvm_backend.cpp
+++ b/src/llvm_backend.cpp
@@ -2504,7 +2504,6 @@ gb_internal String lb_filepath_obj_for_module(lbModule *m) {
gbString path = gb_string_make_length(heap_allocator(), basename.text, basename.len);
path = gb_string_appendc(path, "/");
- path = gb_string_append_length(path, name.text, name.len);
if (USE_SEPARATE_MODULES) {
GB_ASSERT(m->module_name != nullptr);
@@ -2516,6 +2515,8 @@ gb_internal String lb_filepath_obj_for_module(lbModule *m) {
}
path = gb_string_append_length(path, s.text, s.len);
+ } else {
+ path = gb_string_append_length(path, name.text, name.len);
}
if (use_temporary_directory) {
@@ -2526,38 +2527,15 @@ gb_internal String lb_filepath_obj_for_module(lbModule *m) {
String ext = {};
if (build_context.build_mode == BuildMode_Assembly) {
- ext = STR_LIT(".S");
+ ext = STR_LIT("S");
+ } else if (build_context.build_mode == BuildMode_Object) {
+ // Allow a user override for the object extension.
+ ext = build_context.build_paths[BuildPath_Output].ext;
} else {
- if (is_arch_wasm()) {
- ext = STR_LIT(".wasm.o");
- } else {
- switch (build_context.metrics.os) {
- case TargetOs_windows:
- ext = STR_LIT(".obj");
- break;
- default:
- case TargetOs_darwin:
- case TargetOs_linux:
- case TargetOs_essence:
- ext = STR_LIT(".o");
- break;
-
- case TargetOs_freestanding:
- switch (build_context.metrics.abi) {
- default:
- case TargetABI_Default:
- case TargetABI_SysV:
- ext = STR_LIT(".o");
- break;
- case TargetABI_Win64:
- ext = STR_LIT(".obj");
- break;
- }
- break;
- }
- }
+ ext = infer_object_extension_from_build_context();
}
+ path = gb_string_append_length(path, ".", 1);
path = gb_string_append_length(path, ext.text, ext.len);
return make_string(cast(u8 *)path, gb_string_length(path));
diff --git a/src/main.cpp b/src/main.cpp
index dfc2f3213..af321258c 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -3889,6 +3889,16 @@ end_of_code_gen:;
if (!build_context.keep_executable) {
char const *filename = cast(char const *)exe_name.text;
gb_file_remove(filename);
+
+ if (build_context.ODIN_DEBUG) {
+ if (build_context.metrics.os == TargetOs_windows || build_context.metrics.os == TargetOs_darwin) {
+ String symbol_path = path_to_string(heap_allocator(), build_context.build_paths[BuildPath_Symbols]);
+ defer (gb_free(heap_allocator(), symbol_path.text));
+
+ filename = cast(char const *)symbol_path.text;
+ gb_file_remove(filename);
+ }
+ }
}
}
return 0;
diff --git a/tests/benchmark/all.odin b/tests/benchmark/all.odin
index a48872cc6..30640ac87 100644
--- a/tests/benchmark/all.odin
+++ b/tests/benchmark/all.odin
@@ -4,3 +4,4 @@ package benchmarks
@(require) import "crypto"
@(require) import "hash"
@(require) import "text/regex"
+@(require) import "strings" \ No newline at end of file
diff --git a/tests/benchmark/strings/benchmark_strings.odin b/tests/benchmark/strings/benchmark_strings.odin
new file mode 100644
index 000000000..866e8f756
--- /dev/null
+++ b/tests/benchmark/strings/benchmark_strings.odin
@@ -0,0 +1,131 @@
+package benchmark_strings
+
+import "base:intrinsics"
+import "core:fmt"
+import "core:log"
+import "core:testing"
+import "core:strings"
+import "core:text/table"
+import "core:time"
+import "core:unicode/utf8"
+
+RUNS_PER_SIZE :: 2500
+
+sizes := [?]int {
+ 7, 8, 9,
+ 15, 16, 17,
+ 31, 32, 33,
+ 63, 64, 65,
+ 95, 96, 97,
+ 128,
+ 256,
+ 512,
+ 1024,
+ 4096,
+}
+
+// These are the normal, unoptimized algorithms.
+
+plain_prefix_length :: proc "contextless" (a, b: string) -> (n: int) {
+ _len := min(len(a), len(b))
+
+ // Scan for matches including partial codepoints.
+ #no_bounds_check for n < _len && a[n] == b[n] {
+ n += 1
+ }
+
+ // Now scan to ignore partial codepoints.
+ if n > 0 {
+ s := a[:n]
+ n = 0
+ for {
+ r0, w := utf8.decode_rune(s[n:])
+ if r0 != utf8.RUNE_ERROR {
+ n += w
+ } else {
+ break
+ }
+ }
+ }
+ return
+}
+
+run_trial_size_prefix :: proc(p: proc "contextless" (string, string) -> $R, suffix: string, size: int, idx: int, runs: int, loc := #caller_location) -> (timing: time.Duration) {
+ left := make([]u8, size)
+ right := make([]u8, size)
+ defer {
+ delete(left)
+ delete(right)
+ }
+
+ if len(suffix) > 0 {
+ copy(left [idx:], suffix)
+ copy(right[idx:], suffix)
+
+ } else {
+ right[idx] = 'A'
+ }
+
+ accumulator: int
+
+ watch: time.Stopwatch
+
+ time.stopwatch_start(&watch)
+ for _ in 0..<runs {
+ result := p(string(left[:size]), string(right[:size]))
+ accumulator += result
+ }
+ time.stopwatch_stop(&watch)
+ timing = time.stopwatch_duration(watch)
+
+ log.debug(accumulator)
+ return
+}
+
+run_trial_size :: proc {
+ run_trial_size_prefix,
+}
+
+bench_table_size :: proc(algo_name: string, plain, simd: $P, suffix := "") {
+ string_buffer := strings.builder_make()
+ defer strings.builder_destroy(&string_buffer)
+
+ tbl: table.Table
+ table.init(&tbl)
+ defer table.destroy(&tbl)
+
+ table.aligned_header_of_values(&tbl, .Right, "Algorithm", "Size", "Iterations", "Scalar", "SIMD", "SIMD Relative (%)", "SIMD Relative (x)")
+
+ for size in sizes {
+ // Place the non-zero byte somewhere in the middle.
+ needle_index := size / 2
+
+ plain_timing := run_trial_size(plain, suffix, size, needle_index, RUNS_PER_SIZE)
+ simd_timing := run_trial_size(simd, suffix, size, needle_index, RUNS_PER_SIZE)
+
+ _plain := fmt.tprintf("%8M", plain_timing)
+ _simd := fmt.tprintf("%8M", simd_timing)
+ _relp := fmt.tprintf("%.3f %%", f64(simd_timing) / f64(plain_timing) * 100.0)
+ _relx := fmt.tprintf("%.3f x", 1 / (f64(simd_timing) / f64(plain_timing)))
+
+ table.aligned_row_of_values(
+ &tbl,
+ .Right,
+ algo_name,
+ size, RUNS_PER_SIZE, _plain, _simd, _relp, _relx)
+ }
+
+ builder_writer := strings.to_writer(&string_buffer)
+
+ fmt.sbprintln(&string_buffer)
+ table.write_plain_table(builder_writer, &tbl)
+
+ my_table_string := strings.to_string(string_buffer)
+ log.info(my_table_string)
+}
+
+@test
+benchmark_memory_procs :: proc(t: ^testing.T) {
+ bench_table_size("prefix_length ascii", plain_prefix_length, strings.prefix_length)
+ bench_table_size("prefix_length unicode", plain_prefix_length, strings.prefix_length, "🦉")
+} \ No newline at end of file
diff --git a/tests/core/strings/test_core_strings.odin b/tests/core/strings/test_core_strings.odin
index 7b5f7fbb4..140689468 100644
--- a/tests/core/strings/test_core_strings.odin
+++ b/tests/core/strings/test_core_strings.odin
@@ -1,9 +1,10 @@
package test_core_strings
+import "base:runtime"
import "core:mem"
import "core:strings"
import "core:testing"
-import "base:runtime"
+import "core:unicode/utf8"
@test
test_index_any_small_string_not_found :: proc(t: ^testing.T) {
@@ -218,3 +219,51 @@ test_builder_to_cstring :: proc(t: ^testing.T) {
testing.expect(t, err == .Out_Of_Memory)
}
}
+
+@test
+test_prefix_length :: proc(t: ^testing.T) {
+ prefix_length :: proc "contextless" (a, b: string) -> (n: int) {
+ _len := min(len(a), len(b))
+
+ // Scan for matches including partial codepoints.
+ #no_bounds_check for n < _len && a[n] == b[n] {
+ n += 1
+ }
+
+ // Now scan to ignore partial codepoints.
+ if n > 0 {
+ s := a[:n]
+ n = 0
+ for {
+ r0, w := utf8.decode_rune(s[n:])
+ if r0 != utf8.RUNE_ERROR {
+ n += w
+ } else {
+ break
+ }
+ }
+ }
+ return
+ }
+
+ cases := [][2]string{
+ {"Hellope, there!", "Hellope, world!"},
+ {"Hellope, there!", "Foozle"},
+ {"Hellope, there!", "Hell"},
+ {"Hellope! 🦉", "Hellope! 🦉"},
+ }
+
+ for v in cases {
+ p_scalar := prefix_length(v[0], v[1])
+ p_simd := strings.prefix_length(v[0], v[1])
+ testing.expect_value(t, p_simd, p_scalar)
+
+ s := v[0]
+ for len(s) > 0 {
+ p_scalar = prefix_length(v[0], s)
+ p_simd = strings.prefix_length(v[0], s)
+ testing.expect_value(t, p_simd, p_scalar)
+ s = s[:len(s) - 1]
+ }
+ }
+} \ No newline at end of file
generated by cgit v1.2.3 (git 2.39.1) at 2026-02-15 01:04:54 +0000