c++ - 如何通过systemC tlm_fifo <float>连接两个模块？

我仍然是编写systemC-TLM的新手。现在，我想通过tlm_fifoFF连接两个模块。我正在网上搜索示例很长时间。但是没用。请帮助给出一些想法或示例，以实现这一目标。

这是我的体系结构:

并且，这是我的错误信息:

这是“main.cpp”

#include <systemc.h>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include "merlin2.h"

#include "tlm.h"
#include <tlm_utils/simple_target_socket.h>
#include <tlm_utils/simple_initiator_socket.h>
#include <tlm_utils/multi_passthrough_initiator_socket.h>
#include <tlm_utils/multi_passthrough_target_socket.h>
#include <tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo.h>
#include <tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_fifo_ifs.h>
using namespace sc_core;
using namespace tlm;
using namespace tlm_utils;
using namespace std;

int sc_main(int argc, char** argv){

    Merlin2 merlin_test("merlin2_JW");

    sc_start();
    cout << "end" << endl;
    return 0;
}

这是“merlin2.cpp”

#include "merlin2.h"
Merlin2::Merlin2(const sc_module_name& name)
{
    ProcessEngine PE_TEST("test_PE");
    test_PE TP("PE_test");
    tlm::tlm_fifo <float> FF ("fifo");

    TP.out(FF);
    PE_TEST.in(FF);
}

这是“merlin2.h”

#ifndef __MERLIN2_H__
#define __MERLIN2_H__
#include <fstream>
#include <string>
#include <systemc.h>

#include "pe.h"
#include "test_PE.h"

class Merlin2: public sc_module
{
    public:

        SC_HAS_PROCESS(Merlin2);
        Merlin2(const sc_module_name& name);

};

#endif

这是“pe.cpp”

#include <systemc.h>
#include <iostream>
#include "pe.h"

using namespace std;
ProcessEngine::ProcessEngine(const sc_module_name& name):in("in")
{
    cout << "before SC_THREAD(run)" << endl;
    SC_THREAD(run);
    cout << "after SC_THREAD(run)" << endl;
}

void ProcessEngine::run()
{
    int N = in.nb_get();
    cout <<  " N=" << N << endl;

    wait(1,SC_NS);
}

这是“pe.h”

#ifndef __PE_H__
#define __PE_H__

#include <iostream>
#include <bitset>
#include "tlm.h"
#include <tlm_utils/simple_target_socket.h>
#include <tlm_utils/simple_initiator_socket.h>
#include <tlm_utils/multi_passthrough_initiator_socket.h>
#include <tlm_utils/multi_passthrough_target_socket.h>
#include <tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo.h>
#include <tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_fifo_ifs.h>
using namespace sc_core;
using namespace tlm;
using namespace tlm_utils;
using namespace std;


class ProcessEngine: public sc_module
{
    public:

        tlm::tlm_fifo<float>  in;
        void run();

        ProcessEngine(const sc_module_name& name);
        SC_HAS_PROCESS(ProcessEngine);


};

#endif

这是“test_PE.cpp”

#include <systemc.h>
#include <iostream>
#include "test_PE.h"
using namespace std;

test_PE::test_PE(const sc_module_name& name):out("out")
{
    cout << "before start_test " << endl;
    SC_THREAD(start_test);
    cout << "After start_test " << endl;
}

void test_PE::start_test()
{
    float A=5;
    in.nb_put(A);
    cout << "A=" << A << endl;
    wait(1,SC_NS);
}

这是“test_PE.h”

#ifndef __TESTPE_H__
#define __TESTPE_H__
#include <fstream>
#include <string>
#include <systemc.h>

#include "tlm.h"
#include <tlm_utils/simple_target_socket.h>
#include <tlm_utils/simple_initiator_socket.h>
#include <tlm_utils/multi_passthrough_initiator_socket.h>
#include <tlm_utils/multi_passthrough_target_socket.h>
#include <tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo.h>
#include <tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_fifo_ifs.h>

using namespace sc_core;
using namespace tlm;
using namespace tlm_utils;
using namespace std;

class test_PE:public sc_module
{
    public:
        tlm::tlm_fifo<float>  out;
        test_PE(const sc_module_name& name);
        SC_HAS_PROCESS(test_PE);
        void start_test();
    private:
        float A;
};
#endif

最佳答案

您正在混合SystemC / TLM概念，尤其是端口和通道。

tlm_fifo是一个 channel 。它可以用于连接两个端口。这是图像的黄色部分。

但是，您不能直接将通道连接到模块。相反，您需要在要连接通道的每个模块中使用端口。端口与定义您可以使用的方法的接口(interface)相关联。在您的情况下，请使用nb_get(...)和nb_put(...)。

对于tlm_fifo，您可以使用以下端口:

sc_port< tlm_nonblocking_put_if<float> >

sc_port< tlm_nonblocking_get_if<float> >

c++ - 如何通过systemC tlm_fifo <float>连接两个模块？-LMLPHP

最后，在Merlin2构造函数中创建模块的实例。对象不会在构造函数的末尾保留和删除。他们应该是类的一员。这是使用带有无阻塞接口(interface)的tlm_fifo的TLM-1.0的完整工作示例。

注意:您正在混合使用TLM-2.0和TLM-1.0 header 。我删除了无用的标题。

main.cpp

#include <systemc>
#include "merlin2.h"

using namespace sc_core;
using namespace std;

int sc_main(int argc, char** argv) {
    Merlin2 merlin_test("merlin2_JW");
    sc_start();
    cout << "end" << endl;
    return 0;
}

merlin2.h

#ifndef __MERLIN2_H__
#define __MERLIN2_H__
#include <fstream>
#include <string>
#include <systemc>

#include "pe.h"
#include "test_PE.h"

class Merlin2: public sc_module
{
public:
    Merlin2(const sc_module_name& name);
    tlm::tlm_fifo <float> FF;
    ProcessEngine PE_TEST;
    test_PE TP;
};
#endif

merlin2.cpp

#include "merlin2.h"

Merlin2::Merlin2(const sc_module_name& name):
        PE_TEST("test_PE"),
        TP("PE_test"),
        FF("fifo")
{
    TP.out(FF);
    PE_TEST.in(FF);
}

pe.h

#ifndef __PE_H__
#define __PE_H__

#include <fstream>
#include <string>
#include <systemc>
#include <tlm>

using namespace sc_core;
using namespace tlm;
using namespace std;

class ProcessEngine: public sc_module
{
public:
    sc_port< tlm_nonblocking_get_if<float> >  in;
    void run();
    ProcessEngine(const sc_module_name& name);
    SC_HAS_PROCESS(ProcessEngine);
};

#endif

pe.cpp

#include <systemc.h>
#include "pe.h"

using namespace std;

ProcessEngine::ProcessEngine(const sc_module_name& name):
        in("in")
{
    SC_THREAD(run);
}

void ProcessEngine::run()
{
    sc_core::wait(1, SC_NS);
    float N = 0;
    bool r = in->nb_get(N);
    cout <<  " N=" << N << endl;
}

test_PE.cpp

#include <systemc>
#include "test_PE.h"

using namespace std;

test_PE::test_PE(const sc_module_name& name):
        out("out")
{
    SC_THREAD(start_test);
}

void test_PE::start_test()
{
    float A=5;
    out->nb_put(A);
    cout << "A=" << A << endl;
    sc_core::wait(1, SC_NS);
}

test_PE.h

#ifndef __TESTPE_H__
#define __TESTPE_H__

#include <fstream>
#include <string>
#include <systemc>
#include <tlm>

using namespace sc_core;
using namespace tlm;
using namespace std;

class test_PE:public sc_module
{
public:
    sc_port< tlm_nonblocking_put_if<float> >  out;
    test_PE(const sc_module_name& name);
    SC_HAS_PROCESS(test_PE);
    void start_test();
private:
    float A;
};
#endif