T2.3 decission support tool

doc/decission-support.md

@@ -0,0 +1,80 @@
+# Decission Support
+
+JULEA can trace backend accesses granularly,
+allowing further application analysis and object access pattern comparison across applications.
+
+Furthermore, this can be used to provide a first rough estimate of which backend combination
+is preferable for the application setup.
+
+## Access Record
+
+To create an `access-record`, which is simply a CSV file, execute `julea-server` with `JULEA_TRACE=access` and store the output (`stderr`) in a file.
+Then run your applications and stop the server when finished.
+
+```sh
+JULEA_TRACE=access julea-server 2> access-record.csv
+```
+
+Tracing is per default only in debug builds enabled. To build a realease build
+with trace funtcionality you need to set `julea_trace` to true
+
+```sh
+meson configure -Djulea_trace=ture --buildtype=release bld
+```
+
+## Replay
+
+An `access-record` can be replayed with `julea-access-replay`, which takes only the `access-record` as input.
+Replays will execute the same backend operations in the same order as listed in `access-record`.
+This allows comparison of backend performance without running the complete application over and over.
+
+Note that the backends must be in the same state, preferably empty, before every replay.
+Also note that the performance of a replay can vary compared to the original run, depending on the device's load.
+
+```sh
+JULEA_TRACE=access julea-access-replay access-record.csv 2> replay-record.csv
+```
+
+## Setup Testing
+
+The script `./scripts/decission-support.py` can help to select a good backend combination for a given workload. 
+It will test different backend configurations and creates a directory `evaluation` with the results.
+
+Configurations that should be tested must be defined in a `config.json` file.
+The expected structure is as follows (an example config can also be found at `example/decission-support-config.json`):
+
+```json
+{
+  "object": [{"backend": "posix", "path": "/tmp/<tmp>/posix"}],
+  "kv": [{"backend": "sqlite", "path": "/tmp/<tmp>/sqlite"}, {"backend": "sqlite", "path": "/mnt/slow/<tmp>/sqlite"}],
+  "db": [{"backend": "sqlite", "path": ":memory:"}],
+}
+```
+
+Note that `<tmp>` inside of paths will be replaced with a temporary directory removed after execution.
+
+The script will replay each access type with all corresponding backends (e.g., all KV accesses are tested on all specified KV configurations). 
+This will produce `summary.csv`.
+
+The summary can be evaluated using `./scripts/decision-support.R`.
+An example workflow is shown below.
+
+```sh
+JULEA_TRACE=access julea-server 2> access-record.csv
+# run application
+# stop julea-server (Ctrl+C)
+./scripts/decission-support.py config.json acces-record.csv summary.csv
+Rscript ./scripts/decission-support.R summary.csv html > summary.html
+# or only ci output
+Rscript ./scripts/decission-support.R summary.csv
+```
+
+Important remarks:
+* The script assumes an empty backend state on start.
+* A MySQL/MariaDB instance must be provided if specified as backend.
+  *  User: `julea_user` 
+  *  PW: `julea_pw` 
+  *  Access to the existing (and empty) database `julea_db`
+  * These DB servers must be reset by hand for now. Resets on server startup will be available in the future and the resets will be automated by the script.
+
+

example/decission-support-config.json

@@ -0,0 +1,56 @@
+{
+  "object": [
+    {
+      "backend": "posix",
+      "path": "/tmp/<tmp>/"
+    },
+    {
+      "backend": "posix",
+      "path": "/mnt/stick/<tmp>/"
+    },
+    {
+      "backend": "gio",
+      "path": "/tmp/<tmp>/"
+    }
+  ],
+  "db": [
+    {
+      "backend": "sqlite",
+      "path": "/tmp/<tmp>/sqlite"
+    },
+    {
+      "backend": "sqlite",
+      "path": ":memory:"
+    },
+    {
+      "backend": "sqlite",
+      "path": "/mnt/stick/<tmp>/sqlite"
+    },
+    {
+      "backend": "mysql",
+      "path": "127.0.0.1:julea_db:julea_user:julea_pw"
+    }
+  ],
+  "kv": [
+    {
+      "backend": "leveldb",
+      "path": "/tmp/<tmp>/"
+    },
+    {
+      "backend": "lmdb",
+      "path": "/tmp/<tmp>/"
+    },
+    {
+      "backend": "sqlite",
+      "path": "/tmp/<tmp>/sqlite"
+    },
+    {
+      "backend": "sqlite",
+      "path": ":memory:"
+    },
+    {
+      "backend": "rocksdb",
+      "path": "/tmp/<tmp>/"
+    }
+  ]
+}

include/core/jconfiguration.h

@@ -115,6 +115,7 @@ guint32 j_configuration_get_max_connections(JConfiguration*);
 guint64 j_configuration_get_stripe_size(JConfiguration*);
 
 gchar const* j_configuration_get_checksum(JConfiguration*);
+guint32 j_configuration_get_uid(JConfiguration*);
 
 G_END_DECLS
 

include/core/jsemantics.h

@@ -264,7 +264,35 @@ void j_semantics_set(JSemantics* semantics, JSemanticsType key, gint value);
  *
  * \return The aspect's value.
  **/
-gint j_semantics_get(JSemantics* semantics, JSemanticsType key);
+gint j_semantics_get(const JSemantics* semantics, JSemanticsType key);
+
+/**
+ * Encodes semantics in a guint32
+ *
+ * \code
+ * JSemantics* semantics;
+ * ...
+ * guint32 serial_semantics = j_semantics_serialize(semantics);
+ * JSemantics* simular_semantics = j_semantics_deserialize(serial_semantics);
+ * \encode
+ *
+ * \param semnatics The Semantics
+ *
+ * \return serialized semantics as LE encoded guint32
+ * \retval 0 if no semantics are given eg (semantics == NULL)
+ **/
+guint32 j_semantics_serialize(const JSemantics* semantics);
+
+/**
+ * Decode serialized semantics, and create new Semantics
+ *
+ * For a example see j_semantics_serialize()
+ *
+ * \param serial_semantics serialized semantics, created with j_semantics_serialize()
+ *
+ * \return new created JSemantics
+ **/
+JSemantics* j_semantics_deserialize(guint32 serial_semantics);
 
 /**
  * @}

include/core/jtrace.h

@@ -106,7 +106,7 @@ void j_trace_leave(JTrace* trace);
 
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(JTrace, j_trace_leave)
 
-#ifdef JULEA_DEBUG
+#ifdef JULEA_TRACE
 #ifdef __COUNTER__
 #define J_TRACE(name, ...) g_autoptr(JTrace) G_PASTE(j_trace, __COUNTER__) G_GNUC_UNUSED = j_trace_enter(name, __VA_ARGS__)
 #define J_TRACE_FUNCTION(...) g_autoptr(JTrace) G_PASTE(j_trace_function, __COUNTER__) G_GNUC_UNUSED = j_trace_enter(G_STRFUNC, __VA_ARGS__)