src/sim/init.cc

   1 /*
   2  * Copyright (c) 2012, 2017 ARM Limited
   3  * All rights reserved
   4  *
   5  * The license below extends only to copyright in the software and shall
   6  * not be construed as granting a license to any other intellectual
   7  * property including but not limited to intellectual property relating
   8  * to a hardware implementation of the functionality of the software
   9  * licensed hereunder.  You may use the software subject to the license
  10  * terms below provided that you ensure that this notice is replicated
  11  * unmodified and in its entirety in all distributions of the software,
  12  * modified or unmodified, in source code or in binary form.
  13  *
  14  * Copyright (c) 2000-2005 The Regents of The University of Michigan
  15  * Copyright (c) 2008 The Hewlett-Packard Development Company
  16  * All rights reserved.
  17  *
  18  * Redistribution and use in source and binary forms, with or without
  19  * modification, are permitted provided that the following conditions are
  20  * met: redistributions of source code must retain the above copyright
  21  * notice, this list of conditions and the following disclaimer;
  22  * redistributions in binary form must reproduce the above copyright
  23  * notice, this list of conditions and the following disclaimer in the
  24  * documentation and/or other materials provided with the distribution;
  25  * neither the name of the copyright holders nor the names of its
  26  * contributors may be used to endorse or promote products derived from
  27  * this software without specific prior written permission.
  28  *
  29  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  30  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  31  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  32  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  33  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  34  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  35  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  36  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  37  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  38  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  39  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  40  *
  41  * Authors: Nathan Binkert
  42  */
  43
  44 #include <Python.h>
  45
  46 #include "sim/init.hh"
  47
  48 #include <marshal.h>
  49 #include <zlib.h>
  50
  51 #include <iostream>
  52 #include <list>
  53 #include <string>
  54 #include <vector>
  55
  56 #include "base/cprintf.hh"
  57 #include "base/logging.hh"
  58 #include "base/types.hh"
  59 #include "config/have_protobuf.hh"
  60 #include "python/pybind11/pybind.hh"
  61 #include "sim/async.hh"
  62 #include "sim/core.hh"
  63
  64 #if HAVE_PROTOBUF
  65 #include <google/protobuf/stubs/common.h>
  66
  67 #endif
  68
  69 using namespace std;
  70 namespace py = pybind11;
  71
  72 // The python library is totally messed up with respect to constness,
  73 // so make a simple macro to make life a little easier
  74 #define PyCC(x) (const_cast<char *>(x))
  75
  76 EmbeddedPython *EmbeddedPython::importer = NULL;
  77 PyObject *EmbeddedPython::importerModule = NULL;
  78 EmbeddedPython::EmbeddedPython(const char *filename, const char *abspath,
  79     const char *modpath, const unsigned char *code, int zlen, int len)
  80     : filename(filename), abspath(abspath), modpath(modpath), code(code),
  81       zlen(zlen), len(len)
  82 {
  83     // if we've added the importer keep track of it because we need it
  84     // to bootstrap.
  85     if (string(modpath) == string("importer"))
  86         importer = this;
  87     else
  88         getList().push_back(this);
  89 }
  90
  91 list<EmbeddedPython *> &
  92 EmbeddedPython::getList()
  93 {
  94     static list<EmbeddedPython *> the_list;
  95     return the_list;
  96 }
  97
  98 /*
  99  * Uncompress and unmarshal the code object stored in the
 100  * EmbeddedPython
 101  */
 102 PyObject *
 103 EmbeddedPython::getCode() const
 104 {
 105     Bytef marshalled[len];
 106     uLongf unzlen = len;
 107     int ret = uncompress(marshalled, &unzlen, (const Bytef *)code, zlen);
 108     if (ret != Z_OK)
 109         panic("Could not uncompress code: %s\n", zError(ret));
 110     assert(unzlen == (uLongf)len);
 111
 112     return PyMarshal_ReadObjectFromString((char *)marshalled, len);
 113 }
 114
 115 bool
 116 EmbeddedPython::addModule() const
 117 {
 118     PyObject *code = getCode();
 119     PyObject *result = PyObject_CallMethod(importerModule, PyCC("add_module"),
 120         PyCC("sssO"), filename, abspath, modpath, code);
 121     if (!result) {
 122         PyErr_Print();
 123         return false;
 124     }
 125
 126     Py_DECREF(result);
 127     return true;
 128 }
 129
 130 /*
 131  * Load and initialize all of the python parts of M5.
 132  */
 133 int
 134 EmbeddedPython::initAll()
 135 {
 136     // Load the importer module
 137     PyObject *code = importer->getCode();
 138     importerModule = PyImport_ExecCodeModule(PyCC("importer"), code);
 139     if (!importerModule) {
 140         PyErr_Print();
 141         return 1;
 142     }
 143
 144     // Load the rest of the embedded python files into the embedded
 145     // python importer
 146     list<EmbeddedPython *>::iterator i = getList().begin();
 147     list<EmbeddedPython *>::iterator end = getList().end();
 148     for (; i != end; ++i)
 149         if (!(*i)->addModule())
 150             return 1;
 151
 152     return 0;
 153 }
 154
 155 EmbeddedPyBind::EmbeddedPyBind(const char *_name,
 156                                void (*init_func)(py::module &),
 157                                const char *_base)
 158     : initFunc(init_func), registered(false), name(_name), base(_base)
 159 {
 160     getMap()[_name] = this;
 161 }
 162
 163 EmbeddedPyBind::EmbeddedPyBind(const char *_name,
 164                                void (*init_func)(py::module &))
 165     : initFunc(init_func), registered(false), name(_name), base("")
 166 {
 167     getMap()[_name] = this;
 168 }
 169
 170 void
 171 EmbeddedPyBind::init(py::module &m)
 172 {
 173     if (!registered) {
 174         initFunc(m);
 175         registered = true;
 176     } else {
 177         cprintf("Warning: %s already registered.\n", name);
 178     }
 179 }
 180
 181 bool
 182 EmbeddedPyBind::depsReady() const
 183 {
 184     return base.empty() || getMap()[base]->registered;
 185 }
 186
 187 std::map<std::string, EmbeddedPyBind *> &
 188 EmbeddedPyBind::getMap()
 189 {
 190     static std::map<std::string, EmbeddedPyBind *> objs;
 191     return objs;
 192 }
 193
 194 void
 195 EmbeddedPyBind::initAll()
 196 {
 197     std::list<EmbeddedPyBind *> pending;
 198
 199     py::module m_m5 = py::module("_m5");
 200     m_m5.attr("__package__") = py::cast("_m5");
 201
 202     pybind_init_core(m_m5);
 203     pybind_init_debug(m_m5);
 204
 205     pybind_init_event(m_m5);
 206     pybind_init_pyobject(m_m5);
 207     pybind_init_stats(m_m5);
 208
 209     for (auto &kv : getMap()) {
 210         auto &obj = kv.second;
 211         if (obj->base.empty()) {
 212             obj->init(m_m5);
 213         } else {
 214             pending.push_back(obj);
 215         }
 216     }
 217
 218     while (!pending.empty()) {
 219         for (auto it = pending.begin(); it != pending.end(); ) {
 220             EmbeddedPyBind &obj = **it;
 221             if (obj.depsReady()) {
 222                 obj.init(m_m5);
 223                 it = pending.erase(it);
 224             } else {
 225                 ++it;
 226             }
 227         }
 228     }
 229 }
 230
 231 int
 232 initM5Python()
 233 {
 234     EmbeddedPyBind::initAll();
 235     return EmbeddedPython::initAll();
 236 }
 237
 238 /*
 239  * Make the commands array weak so that they can be overridden (used
 240  * by unit tests to specify a different python main function.
 241  */
 242 const char * __attribute__((weak)) m5MainCommands[] = {
 243     "import m5",
 244     "m5.main()",
 245     0 // sentinel is required
 246 };
 247
 248 /*
 249  * Start up the M5 simulator.  This mostly vectors into the python
 250  * main function.
 251  */
 252 int
 253 m5Main(int argc, char **_argv)
 254 {
 255 #if HAVE_PROTOBUF
 256     // Verify that the version of the protobuf library that we linked
 257     // against is compatible with the version of the headers we
 258     // compiled against.
 259     GOOGLE_PROTOBUF_VERIFY_VERSION;
 260 #endif
 261
 262
 263 #if PY_MAJOR_VERSION >= 3
 264     typedef std::unique_ptr<wchar_t[], decltype(&PyMem_RawFree)> WArgUPtr;
 265     std::vector<WArgUPtr> v_argv;
 266     std::vector<wchar_t *> vp_argv;
 267     v_argv.reserve(argc);
 268     vp_argv.reserve(argc);
 269     for (int i = 0; i < argc; i++) {
 270         v_argv.emplace_back(Py_DecodeLocale(_argv[i], NULL), &PyMem_RawFree);
 271         vp_argv.emplace_back(v_argv.back().get());
 272     }
 273
 274     wchar_t **argv = vp_argv.data();
 275 #else
 276     char **argv = _argv;
 277 #endif
 278
 279     PySys_SetArgv(argc, argv);
 280
 281     // We have to set things up in the special __main__ module
 282     PyObject *module = PyImport_AddModule(PyCC("__main__"));
 283     if (module == NULL)
 284         panic("Could not import __main__");
 285     PyObject *dict = PyModule_GetDict(module);
 286
 287     // import the main m5 module
 288     PyObject *result;
 289     const char **command = m5MainCommands;
 290
 291     // evaluate each command in the m5MainCommands array (basically a
 292     // bunch of python statements.
 293     while (*command) {
 294         result = PyRun_String(*command, Py_file_input, dict, dict);
 295         if (!result) {
 296             PyErr_Print();
 297             return 1;
 298         }
 299         Py_DECREF(result);
 300
 301         command++;
 302     }
 303
 304 #if HAVE_PROTOBUF
 305     google::protobuf::ShutdownProtobufLibrary();
 306 #endif
 307
 308     return 0;
 309 }
 310
 311 PyMODINIT_FUNC
 312 initm5(void)
 313 {
 314     initM5Python();
 315     PyImport_ImportModule(PyCC("m5"));
 316 }