Logger.h

Go to the documentation of this file.

/* Copyright (c) 2018 Skyward Experimental Rocketry
 * Author: Federico Terraneo
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
 
#pragma once
 
#include <Singleton.h>
#include <interfaces/atomic_ops.h>
#include <miosix.h>
#include <stdint.h>
#include <utils/Debug.h>
 
#include <atomic>
#include <cstdio>
#include <list>
#include <queue>
#include <string>
#include <type_traits>
#include <userde.hpp>
 
#include "LoggerStats.h"
 
namespace Boardcore
{
 
constexpr char MappingMarker = '!';
 
enum TypeIDByte : char
{
    Unknown = '?',
    Bool    = 'b',
    Char    = 'c',
    Int8    = 'h',
    UInt8   = 'H',
    Int16   = 'i',
    UInt16  = 'I',
    Int32   = 'j',
    UInt32  = 'J',
    Int64   = 'l',
    UInt64  = 'L',
    Float   = 'f',
    Double  = 'd',
};
 
template <typename T, typename = void>
struct TypeID
{
    static constexpr char VALUE = TypeIDByte::Unknown;
};
 
#define TYPEID_STRUCT(type, character)           \
    template <>                                  \
    struct TypeID<type>                          \
    {                                            \
        static constexpr char VALUE = character; \
    };
 
TYPEID_STRUCT(bool, TypeIDByte::Bool)
TYPEID_STRUCT(char, TypeIDByte::Char)
TYPEID_STRUCT(int8_t, TypeIDByte::Int8)
TYPEID_STRUCT(uint8_t, TypeIDByte::UInt8)
TYPEID_STRUCT(int16_t, TypeIDByte::Int16)
TYPEID_STRUCT(uint16_t, TypeIDByte::UInt16)
TYPEID_STRUCT(int32_t, TypeIDByte::Int32)
TYPEID_STRUCT(uint32_t, TypeIDByte::UInt32)
TYPEID_STRUCT(int64_t, TypeIDByte::Int64)
TYPEID_STRUCT(uint64_t, TypeIDByte::UInt64)
TYPEID_STRUCT(float, TypeIDByte::Float)
TYPEID_STRUCT(double, TypeIDByte::Double)
 
template <typename T>
struct TypeID<T, std::enable_if_t<std::is_enum<T>::value>>
{
    static constexpr char VALUE = TypeID<std::underlying_type_t<T>>::VALUE;
};
 
template <typename T>
struct TypePrinter
{
    static constexpr void print(std::string& mappingString,
                                uint8_t* numberOfTypes, const char* name)
    {
        static_assert(TypeID<T>::VALUE != TypeIDByte::Unknown,
                      "Unknown TypeID '?'. This type is not supported for "
                      "logging, refer to the error log above for details.");
 
        mappingString += std::string(name);
        mappingString += '\0';
        mappingString += TypeID<T>::VALUE;
        mappingString += '\0';
 
        (*numberOfTypes) += 1;
    }
};
 
template <typename T, size_t I>
struct TypePrinter<T[I]>
{
    static constexpr void print(std::string& mappingString,
                                uint8_t* numberOfTypes, const char* name)
    {
        for (unsigned int i = 0; i < I; i++)
        {
            mappingString += std::string(name) + "[" + std::to_string(i) + "]";
            mappingString += '\0';
            mappingString += TypeID<T>::VALUE;
            mappingString += '\0';
 
            (*numberOfTypes) += 1;
        }
    }
};
 
enum class LoggerResult
{
    Queued,   
    Dropped,  
    Ignored,  
    TooLarge  
};
 
class Logger : public Singleton<Logger>
{
    friend class Singleton<Logger>;
 
public:
    bool start();
 
    void stop();
 
    static bool testSDCard();
 
    int getCurrentLogNumber();
 
    std::string getCurrentFileName();
 
    LoggerStats getStats();
 
    void resetStats();
 
    bool isStarted() const;
 
    template <typename T>
    LoggerResult log(const T& t);
 
    void logStats();
 
    static constexpr unsigned int getMaxFilenameNumber()
    {
        return maxFilenameNumber;
    }
 
private:
    Logger();
 
    static int findNextLogNumber();
 
    static std::string getLogName(int logNumber);
 
    static void packThreadLauncher(void* argv);
 
    static void writeThreadLauncher(void* argv);
 
    void packThread();
 
    void writeThread();
 
    static constexpr int maxFilenameNumber = 1024;  
 
#ifndef _ARCH_CORTEXM3_STM32F2
    static constexpr int maxRecordSize  = 512;   
    static constexpr int maxMappingSize = 1024;  
    static constexpr int numRecords     = 512;   
    static constexpr int numMappings    = 32;    
    static constexpr int numBuffers     = 8;     
    static constexpr int bufferSize     = 64 * 1024;  
#else
    static constexpr int maxRecordSize  = 512;       
    static constexpr int maxMappingSize = 1024;      
    static constexpr int numRecords     = 64;        
    static constexpr int numMappings    = 16;        
    static constexpr int numBuffers     = 8;         
    static constexpr int bufferSize     = 4 * 1024;  
#endif
 
    class MappingRecord
    {
    public:
        MappingRecord() : size(0) {}
        uint8_t data[maxMappingSize] = {};
        unsigned int size;  
    };
 
    class Record
    {
    public:
        Record() : size(0) {}
        uint8_t data[maxRecordSize] = {};
        unsigned int size;
        MappingRecord* mapping = nullptr;
    };
 
    template <typename T>
    LoggerResult mapType(const T& t, Record*& record);
 
    class Buffer
    {
    public:
        Buffer() : size(0) {}
        uint8_t data[bufferSize] = {};
        unsigned int size;
    };
 
    int fileNumber = -1;
 
    miosix::Queue<Record*, numRecords> fullRecordsQueue;
    miosix::Queue<Record*, numRecords> emptyRecordsQueue;
    miosix::Queue<MappingRecord*, numMappings> emptyMappingsQueue;
    std::queue<Buffer*, std::list<Buffer*>> fullBufferList;
    std::queue<Buffer*, std::list<Buffer*>> emptyBufferList;
 
    miosix::FastMutex mutex;  
    miosix::ConditionVariable cond;  
 
    miosix::Thread* packTh  = nullptr;  
    miosix::Thread* writeTh = nullptr;  
 
    std::atomic<bool> started{
        false};  
 
    FILE* file = nullptr;  
    LoggerStats stats;     
 
    static_assert(
        sizeof(int32_t) == sizeof(int),
        "Int type should be 32 bits in size, if that is not the case "
        "consider updating the reinterpret_cast in the atomicAdd calls");
};
 
template <typename T>
LoggerResult Logger::log(const T& t)
{
    // The last log number for which mapping information was written
    // A boolean is not enough because the logger can be restarted many times
    static int lastMappedLog = -1;
 
    if (started == false)
    {
        stats.droppedSamples++;
        // Signal that we are trying to write to a closed log
        stats.lastWriteError = -1;
        return LoggerResult::Ignored;
    }
 
    T mutableCopy  = t;  // TODO: update socrate to remove this
    Record* record = nullptr;
    // Retrieve a record from the empty queue, if available
    {
        // We disable interrupts because IRQget() is nonblocking, unlike get()
        miosix::FastInterruptDisableLock dLock;
        if (emptyRecordsQueue.IRQget(record) == false)
        {
            stats.droppedSamples++;
            return LoggerResult::Dropped;
        }
    }
 
    // Copy the data in the record
    auto result = socrate::userde::serialize_with_name<T>(
        mutableCopy, record->data, maxRecordSize);
 
    // If the record is too small, move the record in the empty queue and
    // error
    if (result == socrate::userde::Error::BufferTooSmall)
    {
        emptyRecordsQueue.put(record);
        miosix::atomicAdd(reinterpret_cast<int*>(&stats.tooLargeSamples), 1);
        TRACE("The current record size is not enough to store %s\n",
              T::reflect().type_name());
        return LoggerResult::TooLarge;
    }
 
    record->size = socrate::userde::Serde<T>::size() +
                   strlen(T::reflect().type_name()) + 1;
 
    if (lastMappedLog != fileNumber)
    {
        auto mapResult = mapType(t, record);
 
        if (mapResult != LoggerResult::Queued)
        {
            // Mapping failed, scrap the logged data and return the error
            emptyRecordsQueue.put(record);
            return mapResult;
        }
 
        // Mark mapping successful
        lastMappedLog = fileNumber;
    }
    else
    {
        record->mapping = nullptr;  // No mapping for this record
    }
 
    // Move the record to the full queue, where the pack thread will read and
    // store it in a buffer
    fullRecordsQueue.put(record);
 
    miosix::atomicAdd(reinterpret_cast<int*>(&stats.queuedSamples), 1);
 
    return LoggerResult::Queued;
}
 
template <typename T>
LoggerResult Logger::mapType(const T& t, Record*& record)
{
    MappingRecord* mapping = nullptr;
    // Retrieve a record from the empty queue, if available
    {
        // We disable interrupts because IRQget() is nonblocking, unlike get()
        miosix::FastInterruptDisableLock dLock;
        if (emptyMappingsQueue.IRQget(mapping) == false)
        {
            stats.droppedSamples++;
            return LoggerResult::Dropped;
        }
    }
 
    std::string mappingString;         // This is the complete mapping string
    std::string partialMappingString;  // This string only conains the type
                                       // names and their typeIDs
    uint8_t numberOfTypes =
        0;  // This is used to get the number of fields in the type
            // (we want to count all of the elements of an array)
 
    mappingString += MappingMarker;  // Marks the beginning of a mapping
    mappingString += T::reflect().type_name();
    mappingString += '\0';
 
    T::reflect().for_each_field_type(
        [&](const char* name, auto type)
        {
            using Type = typename decltype(type)::Type;
            TypePrinter<Type>::print(partialMappingString, &numberOfTypes,
                                     name);
        });
 
    // now that we have all of the information we need we can merge the mapping
    // strings
    mappingString += numberOfTypes;
    mappingString += '\0';
    mappingString += partialMappingString;
 
    // check if the mapping size is too large for the record, if it's too small
    // move the record to the empty queue
    if (mappingString.size() > maxRecordSize)
    {
        emptyMappingsQueue.put(mapping);
        TRACE(
            "The current record size is not enough to store the mapping of "
            "%s\n",
            T::reflect().type_name());
        return LoggerResult::TooLarge;
    }
 
    // If the record is big enough, copy the mapping string in the record
    memcpy(mapping->data, mappingString.c_str(), mappingString.size());
    mapping->size = mappingString.size();
 
    // Add the mapping to the record
    record->mapping = mapping;
 
    miosix::atomicAdd(reinterpret_cast<int*>(&stats.queuedMappings), 1);
 
    return LoggerResult::Queued;
}
 
}  // namespace Boardcore