charm-crypto-lite 0.61.1__cp314-cp314-macosx_10_15_universal2.whl

charm_crypto_lite-0.61.1.dist-info/METADATA

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: charm-crypto-lite
+Version: 0.61.1
+Summary: Lightweight elliptic curve cryptography from the Charm framework (OpenSSL-only, no GMP/PBC)
+Author-email: "J. Ayo Akinyele" <jakinye3@jhu.edu>
+Maintainer-email: "J. Ayo Akinyele" <jakinye3@jhu.edu>
+Project-URL: Homepage, https://github.com/JHUISI/charm
+Project-URL: Documentation, https://jhuisi.github.io/charm/
+Project-URL: Repository, https://github.com/JHUISI/charm
+Project-URL: Issues, https://github.com/JHUISI/charm/issues
+Keywords: cryptography,elliptic curves,secp256k1,hash-to-curve,openssl
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: C
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+
+# charm-crypto-lite
+
+**Minimal elliptic curve cryptography for Python** — a lightweight subset of the [Charm Crypto Framework](https://github.com/JHUISI/charm).
+
+## Why charm-crypto-lite?
+
+| | charm-crypto-lite | charm-crypto-framework |
+|---|---|---|
+| **Python dependencies** | **None** | pyparsing |
+| **C library dependencies** | OpenSSL only | OpenSSL + GMP + PBC |
+| **Scope** | secp256k1 EC operations | Full crypto toolkit |
+| **Use case** | ECDSA, Schnorr, ECDH | ABE, IBE, pairing-based crypto |
+
+**Use charm-crypto-lite if you:**
+- Only need elliptic curve operations on secp256k1 (Bitcoin/Ethereum curve)
+- Want zero Python dependencies and minimal C dependencies
+- Need a lightweight package for serverless/containerized environments
+
+**Use [charm-crypto-framework](https://pypi.org/project/charm-crypto-framework/) if you:**
+- Need pairing-based cryptography (ABE, IBE, signatures)
+- Need multiple curve types or pairing groups
+- Are building advanced cryptographic protocols
+
+## Installation
+
+```bash
+pip install charm-crypto-lite
+```
+
+**Prerequisites:** OpenSSL development libraries
+
+```bash
+# macOS
+brew install openssl
+
+# Ubuntu/Debian
+sudo apt-get install libssl-dev python3-dev build-essential
+```
+
+## Quick Start
+
+```python
+from charm_lite.toolbox.ecgroup import ECGroup, ZR, G
+from charm_lite.toolbox.eccurve import secp256k1
+
+group = ECGroup(secp256k1)
+
+# Get the generator point
+g = group.generator()
+
+# Generate random scalar (private key)
+x = group.random(ZR)
+
+# Scalar multiplication: public_key = g^x
+pk = g ** x
+
+# Point addition (multiplicative notation): p = h * k
+h = g ** group.random(ZR)
+p = pk * h
+
+# Serialization
+data = group.serialize(pk)
+pk2 = group.deserialize(data)
+assert pk == pk2
+```
+
+## API Reference
+
+### ECGroup Operations
+
+| Operation | Syntax | Description |
+|-----------|--------|-------------|
+| Generator | `group.generator()` | Get curve generator point G |
+| Random scalar | `group.random(ZR)` | Random scalar in field |
+| Random point | `group.random(G)` | Random point on curve |
+| Scalar multiply | `g ** x` | Point × scalar |
+| Point add | `h * k` | Point + point (multiplicative notation) |
+| Point negate | `-h` | Additive inverse |
+| Scalar add | `x + y` | Field addition |
+| Scalar multiply | `x * y` | Field multiplication |
+| Scalar invert | `~x` | Multiplicative inverse |
+| Serialize | `group.serialize(elem)` | To bytes |
+| Deserialize | `group.deserialize(data)` | From bytes |
+| Group order | `group.order()` | Curve order n |
+
+### PKEnc Base Class
+
+For building encryption schemes:
+
+```python
+from charm_lite.toolbox.PKEnc import PKEnc
+
+class MyScheme(PKEnc):
+    def keygen(self): ...
+    def encrypt(self, pk, msg): ...
+    def decrypt(self, sk, ct): ...
+```
+
+## Migrating to Full Charm
+
+```bash
+pip uninstall charm-crypto-lite
+pip install charm-crypto-framework
+```
+
+Change imports from `charm_lite` to `charm`:
+
+```python
+# Before
+from charm_lite.toolbox.ecgroup import ECGroup
+
+# After
+from charm.toolbox.ecgroup import ECGroup
+```
+
+## License
+
+LGPL-3.0-or-later
+
+## Links
+
+- [Charm Crypto Framework](https://github.com/JHUISI/charm)
+- [Documentation](https://jhuisi.github.io/charm/)
+

charm_crypto_lite-0.61.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+charm_lite/__init__.py,sha256=DV-Duk1ONbXL8kZevkU-Rj4MD2z2imKvd9PM_SXybwQ,552
+charm_lite/core/__init__.py,sha256=mEEL_brdoxBPGFFU2a9NkRBvkGV4rsWWpK9eU9EjPYk,27
+charm_lite/core/benchmark.cpython-314-darwin.so,sha256=8PqyN2Fg-C6RvIQMAT1Ibfw9U2YWX5o9AkqC9FIvXsI,86304
+charm_lite/core/benchmark/benchmark_util.c,sha256=a6sXY_rgB89fGIpatQvHD5fQ69fEGEeZX5xZ_Z2h0MQ,11271
+charm_lite/core/benchmark/benchmark_util.h,sha256=QfAe293WZCZJy_cIR1gWwtAJc1jnpy-i6jyqoE-mmK8,2529
+charm_lite/core/benchmark/benchmarkmodule.c,sha256=eNn1UdvcQwojuknxu6qqkD1Zg84uB8PqUo0NC64UwPg,14779
+charm_lite/core/benchmark/benchmarkmodule.h,sha256=HOfMpBmlsr9IjSlyh0-ImKKDt-ZM-Da3j0o820LIhbA,5367
+charm_lite/core/math/__init__.py,sha256=q4yW8ju44bUbBfuj27t8opMuZ3eyPBmudGYMFqFpO7k,32
+charm_lite/core/math/elliptic_curve.cpython-314-darwin.so,sha256=1y-Ma3GyJnFprLk3c-uAuEkf8cVu4tViYw2yIoFEoHY,147080
+charm_lite/core/math/elliptic_curve/ecmodule.c,sha256=FqfDFIA4G6JjFHKrWZ579y6NAdQKN1wHj-96uf4MAYM,61079
+charm_lite/core/math/elliptic_curve/ecmodule.h,sha256=o5jNvVs_P6_WM0cJ0aBIHcZ_Ovzi5yjandQlvgoN7gA,6372
+charm_lite/core/utilities/base64.c,sha256=MCyZ4JPN1VdMKB1CzOkQPKxT4oSG0UfTP8JGviG2ZDs,6888
+charm_lite/core/utilities/base64.h,sha256=WlAp5qvXDGIGFFFzvuGj87XHyjKz1YC4zM9K_Fjdv7k,333
+charm_lite/toolbox/PKEnc.py,sha256=orVbLwc2p6bqd3RBt0iN5zaDI3qRLizwLh6X7ZfK9GM,1922
+charm_lite/toolbox/__init__.py,sha256=lOJsdc4-GEhX1jsNxRZXfAmVN0fIfF8cNGUwvenKQZU,472
+charm_lite/toolbox/eccurve.py,sha256=SiNqoy91Py3rhZwvDi0cH-S97pVvSsy6U77yqaNDelQ,315
+charm_lite/toolbox/ecgroup.py,sha256=wPvuv53dSPcl8cpvDOlja2oiEZWQoNHlHAYrQA7E9TY,3995
+charm_crypto_lite-0.61.1.dist-info/METADATA,sha256=JHTRfmopX8jfaW6DTqyvDUc1M5QiXqy7S-WtHS4hhDc,4731
+charm_crypto_lite-0.61.1.dist-info/WHEEL,sha256=pBq69egh5x97PWc2-uzeinGu5GE3fGCM9h7i8BZE5wo,116
+charm_crypto_lite-0.61.1.dist-info/top_level.txt,sha256=9oHoHzQpzqTBN9XyGTp__tqA-z5abC136kNDtiU5lNw,11
+charm_crypto_lite-0.61.1.dist-info/RECORD,,

charm_crypto_lite-0.61.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: false
+Tag: cp314-cp314-macosx_10_15_universal2
+

charm_crypto_lite-0.61.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+charm_lite

charm_lite/__init__.py

@@ -0,0 +1,22 @@
+"""
+charm-crypto-lite: Lightweight elliptic curve cryptography from the Charm framework.
+
+This package provides OpenSSL-based elliptic curve operations without
+GMP or PBC dependencies.
+
+Example usage:
+    from charm_lite.toolbox.ecgroup import ECGroup
+    from charm_lite.toolbox.eccurve import secp256k1
+    
+    group = ECGroup(secp256k1)
+    g = group.random(G)
+    x = group.random(ZR)
+    h = g ** x
+"""
+
+# Preload benchmark module to ensure symbols are available
+import charm_lite.core.benchmark
+
+__version__ = "0.1.0"
+__all__ = ['__version__']
+

charm_lite/core/__init__.py

@@ -0,0 +1,2 @@
+# charm_lite.core package
+

charm_lite/core/benchmark/benchmark_util.c

@@ -0,0 +1,353 @@
+
+#if defined(__APPLE__)
+// 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);
+}
+
+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
+
+void Operations_dealloc(Operations *self)
+{
+	debug("Releasing operations object.\n");
+	Py_TYPE(self)->tp_free((PyObject *) self);
+}
+
+PyObject *Operations_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+	Operations *self = (Operations *) type->tp_alloc(type, 0);
+	if(self != NULL) {
+		/* initialize */
+		self->op_init = FALSE;
+	}
+
+	return (PyObject *) self;
+}
+
+int Operations_init(Operations *self, PyObject *args, PyObject *kwds)
+{
+	self->op_init = TRUE;
+	return 0;
+}
+
+/* for python 3.x */
+PyTypeObject OperationsType = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	"profile.Operations",             /*tp_name*/
+	sizeof(Operations),         /*tp_basicsize*/
+	0,                         /*tp_itemsize*/
+	(destructor)Operations_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*/
+	"Granular 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)Operations_init,      /* tp_init */
+	0,                         /* tp_alloc */
+	Operations_new,                 /* tp_new */
+};
+
+PyObject *InitBenchmark(PyObject *self, PyObject *args) {
+	Benchmark *benchObj = NULL;
+	GROUP_OBJECT *group = NULL;
+	if(!PyArg_ParseTuple(args, "O", &group)) {
+		PyErr_SetString(BENCH_ERROR, "InitBenchmark - invalid argument.");
+		return NULL;
+	}
+
+	VERIFY_GROUP(group);
+	if(group->dBench == NULL) {
+		benchObj = PyObject_New(Benchmark, &BenchmarkType);
+		if (benchObj == NULL) {
+			PyErr_SetString(BENCH_ERROR, "out of memory.");
+			return NULL;
+		}
+
+		/* setup granular options */
+		if(group->gBench == NULL) {
+			group->gBench = PyObject_New(Operations, &OperationsType);
+			CLEAR_ALLDBENCH(group->gBench);
+		}
+		benchObj->num_options = 0;
+		benchObj->op_add = benchObj->op_sub = benchObj->op_mult = 0;
+		benchObj->op_div = benchObj->op_exp = benchObj->op_pair = 0;
+		benchObj->cpu_time_ms = 0.0;
+		benchObj->real_time_ms = 0.0;
+		benchObj->bench_initialized = TRUE;
+		benchObj->bench_inprogress = FALSE;
+		benchObj->identifier = BenchmarkIdentifier;
+		debug("%s: bench id set: '%i'\n", __FUNCTION__, benchObj->identifier);
+		debug("Initialized benchmark object.\n");
+		// set benchmark field in group object
+		group->dBench = benchObj;
+		RAND_pseudo_bytes(group->bench_id, ID_LEN);
+		Py_RETURN_TRUE;
+	}
+	else if(group->dBench->bench_inprogress == FALSE && group->dBench->bench_initialized == TRUE) {
+		// if we have initialized the benchmark object and ended a benchmark execution:
+		// action: reset the fields
+		debug("Reset benchmark state.\n");
+		if(group->gBench != NULL) {
+			CLEAR_ALLDBENCH(group->gBench);
+		}
+		PyClearBenchmark(group->dBench);
+		group->dBench->bench_initialized = TRUE;
+		group->dBench->bench_inprogress = FALSE;
+		group->dBench->identifier = BenchmarkIdentifier;
+		Py_RETURN_TRUE;
+	}
+	else if(group->dBench->bench_inprogress == TRUE) {
+		debug("Benchmark in progress.\n");
+	}
+	debug("Benchmark already initialized.\n");
+	Py_RETURN_FALSE;
+}
+
+PyObject *StartBenchmark(PyObject *self, PyObject *args)
+{
+	PyObject *list = NULL;
+	GROUP_OBJECT *group = NULL;
+	if(!PyArg_ParseTuple(args, "OO", &group, &list)) {
+		PyErr_SetString(BENCH_ERROR, "StartBenchmark - invalid argument.");
+		return NULL;
+	}
+
+	VERIFY_GROUP(group);
+	if(group->dBench == NULL) {
+		PyErr_SetString(BENCH_ERROR, "uninitialized benchmark object.");
+		return NULL;
+	}
+	else if(PyList_Check(list) && group->dBench->bench_initialized == TRUE && group->dBench->bench_inprogress == FALSE
+			&& group->dBench->identifier == BenchmarkIdentifier)
+	{
+		debug("%s: bench id: '%i'\n", __FUNCTION__, group->dBench->identifier);
+		size_t size = PyList_Size(list);
+		PyStartBenchmark(group->dBench, list, size);
+		debug("list size => %zd\n", size);
+		debug("benchmark enabled and initialized!\n");
+		Py_RETURN_TRUE;
+	}
+	Py_RETURN_FALSE;
+}
+
+PyObject *EndBenchmark(PyObject *self, PyObject *args)
+{
+	GROUP_OBJECT *group = NULL;
+	if(!PyArg_ParseTuple(args, "O", &group)) {
+		PyErr_SetString(BENCH_ERROR, "EndBenchmark - invalid argument.");
+		return NULL;
+	}
+
+	VERIFY_GROUP(group);
+	if(group->dBench == NULL) {
+		PyErr_SetString(BENCH_ERROR, "uninitialized benchmark object.");
+		return NULL;
+	}
+	else if(group->dBench->bench_initialized == TRUE && group->dBench->bench_inprogress == TRUE && group->dBench->identifier == BenchmarkIdentifier) {
+		PyEndBenchmark(group->dBench);
+		debug("%s: bench id: '%i'\n", __FUNCTION__, group->dBench->identifier);
+		Py_RETURN_TRUE;
+	}
+	Py_RETURN_FALSE;
+}
+
+PyObject *GetAllBenchmarks(PyObject *self, PyObject *args)
+{
+	GROUP_OBJECT *group = NULL;
+	if(!PyArg_ParseTuple(args, "O", &group)) {
+		PyErr_SetString(BENCH_ERROR, "GetGeneralBenchmarks - invalid argument.");
+		return NULL;
+	}
+	VERIFY_GROUP(group);
+	if(group->dBench == NULL) {
+		PyErr_SetString(BENCH_ERROR, "uninitialized benchmark object.");
+		return NULL;
+	}
+	else if(group->dBench->bench_inprogress == FALSE && group->dBench->identifier == BenchmarkIdentifier) {
+		debug("%s: bench id: '%i'\n", __FUNCTION__, group->dBench->identifier);
+		// return GetResultsWithPair(group->dBench);
+		return GET_RESULTS_FUNC(group->dBench);
+	}
+	else if(group->dBench->bench_inprogress == TRUE) {
+		printf("Benchmark in progress.\n");
+	}
+	else {
+		debug("Invalid benchmark identifier.\n");
+	}
+	Py_RETURN_FALSE;
+}
+
+PyObject *GetBenchmark(PyObject *self, PyObject *args) {
+	char *opt = NULL;
+	GROUP_OBJECT *group = NULL;
+	if(!PyArg_ParseTuple(args, "Os", &group, &opt))
+	{
+		PyErr_SetString(BENCH_ERROR, "GetBenchmark - invalid argument.");
+		return NULL;
+	}
+
+	VERIFY_GROUP(group);
+	if(group->dBench == NULL) {
+		PyErr_SetString(BENCH_ERROR, "uninitialized benchmark object.");
+		return NULL;
+	}
+	else if(group->dBench->bench_inprogress == FALSE && group->dBench->identifier == BenchmarkIdentifier) {
+		return Retrieve_result(group->dBench, opt);
+	}
+	else if(group->dBench->bench_inprogress == TRUE) {
+		printf("Benchmark in progress.\n");
+	}
+	Py_RETURN_FALSE;
+}
+
+static PyObject *GranularBenchmark(PyObject *self, PyObject *args)
+{
+	PyObject *dict = NULL;
+	GROUP_OBJECT *group = NULL;
+	if(!PyArg_ParseTuple(args, "O", &group)) {
+		PyErr_SetString(BENCH_ERROR, "GetGranularBenchmark - invalid argument.");
+		return NULL;
+	}
+
+	if(group->gBench == NULL || group->dBench == NULL) {
+		PyErr_SetString(BENCH_ERROR, "uninitialized benchmark object.");
+		return NULL;
+	}
+	else if(group->dBench->bench_inprogress == FALSE && BenchmarkIdentifier == group->dBench->identifier) {
+		if(group->dBench->granular_option == FALSE) {
+			PyErr_SetString(BENCH_ERROR, "granular option was not set.");
+			return NULL;
+		}
+		dict = PyDict_New();
+		if(dict == NULL) return NULL;
+		if(group->dBench->op_mult > 0) {
+			PyObject *MulList = PyCreateList(group->gBench, MULTIPLICATION);
+			//PrintPyRef('MulList Before =>', MulList);
+			PyDict_SetItemString(dict, "Mul", MulList);
+			Py_DECREF(MulList);
+		}
+
+		if(group->dBench->op_div > 0) {
+			PyObject *DivList = PyCreateList(group->gBench, DIVISION);
+			PyDict_SetItemString(dict, "Div", DivList);
+			Py_DECREF(DivList);
+		}
+
+		if(group->dBench->op_add > 0) {
+			PyObject *AddList = PyCreateList(group->gBench, ADDITION);
+			PyDict_SetItemString(dict, "Add", AddList);
+			Py_DECREF(AddList);
+		}
+
+		if(group->dBench->op_sub > 0) {
+			PyObject *SubList = PyCreateList(group->gBench, SUBTRACTION);
+			PyDict_SetItemString(dict, "Sub", SubList);
+			Py_DECREF(SubList);
+		}
+
+		if(group->dBench->op_exp > 0) {
+			PyObject *ExpList = PyCreateList(group->gBench, EXPONENTIATION);
+			PyDict_SetItemString(dict, "Exp", ExpList);
+			Py_DECREF(ExpList);
+		}
+		//PrintPyRef('MulList After =>', MulList);
+	}
+	else if(group->dBench->bench_inprogress == TRUE) {
+		printf("Benchmark in progress.\n");
+	}
+	else {
+		PyErr_SetString(BENCH_ERROR, "uninitialized benchmark object.");
+	}
+
+	return dict;
+}
+

charm_lite/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