Store CPU list in a metadata.json file

This allows early access to the CPU list in order to emit the PRV header
before consuming events from the streams.

Makefile

@@ -17,16 +17,16 @@ all: $(BIN)
 libovni.a: ovni.o
 	ar -crs $@ $^
 
-dump: ovni.o dump.o
+dump: ovni.o dump.o parson.o
 
-test_speed: test_speed.c ovni.o
+test_speed: test_speed.c ovni.o parson.o
 
-emu: emu.o emu_ovni.o emu_nosv.o ovni.o prv.o
+emu: emu.o emu_ovni.o emu_nosv.o ovni.o prv.o parson.o
 
-libovni.so: ovni.o
+libovni.so: ovni.o parson.o
 	$(LINK.c) -shared $^ -o $@
 
-ovni2prv: ovni2prv.c ovni.o
+ovni2prv: ovni2prv.c ovni.o parson.o
 
 ovnisync: ovnisync.c
 	mpicc -lm $^ -o $@

emu.c

@@ -190,6 +190,7 @@ emulate(struct ovni_emu *emu)
 		ovni_load_next_event(stream);
 	}
 
+
 	emu->lastclock = 0;
 
 	/* Then process all events */
@@ -237,6 +238,112 @@ emu_get_thread(struct ovni_emu *emu, int tid)
 	return thread;
 }
 
+static void
+add_new_cpu(struct ovni_emu *emu, struct ovni_loom *loom, int i, int phyid)
+{
+	/* The logical id must match our index */
+	assert(i == loom->ncpus);
+
+	assert(loom->cpu[i].state == CPU_ST_UNKNOWN);
+
+	loom->cpu[loom->ncpus].state = CPU_ST_READY;
+	loom->cpu[loom->ncpus].i = i;
+	loom->cpu[loom->ncpus].phyid = phyid;
+	loom->cpu[loom->ncpus].gindex = emu->total_cpus++;
+
+	dbg("new cpu %d at phyid=%d\n", i, phyid);
+
+	loom->ncpus++;
+}
+
+void
+proc_load_cpus(struct ovni_emu *emu, struct ovni_loom *loom, struct ovni_eproc *proc)
+{
+	JSON_Array *cpuarray;
+	JSON_Object *cpu;
+	JSON_Object *meta;
+	int i, index, phyid;
+
+	meta = json_value_get_object(proc->meta);
+
+	assert(meta);
+
+	cpuarray = json_object_get_array(meta, "cpus");
+
+	/* This process doesn't have the cpu list */
+	if(cpuarray == NULL)
+		return;
+
+	assert(loom->ncpus == 0);
+
+	for(i = 0; i < json_array_get_count(cpuarray); i++)
+	{
+		cpu = json_array_get_object(cpuarray, i);
+
+		index = (int) json_object_get_number(cpu, "index");
+		phyid = (int) json_object_get_number(cpu, "phyid");
+
+		add_new_cpu(emu, loom, index, phyid);
+	}
+}
+
+/* Obtain CPUs in the metadata files and other data */
+static int
+load_metadata(struct ovni_emu *emu)
+{
+	int i, j, k, s;
+	struct ovni_loom *loom;
+	struct ovni_eproc *proc;
+	struct ovni_ethread *thread;
+	struct ovni_stream *stream;
+	struct ovni_trace *trace;
+
+	trace = &emu->trace;
+
+	for(i=0; i<trace->nlooms; i++)
+	{
+		loom = &trace->loom[i];
+		for(j=0; j<loom->nprocs; j++)
+		{
+			proc = &loom->proc[j];
+
+			proc_load_cpus(emu, loom, proc);
+		}
+
+		/* One of the process must have the list of CPUs */
+		/* FIXME: The CPU list should be at the loom dir */
+		assert(loom->ncpus > 0);
+	}
+
+	return 0;
+}
+
+static int
+destroy_metadata(struct ovni_emu *emu)
+{
+	int i, j, k, s;
+	struct ovni_loom *loom;
+	struct ovni_eproc *proc;
+	struct ovni_ethread *thread;
+	struct ovni_stream *stream;
+	struct ovni_trace *trace;
+
+	trace = &emu->trace;
+
+	for(i=0; i<trace->nlooms; i++)
+	{
+		loom = &trace->loom[i];
+		for(j=0; j<loom->nprocs; j++)
+		{
+			proc = &loom->proc[j];
+
+			assert(proc->meta);
+			json_value_free(proc->meta);
+		}
+	}
+
+	return 0;
+}
 
 
 int
@@ -256,16 +363,23 @@ main(int argc, char *argv[])
 	memset(&emu, 0, sizeof(emu));
 
 	if(ovni_load_trace(&emu.trace, tracedir))
-		return 1;
+		abort();
 
 	if(ovni_load_streams(&emu.trace))
-		return 1;
+		abort();
 
-	printf("#Paraver (19/01/38 at 03:14):00000000000000000000_ns:0:1:1(%d:1)\n", 10);
+	if(load_metadata(&emu) != 0)
+		abort();
+
+
+	printf("#Paraver (19/01/38 at 03:14):00000000000000000000_ns:0:1:1(%d:1)\n", emu.total_cpus);
 
 	emulate(&emu);
 
+	destroy_metadata(&emu);
+
 	ovni_free_streams(&emu.trace);
 
+
 	return 0;
 }

emu.h

@@ -3,6 +3,7 @@
 
 #include "ovni.h"
 #include "uthash.h"
+#include "parson.h"
 #include <stdio.h>
 
 /* Debug macros */
@@ -91,6 +92,8 @@ struct ovni_eproc {
 	size_t nthreads;
 	struct ovni_ethread thread[OVNI_MAX_THR];
 
+	JSON_Value *meta;
+
 	/* ------ Subsystem specific data --------*/
 	/* TODO: Use dynamic allocation */
 
@@ -189,7 +192,7 @@ struct ovni_emu {
 	/* Total counters */
 	int total_thread;
 	int total_proc;
-	int total_cpu;
+	int total_cpus;
 };
 
 /* Emulator function declaration */

emu_ovni.c

@@ -243,74 +243,6 @@ ev_affinity(struct ovni_emu *emu)
 	}
 }
 
-static void
-ev_cpu_count(struct ovni_emu *emu)
-{
-	int i, max_ncpus, max_phyid;
-	struct ovni_loom *loom;
-
-	loom = emu->cur_loom;
-	max_ncpus = emu->cur_ev->payload.i32[0];
-	max_phyid = emu->cur_ev->payload.i32[1];
-
-	assert(max_ncpus < OVNI_MAX_CPU);
-	assert(max_phyid < OVNI_MAX_CPU);
-
-	for(i=0; i<OVNI_MAX_CPU; i++)
-	{
-		loom->cpu[i].state = CPU_ST_UNKNOWN;
-		loom->cpu[i].i = -1;
-		loom->cpu[i].phyid = -1;
-		loom->cpu[i].gindex = -1;
-	}
-
-	loom->ncpus = 0;
-	loom->max_ncpus = max_ncpus;
-	loom->max_phyid = max_phyid;
-}
-
-static void
-ev_cpu_id(struct ovni_emu *emu)
-{
-	int i, phyid;
-	struct ovni_loom *loom;
-
-	loom = emu->cur_loom;
-	i = emu->cur_ev->payload.i32[0];
-	phyid = emu->cur_ev->payload.i32[1];
-
-	/* The logical id must match our index */
-	assert(i == loom->ncpus);
-
-	assert(0 <= phyid && phyid <= loom->max_phyid);
-
-	assert(loom->cpu[i].state == CPU_ST_UNKNOWN);
-
-	loom->cpu[loom->ncpus].state = CPU_ST_READY;
-	loom->cpu[loom->ncpus].i = i;
-	loom->cpu[loom->ncpus].phyid = phyid;
-	loom->cpu[loom->ncpus].gindex = emu->total_cpu++;
-
-	dbg("new cpu %d at phyid=%d\n", i, phyid);
-
-	loom->ncpus++;
-}
-
-
-static void
-ev_cpu(struct ovni_emu *emu)
-{
-	switch(emu->cur_ev->header.value)
-	{
-		case 'n': ev_cpu_count(emu); break;
-		case 'i': ev_cpu_id(emu); break;
-		default:
-			dbg("unknown cpu event value %c\n",
-					emu->cur_ev->header.value);
-			break;
-	}
-}
-
 void
 hook_pre_ovni(struct ovni_emu *emu)
 {
@@ -320,7 +252,6 @@ hook_pre_ovni(struct ovni_emu *emu)
 	{
 		case 'H': ev_thread(emu); break;
 		case 'A': ev_affinity(emu); break;
-		case 'C': ev_cpu(emu); break;
 		case 'B': dbg("burst %c\n", emu->cur_ev->header.value); break;
 		default:
 			dbg("unknown ovni event class %c\n",
@@ -410,7 +341,6 @@ hook_emit_ovni(struct ovni_emu *emu)
 			emit_thread_state(emu);
 			/* falltrough */
 		case 'A':
-		case 'C':
 			emit_thread_count(emu);
 			//emit_current_pid(emu);
 			break;

ovni.c

@@ -19,6 +19,7 @@
 
 #include "ovni.h"
 #include "ovni_trace.h"
+#include "parson.h"
 
 #define ENABLE_DEBUG
 
@@ -93,8 +94,113 @@ create_trace_stream()
 	return 0;
 }
 
+static int
+proc_metadata_init(struct ovni_rproc *proc)
+{
+	JSON_Value *meta;
+
+	proc->meta = json_value_init_object();
+
+	if(proc->meta == NULL)
+	{
+		err("failed to create json object\n");
+		abort();
+	}
+
+	return 0;
+}
+
+static int
+proc_metadata_store(struct ovni_rproc *proc)
+{
+	char path[PATH_MAX];
+       
+	snprintf(path, PATH_MAX, "%s/metadata.json", proc->dir);
+
+	assert(proc->meta != NULL);
+
+	puts(json_serialize_to_string_pretty(proc->meta));
+
+	if(json_serialize_to_file_pretty(proc->meta, path) != JSONSuccess)
+	{
+		err("failed to write proc metadata\n");
+		abort();
+	}
+
+	return 0;
+}
+
+void
+ovni_add_cpu(int index, int phyid)
+{
+	JSON_Array *cpuarray;
+	JSON_Object *cpu;
+	JSON_Object *meta;
+	JSON_Value *valcpu, *valcpuarray;
+	int append = 0;
+
+	assert(rproc.ready == 1);
+	assert(rproc.meta != NULL);
+
+	meta = json_value_get_object(rproc.meta);
+
+	assert(meta);
+
+	/* Find the CPU array and create it if needed  */
+	cpuarray = json_object_dotget_array(meta, "cpus");
+
+	if(cpuarray == NULL)
+	{
+		valcpuarray = json_value_init_array();
+		assert(valcpuarray);
+
+		cpuarray = json_array(valcpuarray);
+		assert(cpuarray);
+		append = 1;
+	}
+
+	valcpuarray = json_array_get_wrapping_value(cpuarray);
+	assert(valcpuarray);
+
+	valcpu = json_value_init_object();
+	assert(valcpu);
+
+	cpu = json_object(valcpu);
+	assert(cpu);
+
+	if(json_object_set_number(cpu, "index", index) != 0)
+		abort();
+
+	if(json_object_set_number(cpu, "phyid", phyid) != 0)
+		abort();
+
+	if(json_array_append_value(cpuarray, valcpu) != 0)
+		abort();
+
+	if(append && json_object_set_value(meta, "cpus", valcpuarray) != 0)
+		abort();
+
+	//puts(json_serialize_to_string_pretty(rproc.meta));
+}
+
+static void
+proc_set_app(int appid)
+{
+	JSON_Object *meta;
+
+	assert(rproc.ready == 1);
+	assert(rproc.meta != NULL);
+
+	meta = json_value_get_object(rproc.meta);
+
+	assert(meta);
+
+	if(json_object_set_number(meta, "app_id", appid) != 0)
+		abort();
+}
+
 int
-ovni_proc_init(char *loom, int proc)
+ovni_proc_init(int app, char *loom, int proc)
 {
 	int i;
 
@@ -105,6 +211,7 @@ ovni_proc_init(char *loom, int proc)
 	/* FIXME: strcpy is insecure */
 	strcpy(rproc.loom, loom);
 	rproc.proc = proc;
+	rproc.app = app;
 
 	/* By default we use the monotonic clock */
 	rproc.clockid = CLOCK_MONOTONIC;
@@ -112,8 +219,22 @@ ovni_proc_init(char *loom, int proc)
 	if(create_trace_dirs(OVNI_TRACEDIR, loom, proc))
 		abort();
 
+	if(proc_metadata_init(&rproc) != 0)
+		abort();
+
 	rproc.ready = 1;
 
+	proc_set_app(app);
+
+	return 0;
+}
+
+int
+ovni_proc_fini()
+{
+	if(proc_metadata_store(&rproc) != 0)
+		abort();
+
 	return 0;
 }
 
@@ -511,6 +632,11 @@ load_proc(struct ovni_eproc *proc, int index, int pid, char *procdir)
 	proc->index = index;
 	proc->gindex = total_procs++;
 
+	sprintf(path, "%s/%s", procdir, "metadata.json");
+	proc->meta = json_parse_file_with_comments(path);
+
+	assert(proc->meta);
+
 	if((dir = opendir(procdir)) == NULL)
 	{
 		fprintf(stderr, "opendir %s failed: %s\n",
@@ -545,6 +671,8 @@ load_proc(struct ovni_eproc *proc, int index, int pid, char *procdir)
 
 	closedir(dir);
 
+
+
 	return 0;
 }
 

ovni.h

@@ -8,6 +8,8 @@
 #include <linux/limits.h>
 #include <limits.h>
 
+#include "parson.h"
+
 #define OVNI_MAX_CPU 256
 #define OVNI_MAX_PROC 32
 #define OVNI_MAX_THR 32
@@ -93,6 +95,7 @@ struct ovni_rproc {
 	/* Path of the process tracedir */
 	char dir[PATH_MAX];
 
+	int app;
 	int proc;
 	char loom[HOST_NAME_MAX];
 	int ncpus;
@@ -100,9 +103,13 @@ struct ovni_rproc {
 	char procdir[PATH_MAX];
 
 	int ready;
+
+	JSON_Value *meta;
 };
 
-int ovni_proc_init(char *loom, int proc);
+int ovni_proc_init(int app, char *loom, int proc);
+
+int ovni_proc_fini();
 
 int ovni_thread_init(pid_t tid);
 
@@ -120,6 +127,8 @@ int ovni_ev_size(struct ovni_ev *ev);
 
 int ovni_payload_size(struct ovni_ev *ev);
 
+void ovni_add_cpu(int index, int phyid);
+
 /* Set the current clock in the event and queue it */
 void ovni_ev(struct ovni_ev *ev);
 void ovni_ev_jumbo(struct ovni_ev *ev, uint8_t *buf, uint32_t bufsize);

parson.h

@@ -0,0 +1,250 @@
+/*
+ SPDX-License-Identifier: MIT
+
+ Parson 1.1.3 ( http://kgabis.github.com/parson/ )
+ Copyright (c) 2012 - 2021 Krzysztof Gabis
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+*/
+
+#ifndef parson_parson_h
+#define parson_parson_h
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stddef.h>   /* size_t */
+
+/* Types and enums */
+typedef struct json_object_t JSON_Object;
+typedef struct json_array_t  JSON_Array;
+typedef struct json_value_t  JSON_Value;
+
+enum json_value_type {
+    JSONError   = -1,
+    JSONNull    = 1,
+    JSONString  = 2,
+    JSONNumber  = 3,
+    JSONObject  = 4,
+    JSONArray   = 5,
+    JSONBoolean = 6
+};
+typedef int JSON_Value_Type;
+
+enum json_result_t {
+    JSONSuccess = 0,
+    JSONFailure = -1
+};
+typedef int JSON_Status;
+
+typedef void * (*JSON_Malloc_Function)(size_t);
+typedef void   (*JSON_Free_Function)(void *);
+
+/* Call only once, before calling any other function from parson API. If not called, malloc and free
+   from stdlib will be used for all allocations */
+void json_set_allocation_functions(JSON_Malloc_Function malloc_fun, JSON_Free_Function free_fun);
+
+/* Sets if slashes should be escaped or not when serializing JSON. By default slashes are escaped.
+ This function sets a global setting and is not thread safe. */
+void json_set_escape_slashes(int escape_slashes);
+
+/* Parses first JSON value in a file, returns NULL in case of error */
+JSON_Value * json_parse_file(const char *filename);
+
+/* Parses first JSON value in a file and ignores comments (/ * * / and //),
+   returns NULL in case of error */
+JSON_Value * json_parse_file_with_comments(const char *filename);
+
+/*  Parses first JSON value in a string, returns NULL in case of error */
+JSON_Value * json_parse_string(const char *string);
+
+/*  Parses first JSON value in a string and ignores comments (/ * * / and //),
+    returns NULL in case of error */
+JSON_Value * json_parse_string_with_comments(const char *string);
+
+/* Serialization */
+size_t      json_serialization_size(const JSON_Value *value); /* returns 0 on fail */
+JSON_Status json_serialize_to_buffer(const JSON_Value *value, char *buf, size_t buf_size_in_bytes);
+JSON_Status json_serialize_to_file(const JSON_Value *value, const char *filename);
+char *      json_serialize_to_string(const JSON_Value *value);
+
+/* Pretty serialization */
+size_t      json_serialization_size_pretty(const JSON_Value *value); /* returns 0 on fail */
+JSON_Status json_serialize_to_buffer_pretty(const JSON_Value *value, char *buf, size_t buf_size_in_bytes);
+JSON_Status json_serialize_to_file_pretty(const JSON_Value *value, const char *filename);
+char *      json_serialize_to_string_pretty(const JSON_Value *value);
+
+void        json_free_serialized_string(char *string); /* frees string from json_serialize_to_string and json_serialize_to_string_pretty */
+
+/* Comparing */
+int  json_value_equals(const JSON_Value *a, const JSON_Value *b);
+
+/* Validation
+   This is *NOT* JSON Schema. It validates json by checking if object have identically
+   named fields with matching types.
+   For example schema {"name":"", "age":0} will validate
+   {"name":"Joe", "age":25} and {"name":"Joe", "age":25, "gender":"m"},
+   but not {"name":"Joe"} or {"name":"Joe", "age":"Cucumber"}.
+   In case of arrays, only first value in schema is checked against all values in tested array.
+   Empty objects ({}) validate all objects, empty arrays ([]) validate all arrays,
+   null validates values of every type.
+ */
+JSON_Status json_validate(const JSON_Value *schema, const JSON_Value *value);
+
+/*
+ * JSON Object
+ */
+JSON_Value  * json_object_get_value  (const JSON_Object *object, const char *name);
+const char  * json_object_get_string (const JSON_Object *object, const char *name);
+size_t        json_object_get_string_len(const JSON_Object *object, const char *name); /* doesn't account for last null character */
+JSON_Object * json_object_get_object (const JSON_Object *object, const char *name);
+JSON_Array  * json_object_get_array  (const JSON_Object *object, const char *name);
+double        json_object_get_number (const JSON_Object *object, const char *name); /* returns 0 on fail */
+int           json_object_get_boolean(const JSON_Object *object, const char *name); /* returns -1 on fail */
+
+/* dotget functions enable addressing values with dot notation in nested objects,
+ just like in structs or c++/java/c# objects (e.g. objectA.objectB.value).
+ Because valid names in JSON can contain dots, some values may be inaccessible
+ this way. */
+JSON_Value  * json_object_dotget_value  (const JSON_Object *object, const char *name);
+const char  * json_object_dotget_string (const JSON_Object *object, const char *name);
+size_t        json_object_dotget_string_len(const JSON_Object *object, const char *name); /* doesn't account for last null character */
+JSON_Object * json_object_dotget_object (const JSON_Object *object, const char *name);
+JSON_Array  * json_object_dotget_array  (const JSON_Object *object, const char *name);
+double        json_object_dotget_number (const JSON_Object *object, const char *name); /* returns 0 on fail */
+int           json_object_dotget_boolean(const JSON_Object *object, const char *name); /* returns -1 on fail */
+
+/* Functions to get available names */
+size_t        json_object_get_count   (const JSON_Object *object);
+const char  * json_object_get_name    (const JSON_Object *object, size_t index);
+JSON_Value  * json_object_get_value_at(const JSON_Object *object, size_t index);
+JSON_Value  * json_object_get_wrapping_value(const JSON_Object *object);
+
+/* Functions to check if object has a value with a specific name. Returned value is 1 if object has
+ * a value and 0 if it doesn't. dothas functions behave exactly like dotget functions. */
+int json_object_has_value        (const JSON_Object *object, const char *name);
+int json_object_has_value_of_type(const JSON_Object *object, const char *name, JSON_Value_Type type);
+
+int json_object_dothas_value        (const JSON_Object *object, const char *name);
+int json_object_dothas_value_of_type(const JSON_Object *object, const char *name, JSON_Value_Type type);
+
+/* Creates new name-value pair or frees and replaces old value with a new one.
+ * json_object_set_value does not copy passed value so it shouldn't be freed afterwards. */
+JSON_Status json_object_set_value(JSON_Object *object, const char *name, JSON_Value *value);
+JSON_Status json_object_set_string(JSON_Object *object, const char *name, const char *string);
+JSON_Status json_object_set_string_with_len(JSON_Object *object, const char *name, const char *string, size_t len);  /* length shouldn't include last null character */
+JSON_Status json_object_set_number(JSON_Object *object, const char *name, double number);
+JSON_Status json_object_set_boolean(JSON_Object *object, const char *name, int boolean);
+JSON_Status json_object_set_null(JSON_Object *object, const char *name);
+
+/* Works like dotget functions, but creates whole hierarchy if necessary.
+ * json_object_dotset_value does not copy passed value so it shouldn't be freed afterwards. */
+JSON_Status json_object_dotset_value(JSON_Object *object, const char *name, JSON_Value *value);
+JSON_Status json_object_dotset_string(JSON_Object *object, const char *name, const char *string);
+JSON_Status json_object_dotset_string_with_len(JSON_Object *object, const char *name, const char *string, size_t len); /* length shouldn't include last null character */
+JSON_Status json_object_dotset_number(JSON_Object *object, const char *name, double number);
+JSON_Status json_object_dotset_boolean(JSON_Object *object, const char *name, int boolean);
+JSON_Status json_object_dotset_null(JSON_Object *object, const char *name);
+
+/* Frees and removes name-value pair */
+JSON_Status json_object_remove(JSON_Object *object, const char *name);
+
+/* Works like dotget function, but removes name-value pair only on exact match. */
+JSON_Status json_object_dotremove(JSON_Object *object, const char *key);
+
+/* Removes all name-value pairs in object */
+JSON_Status json_object_clear(JSON_Object *object);
+
+/*
+ *JSON Array
+ */
+JSON_Value  * json_array_get_value  (const JSON_Array *array, size_t index);
+const char  * json_array_get_string (const JSON_Array *array, size_t index);
+size_t        json_array_get_string_len(const JSON_Array *array, size_t index); /* doesn't account for last null character */
+JSON_Object * json_array_get_object (const JSON_Array *array, size_t index);
+JSON_Array  * json_array_get_array  (const JSON_Array *array, size_t index);
+double        json_array_get_number (const JSON_Array *array, size_t index); /* returns 0 on fail */
+int           json_array_get_boolean(const JSON_Array *array, size_t index); /* returns -1 on fail */
+size_t        json_array_get_count  (const JSON_Array *array);
+JSON_Value  * json_array_get_wrapping_value(const JSON_Array *array);
+
+/* Frees and removes value at given index, does nothing and returns JSONFailure if index doesn't exist.
+ * Order of values in array may change during execution.  */
+JSON_Status json_array_remove(JSON_Array *array, size_t i);
+
+/* Frees and removes from array value at given index and replaces it with given one.
+ * Does nothing and returns JSONFailure if index doesn't exist.
+ * json_array_replace_value does not copy passed value so it shouldn't be freed afterwards. */
+JSON_Status json_array_replace_value(JSON_Array *array, size_t i, JSON_Value *value);
+JSON_Status json_array_replace_string(JSON_Array *array, size_t i, const char* string);
+JSON_Status json_array_replace_string_with_len(JSON_Array *array, size_t i, const char *string, size_t len); /* length shouldn't include last null character */
+JSON_Status json_array_replace_number(JSON_Array *array, size_t i, double number);
+JSON_Status json_array_replace_boolean(JSON_Array *array, size_t i, int boolean);
+JSON_Status json_array_replace_null(JSON_Array *array, size_t i);
+
+/* Frees and removes all values from array */
+JSON_Status json_array_clear(JSON_Array *array);
+
+/* Appends new value at the end of array.
+ * json_array_append_value does not copy passed value so it shouldn't be freed afterwards. */
+JSON_Status json_array_append_value(JSON_Array *array, JSON_Value *value);
+JSON_Status json_array_append_string(JSON_Array *array, const char *string);
+JSON_Status json_array_append_string_with_len(JSON_Array *array, const char *string, size_t len); /* length shouldn't include last null character */
+JSON_Status json_array_append_number(JSON_Array *array, double number);
+JSON_Status json_array_append_boolean(JSON_Array *array, int boolean);
+JSON_Status json_array_append_null(JSON_Array *array);
+
+/*
+ *JSON Value
+ */
+JSON_Value * json_value_init_object (void);
+JSON_Value * json_value_init_array  (void);
+JSON_Value * json_value_init_string (const char *string); /* copies passed string */
+JSON_Value * json_value_init_string_with_len(const char *string, size_t length); /* copies passed string, length shouldn't include last null character */
+JSON_Value * json_value_init_number (double number);
+JSON_Value * json_value_init_boolean(int boolean);
+JSON_Value * json_value_init_null   (void);
+JSON_Value * json_value_deep_copy   (const JSON_Value *value);
+void         json_value_free        (JSON_Value *value);
+
+JSON_Value_Type json_value_get_type   (const JSON_Value *value);
+JSON_Object *   json_value_get_object (const JSON_Value *value);
+JSON_Array  *   json_value_get_array  (const JSON_Value *value);
+const char  *   json_value_get_string (const JSON_Value *value);
+size_t          json_value_get_string_len(const JSON_Value *value); /* doesn't account for last null character */
+double          json_value_get_number (const JSON_Value *value);
+int             json_value_get_boolean(const JSON_Value *value);
+JSON_Value  *   json_value_get_parent (const JSON_Value *value);
+
+/* Same as above, but shorter */
+JSON_Value_Type json_type   (const JSON_Value *value);
+JSON_Object *   json_object (const JSON_Value *value);
+JSON_Array  *   json_array  (const JSON_Value *value);
+const char  *   json_string (const JSON_Value *value);
+size_t          json_string_len(const JSON_Value *value); /* doesn't account for last null character */
+double          json_number (const JSON_Value *value);
+int             json_boolean(const JSON_Value *value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

test_speed.c

@@ -13,7 +13,7 @@ int main()
 	struct ovni_ev ev = {0};
 	int i;
 
-	ovni_proc_init(0, 0);
+	ovni_proc_init(0, "test", 0);
 	ovni_thread_init(1);
 
 	ovni_ev_set_mcv(&ev, "OB.");