push() [2/3]

template<fl::size DescriptorCount, fl::size ArenaSize>

bool fl::AsyncLogQueue< DescriptorCount, ArenaSize >::push ( const char * str, fl::u16 len )

private

Implementation details.

Definition at line 117 of file async_log_queue.cpp.hpp.

                                                                               {
    if (len == 0) {
        return true;  // Empty message, accept but don't store
    }
 
    // Load indices (head is producer-owned, tail needs barrier)
    fl::u32 head = mHead;
    fl::u32 tail = loadTail();
    fl::u32 next = (head + 1) & (DescriptorCount - 1);
 
    // Check if descriptor ring is full
    if (next == tail) {
        atomicIncDropped();
        return false;
    }
 
    // Check if arena has enough free space
    fl::u32 aHead = mArenaHead;
    fl::u32 aTail = loadArenaTail();
 
    if (!arenaHasSpace(aHead, aTail, len)) {
        atomicIncDropped();
        return false;
    }
 
    // Allocate space in arena
    fl::u32 start = aHead;
 
    // Check if message would wrap past arena end
    if (start + len > ArenaSize) {
        // Insert padding to wrap to start of arena (contiguous records)
        fl::u32 padding = ArenaSize - start;
 
        // Check if padding + message fits
        if (!arenaHasSpace(aHead, aTail, static_cast<fl::u16>(padding + len))) {
            atomicIncDropped();
            return false;
        }
 
        // Advance arena head to skip padding bytes
        aHead = (aHead + padding) & (ArenaSize - 1);  // Should wrap to 0
        // Store message at wrapped position
        start = aHead;
    }
 
    // Copy message into arena (the only potentially slow operation in ISR)
    for (fl::u16 i = 0; i < len; i++) {
        mArena[start + i] = str[i];
    }
 
    // Advance arena head by message length
    fl::u32 newArenaHead = (aHead + len) & (ArenaSize - 1);
    {
        fl::isr::critical_section cs;  // Protect arena head update
        mArenaHead = newArenaHead;
    }
 
    // Write descriptor (data is already copied, safe to publish)
    mDescriptors[head].mStartIdx = start;
    mDescriptors[head].mLength = len;
 
    // Publish by advancing head (critical section for memory ordering)
    {
        fl::isr::critical_section cs;
        mHead = next;
    }
 
    return true;
}

References arenaHasSpace(), atomicIncDropped(), loadArenaTail(), loadTail(), mArena, mArenaHead, mDescriptors, and mHead.

Here is the call graph for this function: