Labee Structure Driver and Dummy driver implementation

Author: Alcpz

Diff for: Makefile.am

@@ -1,4 +1,4 @@
-AM_CFLAGS = -Wall -Werror -Wextra -pedantic -fno-strict-aliasing
+AM_CFLAGS = -Wall -Wno-error -Wextra -pedantic -fno-strict-aliasing
 ACLOCAL_AMFLAGS = -I m4
 
 #Shared library
@@ -24,6 +24,12 @@ lib@PACKAGE_TARNAME@_la_SOURCES = \
 
 lib@PACKAGE_TARNAME@_la_LIBADD =
 
+
+if ENABLE_DUMMY
+lib@PACKAGE_TARNAME@_la_CPPFLAGS += -DENABLE_DUMMY
+lib@PACKAGE_TARNAME@_la_SOURCES += src/driver-dummy.c
+endif
+
 if ENABLE_MIC
 lib@PACKAGE_TARNAME@_la_CPPFLAGS += -DENABLE_MIC
 lib@PACKAGE_TARNAME@_la_SOURCES += src/driver-mic.c
@@ -53,6 +59,11 @@ lib@PACKAGE_TARNAME@_la_CPPFLAGS += -DENABLE_ODROID
 lib@PACKAGE_TARNAME@_la_SOURCES += src/driver-odroid.c
 endif
 
+if ENABLE_LABEE
+lib@PACKAGE_TARNAME@_la_CPPFLAGS += -DENABLE_LABEE
+lib@PACKAGE_TARNAME@_la_SOURCES += src/driver-labee.c
+endif
+
 
 #Flags for common dependencies
 

Diff for: configure.ac

@@ -19,6 +19,13 @@ AC_SEARCH_LIBS([pthread_create], [pthread])
 
 PKG_CHECK_MODULES([CONFUSE], [libconfuse])
 
+# Optional: Dummy testing module Support 
+AC_ARG_ENABLE([dummy], AS_HELP_STRING([--enable-dummy],
+	[Enable Dummy testing support
+		(default: disabled)]))
+AS_IF([test "x$enable_dummy" != "xno"], [have_dummy=yes])
+AM_CONDITIONAL([ENABLE_DUMMY], [test "x$have_dummy" = "xyes"])
+
 # Optional: Intel MIC support
 AC_ARG_WITH([mic], AS_HELP_STRING([--without-mic],
 	[Disable Intel Many Integrated Core support
@@ -43,20 +50,26 @@ AS_IF([test "x$with_nvml" != "xno"],
 AM_CONDITIONAL([ENABLE_NVML], [test "x$have_nvml" = "xyes"])
 
 # Optional: Schleifenbauer PDU support
-AC_ARG_WITH([sb_pdu], AS_HELP_STRING([--without-sb-pdu],
-	[Disable Schleifenbauer PDU support
-		(default: enabled if libcrypto is available)]))
-AS_IF([test "x$with_sb_pdu" != "xno"],
+AC_ARG_ENABLE([sb_pdu], AS_HELP_STRING([--enable-sb-pdu],
+	[Enable Schleifenbauer PDU support
+		(default: disabled)]))
+AS_IF([test "x$enable_sb_pdu" = "xyes"],
 	[PKG_CHECK_MODULES([CRYPTO], [libcrypto], [have_sb_pdu=yes])])
 AM_CONDITIONAL([ENABLE_SB_PDU], [test "x$have_sb_pdu" = "xyes"])
 
 # Optional: Odroid INA231 Sensor support 
-AC_ARG_WITH([sb_pdu], AS_HELP_STRING([--without-odroid],
+AC_ARG_WITH([odroid], AS_HELP_STRING([--without-odroid],
 	[Disable Odroid support
 		(default: enabled)]))
 AS_IF([test "x$with_odroid" != "xno"], [have_odroid=yes])
 AM_CONDITIONAL([ENABLE_ODROID], [test "x$have_odroid" = "xyes"])
 
+# Optional: Labee(PSNN) REST Support 
+AC_ARG_ENABLE([labee], AS_HELP_STRING([--enable-labee],
+	[Enable Labee support
+		(default: disable)]))
+AS_IF([test "x$enable_labee" = "xyes"], [have_labee=yes])
+AM_CONDITIONAL([ENABLE_LABEE], [test "x$have_labee" = "xyes"])
 
 LT_INIT
 

Diff for: include/eml/device.h

@@ -35,16 +35,20 @@ typedef struct emlDevice emlDevice_t;
 
 /** Known device types */
 typedef enum emlDeviceType {
+  /** Dummy measurement for testing algorithms */
+  EML_DEV_DUMMY = 0,
   /** Nvidia cards supporting power readings through NVML */
-  EML_DEV_NVML = 0,
+  EML_DEV_NVML = 1,
   /** Intel CPUs supporting energy counters through RAPL */
-  EML_DEV_RAPL = 1,
+  EML_DEV_RAPL = 2,
   /** Intel MICs (Xeon Phi) */
-  EML_DEV_MIC = 2,
+  EML_DEV_MIC = 3,
   /** Schleifenbauer PDUs */
-  EML_DEV_SB_PDU = 3,
+  EML_DEV_SB_PDU = 4,
   /** Odroid with sensor support */
-  EML_DEV_ODROID = 4,
+  EML_DEV_ODROID = 5,
+  /** Labee(PSNN) Rest interface */
+  EML_DEV_LABEE = 6,
   /** Number of supported device types */
   EML_DEVICE_TYPE_COUNT
 } emlDeviceType_t;

Diff for: src/device.c

@@ -32,6 +32,11 @@ enum emlError emlInit() {
   if (devices)
     return EML_ALREADY_INITIALIZED;
 
+#ifdef ENABLE_DUMMY
+  extern struct emlDriver dummy_driver;
+  drivers[EML_DEV_DUMMY] = &dummy_driver;
+#endif
+
 #ifdef ENABLE_NVML
   extern struct emlDriver nvml_driver;
   drivers[EML_DEV_NVML] = &nvml_driver;
@@ -57,9 +62,17 @@ enum emlError emlInit() {
   drivers[EML_DEV_ODROID] = &odroid_driver;
 #endif
 
+#ifdef ENABLE_LABEE
+  extern struct emlDriver labee_driver;
+  drivers[EML_DEV_LABEE] = &labee_driver;
+#endif
 
   cfg_opt_t cfgopts[] = {
 
+#ifdef ENABLE_DUMMY
+    CFG_SEC("dummy", drivers[EML_DEV_DUMMY]->cfgopts, CFGF_NONE),
+#endif
+
 #ifdef ENABLE_NVML
     CFG_SEC("nvml", drivers[EML_DEV_NVML]->cfgopts, CFGF_NONE),
 #endif
@@ -80,6 +93,9 @@ enum emlError emlInit() {
     CFG_SEC("odroid", drivers[EML_DEV_ODROID]->cfgopts, CFGF_NONE),
 #endif
 
+#ifdef ENABLE_LABEE
+    CFG_SEC("labee", drivers[EML_DEV_LABEE]->cfgopts, CFGF_NONE),
+#endif
 
     CFG_END()
   };

Diff for: src/driver-dummy.c

@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2017 Universidad de La Laguna <cap@pcg.ull.es>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+
+//feature test macro for pread() in unistd.h
+#define _XOPEN_SOURCE 500
+
+#define DUMMY_DEFAULT_SAMPLING_INTERVAL 100000000L // ~100ms
+
+#include <assert.h>
+//#include <ctype.h>
+//#include <errno.h>
+//#include <stddef.h>
+//#include <stdint.h>
+//#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+//#include <dirent.h>
+//
+//#include <confuse.h>
+//#include <fcntl.h>
+//#include <sys/stat.h>
+//#include <unistd.h>
+//
+#include "data.h"
+#include "debug.h"
+#include "driver.h"
+#include "error.h"
+#include "timer.h"
+
+struct emlDriver dummy_driver;
+
+
+static enum emlError init(cfg_t* const config) {
+  assert(!dummy_driver.initialized);
+  assert(config);
+  dummy_driver.config = config;
+
+  printf("OMG pre\n");
+  dummy_driver.ndevices = 1;
+  dummy_driver.devices = malloc(dummy_driver.ndevices * sizeof(*dummy_driver.devices));
+  for (size_t i = 0; i < dummy_driver.ndevices; i++) {
+    struct emlDevice devinit = {
+      .driver = &dummy_driver,
+      .index = i,
+    };
+    sprintf(devinit.name, "%s%zu", dummy_driver.name, i);
+
+    struct emlDevice* const dev = &dummy_driver.devices[i];
+    memcpy(dev, &devinit, sizeof(*dev));
+  }
+
+  printf("OMG\n");
+  dummy_driver.initialized = 1;
+  return EML_SUCCESS;
+}
+
+
+static enum emlError shutdown() {
+  assert(dummy_driver.initialized);
+
+  dummy_driver.initialized = 0;
+
+  return EML_SUCCESS;
+}
+
+static enum emlError measure(size_t devno, unsigned long long* values) {
+  assert(dummy_driver.initialized);
+  assert(devno < dummy_driver.ndevices); // Shouldn't be more than one anyways
+
+  values[0] = millitimestamp();
+  values[dummy_driver.default_props->inst_power_field * DATABLOCK_SIZE] = values[0]; 
+  return EML_SUCCESS;
+}
+
+// default measurement properties for this driver
+static struct emlDataProperties default_props = {
+  .time_factor = EML_SI_MILLI,
+  .energy_factor = EML_SI_MILLI, // Measurement is in W, but to store on a long, it is multiplied by EML_SI_MEGA
+//  .power_factor = EML_SI_MICRO,  
+  .inst_energy_field = 0,
+  .inst_power_field = 1,
+};
+
+static cfg_opt_t cfgopts[] = {
+  CFG_BOOL("disabled", cfg_true, CFGF_NONE),
+  CFG_INT("sampling_interval", DUMMY_DEFAULT_SAMPLING_INTERVAL, CFGF_NONE),
+  CFG_END()
+};
+
+//public driver state and interface
+struct emlDriver dummy_driver = {
+  .name = "dummy",
+  .type = EML_DEV_DUMMY,
+  .failed_reason = "",
+  .default_props = &default_props,
+  .cfgopts = cfgopts,
+  .config = NULL,
+
+  .init = &init,
+  .shutdown = &shutdown,
+  .measure = &measure,
+};

Diff for: src/driver-labee.c

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2018 Universidad de La Laguna <cap@pcg.ull.es>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * @author: Alberto Cabrera Perez <Alberto.Cabrera@ull.edu.es>
+ */
+
+#define _XOPEN_SOURCE 500
+
+#include <assert.h>
+//#include <ctype.h>
+//#include <errno.h>
+//#include <stddef.h>
+//#include <stdint.h>
+//#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+//#include <dirent.h>
+//
+#include <confuse.h>
+//#include <fcntl.h>
+//#include <sys/stat.h>
+//#include <unistd.h>
+//
+#include "data.h"
+#include "debug.h"
+#include "driver.h"
+#include "error.h"
+#include "timer.h"
+
+#define LABEE_DEFAULT_SAMPLING_INTERVAL 100000000L // 100ms
+
+struct emlDriver labee_driver;
+
+
+static enum emlError init(cfg_t* const config) {
+  assert(!labee_driver.initialized);
+  assert(config);
+  labee_driver.config = config;
+
+  enum emlError err;
+
+  // TODO Check if the API is up
+  
+  // FUnction that generates error code
+  if (err != EML_SUCCESS)
+    goto err_free;
+  
+  labee_driver.ndevices = 1;
+  labee_driver.devices = malloc(labee_driver.ndevices * sizeof(*labee_driver.devices));
+  for (size_t i = 0; i < labee_driver.ndevices; i++) {
+    struct emlDevice devinit = {
+      .driver = &labee_driver,
+      .index = i,
+    };
+    sprintf(devinit.name, "%s%zu", labee_driver.name, i);
+
+    struct emlDevice* const dev = &labee_driver.devices[i];
+    memcpy(dev, &devinit, sizeof(*dev));
+  }
+
+  labee_driver.initialized = 1;
+  return EML_SUCCESS;
+
+err_free:
+  if (labee_driver.failed_reason[0] == '\0')
+    strncpy(labee_driver.failed_reason, emlErrorMessage(err), sizeof(labee_driver.failed_reason) - 1);
+  return err;
+}
+
+
+static enum emlError shutdown() {
+  assert(labee_driver.initialized);
+
+  labee_driver.initialized = 0;
+
+  return EML_SUCCESS;
+}
+
+static enum emlError measure(size_t devno, unsigned long long* values) {
+  assert(labee_driver.initialized);
+  assert(devno < labee_driver.ndevices); // Shouldn't be more than one anyways
+
+  enum emlError err;
+
+  values[0] = millitimestamp();
+  const long sampling_interval = cfg_getint(labee_driver.config, "sampling_interval");
+  unsigned long long power = 1 / sampling_interval;
+
+  //TODO parse xml from rest api apply average proportionally to interval 
+  values[labee_driver.default_props->inst_energy_field * DATABLOCK_SIZE] = power; 
+  return EML_SUCCESS;
+}
+
+// default measurement properties for this driver
+static struct emlDataProperties default_props = {
+  .time_factor = EML_SI_MILLI,
+  .energy_factor = EML_SI_MICRO, // Measurement is in J, but to store on a long, it is multiplied by EML_SI_MEGA
+  .power_factor = EML_SI_MICRO,  // Measurement is in W, same principle, with EML_SI_MEGA 
+  .inst_energy_field = 1,
+  .inst_power_field = 2,
+};
+
+static cfg_opt_t cfgopts[] = {
+  CFG_BOOL("disabled", cfg_false, CFGF_NONE),
+  CFG_INT("sampling_interval", LABEE_DEFAULT_SAMPLING_INTERVAL, CFGF_NONE),
+  CFG_END()
+};
+
+//public driver state and interface
+struct emlDriver labee_driver = {
+  .name = "labee",
+  .type = EML_DEV_LABEE,
+  .failed_reason = "",
+  .default_props = &default_props,
+  .cfgopts = cfgopts,
+  .config = NULL,
+
+  .init = &init,
+  .shutdown = &shutdown,
+  .measure = &measure,
+};

Diff for: src/driver-odroid.c

@@ -199,7 +199,7 @@ static enum emlError init(cfg_t* const config) {
   free(sensors);
 
   if (odroid_driver.failed_reason[0] == '\0')
-    strncpy(odroid_driver.failed_reason, emlErrorMessage(err), sizeof(odroid_driver.failed_reason));
+    strncpy(odroid_driver.failed_reason, emlErrorMessage(err), sizeof(odroid_driver.failed_reason) - 1);
   return err;
 }
 

Diff for: src/driver-rapl.c

@@ -405,7 +405,7 @@ static enum emlError init(cfg_t* const config) {
 
 error:
   if (rapl_driver.failed_reason[0] == '\0')
-    strncpy(rapl_driver.failed_reason, emlErrorMessage(err), sizeof(rapl_driver.failed_reason));
+    strncpy(rapl_driver.failed_reason, emlErrorMessage(err), sizeof(rapl_driver.failed_reason) - 1);
   return err;
 }