Trace Logger Feature Review and Merge

Fw/CMakeLists.txt

@@ -1,5 +1,5 @@
 # Module subdirectories
-set(FPRIME_FRAMEWORK_MODULES Fw_Prm Fw_Cmd Fw_Log Fw_Tlm Fw_Com Fw_Time Fw_Port Fw_Types Fw_Cfg CACHE INTERNAL "Fw mods")
+set(FPRIME_FRAMEWORK_MODULES Fw_Prm Fw_Cmd Fw_Trace Fw_Log Fw_Tlm Fw_Com Fw_Time Fw_Port Fw_Types Fw_Cfg CACHE INTERNAL "Fw mods")
 # Port subdirectories
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/Buffer/")
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/Cmd/")
@@ -10,6 +10,7 @@ add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/Logger/")
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/Prm/")
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/Time/")
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/Tlm/")
+add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/Trace/")
 
 # Framework subdirectories
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/Cfg/")

Fw/Cfg/SerIds.hpp

@@ -51,6 +51,7 @@ namespace Fw {
         FW_TYPEID_PRM_BUFF  =    46, //!< Parameter Buffer type id
         FW_TYPEID_PRM_STR   =    47, //!< Parameter string type id
         FW_TYPEID_FILE_BUFF =    48, //!< File piece Buffer type id
+        FW_TYPEID_TRACE_BUFF=    49, //!< Trace Buffer type id
 
         // Other types
 

Fw/Com/ComPacket.hpp

@@ -26,6 +26,7 @@ namespace Fw {
                 FW_PACKET_PACKETIZED_TLM, // !< Packetized telemetry packet type
                 FW_PACKET_DP, //!< Data product packet
                 FW_PACKET_IDLE, // !< Idle packet
+                FW_PACKET_TRACE, // !< Trace packet
                 FW_PACKET_UNKNOWN = 0xFF // !< Unknown packet
             } ComPacketType;
 

Fw/Trace/CMakeLists.txt

@@ -0,0 +1,16 @@
+####
+# F prime CMakeLists.txt:
+#
+# SOURCE_FILES: combined list of source and autocoding files
+# MOD_DEPS: (optional) module dependencies
+#
+####
+set(MOD_DEPS
+    Fw/Com
+)
+set(SOURCE_FILES
+  "${CMAKE_CURRENT_LIST_DIR}/TraceBuffer.cpp"
+  "${CMAKE_CURRENT_LIST_DIR}/TraceEntity.cpp"
+  "${CMAKE_CURRENT_LIST_DIR}/Trace.fpp"
+)
+register_fprime_module()

Fw/Trace/Trace.fpp

@@ -0,0 +1,13 @@
+module Fw {
+
+  type TraceBuffer
+
+
+  @ Port for sending Traces
+  port Trace(
+            $id: FwTraceIdType @< Trace ID
+            ref timeTag: Fw.Time @< Time Tag
+            $type: TraceCfg.TraceType @< The trace type argument
+            ref args: TraceBuffer @< Buffer containing serialized trace entry
+          )
+}

Fw/Trace/TraceBuffer.cpp

@@ -0,0 +1,60 @@
+#include <Fw/Trace/TraceBuffer.hpp>
+#include <Fw/Types/Assert.hpp>
+#include <Fw/Log/TextLogString.hpp>
+#include <stdio.h>
+
+namespace Fw {
+
+    TraceBuffer::TraceBuffer(const U8 *args, NATIVE_UINT_TYPE size) {
+        SerializeStatus stat = SerializeBufferBase::setBuff(args,size);
+        FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
+    }
+
+    TraceBuffer::TraceBuffer() {
+    }
+
+    TraceBuffer::~TraceBuffer() {
+    }
+
+    TraceBuffer::TraceBuffer(const TraceBuffer& other) : Fw::SerializeBufferBase() {
+        SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData,other.getBuffLength());
+        FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
+    }
+
+    TraceBuffer& TraceBuffer::operator=(const TraceBuffer& other) {
+        if(this == &other) {
+            return *this;
+        }
+
+        SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData,other.getBuffLength());
+        FW_ASSERT(FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));
+        return *this;
+    }
+
+    NATIVE_UINT_TYPE TraceBuffer::getBuffCapacity() const {
+        return sizeof(this->m_bufferData);
+    }
+
+    const U8* TraceBuffer::getBuffAddr() const {
+        return this->m_bufferData;
+    }
+
+    U8* TraceBuffer::getBuffAddr() {
+        return this->m_bufferData;
+    }
+
+    void TraceBuffer::toString(std::string& text) const{
+
+        //FW_ASSERT(text != nullptr);
+        FW_ASSERT(this->getBuffLength() < FW_TRACE_BUFFER_MAX_SIZE);
+
+        std::string str_format(reinterpret_cast<const char*>(this->m_bufferData),this->getBuffLength());
+        text += str_format;
+        /*char temp_text[1];
+        for (NATIVE_UINT_TYPE i = 0; i < this->getBuffLength(); i++) {
+            //snprintf(temp_text,sizeof(temp_text),"%d",this->m_bufferData[i]);
+            temp_text[0] = static_cast<char>(this->m_bufferData[i]);
+            text[i] = temp_text[0];
+        }*/
+    }
+}

Fw/Trace/TraceBuffer.hpp

@@ -0,0 +1,47 @@
+/*
+ * TraceBuffer.hpp
+ *
+ *      Author: sreddy
+ */
+
+/*
+ * Description:
+ * This object contains the TraceBuffer type, used for storing trace entries
+ */
+#ifndef FW_TRACE_BUFFER_HPP
+#define FW_TRACE_BUFFER_HPP
+
+#include <FpConfig.hpp>
+#include <Fw/Types/Serializable.hpp>
+#include <Fw/Cfg/SerIds.hpp>
+#include <string>
+
+namespace Fw {
+
+    class TraceBuffer : public SerializeBufferBase {
+        public:
+
+            enum {
+                SERIALIZED_TYPE_ID = FW_TYPEID_TRACE_BUFF,
+                SERIALIZED_SIZE = FW_TRACE_BUFFER_MAX_SIZE+ sizeof(FwBuffSizeType)
+            };
+
+            TraceBuffer(const U8 *args, NATIVE_UINT_TYPE size);
+            TraceBuffer();
+            TraceBuffer(const TraceBuffer& other);
+            virtual ~TraceBuffer();
+            TraceBuffer& operator=(const TraceBuffer& other);
+
+            NATIVE_UINT_TYPE getBuffCapacity() const; // !< returns capacity, not current size, of buffer
+            U8* getBuffAddr();
+            const U8* getBuffAddr() const;
+            //! Supports writing this buffer to a string representation
+            void toString(std::string& text) const;
+
+        private:
+            U8 m_bufferData[FW_TRACE_BUFFER_MAX_SIZE]; // command argument buffer
+    };
+
+}
+
+#endif

Fw/Trace/TraceEntity.cpp

@@ -0,0 +1,92 @@
+/*
+ * TraceEntity.cpp
+ *
+ */
+
+#include <Fw/Trace/TraceEntity.hpp>
+#include <Fw/Types/Assert.hpp>
+
+namespace Fw {
+
+    TraceEntity::TraceEntity() : m_id(0) {
+        this->m_type = FW_PACKET_TRACE;
+    }
+
+    TraceEntity::~TraceEntity() {
+    }
+
+    SerializeStatus TraceEntity::serialize(SerializeBufferBase& buffer) const {
+
+        SerializeStatus stat = ComPacket::serializeBase(buffer);
+        if (stat != FW_SERIALIZE_OK) {
+            return stat;
+        }
+
+        stat = buffer.serialize(this->m_id);
+        if (stat != FW_SERIALIZE_OK) {
+            return stat;
+        }
+
+        stat = buffer.serialize(this->m_timeTag);
+        if (stat != FW_SERIALIZE_OK) {
+            return stat;
+        }
+
+        // We want to add data but not size for the ground software
+        return buffer.serialize(this->m_traceBuffer.getBuffAddr(),m_traceBuffer.getBuffLength(),true);
+
+    }
+
+    SerializeStatus TraceEntity::deserialize(SerializeBufferBase& buffer) {
+        SerializeStatus stat = deserializeBase(buffer);
+        if (stat != FW_SERIALIZE_OK) {
+            return stat;
+        }
+
+        stat = buffer.deserialize(this->m_id);
+        if (stat != FW_SERIALIZE_OK) {
+            return stat;
+        }
+
+        stat = buffer.deserialize(this->m_timeTag);
+        if (stat != FW_SERIALIZE_OK) {
+            return stat;
+        }
+
+        // remainder of buffer must be telemetry value
+        NATIVE_UINT_TYPE size = buffer.getBuffLeft();
+        stat = buffer.deserialize(this->m_traceBuffer.getBuffAddr(),size,true);
+        if (stat == FW_SERIALIZE_OK) {
+            // Shouldn't fail
+            stat = this->m_traceBuffer.setBuffLen(size);
+            FW_ASSERT(stat == FW_SERIALIZE_OK,static_cast<NATIVE_INT_TYPE>(stat));
+        }
+        return stat;
+    }
+
+    void TraceEntity::setId(FwTraceIdType id) {
+        this->m_id = id;
+    }
+
+    void TraceEntity::setTraceBuffer(const TraceBuffer& buffer) {
+        this->m_traceBuffer = buffer;
+    }
+
+    void TraceEntity::setTimeTag(const Fw::Time& timeTag) {
+        this->m_timeTag = timeTag;
+    }
+
+    FwTraceIdType TraceEntity::getId() {
+        return this->m_id;
+    }
+
+    Fw::Time& TraceEntity::getTimeTag() {
+        return this->m_timeTag;
+    }
+
+    TraceBuffer& TraceEntity::getTraceBuffer() {
+         return this->m_traceBuffer;
+    }
+
+
+} /* namespace Fw */

Fw/Trace/TraceEntity.hpp

@@ -0,0 +1,41 @@
+/*
+ * TraceEntity.hpp
+ *
+ *      Author: sreddy
+ */
+
+#ifndef TRACEENTITY_HPP_
+#define TRACEENTITY_HPP_
+
+#include <Fw/Com/ComPacket.hpp>
+#include <Fw/Trace/TraceBuffer.hpp>
+#include <Fw/Time/Time.hpp>
+
+namespace Fw {
+
+    class TraceEntity : public ComPacket {
+        public:
+
+            TraceEntity();
+            virtual ~TraceEntity();
+
+            SerializeStatus serialize(SerializeBufferBase& buffer) const; //!< serialize contents
+            SerializeStatus deserialize(SerializeBufferBase& buffer);
+
+            void setId(FwTraceIdType id);
+            void setTraceBuffer(const TraceBuffer& buffer);
+            void setTimeTag(const Fw::Time& timeTag);
+
+            FwTraceIdType getId();
+            Fw::Time& getTimeTag();
+            TraceBuffer& getTraceBuffer();
+
+        protected:
+            FwTraceIdType m_id; // !< Channel id
+            Fw::Time m_timeTag; // !< time tag
+            TraceBuffer m_traceBuffer; // !< serialized argument data
+    };
+
+} /* namespace Fw */
+
+#endif /* TRACEENTITY_HPP_ */

Fw/Trace/docs/sdd.md

@@ -0,0 +1,25 @@
+\page FwTracePort Fw::Trace Port
+# Fw::Trace Port
+
+## 1. Introduction
+The `Fw::Trace` port is used to pass serialized trace log values with time tags to record diagnostic data that indicates the order of execution in software. 
+
+## 2. Requirements
+Trace Requirements in FPrime:
+1. F’Prime shall provide a feature called Trace to log diagnostic information on various points of software execution. 
+	- It is a way to create time correlation events as a reaction for resetting software. 
+2. Trace shall provide a port to log the following:
+	- Event ID : A unique identifier recording a “Trace Event”
+	- Time Tag : Captures a high precision timestamp
+	- Client Data : A small sample of user arguments recorded into trace buffer
+3. Trace shall create trace points and log events in software automatically for thread switching(?) and  ...TBD, ask Tim
+4. Trace shall provide a port for other components or user defined points to log events during software execution.
+5. Trace shall record log events in an in-memory logger with data products to dump the buffers
+6. Trace shall store data on a per thread basis so there is only one write to the buffer, preventing a need for mutual exclusion.
+7. Trace shall maintain a double buffer, one for logs collected in the previous run before the latest reset and the other for current autopsy events. This way during init a data product can be generated for the trace events from prior run while actively collecting current trace logs. 
+8. Trace logs shall be stored in recoverable memory so they can be preserved over resets
+9. Trace shall write the trace data (stored in buffers) to data products upon boot initialization, a reset and by ground command
+10. Trace shall provide a ground command to dump trace logs upon request. 
+11. Trace shall provide a command to enable/disable Trace logging as it can consume significant code and processing 
+12. Trace entries shall be put in a dictionary so ground systems can automatically decode trace data
+

Ref/Top/RefTopology.cpp

@@ -137,6 +137,10 @@ void configureTopology() {
 
     // Note: Uncomment when using Svc:TlmPacketizer
     //tlmSend.setPacketList(RefPacketsPkts, RefPacketsIgnore, 1);
+
+    //Configure Trace Logger filename and size to be used for storing trace data
+    traceLogger.configure("TraceFile.dat",2720000);
+    traceLogger.filterTraceType(0xF,Svc::TraceLogger_Enable::ENABLE);
 }
 
 // Public functions for use in main program are namespaced with deployment name Ref

Ref/Top/instances.fpp

@@ -165,5 +165,7 @@ module Ref {
   instance dpBufferManager: Svc.BufferManager base id 0x4C00
 
   instance version: Svc.Version base id 0x4D00 
+
+  instance trace: Svc.TraceLogger base id 0x4E00 
 
 }

Ref/Top/topology.fpp

@@ -59,6 +59,7 @@ module Ref {
     instance dpWriter
     instance dpBufferManager
     instance version
+    instance trace 
 
     # ----------------------------------------------------------------------
     # Pattern graph specifiers

Svc/CMakeLists.txt

@@ -48,6 +48,7 @@ add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/TlmChan/")
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/TlmPacketizer/")
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/SystemResources/")
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/Ports/VersionPorts")
+add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/TraceFileLogger/")
 
 # Text logger components included by default, 
 # but can be disabled if FW_ENABLE_TEXT_LOGGING=0 is desired.

Svc/Deframer/CMakeLists.txt

@@ -41,5 +41,5 @@ set(UT_SOURCE_FILES
   "${CMAKE_CURRENT_LIST_DIR}/test/ut-fprime-protocol/DeframerTestMain.cpp"
   "${CMAKE_CURRENT_LIST_DIR}/test/ut-fprime-protocol/UplinkFrame.cpp"
 )
-set(UT_MOD_DEPS STest)
+set( STest)
 register_fprime_ut(Svc_Deframer_fprime_protocol)