• 0 Posts
  • 310 Comments
Joined 3 years ago
cake
Cake day: July 9th, 2023

help-circle




  • C++ already does that for short strings

    I’ve already been discussing this. Maybe read the rest of the thread.

    Also the case in the standard library

    I think you’re missing the point of why. I built this to be a nearly drop in replacement for the standard string. If this wasn’t the case it would need to do even more processing and work to pass the strings to anything.

    discontinued because it was against the standard.

    Standards don’t matter for an internal type that’s not exposed to public APIs. I’m not trying to be exactly compatible with everything under the sun. There’s no undefined behavior here so it’s fine



  • 22 characters is significantly less useful than 255 characters. I use this for resource name keys, asset file paths, and a few other scenarios. The max size is configurable, so I know that nothing I am going to store is ever going to require heap allocations (really bad to be doing every frame in a game engine).

    I developed this specifically after benchmarking a simpler version and noticed a significant amount of time being spent in strlen(), and it had real benefits in my case.
    Admittedly just storing a struct with a static buffer and separate size would have worked pretty much the same and eliminated the 255 char limitation, but it was fun to build.



  • I came up with a kind of clever data type for storing short strings in a fixed size struct so they can be stored on the stack or inline without any allocations.
    It’s always null-terminated so it can be passed directly as a C-style string, but it also stores the string length without using any additional data (Getting the length would normally have to iterate to find the end).
    The trick is to store the number of unused bytes in the last character of the buffer. When the string is full, there are 0 unused bytes and the size byte overlaps the null terminator.
    (Only works for strings < 256 chars excluding null byte)

    Implementation in C++ here: https://github.com/frustra/strayphotons/blob/master/src/common/common/InlineString.hh

    Edit: Since a couple people don’t seem to understand the performance impact of this vs regular std::string, here’s a demo: https://godbolt.org/z/34j7obnbs This generates 10000 strings like “Hello, World! 00001” via concatenation. The effect is huge in debug mode, but still has performance benefits with optimizations turned on:

    With -O3 optimization
    std::string: 0.949216ms
    char[256] with strlen: 0.88104ms
    char[256] without strlen: 0.684734ms
    
    With no optimization:
    std::string: 3.5501ms
    char[256] with strlen: 0.885888ms
    char[256] without strlen: 0.687733ms
    
    (You may need to run it a few times to get sample numbers due to random server load on godbolt)
    Changing the buffer size to 32 bytes has a negligible performance improvement over 256 bytes in this case, but might be slightly faster due to the whole string fitting in a cache line.
    



  • they want them to be rich, happy and healthy so they keep coming back and spending more money.

    See there’s the problem right there. They don’t need customers to be any of those things to suck every last cent out of them. Corporations would love nothing more than becoming a monopoly on human essentials like food, water, housing, etc… because people will go to great lengths to afford food whether they like it or not.



  • To me, the term evokes a feeling of an unmaintained mechanical machine that isn’t running right. Considering it seems to be meant as a derogatory term towards LLMs, I understand how it came about, though personally I can’t get over the similarity to “clunker” which is often used endearingly to refer to an old vehicle. I wish we had a term that was more associated with digital systems.