ElementSimState.h

Go to the documentation of this file.

// Copyright 2015 - 2026, GIBIS-UNIFESP and the wiRedPanda contributors
// SPDX-License-Identifier: GPL-3.0-or-later

 
#pragma once
 
#include <algorithm>
 
#include <QVector>
 
#include "App/Core/Enums.h"
 
class GraphicElement;
class InputPort;
class OutputPort;

class ElementSimState
{
public:
    struct InputConnection {
        GraphicElement *sourceElement = nullptr;
        int sourceOutputIndex = 0;
    };

    void initVectors(int inputCount, int outputCount, const QVector<OutputPort *> &outputPorts);

    void reset(const QVector<OutputPort *> &outputPorts);

    void connectPredecessor(int inputIndex, GraphicElement *source, int outputPort);

    bool updateInputs(bool allowUnknown, const QVector<InputPort *> &inputPorts);

    int decodeSelectValue(int offset, int count) const;

    Status outputValue(const int index = 0) const
    {
        if (index >= m_outputs.size()) { return Status::Unknown; }
        return m_outputs.at(index);
    }

    void setOutputValue(const int index, const Status value)
    {
        if (index >= m_outputs.size()) { return; }
        if (m_deferCommit) {
            // Synchronous sequential element mid-tick: stage the value so peers
            // still read the old output. commitDeferredOutputs() publishes it.
            m_staged[index] = value;
            return;
        }
        if (m_outputs[index] != value) { m_outputChanged = true; }
        m_outputs[index] = value;
    }

    qsizetype outputSize() const { return m_outputs.size(); }

    bool outputChanged() const { return m_outputChanged; }

    void clearOutputChanged() { m_outputChanged = false; }

    const QVector<Status> &inputs() const { return m_inputs; }

    const QVector<Status> &outputs() const { return m_deferCommit ? m_staged : m_outputs; }

    void beginDeferredCommit()
    {
        // Element-wise copy into persistent storage, deliberately NOT `m_staged =
        // m_outputs`: assignment CoW-shares the two buffers, so every staged write and
        // every commit write into m_outputs pays a detach (malloc + deep copy) -- per
        // sequential element, per simulation tick, even when nothing changed. The copy
        // keeps both buffers owned and the whole tick allocation-free. The resize is a
        // no-op in steady state (initVectors() sizes m_staged); it only guards a
        // mid-run port-count change.
        m_staged.resize(m_outputs.size());
        std::copy(m_outputs.cbegin(), m_outputs.cend(), m_staged.begin());
        m_deferCommit = true;
    }

    void commitDeferredOutputs()
    {
        m_deferCommit = false;
        for (int i = 0; i < m_staged.size() && i < m_outputs.size(); ++i) {
            setOutputValue(i, m_staged.at(i));
        }
    }
 
private:
    QVector<InputConnection> m_connections;
    QVector<Status> m_inputs;
    QVector<Status> m_outputs;
    QVector<Status> m_staged;
    bool m_outputChanged = false;
    bool m_deferCommit = false;
};