Implements mmap.mmap usage in RPNIterExpr

Preparing serialization

python_const.c

@@ -40,6 +40,11 @@ on pos_flag",
 		.name = "const_values",
 		.doc = "Constant values to use when setting value in space \
 (expr gives the position, and we set this value",
+	},
+	{
+		.name = "memory_size",
+		.doc = "The size of the underlying memory map data are \
+readed/written to",
 	},
 	{ NULL, NULL },
 };

python_if.c

@@ -8,10 +8,20 @@
 /**@brief @ref pymod_pyrpn_RPNExprIter methods definition
  * @ingroup pymod_pyrpn_RPNExprIter */
 static PyMethodDef RPNIterExpr_methods[] = {
+	PYRPN_method("params", rpnif_params,
+			METH_VARARGS | METH_KEYWORDS | METH_CLASS,
+			/**@todo add default values */
+			"cls, pos_flag, res_flag, size_lim, const_values, stack_size",
+			"Get a name tuple with parameters given a position \
+flag, a result flag and size limits"),
 	PYRPN_method("get_params", rpnif_get_params,
 			METH_NOARGS,
 			"self, /",
 			"Get a name tuple with parameters"),
+	PYRPN_method("set_mmap", rpnif_set_mmap,
+			METH_O,
+			"self, mmap, /",
+			"Set the mmap that stores data"),
 	PYRPN_method("shape", rpnif_shape,
 			METH_NOARGS,
 			"self, /",
@@ -58,6 +68,8 @@ static PyMethodDef RPNIterExpr_methods[] = {
 static PyMemberDef RPNIterExpr_members[] = {
 	{"expressions", T_OBJECT, offsetof(PyRPNIterExpr_t, expr), READONLY,
 		"The tuple of expressions"},
+	{"mmap", T_OBJECT, offsetof(PyRPNIterExpr_t, mmap), READONLY,
+		"The mmap storing data"},
 	{NULL}
 };
 
@@ -110,6 +122,44 @@ PyTypeObject RPNIterExprType = {
 	.tp_new = rpnif_new,
 };
 
+PyObject* rpnif_params(PyObject *cls, PyObject *args, PyObject *kwds)
+{
+	char *names[] = {"pos_flag", "res_flag", "size_lim", "const_values", "stack_size", NULL};
+
+	unsigned short pos_flag, res_flag, stack_size;
+	PyObject *lim_obj, *const_values_obj;
+
+	stack_size = 16;
+	const_values_obj = lim_obj = NULL;
+	
+	if(!PyArg_ParseTupleAndKeywords(args, kwds,
+			"HHO|OH:RPNIterExppr.get_params", names,
+			&pos_flag, &res_flag, &lim_obj, &const_values_obj,
+			&stack_size))
+	{
+		return NULL;
+	}
+
+	rpn_if_param_t *rif_params = _rpnif_get_params(pos_flag, res_flag,
+			lim_obj, const_values_obj, stack_size);
+	if(!rif_params)
+	{
+		return NULL;
+	}
+
+	PyObject *res = _rpnif_params_to_tuple(rif_params);
+	if(!res)
+	{
+		goto err;
+	}
+	free(rif_params);
+	return res;
+
+err:
+	free(rif_params);
+	return NULL;
+}
+
 PyObject* rpnif_new(PyTypeObject *subtype, PyObject *args, PyObject* kwds)
 {
 	PyObject *ret, *err;
@@ -130,175 +180,72 @@ PyObject* rpnif_new(PyTypeObject *subtype, PyObject *args, PyObject* kwds)
 int rpnif_init(PyObject *self, PyObject *args, PyObject *kwds)
 {
 	PyRPNIterExpr_t *expr_self;
-	char *names[] = {"pos_flag", "res_flag", "size_lim", "const_values", "stack_size", NULL};
+	char *names[] = {"pos_flag", "res_flag", "size_lim", "const_values", "stack_size", "mmap", NULL};
 	unsigned short pos_flag, res_flag, stack_size;
-	PyObject *lim_obj, *const_values_obj;
-	int ndim;
+	PyObject *lim_obj, *const_values_obj, *mmap_obj;
 
-	char err_str[256];
 
 	expr_self = (PyRPNIterExpr_t*)self;
 
 	stack_size = 16;
-	const_values_obj = lim_obj = NULL;
+	const_values_obj = lim_obj = mmap_obj = NULL;
 	expr_self->rif = NULL;
+	expr_self->mmap = NULL;
 
-	if(!PyArg_ParseTupleAndKeywords(args, kwds, "HHO|OH:RPNIterExpr.__init__", names,
-		&pos_flag, &res_flag, &lim_obj, &const_values_obj, &stack_size))
+	if(!PyArg_ParseTupleAndKeywords(args, kwds, "HHO|OHO:RPNIterExpr.__init__", names,
+		&pos_flag, &res_flag, &lim_obj, &const_values_obj, &stack_size,
+		&mmap_obj))
 	{
 		return -1;
 	}
 
-	// Args checking
-	if(stack_size < 4 || stack_size > 255)
-	{
-		snprintf(err_str, 128,
-			"Stack size should be in [0..255] but %u given",
-			stack_size);
-		PyErr_SetString(PyExc_ValueError, err_str);
-		return -1;
-	}
+	rpn_if_param_t *rif_params = _rpnif_get_params(pos_flag, res_flag,
+			lim_obj, const_values_obj, stack_size);
 
-	// Checks flags & fetch expected sizes for size_lim & const_values
-	short expt_sizes[2];
-	if(rpn_if_sizes_from_flag(pos_flag, res_flag, expt_sizes) < 0)
+	if(!rif_params)
 	{
-		if(expt_sizes[0] < 0)
-		{
-			PyErr_SetString(PyExc_ValueError,
-				"Invalid position flag given");
-		}
-		else
-		{
-			PyErr_SetString(PyExc_ValueError,
-				"Invalid result flag given");
-		}
 		return -1;
 	}
 
-	//Check & convert lim
-	PyObject *tmp;
-	tmp = PySequence_Fast(lim_obj, "Sequence expected for size_lim argument");
-	if(PyErr_Occurred())
-	{
-		return -1;
-	}
-	Py_ssize_t lim_obj_sz = PySequence_Fast_GET_SIZE(tmp);
-	ndim = lim_obj_sz;
-	if(PyErr_Occurred())
-	{
-		Py_DECREF(tmp);
-		return -1;
-	}
-	if(lim_obj_sz < 1)
-	{
-		Py_DECREF(tmp);
-		PyErr_SetString(PyExc_ValueError,
-			"Size limits cannot be empty");
-		return -1;
-	}
+	expr_self->ndim = ((rpn_if_default_data_t*)(rif_params->data))->ndim;
 
-	if(pos_flag == RPN_IF_POSITION_XDIM)
+	const Py_ssize_t expt_sz = rif_params->mem_sz * rif_params->value_sz;
+	if(!mmap_obj)
 	{
-		PyObject *item = PySequence_Fast_GET_ITEM(tmp, 0);
-		Py_ssize_t tmp = PyLong_AsSsize_t(item);
-		if(PyErr_Occurred())
-		{
-			PyErr_SetString(PyExc_ValueError,
-				"Unable to convert size_lim[0] to int");
-			Py_DECREF(tmp);
-			return -1;
-		}
-		if(lim_obj_sz != tmp + 1)
-		{
-			PyErr_Format(PyExc_ValueError,
-				"Xdim indicate %d size_lim but len(size_lim)=%d",
-				tmp+1, lim_obj_sz);
-			Py_DECREF(tmp);
-			return -1;
-		}
-		expt_sizes[0] = ndim = tmp;
+		PyObject *fileno = PyLong_FromLong(-1);
+		PyObject *length = PyLong_FromSize_t(expt_sz);
+		mmap_obj = PyObject_CallFunctionObjArgs(mmap_cls, fileno, length, NULL);
 	}
 	else
 	{
-		if(lim_obj_sz != expt_sizes[0])
-		{
-			PyErr_Format(PyExc_ValueError,
-				"Expected %d size_lim but len(size_lim)=%d",
-				expt_sizes[0], lim_obj_sz);
-			Py_DECREF(tmp);
-			return -1;
-		}
-	}
-
-	size_t sz_limits[lim_obj_sz];
-	for(Py_ssize_t i = 0; i<lim_obj_sz; i++)
-	{
-		PyObject *item = PySequence_Fast_GET_ITEM(tmp, i);
-		sz_limits[i] = PyLong_AsSize_t(item);
-		if(PyErr_Occurred())
-		{
-			PyErr_Format(PyExc_ValueError,
-				"Unable to convert size_lim[%d] to unsigned int",
-				i);
-			Py_DECREF(tmp);
-			return -1;
-		}
-	}
-	Py_DECREF(tmp);
-	tmp = NULL;
-
-	expr_self->ndim = ndim;
-
-	//Check & convert const values
-	Py_ssize_t values_obj_sz = 0;
-	if(expt_sizes[1] > 0)
-	{
-		tmp = const_values_obj;
-		if(!PyTuple_Check(tmp))
+		if(!PyObject_TypeCheck(mmap_obj, (PyTypeObject*)mmap_cls))
 		{
-			PyErr_SetString(PyExc_ValueError,
-				"Invalid type for const_values argument");
+			PyErr_Format(PyExc_TypeError,
+					"The mmap argument MUST be an instance \
+of mmap.mmap");
 			return -1;
 		}
-		values_obj_sz = PyTuple_Size(tmp);
-		if(values_obj_sz != expt_sizes[1])
+		/**@todo check if mmap is shared & writable ? */
+		if(PyObject_Length(mmap_obj) != (Py_ssize_t) expt_sz)
 		{
 			PyErr_Format(PyExc_ValueError,
-				"Expected %d const_values but len(const_values)=%d",
-				expt_sizes[1], values_obj_sz);
+				"Expected mmap length is %ld but mmap with length  %ld provided",
+				rif_params->mem_sz, PyObject_Length(mmap_obj));
 			return -1;
 		}
 	}
 
-	rpn_value_t const_values[values_obj_sz];
-	for(Py_ssize_t i = 0; i<values_obj_sz; i++)
-	{
-		PyObject *item = PyTuple_GET_ITEM(tmp, i);
-		const_values[i] = PyLong_AsRpnValue_t(item);
-		if(PyErr_Occurred())
-		{
-			PyErr_Format(PyExc_ValueError,
-				"Unable to convert size_lim[%d] to unsigned int",
-				i);
-			return -1;
-		}
-	}
-
-
-	// Creating rif params
-	rpn_if_param_t *rif_params;
 
-	if(!(rif_params = rpn_if_default_params(pos_flag, res_flag,
-		sz_limits, const_values, stack_size)))
+	if(PyObject_GetBuffer(mmap_obj, &expr_self->mm_buff,
+				PyBUF_CONTIG) == -1)
 	{
-		PyErr_SetString(PyExc_ValueError, "Unable to create parameters \
-with given arguments");
 		return -1;
 	}
 
+	expr_self->mmap = mmap_obj;
+
 	// Creating rif with a new memory map
-	expr_self->rif = rpn_if_new(rif_params, NULL);
+	expr_self->rif = rpn_if_new(rif_params, expr_self->mm_buff.buf);
 	if(!expr_self->rif)
 	{
 		PyErr_Format(PyExc_RuntimeError,
@@ -326,75 +273,48 @@ with given arguments");
 PyObject *rpnif_get_params(PyObject *self)
 {
 	PyRPNIterExpr_t *expr_self = (PyRPNIterExpr_t*)self;
-	PyObject *res, *val;
-	rpn_if_default_data_t *params;
-
-	params = (rpn_if_default_data_t*)(expr_self->rif->params->data);
+	return _rpnif_params_to_tuple(expr_self->rif->params);
+}
 
-	short expt_sizes[2];
-	if(rpn_if_sizes_from_flag(params->pos_flag, params->res_flag, expt_sizes) < 0)
+PyObject *rpnif_set_mmap(PyObject *self, PyObject *mm_obj)
+{
+	if(!PyObject_TypeCheck(mm_obj, (PyTypeObject*)mmap_cls))
 	{
-		PyErr_SetString(PyExc_RuntimeError, "Invalid internal state");
+		PyErr_Format(PyExc_TypeError,
+				"Excpected instance of mmap.mmap");
 		return NULL;
 	}
+	PyRPNIterExpr_t *expr_self = (PyRPNIterExpr_t*)self;
 
-	res = PyStructSequence_New(&rpnif_params_SeqDesc);
-	if(!res)
+	Py_buffer buff;
+
+	/**@todo check mm size &writable ? */
+	if(PyObject_GetBuffer(mm_obj, &buff, PyBUF_CONTIG) == -1)
 	{
 		return NULL;
 	}
-	val = PyLong_FromLong(expr_self->rif->params->rpn_argc);
-	PyStructSequence_SET_ITEM(res, 0, val);
-
-	val = PyLong_FromLong(params->pos_flag);
-	PyStructSequence_SET_ITEM(res, 1, val);
 
-	val = PyLong_FromLong(params->res_flag);
-	PyStructSequence_SET_ITEM(res, 2, val);
+	// Release old mmap
+	PyBuffer_Release(&expr_self->mm_buff);
+	Py_DECREF(expr_self->mmap);
 
-	if(params->pos_flag == RPN_IF_POSITION_XDIM)
+	if(expr_self->rif->self_mem)
 	{
-		expt_sizes[0] = params->size_lim[0] + 1;
+		const size_t mm_sz = expr_self->rif->params->mem_sz *\
+				     expr_self->rif->params->value_sz;
+		munmap(expr_self->rif->mem, mm_sz);
 	}
 
-	PyObject *lim  = PyTuple_New(expt_sizes[0]);
-	if(!lim)
-	{
-		Py_DECREF(res);
-		return NULL;
-	}
-	PyStructSequence_SET_ITEM(res, 3, lim);
+	// Set new mmap in python struct & rif struct
+	expr_self->mm_buff = buff;
+	expr_self->mmap = mm_obj;
 
-	for(Py_ssize_t i=0; i<expt_sizes[0]; i++)
-	{
-		val = PyLong_FromSize_t(params->size_lim[i]);
-		PyTuple_SET_ITEM(lim, i, val);
-	}
+	expr_self->rif->mem = buff.buf;
+	expr_self->rif->self_mem = 0;
 
-	if(!params->const_val)
-	{
-		Py_INCREF(Py_None);
-		PyTuple_SET_ITEM(res, 4, Py_None);
-	}
-	else
-	{
-		PyObject *values = PyTuple_New(expt_sizes[1]);
-		if(!values)
-		{
-			Py_DECREF(res);
-			return NULL;
-		}
-		PyStructSequence_SET_ITEM(res, 4, values);
-		for(Py_ssize_t i=0; i<expt_sizes[1]; i++)
-		{
-			val = PyLong_FromRpnValue_t(params->const_val[i]);
-			PyTuple_SET_ITEM(values, i, val);
-		}
-	}
-	return res;
+	Py_RETURN_NONE;
 }
 
-
 PyObject *rpnif_shape(PyObject *self)
 {
 	PyRPNIterExpr_t *expr_self = (PyRPNIterExpr_t*)self;
@@ -705,6 +625,11 @@ void rpnif_del(PyObject *self)
 		rpn_if_free(expr_self->rif);
 		expr_self->rif = NULL;
 	}
+	if(expr_self->mm_buff.buf)
+	{
+		PyBuffer_Release(&expr_self->mm_buff);
+	}
+	Py_DECREF(expr_self->mmap);
 }
 
 
@@ -912,9 +837,12 @@ int rpnif_getbuffer(PyObject *self, Py_buffer *view, int flags)
 	PyRPNIterExpr_t *expr_self;
 	expr_self = (PyRPNIterExpr_t*)self;
 
+	return PyObject_GetBuffer(expr_self->mmap, view, flags);
+
 	rpn_if_default_data_t *data = (rpn_if_default_data_t*)expr_self->rif->params->data;
 
 	view->buf = expr_self->rif->mem;
+dprintf(2, "buffer addr %p\n", expr_self->mm_buff.buf);
 	view->obj = self;
 	view->len = expr_self->rif->params->mem_sz * expr_self->rif->params->value_sz;
 	view->readonly = 0;
@@ -1186,7 +1114,7 @@ PyObject* rpnif_getstate(PyObject *self, PyObject *noargs)
 	PyErr_SetString(PyExc_NotImplementedError,
 		"getstate Not implemented");
 	return NULL;
-	/**@todo TODO write the function */
+
 	Py_RETURN_NONE;
 }
 
@@ -1199,6 +1127,233 @@ PyObject* rpnif_setstate(PyObject *self, PyObject *state_bytes)
 	Py_RETURN_NONE;
 }
 
+rpn_if_param_t *_rpnif_get_params(unsigned short pos_flag, unsigned short res_flag,
+		PyObject *lim_obj, PyObject *const_values_obj,
+		unsigned short stack_size)
+{
+	char err_str[256];
+	int ndim;
+
+	// Args checking
+	if(stack_size < 4 || stack_size > 255)
+	{
+		snprintf(err_str, 128,
+			"Stack size should be in [0..255] but %u given",
+			stack_size);
+		PyErr_SetString(PyExc_ValueError, err_str);
+		return NULL;
+	}
+
+	// Checks flags & fetch expected sizes for size_lim & const_values
+	short expt_sizes[2];
+	if(rpn_if_sizes_from_flag(pos_flag, res_flag, expt_sizes) < 0)
+	{
+		if(expt_sizes[0] < 0)
+		{
+			PyErr_SetString(PyExc_ValueError,
+				"Invalid position flag given");
+		}
+		else
+		{
+			PyErr_SetString(PyExc_ValueError,
+				"Invalid result flag given");
+		}
+		return NULL;
+	}
+
+	//Check & convert lim
+	PyObject *tmp;
+	tmp = PySequence_Fast(lim_obj, "Sequence expected for size_lim argument");
+	if(PyErr_Occurred())
+	{
+		return NULL;
+	}
+	Py_ssize_t lim_obj_sz = PySequence_Fast_GET_SIZE(tmp);
+	ndim = lim_obj_sz;
+	if(PyErr_Occurred())
+	{
+		Py_DECREF(tmp);
+		return NULL;
+	}
+	if(lim_obj_sz < 1)
+	{
+		Py_DECREF(tmp);
+		PyErr_SetString(PyExc_ValueError,
+			"Size limits cannot be empty");
+		return NULL;
+	}
+
+	if(pos_flag == RPN_IF_POSITION_XDIM)
+	{
+		PyObject *item = PySequence_Fast_GET_ITEM(tmp, 0);
+		Py_ssize_t tmp = PyLong_AsSsize_t(item);
+		if(PyErr_Occurred())
+		{
+			PyErr_SetString(PyExc_ValueError,
+				"Unable to convert size_lim[0] to int");
+			Py_DECREF(tmp);
+			return NULL;
+		}
+		if(lim_obj_sz != tmp + 1)
+		{
+			PyErr_Format(PyExc_ValueError,
+				"Xdim indicate %d size_lim but len(size_lim)=%d",
+				tmp+1, lim_obj_sz);
+			Py_DECREF(tmp);
+			return NULL;
+		}
+		expt_sizes[0] = ndim = tmp;
+	}
+	else
+	{
+		if(lim_obj_sz != expt_sizes[0])
+		{
+			PyErr_Format(PyExc_ValueError,
+				"Expected %d size_lim but len(size_lim)=%d",
+				expt_sizes[0], lim_obj_sz);
+			Py_DECREF(tmp);
+			return NULL;
+		}
+	}
+
+	size_t sz_limits[lim_obj_sz];
+	for(Py_ssize_t i = 0; i<lim_obj_sz; i++)
+	{
+		PyObject *item = PySequence_Fast_GET_ITEM(tmp, i);
+		sz_limits[i] = PyLong_AsSize_t(item);
+		if(PyErr_Occurred())
+		{
+			PyErr_Format(PyExc_ValueError,
+				"Unable to convert size_lim[%d] to unsigned int",
+				i);
+			Py_DECREF(tmp);
+			return NULL;
+		}
+	}
+	Py_DECREF(tmp);
+	tmp = NULL;
+
+	//Check & convert const values
+	Py_ssize_t values_obj_sz = 0;
+	if(expt_sizes[1] > 0)
+	{
+		tmp = const_values_obj;
+		if(!PyTuple_Check(tmp))
+		{
+			PyErr_SetString(PyExc_ValueError,
+				"Invalid type for const_values argument");
+			return NULL;
+		}
+		values_obj_sz = PyTuple_Size(tmp);
+		if(values_obj_sz != expt_sizes[1])
+		{
+			PyErr_Format(PyExc_ValueError,
+				"Expected %d const_values but len(const_values)=%d",
+				expt_sizes[1], values_obj_sz);
+			return NULL;
+		}
+	}
+
+	rpn_value_t const_values[values_obj_sz];
+	for(Py_ssize_t i = 0; i<values_obj_sz; i++)
+	{
+		PyObject *item = PyTuple_GET_ITEM(tmp, i);
+		const_values[i] = PyLong_AsRpnValue_t(item);
+		if(PyErr_Occurred())
+		{
+			PyErr_Format(PyExc_ValueError,
+				"Unable to convert size_lim[%d] to unsigned int",
+				i);
+			return NULL;
+		}
+	}
+
+
+	// Creating rif params
+	rpn_if_param_t *rif_params;
+
+	if(!(rif_params = rpn_if_default_params(pos_flag, res_flag,
+		sz_limits, const_values, stack_size)))
+	{
+		PyErr_SetString(PyExc_ValueError, "Unable to create parameters \
+with given arguments");
+		return NULL;
+	}
+
+	return rif_params;
+}
+
+PyObject *_rpnif_params_to_tuple(const rpn_if_param_t *_params)
+{
+	PyObject *res, *val;
+	short expt_sizes[2];
+	rpn_if_default_data_t *params;
+	params = (rpn_if_default_data_t*)(_params->data);
+
+	if(rpn_if_sizes_from_flag(params->pos_flag, params->res_flag, expt_sizes) < 0)
+	{
+		PyErr_SetString(PyExc_RuntimeError, "Invalid internal state");
+		return NULL;
+	}
+
+	res = PyStructSequence_New(&rpnif_params_SeqDesc);
+	if(!res)
+	{
+		return NULL;
+	}
+	val = PyLong_FromLong(_params->rpn_argc);
+	PyStructSequence_SET_ITEM(res, 0, val);
+
+	val = PyLong_FromLong(params->pos_flag);
+	PyStructSequence_SET_ITEM(res, 1, val);
+
+	val = PyLong_FromLong(params->res_flag);
+	PyStructSequence_SET_ITEM(res, 2, val);
+
+	if(params->pos_flag == RPN_IF_POSITION_XDIM)
+	{
+		expt_sizes[0] = params->size_lim[0] + 1;
+	}
+
+	PyObject *lim  = PyTuple_New(expt_sizes[0]);
+	if(!lim)
+	{
+		Py_DECREF(res);
+		return NULL;
+	}
+	PyStructSequence_SET_ITEM(res, 3, lim);
+
+	for(Py_ssize_t i=0; i<expt_sizes[0]; i++)
+	{
+		val = PyLong_FromSize_t(params->size_lim[i]);
+		PyTuple_SET_ITEM(lim, i, val);
+	}
+
+	if(!params->const_val)
+	{
+		Py_INCREF(Py_None);
+		PyTuple_SET_ITEM(res, 4, Py_None);
+	}
+	else
+	{
+		PyObject *values = PyTuple_New(expt_sizes[1]);
+		if(!values)
+		{
+			Py_DECREF(res);
+			return NULL;
+		}
+		PyStructSequence_SET_ITEM(res, 4, values);
+		for(Py_ssize_t i=0; i<expt_sizes[1]; i++)
+		{
+			val = PyLong_FromRpnValue_t(params->const_val[i]);
+			PyTuple_SET_ITEM(values, i, val);
+		}
+	}
+	val = PyLong_FromUnsignedLong(_params->mem_sz * _params->value_sz);
+	PyStructSequence_SET_ITEM(res, 5, val);
+	return res;
+}
+
 /**@def _ret_append(key) 
  * @hiderefs
  * local macro */

python_if.h

@@ -55,6 +55,11 @@
  * @ingroup pymod_pyrpn_RPNExprIter */
 extern PyTypeObject RPNIterExprType;
 
+/**@brief Points on Python's std mmap module */
+extern PyObject *mmap_module;
+/**@brief Python's mmap.mmap class */
+extern PyObject *mmap_cls;
+
 /**@brief Structure holding RPNIterExpr objects
  * @ingroup pymod_pyrpn_RPNExprIter */
 typedef struct
@@ -71,8 +76,21 @@ typedef struct
 	/**@brief Python tuple with instances of RPNExpr */
 	PyObject *expr;
 
+	/**@brief Python mmap.mmap instance representing rif memory map */
+	PyObject *mmap;
+
+	/**@brief Memory map buffer allowing acces to underlying pointer */
+	Py_buffer mm_buff;
+
 } PyRPNIterExpr_t;
 
+/**@brief RPNIterExpr.params static method
+ * @param args Position arguments
+ * @param kwds Keyword arguments
+ * @return A new rpnif_params_SeqDesc instance
+ */
+PyObject* rpnif_params(PyObject *cls, PyObject *args, PyObject *kwds);
+
 /**@brief RpnIterExpr __new__ method
  * @param subtype Type of object being created (pyrpn.RPNIterExpr)
  * @param args positional arguments for subtype
@@ -124,6 +142,13 @@ void rpnif_releasebuffer(PyObject *self, Py_buffer *view);
  */
 PyObject *rpnif_get_params(PyObject *self);
 
+/**@brief Set the mmap object used for data storage
+ * @param self RPNIterExpr instance
+ * @return None
+ * @ingroup pymod_pyrpn_RPNExprIter
+ */
+PyObject *rpnif_set_mmap(PyObject *self, PyObject *mm_obj);
+
 /**@brief Return a tuple with data buffer's shape
  * @param self RPNIterExpr instance
  * @return A new ref on a tuple
@@ -250,6 +275,22 @@ PyObject *rpnif_values(PyObject *self);
  * @ingroup pymod_pyrpn_RPNExprIter */
 PyObject *rpnif_items(PyObject *self);
 
+/**@brief Returns rpn_if_params given arguments
+ * @param pos_flag a position flag
+ * @param res_flag a result flag
+ * @param size_lim a tuple with size limits
+ * @param const_values a tuple wiith constant values
+ * @param stack_size a stack size
+ */
+rpn_if_param_t *_rpnif_get_params(unsigned short pos_flag, unsigned short res_flag,
+		PyObject *size_lim, PyObject *const_values,
+		unsigned short stack_size);
+
+/**@brief Converts rpn_if_params to named tuple
+ * @param params The rpnif params
+ * @return A named tuple
+ */
+PyObject *_rpnif_params_to_tuple(const rpn_if_param_t *params);
 
 #endif
 

python_pyrpn.c

@@ -51,9 +51,33 @@ PyModuleDef rpnmodule = {
 	NULL	// m_free
 };
 
+PyObject *mmap_module = NULL;
+PyObject *mmap_cls = NULL;
+
 PyMODINIT_FUNC
 PyInit_pyrpn(void)
 {
+	if(mmap_module == NULL)
+	{
+		mmap_module = PyImport_ImportModule("mmap");
+		if(PyErr_Occurred()) { return NULL; }
+		else if(!mmap_module)
+		{
+			PyErr_Format(PyExc_ImportError, "Unable to import mmap module");
+			return NULL;
+		}
+	}
+	if(mmap_cls == NULL)
+	{
+		mmap_cls = PyObject_GetAttrString(mmap_module, "mmap");
+		if(PyErr_Occurred()) { return NULL; }
+		else if (!mmap_cls)
+		{
+			PyErr_Format(PyExc_ImportError, "Unable to import mmap.mmap");
+			return NULL;
+		}
+	}
+	
 
 	PyObject *mod, *const_mod, *tokens_mod;
 	// init module & globals

python_pyrpn.h

@@ -77,6 +77,11 @@ PyMODINIT_FUNC PyInit_pyrpn(void);
  * @ingroup pymod_pyrpn */
 extern PyModuleDef rpnmodule;
 
+/**@brief Points on Python's std mmap module */
+extern PyObject *mmap_module;
+/**@brief Python's mmap.mmap class */
+extern PyObject *mmap_cls;
+
 /**@brief Return a dict with valid operations (short keys and long values)
  * @param mod pyrpn module object
  * @param noargs Dummy argument for METH_NOARG

tests/tests_rpniter.py

@@ -18,6 +18,7 @@
 #
 
 import copy
+import mmap
 import pickle
 import random
 import sys
@@ -87,6 +88,7 @@ class TestRPNIterInit(unittest.TestCase):
                 self.assertEqual(params.size_lim, arg[2])
                 self.assertIsNone(params.const_values)
     
+
     def test_params_const(self):
         """ Test parameters from instanciation when const values used as result """
         args = [(pyrpn.const.POS_XY,
@@ -171,6 +173,78 @@ class TestRPNIterInit(unittest.TestCase):
                     self.assertEqual(len(arr), expt_sz)
                     arr += 0x11111111 # check writing to all bytes
 
+    @skipIfNoNumpy()
+    def test_mmap_accessor(self):
+        """ Testing mmap access """
+        args = (pyrpn.const.POS_XY,
+                  pyrpn.const.RESULT_COUNT,
+                  (640,480))
+        rif = pyrpn.RPNIterExpr(*args)
+        arr = np.frombuffer(rif, dtype=np.uint64)
+        arr[42] = 1312
+        arr2 = np.frombuffer(rif.mmap, dtype=np.uint64)
+        self.assertTrue((arr == arr2).all())
+
+        rif.mmap.write(b'hello world !')
+        arr = np.frombuffer(rif, dtype=np.uint64)
+        arr2 = np.frombuffer(rif.mmap, dtype=np.uint64)
+        self.assertTrue((arr == arr2).all())
+
+    @skipIfNoNumpy()
+    def test_mmap_argument(self):
+        """ Testing mmap argument """
+        args = (pyrpn.const.POS_XY,
+                  pyrpn.const.RESULT_COUNT,
+                  (640,480))
+        params = pyrpn.RPNIterExpr.params(*args)
+        mm = mmap.mmap(-1, params.memory_size)
+        mm.write(b'Hello world !')
+        rif = pyrpn.RPNIterExpr(*args, mmap=mm)
+        self.assertEqual(mm, rif.mmap)
+        arr = np.frombuffer(rif, dtype=np.uint64)
+        arr2 = np.frombuffer(mm, dtype=np.uint64)
+        self.assertTrue((arr == arr2).all())
+
+    @skipIfNoNumpy()
+    def test_mmap_update(self):
+        """ Testing mmap update """
+        args = (pyrpn.const.POS_XY, pyrpn.const.RESULT_RGB,
+                (640,480))
+        params = pyrpn.RPNIterExpr.params(*args)
+        mm1 = mmap.mmap(-1, params.memory_size)
+        arr = np.frombuffer(mm1, dtype=np.uint64)
+        for _ in range(1024):
+            idx = random.randint(0, params.memory_size // 8)
+            val = random.randint(0, 0xFFFFFFFF)
+            arr[idx] = val
+
+        rif = pyrpn.RPNIterExpr(*args)
+        pos = 0
+        while pos == 0:
+            for exp in rif.expressions:
+                exp.mutate(n_mutations=15)
+            pos = rif.step(pos)
+
+        for _ in range(4096):
+            pos = rif.step(pos)
+
+        arr2 = arrorig = np.frombuffer(rif, dtype=np.uint64)
+        self.assertFalse((arr == arr2).all())
+
+        rif.set_mmap(mm1)
+        arr2 = np.frombuffer(rif, dtype=np.uint64)
+        self.assertTrue((arr == arr2).all())
+        del(arr)
+        del(arr2)
+
+        mm1.write(b'Hello world !')
+        arr2 = np.frombuffer(rif, dtype=np.uint64)
+        arr = np.frombuffer(mm1, dtype=np.uint64)
+        self.assertTrue((arr == arr2).all())
+
+        arr = np.frombuffer(mm1, dtype=np.uint64)
+        self.assertFalse((arr == arrorig).all())
+
     def test_str(self):
         """ Test string representation of rif """