Merge branch 'dev' into main

Author: Ivan Dlugos

Makefile

@@ -4,6 +4,10 @@ export PATH := ${VIRTUAL_ENV}/bin:${PATH}
 
 ################################
 
+build: ${VENV} clean
+	python3 setup.py bdist_wheel
+	ls -lh dist
+
 ${VENV}: ${VENV}/bin/activate
 
 ${VENV}/bin/activate: requirements.txt
@@ -20,13 +24,12 @@ init: ${VENV}
 test: ${VENV}
 	python3 -m pytest -s
 
-build: ${VENV} clean
-	python3 setup.py bdist_wheel
-	ls -lh dist
+benchmark: ${VENV}
+	python3 -m benchmark
 
 clean:
 	rm -rf build/
 	rm -rf dist/
 	rm -rf *.egg-info
 
-.PHONY: init test build
+.PHONY: init test build benchmark

README.md

@@ -125,6 +125,7 @@ cp lib/*objectbox* [/path/to/your/git/objectbox/checkout]/objectbox/lib/$(uname
 ```
 
 You can run `make test` to make sure everything works as expected.
+You can also try `make benchmark` to measure the CRUD performance on your machine.
 
 License
 -------

benchmark.py

@@ -0,0 +1,119 @@
+import objectbox
+import time
+from tests.model import TestEntity
+from tests.common import remove_test_dir, load_empty_test_objectbox
+
+
+class ObjectBoxPerf:
+    """
+    Performance executable
+    """
+
+    def __init__(self):
+        self.ob = load_empty_test_objectbox()
+        self.box = objectbox.Box(self.ob, TestEntity)
+
+    def remove_all(self):
+        self.box.remove_all()
+
+    def put_many(self, items):
+        self.box.put(items)
+
+    def read_all(self):
+        return self.box.get_all()
+
+
+class Timer:
+    """
+    Context manager to time a block of code.
+    Appends the resulting runtime in milliseconds to a list of floats.
+    """
+
+    def __init__(self, out_list: [float]):
+        self.start = time.time_ns()
+        self.list = out_list
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.list.append((time.time_ns() - self.start) / 1000 / 1000)
+
+
+class PerfExecutor:
+    """
+    Performance executable
+    """
+
+    def __init__(self, executable):
+        self.perf = executable
+
+    def run(self, count=1000, runs=10):
+        inserts = self.__prepare_data(count)
+
+        # function => vector of runtimes in milliseconds
+        from collections import defaultdict
+        times = defaultdict(list)
+
+        progress_text = "Measuring performance"
+        for i in range(runs):
+            self.__progress_bar(progress_text, i, runs)
+
+            with Timer(times["insert-many"]):
+                self.perf.put_many(inserts)
+
+            with Timer(times["read-all"]):
+                items = self.perf.read_all()
+
+            with Timer(times["update-many"]):
+                self.perf.put_many(items)
+
+            with Timer(times["remove-all"]):
+                self.perf.remove_all()
+
+        self.__progress_bar(progress_text, runs, runs)
+
+        # print the results
+        print()
+        print('=' * 80)
+        print("runs\t%d\t\tcount\t%d\t\tunit\tms" % (runs, count))
+        print("Function\tMedian\tMean\tStdDev")
+        import statistics
+        for key in times.keys():
+            print("%s\t%d\t%d\t%d" % (
+                key,
+                statistics.median(times[key]),
+                statistics.mean(times[key]),
+                statistics.stdev(times[key])
+            ))
+
+    @staticmethod
+    def __prepare_data(count: int) -> [TestEntity]:
+        result = []
+        for i in range(count):
+            object = TestEntity()
+            object.str = "Entity no. %d" % i
+            object.float = i * 1.1
+            object.int = i
+            result.append(object)
+        return result
+
+    @staticmethod
+    def __progress_bar(text, value, endvalue, bar_length=20):
+        import sys
+        percent = float(value) / endvalue
+        arrow = '-' * int(round(percent * bar_length) - 1) + '>'
+        spaces = ' ' * (bar_length - len(arrow))
+
+        sys.stdout.write("\r{0}: [{1}] {2}%".format(text, arrow + spaces, int(round(percent * 100))))
+        sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    remove_test_dir()
+
+    obPerf = ObjectBoxPerf()
+    executor = PerfExecutor(obPerf)
+    executor.run(count=10000, runs=20)
+
+    remove_test_dir()

objectbox/box.py

@@ -105,31 +105,33 @@ def _put_many(self, objects) -> None:
             self._entity.set_object_id(objects[k], ids[k])
 
     def get(self, id: int):
-        c_data = ctypes.c_void_p()
-        c_size = ctypes.c_size_t()
-        obx_box_get(self._c_box, id, ctypes.byref(c_data), ctypes.byref(c_size))
+        with self._ob.read_tx():
+            c_data = ctypes.c_void_p()
+            c_size = ctypes.c_size_t()
+            obx_box_get(self._c_box, id, ctypes.byref(c_data), ctypes.byref(c_size))
 
-        data = c_voidp_as_bytes(c_data, c_size.value)
-        return self._entity.unmarshal(data)
+            data = c_voidp_as_bytes(c_data, c_size.value)
+            return self._entity.unmarshal(data)
 
     def get_all(self) -> list:
-        # OBX_bytes_array*
-        c_bytes_array_p = obx_box_get_all(self._c_box)
-
-        try:
-            # OBX_bytes_array
-            c_bytes_array = c_bytes_array_p.contents
-
-            result = list()
-            for i in range(c_bytes_array.count):
-                # OBX_bytes
-                c_bytes = c_bytes_array.data[i]
-                data = c_voidp_as_bytes(c_bytes.data, c_bytes.size)
-                result.append(self._entity.unmarshal(data))
-
-            return result
-        finally:
-            obx_bytes_array_free(c_bytes_array_p)
+        with self._ob.read_tx():
+            # OBX_bytes_array*
+            c_bytes_array_p = obx_box_get_all(self._c_box)
+
+            try:
+                # OBX_bytes_array
+                c_bytes_array = c_bytes_array_p.contents
+
+                result = list()
+                for i in range(c_bytes_array.count):
+                    # OBX_bytes
+                    c_bytes = c_bytes_array.data[i]
+                    data = c_voidp_as_bytes(c_bytes.data, c_bytes.size)
+                    result.append(self._entity.unmarshal(data))
+
+                return result
+            finally:
+                obx_bytes_array_free(c_bytes_array_p)
 
     def remove(self, id_or_object):
         if isinstance(id_or_object, self._entity.cls):

objectbox/builder.py

@@ -33,9 +33,16 @@ def model(self, model: Model) -> 'Builder':
         return self
 
     def build(self) -> 'ObjectBox':
-        c_options = OBX_store_options()
-        if len(self._directory) > 0:
-            c_options.directory = c_str(self._directory)
+        c_options = obx_opt()
 
-        c_store = obx_store_open(self._model._c_model, c_options.p())
+        try:
+            if len(self._directory) > 0:
+                obx_opt_directory(c_options, c_str(self._directory))
+
+            obx_opt_model(c_options, self._model._c_model)
+        except CoreException:
+            obx_opt_free(c_options)
+            raise
+
+        c_store = obx_store_open(c_options)
         return ObjectBox(c_store)

objectbox/c.py

@@ -18,8 +18,8 @@
 import platform
 from objectbox.version import Version
 
-
 # This file contains C-API bindings based on the objectbox.h, linking to the 'objectbox' shared library
+required_version = "0.5.104"
 
 
 def shlib_name(library: str) -> str:
@@ -48,7 +48,6 @@ def shlib_name(library: str) -> str:
 # C-api (core library) version
 version_core = Version(__major.value, __minor.value, __patch.value)
 
-required_version = "0.5.103"
 assert str(version_core) == required_version, \
     "Incorrect ObjectBox version loaded: %s instead of expected %s " % (str(version_core), required_version)
 
@@ -82,15 +81,7 @@ class OBX_store(ctypes.Structure):
 
 
 class OBX_store_options(ctypes.Structure):
-    _fields_ = [
-        ('directory', ctypes.c_char_p),
-        ('maxDbSizeInKByte', ctypes.c_uint64),
-        ('fileMode', ctypes.c_uint),
-        ('maxReaders', ctypes.c_uint)
-    ]
-
-    def p(self) -> 'ctypes.POINTER(OBX_store_options)':
-        return ctypes.byref(self)
+    pass
 
 
 OBX_store_options_p = ctypes.POINTER(OBX_store_options)
@@ -282,12 +273,48 @@ def c_voidp_as_bytes(voidp, size):
 obx_model_entity_last_property_id = fn('obx_model_entity_last_property_id', obx_err,
                                        [OBX_model_p, obx_schema_id, obx_uid])
 
-# OBX_store* (OBX_model* model, const OBX_store_options* options);
-obx_store_open = fn('obx_store_open', OBX_store_p, [OBX_model_p, OBX_store_options_p])
+# OBX_store_options* ();
+obx_opt = fn('obx_opt', OBX_store_options_p, [])
+
+# obx_err (OBX_store_options* opt, const char* dir);
+obx_opt_directory = fn('obx_opt_directory', obx_err, [OBX_store_options_p, ctypes.c_char_p])
+
+# void (OBX_store_options* opt, size_t size_in_kb);
+obx_opt_max_db_size_in_kb = fn('obx_opt_max_db_size_in_kb', None, [OBX_store_options_p, ctypes.c_size_t])
+
+# void (OBX_store_options* opt, int file_mode);
+obx_opt_file_mode = fn('obx_opt_file_mode', None, [OBX_store_options_p, ctypes.c_int])
+
+# void (OBX_store_options* opt, int max_readers);
+obx_opt_max_readers = fn('obx_opt_max_readers', None, [OBX_store_options_p, ctypes.c_int])
+
+# obx_err (OBX_store_options* opt, OBX_model* model);
+obx_opt_model = fn('obx_opt_model', obx_err, [OBX_store_options_p, OBX_model_p])
+
+# void (OBX_store_options* opt);
+obx_opt_free = fn('obx_opt_free', None, [OBX_store_options_p])
+
+# OBX_store* (const OBX_store_options* options);
+obx_store_open = fn('obx_store_open', OBX_store_p, [OBX_store_options_p])
 
 # obx_err (OBX_store* store);
 obx_store_close = fn('obx_store_close', obx_err, [OBX_store_p])
 
+# OBX_txn* (OBX_store* store);
+obx_txn_begin = fn('obx_txn_begin', OBX_txn_p, [OBX_store_p])
+
+# OBX_txn* (OBX_store* store);
+obx_txn_begin_read = fn('obx_txn_begin_read', OBX_txn_p, [OBX_store_p])
+
+# obx_err (OBX_txn* txn)
+obx_txn_close = fn('obx_txn_close', obx_err, [OBX_txn_p])
+
+# obx_err (OBX_txn* txn);
+obx_txn_abort = fn('obx_txn_abort', obx_err, [OBX_txn_p])
+
+# obx_err (OBX_txn* txn);
+obx_txn_commit = fn('obx_txn_commit', obx_err, [OBX_txn_p])
+
 # OBX_box* (OBX_store* store, obx_schema_id entity_id);
 obx_box = fn('obx_box', OBX_box_p, [OBX_store_p, obx_schema_id])
 

objectbox/objectbox.py

@@ -14,11 +14,16 @@
 
 
 from objectbox.c import *
-
+import objectbox.transaction
 
 class ObjectBox:
     def __init__(self, c_store: OBX_store_p):
         self._c_store = c_store
 
     def __del__(self):
         obx_store_close(self._c_store)
+
+    def read_tx(self):
+        return objectbox.transaction.read(self)
+
+

objectbox/transaction.py

@@ -0,0 +1,42 @@
+# Copyright 2019 ObjectBox Ltd. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from objectbox.c import *
+from contextlib import contextmanager
+
+
+@contextmanager
+def read(ob: 'ObjectBox'):
+    tx = obx_txn_begin_read(ob._c_store)
+    try:
+        yield
+    finally:
+        obx_txn_close(tx)
+
+
+@contextmanager
+def write(ob: 'ObjectBox'):
+    tx = obx_txn_begin(ob._c_store)
+    successful = False
+    try:
+        yield
+        successful = True
+    finally:
+        # this is better than bare `except:` because it doesn't catch stuff like KeyboardInterrupt
+        if successful:
+            obx_txn_commit(tx)
+        else:
+            obx_txn_abort(tx)
+
+        obx_txn_close(tx)