Index: uspace/app/hbench/csv.c
===================================================================
--- uspace/app/hbench/csv.c	(revision a787081a79dcfffa35f9e024d6587817108cf357)
+++ uspace/app/hbench/csv.c	(revision ebb0835c2c47eb2e0f1fd4e27708490ece3c25db)
@@ -67,5 +67,5 @@
  * @param workload_size Workload size.
  */
-void csv_report_add_entry(stopwatch_t *stopwatch, int run_index,
+void csv_report_add_entry(benchmeter_t *meter, int run_index,
     benchmark_t *bench, uint64_t workload_size)
 {
@@ -76,5 +76,5 @@
 	fprintf(csv_output, "%s,%d,%" PRIu64 ",%lld\n",
 	    bench->name, run_index, workload_size,
-	    (long long) stopwatch_get_nanos(stopwatch));
+	    (long long) stopwatch_get_nanos(&meter->stopwatch));
 }
 
Index: uspace/app/hbench/doc/doxygroups.h
===================================================================
--- uspace/app/hbench/doc/doxygroups.h	(revision a787081a79dcfffa35f9e024d6587817108cf357)
+++ uspace/app/hbench/doc/doxygroups.h	(revision ebb0835c2c47eb2e0f1fd4e27708490ece3c25db)
@@ -19,6 +19,7 @@
  * benchmark function to the benchmark_t.
  *
- * The benchmarking function has to accept for arguments:
- *  @li stopwatch_t: store the measured data there
+ * The benchmarking function has to accept four arguments:
+ *  @li benchmeter_t: call benchmeter_start and benchmeter_stop around the
+ *      actual benchmarking code
  *  @li uint64_t: size of the workload - typically number of inner loops in
  *      your benchmark (used to self-calibrate benchmark size)
@@ -28,12 +29,12 @@
  * Typically, the structure of the function is following:
  * @code{c}
- * static bool runner(stopwatch_t *stopwatch, uint64_t size,
+ * static bool runner(benchmeter_t *meter, uint64_t size,
  *     char *error, size_t error_size)
  * {
- * 	stopwatch_start(stopwatch);
+ * 	benchmeter_start(meter);
  * 	for (uint64_t i = 0; i < size; i++) {
  * 		// measured action
  * 	}
- * 	stopwatch_stop(stopwatch);
+ * 	benchmeter_stop(meter);
  *
  * 	return true;
Index: uspace/app/hbench/fs/dirread.c
===================================================================
--- uspace/app/hbench/fs/dirread.c	(revision a787081a79dcfffa35f9e024d6587817108cf357)
+++ uspace/app/hbench/fs/dirread.c	(revision ebb0835c2c47eb2e0f1fd4e27708490ece3c25db)
@@ -43,10 +43,10 @@
  * that the corresponding blocks would be cached after first run.
  */
-static bool runner(stopwatch_t *stopwatch, uint64_t size,
+static bool runner(benchmeter_t *meter, uint64_t size,
     char *error, size_t error_size)
 {
 	const char *path = bench_param_get("dirname", "/");
 
-	stopwatch_start(stopwatch);
+	benchmeter_start(meter);
 	for (uint64_t i = 0; i < size; i++) {
 		DIR *dir = opendir(path);
@@ -64,5 +64,5 @@
 		closedir(dir);
 	}
-	stopwatch_stop(stopwatch);
+	benchmeter_stop(meter);
 
 	return true;
Index: uspace/app/hbench/fs/fileread.c
===================================================================
--- uspace/app/hbench/fs/fileread.c	(revision a787081a79dcfffa35f9e024d6587817108cf357)
+++ uspace/app/hbench/fs/fileread.c	(revision ebb0835c2c47eb2e0f1fd4e27708490ece3c25db)
@@ -44,5 +44,5 @@
  * corresponding blocks would be cached after first run.
  */
-static bool runner(stopwatch_t *stopwatch, uint64_t size,
+static bool runner(benchmeter_t *meter, uint64_t size,
     char *error, size_t error_size)
 {
@@ -65,5 +65,5 @@
 	}
 
-	stopwatch_start(stopwatch);
+	benchmeter_start(meter);
 	for (uint64_t i = 0; i < size; i++) {
 		int rc = fseek(file, 0, SEEK_SET);
@@ -84,5 +84,5 @@
 		}
 	}
-	stopwatch_stop(stopwatch);
+	benchmeter_stop(meter);
 
 leave_close:
Index: uspace/app/hbench/hbench.h
===================================================================
--- uspace/app/hbench/hbench.h	(revision a787081a79dcfffa35f9e024d6587817108cf357)
+++ uspace/app/hbench/hbench.h	(revision ebb0835c2c47eb2e0f1fd4e27708490ece3c25db)
@@ -41,5 +41,29 @@
 #include <perf.h>
 
-typedef bool (*benchmark_entry_t)(stopwatch_t *, uint64_t,
+/*
+ * So far, a simple wrapper around system stopwatch.
+ * Eventually, we could collection of hardware counters etc. without
+ * modifying signatures of any existing benchmark.
+ */
+typedef struct {
+	stopwatch_t stopwatch;
+} benchmeter_t;
+
+static inline void benchmeter_init(benchmeter_t *meter)
+{
+	stopwatch_init(&meter->stopwatch);
+}
+
+static inline void benchmeter_start(benchmeter_t *meter)
+{
+	stopwatch_start(&meter->stopwatch);
+}
+
+static inline void benchmeter_stop(benchmeter_t *meter)
+{
+	stopwatch_stop(&meter->stopwatch);
+}
+
+typedef bool (*benchmark_entry_t)(benchmeter_t *, uint64_t,
     char *, size_t);
 typedef bool (*benchmark_helper_t)(char *, size_t);
@@ -57,5 +81,5 @@
 
 extern errno_t csv_report_open(const char *);
-extern void csv_report_add_entry(stopwatch_t *, int, benchmark_t *, uint64_t);
+extern void csv_report_add_entry(benchmeter_t *, int, benchmark_t *, uint64_t);
 extern void csv_report_close(void);
 
Index: uspace/app/hbench/ipc/ns_ping.c
===================================================================
--- uspace/app/hbench/ipc/ns_ping.c	(revision a787081a79dcfffa35f9e024d6587817108cf357)
+++ uspace/app/hbench/ipc/ns_ping.c	(revision ebb0835c2c47eb2e0f1fd4e27708490ece3c25db)
@@ -38,8 +38,8 @@
 #include "../hbench.h"
 
-static bool runner(stopwatch_t *stopwatch, uint64_t niter,
+static bool runner(benchmeter_t *meter, uint64_t niter,
     char *error, size_t error_size)
 {
-	stopwatch_start(stopwatch);
+	benchmeter_start(meter);
 
 	for (uint64_t count = 0; count < niter; count++) {
@@ -54,5 +54,5 @@
 	}
 
-	stopwatch_stop(stopwatch);
+	benchmeter_stop(meter);
 
 	return true;
Index: uspace/app/hbench/ipc/ping_pong.c
===================================================================
--- uspace/app/hbench/ipc/ping_pong.c	(revision a787081a79dcfffa35f9e024d6587817108cf357)
+++ uspace/app/hbench/ipc/ping_pong.c	(revision ebb0835c2c47eb2e0f1fd4e27708490ece3c25db)
@@ -59,8 +59,8 @@
 }
 
-static bool runner(stopwatch_t *stopwatch, uint64_t niter,
+static bool runner(benchmeter_t *meter, uint64_t niter,
     char *error, size_t error_size)
 {
-	stopwatch_start(stopwatch);
+	benchmeter_start(meter);
 
 	for (uint64_t count = 0; count < niter; count++) {
@@ -75,5 +75,5 @@
 	}
 
-	stopwatch_stop(stopwatch);
+	benchmeter_stop(meter);
 
 	return true;
Index: uspace/app/hbench/main.c
===================================================================
--- uspace/app/hbench/main.c	(revision a787081a79dcfffa35f9e024d6587817108cf357)
+++ uspace/app/hbench/main.c	(revision ebb0835c2c47eb2e0f1fd4e27708490ece3c25db)
@@ -53,15 +53,15 @@
 #define MAX_ERROR_STR_LENGTH 1024
 
-static void short_report(stopwatch_t *stopwatch, int run_index,
+static void short_report(benchmeter_t *meter, int run_index,
     benchmark_t *bench, uint64_t workload_size)
 {
-	csv_report_add_entry(stopwatch, run_index, bench, workload_size);
-
-	usec_t duration_usec = NSEC2USEC(stopwatch_get_nanos(stopwatch));
+	csv_report_add_entry(meter, run_index, bench, workload_size);
+
+	usec_t duration_usec = NSEC2USEC(stopwatch_get_nanos(&meter->stopwatch));
 
 	printf("Completed %" PRIu64 " operations in %llu us",
 	    workload_size, duration_usec);
 	if (duration_usec > 0) {
-		double nanos = stopwatch_get_nanos(stopwatch);
+		double nanos = stopwatch_get_nanos(&meter->stopwatch);
 		double thruput = (double) workload_size / (nanos / 1000000000.0l);
 		printf(", %.0f ops/s.\n", thruput);
@@ -106,5 +106,5 @@
  *
  */
-static void compute_stats(stopwatch_t *stopwatch, size_t stopwatch_count,
+static void compute_stats(benchmeter_t *meter, size_t stopwatch_count,
     uint64_t workload_size, double precision, double *out_duration_avg,
     double *out_duration_sigma, double *out_thruput_avg)
@@ -115,5 +115,5 @@
 
 	for (size_t i = 0; i < stopwatch_count; i++) {
-		double nanos = stopwatch_get_nanos(&stopwatch[i]);
+		double nanos = stopwatch_get_nanos(&meter[i].stopwatch);
 		double thruput = (double) workload_size / nanos;
 
@@ -130,9 +130,9 @@
 }
 
-static void summary_stats(stopwatch_t *stopwatch, size_t stopwatch_count,
+static void summary_stats(benchmeter_t *meter, size_t meter_count,
     benchmark_t *bench, uint64_t workload_size)
 {
 	double duration_avg, duration_sigma, thruput_avg;
-	compute_stats(stopwatch, stopwatch_count, workload_size, 0.001,
+	compute_stats(meter, meter_count, workload_size, 0.001,
 	    &duration_avg, &duration_sigma, &thruput_avg);
 
@@ -140,5 +140,5 @@
 	    "%.0f ops/s; Samples: %zu\n",
 	    workload_size, duration_avg / 1000.0, duration_sigma / 1000.0,
-	    thruput_avg * 1000000000.0, stopwatch_count);
+	    thruput_avg * 1000000000.0, meter_count);
 }
 
@@ -175,14 +175,15 @@
 		workload_size = ((uint64_t) 1) << bits;
 
-		stopwatch_t stopwatch = STOPWATCH_INITIALIZE_STATIC;
-
-		bool ok = bench->entry(&stopwatch, workload_size,
+		benchmeter_t meter;
+		benchmeter_init(&meter);
+
+		bool ok = bench->entry(&meter, workload_size,
 		    error_msg, MAX_ERROR_STR_LENGTH);
 		if (!ok) {
 			goto leave_error;
 		}
-		short_report(&stopwatch, -1, bench, workload_size);
-
-		nsec_t duration = stopwatch_get_nanos(&stopwatch);
+		short_report(&meter, -1, bench, workload_size);
+
+		nsec_t duration = stopwatch_get_nanos(&meter.stopwatch);
 		if (duration > SEC2NSEC(MIN_DURATION_SECS)) {
 			break;
@@ -192,25 +193,25 @@
 	printf("Workload size set to %" PRIu64 ", measuring %d samples.\n", workload_size, NUM_SAMPLES);
 
-	stopwatch_t *stopwatch = calloc(NUM_SAMPLES, sizeof(stopwatch_t));
-	if (stopwatch == NULL) {
+	benchmeter_t *meter = calloc(NUM_SAMPLES, sizeof(benchmeter_t));
+	if (meter == NULL) {
 		snprintf(error_msg, MAX_ERROR_STR_LENGTH, "failed allocating memory");
 		goto leave_error;
 	}
 	for (int i = 0; i < NUM_SAMPLES; i++) {
-		stopwatch_init(&stopwatch[i]);
-
-		bool ok = bench->entry(&stopwatch[i], workload_size,
+		benchmeter_init(&meter[i]);
+
+		bool ok = bench->entry(&meter[i], workload_size,
 		    error_msg, MAX_ERROR_STR_LENGTH);
 		if (!ok) {
-			free(stopwatch);
+			free(meter);
 			goto leave_error;
 		}
-		short_report(&stopwatch[i], i, bench, workload_size);
-	}
-
-	summary_stats(stopwatch, NUM_SAMPLES, bench, workload_size);
+		short_report(&meter[i], i, bench, workload_size);
+	}
+
+	summary_stats(meter, NUM_SAMPLES, bench, workload_size);
 	printf("\nBenchmark completed\n");
 
-	free(stopwatch);
+	free(meter);
 
 	goto leave;
Index: uspace/app/hbench/malloc/malloc1.c
===================================================================
--- uspace/app/hbench/malloc/malloc1.c	(revision a787081a79dcfffa35f9e024d6587817108cf357)
+++ uspace/app/hbench/malloc/malloc1.c	(revision ebb0835c2c47eb2e0f1fd4e27708490ece3c25db)
@@ -36,8 +36,8 @@
 #include "../hbench.h"
 
-static bool runner(stopwatch_t *stopwatch, uint64_t size,
+static bool runner(benchmeter_t *meter, uint64_t size,
     char *error, size_t error_size)
 {
-	stopwatch_start(stopwatch);
+	benchmeter_start(meter);
 	for (uint64_t i = 0; i < size; i++) {
 		void *p = malloc(1);
@@ -50,5 +50,5 @@
 		free(p);
 	}
-	stopwatch_stop(stopwatch);
+	benchmeter_stop(meter);
 
 	return true;
Index: uspace/app/hbench/malloc/malloc2.c
===================================================================
--- uspace/app/hbench/malloc/malloc2.c	(revision a787081a79dcfffa35f9e024d6587817108cf357)
+++ uspace/app/hbench/malloc/malloc2.c	(revision ebb0835c2c47eb2e0f1fd4e27708490ece3c25db)
@@ -35,8 +35,8 @@
 #include "../hbench.h"
 
-static bool runner(stopwatch_t *stopwatch, uint64_t niter,
+static bool runner(benchmeter_t *meter, uint64_t niter,
     char *error, size_t error_size)
 {
-	stopwatch_start(stopwatch);
+	benchmeter_start(meter);
 
 	void **p = malloc(niter * sizeof(void *));
@@ -67,5 +67,5 @@
 	free(p);
 
-	stopwatch_stop(stopwatch);
+	benchmeter_stop(meter);
 
 	return true;