337 lines
10 KiB
C++
337 lines
10 KiB
C++
#include "ns3module.h"
|
|
#include "ns3/ref-count-base.h"
|
|
|
|
|
|
namespace ns3{
|
|
|
|
void PythonCompleteConstruct (Ptr<Object> object, TypeId typeId, const AttributeList &attributes)
|
|
{
|
|
object->SetTypeId (typeId);
|
|
object->Object::Construct (attributes);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class PythonEventImpl : public ns3::EventImpl
|
|
{
|
|
private:
|
|
PyObject *m_callback;
|
|
PyObject *m_args;
|
|
public:
|
|
PythonEventImpl (PyObject *callback, PyObject *args)
|
|
{
|
|
m_callback = callback;
|
|
Py_INCREF(m_callback);
|
|
m_args = args;
|
|
Py_INCREF(m_args);
|
|
}
|
|
virtual ~PythonEventImpl ()
|
|
{
|
|
PyGILState_STATE __py_gil_state;
|
|
__py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
|
|
|
|
Py_DECREF(m_callback);
|
|
Py_DECREF(m_args);
|
|
|
|
if (PyEval_ThreadsInitialized())
|
|
PyGILState_Release(__py_gil_state);
|
|
}
|
|
virtual void Notify ()
|
|
{
|
|
PyGILState_STATE __py_gil_state;
|
|
__py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
|
|
|
|
PyObject *retval = PyObject_CallObject(m_callback, m_args);
|
|
if (retval) {
|
|
if (retval != Py_None) {
|
|
PyErr_SetString(PyExc_TypeError, "event callback should return None");
|
|
PyErr_Print();
|
|
}
|
|
Py_DECREF(retval);
|
|
} else {
|
|
PyErr_Print();
|
|
}
|
|
|
|
if (PyEval_ThreadsInitialized())
|
|
PyGILState_Release(__py_gil_state);
|
|
}
|
|
};
|
|
|
|
|
|
PyObject *
|
|
_wrap_Simulator_Schedule(PyNs3Simulator *PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs,
|
|
PyObject **return_exception)
|
|
{
|
|
PyObject *exc_type, *traceback;
|
|
PyObject *py_time;
|
|
PyObject *py_callback;
|
|
PyObject *user_args;
|
|
ns3::Ptr<PythonEventImpl> py_event_impl;
|
|
PyNs3EventId *py_EventId;
|
|
|
|
if (kwargs && PyObject_Length(kwargs) > 0) {
|
|
PyErr_SetString(PyExc_TypeError, "keyword arguments not supported");
|
|
goto error;
|
|
}
|
|
|
|
if (PyTuple_GET_SIZE(args) < 2) {
|
|
PyErr_SetString(PyExc_TypeError, "ns3.Simulator.Schedule needs at least 2 arguments");
|
|
goto error;
|
|
}
|
|
py_time = PyTuple_GET_ITEM(args, 0);
|
|
py_callback = PyTuple_GET_ITEM(args, 1);
|
|
|
|
if (!PyObject_IsInstance(py_time, (PyObject*) &PyNs3Time_Type)) {
|
|
PyErr_SetString(PyExc_TypeError, "Parameter 1 should be a ns3.Time instance");
|
|
goto error;
|
|
}
|
|
if (!PyCallable_Check(py_callback)) {
|
|
PyErr_SetString(PyExc_TypeError, "Parameter 2 should be callable");
|
|
goto error;
|
|
}
|
|
user_args = PyTuple_GetSlice(args, 2, PyTuple_GET_SIZE(args));
|
|
py_event_impl = ns3::Create<PythonEventImpl>(py_callback, user_args);
|
|
Py_DECREF(user_args);
|
|
|
|
py_EventId = PyObject_New(PyNs3EventId, &PyNs3EventId_Type);
|
|
py_EventId->obj = new ns3::EventId(
|
|
ns3::Simulator::Schedule(*((PyNs3Time *) py_time)->obj, py_event_impl));
|
|
return (PyObject *) py_EventId;
|
|
|
|
error:
|
|
PyErr_Fetch(&exc_type, return_exception, &traceback);
|
|
Py_XDECREF(exc_type);
|
|
Py_XDECREF(traceback);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
PyObject *
|
|
_wrap_Simulator_ScheduleNow(PyNs3Simulator *PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs,
|
|
PyObject **return_exception)
|
|
{
|
|
PyObject *exc_type, *traceback;
|
|
PyObject *py_callback;
|
|
PyObject *user_args;
|
|
ns3::Ptr<PythonEventImpl> py_event_impl;
|
|
PyNs3EventId *py_EventId;
|
|
|
|
if (kwargs && PyObject_Length(kwargs) > 0) {
|
|
PyErr_SetString(PyExc_TypeError, "keyword arguments not supported");
|
|
goto error;
|
|
}
|
|
|
|
if (PyTuple_GET_SIZE(args) < 1) {
|
|
PyErr_SetString(PyExc_TypeError, "ns3.Simulator.Schedule needs at least 1 argument");
|
|
goto error;
|
|
}
|
|
py_callback = PyTuple_GET_ITEM(args, 0);
|
|
|
|
if (!PyCallable_Check(py_callback)) {
|
|
PyErr_SetString(PyExc_TypeError, "Parameter 2 should be callable");
|
|
goto error;
|
|
}
|
|
user_args = PyTuple_GetSlice(args, 1, PyTuple_GET_SIZE(args));
|
|
py_event_impl = ns3::Create<PythonEventImpl>(py_callback, user_args);
|
|
Py_DECREF(user_args);
|
|
|
|
py_EventId = PyObject_New(PyNs3EventId, &PyNs3EventId_Type);
|
|
py_EventId->obj = new ns3::EventId(ns3::Simulator::ScheduleNow(py_event_impl));
|
|
return (PyObject *) py_EventId;
|
|
|
|
error:
|
|
PyErr_Fetch(&exc_type, return_exception, &traceback);
|
|
Py_XDECREF(exc_type);
|
|
Py_XDECREF(traceback);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
PyObject *
|
|
_wrap_Simulator_ScheduleDestroy(PyNs3Simulator *PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs,
|
|
PyObject **return_exception)
|
|
{
|
|
PyObject *exc_type, *traceback;
|
|
PyObject *py_callback;
|
|
PyObject *user_args;
|
|
ns3::Ptr<PythonEventImpl> py_event_impl;
|
|
PyNs3EventId *py_EventId;
|
|
|
|
if (kwargs && PyObject_Length(kwargs) > 0) {
|
|
PyErr_SetString(PyExc_TypeError, "keyword arguments not supported");
|
|
goto error;
|
|
}
|
|
|
|
if (PyTuple_GET_SIZE(args) < 1) {
|
|
PyErr_SetString(PyExc_TypeError, "ns3.Simulator.Schedule needs at least 1 argument");
|
|
goto error;
|
|
}
|
|
py_callback = PyTuple_GET_ITEM(args, 0);
|
|
|
|
if (!PyCallable_Check(py_callback)) {
|
|
PyErr_SetString(PyExc_TypeError, "Parameter 2 should be callable");
|
|
goto error;
|
|
}
|
|
user_args = PyTuple_GetSlice(args, 1, PyTuple_GET_SIZE(args));
|
|
py_event_impl = ns3::Create<PythonEventImpl>(py_callback, user_args);
|
|
Py_DECREF(user_args);
|
|
|
|
py_EventId = PyObject_New(PyNs3EventId, &PyNs3EventId_Type);
|
|
py_EventId->obj = new ns3::EventId(ns3::Simulator::ScheduleDestroy(py_event_impl));
|
|
return (PyObject *) py_EventId;
|
|
|
|
error:
|
|
PyErr_Fetch(&exc_type, return_exception, &traceback);
|
|
Py_XDECREF(exc_type);
|
|
Py_XDECREF(traceback);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
PyObject *
|
|
_wrap_TypeId_LookupByNameFailSafe(PyNs3TypeId *PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs,
|
|
PyObject **return_exception)
|
|
{
|
|
bool ok;
|
|
const char *name;
|
|
Py_ssize_t name_len;
|
|
ns3::TypeId tid;
|
|
PyNs3TypeId *py_tid;
|
|
const char *keywords[] = {"name", NULL};
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "s#", (char **) keywords, &name, &name_len)) {
|
|
PyObject *exc_type, *traceback;
|
|
PyErr_Fetch(&exc_type, return_exception, &traceback);
|
|
Py_XDECREF(exc_type);
|
|
Py_XDECREF(traceback);
|
|
return NULL;
|
|
}
|
|
ok = ns3::TypeId::LookupByNameFailSafe(std::string(name, name_len), &tid);
|
|
if (!ok)
|
|
{
|
|
PyErr_Format(PyExc_KeyError, "The ns3 type with name `%s' is not registered", name);
|
|
return NULL;
|
|
}
|
|
|
|
py_tid = PyObject_New(PyNs3TypeId, &PyNs3TypeId_Type);
|
|
py_tid->obj = new ns3::TypeId (tid);
|
|
PyNs3TypeId_wrapper_registry[(void *) py_tid->obj] = (PyObject *) py_tid;
|
|
|
|
return (PyObject *) py_tid;
|
|
}
|
|
|
|
|
|
class CommandLinePythonValueSetter : public ns3::RefCountBase
|
|
{
|
|
PyObject *m_namespace;
|
|
std::string m_variable;
|
|
public:
|
|
CommandLinePythonValueSetter (PyObject *ns, std::string const &variable) {
|
|
Py_INCREF(ns);
|
|
m_namespace = ns;
|
|
m_variable = variable;
|
|
}
|
|
bool Parse (std::string value) {
|
|
PyObject *pyvalue = PyString_FromStringAndSize (value.data(), value.size());
|
|
PyObject_SetAttrString (m_namespace, (char *) m_variable.c_str(), pyvalue);
|
|
if (PyErr_Occurred()) {
|
|
PyErr_Print();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
virtual ~CommandLinePythonValueSetter () {
|
|
Py_DECREF (m_namespace);
|
|
m_namespace = NULL;
|
|
}
|
|
|
|
};
|
|
|
|
PyObject *
|
|
_wrap_CommandLine_AddValue(PyNs3CommandLine *self, PyObject *args, PyObject *kwargs,
|
|
PyObject **return_exception)
|
|
{
|
|
const char *name, *help, *variable = NULL;
|
|
PyObject *py_namespace = NULL;
|
|
const char *keywords[] = {"name", "help", "variable", "namespace", NULL};
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "ss|sO", (char **) keywords, &name, &help, &variable, &py_namespace)) {
|
|
PyObject *exc_type, *traceback;
|
|
PyErr_Fetch(&exc_type, return_exception, &traceback);
|
|
Py_XDECREF(exc_type);
|
|
Py_XDECREF(traceback);
|
|
return NULL;
|
|
}
|
|
|
|
if (variable == NULL) {
|
|
variable = name;
|
|
}
|
|
if (py_namespace == NULL) {
|
|
py_namespace = (PyObject *) self;
|
|
}
|
|
|
|
ns3::Ptr<CommandLinePythonValueSetter> setter = ns3::Create<CommandLinePythonValueSetter> (py_namespace, variable);
|
|
self->obj->AddValue (name, help, ns3::MakeCallback (&CommandLinePythonValueSetter::Parse, setter));
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
|
|
PyObject *
|
|
_wrap_Simulator_Run(PyNs3Simulator *PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs,
|
|
PyObject **return_exception)
|
|
{
|
|
const char *keywords[] = {"signal_check_frequency", NULL};
|
|
int signal_check_frequency;
|
|
|
|
ns3::Ptr<ns3::DefaultSimulatorImpl> defaultSim =
|
|
ns3::DynamicCast<ns3::DefaultSimulatorImpl> (ns3::Simulator::GetImplementation ());
|
|
if (defaultSim) {
|
|
signal_check_frequency = 100;
|
|
} else {
|
|
signal_check_frequency = -1;
|
|
}
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "|i", (char **) keywords, &signal_check_frequency)) {
|
|
PyObject *exc_type, *traceback;
|
|
PyErr_Fetch(&exc_type, return_exception, &traceback);
|
|
Py_XDECREF(exc_type);
|
|
Py_XDECREF(traceback);
|
|
return NULL;
|
|
}
|
|
|
|
PyThreadState *py_thread_state = NULL;
|
|
|
|
if (signal_check_frequency == -1)
|
|
{
|
|
if (PyEval_ThreadsInitialized ())
|
|
py_thread_state = PyEval_SaveThread();
|
|
ns3::Simulator::Run();
|
|
if (py_thread_state)
|
|
PyEval_RestoreThread(py_thread_state);
|
|
} else {
|
|
while (!ns3::Simulator::IsFinished())
|
|
{
|
|
if (PyEval_ThreadsInitialized())
|
|
py_thread_state = PyEval_SaveThread();
|
|
|
|
for (int n = signal_check_frequency; n > 0 && !ns3::Simulator::IsFinished(); --n)
|
|
{
|
|
ns3::Simulator::RunOneEvent();
|
|
}
|
|
|
|
if (py_thread_state)
|
|
PyEval_RestoreThread(py_thread_state);
|
|
PyErr_CheckSignals();
|
|
if (PyErr_Occurred())
|
|
return NULL;
|
|
}
|
|
}
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|