charm-crypto-framework 0.61.1__cp313-cp313-macosx_10_13_universal2.whl

charm/core/benchmark/benchmark_util.h

@@ -0,0 +1,61 @@
+#ifndef BENCHMARK_UTIL_H
+#define BENCHMARK_UTIL_H
+
+// for multiplicative notation
+#define Op_MUL(op_var_type, op_group_type, group, bench_obj)  \
+	if(op_var_type == MULTIPLICATION && op_group_type == group)      \
+		((Operations *) bench_obj)->mul_ ##group += 1;
+
+#define Op_DIV(op_var_type, op_group_type, group, bench_obj)  \
+	if(op_var_type == DIVISION && op_group_type == group)      \
+		((Operations *) bench_obj)->div_ ##group += 1;
+
+// for additive notation
+#define Op_ADD(op_var_type, op_group_type, group, bench_obj)  \
+	if(op_var_type == ADDITION && op_group_type == group)      \
+		((Operations *) bench_obj)->add_ ##group += 1;
+
+#define Op_SUB(op_var_type, op_group_type, group, bench_obj)  \
+	if(op_var_type == SUBTRACTION && op_group_type == group)      \
+		((Operations *) bench_obj)->sub_ ##group += 1;
+
+// exponentiation
+#define Op_EXP(op_var_type, op_group_type, group, bench_obj)  \
+	if(op_var_type == EXPONENTIATION && op_group_type == group)      \
+		((Operations *) bench_obj)->exp_ ##group += 1;
+
+#define UPDATE_BENCH(op_type, elem_type, gobj) \
+	if(gobj->dBench != NULL && gobj->dBench->granular_option == TRUE && elem_type != NONE_G) {		\
+		Update_Op(MUL, op_type, elem_type, gobj->gBench) \
+		Update_Op(DIV, op_type, elem_type, gobj->gBench) \
+		Update_Op(ADD, op_type, elem_type, gobj->gBench) \
+		Update_Op(SUB, op_type, elem_type, gobj->gBench) \
+		Update_Op(EXP, op_type, elem_type, gobj->gBench) \
+	}		\
+	UPDATE_BENCHMARK(op_type, gobj->dBench);
+
+#define CLEAR_DBENCH(bench_obj, group)   \
+	((Operations *) bench_obj)->mul_ ##group = 0;	\
+	((Operations *) bench_obj)->exp_ ##group = 0;	\
+	((Operations *) bench_obj)->div_ ##group = 0;	\
+	((Operations *) bench_obj)->add_ ##group = 0;	\
+	((Operations *) bench_obj)->sub_ ##group = 0;	\
+
+#define GetField(count, type, group, bench_obj)  \
+	if(type == MULTIPLICATION) count = (((Operations *) bench_obj)->mul_ ##group ); \
+	else if(type == DIVISION) count = (((Operations *) bench_obj)->div_ ##group );	\
+	else if(type == ADDITION) count = (((Operations *) bench_obj)->add_ ##group ); \
+	else if(type == SUBTRACTION) count = (((Operations *) bench_obj)->sub_ ##group ); \
+	else if(type == EXPONENTIATION) count = (((Operations *) bench_obj)->exp_ ##group );
+
+#define ClearBenchmark(data) \
+	data->op_add = data->op_sub = data->op_mult = 0; \
+	data->op_div = data->op_exp = data->op_pair = 0; \
+	data->cpu_time_ms = 0.0;	\
+	data->real_time_ms = 0.0;	\
+	data->cpu_option = FALSE;	\
+	data->real_option = FALSE;	\
+	data->granular_option = FALSE;
+
+
+#endif

charm/core/benchmark/benchmarkmodule.c

@@ -0,0 +1,476 @@
+#define BENCHMARK_MODULE
+#include "benchmarkmodule.h"
+#ifndef BENCHMARK_MODULE
+// define new benchmark type for benchmark module
+PyTypeObject BenchmarkType;
+// define new benchmark error type (will be used for notifying errors)
+PyObject *BenchmarkError;
+#endif
+double CalcUsecs(struct timeval *start, struct timeval *stop) {
+	double usec_per_second = 1000000;
+	double result = usec_per_second * (stop->tv_sec - start->tv_sec);
+
+	if(stop->tv_usec >= start->tv_usec) {
+		result += (stop->tv_usec - start->tv_usec);
+	}
+	else {
+		result -= (start->tv_usec - stop->tv_usec);
+	}
+
+//	if(result < 0) {
+//		debug("start secs => '%ld' and usecs => '%d'\n", start->tv_sec, start->tv_usec);
+//		debug("stop secs => '%ld' and usecs => '%d'\n", stop->tv_sec, stop->tv_usec);
+//	}
+
+	return result / usec_per_second;
+}
+
+int check_option(MeasureType o, Benchmark *d)  {
+	int i;
+	if(d != NULL && d->bench_initialized) {
+		for(i = 0; i < d->num_options; i++) {
+			MeasureType tmp = d->options_selected[i];
+			if(tmp == o) { return TRUE; }
+		}
+	}
+	return FALSE;
+}
+
+
+// benchmark new
+PyObject *Benchmark_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+	Benchmark *self;
+    self = (Benchmark *)type->tp_alloc(type, 0);
+    if(self != NULL) {
+    	self->bench_initialized = FALSE;
+		self->bench_inprogress = FALSE;  // false until we StartBenchmark( ... )
+		self->op_add = self->op_sub = self->op_mult = 0;
+		self->op_div = self->op_exp = self->op_pair = 0;
+		self->cpu_time_ms = self->real_time_ms = 0.0;
+		self->cpu_option = self->real_option = FALSE;
+    	debug("Creating new benchmark object.\n");
+    }
+    return (PyObject *) self;
+}
+
+// benchmark init
+int Benchmark_init(Benchmark *self, PyObject *args, PyObject *kwds)
+{
+	return 0;
+}
+// benchmark dealloc
+void Benchmark_dealloc(Benchmark *self) {
+	debug("Releasing benchmark object.\n");
+	Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+static int PyStartBenchmark(Benchmark *data, PyObject *opList, int opListSize)
+{
+	int i;
+	if(!PyList_Check(opList)) {
+		PyErr_SetString(BenchmarkError, "did not provide a list.");
+		return FALSE;
+	}
+
+	PyObject *tmpObj;
+	char *s;
+	if(data != NULL) {
+		int cnt = 0;
+		/* initialize */
+		data->cpu_option = data->real_option = data->granular_option = FALSE;
+		for(i = 0; i < opListSize; i++) {
+			PyObject *item = PyList_GetItem(opList, i);
+			if(PyBytes_CharmCheck(item)) {
+				s = NULL;
+				tmpObj = NULL;
+				PyBytes_ToString2(s, item, tmpObj);
+				if(strcmp(s, _CPUTIME_OPT) == 0) {
+					debug("enabled cputime option!\n");
+					data->options_selected[cnt] = CPU_TIME;
+					data->cpu_option = TRUE;
+				}
+				else if(strcmp(s, _REALTIME_OPT) == 0) {
+					debug("enabled realtime option!\n");
+					data->options_selected[cnt] = REAL_TIME;
+					data->real_option = TRUE;
+				}
+				else if(strcmp(s, _ADD_OPT) == 0) {
+					debug("enabled add option!\n");
+					data->options_selected[cnt] = ADDITION;
+					data->op_add = 0;
+				}
+				else if(strcmp(s, _SUB_OPT) == 0) {
+					debug("enabled sub option!\n");
+					data->options_selected[cnt] = SUBTRACTION;
+					data->op_sub = 0;
+				}
+				else if(strcmp(s, _MUL_OPT) == 0) {
+					debug("enabled mul option!\n");
+					data->options_selected[cnt] = MULTIPLICATION;
+					data->op_mult = 0;
+				}
+				else if(strcmp(s, _DIV_OPT) == 0) {
+					debug("enabled div option!\n");
+					data->options_selected[cnt] = DIVISION;
+					data->op_div = 0;
+				}
+				else if(strcmp(s, _EXP_OPT) == 0) {
+					debug("enabled exp option!\n");
+					data->options_selected[cnt] = EXPONENTIATION;
+					data->op_exp = 0;
+				}
+				else if(strcmp(s, _PAIR_OPT) == 0) {
+					debug("enabled pair option!\n");
+					data->options_selected[cnt] = PAIRINGS;
+					data->op_pair = 0;
+				}
+				else if(strcmp(s, _GRAN_OPT) == 0) {
+					debug("enabled granular option!\n");
+					data->options_selected[cnt] = GRANULAR;
+					data->granular_option = TRUE;
+				}
+				else {
+					debug("not a valid option.\n");
+				}
+				cnt++;
+                if (tmpObj!=NULL)
+				    Py_DECREF(tmpObj);
+			}
+		}
+		// set size of list
+		data->num_options = cnt;
+		debug("num_options set: %d\n", data->num_options);
+		data->bench_initialized = TRUE;
+		data->bench_inprogress = TRUE;
+
+		//set timers for time-based measures (reduces the overhead of timer)
+		if(data->cpu_option) { data->start_clock = clock(); }
+		if(data->real_option) { gettimeofday(&data->start_time, NULL); }
+		return TRUE;
+	}
+	return FALSE;
+}
+
+static int PyEndBenchmark(Benchmark *data)
+{
+	gettimeofday(&data->stop_time, NULL); // stop real time clock
+	data->stop_clock = clock(); // stop cpu time clock
+	int i;
+	if(data != NULL && data->bench_initialized) {
+		debug("Results....\n");
+		for(i = 0; i < data->num_options; i++) {
+			MeasureType option = data->options_selected[i];
+			debug("option => %d\n", option);
+			switch(option) {
+				case CPU_TIME:  // compute processor time or clocks per sec
+								data->cpu_time_ms = ((double)(data->stop_clock - data->start_clock))/CLOCKS_PER_SEC;
+								debug("CPU Time:\t%f\n", data->cpu_time_ms);
+								break;
+				case REAL_TIME:	debug("realtime option was set!\n");
+								data->real_time_ms = CalcUsecs(&data->start_time, &data->stop_time);
+								debug("Real Time:\t%f\n", data->real_time_ms);
+								break;
+				case ADDITION: 		debug("add operations:\t\t%d\n", data->op_add); break;
+				case SUBTRACTION:  debug("sub operations:\t\t%d\n", data->op_sub); break;
+				case MULTIPLICATION:  debug("mult operations:\t\t%d\n", data->op_mult); break;
+				case DIVISION:	debug("div operations:\t\t%d\n", data->op_div); break;
+				case EXPONENTIATION: debug("exp operations:\t\t%d\n", data->op_exp); break;
+				case PAIRINGS: debug("pairing operations:\t\t%d\n", data->op_pair); break;
+				case GRANULAR: debug("granular option was set!\n"); break;
+				default: debug("not a valid option.\n"); break;
+			}
+		}
+		data->bench_inprogress = FALSE;
+		return TRUE;
+	}
+	return FALSE;
+}
+
+static int PyUpdateBenchmark(MeasureType option, Benchmark *data) {
+	int i, errcode = FALSE, foundOption = FALSE;
+	// make sure option is set in benchmark
+
+	if(data != NULL && data->bench_initialized) {
+		for(i = 0; i < data->num_options; i++) {
+			MeasureType tmp = data->options_selected[i];
+			if(tmp == option) { foundOption = TRUE; break; }
+		}
+	}
+
+	// if so, just increment the corresponding operation option counter
+	if(foundOption) {
+		switch(option) {
+		case ADDITION: 		 data->op_add++; break;
+		case SUBTRACTION:  	 data->op_sub++; break;
+		case MULTIPLICATION: data->op_mult++; break;
+		case DIVISION:		 data->op_div++; break;
+		case EXPONENTIATION: data->op_exp++; break;
+		case PAIRINGS: 		 data->op_pair++; break;
+		default: debug("not a valid option.\n");
+					 break;
+		}
+		errcode = TRUE;
+	}
+	return errcode;
+}
+
+static int PyClearBenchmark(Benchmark *data) {
+	if(data == NULL) { return FALSE; }
+
+	data->bench_initialized = FALSE;
+	data->identifier = -1;
+	data->op_add = data->op_sub = data->op_mult = 0;
+	data->op_div = data->op_exp = data->op_pair = 0;
+	data->cpu_time_ms = 0.0;
+	data->real_time_ms = 0.0;
+	data->cpu_option = FALSE;
+	data->real_option = FALSE;
+	data->granular_option = FALSE;
+	memset(data->options_selected, 0, MAX_MEASURE);
+	debug("Initialized benchmark object.\n");
+	return TRUE;
+}
+
+PyObject *Benchmark_print(Benchmark *self) {
+	if(self != NULL) {
+		PyObject *cpu = PyFloat_FromDouble(self->cpu_time_ms);
+		PyObject *real = PyFloat_FromDouble(self->real_time_ms);
+		PyObject *results = _PyUnicode_FromFormat("<--- Results --->\nCPU Time:  %Sms\nReal Time: %Ss\nAdd:\t%i\nSub:\t%i\nMul:\t%i\nDiv:\t%i\nExp:\t%i\nPair:\t%i\n",
+								cpu, real, self->op_add, self->op_sub, self->op_mult, self->op_div, self->op_exp, self->op_pair);
+
+		PyClearBenchmark(self);
+		return results;
+	}
+	return _PyUnicode_FromString("Benchmark object has not been initialized properly.");
+}
+
+PyObject *GetResults(Benchmark *self) {
+	if(self != NULL) {
+		return Py_BuildValue("{sfsfsisisisisi}",
+						"CpuTime", self->cpu_time_ms, "RealTime", self->real_time_ms,
+						"Add", self->op_add, "Sub", self->op_sub, "Mul", self->op_mult,
+						"Div", self->op_div, "Exp", self->op_exp);
+	}
+
+	return _PyUnicode_FromString("Benchmark object has not been initialized properly.");
+}
+
+PyObject *GetResultsWithPair(Benchmark *self) {
+	if(self != NULL) {
+		return Py_BuildValue("{sfsfsisisisisisi}",
+						"CpuTime", self->cpu_time_ms, "RealTime", self->real_time_ms,
+						"Add", self->op_add, "Sub", self->op_sub, "Mul", self->op_mult,
+						"Div", self->op_div, "Exp", self->op_exp, "Pair", self->op_pair);
+	}
+
+	return _PyUnicode_FromString("Benchmark object has not been initialized properly.");
+}
+
+
+PyObject *Retrieve_result(Benchmark *self, char *option) {
+	PyObject *result = NULL;
+
+	if(self != NULL) {
+		if(strcmp(option, _CPUTIME_OPT) == 0) {
+			result = PyFloat_FromDouble(self->cpu_time_ms);
+		}
+		else if(strcmp(option, _REALTIME_OPT) == 0) {
+			result = PyFloat_FromDouble(self->real_time_ms);
+		}
+		else if(strcmp(option, _ADD_OPT) == 0) {
+			result = PyToLongObj(self->op_add);
+		}
+		else if(strcmp(option, _SUB_OPT) == 0) {
+			result = PyToLongObj(self->op_sub);
+		}
+		else if(strcmp(option, _MUL_OPT) == 0) {
+			result = PyToLongObj(self->op_mult);
+		}
+		else if(strcmp(option, _DIV_OPT) == 0) {
+			result = PyToLongObj(self->op_div);
+		}
+		else if(strcmp(option, _EXP_OPT) == 0) {
+			result = PyToLongObj(self->op_exp);
+		}
+		else if(strcmp(option, _PAIR_OPT) == 0) {
+			result = PyToLongObj(self->op_pair);
+		}
+		else {
+			debug("not a valid option.\n");
+		}
+	}
+	return result;
+}
+
+#if PY_MAJOR_VERSION >= 3
+PyTypeObject BenchmarkType = {
+  PyVarObject_HEAD_INIT(NULL, 0)
+  "profile.Benchmark",       /*tp_name*/
+  sizeof(Benchmark),         /*tp_basicsize*/
+  0,                         /*tp_itemsize*/
+  (destructor)Benchmark_dealloc, /*tp_dealloc*/
+  0,                         /*tp_print*/
+  0,                         /*tp_getattr*/
+  0,                         /*tp_setattr*/
+  0,                /*tp_reserved*/
+  0, /*tp_repr*/
+  0,               /*tp_as_number*/
+  0,                         /*tp_as_sequence*/
+  0,                         /*tp_as_mapping*/
+  0,   /*tp_hash */
+  0,                         /*tp_call*/
+  0, /*tp_str*/
+  0,                         /*tp_getattro*/
+  0,                         /*tp_setattro*/
+  0,                         /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "Benchmark objects",           /* tp_doc */
+  0,                   /* tp_traverse */
+  0,                   /* tp_clear */
+  0,          /* tp_richcompare */
+  0,                   /* tp_weaklistoffset */
+  0,                   /* tp_iter */
+  0,                   /* tp_iternext */
+  0,             /* tp_methods */
+  0,             /* tp_members */
+  0,                         /* tp_getset */
+  0,                         /* tp_base */
+  0,                         /* tp_dict */
+  0,                         /* tp_descr_get */
+  0,                         /* tp_descr_set */
+  0,                         /* tp_dictoffset */
+  (initproc)Benchmark_init,      /* tp_init */
+  0,                         /* tp_alloc */
+  Benchmark_new,                 /* tp_new */
+};
+
+#else
+PyTypeObject BenchmarkType = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	"profile.Benchmark",       /*tp_name*/
+	sizeof(Benchmark),         /*tp_basicsize*/
+	0,                         /*tp_itemsize*/
+	(destructor)Benchmark_dealloc, /*tp_dealloc*/
+	0,                         /*tp_print*/
+	0,                         /*tp_getattr*/
+	0,                         /*tp_setattr*/
+	0,			   				/*tp_reserved*/
+	0, 							/*tp_repr*/
+	0,               		   /*tp_as_number*/
+	0,                         /*tp_as_sequence*/
+	0,                         /*tp_as_mapping*/
+	0,                         /*tp_hash */
+	0,                         /*tp_call*/
+	0,                         /*tp_str*/
+	0,                         /*tp_getattro*/
+	0,                         /*tp_setattro*/
+	0,                         /*tp_as_buffer*/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
+	"Benchmark objects",           /* tp_doc */
+	0,		               /* tp_traverse */
+	0,		               /* tp_clear */
+	0,		       		   /* tp_richcompare */
+	0,		               /* tp_weaklistoffset */
+	0,		               /* tp_iter */
+	0,		               /* tp_iternext */
+	0,             		   /* tp_methods */
+	0,             			   /* tp_members */
+	0,                         /* tp_getset */
+	0,                         /* tp_base */
+	0,                         /* tp_dict */
+	0,                         /* tp_descr_get */
+	0,                         /* tp_descr_set */
+	0,                         /* tp_dictoffset */
+	(initproc)Benchmark_init,      /* tp_init */
+	0,                         /* tp_alloc */
+	Benchmark_new,                 /* tp_new */
+};
+#endif
+
+struct module_state {
+	PyObject *error;
+};
+
+#if PY_MAJOR_VERSION >= 3
+#define GETSTATE(m) ((struct module_state *) PyModule_GetState(m))
+#else
+#define GETSTATE(m) (&_state)
+static struct module_state _state;
+#endif
+
+// benchmark type methods (module scope)
+static PyMethodDef module_methods[] = {
+		{NULL}
+};
+
+#if PY_MAJOR_VERSION >= 3
+static int bm_traverse(PyObject *m, visitproc visit, void *arg) {
+	Py_VISIT(GETSTATE(m)->error);
+	return 0;
+}
+
+static int bm_clear(PyObject *m) {
+	Py_CLEAR(GETSTATE(m)->error);
+	return 0;
+}
+
+static struct PyModuleDef moduledef = {
+		PyModuleDef_HEAD_INIT,
+		"benchmark",
+		NULL,
+		sizeof(struct module_state),
+		module_methods,
+		NULL,
+		bm_traverse,
+		bm_clear,
+		NULL
+};
+
+#define INITERROR return NULL
+PyMODINIT_FUNC
+PyInit_benchmark(void) 		{
+#else
+#define INITERROR return
+void initbenchmark(void) 		{
+#endif
+	PyObject *module;
+	static void *PyBenchmark_API[PyBenchmark_API_pointers];
+	PyObject *api_object;
+
+	if(PyType_Ready(&BenchmarkType) < 0) INITERROR;
+
+#if PY_MAJOR_VERSION >= 3
+  module = PyModule_Create(&moduledef);
+#else
+  module = Py_InitModule("benchmark", module_methods);
+#endif
+	if(module == NULL) INITERROR;
+
+	struct module_state *st = GETSTATE(module);
+	st->error = PyErr_NewException("benchmark.Error", NULL, NULL);
+	if(st->error == NULL) {
+		Py_DECREF(module);
+		INITERROR;
+	}
+	BenchmarkError = st->error;
+
+	/* initialize the c api pointer array - this is what other modules call */
+	PyBenchmark_API[PyBenchmark_Start]  = (void *)PyStartBenchmark;
+	PyBenchmark_API[PyBenchmark_End]    = (void *)PyEndBenchmark;
+	PyBenchmark_API[PyBenchmark_Update] = (void *)PyUpdateBenchmark;
+	PyBenchmark_API[PyBenchmark_Clear]  = (void *)PyClearBenchmark;
+
+	api_object = (PyObject *) PyCapsule_New((void *) PyBenchmark_API,BENCHMARK_MOD_NAME, NULL);
+	if(api_object != NULL) {
+	  PyModule_AddObject(module, "_C_API", api_object);
+	}
+
+	Py_INCREF(&BenchmarkType);
+	PyModule_AddObject(module, "Benchmark", (PyObject *) &BenchmarkType);
+	// add exception handler
+#if PY_MAJOR_VERSION >= 3
+	return module;
+#endif
+
+}

charm/core/benchmark/benchmarkmodule.h

@@ -0,0 +1,162 @@
+/*
+ * benchmarkmodule.h
+ */
+#ifndef Py_BENCHMARKMODULE_H_
+#define Py_BENCHMARKMODULE_H_
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef PY_SSIZE_T_CLEAN
+#define PY_SSIZE_T_CLEAN
+#endif
+
+#include <Python.h>
+#include <structmember.h>
+#include <sys/time.h>
+
+// set default if not passed in by compiler
+//#ifndef BENCHMARK_ENABLED
+//#define BENCHMARK_ENABLED 1vi bad
+//#endif
+//#define DEBUG   1
+#define TRUE	1
+#define FALSE	0
+
+#ifdef DEBUG
+#define debug(...)	printf("DEBUG: "__VA_ARGS__)
+#else
+#define debug(...)
+#endif
+
+/* Python 3.x definitions */
+#define _PyLong_Check(o1) PyLong_Check(o1)
+#define ConvertToInt(o) PyLong_AsLong(o)
+#define PyToLongObj(o) PyLong_FromLong(o)
+/* check for both unicode and bytes objects */
+#define PyBytes_CharmCheck(obj) PyUnicode_Check(obj) || PyBytes_Check(obj)
+/* if unicode then add extra conversion step. two possibilities: unicode or bytes */
+#define PyBytes_ToString2(a, obj, tmp_obj)	\
+if(PyBytes_Check(obj)) { a = PyBytes_AsString(obj); } \
+else if(PyUnicode_Check(obj)) { tmp_obj = PyUnicode_AsUTF8String(obj); a = PyBytes_AsString(tmp_obj); }	\
+else { tmp_obj = PyObject_Str(obj); a = PyBytes_AsString(tmp_obj); }
+
+#define _PyUnicode_FromFormat PyUnicode_FromFormat
+#define _PyUnicode_FromString PyUnicode_FromString
+
+#define BENCHMARK_MOD_NAME "charm.core.benchmark._C_API"
+
+#ifndef BENCHMARK_MODULE
+// define new benchmark type for benchmark module
+extern PyTypeObject BenchmarkType;
+// define new benchmark error type (will be used for notifying errors)
+extern PyObject *BenchmarkError;
+#else
+// define new benchmark type for benchmark module
+PyTypeObject BenchmarkType;
+// define new benchmark error type (will be used for notifying errors)
+PyObject *BenchmarkError;
+#endif
+// define a macro to help determine whether an object is of benchmark type
+#define PyBenchmark_Check(obj) PyObject_TypeCheck(obj, &BenchmarkType)
+/* header file for benchmark module */
+#define MAX_MEASURE 10
+enum Measure {CPU_TIME = 0, REAL_TIME, NATIVE_TIME, ADDITION, SUBTRACTION, MULTIPLICATION, DIVISION, EXPONENTIATION, PAIRINGS, GRANULAR, NONE};
+typedef enum Measure MeasureType;
+#define _CPUTIME_OPT 	"CpuTime"
+#define _REALTIME_OPT 	"RealTime"
+#define _ADD_OPT		"Add"
+#define _SUB_OPT		"Sub"
+#define _MUL_OPT		"Mul"
+#define _DIV_OPT		"Div"
+#define _EXP_OPT		"Exp"
+#define _PAIR_OPT		"Pair"
+#define _GRAN_OPT		"Granular"
+
+typedef struct {
+	PyObject_HEAD
+	struct timeval start_time, stop_time, native_time; // track real time
+	clock_t start_clock, stop_clock; // track cpu time
+
+	int op_add, op_sub, op_mult, op_div;
+	int op_exp, op_pair;
+	double cpu_time_ms, real_time_ms;
+	int num_options; // track num options for a particular benchmark
+	MeasureType options_selected[MAX_MEASURE+1]; // measurement options selected
+	int cpu_option, real_option, granular_option;
+	int identifier;
+	int bench_initialized, bench_inprogress;
+} Benchmark;
+
+// PyMethodDef Benchmark_methods[];
+PyObject *Benchmark_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
+void Benchmark_dealloc(Benchmark *self);
+int Benchmark_init(Benchmark *self, PyObject *args, PyObject *kwds);
+
+PyObject *Benchmark_print(Benchmark *self);
+PyObject *GetResults(Benchmark *self);
+PyObject *GetResultsWithPair(Benchmark *self);
+PyObject *Retrieve_result(Benchmark *self, char *option);
+
+/* c api functions */
+#define PyBenchmark_Start 		  0
+#define PyBenchmark_End 		  1
+#define PyBenchmark_Update		  2
+#define PyBenchmark_Clear		  3
+
+/* total number of C api pointers? */
+#define PyBenchmark_API_pointers 4
+
+#ifdef BENCHMARK_ENABLED
+#define UPDATE_BENCHMARK(option, bench)   \
+	if(bench != NULL && bench->bench_initialized == TRUE) {	   \
+	PyUpdateBenchmark(option, bench); }
+
+#else
+#define UPDATE_BENCHMARK(option, bench) /* ... */
+#endif
+
+#ifdef BENCHMARK_MODULE
+/* This section is used when compiling benchmarkmodule.c */
+static int PyStartBenchmark(Benchmark *data, PyObject *opList, int opListSize);
+static int PyEndBenchmark(Benchmark *data);
+static int PyUpdateBenchmark(MeasureType option, Benchmark *data);
+static int PyClearBenchmark(Benchmark *data);
+
+#else
+
+/* This section is used in modules that use benchmarkmodule's API
+ * e.g. pairingmath, integermath, etc.
+ */
+static void **PyBenchmark_API;
+
+#define PyStartBenchmark (*(int (*)(Benchmark *data, PyObject *opList, int opListSize)) PyBenchmark_API[PyBenchmark_Start])
+#define PyEndBenchmark (*(int (*)(Benchmark *data)) PyBenchmark_API[PyBenchmark_End])
+#define PyUpdateBenchmark (*(int (*)(MeasureType option, Benchmark *data)) PyBenchmark_API[PyBenchmark_Update])
+#define PyClearBenchmark (*(int (*)(Benchmark *data)) PyBenchmark_API[PyBenchmark_Clear])
+
+#define ADD_BENCHMARK_OPTIONS(m)		\
+	PyModule_AddStringConstant(m, "CpuTime", "CpuTime");		\
+	PyModule_AddStringConstant(m, "RealTime", "RealTime");		\
+	PyModule_AddStringConstant(m, "Add", "Add");			\
+	PyModule_AddStringConstant(m, "Sub", "Sub");		\
+	PyModule_AddStringConstant(m, "Mul", "Mul");		\
+	PyModule_AddStringConstant(m, "Div", "Div");			\
+	PyModule_AddStringConstant(m, "Exp", "Exp");
+
+/* end - api helper functions */
+
+static int import_benchmark(void)
+{
+	// PyBenchmark_API = (void **) PyCapsule_Import(BENCHMARK_MOD_NAME, 1);
+  PyBenchmark_API = (void **) PyCapsule_Import(BENCHMARK_MOD_NAME, 0); // 0 = enable tracing
+  return (PyBenchmark_API != NULL) ? 0 : -1;
+}
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PY_BENCHMARK_H_ */