ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-08-01 20:28:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge core:simd/util into core:bytes

Browse Source
This commit is contained in:
Feoramund
2024-08-10 07:17:03 -04:00
parent e7e7fe766a
commit c69fa87d53
8 changed files with 164 additions and 246 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/bytes/bytes.odin
+130 -21
View File
@@ -2,10 +2,21 @@ package bytes
import "base:intrinsics"
import "core:mem"
@require import simd_util "core:simd/util"
import "core:unicode"
import "core:unicode/utf8"
@private SIMD_SCAN_WIDTH :: 32
@(private, rodata)
simd_scanner_indices := #simd[SIMD_SCAN_WIDTH]u8 {
0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31,
}
clone :: proc(s: []byte, allocator := context.allocator, loc := #caller_location) -> []byte {
c := make([]byte, len(s), allocator, loc)
copy(c, s)
@@ -295,43 +306,141 @@ split_after_iterator :: proc(s: ^[]byte, sep: []byte) -> ([]byte, bool) {
return _split_iterator(s, sep, len(sep))
}
/*
Scan a slice of bytes for a specific byte.
index_byte :: proc(s: []byte, c: byte) -> int {
_index_byte :: #force_inline proc "contextless" (s: []byte, c: byte) -> int {
for ch, i in s {
if ch == c {
This procedure safely handles slices of any length, including empty slices.
Inputs:
- data: A slice of bytes.
- c: The byte to search for.
Returns:
- index: The index of the byte `c`, or -1 if it was not found.
*/
index_byte :: proc(s: []byte, c: byte) -> (index: int) #no_bounds_check {
length := len(s)
i := 0
// Guard against small strings.
if length < SIMD_SCAN_WIDTH {
for /**/; i < length; i += 1 {
if s[i] == c {
return i
}
}
return -1
}
// NOTE(Feoramund): On my Alder Lake CPU, I have only witnessed a
// significant speedup when compiling in either Size or Speed mode.
// The SIMD version is usually 2-3x slower without optimizations on.
when ODIN_OPTIMIZATION_MODE > .Minimal {
return #force_inline simd_util.index_byte(s, c)
} else {
return _index_byte(s, c)
ptr := cast(int)cast(uintptr)raw_data(s)
alignment_start := (SIMD_SCAN_WIDTH - ptr % SIMD_SCAN_WIDTH) % SIMD_SCAN_WIDTH
// Iterate as a scalar until the data is aligned on a `SIMD_SCAN_WIDTH` boundary.
//
// This way, every load in the vector loop will be aligned, which should be
// the fastest possible scenario.
for /**/; i < alignment_start; i += 1 {
if s[i] == c {
return i
}
}
// Iterate as a vector over every aligned chunk, evaluating each byte simultaneously at the CPU level.
scanner: #simd[SIMD_SCAN_WIDTH]u8 = c
tail := length - (length - alignment_start) % SIMD_SCAN_WIDTH
for /**/; i < tail; i += SIMD_SCAN_WIDTH {
load := (cast(^#simd[SIMD_SCAN_WIDTH]u8)(&s[i]))^
comparison := intrinsics.simd_lanes_eq(load, scanner)
match := intrinsics.simd_reduce_or(comparison)
if match > 0 {
sentinel: #simd[SIMD_SCAN_WIDTH]u8 = u8(0xFF)
index_select := intrinsics.simd_select(comparison, simd_scanner_indices, sentinel)
index_reduce := intrinsics.simd_reduce_min(index_select)
return i + cast(int)index_reduce
}
}
// Iterate as a scalar over the remaining unaligned portion.
for /**/; i < length; i += 1 {
if s[i] == c {
return i
}
}
return -1
}
// Returns -1 if c is not present
last_index_byte :: proc(s: []byte, c: byte) -> int {
_last_index_byte :: #force_inline proc "contextless" (s: []byte, c: byte) -> int {
#reverse for ch, i in s {
if ch == c {
/*
Scan a slice of bytes for a specific byte, starting from the end and working
backwards to the start.
This procedure safely handles slices of any length, including empty slices.
Inputs:
- data: A slice of bytes.
- c: The byte to search for.
Returns:
- index: The index of the byte `c`, or -1 if it was not found.
*/
last_index_byte :: proc(s: []byte, c: byte) -> int #no_bounds_check {
length := len(s)
i := length - 1
// Guard against small strings.
if length < SIMD_SCAN_WIDTH {
for /**/; i >= 0; i -= 1 {
if s[i] == c {
return i
}
}
return -1
}
when ODIN_OPTIMIZATION_MODE > .Minimal {
return #force_inline simd_util.last_index_byte(s, c)
} else {
return _last_index_byte(s, c)
ptr := cast(int)cast(uintptr)raw_data(s)
tail := length - (ptr + length) % SIMD_SCAN_WIDTH
// Iterate as a scalar until the data is aligned on a `SIMD_SCAN_WIDTH` boundary.
//
// This way, every load in the vector loop will be aligned, which should be
// the fastest possible scenario.
for /**/; i >= tail; i -= 1 {
if s[i] == c {
return i
}
}
// Iterate as a vector over every aligned chunk, evaluating each byte simultaneously at the CPU level.
scanner: #simd[SIMD_SCAN_WIDTH]u8 = c
alignment_start := (SIMD_SCAN_WIDTH - ptr % SIMD_SCAN_WIDTH) % SIMD_SCAN_WIDTH
i -= SIMD_SCAN_WIDTH - 1
for /**/; i >= alignment_start; i -= SIMD_SCAN_WIDTH {
load := (cast(^#simd[SIMD_SCAN_WIDTH]u8)(&s[i]))^
comparison := intrinsics.simd_lanes_eq(load, scanner)
match := intrinsics.simd_reduce_or(comparison)
if match > 0 {
sentinel: #simd[SIMD_SCAN_WIDTH]u8
index_select := intrinsics.simd_select(comparison, simd_scanner_indices, sentinel)
index_reduce := intrinsics.simd_reduce_max(index_select)
return i + cast(int)index_reduce
}
}
// Iterate as a scalar over the remaining unaligned portion.
i += SIMD_SCAN_WIDTH - 1
for /**/; i >= 0; i -= 1 {
if s[i] == c {
return i
}
}
return -1
}
core/simd/util/util.odin
-160
View File
@@ -1,160 +0,0 @@
/*
(c) Copyright 2024 Feoramund <rune@swevencraft.org>.
Made available under Odin's BSD-3 license.
List of contributors:
Feoramund: `index_byte` procedures.
*/
// package simd_util implements compositions of SIMD operations for optimizing
// the core library where available.
package simd_util
import "base:intrinsics"
@private SCAN_WIDTH :: 32
@(private, rodata)
simd_scanner_indices := #simd[SCAN_WIDTH]u8 {
0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31,
}
/*
Scan a slice of bytes for a specific byte.
This procedure safely handles slices of any length, including empty slices.
Inputs:
- data: A slice of bytes.
- c: The byte to search for.
Returns:
- index: The index of the byte `c`, or -1 if it was not found.
*/
index_byte :: proc "contextless" (data: []u8, c: byte) -> (index: int) #no_bounds_check {
length := len(data)
i := 0
// Guard against small strings.
if length < SCAN_WIDTH {
for /**/; i < length; i += 1 {
if data[i] == c {
return i
}
}
return -1
}
ptr := cast(int)cast(uintptr)raw_data(data)
alignment_start := (SCAN_WIDTH - ptr % SCAN_WIDTH) % SCAN_WIDTH
// Iterate as a scalar until the data is aligned on a `SCAN_WIDTH` boundary.
//
// This way, every load in the vector loop will be aligned, which should be
// the fastest possible scenario.
for /**/; i < alignment_start; i += 1 {
if data[i] == c {
return i
}
}
// Iterate as a vector over every aligned chunk, evaluating each byte simultaneously at the CPU level.
scanner: #simd[SCAN_WIDTH]u8 = c
tail := length - (length - alignment_start) % SCAN_WIDTH
for /**/; i < tail; i += SCAN_WIDTH {
load := (cast(^#simd[SCAN_WIDTH]u8)(&data[i]))^
comparison := intrinsics.simd_lanes_eq(load, scanner)
match := intrinsics.simd_reduce_or(comparison)
if match > 0 {
sentinel: #simd[SCAN_WIDTH]u8 = u8(0xFF)
index_select := intrinsics.simd_select(comparison, simd_scanner_indices, sentinel)
index_reduce := intrinsics.simd_reduce_min(index_select)
return i + cast(int)index_reduce
}
}
// Iterate as a scalar over the remaining unaligned portion.
for /**/; i < length; i += 1 {
if data[i] == c {
return i
}
}
return -1
}
/*
Scan a slice of bytes for a specific byte, starting from the end and working
backwards to the start.
This procedure safely handles slices of any length, including empty slices.
Inputs:
- data: A slice of bytes.
- c: The byte to search for.
Returns:
- index: The index of the byte `c`, or -1 if it was not found.
*/
last_index_byte :: proc "contextless" (data: []u8, c: byte) -> int #no_bounds_check {
length := len(data)
i := length - 1
// Guard against small strings.
if length < SCAN_WIDTH {
for /**/; i >= 0; i -= 1 {
if data[i] == c {
return i
}
}
return -1
}
ptr := cast(int)cast(uintptr)raw_data(data)
tail := length - (ptr + length) % SCAN_WIDTH
// Iterate as a scalar until the data is aligned on a `SCAN_WIDTH` boundary.
//
// This way, every load in the vector loop will be aligned, which should be
// the fastest possible scenario.
for /**/; i >= tail; i -= 1 {
if data[i] == c {
return i
}
}
// Iterate as a vector over every aligned chunk, evaluating each byte simultaneously at the CPU level.
scanner: #simd[SCAN_WIDTH]u8 = c
alignment_start := (SCAN_WIDTH - ptr % SCAN_WIDTH) % SCAN_WIDTH
i -= SCAN_WIDTH - 1
for /**/; i >= alignment_start; i -= SCAN_WIDTH {
load := (cast(^#simd[SCAN_WIDTH]u8)(&data[i]))^
comparison := intrinsics.simd_lanes_eq(load, scanner)
match := intrinsics.simd_reduce_or(comparison)
if match > 0 {
sentinel: #simd[SCAN_WIDTH]u8
index_select := intrinsics.simd_select(comparison, simd_scanner_indices, sentinel)
index_reduce := intrinsics.simd_reduce_max(index_select)
return i + cast(int)index_reduce
}
}
// Iterate as a scalar over the remaining unaligned portion.
i += SCAN_WIDTH - 1
for /**/; i >= 0; i -= 1 {
if data[i] == c {
return i
}
}
return -1
}
core/strings/strings.odin
+3 -32
View File
@@ -2,8 +2,8 @@
package strings
import "base:intrinsics"
import "core:bytes"
import "core:io"
@require import simd_util "core:simd/util"
import "core:mem"
import "core:unicode"
import "core:unicode/utf8"
@@ -1426,23 +1426,7 @@ Output:
*/
index_byte :: proc(s: string, c: byte) -> (res: int) {
_index_byte :: #force_inline proc "contextless" (s: string, c: byte) -> int {
for i := 0; i < len(s); i += 1 {
if s[i] == c {
return i
}
}
return -1
}
// NOTE(Feoramund): On my Alder Lake CPU, I have only witnessed a
// significant speedup when compiling in either Size or Speed mode.
// The SIMD version is usually 2-3x slower without optimizations on.
when ODIN_OPTIMIZATION_MODE > .Minimal {
return #force_inline simd_util.index_byte(transmute([]u8)s, c)
} else {
return _index_byte(s, c)
}
return #force_inline bytes.index_byte(transmute([]u8)s, c)
}
/*
Returns the byte offset of the last byte `c` in the string `s`, -1 when not found.
@@ -1477,20 +1461,7 @@ Output:
*/
last_index_byte :: proc(s: string, c: byte) -> (res: int) {
_last_index_byte :: #force_inline proc "contextless" (s: string, c: byte) -> int {
for i := len(s)-1; i >= 0; i -= 1 {
if s[i] == c {
return i
}
}
return -1
}
when ODIN_OPTIMIZATION_MODE > .Minimal {
return #force_inline simd_util.last_index_byte(transmute([]u8)s, c)
} else {
return _last_index_byte(s, c)
}
return #force_inline bytes.last_index_byte(transmute([]u8)s, c)
}
/*
Returns the byte offset of the first rune `r` in the string `s` it finds, -1 when not found.