btf.h

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <any>
#include <fstream>
#include <iostream>
#include <list>
#include <sstream>
#include <string>
#include <string_view>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#include "btf_entity_types.h"
#include "btf_signal.h"
#include "common.h"
#include "core.h"
#include "os.h"
#include "process.h"
#include "runnable.h"
#include "scheduler.h"
#include "semaphore.h"
#include "simulation.h"
#include "stimulus.h"
 
// Supported Entities
//  - Cores (only idle, execution and frequency change)
//  - OS
//  - Tasks/ISRs (Process)
//  - Runnables
//  - Scheduler
//  - Signals
//  - Stimuli
 
// Not supported general
//  - Entity Id Tables
 
// FIXME propably better to make the storage of events a vector (not a list), because faster and random accessable
//          requires to drop support for instertEvent
 
namespace btf
{
 
struct PairHash
{
    template <typename T1, typename T2> std::size_t operator()(const std::pair<T1, T2>& p) const
    {
        auto hash1 = std::hash<T1>{}(p.first);
        auto hash2 = std::hash<T1>{}(p.second);
 
        return (hash1 << 1) + hash1 + hash2;
    }
};
 
struct TupleHash
{
    template <typename T1, typename T2, typename T3> std::size_t operator()(const std::tuple<T1, T2, T3>& t) const
    {
        return std::get<0>(t)
               ^ std::get<1>(t)
               ^ std::get<2>(t);
    }
};
 
struct QuadrupleHash
{
    template <typename T1, typename T2, typename T3, typename T4> std::size_t operator()(const std::pair<std::tuple<T1, T2, T3>,T4>& q) const
    {
        return std::get<0>(q.first)
               ^ std::get<1>(q.first)
               ^ std::get<2>(q.first)
               ^ q.second;
    }
};
 
class BtfEntry
{
  public:
  
    union Events {
        Core::Events core_event;
        OS::Events os_event;
        Process::Events process_event;
        Runnable::Events runnable_event;
        Scheduler::Events scheduler_event;
        Semaphore::Events semaphore_event;
        Signal::Events signal_event;
        Simulation::Events simulation_event;
        Stimulus::Events stimulus_event;
 
        Events() : core_event(Core::Events::unknown){};
 
        Events(Core::Events ce) : core_event(ce){};
        
        Events(OS::Events oe) : os_event(oe){};
 
        Events(Process::Events te) : process_event(te){};
 
        Events(Runnable::Events re) : runnable_event(re){};
        
        Events(Scheduler::Events sche) : scheduler_event(sche){};
        
        Events(Semaphore::Events sem) : semaphore_event(sem){};
 
        Events(Signal::Events se) : signal_event(se){};
 
        Events(Stimulus::Events ste) : stimulus_event(ste){};
 
        Events(Simulation::Events se) : simulation_event(se){};
    };
 
    uint64_t time_{0};
 
    EntityTypes type_{EntityTypes::unknown};
 
    size_t source_hash_{0};
    uint64_t source_instance_{0};
    size_t target_hash_{0};
    uint64_t target_instance_{0};
    
    Events event_;
 
    std::string note_;
 
 
    std::string toString(std::unordered_map<size_t, std::string>& hash_map) const;
 
    std::string eventToString() const;
};
 
class BtfFile
{
  public:
    
    enum class TimeScales
    {
        pico_seconds,
        nano_seconds,
        micro_seconds,
        milli_seconds
    };
 
    explicit BtfFile(std::string path, TimeScales time_scale = TimeScales::nano_seconds, bool auto_suspend_parent_runnable = true,
                     bool source_is_core = true, bool auto_generate_core_events = false, bool auto_wait_resume_os_events = false);
 
    void finish();
 
    void importFromFile(const std::string& path, char delimiter = ',');
 
    void setStringHashMap(std::unordered_map<size_t, std::string> hash_map);
 
    ErrorCodes coreEvent(uint64_t time, const std::string& core, Core::Events core_event);
 
    ErrorCodes coreEvent(uint64_t time, size_t core_hash, Core::Events core_event);
 
    ErrorCodes osEvent(uint64_t time, const std::string& process, const std::string& os, OS::Events os_event);
 
    ErrorCodes osEvent(uint64_t time, size_t core_hash, size_t os_hash, OS::Events os_event);
 
 
    ErrorCodes taskMigrationEvent(uint64_t time, const std::string& source_core, const std::string& destination_core, const std::string& task,
                                  uint64_t task_instance_id);
 
    ErrorCodes taskMigrationEvent(uint64_t time, size_t source_core_hash, size_t destination_core_hash, size_t task_hash, uint64_t task_instance_id);
 
    ErrorCodes processEvent(uint64_t time, const std::string& source, const std::string& process, uint64_t process_instance_id, Process::Events process_event,
                         bool is_isr = false);
 
    ErrorCodes processEvent(uint64_t time, size_t source_hash, size_t process_hash, uint64_t process_instance_id, Process::Events process_event, bool is_isr = false);
 
    ErrorCodes runnableEvent(uint64_t time, const std::string& source, const std::string& runnable, Runnable::Events runnable_event);
 
    ErrorCodes runnableEvent(uint64_t time, size_t core_hash, size_t process_hash, size_t runnable_hash, Runnable::Events runnable_event);
 
    ErrorCodes semaphoreEvent(uint64_t time, const std::string& source, const std::string& target, Semaphore::Events semaphore_event, uint64_t note);
 
    ErrorCodes semaphoreEvent(uint64_t time, size_t semaphore_hash, Semaphore::Events semaphore_event, uint64_t note);
 
    ErrorCodes semaphoreEvent(uint64_t time, size_t core_hash, size_t semaphore_hash, Semaphore::Events semaphore_event, uint64_t note);
 
 
    ErrorCodes schedulerEvent(uint64_t time, const std::string& source, const std::string& scheduler, Scheduler::Events scheduler_event);
 
    ErrorCodes schedulerEvent(uint64_t time, size_t core_hash, size_t scheduler_hash, Scheduler::Events scheduler_event);
 
    ErrorCodes schedulerEvent(uint64_t time, size_t scheduler_hash, Scheduler::Events scheduler_event);
 
    ErrorCodes signalEvent(uint64_t time, const std::string& source, const std::string& signal, Signal::Events signal_event,
                           const std::string& signal_value = "");
 
    ErrorCodes signalEvent(uint64_t time, size_t core_hash, size_t signal_hash, Signal::Events signal_event, const std::string& signal_value = "");
    
    ErrorCodes stimulusEvent(uint64_t time, const std::string& source, const std::string& target, Stimulus::Events stimulus_event);
 
    ErrorCodes stimulusEvent(uint64_t time, size_t stimulus_hash, Stimulus::Events stimulus_event);
    
    
    std::list<std::list<BtfEntry>::iterator> getEventsForEntity(const std::string& entity);
    std::list<std::list<BtfEntry>::iterator> getEventsForEntity(size_t entity_hash);
 
    void comment(const std::string& comment);
 
    void headerEntry(const std::string& header_entry);
 
    void insertEvent(std::list<std::list<BtfEntry>::iterator>::iterator pos, const BtfEntry& entry);
 
    std::list<std::list<BtfEntry>::iterator>& getEntityEvents(const std::string& entity);
 
    std::list<BtfEntry> getAllEvents() const;
 
    size_t getNumberOfAllEvents() const;
 
    ErrorCodes simulationEventProcessName(uint64_t time, const std::string& process, const std::string& name);
 
    ErrorCodes simulationEventProcessName(uint64_t time, size_t process_hash, const std::string& name);
 
    ErrorCodes simulationEventProcessCreation(uint64_t time, const std::string& process, uint64_t pid, uint64_t ppid);
 
    ErrorCodes simulationEventProcessCreation(uint64_t time, size_t process_hash, uint64_t pid, uint64_t ppid);
 
    ErrorCodes simulationEventThreadName(uint64_t time, const std::string& thread, const std::string& name);
 
    ErrorCodes simulationEventThreadName(uint64_t time, size_t thread_hash, const std::string& name);
 
    ErrorCodes simulationEventThreadCreation(uint64_t time, const std::string& thread, uint64_t tid, uint64_t pid);
 
    ErrorCodes simulationEventThreadCreation(uint64_t time, size_t thread_hash, uint64_t tid, uint64_t pid);
 
    void setIgnoreMultipleTaskReleases(bool value);
 
  private:
    BtfFile(BtfFile&) = delete;
    BtfFile(BtfFile&&) = delete;
 
    void operator=(BtfFile&) = delete;
    void operator=(BtfFile&&) = delete;
 
    void generateCoreIdleEvent(uint64_t time, size_t source_hash);
 
    void generateCoreExecuteEvent(uint64_t time, size_t source_hash, Process::Events process_event);
 
    ErrorCodes checkTime(uint64_t time);
 
    ErrorCodes checkType(size_t hash, EntityTypes should_be_type);
 
    std::string getHeader() const;
 
 
 
    std::string path_;
 
    TimeScales time_scale_;
 
    uint64_t last_time_{0};
 
    std::unordered_map<size_t, Core> cores_;
 
    std::unordered_map<std::pair<size_t, uint64_t>, Process, PairHash> tasks_;
 
    std::unordered_map<std::pair<size_t, size_t>, Runnable, PairHash> runnables_;
 
    std::unordered_map<size_t, Semaphore> semaphores_;
 
    std::unordered_map<std::string, std::string> task_core_map_;
 
    std::unordered_map<std::pair<size_t, uint64_t>, std::vector<std::pair<size_t, uint64_t>>, PairHash> runnable_stacks_;
 
    std::unordered_map<std::pair<std::tuple<size_t, uint64_t, size_t>, size_t>, bool, QuadrupleHash> os_iswait_;
 
    std::unordered_map<size_t, std::string> hash_map_;
 
    std::list<BtfEntry> btf_entries_;
 
    std::unordered_map<size_t, std::list<std::list<BtfEntry>::iterator>> btf_entries_per_entity_;
 
    std::unordered_map<size_t, EntityTypes> type_map_; 
 
    std::unordered_map<size_t, std::pair<size_t, size_t>> current_running_tasks_;
 
    const std::pair<size_t, size_t> no_running_task_{0, 0};
 
    std::unordered_map<size_t, bool> did_de_allocated_task_event_occurred_on_core_; 
 
    std::unordered_map<size_t, uint64_t> stimuli_instance_ids_map_;
 
    std::unordered_map<size_t, std::vector<std::list<BtfEntry>::iterator>> runnable_without_task_buffers_; 
    
    std::unordered_map<size_t, std::vector<std::pair<size_t, uint64_t>>> runnable_without_task_stacks_;
 
    std::unordered_map<size_t, uint64_t> runnable_instance_id_counters_;
 
    std::vector<std::string> custom_header_entries_;
 
    std::unordered_map<size_t, bool> did_task_allocation_event_happen_on_core_;
 
    bool auto_suspend_parent_runnable_;
 
    bool source_is_core_;
 
    bool auto_generate_core_events_;
 
    bool auto_wait_resume_os_events_;
 
    bool auto_generate_events_{true};
 
    bool ignore_multiple_task_releases_{ false };
};
} // namespace btf