TheZone/clay
1
0
Fork 0
mirror of https://github.com/nicbarker/clay.git synced 2025-04-23 22:58:06 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Cleanup

Browse Source
This commit is contained in:
Nic Barker 2025-03-21 14:38:21 +13:00
parent 36f764b207
commit 598cc7e337
1 changed files with 19 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
clay.h
View File

@ -385,10 +385,6 @@ typedef struct {
// CLAY_TEXT_ALIGN_CENTER - Horizontally aligns wrapped lines of text to the center of their bounding box. // CLAY_TEXT_ALIGN_CENTER - Horizontally aligns wrapped lines of text to the center of their bounding box.
// CLAY_TEXT_ALIGN_RIGHT - Horizontally aligns wrapped lines of text to the right hand side of their bounding box. // CLAY_TEXT_ALIGN_RIGHT - Horizontally aligns wrapped lines of text to the right hand side of their bounding box.
Clay_TextAlignment textAlignment; Clay_TextAlignment textAlignment;
// When set to true, clay will hash the entire text contents of this string as an identifier for its internal
// text measurement cache, rather than just the pointer and length. This will incur significant performance cost for
// long bodies of text.
bool hashStringContents;
} Clay_TextElementConfig; } Clay_TextElementConfig;
CLAY__WRAPPER_STRUCT(Clay_TextElementConfig); CLAY__WRAPPER_STRUCT(Clay_TextElementConfig);
@ -877,8 +873,7 @@ CLAY_DLL_EXPORT int32_t Clay_GetMaxMeasureTextCacheWordCount(void);
// Modifies the maximum number of measured "words" (whitespace seperated runs of characters) that Clay can store in its internal text measurement cache. // Modifies the maximum number of measured "words" (whitespace seperated runs of characters) that Clay can store in its internal text measurement cache.
// This may require reallocating additional memory, and re-calling Clay_Initialize(); // This may require reallocating additional memory, and re-calling Clay_Initialize();
CLAY_DLL_EXPORT void Clay_SetMaxMeasureTextCacheWordCount(int32_t maxMeasureTextCacheWordCount); CLAY_DLL_EXPORT void Clay_SetMaxMeasureTextCacheWordCount(int32_t maxMeasureTextCacheWordCount);
// Resets Clay's internal text measurement cache, useful if memory to represent strings is being re-used. // Resets Clay's internal text measurement cache. Useful if font mappings have changed or fonts have been reloaded.
// Similar behaviour can be achieved on an individual text element level by using Clay_TextElementConfig.hashStringContents
CLAY_DLL_EXPORT void Clay_ResetMeasureTextCache(void); CLAY_DLL_EXPORT void Clay_ResetMeasureTextCache(void);
// Internal API functions required by macros ---------------------- // Internal API functions required by macros ----------------------
@ -1349,18 +1344,15 @@ Clay_ElementId Clay__HashString(Clay_String key, const uint32_t offset, const ui
} }
#if !defined(CLAY_DISABLE_SIMD) && (defined(__x86_64__) || defined(_M_X64) || defined(_M_AMD64)) #if !defined(CLAY_DISABLE_SIMD) && (defined(__x86_64__) || defined(_M_X64) || defined(_M_AMD64))
// Rotate left in AVX (equivalent to _mm_rol_epi64 in AVX2)
static inline __m128i Clay__SIMDRotateLeft(__m128i x, int r) { static inline __m128i Clay__SIMDRotateLeft(__m128i x, int r) {
return _mm_or_si128(_mm_slli_epi64(x, r), _mm_srli_epi64(x, 64 - r)); return _mm_or_si128(_mm_slli_epi64(x, r), _mm_srli_epi64(x, 64 - r));
} }
// A simple ARX mix function (AVX)
static inline void Clay__SIMDARXMix(__m128i* a, __m128i* b) { static inline void Clay__SIMDARXMix(__m128i* a, __m128i* b) {
*a = _mm_add_epi64(*a, *b); *a = _mm_add_epi64(*a, *b);
*b = _mm_xor_si128(Clay__SIMDRotateLeft(*b, 17), *a); *b = _mm_xor_si128(Clay__SIMDRotateLeft(*b, 17), *a);
} }
// SIMD ARX hash function (AVX)
uint64_t Clay__HashData(const uint8_t* data, size_t len) { uint64_t Clay__HashData(const uint8_t* data, size_t len) {
// Pinched these constants from the BLAKE implementation // Pinched these constants from the BLAKE implementation
__m128i v0 = _mm_set1_epi64x(0x6a09e667f3bcc908ULL); __m128i v0 = _mm_set1_epi64x(0x6a09e667f3bcc908ULL);
@ -1408,19 +1400,16 @@ uint64_t Clay__HashData(const uint8_t* data, size_t len) {
return result[0] ^ result[1]; return result[0] ^ result[1];
} }
#elif !defined(CLAY_DISABLE_SIMD) && defined(__aarch64__) #elif !defined(CLAY_DISABLE_SIMD) && defined(__aarch64__)
// Rotate left in NEON (simulating _mm256_rol_epi64)
static inline uint64x2_t Clay__SIMDRotateLeft(uint64x2_t x, int r) { static inline uint64x2_t Clay__SIMDRotateLeft(uint64x2_t x, int r) {
return vorrq_u64(vshlq_n_u64(x, 17), vshrq_n_u64(x, 64 - 17)); return vorrq_u64(vshlq_n_u64(x, 17), vshrq_n_u64(x, 64 - 17));
} }
// A simple ARX mix function
static inline void Clay__SIMDARXMix(uint64x2_t* a, uint64x2_t* b) { static inline void Clay__SIMDARXMix(uint64x2_t* a, uint64x2_t* b) {
*a = vaddq_u64(*a, *b); *a = vaddq_u64(*a, *b);
*b = veorq_u64(Clay__SIMDRotateLeft(*b, 17), *a); *b = veorq_u64(Clay__SIMDRotateLeft(*b, 17), *a);
} }
// SIMD ARX hash function (NEON) uint64_t Clay__HashData(const uint8_t* data, size_t length) {
uint64_t Clay__HashData(const uint8_t* data, size_t len) {
// Pinched these constants from the BLAKE implementation // Pinched these constants from the BLAKE implementation
uint64x2_t v0 = vdupq_n_u64(0x6a09e667f3bcc908ULL); uint64x2_t v0 = vdupq_n_u64(0x6a09e667f3bcc908ULL);
uint64x2_t v1 = vdupq_n_u64(0xbb67ae8584caa73bULL); uint64x2_t v1 = vdupq_n_u64(0xbb67ae8584caa73bULL);
@ -1430,31 +1419,30 @@ uint64_t Clay__HashData(const uint8_t* data, size_t len) {
uint8_t overflowBuffer[8] = { 0 }; uint8_t overflowBuffer[8] = { 0 };
// Process 16-byte chunks // Process 16-byte chunks
while (len > 0) { while (length > 0) {
uint64x2_t msg; uint64x2_t msg;
if (len > 16) { if (length > 16) {
msg = vld1q_u64((const uint64_t*)data); msg = vld1q_u64((const uint64_t*)data);
data += 16; data += 16;
len -= 16; length -= 16;
} }
else if (len > 8) { else if (length > 8) {
msg = vcombine_u64(vld1_u64((const uint64_t*)data), vdup_n_u64(0)); msg = vcombine_u64(vld1_u64((const uint64_t*)data), vdup_n_u64(0));
data += 8; data += 8;
len -= 8; length -= 8;
} }
else { else {
for (int i = 0; i < len; i++) { for (int i = 0; i < length; i++) {
overflowBuffer[i] = data[i]; overflowBuffer[i] = data[i];
} }
uint8x8_t lower = vld1_u8(overflowBuffer); // Load up to 8 bytes uint8x8_t lower = vld1_u8(overflowBuffer);
msg = vcombine_u8(lower, vdup_n_u8(0)); // Zero upper 8 bytes msg = vcombine_u8(lower, vdup_n_u8(0));
len = 0; length = 0;
} }
v0 = veorq_u64(v0, msg); v0 = veorq_u64(v0, msg);
Clay__SIMDARXMix(&v0, &v1); Clay__SIMDARXMix(&v0, &v1);
Clay__SIMDARXMix(&v2, &v3); Clay__SIMDARXMix(&v2, &v3);
// Cross-lane mixing
v0 = vaddq_u64(v0, v2); v0 = vaddq_u64(v0, v2);
v1 = vaddq_u64(v1, v3); v1 = vaddq_u64(v1, v3);
} }
@ -1462,15 +1450,15 @@ uint64_t Clay__HashData(const uint8_t* data, size_t len) {
// Final mixing rounds // Final mixing rounds
Clay__SIMDARXMix(&v0, &v1); Clay__SIMDARXMix(&v0, &v1);
Clay__SIMDARXMix(&v2, &v3); Clay__SIMDARXMix(&v2, &v3);
v0 = vaddq_u64(v0, v2); v0 = vaddq_u64(v0, v2);
v1 = vaddq_u64(v1, v3); v1 = vaddq_u64(v1, v3);
// Extract final hash // Extract final hash
uint64_t result[2]; uint64_t result[2];
vst1q_u64(result, v0); vst1q_u64(result, v0);
return result[0] ^ result[1]; return result[0] ^ result[1];
} }
#else #else
uint64_t Clay__HashData(const uint8_t* data, size_t length) { uint64_t Clay__HashData(const uint8_t* data, size_t length) {
uint64_t hash = 0; uint64_t hash = 0;
@ -1485,10 +1473,7 @@ uint64_t Clay__HashData(const uint8_t* data, size_t length) {
#endif #endif
uint32_t Clay__HashStringContentsWithConfig(Clay_String *text, Clay_TextElementConfig *config) { uint32_t Clay__HashStringContentsWithConfig(Clay_String *text, Clay_TextElementConfig *config) {
uint32_t hash = 0; uint32_t hash = Clay__HashData((const uint8_t *)text->chars, text->length) % UINT32_MAX;
uintptr_t pointerAsNumber = (uintptr_t)text->chars;
hash = Clay__HashData((const uint8_t *)text->chars, text->length) % UINT32_MAX;
hash += config->fontId; hash += config->fontId;
hash += (hash << 10); hash += (hash << 10);