build_tools/sim_object_param_struct_cc.py - public/gem5 - Git at Google

 # Copyright 2004-2006 The Regents of The University of Michigan
 # Copyright 2010-20013 Advanced Micro Devices, Inc.
 # Copyright 2013 Mark D. Hill and David A. Wood
 # Copyright 2017-2020 ARM Limited
 # Copyright 2021 Google, Inc.
 #
 # The license below extends only to copyright in the software and shall
 # not be construed as granting a license to any other intellectual
 # property including but not limited to intellectual property relating
 # to a hardware implementation of the functionality of the software
 # licensed hereunder.  You may use the software subject to the license
 # terms below provided that you ensure that this notice is replicated
 # unmodified and in its entirety in all distributions of the software,
 # modified or unmodified, in source code or in binary form.
 #
 # 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.

 import argparse
 import importlib
 import os.path
 import sys

 import importer

 from code_formatter import code_formatter

 parser = argparse.ArgumentParser()
 parser.add_argument("modpath", help="module the simobject belongs to")
 parser.add_argument("param_cc", help="parameter cc file to generate")
 parser.add_argument(
     "use_python", help="whether python is enabled in gem5 (True or False)"
 )

 args = parser.parse_args()

 use_python = args.use_python.lower()
 if use_python == "true":
     use_python = True
 elif use_python == "false":
     use_python = False
 else:
     print(f'Unrecognized "use_python" value {use_python}', file=sys.stderr)
     sys.exit(1)

 basename = os.path.basename(args.param_cc)
 no_ext = os.path.splitext(basename)[0]
 sim_object_name = "_".join(no_ext.split("_")[1:])

 importer.install()
 module = importlib.import_module(args.modpath)
 sim_object = getattr(module, sim_object_name)

 from m5.objects.SimObject import PyBindProperty

 code = code_formatter()

 py_class_name = sim_object.pybind_class

 # The 'local' attribute restricts us to the params declared in
 # the object itself, not including inherited params (which
 # will also be inherited from the base class's param struct
 # here). Sort the params based on their key
 params = list(
     map(lambda k_v: k_v[1], sorted(sim_object._params.local.items()))
 )
 ports = sim_object._ports.local

 # only include pybind if python is enabled in the build
 if use_python:

     code(
         """#include "pybind11/pybind11.h"
 #include "pybind11/stl.h"

 #include <type_traits>

 #include "base/compiler.hh"
 #include "params/$sim_object.hh"
 #include "sim/init.hh"
 #include "sim/sim_object.hh"

 #include "${{sim_object.cxx_header}}"

 """
     )
 else:
     code(
         """
 #include <type_traits>

 #include "base/compiler.hh"
 #include "params/$sim_object.hh"

 #include "${{sim_object.cxx_header}}"

 """
     )
 # only include the python params code if python is enabled.
 if use_python:
     for param in params:
         param.pybind_predecls(code)

     code(
         """namespace py = pybind11;

 namespace gem5
 {

 static void
 module_init(py::module_ &m_internal)
 {
 py::module_ m = m_internal.def_submodule("param_${sim_object}");
 """
     )
     code.indent()
     if sim_object._base:
         code(
             "py::class_<${sim_object}Params, "
             "${{sim_object._base.type}}Params, "
             "std::unique_ptr<${{sim_object}}Params, py::nodelete>>("
             'm, "${sim_object}Params")'
         )
     else:
         code(
             "py::class_<${sim_object}Params, "
             "std::unique_ptr<${sim_object}Params, py::nodelete>>("
             'm, "${sim_object}Params")'
         )

     code.indent()
     if not hasattr(sim_object, "abstract") or not sim_object.abstract:
         code(".def(py::init<>())")
         code('.def("create", &${sim_object}Params::create)')

     param_exports = (
         sim_object.cxx_param_exports
         + [
             PyBindProperty(k)
             for k, v in sorted(sim_object._params.local.items())
         ]
         + [
             PyBindProperty(f"port_{port.name}_connection_count")
             for port in ports.values()
         ]
     )
     for exp in param_exports:
         exp.export(code, f"{sim_object}Params")

     code(";")
     code()
     code.dedent()

     bases = []
     if "cxx_base" in sim_object._value_dict:
         # If the c++ base class implied by python inheritance was
         # overridden, use that value.
         if sim_object.cxx_base:
             bases.append(sim_object.cxx_base)
     elif sim_object._base:
         # If not and if there was a SimObject base, use its c++ class
         # as this class' base.
         bases.append(sim_object._base.cxx_class)
     # Add in any extra bases that were requested.
     bases.extend(sim_object.cxx_extra_bases)

     if bases:
         base_str = ", ".join(bases)
         code(
             "py::class_<${{sim_object.cxx_class}}, ${base_str}, "
             "std::unique_ptr<${{sim_object.cxx_class}}, py::nodelete>>("
             'm, "${py_class_name}")'
         )
     else:
         code(
             "py::class_<${{sim_object.cxx_class}}, "
             "std::unique_ptr<${{sim_object.cxx_class}}, py::nodelete>>("
             'm, "${py_class_name}")'
         )
     code.indent()
     for exp in sim_object.cxx_exports:
         exp.export(code, sim_object.cxx_class)
     code(";")
     code.dedent()
     code()
     code.dedent()
     code("}")
     code()
     code(
         "static EmbeddedPyBind " 'embed_obj("${0}", module_init, "${1}");',
         sim_object,
         sim_object._base.type if sim_object._base else "",
     )
     code()
     code("} // namespace gem5")

 # include the create() methods whether or not python is enabled.
 if not hasattr(sim_object, "abstract") or not sim_object.abstract:
     if "type" in sim_object.__dict__:
         code(
             """
 namespace gem5
 {

 namespace
 {

 /*
  * If we can't define a default create() method for this params
  * struct because the SimObject doesn't have the right
  * constructor, use template magic to make it so we're actually
  * defining a create method for this class instead.
  */
 class Dummy${sim_object}ParamsClass
 {
   public:
     ${{sim_object.cxx_class}} *create() const;
 };

 template <class CxxClass, class Enable=void>
 class Dummy${sim_object}Shunt;

 /*
  * This version directs to the real Params struct and the
  * default behavior of create if there's an appropriate
  * constructor.
  */
 template <class CxxClass>
 class Dummy${sim_object}Shunt<CxxClass, std::enable_if_t<
     std::is_constructible_v<CxxClass, const ${sim_object}Params &>>>
 {
   public:
     using Params = ${sim_object}Params;
     static ${{sim_object.cxx_class}} *
     create(const Params &p)
     {
         return new CxxClass(p);
     }
 };

 /*
  * This version diverts to the DummyParamsClass and a dummy
  * implementation of create if the appropriate constructor does
  * not exist.
  */
 template <class CxxClass>
 class Dummy${sim_object}Shunt<CxxClass, std::enable_if_t<
     !std::is_constructible_v<CxxClass, const ${sim_object}Params &>>>
 {
   public:
     using Params = Dummy${sim_object}ParamsClass;
     static ${{sim_object.cxx_class}} *
     create(const Params &p)
     {
         return nullptr;
     }
 };

 } // anonymous namespace

 /*
  * An implementation of either the real Params struct's create
  * method, or the Dummy one. Either an implementation is
  * mandantory since this was shunted off to the dummy class, or
  * one is optional which will override this weak version.
  */
 [[maybe_unused]] ${{sim_object.cxx_class}} *
 Dummy${sim_object}Shunt<${{sim_object.cxx_class}}>::Params::create() const
 {
     return Dummy${sim_object}Shunt<${{sim_object.cxx_class}}>::create(*this);
 }

 } // namespace gem5
 """
         )

 code.write(args.param_cc)
	# Copyright 2004-2006 The Regents of The University of Michigan
	# Copyright 2010-20013 Advanced Micro Devices, Inc.
	# Copyright 2013 Mark D. Hill and David A. Wood
	# Copyright 2017-2020 ARM Limited
	# Copyright 2021 Google, Inc.
	#
	# The license below extends only to copyright in the software and shall
	# not be construed as granting a license to any other intellectual
	# property including but not limited to intellectual property relating
	# to a hardware implementation of the functionality of the software
	# licensed hereunder. You may use the software subject to the license
	# terms below provided that you ensure that this notice is replicated
	# unmodified and in its entirety in all distributions of the software,
	# modified or unmodified, in source code or in binary form.
	#
	# 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.

	import argparse
	import importlib
	import os.path
	import sys

	import importer

	from code_formatter import code_formatter

	parser = argparse.ArgumentParser()
	parser.add_argument("modpath", help="module the simobject belongs to")
	parser.add_argument("param_cc", help="parameter cc file to generate")
	parser.add_argument(
	"use_python", help="whether python is enabled in gem5 (True or False)"
	)

	args = parser.parse_args()

	use_python = args.use_python.lower()
	if use_python == "true":
	use_python = True
	elif use_python == "false":
	use_python = False
	else:
	print(f'Unrecognized "use_python" value {use_python}', file=sys.stderr)
	sys.exit(1)

	basename = os.path.basename(args.param_cc)
	no_ext = os.path.splitext(basename)[0]
	sim_object_name = "_".join(no_ext.split("_")[1:])

	importer.install()
	module = importlib.import_module(args.modpath)
	sim_object = getattr(module, sim_object_name)

	from m5.objects.SimObject import PyBindProperty

	code = code_formatter()

	py_class_name = sim_object.pybind_class

	# The 'local' attribute restricts us to the params declared in
	# the object itself, not including inherited params (which
	# will also be inherited from the base class's param struct
	# here). Sort the params based on their key
	params = list(
	map(lambda k_v: k_v[1], sorted(sim_object._params.local.items()))
	)
	ports = sim_object._ports.local

	# only include pybind if python is enabled in the build
	if use_python:

	code(
	"""#include "pybind11/pybind11.h"
	#include "pybind11/stl.h"

	#include <type_traits>

	#include "base/compiler.hh"
	#include "params/$sim_object.hh"
	#include "sim/init.hh"
	#include "sim/sim_object.hh"

	#include "${{sim_object.cxx_header}}"

	"""
	)
	else:
	code(
	"""
	#include <type_traits>

	#include "base/compiler.hh"
	#include "params/$sim_object.hh"

	#include "${{sim_object.cxx_header}}"

	"""
	)
	# only include the python params code if python is enabled.
	if use_python:
	for param in params:
	param.pybind_predecls(code)

	code(
	"""namespace py = pybind11;

	namespace gem5
	{

	static void
	module_init(py::module_ &m_internal)
	{
	py::module_ m = m_internal.def_submodule("param_${sim_object}");
	"""
	)
	code.indent()
	if sim_object._base:
	code(
	"py::class_<${sim_object}Params, "
	"${{sim_object._base.type}}Params, "
	"std::unique_ptr<${{sim_object}}Params, py::nodelete>>("
	'm, "${sim_object}Params")'
	)
	else:
	code(
	"py::class_<${sim_object}Params, "
	"std::unique_ptr<${sim_object}Params, py::nodelete>>("
	'm, "${sim_object}Params")'
	)

	code.indent()
	if not hasattr(sim_object, "abstract") or not sim_object.abstract:
	code(".def(py::init<>())")
	code('.def("create", &${sim_object}Params::create)')

	param_exports = (
	sim_object.cxx_param_exports
	+ [
	PyBindProperty(k)
	for k, v in sorted(sim_object._params.local.items())
	]
	+ [
	PyBindProperty(f"port_{port.name}_connection_count")
	for port in ports.values()
	]
	)
	for exp in param_exports:
	exp.export(code, f"{sim_object}Params")

	code(";")
	code()
	code.dedent()

	bases = []
	if "cxx_base" in sim_object._value_dict:
	# If the c++ base class implied by python inheritance was
	# overridden, use that value.
	if sim_object.cxx_base:
	bases.append(sim_object.cxx_base)
	elif sim_object._base:
	# If not and if there was a SimObject base, use its c++ class
	# as this class' base.
	bases.append(sim_object._base.cxx_class)
	# Add in any extra bases that were requested.
	bases.extend(sim_object.cxx_extra_bases)

	if bases:
	base_str = ", ".join(bases)
	code(
	"py::class_<${{sim_object.cxx_class}}, ${base_str}, "
	"std::unique_ptr<${{sim_object.cxx_class}}, py::nodelete>>("
	'm, "${py_class_name}")'
	)
	else:
	code(
	"py::class_<${{sim_object.cxx_class}}, "
	"std::unique_ptr<${{sim_object.cxx_class}}, py::nodelete>>("
	'm, "${py_class_name}")'
	)
	code.indent()
	for exp in sim_object.cxx_exports:
	exp.export(code, sim_object.cxx_class)
	code(";")
	code.dedent()
	code()
	code.dedent()
	code("}")
	code()
	code(
	"static EmbeddedPyBind " 'embed_obj("${0}", module_init, "${1}");',
	sim_object,
	sim_object._base.type if sim_object._base else "",
	)
	code()
	code("} // namespace gem5")

	# include the create() methods whether or not python is enabled.
	if not hasattr(sim_object, "abstract") or not sim_object.abstract:
	if "type" in sim_object.__dict__:
	code(
	"""
	namespace gem5
	{

	namespace
	{

	/*
	* If we can't define a default create() method for this params
	* struct because the SimObject doesn't have the right
	* constructor, use template magic to make it so we're actually
	* defining a create method for this class instead.
	*/
	class Dummy${sim_object}ParamsClass
	{
	public:
	${{sim_object.cxx_class}} *create() const;
	};

	template <class CxxClass, class Enable=void>
	class Dummy${sim_object}Shunt;

	/*
	* This version directs to the real Params struct and the
	* default behavior of create if there's an appropriate
	* constructor.
	*/
	template <class CxxClass>
	class Dummy${sim_object}Shunt<CxxClass, std::enable_if_t<
	std::is_constructible_v<CxxClass, const ${sim_object}Params &>>>
	{
	public:
	using Params = ${sim_object}Params;
	static ${{sim_object.cxx_class}} *
	create(const Params &p)
	{
	return new CxxClass(p);
	}
	};

	/*
	* This version diverts to the DummyParamsClass and a dummy
	* implementation of create if the appropriate constructor does
	* not exist.
	*/
	template <class CxxClass>
	class Dummy${sim_object}Shunt<CxxClass, std::enable_if_t<
	!std::is_constructible_v<CxxClass, const ${sim_object}Params &>>>
	{
	public:
	using Params = Dummy${sim_object}ParamsClass;
	static ${{sim_object.cxx_class}} *
	create(const Params &p)
	{
	return nullptr;
	}
	};

	} // anonymous namespace

	/*
	* An implementation of either the real Params struct's create
	* method, or the Dummy one. Either an implementation is
	* mandantory since this was shunted off to the dummy class, or
	* one is optional which will override this weak version.
	*/
	[[maybe_unused]] ${{sim_object.cxx_class}} *
	Dummy${sim_object}Shunt<${{sim_object.cxx_class}}>::Params::create() const
	{
	return Dummy${sim_object}Shunt<${{sim_object.cxx_class}}>::create(*this);
	}

	} // namespace gem5
	"""
	)

	code.write(args.param_cc)