Unable to find missing declaration for gem5::SimpleMemobjParams::create()

[alhussein-jamil]

Describe the bug
I am trying to following the "LearningGem5" Tutorial for creating a simple memory object https://www.gem5.org/documentation/learning_gem5/part2/memoryobject/

I folllowed to the letter and added some changes to account for the new releases compatibility, something seems off with the code generation for Params. When i try to build using scons build/RISCV/gem5.opt -j20 I get a compilation error

error: no declaration matches ‘gem5::SimpleMemobj* gem5::SimpleMemobjParams::create() const’ 237 | SimpleMemobjParams::create() const | ^~~~~~~~~~~~~~~~~~

To Reproduce
Steps to reproduce the behavior. Please assume starting from a clean repository:

empty src/learning_gem5/part2 directory and add the following files :

simple_memobj.cc :
`/*

• Copyright (c) 2017 Jason Lowe-Power
• 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 copyright holders nor the names of its
• contributors may be used to endorse or promote products derived from
• this software without specific prior written permission.
• THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
• "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 COPYRIGHT
• OWNER OR CONTRIBUTORS BE 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.
• Authors: Jason Lowe-Power
  */

#include "learning_gem5/part2/simple_memobj.hh"

#include "base/trace.hh"
#include "debug/SimpleMemobj.hh"

namespace gem5
{
SimpleMemobj::SimpleMemobj(const SimpleMemobjParams &params) : SimObject(params),
instPort(params.name + ".inst_port", this),
dataPort(params.name + ".data_port", this),
memPort(params.name + ".mem_side", this),
blocked(false)
{
}

Port &
SimpleMemobj::getPort(const std::string &if_name, PortID idx)
{
    panic_if(idx != InvalidPortID, "This object doesn't support vector ports");

    // This is the name from the Python SimObject declaration (SimpleMemobj.py)
    if (if_name == "mem_side")
    {
        return memPort;
    }
    else if (if_name == "inst_port")
    {
        return instPort;
    }
    else if (if_name == "data_port")
    {
        return dataPort;
    }
    else
    {
        // pass it along to our super class
        return SimObject::getPort(if_name, idx);
    }
}

void
SimpleMemobj::CPUSidePort::sendPacket(PacketPtr pkt)
{
    // Note: This flow control is very simple since the memobj is blocking.

    panic_if(blockedPacket != nullptr, "Should never try to send if blocked!");

    // If we can't send the packet across the port, store it for later.
    if (!sendTimingResp(pkt))
    {
        blockedPacket = pkt;
    }
}

AddrRangeList
SimpleMemobj::CPUSidePort::getAddrRanges() const
{
    return owner->getAddrRanges();
}

void
SimpleMemobj::CPUSidePort::trySendRetry()
{
    if (needRetry && blockedPacket == nullptr)
    {
        // Only send a retry if the port is now completely free
        needRetry = false;
        DPRINTF(SimpleMemobj, "Sending retry req for %d\n", id);
        sendRetryReq();
    }
}

void
SimpleMemobj::CPUSidePort::recvFunctional(PacketPtr pkt)
{
    // Just forward to the memobj.
    return owner->handleFunctional(pkt);
}

bool
SimpleMemobj::CPUSidePort::recvTimingReq(PacketPtr pkt)
{
    // Just forward to the memobj.
    if (!owner->handleRequest(pkt))
    {
        needRetry = true;
        return false;
    }
    else
    {
        return true;
    }
}

void
SimpleMemobj::CPUSidePort::recvRespRetry()
{
    // We should have a blocked packet if this function is called.
    assert(blockedPacket != nullptr);

    // Grab the blocked packet.
    PacketPtr pkt = blockedPacket;
    blockedPacket = nullptr;

    // Try to resend it. It's possible that it fails again.
    sendPacket(pkt);
}

void
SimpleMemobj::MemSidePort::sendPacket(PacketPtr pkt)
{
    // Note: This flow control is very simple since the memobj is blocking.

    panic_if(blockedPacket != nullptr, "Should never try to send if blocked!");

    // If we can't send the packet across the port, store it for later.
    if (!sendTimingReq(pkt))
    {
        blockedPacket = pkt;
    }
}

bool
SimpleMemobj::MemSidePort::recvTimingResp(PacketPtr pkt)
{
    // Just forward to the memobj.
    return owner->handleResponse(pkt);
}

void
SimpleMemobj::MemSidePort::recvReqRetry()
{
    // We should have a blocked packet if this function is called.
    assert(blockedPacket != nullptr);

    // Grab the blocked packet.
    PacketPtr pkt = blockedPacket;
    blockedPacket = nullptr;

    // Try to resend it. It's possible that it fails again.
    sendPacket(pkt);
}

void
SimpleMemobj::MemSidePort::recvRangeChange()
{
    owner->sendRangeChange();
}

bool
SimpleMemobj::handleRequest(PacketPtr pkt)
{
    if (blocked)
    {
        // There is currently an outstanding request. Stall.
        return false;
    }

    DPRINTF(SimpleMemobj, "Got request for addr %#x\n", pkt->getAddr());

    // This memobj is now blocked waiting for the response to this packet.
    blocked = true;

    // Simply forward to the memory port
    memPort.sendPacket(pkt);

    return true;
}

bool
SimpleMemobj::handleResponse(PacketPtr pkt)
{
    assert(blocked);
    DPRINTF(SimpleMemobj, "Got response for addr %#x\n", pkt->getAddr());

    // The packet is now done. We're about to put it in the port, no need for
    // this object to continue to stall.
    // We need to free the resource before sending the packet in case the CPU
    // tries to send another request immediately (e.g., in the same callchain).
    blocked = false;

    // Simply forward to the memory port
    if (pkt->req->isInstFetch())
    {
        instPort.sendPacket(pkt);
    }
    else
    {
        dataPort.sendPacket(pkt);
    }

    // For each of the cpu ports, if it needs to send a retry, it should do it
    // now since this memory object may be unblocked now.
    instPort.trySendRetry();
    dataPort.trySendRetry();

    return true;
}

void
SimpleMemobj::handleFunctional(PacketPtr pkt)
{
    // Just pass this on to the memory side to handle for now.
    memPort.sendFunctional(pkt);
}

AddrRangeList
SimpleMemobj::getAddrRanges() const
{
    DPRINTF(SimpleMemobj, "Sending new ranges\n");
    // Just use the same ranges as whatever is on the memory side.
    return memPort.getAddrRanges();
}

void
SimpleMemobj::sendRangeChange()
{
    instPort.sendRangeChange();
    dataPort.sendRangeChange();
}

SimpleMemobj *
SimpleMemobjParams::create() const
{
    return new SimpleMemobj(*this);
}

} // namespace gem5`

simple_memobj.hh :

`#ifndef SIMPLE_MEMOBJ_HH
#define SIMPLE_MEMOBJ_HH

#include "mem/port.hh"
#include "sim/sim_object.hh"
#include "params/SimpleMemobj.hh"

namespace gem5
{

class SimpleMemobj : public SimObject
{
private:
    class CPUSidePort : public ResponsePort
    {
    private:
        SimpleMemobj *owner;
        bool needRetry;
        PacketPtr blockedPacket;

    public:
        CPUSidePort(const std::string &name, SimpleMemobj *owner) : ResponsePort(name),
                                                                    owner(owner),
                                                                    needRetry(false),
                                                                    blockedPacket(nullptr)
        {
        }

        AddrRangeList getAddrRanges() const override;
        void sendPacket(PacketPtr pkt);
        void trySendRetry();

    protected:
        Tick recvAtomic(PacketPtr pkt) override { panic("recvAtomic unimpl."); }
        void recvFunctional(PacketPtr pkt) override;
        bool recvTimingReq(PacketPtr pkt) override;
        void recvRespRetry() override;
    };

    class MemSidePort : public RequestPort
    {
    private:
        SimpleMemobj *owner;
        PacketPtr blockedPacket;

    public:
        MemSidePort(const std::string &name, SimpleMemobj *owner) : RequestPort(name),
                                                                    owner(owner),
                                                                    blockedPacket(nullptr)
        {
        }

        void sendPacket(PacketPtr pkt);

    protected:
        bool recvTimingResp(PacketPtr pkt) override;
        void recvReqRetry() override;
        void recvRangeChange() override;
    };

    CPUSidePort instPort;
    CPUSidePort dataPort;

    MemSidePort memPort;
    bool blocked;

public:
    SimpleMemobj(const SimpleMemobjParams &params);

    Port &getPort(const std::string &if_name,
                  PortID idx = InvalidPortID) override;

    void handleFunctional(PacketPtr pkt);
    AddrRangeList getAddrRanges() const;
    bool handleRequest(PacketPtr pkt);
    bool handleResponse(PacketPtr pkt);
    void sendRangeChange();
};

} // namespace gem5

#endif // SIMPLE_MEMOBJ_HH`

SimpleMemobj.py :

`from m5.params import *
from m5.proxy import *
from m5.SimObject import SimObject

class SimpleMemobj(SimObject):
type = 'SimpleMemobj'
cxx_header = "learning_gem5/part2/simple_memobj.hh"

inst_port = ResponsePort("CPU side port, receives requests")
data_port = ResponsePort("CPU side port, receives requests")
mem_side = RequestPort("Memory side port, sends requests")`

SConscript :
`Import('*')

SimObject('SimpleMemobj.py', sim_objects=['SimpleMemobj'])

Source('simple_memobj.cc')

DebugFlag('SimpleMemobj')`

Terminal Output
If applicable, add the terminal output here. If long, only include the relevant lines.
Please put the terminal output in code blocks. I.e.:

 scons build/RISCV/gem5.opt -j20
scons: Reading SConscript files ...
Mkdir("/home/ajvendetta/arago/gem5/build/RISCV/gem5.build")
Checking for linker -Wl,--as-needed support... (cached) yes
Checking for compiler -gz support... (cached) yes
Checking for linker -gz support... (cached) yes
Info: Using Python config: python3-config
Checking for C header file Python.h... (cached) yes
Checking Python version... (cached) 3.12.7
Checking for accept(0,0,0) in C++ library None... (cached) yes
Checking for zlibVersion() in C++ library z... (cached) yes
Checking for C library tcmalloc_minimal... (cached) yes
Building in /home/ajvendetta/arago/gem5/build/RISCV
"build_tools/kconfig_base.py" "/home/ajvendetta/arago/gem5/build/RISCV/gem5.build/Kconfig" "/home/ajvendetta/arago/gem5/src/Kconfig"
Checking size of struct kvm_xsave ... (cached) yes
Checking for C header file fenv.h... (cached) yes
Checking for C header file png.h... (cached) yes
Checking for clock_nanosleep(0,0,NULL,NULL) in C library None... (cached) yes
Checking for C header file valgrind/valgrind.h... (cached) no
Checking for pkg-config package hdf5-serial... (cached) yes
Checking for H5Fcreate("", 0, 0, 0) in C library hdf5... (cached) yes
Checking for H5::H5File("", 0) in C++ library hdf5_cpp... (cached) yes
Checking for pkg-config package protobuf... (cached) yes
Checking for shm_open("/test", 0, 0) in C library None... (cached) yes
Checking for backtrace_symbols_fd((void *)1, 0, 0) in C library None... (cached) yes
Checking for C header file linux/if_tun.h... (cached) yes
Checking for C header file capstone/capstone.h... (cached) yes
Checking for C header file linux/kvm.h... (cached) yes
Checking for timer_create(CLOCK_MONOTONIC, NULL, NULL) in C library None... (cached) yes
Checking for member exclude_host in struct perf_event_attr...(cached) yes
Checking whether __i386__ is declared... (cached) no
Checking whether __x86_64__ is declared... (cached) yes
BUILD_TLM not set, not building CHI-TLM integration

Checking for compiler -Wno-self-assign-overloaded support... (cached) yes
Checking for linker -Wno-free-nonheap-object support... (cached) yes
scons: done reading SConscript files.
scons: Building targets ...
 [     CXX] RISCV/python/_m5/param_SimpleMemobj.cc -> .o
 [     CXX] src/learning_gem5/part2/simple_memobj.cc -> RISCV/learning_gem5/part2/simple_memobj.o
 [     CXX] RISCV/python/gem5/components/cachehierarchies/ruby/caches/mesi_two_level/dma_controller.py.cc -> .o
 [     CXX] RISCV/python/gem5/components/cachehierarchies/ruby/caches/mesi_two_level/l1_cache.py.cc -> .o
 [     CXX] RISCV/python/gem5/components/cachehierarchies/ruby/caches/mesi_two_level/l2_cache.py.cc -> .o
 [     CXX] RISCV/python/gem5/components/cachehierarchies/ruby/caches/mesi_three_level/directory.py.cc -> .o
 [     CXX] RISCV/python/gem5/components/cachehierarchies/ruby/caches/mesi_three_level/l1_cache.py.cc -> .o
 [     CXX] RISCV/python/gem5/components/cachehierarchies/ruby/caches/mesi_three_level/l3_cache.py.cc -> .o
 [     CXX] RISCV/python/gem5/components/cachehierarchies/ruby/caches/prebuilt/octopi_cache/__init__.py.cc -> .o
 [     CXX] RISCV/python/gem5/components/cachehierarchies/ruby/caches/prebuilt/octopi_cache/core_complex.py.cc -> .o
 [     CXX] RISCV/python/gem5/components/cachehierarchies/ruby/caches/prebuilt/octopi_cache/ruby_network_components.py.cc -> .o
 [     CXX] RISCV/python/gem5/components/cachehierarchies/ruby/caches/mi_example/directory.py.cc -> .o
 [     CXX] RISCV/python/gem5/components/cachehierarchies/ruby/caches/mi_example/dma_controller.py.cc -> .o
 [     CXX] RISCV/python/gem5/components/cachehierarchies/ruby/caches/mesi_three_level/l2_cache.py.cc -> .o
 [     CXX] RISCV/python/gem5/components/cachehierarchies/ruby/caches/prebuilt/octopi_cache/octopi.py.cc -> .o
 [     CXX] RISCV/python/gem5/components/cachehierarchies/ruby/caches/mi_example/__init__.py.cc -> .o
 [     CXX] RISCV/python/gem5/components/cachehierarchies/ruby/caches/mesi_three_level/dma_controller.py.cc -> .o
 [     CXX] RISCV/python/gem5/components/cachehierarchies/ruby/caches/prebuilt/octopi_cache/octopi_network.py.cc -> .o
 [     CXX] RISCV/python/gem5/components/cachehierarchies/ruby/caches/prebuilt/__init__.py.cc -> .o
 [     CXX] RISCV/python/gem5/components/cachehierarchies/ruby/caches/mesi_three_level/__init__.py.cc -> .o
src/learning_gem5/part2/simple_memobj.cc:237:1: error: no declaration matches ‘gem5::SimpleMemobj* gem5::SimpleMemobjParams::create() const’
  237 | SimpleMemobjParams::create() const
      | ^~~~~~~~~~~~~~~~~~
In file included from src/learning_gem5/part2/simple_memobj.hh:6,
                 from src/learning_gem5/part2/simple_memobj.cc:31:
build/RISCV/params/SimpleMemobj.hh:19:20: note: candidate is: ‘SimpleMemobj* gem5::SimpleMemobjParams::create() const’
   19 |     SimpleMemobj * create() const;
      |                    ^~~~~~
build/RISCV/params/SimpleMemobj.hh:16:8: note: ‘struct gem5::SimpleMemobjParams’ defined here
   16 | struct SimpleMemobjParams
      |        ^~~~~~~~~~~~~~~~~~
scons: *** [build/RISCV/learning_gem5/part2/simple_memobj.o] Error 1
build/RISCV/python/_m5/param_SimpleMemobj.cc:110:1: error: no declaration matches ‘gem5::SimpleMemobj* gem5::SimpleMemobjParams::create() const’
  110 | DummySimpleMemobjShunt<SimpleMemobj>::Params::create() const
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from build/RISCV/python/_m5/param_SimpleMemobj.cc:13:
build/RISCV/params/SimpleMemobj.hh:19:20: note: candidate is: ‘SimpleMemobj* gem5::SimpleMemobjParams::create() const’
   19 |     SimpleMemobj * create() const;
      |                    ^~~~~~
build/RISCV/params/SimpleMemobj.hh:16:8: note: ‘struct gem5::SimpleMemobjParams’ defined here
   16 | struct SimpleMemobjParams
      |        ^~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/bits/stl_pair.h:60,
                 from /usr/include/c++/14/bits/stl_algobase.h:64,
                 from /usr/include/c++/14/bits/specfun.h:43,
                 from /usr/include/c++/14/cmath:3898,
                 from /usr/include/c++/14/math.h:36,
                 from /usr/include/python3.12/pyport.h:195,
                 from /usr/include/python3.12/Python.h:38,
                 from ext/pybind11/include/pybind11/detail/../detail/common.h:266,
                 from ext/pybind11/include/pybind11/detail/../attr.h:13,
                 from ext/pybind11/include/pybind11/detail/class.h:12,
                 from ext/pybind11/include/pybind11/pybind11.h:13,
                 from build/RISCV/python/_m5/param_SimpleMemobj.cc:7:
/usr/include/c++/14/type_traits: In instantiation of ‘struct std::is_base_of<pybind11::detail::pyobject_tag, SimpleMemobj>’:
/usr/include/c++/14/type_traits:1493:30:   recursively required by substitution of ‘template<class T> class pybind11::detail::type_caster<T, typename std::enable_if<std::is_base_of<pybind11::detail::pyobject_tag, typename std::remove_reference<_Tp>::type>::value, void>::type> [with T = SimpleMemobj]’
 1493 |     : public __bool_constant<__is_base_of(_Base, _Derived)>
      |                              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
ext/pybind11/include/pybind11/pybind11.h:241:63:   recursively required by substitution of ‘template<class Return> struct pybind11::detail::return_value_policy_override<Return, typename std::enable_if<std::is_base_of<pybind11::detail::type_caster_generic, pybind11::detail::type_caster<typename pybind11::detail::intrinsic_type<T>::type> >::value, void>::type> [with Return = SimpleMemobj*]’
  241 |                 = return_value_policy_override<Return>::policy(call.func.policy);
      |                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~
ext/pybind11/include/pybind11/pybind11.h:241:63:   required from ‘void pybind11::cpp_function::initialize(Func&&, Return (*)(Args ...), const Extra& ...) [with Func = pybind11::cpp_function::cpp_function<SimpleMemobj*, gem5::SimpleMemobjParams, pybind11::name, pybind11::is_method, pybind11::sibling>(SimpleMemobj* (gem5::SimpleMemobjParams::*)() const, const pybind11::name&, const pybind11::is_method&, const pybind11::sibling&)::<lambda(const gem5::SimpleMemobjParams*)>; Return = SimpleMemobj*; Args = {const gem5::SimpleMemobjParams*}; Extra = {pybind11::name, pybind11::is_method, pybind11::sibling}]’
ext/pybind11/include/pybind11/pybind11.h:131:19:   required from ‘pybind11::cpp_function::cpp_function(Return (Class::*)(Arg ...) const, const Extra& ...) [with Return = SimpleMemobj*; Class = gem5::SimpleMemobjParams; Arg = {}; Extra = {pybind11::name, pybind11::is_method, pybind11::sibling}]’
  131 |         initialize([f](const Class *c,
      |         ~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~
  132 |                        Arg... args) -> Return { return (c->*f)(std::forward<Arg>(args)...); },
      |                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  133 |                    (Return(*)(const Class *, Arg...)) nullptr,
      |                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  134 |                    extra...);
      |                    ~~~~~~~~~
ext/pybind11/include/pybind11/pybind11.h:1583:22:   required from ‘pybind11::class_<type_, options>& pybind11::class_<type_, options>::def(const char*, Func&&, const Extra& ...) [with Func = SimpleMemobj* (gem5::SimpleMemobjParams::*)() const; Extra = {}; type_ = gem5::SimpleMemobjParams; options = {gem5::SimObjectParams, std::unique_ptr<gem5::SimpleMemobjParams, pybind11::nodelete>}]’
 1583 |         cpp_function cf(method_adaptor<type>(std::forward<Func>(f)),
      |                      ^~
build/RISCV/python/_m5/param_SimpleMemobj.cc:30:13:   required from here
   28 |     py::class_<SimpleMemobjParams, SimObjectParams, std::unique_ptr<SimpleMemobjParams, py::nodelete>>(m, "SimpleMemobjParams")
      |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   29 |         .def(py::init<>())
      |         ~~~~~~~~~~~~~~~~~~
   30 |         .def("create", &SimpleMemobjParams::create)
      |         ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/type_traits:1493:30: error: invalid use of incomplete type ‘class SimpleMemobj’
 1493 |     : public __bool_constant<__is_base_of(_Base, _Derived)>
      |                              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
build/RISCV/params/SimpleMemobj.hh:10:7: note: forward declaration of ‘class SimpleMemobj’
   10 | class SimpleMemobj;
      |       ^~~~~~~~~~~~
In file included from ext/pybind11/include/pybind11/detail/../cast.h:14,
                 from ext/pybind11/include/pybind11/detail/../attr.h:14:
ext/pybind11/include/pybind11/detail/../detail/descr.h: In instantiation of ‘static constexpr std::array<const std::type_info*, (sizeof... (Ts) + 1)> pybind11::detail::descr<N, Ts>::types() [with long unsigned int N = 10; Ts = {gem5::SimpleMemobjParams, SimpleMemobj}]’:
ext/pybind11/include/pybind11/pybind11.h:292:73:   required from ‘void pybind11::cpp_function::initialize(Func&&, Return (*)(Args ...), const Extra& ...) [with Func = pybind11::cpp_function::cpp_function<SimpleMemobj*, gem5::SimpleMemobjParams, pybind11::name, pybind11::is_method, pybind11::sibling>(SimpleMemobj* (gem5::SimpleMemobjParams::*)() const, const pybind11::name&, const pybind11::is_method&, const pybind11::sibling&)::<lambda(const gem5::SimpleMemobjParams*)>; Return = SimpleMemobj*; Args = {const gem5::SimpleMemobjParams*}; Extra = {pybind11::name, pybind11::is_method, pybind11::sibling}]’
  292 |         PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
      |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~^~
ext/pybind11/include/pybind11/pybind11.h:131:19:   required from ‘pybind11::cpp_function::cpp_function(Return (Class::*)(Arg ...) const, const Extra& ...) [with Return = SimpleMemobj*; Class = gem5::SimpleMemobjParams; Arg = {}; Extra = {pybind11::name, pybind11::is_method, pybind11::sibling}]’
  131 |         initialize([f](const Class *c,
      |         ~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~
  132 |                        Arg... args) -> Return { return (c->*f)(std::forward<Arg>(args)...); },
      |                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  133 |                    (Return(*)(const Class *, Arg...)) nullptr,
      |                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  134 |                    extra...);
      |                    ~~~~~~~~~
ext/pybind11/include/pybind11/pybind11.h:1583:22:   required from ‘pybind11::class_<type_, options>& pybind11::class_<type_, options>::def(const char*, Func&&, const Extra& ...) [with Func = SimpleMemobj* (gem5::SimpleMemobjParams::*)() const; Extra = {}; type_ = gem5::SimpleMemobjParams; options = {gem5::SimObjectParams, std::unique_ptr<gem5::SimpleMemobjParams, pybind11::nodelete>}]’
 1583 |         cpp_function cf(method_adaptor<type>(std::forward<Func>(f)),
      |                      ^~
build/RISCV/python/_m5/param_SimpleMemobj.cc:30:13:   required from here
   28 |     py::class_<SimpleMemobjParams, SimObjectParams, std::unique_ptr<SimpleMemobjParams, py::nodelete>>(m, "SimpleMemobjParams")
      |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   29 |         .def(py::init<>())
      |         ~~~~~~~~~~~~~~~~~~
   30 |         .def("create", &SimpleMemobjParams::create)
      |         ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
ext/pybind11/include/pybind11/detail/../detail/descr.h:40:19: error: invalid use of incomplete type ‘class SimpleMemobj’
   40 |         return {{&typeid(Ts)..., nullptr}};
      |                   ^~~~~~~~~~
build/RISCV/params/SimpleMemobj.hh:10:7: note: forward declaration of ‘class SimpleMemobj’
   10 | class SimpleMemobj;
      |       ^~~~~~~~~~~~
ext/pybind11/include/pybind11/detail/../detail/descr.h:40:42: error: could not convert ‘{{<expression error>, nullptr}}’ from ‘<brace-enclosed initializer list>’ to ‘std::array<const std::type_info*, 3>’
   40 |         return {{&typeid(Ts)..., nullptr}};
      |                                          ^
      |                                          |
      |                                          <brace-enclosed initializer list>
ext/pybind11/include/pybind11/pybind11.h: In instantiation of ‘void pybind11::cpp_function::initialize(Func&&, Return (*)(Args ...), const Extra& ...) [with Func = pybind11::cpp_function::cpp_function<SimpleMemobj*, gem5::SimpleMemobjParams, pybind11::name, pybind11::is_method, pybind11::sibling>(SimpleMemobj* (gem5::SimpleMemobjParams::*)() const, const pybind11::name&, const pybind11::is_method&, const pybind11::sibling&)::<lambda(const gem5::SimpleMemobjParams*)>; Return = SimpleMemobj*; Args = {const gem5::SimpleMemobjParams*}; Extra = {pybind11::name, pybind11::is_method, pybind11::sibling}]’:
ext/pybind11/include/pybind11/pybind11.h:131:19:   required from ‘pybind11::cpp_function::cpp_function(Return (Class::*)(Arg ...) const, const Extra& ...) [with Return = SimpleMemobj*; Class = gem5::SimpleMemobjParams; Arg = {}; Extra = {pybind11::name, pybind11::is_method, pybind11::sibling}]’
  131 |         initialize([f](const Class *c,
      |         ~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~
  132 |                        Arg... args) -> Return { return (c->*f)(std::forward<Arg>(args)...); },
      |                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  133 |                    (Return(*)(const Class *, Arg...)) nullptr,
      |                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  134 |                    extra...);
      |                    ~~~~~~~~~
ext/pybind11/include/pybind11/pybind11.h:1583:22:   required from ‘pybind11::class_<type_, options>& pybind11::class_<type_, options>::def(const char*, Func&&, const Extra& ...) [with Func = SimpleMemobj* (gem5::SimpleMemobjParams::*)() const; Extra = {}; type_ = gem5::SimpleMemobjParams; options = {gem5::SimObjectParams, std::unique_ptr<gem5::SimpleMemobjParams, pybind11::nodelete>}]’
 1583 |         cpp_function cf(method_adaptor<type>(std::forward<Func>(f)),
      |                      ^~
build/RISCV/python/_m5/param_SimpleMemobj.cc:30:13:   required from here
   28 |     py::class_<SimpleMemobjParams, SimObjectParams, std::unique_ptr<SimpleMemobjParams, py::nodelete>>(m, "SimpleMemobjParams")
      |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   29 |         .def(py::init<>())
      |         ~~~~~~~~~~~~~~~~~~
   30 |         .def("create", &SimpleMemobjParams::create)
      |         ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
ext/pybind11/include/pybind11/pybind11.h:292:73:   in ‘constexpr’ expansion of ‘pybind11::detail::descr<10, gem5::SimpleMemobjParams, SimpleMemobj>::types()’
ext/pybind11/include/pybind11/pybind11.h:292:73: error: ‘constexpr’ call flows off the end of the function
  292 |         PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
      |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~^~
scons: *** [build/RISCV/python/_m5/param_SimpleMemobj.o] Error 1
scons: building terminated because of errors.

Additional information
I am completely new to CPU Architecture and Performance modeling using Gem5, help is very appreciated

[powerjg]

You should remove the definition of the create() function from your code and instead use PARAMS(<your sim object>). This changed a few versions ago. See https://github.com/gem5/gem5/tree/stable/src/learning_gem5/part2 for up-to-date code.