Ravi / hclmxv · Files

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

/*
@file
@author Ravi Reddy Manumachu <ravi.manumachu@ucd.ie>
@version 1.0
*/

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

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <sstream>
#include <string>
#include <climits>
#include <vector>

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

namespace hcl {

namespace topology {

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

/*
 * One way to do this is to store the lines in a vector.
 * Parse top-to-bottom and bottom-to-top to get the siblings.
 */
int
getSibling(
   const unsigned int cpu,
   std::vector<unsigned int>& siblings
)
{
    FILE* commandFp = popen("lscpu -p", "r");
    if (commandFp == NULL)
    {
       std::cerr << "Error from execution of lscpu -p."
                 << std::endl;
       return -1;
    }

    char* line = NULL;
    size_t len = 0;
    std::vector<std::string> lscpuLines;

    while (getline(&line, &len, commandFp) != -1)
    {
       if (line[0] == '#')
       {
          continue;
       }

       lscpuLines.push_back(line);
    }

    free(line);

    int status = pclose(commandFp);
    if (status == -1)
    {
       std::cerr << "Error from execution of lscpu -p."
                 << std::endl;
       return -1;
    }

    bool siblingsFound = false;
    bool myCoreFound = false;
    unsigned int myCore = UINT_MAX;

    for (unsigned int cpuLine = 0;
         cpuLine < lscpuLines.size();
         cpuLine++)
    {
        std::stringstream cpuLineStream(lscpuLines[cpuLine]);
        std::string token;
        std::vector<std::string> tokens;
        while (std::getline(
                  cpuLineStream, token, ','
              )
        ) 
        {
            tokens.push_back(token);
        }

        unsigned int cpuParsed = atoi(tokens[0].c_str());

        if (cpu == cpuParsed)
        {
           myCore = atoi(tokens[1].c_str());
           myCoreFound = true;
        }
        else
        {
           unsigned int core = atoi(tokens[1].c_str());

           if (core == myCore)
           {
              siblings.push_back(
                 atoi(tokens[0].c_str())
              );
              siblingsFound = true;
           }
        }
    }

    if (myCoreFound == false)
    {
        std::cerr << "Failed to find siblings." << std::endl;
        return -1;
    }

    /*
     * If siblings are not found, then
     * it is possible that we have to traverse in the
     * reverse order to build the siblings.
     */
    if (siblingsFound)
    {
       return 0;
    }

    std::vector<std::string>::reverse_iterator rit = 
           lscpuLines.rbegin();

    for (; rit != lscpuLines.rend(); ++rit)
    {
        std::stringstream cpuLineStream(*rit);
        std::string token;
        std::vector<std::string> tokens;
        while (std::getline(
                  cpuLineStream, token, ','
              )
        ) 
        {
            tokens.push_back(token);
        }

        unsigned int cpuParsed = atoi(tokens[0].c_str());

        if (cpu == cpuParsed)
        {
           myCore = atoi(tokens[1].c_str());
        }
        else
        {
           unsigned int core = atoi(tokens[1].c_str());

           if (core == myCore)
           {
              siblings.push_back(
                 atoi(tokens[0].c_str())
              );
           }
        }
    }

    std::reverse(
       siblings.begin(), siblings.end());

    return 0;
}

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

int
getNumCpuNumaNodes(
   unsigned int* numNUMAs
)
{
    FILE* commandFp = popen("lscpu -p", "r");
    if (commandFp == NULL)
    {
       std::cerr << "Error from execution of lscpu -p."
                 << std::endl;
       return -1;
    }

    char* line = NULL;
    size_t len = 0;

    *numNUMAs = 0;

    while (getline(&line, &len, commandFp) != -1)
    {
       if (line[0] == '#')
       {
          continue;
       }

       char* token = strtok(line, ",");

       /*
        * The core...
        */
       if (token != NULL)
       {
          token = strtok(NULL, ",");
       }

       /*
        * The socket
        */
       if (token != NULL)
       {
          token = strtok(NULL, ",");
          unsigned int numaNodeParsed = atoi(token);
          if (numaNodeParsed > *numNUMAs)
          {
             *numNUMAs = numaNodeParsed;
          }
       }
    }

    free(line);

    int status = pclose(commandFp);
    if (status == -1)
    {
       std::cerr << "Error from execution of lscpu -p."
                 << std::endl;
       return -1;
    }

    *numNUMAs = *numNUMAs + 1;

    return 0;
}

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

int
getCpuNumaNode(
   const unsigned int cpu,
   unsigned int* numaNode
)
{
    FILE* commandFp = popen("lscpu -p", "r");
    if (commandFp == NULL)
    {
       std::cerr << "Error from execution of lscpu -p."
                 << std::endl;
       return -1;
    }

    char* line = NULL;
    size_t len = 0;

    while (getline(&line, &len, commandFp) != -1)
    {
       if (line[0] == '#')
       {
          continue;
       }

       char* token = strtok(line, ",");
       unsigned int cpuParsed = atoi(token);

       if (cpuParsed == cpu)
       {
          ;
       }
       else
       {
          continue;
       }

       /*
        * The core...
        */
       if (token != NULL)
       {
          token = strtok(NULL, ",");
       }

       /*
        * The socket
        */
       if (token != NULL)
       {
          token = strtok(NULL, ",");
          *numaNode = atoi(token);
          break;
       }
    }

    free(line);

    int status = pclose(commandFp);
    if (status == -1)
    {
       std::cerr << "Error from execution of lscpu -p."
                 << std::endl;
       return -1;
    }

    return 0;
}

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

int
getNumThreadsPerCore(
   unsigned int* numTPerCore
)
{
    FILE* commandFp = popen("lscpu -p", "r");
    if (commandFp == NULL)
    {
       std::cerr << "Error from execution of lscpu -p."
                 << std::endl;
       return -1;
    }

    char* line = NULL;
    size_t len = 0;

    *numTPerCore = 0;

    while (getline(&line, &len, commandFp) != -1)
    {
       if (line[0] == '#')
       {
          continue;
       }

       char* token = strtok(line, ",");

       /*
        * The core...
        */
       if (token != NULL)
       {
          token = strtok(NULL, ",");
          unsigned int coreParsed = atoi(token);

          /*
           * We will just count for core 0...
           */
          if (coreParsed == 0)
          {
             *numTPerCore = *numTPerCore + 1;
          }
       }
    }

    free(line);

    int status = pclose(commandFp);
    if (status == -1)
    {
       std::cerr << "Error from execution of lscpu -p."
                 << std::endl;
       return -1;
    }

    return 0;
}

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

int
getNumLogicalCpus(
   unsigned int* numCPUs
)
{
    FILE* commandFp = popen("lscpu -p", "r");
    if (commandFp == NULL)
    {
       std::cerr << "Error from execution of lscpu -p."
                 << std::endl;
       return -1;
    }

    char* line = NULL;
    size_t len = 0;

    *numCPUs = 0;

    while (getline(&line, &len, commandFp) != -1)
    {
       if (line[0] == '#')
       {
          continue;
       }

       *numCPUs = *numCPUs + 1;
    }

    free(line);

    int status = pclose(commandFp);
    if (status == -1)
    {
       std::cerr << "Error from execution of lscpu -p."
                 << std::endl;
       return -1;
    }

    return 0;
}

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

int
getNumPhysicalCpus(
   unsigned int* numPhysicalCPUs
)
{
    unsigned int numLogicalCpus;

    int rc = getNumLogicalCpus(
                       &numLogicalCpus
    );

    if (rc != 0)
    {
       return rc;
    }

    unsigned int threadsPerCore;

    rc = getNumThreadsPerCore(&threadsPerCore);

    if (rc != 0)
    {
       return rc;
    }

    *numPhysicalCPUs = numLogicalCpus / threadsPerCore;

    return 0;
}

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

int
getNumCpus(
   const unsigned int numaNode,
   unsigned int* numCPUs
)
{
    FILE* commandFp = popen("lscpu -p", "r");
    if (commandFp == NULL)
    {
       std::cerr << "Error from execution of lscpu -p."
                 << std::endl;
       return -1;
    }

    char* line = NULL;
    size_t len = 0;

    *numCPUs = 0;

    while (getline(&line, &len, commandFp) != -1)
    {
       if (line[0] == '#')
       {
          continue;
       }

       char* token = strtok(line, ",");

       /*
        * The core...
        */
       if (token != NULL)
       {
          token = strtok(NULL, ",");
       }

       /*
        * The socket
        */
       if (token != NULL)
       {
          token = strtok(NULL, ",");
          unsigned int numaNodeParsed = atoi(token);

          if (numaNodeParsed == numaNode)
          {
             *numCPUs = *numCPUs + 1;
          }
       }
    }

    free(line);

    int status = pclose(commandFp);
    if (status == -1)
    {
       std::cerr << "Error from execution of lscpu -p."
                 << std::endl;
       return -1;
    }

    return 0;
}

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

int
getCpus(
   const unsigned int numaNode,
   std::vector<unsigned int>& cpus
)
{
    FILE* commandFp = popen("lscpu -p", "r");
    if (commandFp == NULL)
    {
       std::cerr << "Error from execution of lscpu -p."
                 << std::endl;
       return -1;
    }

    char* line = NULL;
    size_t len = 0;

    while (getline(&line, &len, commandFp) != -1)
    {
       if (line[0] == '#')
       {
          continue;
       }

       char* token = strtok(line, ",");
       unsigned int cpuParsed = atoi(token);

       /*
        * The core...
        */
       if (token != NULL)
       {
          token = strtok(NULL, ",");
       }

       /*
        * The socket
        */
       if (token != NULL)
       {
          token = strtok(NULL, ",");
          unsigned int numaNodeParsed = atoi(token);

          if (numaNodeParsed == numaNode)
          {
             cpus.push_back(cpuParsed);
          }
       }
    }

    free(line);

    int status = pclose(commandFp);
    if (status == -1)
    {
       std::cerr << "Error from execution of lscpu -p."
                 << std::endl;
       return -1;
    }

    return 0;
}

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

}

}

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