UCD Heterogeneous Computing Laboratory / hclwattsup · Files

/*
 * This class provides methods for interacting with wattsup meter.
 *
 *  @file
 *  @author Muhammad Fah'd Azeemi <muhammad.fahad@ucdconnect.ie>
 *  @version 1.0
 */

/*--------------------------------------------------------*/

#include <sys/types.h>
#include <signal.h>
#include <sys/stat.h>
#include <dirent.h>
#include <fcntl.h>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <unistd.h>
#include <iostream>
#include <fstream>
#include <sstream>
#include <algorithm>
#include <omp.h>
#include <numeric>
#include <time.h>

/*--------------------------------------------------------*/

#include "wattsup.hpp"
#include "debug.hpp"
#include "wattsuphelpers.hpp"

/*--------------------------------------------------------*/

namespace hcl {

/*--------------------------------------------------------*/

class Wattsup::Impl {
 public:
  Impl(const unsigned int nMeters,
       const std::string* pathsToMeters,
       const std::string* params,
       const bool removeUSBLockFiles = 1);

  ~Impl();

  /*
   * Starts WattsUp measurement
   */
  int start();

  /*
   * Stops WattsUp measurement
   */
  int stop();

  /*
   * Provides the energy consumed during a measurement
   */
  double energy() const;

  double power() const;

  /*
   * Returns the power consumptions during a measurement
   */
  std::vector<double> powers(
     const unsigned int meter
  ) const;

  /*
   * Clean up all data related to a measurement
   */
  int gc();

  int execute(
      const Measure& measure,
      const std::string& executableName,
      const std::string& executableParams,
      const Precision* inPrecision,
      Precision* outPrecision,
      double* sampleMean,
      double* sd);

  int basePower(
   const Precision* inPrecision,
   Precision* outPrecision,
   double* sampleMean,
   double* sd);

 private:

  int measureTime(
      const std::string& executableName,
      const std::string& executableParams,
      const Precision* inPrecision,
      Precision* outPrecision,
      double* sampleMean,
      double* sd);

  int measureEnergyOrPower(
      const Measure& measure,
      const std::string& executableName,
      const std::string& executableParams,
      const Precision* inPrecision,
      Precision* outPrecision,
      double* sampleMean,
      double* sd);

  int measureEnergyOrPowerNullPrecision(
      const Measure& measure,
      const std::string& executableName,
      const std::string& executableParams,
      double* sampleMean,
      double* sd);
  
  int getNumInvocations(
     const std::string& executableName,
     const std::string& executableParams,
     const Precision* inPrecision,
     Precision* outPrecision,
     unsigned int* numInvocations);

  int Popen(
     const std::string& executableName,
     const std::string& executableParams,
     const unsigned int numInvocations
  );

 private:
  /*
   * Return the filename for the meter given by the id
   */
  std::string getOutputFileName(
     const size_t meterId
  ) const;

 private:
  /*
   * Paths to the WattsUp Meters
   */
  std::vector<std::string> mPathsToMeters;

  /*
   * Params to the WattsUp Meters
   */
  std::vector<std::string> mParams;

  /*
   * The PIDs of the processes invoking the scripts for the meters
   */
  std::vector<pid_t> mPids;

  /*
   * Directory where to write the meter readings
   */
  std::string mOutputDirectory;

  /*
   * The mode for the directory and the data files
   */
  mode_t mMode;

  /*
   * The column of the power in the WattsUp data file
   */
  unsigned int mPowerCol;

  /*
   * Number of header lines in WattsUp Output
   */
  unsigned int* mMeterPreLines;
  unsigned int mNumHeaderLines;

  /*
   * Remove lock files...
   */
  bool mLockUSBFiles;
};

/*--------------------------------------------------------*/

Wattsup::Wattsup(const unsigned int nMeters,
                 const std::string* pathsToMeters,
                 const std::string* params,
                 const bool removeUSBLockFiles)
    : wattsupImpl(new Impl(
                  nMeters, pathsToMeters, 
                  params, removeUSBLockFiles)) 
{}

/*--------------------------------------------------------*/

Wattsup::~Wattsup() { delete wattsupImpl; }

/*--------------------------------------------------------*/

int
Wattsup::start()
{
   return wattsupImpl->start();
}

/*--------------------------------------------------------*/

int
Wattsup::stop()
{
   return wattsupImpl->stop();
}

/*--------------------------------------------------------*/

double
Wattsup::energy() const
{
   return wattsupImpl->energy();
}

/*--------------------------------------------------------*/

double
Wattsup::power() const
{
   return wattsupImpl->power();
}

/*--------------------------------------------------------*/

std::vector<double>
Wattsup::powers(
   const unsigned int meter
) const
{
   return wattsupImpl->powers(meter);
}

/*--------------------------------------------------------*/

int
Wattsup::basePower(
   const Precision* inPrecision,
   Precision* outPrecision,
   double* sampleMean,
   double* sd)
{
   return wattsupImpl->basePower(
          inPrecision, outPrecision, sampleMean, sd);
}

/*--------------------------------------------------------*/

int
Wattsup::gc()
{
   return wattsupImpl->gc();
}

/*--------------------------------------------------------*/

Wattsup::Impl::Impl(
     const unsigned int nMeters,
     const std::string* pathsToMeters,
     const std::string* params,
     const bool removeUSBLockFiles
)
{
    mOutputDirectory = "HCLWattsUpData";
    mPowerCol = 4;
    mMode = 0777;

    Debug::Info(
       "Number of Wattsup meters %u.\n",
       nMeters);

    for (unsigned int meter = 0; meter < nMeters; meter++)
    {
        Debug::Info(
           "Meter %s, %s.\n",
           pathsToMeters[meter].c_str(),
           params[meter].c_str());

        mPathsToMeters.push_back(pathsToMeters[meter]);
        mParams.push_back(params[meter]);
    }
    mNumHeaderLines = 5;
    mLockUSBFiles = removeUSBLockFiles;
    mMeterPreLines = (unsigned int*)malloc(
                     sizeof(unsigned int)*nMeters);
    for (unsigned int meter = 0; meter < nMeters; meter++)
    {
       mMeterPreLines[meter] = 0;
    }
}

/*--------------------------------------------------------*/

Wattsup::Impl::~Impl()
{
    free(mMeterPreLines);
}

/*--------------------------------------------------------*/

std::string
Wattsup::Impl::getOutputFileName(
    const size_t meterId
) const
{
    std::stringstream ss;

    ss << mOutputDirectory << "/" << meterId << ".csv";

    return ss.str();
}

/*--------------------------------------------------------*/

int
Wattsup::Impl::start()
{
    struct stat st = {0};

    if (stat(mOutputDirectory.c_str(), &st) == -1)
    {
       Debug::Info(
          "Creating data directory %s.\n",
          mOutputDirectory.c_str());

       int rc = mkdir(mOutputDirectory.c_str(), mMode);
       if (rc == -1)
       {
           std::cerr << "Unable to create directory "
                     << mOutputDirectory
                     << ", check permissions"
                     << std::endl;
           return -1;
       }
    }

    /*
     * Always remove the lock files...
     */
    size_t nMeters = mPathsToMeters.size();
    if (mLockUSBFiles)
    {
       for (size_t meter = 0; meter < nMeters; meter++)
       {
           std::stringstream ss;
           ss << "/var/lock/LCK..ttyUSB" << meter;
           Debug::Info(
             "Removing lock file %s.\n",
             ss.str().c_str());
           remove(ss.str().c_str());
       }
    }

    Debug::Info(
        "Number of meters %zu.\n",
        nMeters);

    for (size_t meter = 0; meter < nMeters; meter++)
    {
        Debug::Info(
          "Launching meter %zu.\n",
          meter);

        mPids.push_back(fork());

        if (mPids[meter] < 0)
        {
           std::cerr << "HCL Internal Error..."
                     << "Unable to fork()..."
                     << std::endl;
           return -1;
        }

        if (mPids[meter] == 0)
        {
           Debug::Info(
              "Child process %d: opening file %s.\n",
              mPids[meter], getOutputFileName(meter).c_str());

           int fd = open(
                      getOutputFileName(meter).c_str(),
                      O_WRONLY | O_CREAT | O_TRUNC, mMode);

           if (fd == -1)
           {
              Debug::Error(
                 "Child process: %d, open(%s) failure...\n",
                 mPids[meter], getOutputFileName(meter).c_str());
           }

           dup2(fd, 1);
           close(fd);

           dup2(open("/dev/null", O_WRONLY), 2);

           int rc = execl(
                      mPathsToMeters[meter].c_str(),
                      mPathsToMeters[meter].c_str(),
                      mParams[meter].c_str(), NULL);

           if (rc == -1)
           {
              /*
               * Best situation is to remove the file...
               */
              remove(getOutputFileName(meter).c_str());
              Debug::Error(
                 "Child process: %d, execl() failure...\n",
                 mPids[meter]);
           }
        }
    }

    /*
     * In the parent process, we check if in each data file,
     * necessary header records have been written...
     */
    while (1)
    {
#pragma omp parallel num_threads(nMeters)
       {
#pragma omp for
       for (size_t meter = 0; meter < nMeters; meter++)
       {
          std::ifstream ifs(
                     getOutputFileName(meter),
                     std::ifstream::in);
                     
          std::string line;
          unsigned int nLines = 0;

          while (getline(ifs, line))
          {
             std::size_t errorFound = line.find("Error");
             if (errorFound != std::string::npos)
             {
                std::cerr << "Error from meter "
                          << meter
                          << ", Best option is to exit now..."
                          << std::endl;
                this->stop();
                exit(EXIT_FAILURE);
             }

             nLines++;
          }

          ifs.close();

          mMeterPreLines[meter] = nLines;
       }
       }

       bool allMeterHeadersWritten = true;
       for (size_t meter = 0; meter < nMeters; meter++)
       {
           if (!(mMeterPreLines[meter] > mNumHeaderLines))
           {
              allMeterHeadersWritten = false;
              break;
           }
       }

       if (allMeterHeadersWritten)
       {
          if (Debug::getVerbosity())
          {
             std::cout << "Number of lines in meters before measurement: ";
             for (size_t meter = 0; meter < nMeters; meter++)
             {
                std::cout << mMeterPreLines[meter] << " ";
             }
             std::cout << std::endl;
          }

          break;
       }

       /*
        * Nanosleep for 10 milliseconds...
        */
       struct timespec tim, tim2;
       tim.tv_sec = 0;
       tim.tv_nsec = 1e07;

       if (nanosleep(&tim, &tim2) < 0)
       {
          fprintf(
             stderr,
             "nanosleep issue...\n");
       }
    }

    return 0;
}

/*--------------------------------------------------------*/

int
Wattsup::Impl::stop()
{
    for (size_t pid = 0; pid < mPids.size(); pid++)
    {
       int status = kill(mPids[pid], SIGINT);
       if (status != 0)
       {
          return status;
       }
    }

    return 0;
}

/*--------------------------------------------------------*/

double
Wattsup::Impl::energy() const
{
    double energy = 0.0;
    
    for (size_t meter = 0; meter < mPathsToMeters.size(); meter++)
    {
        std::string fileName = getOutputFileName(meter);
        std::vector<double> tokens = parse(
                                        fileName, 
                                        mMeterPreLines[meter], mPowerCol);
        energy += computeEnergy(&tokens);
    }

    return energy;
}

/*--------------------------------------------------------*/

double
Wattsup::Impl::power() const
{
    double power = 0.0;
    
    for (size_t meter = 0; meter < mPathsToMeters.size(); meter++)
    {
        std::string fileName = getOutputFileName(meter);
        std::vector<double> tokens = parse(
                                        fileName, 
                                        mMeterPreLines[meter], mPowerCol);
        power += (std::accumulate(tokens.begin(), tokens.end(), 0.0))
                 / tokens.size();
        
    }

    return power;
}

/*--------------------------------------------------------*/

std::vector<double>
Wattsup::Impl::powers(
    const unsigned int meter
) const
{
    std::string fileName = getOutputFileName(meter);
    return parse(fileName, mMeterPreLines[meter], mPowerCol);
}

/*--------------------------------------------------------*/

int
Wattsup::Impl::gc()
{
    Debug::Info(
       "Cleaning up files for meters %zu.\n",
       mPathsToMeters.size());

    for (size_t meter = 0; meter < mPathsToMeters.size(); meter++)
    {
        std::string fileName = getOutputFileName(meter);
       
        Debug::Info(
          "Removing %s.\n",
          fileName.c_str());

        remove(fileName.c_str());
    }

    Debug::Info(
       "Removing directory %s.\n",
       mOutputDirectory.c_str());

    rmdir(mOutputDirectory.c_str());

    mPids.clear();

    return 0;
}

/*--------------------------------------------------------*/

}

/*--------------------------------------------------------*/

#include "wattsupprecision.cpp"

/*--------------------------------------------------------*/