Session.h

Go to the documentation of this file.

/***********************************************************************************************************************
*                                                                                                                      *
* ngscopeclient                                                                                                        *
*                                                                                                                      *
* Copyright (c) 2012-2026 Andrew D. Zonenberg and contributors                                                         *
* All rights reserved.                                                                                                 *
*                                                                                                                      *
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the     *
* following conditions are met:                                                                                        *
*                                                                                                                      *
*    * Redistributions of source code must retain the above copyright notice, this list of conditions, and the         *
*      following disclaimer.                                                                                           *
*                                                                                                                      *
*    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the       *
*      following disclaimer in the documentation and/or other materials provided with the distribution.                *
*                                                                                                                      *
*    * Neither the name of the author nor the names of any contributors may be used to endorse or promote products     *
*      derived from this software without specific prior written permission.                                           *
*                                                                                                                      *
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED   *
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL *
* THE AUTHORS BE HELD LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES        *
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR       *
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE       *
* POSSIBILITY OF SUCH DAMAGE.                                                                                          *
*                                                                                                                      *
***********************************************************************************************************************/
 
#ifndef Session_h
#define Session_h
 
class MainWindow;
class WaveformArea;
class DisplayedChannel;
 
#include "../xptools/HzClock.h"
#include "HistoryManager.h"
#include "PacketManager.h"
#include "PreferenceManager.h"
#include "Marker.h"
#include "TriggerGroup.h"
 
extern std::atomic<int64_t> g_lastWaveformRenderTime;
 
class Session;
 
class InstrumentConnectionState
{
public:
    InstrumentConnectionState(InstrumentThreadArgs args)
        : m_shuttingDown(false)
        , m_lastTriggerState(Oscilloscope::TRIGGER_MODE_WAIT)
    {
        args.shuttingDown = &m_shuttingDown;
 
        //Can't initialize this in initializer list because we need args.shuttingDown set first
        //cppcheck-suppress useInitializationList
        m_thread = std::make_unique<std::thread>(InstrumentThread, args);
    }
 
    ~InstrumentConnectionState()
    { Close(); }
 
    void Close()
    {
        if(m_thread)
        {
            //Terminate the thread
            m_shuttingDown = true;
            m_thread->join();
        }
        m_thread = nullptr;
    }
 
    std::atomic<bool> m_shuttingDown;
 
    std::unique_ptr<std::thread> m_thread;
 
    Oscilloscope::TriggerMode m_lastTriggerState;
};
 
class StringLessCaseInsensitive
{
public:
 
    bool operator()(const std::string& a, const std::string& b) const
    {
        size_t len = std::min(a.size(), b.size());
 
        for(size_t i=0; i<len; i++)
        {
            auto ca = tolower(a[i]);
            auto cb = tolower(b[i]);
 
            if(ca > cb)
                return false;
            if(ca < cb)
                return true;
        }
 
        if(a.size() < b.size())
            return true;
        return false;
    }
};
 
class Session
{
public:
    Session(MainWindow* wnd);
    virtual ~Session();
 
    bool OnMemoryPressure(MemoryPressureLevel level, MemoryPressureType type, size_t requestedSize);
 
    void ArmTrigger(TriggerGroup::TriggerType type, bool all=false);
    void StopTrigger(bool all=false);
    bool HasOnlineScopes();
    void DownloadWaveforms();
    bool CheckForWaveforms(vk::raii::CommandBuffer& cmdbuf);
    void RefreshAllFilters();
    void RefreshAllFiltersNonblocking();
    void RefreshDirtyFiltersNonblocking();
    bool RefreshDirtyFilters();
    void FlushConfigCache();
 
    void MarkChannelDirty(InstrumentChannel* chan);
 
    void RenderWaveformTextures(
        vk::raii::CommandBuffer& cmdbuf,
        std::vector<std::shared_ptr<InputDescriptor> >& channels);
 
    void Clear();
    void ClearBackgroundThreads();
 
    bool PreLoadFromYaml(const YAML::Node& node, const std::string& dataDir, bool online);
    bool LoadFromYaml(const YAML::Node& node, const std::string& dataDir, bool online);
    YAML::Node SerializeInstrumentConfiguration();
    YAML::Node SerializeMetadata();
    YAML::Node SerializeTriggerGroups();
    bool LoadTriggerGroups(const YAML::Node& node);
    YAML::Node SerializeFilterConfiguration();
    YAML::Node SerializeMarkers();
    bool SerializeWaveforms(const std::string& dataDir);
    bool SerializeSparseWaveform(SparseWaveformBase* wfm, const std::string& path);
    bool SerializeSparseWaveformV2(SparseWaveformBase* wfm, const std::string& path);
    bool SerializeUniformWaveform(UniformWaveformBase* wfm, const std::string& path);
 
    std::shared_ptr<PacketManager> AddPacketFilter(PacketDecoder* filter);
    void RemovePacketFilter(PacketDecoder* filter);
 
    void AddInstrument(std::shared_ptr<Instrument> inst, bool createDialogs = true);
    void RemoveInstrument(std::shared_ptr<Instrument> inst);
    std::shared_ptr<InstrumentConnectionState> GetInstrumentConnectionState(std::shared_ptr<Instrument> inst) { return m_instrumentStates[inst]; }
 
    bool IsMultiScope()
    { return m_multiScope; }
 
    MainWindow* GetMainWindow()
    { return m_mainWindow; }
 
    std::shared_ptr<OscilloscopeState> GetOscilloscopeState(std::shared_ptr<Oscilloscope> scope)
    {
        std::lock_guard<std::mutex> lock(m_scopeMutex);
        if(m_oscilloscopes.find(scope) == m_oscilloscopes.end())
            return nullptr;
        return m_oscilloscopes[scope];
    }
 
    std::shared_ptr<BERTState> GetBERTState(std::shared_ptr<BERT> bert)
    {
        std::lock_guard<std::mutex> lock(m_scopeMutex);
        if(m_berts.find(bert) == m_berts.end())
            return nullptr;
        return m_berts[bert];
    }
 
    std::shared_ptr<PowerSupplyState> GetPSUState(std::shared_ptr<SCPIPowerSupply> psu)
    {
        std::lock_guard<std::mutex> lock(m_scopeMutex);
        if(m_psus.find(psu) == m_psus.end())
            return nullptr;
        return m_psus[psu];
    }
 
    std::shared_ptr<FunctionGeneratorState> GetFunctionGeneratorState(std::shared_ptr<FunctionGenerator> awg)
    {
        std::lock_guard<std::mutex> lock(m_scopeMutex);
        if(m_awgs.find(awg) == m_awgs.end())
            return nullptr;
        return m_awgs[awg];
    }
 
    std::shared_ptr<MultimeterState> GetDmmState(std::shared_ptr<Multimeter> dmm)
    {
        std::lock_guard<std::mutex> lock(m_scopeMutex);
        if(m_meters.find(dmm) == m_meters.end())
            return nullptr;
        return m_meters[dmm];
    }
 
    std::shared_ptr<PacketManager> GetPacketManager(PacketDecoder* filter)
    {
        std::lock_guard<std::mutex> lock(m_packetMgrMutex);
 
        auto it = m_packetmgrs.find(filter);
        if(it != m_packetmgrs.end())
            return it->second;
 
        else
        {
            LogWarning(
                "No packet manager found for filter %s (this should never happen). "
                "Creating a new one to avoid crashing\n",
                filter->GetDisplayName().c_str());
 
            auto ret = std::make_shared<PacketManager>(filter, *this);
            m_packetmgrs[filter] = ret;
            return ret;
        }
    }
 
    void ApplyPreferences(std::shared_ptr<Oscilloscope> scope);
 
    size_t GetFilterCount();
 
    bool IsChannelBeingDragged();
 
    int64_t GetToneMapTime();
 
    int64_t GetFilterGraphExecTime()
    { return m_lastFilterGraphExecTime.load(); }
 
    int64_t GetLastWaveformRenderTime()
    { return g_lastWaveformRenderTime.load(); }
 
    double GetWaveformDownloadRate()
    {
        std::lock_guard<std::mutex> lock(m_perfClockMutex);
        return m_waveformDownloadRate.GetAverageHz();
    }
 
    const std::vector<std::shared_ptr<Oscilloscope>> GetScopes()
    {
        std::lock_guard<std::mutex> lock(m_scopeMutex);
        std::vector<std::shared_ptr<Oscilloscope>> scopes;
        for(auto it : m_oscilloscopes)
        {
            scopes.push_back(it.first);
        }
        return scopes;
    }
 
    const std::vector<std::shared_ptr<BERT> > GetBERTs()
    {
        std::lock_guard<std::mutex> lock(m_scopeMutex);
        std::vector<std::shared_ptr<BERT> > berts;
        for(auto& it : m_berts)
            berts.push_back(it.first);
        return berts;
    }
 
    std::set<std::shared_ptr<SCPIInstrument>> GetSCPIInstruments();
 
    std::set<std::shared_ptr<Instrument>> GetInstruments();
 
    size_t GetInstrumentCount()
    { return GetInstruments().size(); }
 
    bool CheckForPendingWaveforms();
 
    std::shared_mutex& GetWaveformDataMutex()
    { return m_waveformDataMutex; }
 
    HistoryManager& GetHistory()
    { return m_history; }
 
    void AddMarker(Marker m);
 
    void StartWaveformThreadIfNeeded();
 
    void ClearSweeps();
 
    std::mutex& GetRasterizedWaveformMutex()
    { return m_rasterizedWaveformMutex; }
 
    IDTable m_idtable;
 
    std::string m_generalNotes;
 
    std::string m_setupNotes;
 
    std::vector<std::shared_ptr<TriggerGroup> > GetTriggerGroups()
    {
        std::lock_guard<std::recursive_mutex> lock(m_triggerGroupMutex);
        return m_triggerGroups;
    }
 
    void GarbageCollectTriggerGroups();
 
    void MakeNewTriggerGroup(std::shared_ptr<Oscilloscope> scope);
    void MakeNewTriggerGroup(PausableFilter* filter);
 
    int64_t GetDeskew(std::shared_ptr<Oscilloscope> scope)
    { return m_scopeDeskewCal[scope]; }
 
    void SetDeskew(std::shared_ptr<Oscilloscope> scope, int64_t skew)
    { m_scopeDeskewCal[scope] = skew; }
 
    bool IsPrimaryOfMultiScopeGroup(std::shared_ptr<Oscilloscope> scope);
    bool IsSecondaryOfMultiScopeGroup(std::shared_ptr<Oscilloscope> scope);
 
    std::shared_ptr<TriggerGroup> GetTriggerGroupForScope(std::shared_ptr<Oscilloscope> scope);
    std::shared_ptr<TriggerGroup> GetTriggerGroupForFilter(PausableFilter* filter);
 
    const ConfigWarningList& GetWarnings()
    { return m_warnings; }
 
    std::shared_ptr<LoadState> GetLoadState(std::shared_ptr<Load> load)
    {
        auto it = m_loads.find(load);
        if(it != m_loads.end())
            return it->second;
        else
            return nullptr;
    }
 
    std::shared_ptr<TriggerGroup> GetTrendFilterGroup();
 
    void OnMarkerChanged();
 
    std::map<FlowGraphNode*, int64_t> GetFilterGraphRuntime()
    {
        std::lock_guard<std::mutex> lock(m_lastFilterGraphRuntimeMutex);
        return m_lastFilterGraphRuntimeStats;
    }
 
protected:
    void UpdatePacketManagers(const std::set<FlowGraphNode*>& nodes, bool nodesListIsComplete);
 
    std::string GetRegisteredTypeOfDriver(const std::string& drivername);
 
    bool LoadInstruments(int version, const YAML::Node& node, bool online);
    bool PreLoadInstruments(int version, const YAML::Node& node, bool online);
    SCPITransport* CreateTransportForNode(const YAML::Node& node);
    bool VerifyInstrument(const YAML::Node& node, std::shared_ptr<Instrument> inst);
    bool PreLoadVNA(int version, const YAML::Node& node, bool online);
    bool PreLoadOscilloscope(int version, const YAML::Node& node, bool online);
    bool PreLoadPowerSupply(int version, const YAML::Node& node, bool online);
    bool PreLoadRFSignalGenerator(int version, const YAML::Node& node, bool online);
    bool PreLoadFunctionGenerator(int version, const YAML::Node& node, bool online);
    bool PreLoadMultimeter(int version, const YAML::Node& node, bool online);
    bool PreLoadSpectrometer(int version, const YAML::Node& node, bool online);
    bool PreLoadSDR(int version, const YAML::Node& node, bool online);
    bool PreLoadBERT(int version, const YAML::Node& node, bool online);
    bool PreLoadLoad(int version, const YAML::Node& node, bool online);
    bool PreLoadMisc(int version, const YAML::Node& node, bool online);
    bool LoadFilters(int version, const YAML::Node& node);
    bool LoadInstrumentInputs(int version, const YAML::Node& node);
    bool LoadWaveformData(int version, const std::string& dataDir);
    bool LoadWaveformDataForScope(
        int version,
        const YAML::Node& node,
        std::shared_ptr<Oscilloscope> scope,
        const std::string& dataDir);
    bool LoadWaveformDataForFilters(
        int version,
        const YAML::Node& node,
        const std::string& dataDir);
    void DoLoadWaveformDataForStream(WaveformBase* cap, const std::string& format, const std::string& fname);
    bool ConvertLegacyUniformWaveforms();
 
    int m_fileLoadVersion;
 
    ConfigWarningList m_warnings;
 
    std::map<std::shared_ptr<Oscilloscope>, int64_t> m_scopeDeskewCal;
 
    std::mutex m_scopeMutex;
 
    std::shared_mutex m_waveformDataMutex;
 
    std::mutex m_filterUpdatingMutex;
 
    MainWindow* m_mainWindow;
 
    std::atomic<bool> m_shuttingDown;
 
    bool m_modifiedSinceLastSave;
 
    std::map<std::shared_ptr<Oscilloscope>, std::shared_ptr<OscilloscopeState> > m_oscilloscopes;
 
    std::map<std::shared_ptr<PowerSupply>, std::shared_ptr<PowerSupplyState> > m_psus;
 
    std::map<std::shared_ptr<Multimeter>, std::shared_ptr<MultimeterState> > m_meters;
 
    std::map<std::shared_ptr<Load>, std::shared_ptr<LoadState> > m_loads;
 
    std::map<std::shared_ptr<BERT>, std::shared_ptr<BERTState> > m_berts;
 
    std::map<std::shared_ptr<FunctionGenerator>, std::shared_ptr<FunctionGeneratorState> > m_awgs;
 
    std::vector<std::shared_ptr<TriggerGroup> > m_triggerGroups;
 
    std::shared_ptr<TriggerGroup> m_trendTriggerGroup;
 
    std::recursive_mutex m_triggerGroupMutex;
 
    std::map<std::shared_ptr<Instrument>, std::shared_ptr<InstrumentConnectionState> > m_instrumentStates;
 
    std::unique_ptr<std::thread> m_waveformThread;
 
    std::set<std::shared_ptr<Oscilloscope> > m_recentlyTriggeredScopes;
 
    std::set<std::shared_ptr<TriggerGroup>> m_recentlyTriggeredGroups;
 
    std::mutex m_recentlyTriggeredScopeMutex;
 
    double m_tArm;
 
    double m_tPrimaryTrigger;
 
    bool m_triggerArmed;
 
    bool m_triggerOneShot;
 
    FilterGraphExecutor m_graphExecutor;
 
    std::atomic<int64_t> m_lastFilterGraphExecTime;
 
    std::mutex m_lastFilterGraphRuntimeMutex;
 
    std::map<FlowGraphNode*, int64_t> m_lastFilterGraphRuntimeStats;
 
    std::mutex m_perfClockMutex;
 
    HzClock m_waveformDownloadRate;
 
    HistoryManager m_history;
 
    std::mutex m_packetMgrMutex;
 
    std::map<PacketDecoder*, std::shared_ptr<PacketManager> > m_packetmgrs;
 
    std::mutex m_rasterizedWaveformMutex;
 
    bool m_multiScope;
 
    // Markers
 
    std::map<TimePoint, std::vector<Marker> > m_markers;
 
    int m_nextMarkerNum;
 
    // Partial graph refreshes
 
    std::set<FlowGraphNode*> m_dirtyChannels;
 
    std::mutex m_dirtyChannelsMutex;
 
public:
 
    std::string GetNextMarkerName()
    { return std::string("M") + std::to_string(m_nextMarkerNum ++); }
 
    std::vector<Marker>& GetMarkers(TimePoint t)
    { return m_markers[t]; }
 
    std::vector<TimePoint> GetMarkerTimes();
 
    void RemoveMarkers(TimePoint t)
    { m_markers.erase(t); }
 
    void RemovePackets(TimePoint t);
 
    std::set<FlowGraphNode*> GetAllGraphNodes();
 
    std::optional<TimePoint> GetHoveredPacketTimestamp()
    { return m_hoverTime; }
 
    void SetHoveredPacketTimestamp(std::optional<TimePoint> t)
    { m_hoverTime = t; }
 
protected:
    std::optional<TimePoint> m_hoverTime;
 
public:
    // End user preferences (persistent across sessions)
 
    PreferenceManager& GetPreferences()
    { return PreferenceManager::GetPreferences(); }
 
    // Reference filters (used to query legal inputs to filters etc)
 
public:
 
    Filter* GetReferenceFilter(const std::string& name)
    { return m_referenceFilters[name]; }
 
    const std::map<std::string, Filter*, StringLessCaseInsensitive>& GetReferenceFilters()
    { return m_referenceFilters; }
 
    const std::vector<std::string>& GetDriverNamesForType(const std::string& type)
    { return m_driverNamesByType[type]; }
 
    bool CreateAndAddInstrument(
        const std::string& driver,
        SCPITransport* transport,
        const std::string& nickname);
 
protected:
    void CreateReferenceFilters();
    void DestroyReferenceFilters();
 
    std::map<std::string, Filter*, StringLessCaseInsensitive> m_referenceFilters;
 
    std::map<std::string, std::vector<std::string> > m_driverNamesByType;
};
 
#endif