从sc_signal驱动sc_out

Question

Consider the following example, where one module's output ( inner::out ) is supposed to drive two outputs ( outer::out and outer::out2 ) of the upper hierarchy level:

#include <systemc.h>

SC_MODULE(inner) {
    sc_out<bool> out;

    SC_CTOR(inner) : out("out") {
        SC_THREAD(doit);
    };

    void doit() {
        for (int i=0; i<10; ++i) {
            out != out;
            wait(10, SC_NS);
        }
    }
};


SC_MODULE(outer) {
    sc_out<bool> out, out2;

    SC_CTOR(outer) : out("out"), out2("out2"), i("inner"), out_s("out_s") {
        i.out(out_s);

        out(out_s);
        out2(out_s);
    }

    inner i;

    sc_signal<bool> out_s;
};


int sc_main(int argc, char **argv) {
    outer o("outer");

    sc_start(1, SC_MS);

    return 0;
}

https://www.edaplayground.com/x/5s2C#

Running this results in the following error:

Error: (E115) sc_signal<T> cannot have more than one driver: 
 signal `outer.out_s' (sc_signal)
 first driver `outer.inner.out'  (sc_out)
 second driver `outer.out2' (sc_out)
In file: ../../../../src/sysc/communication/sc_signal.cpp:73

It seems that outer::out2 is considered to drive out_s instead of being driven by it. Is there something obvious that I'm overlooking? Is there a way to make this work without using an explicit SC_METHOD sensitive to inner::out inside outer ?

Answer 1

Your design describes a signal driven by three different output ports -- not what you want.

You may want to use port-to-port binding . If you're not familiar with the concept, section 4.1.3 "Port binding and export binding" in the SystemC LRM describes it like this:

When port A is bound to port B, and port B is bound to channel C, the effect shall be the same as if port A were bound directly to channel C. Wherever this standard refers to port A being bound to channel C, it shall be assumed this means that port A is bound either directly to channel C or to another port that is itself bound to channel C according to this very same rule. This same rule shall apply when binding exports.

With port-to-port binding, you can bind inner::out directly to both outer::out and outer::out2 , without a signal in between. For example:

#include <systemc.h>

SC_MODULE(inner) {
    sc_port<sc_signal_inout_if<bool>, 2> out;

    SC_CTOR(inner) : out("out") {
        SC_THREAD(doit);
    };

    void doit() {
        for (int i=0; i<10; ++i) {
            out[0]->write(!out[0]->read());
            out[1]->write(!out[1]->read());
            wait(10, SC_NS);
        }
    }
};


SC_MODULE(outer) {
    sc_out<bool> out, out2;

    SC_CTOR(outer) : out("out"), out2("out2"), i("inner") {
        i.out(out);
        i.out(out2);
    }

    inner i;
};


int sc_main(int argc, char **argv) {
    outer o("outer");
    sc_signal<bool> out_s;
    sc_signal<bool> out2_s;

    o.out(out_s);
    o.out2(out2_s);

    sc_trace_file *tf = sc_create_vcd_trace_file("trace");
    sc_trace(tf, out_s, "out_s");
    sc_trace(tf, out2_s, "out2_s");

    sc_start(1, SC_MS);

    sc_core::sc_close_vcd_trace_file(tf);

    return 0;
}

There are a couple of things to note in the above code:

• inner::out is declared as a sc_port<sc_signal_inout_if<bool>, 2> , which is basically the same as an sc_out but allows the port to be bound to two channels. sc_out can only be bound to a single channel.
• When writing to inner::out , you have to specify the bound channel you are driving. This is done with the [] operator -- see inner::doit() above where both bound channels are driven.

When run, the above code produces a trace.vcd file that shows the levels on the two signals, out_s and out2_s , toggling.

Having explained all that, I'm not sure that it's really what you want. Having an output port fan out like that is pretty unusual. Do you really need two output ports on outer ?

Answer 2

Error: (E115) sc_signal cannot have more than one driver:

Can be solved by using SC_MANY_WRITERS.

for example:

sc_signal < bool, SC_MANY_WRITERS > reset_sig;

and then for a module called initializer we can bind this signal as such:

initializer<int, 16> init("init");

init.reset(reset_sig);

now for the other module, producer module, which is using the same signal:

producer<int, 16> prc("prc");

prc.resetIn(reset_sig);
prc.resetOut(reset_sig);