Method encodeLogMsgs

runtime/Log.cc:208–268

* Interprets the uncompressed log messages (created by the compile-time * generated code) contained in the *from buffer and compresses them to * the internal buffer. The encoded data can later be retrieved via swapBuffer() * * \param from * A buffer containing the uncompressed log message created by the * compile-time generated code * \param nbytes * Maximum number of bytes

 *      insufficient space in the internal buffer to fit the compressed message.
 */
long
Log::Encoder::encodeLogMsgs(char *from,
                                    uint64_t nbytes,
                                    uint32_t bufferId,
                                    bool newPass,
                                    uint64_t *numEventsCompressed)
{
    if (!encodeBufferExtentStart(bufferId, newPass))
        return 0;

    uint64_t lastTimestamp = 0;
    long remaining = nbytes;
    long numEventsProcessed = 0;
    char *bufferStart = writePos;

    while (remaining > 0) {
        auto *entry = reinterpret_cast<UncompressedEntry*>(from);

        if (entry->entrySize > remaining) {
            if (entry->entrySize < (NanoLogConfig::STAGING_BUFFER_SIZE/2))
                break;

            GeneratedFunctions::LogMetadata &lm
                            = GeneratedFunctions::logId2Metadata[entry->fmtId];
            fprintf(stderr, "ERROR: Attempting to log a message that is %u "
                            "bytes while the maximum allowable size is %u.\r\n"
                            "This occurs for the log message %s:%u '%s'\r\n",
                            entry->entrySize,
                            NanoLogConfig::STAGING_BUFFER_SIZE/2,
                            lm.fileName, lm.lineNumber, lm.fmtString);
        }

        // Check for free space using the worst case assumption that
        // none of the arguments compressed and there are as many Nibbles
        // as there are data bytes.
        uint32_t maxCompressedSize = downCast<uint32_t>(2*entry->entrySize
                                + sizeof(Log::UncompressedEntry));
        if (maxCompressedSize > (endOfBuffer - writePos))
            break;

        compressLogHeader(entry, &writePos, lastTimestamp);
        lastTimestamp = entry->timestamp;

        size_t argBytesWritten =
            GeneratedFunctions::compressFnArray[entry->fmtId](entry, writePos);
        writePos += argBytesWritten;

        remaining -= entry->entrySize;
        from += entry->entrySize;

        ++numEventsProcessed;
    }

    assert(currentExtentSize);
    *currentExtentSize += downCast<uint32_t>(writePos - bufferStart);

    if (numEventsCompressed)
        *numEventsCompressed += numEventsProcessed;