Improved performance of Function.__call__, Function.skip_hooks and Function.call_trampoline.

Author: jordanbriere

src/core/modules/memory/memory_function.cpp

@@ -259,24 +259,24 @@ void CallHelperVoid(DCCallVM* vm, unsigned long addr)
 	EXCEPT_SEGV()
 }
 
-object CFunction::Call(tuple args, dict kw)
+object CFunction::Call(PyObject *args, PyObject *kw)
 {
 	if (!IsCallable())
 		BOOST_RAISE_EXCEPTION(PyExc_ValueError, "Function is not callable.")
 
 	Validate();
-	if (len(args) != len(m_tArgs))
+	if (PyTuple_GET_SIZE(args) - 1 != len(m_tArgs))
 		BOOST_RAISE_EXCEPTION(PyExc_ValueError, "Number of passed arguments is not equal to the required number.")
 
 	// Reset VM and set the calling convention
 	dcReset(g_pCallVM);
 	dcMode(g_pCallVM, m_iCallingConvention);
 
 	// Loop through all passed arguments and add them to the VM
-	for(int i=0; i < len(args); i++)
+	for(int i=1; i < PyTuple_GET_SIZE(args); i++)
 	{
-		object arg = args[i];
-		switch(extract<DataType_t>(m_tArgs[i]))
+		PyObject *arg = PyTuple_GET_ITEM(args, i);
+		switch(extract<DataType_t>(m_tArgs[i - 1]))
 		{
 			case DATA_TYPE_BOOL:		dcArgBool(g_pCallVM, extract<bool>(arg)); break;
 			case DATA_TYPE_CHAR:		dcArgChar(g_pCallVM, extract<char>(arg)); break;
@@ -294,8 +294,8 @@ object CFunction::Call(tuple args, dict kw)
 			case DATA_TYPE_POINTER:
 			{
 				unsigned long ulAddr = 0;
-				if (arg.ptr() != Py_None)
-					ulAddr = ExtractAddress(arg);
+				if (arg != Py_None)
+					ulAddr = ExtractAddress(object(handle<>(borrowed(arg))));
 
 				dcArgPointer(g_pCallVM, ulAddr);
 				break;
@@ -336,7 +336,7 @@ object CFunction::Call(tuple args, dict kw)
 	return object();
 }
 
-object CFunction::CallTrampoline(tuple args, dict kw)
+object CFunction::CallTrampoline(PyObject *args, PyObject *kw)
 {
 	CHook* pHook = GetHookManager()->FindHook((void *) m_ulAddr);
 	if (!pHook)
@@ -346,7 +346,7 @@ object CFunction::CallTrampoline(tuple args, dict kw)
 		m_iCallingConvention, m_tArgs, m_eReturnType, m_oConverter).Call(args, kw);
 }
 
-object CFunction::SkipHooks(tuple args, dict kw)
+object CFunction::SkipHooks(PyObject *args, PyObject *kw)
 {
 	CHook* pHook = GetHookManager()->FindHook((void *) m_ulAddr);
 	if (pHook)

src/core/modules/memory/memory_function.h

@@ -71,9 +71,9 @@ class CFunction: public CPointer
 
 	CFunction* GetTrampoline();
 
-	object Call(boost::python::tuple args, dict kw);
-	object CallTrampoline(boost::python::tuple args, dict kw);
-	object SkipHooks(boost::python::tuple args, dict kw);
+	object Call(PyObject *args, PyObject *kw);
+	object CallTrampoline(PyObject *args, PyObject *kw);
+	object SkipHooks(PyObject *args, PyObject *kw);
 
 	void AddHook(HookType_t eType, PyObject* pCallable);
 	void RemoveHook(HookType_t eType, PyObject* pCallable);

src/core/modules/memory/memory_wrap.cpp

@@ -457,7 +457,7 @@ void export_function(scope _memory)
 		.def(init<CFunction&>())
 
 		.def("__call__",
-			raw_method(&CFunction::Call),
+			very_raw_method(&CFunction::Call),
 			"Calls the function dynamically."
 		)
 
@@ -477,12 +477,12 @@ void export_function(scope _memory)
 		)
 
 		.def("call_trampoline",
-			raw_method(&CFunction::CallTrampoline),
+			very_raw_method(&CFunction::CallTrampoline),
 			"Calls the trampoline function dynamically."
 		)
 
 		.def("skip_hooks",
-			raw_method(&CFunction::SkipHooks),
+			very_raw_method(&CFunction::SkipHooks),
 			"Call the function, but skip hooks if there are any."
 		)
 

src/core/utilities/wrap_macros.h

@@ -30,6 +30,7 @@
 // Includes
 //---------------------------------------------------------------------------------
 #include "boost/function.hpp"
+#include "boost/function_types/parameter_types.hpp"
 #include "boost/python.hpp"
 using namespace boost::python;
 
@@ -215,6 +216,39 @@ object raw_method(T func, int min_args = 0)
 	);
 }
 
+template<class T, typename U>
+struct very_raw_method_dispatcher
+{
+public:
+	very_raw_method_dispatcher(T func):
+		func(func)
+	{
+	}
+
+	PyObject *operator()(PyObject *args, PyObject *kwargs)
+	{
+		return incref((extract<U &>(PyTuple_GET_ITEM(args, 0))().*func)(args, kwargs).ptr());
+	}
+
+private:
+	T func;
+};
+
+template<class T>
+object very_raw_method(T func, int min_args = 0)
+{
+	return boost::python::detail::make_raw_function(
+		objects::py_function(
+			very_raw_method_dispatcher<
+				T, boost::mpl::at_c<boost::function_types::parameter_types<T>, 0>::type
+			>(func),
+			boost::mpl::vector1<PyObject *>(),
+			min_args + 1,
+			(std::numeric_limits<unsigned>::max)()
+		)
+	);
+}
+
 //---------------------------------------------------------------------------------
 // Use this macro to define a function or class method that raises a
 // NotImplementedError. This is quite hacky, but saves a lot work!