|
Strings: How Sheerpower Stores Them |
String Attributes for Efficient Processing
This page describes how Sheerpower stores strings and the work its runtime saves when a program assigns, compares and joins them.
-
Length-Aware Strings
Sheerpower STRING variables store their length internally, allowing immediate length access without scanning for a terminator. -
Binary-Safe Content
Since the length is tracked internally, a STRING can include binary data, including embedded null characters.name$ = "A" + chr$(0) + "B" -
External Compatibility
When passed to routines in other languages, Sheerpower automatically appends a zero terminator for compatibility.call "c_function" (name$) ! name$ is zero-terminated
Optimized Memory Management
Efficient Buffer Reuse
Sheerpower manages strings by reusing memory buffers, which significantly reduces the overhead of memory allocations and deallocations. For example, if a string holds "The rain in Spain" and is later changed to "Enjoy life", Sheerpower repurposes the existing buffer. In most applications, over 99% of string buffers are reused.
This approach avoids the frequent memory operations that cause
performance bottlenecks in other languages.
All strings are over-allocated and virtually mutable, making assignments O(1)
operations with no allocation/deallocation cycles.
Comparison with Other Languages
In many languages, every string modification requires a new memory allocation, and the old memory must be deallocated. This cycle introduces overhead, especially in loops.
num$ = str$(i)
next i
num$. The buffer is reused in each iteration, a stark
contrast to languages that could perform 10,000 allocations and
deallocations, slowing down performance.
The Chunked Fixed Data Area (FDA) Optimized Memory Manager
Based on research showing 85% of business strings are under 128 bytes, Sheerpower pre-allocates thousands of fixed-size buffers on startup.
- Strings <= 24 bytes: Inline storage in descriptor
- Strings 25-128 bytes: Pre-allocated FDA chunk (eliminates 85% of malloc/free)
- Seven additional optimized string length ranges
- Strings > 65536 bytes: Traditional heap allocation
Performance Optimizations Internals
String Interning with Shared String IDs (SIDs)
Sheerpower assigns every unique string value a 64-bit sequential String ID (SID). When a string variable is first created, the runtime generates a new SID for its content. When another variable is assigned the same content—either by direct assignment or by copying—the SID from the source descriptor is copied into the destination descriptor along with the data. In other words, the SID travels with the data.
The SID is stored directly inside the string's descriptor, alongside the string's length, the pointer to its character buffer, and the buffer's current allocation size. Because the SID lives inside the descriptor rather than in a centralized lookup table, Sheerpower avoids global SID-table lookups and enables several powerful runtime optimizations:
inline buffer is used, no heap allocation.
- Length <= 24 bytes uses inline buffer.
- Allocation tracks current buffer size (here 24 bytes).
- SID 982734 marks the content "Hello".
- Equality check: compare SIDs, not characters.
- Reassigning A$ reuses the same buffer until it outgrows 24 bytes.
- Fast equality checks: compare SIDs instead of scanning characters. Equal SIDs mean the strings are identical, so the scan is skipped. If the SIDs differ, Sheerpower scans once to compare content; when the content matches, the higher (newer) SID is replaced with the lower (older) one, so every later comparison of those values takes the fast SID path again.
- Copy elimination: Skip copying when source and target already share SIDs
- Hints can be stored along with their SID to avoid re-parsing of previously parsed strings
Copy-on-Write for String Literals
String literal assignments cost almost nothing, as the descriptor simply points to the literal in the compiled code. A copy is only triggered upon modification.
Intelligent Caching and Hinting System
Sheerpower uses an internal hinting mechanism, using SIDs to remember recent operations and cache results. This enhances efficiency by avoiding redundant processing.
Concatenation Hinting: A cache-sized hint array remembers recent concatenation operations by SID combinations. For repetitive tasks like building SQL queries, subsequent operations become simple cache lookups.
Function Parameter Parsing Cache: Functions like
getword$() and geodistance() automatically cache
parsing results by string content.
If you call getword$(bible$, 1000) and then
getword$(bible$, 1001), Sheerpower uses the hint to
quickly find the next word without re-reading from the start.
Practical Benefits and Use Cases
These transparent optimizations provide the most benefit for typical business application patterns:
- Repetitive content (company names, status codes)
- SQL query building
- Report generation and template formatting
- Parsing repeated data formats
The savings grow with the amount of text a program handles: real-time data analysis and large batch runs gain the most.
