Introduction

When working with number formatters in performance-sensitive applications, caching is essential. Our original key generation method was functional but inefficient. By optimizing the key computation, we significantly improved performance and memory usage.

The Old Approach

Previously, the key was generated using a multiplication-based formula:

keyNum *= maxDigit * 100000000 + minDigit * 100000 + mode * 1000 + numberStyle * 10 + (usesGroup ? 1 : 0);
key = [NSString stringWithFormat:@"%ld_%@_%d", keyNum, locale.localeIdentifier, shouldMultiplied];

While this approach worked, it relied on large multiplications, making it inefficient and prone to overflow for larger values. Additionally, constructing the key as an NSString added unnecessary overhead.

The Optimized Approach

We improved efficiency by replacing multiplications with bitwise operations and optimizing string handling:

unsigned long keyNum = (maxDigit << 24) | (minDigit << 16) | (mode << 8) | (accuracyType << 4) | (numberStyle << 2) | (usesGroup << 1) | (shouldMultiplied ? 1 : 0);

size_t keyNumLength = keyNum == 0 ? 1 : (size_t)log10(keyNum) + 1;
size_t localeLength = strlen(localeCString);
size_t totalLength = keyNumLength + 1 + localeLength + 1;

snprintf(buffer, totalLength, "%ld_%s", keyNum, localeCString);
return @(buffer);

Why This is Better

1. Bitwise Operations for Speed – Using bit shifts and bitwise OR (|) eliminates expensive multiplications and ensures a compact representation of keyNum.

2. Memory Optimization – The old method generated multiple intermediate objects, while the new approach directly constructs the key in a buffer, reducing memory allocations.

3. Faster String Formatting – snprintf is more efficient than NSString stringWithFormat, reducing unnecessary overhead.

Performance Gains

This optimization improves speed and reduces memory usage, especially in scenarios where the formatter is frequently accessed. By leveraging bitwise operations and a more efficient string construction approach, we ensure a leaner and faster implementation.

Conclusion

Optimizing low-level operations like key generation can yield significant performance gains in high-traffic applications. This update enhances efficiency while maintaining correctness, making our number formatter caching system even more robust.