• Main
• Home
• Features
• Screenshots
• Downloads
• License
• Team profile
• Documentation
• Manual
• FAQ
• Reference

Search this page:

PCMHostInfo.cpp

Go to the documentation of this file.

//
// This source file is a part of ParCompMark
// Parallel Compositing Benchmark Framework
//
// for latest info see http://parcompmark.sourceforge.net

//
// Copyright (C) 2006 IT2 ParCompMark Dev. Team
// 
// 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.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

//
// Inner includes
//

#include "../include/PCMHostInfo.h"

#include "../include/PCMHost.h"

namespace ParCompMark
{

  //
  // Constructors & destructor
  //

  HostInfo::HostInfo(const std::string & name, const OutputNode::NodeType & type):
        // Parent initialize 
  OutputNode(name               /* Name of the host */
           , type               /* Type of the host node */
        )
        // You have to initialize the following attributes:
        // - mCPUs
        // - mGPUs
        // - mNetIDNames
        // - mPCLibVersion
        // - mPCNumNetworks
        // - mPCVendor
        // - mPCExtensions
        // - mVolatileFrameletLimit
        // - mRetainOutputLimit
  {

        setAttribute("name", name);

        //Create CPUs
        mCPUs = new Container < CPU, Mutex >;

        //Create GPUs
        mGPUs = new Container < GPU, Mutex >;

        mNetIDNames = new Container < HostInfo::NetIDName, DummyLock >;

        mPCLibVersion = "";
        mPCNumNetworks = 0;
        mPCVendor = "";
        mPCExtensions = "";
        mVolatileFrameletLimit = 0;
        mRetainOutputLimit = 0;

  }

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

  HostInfo::~HostInfo()
  {
        if(mCPUs.isNotNull())
         mCPUs.kill();

        if(mGPUs.isNotNull())
         mGPUs.kill();

        if(mNetIDNames.isNotNull())
         mNetIDNames.kill();
  }

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

  //
  // Class methods
  //

  HostInfo::Pointer HostInfo::parseXML(TiXmlElement * &tiHostinfo)
  {
        std::string hostNamespace;
        std::string hostName;

        //string separation
        std::string hostTag(tiHostinfo->Value());
        std::string::size_type pos = hostTag.find(":");
        if(pos != std::string::npos)
        {
         hostNamespace = hostTag.substr(0, pos);
         hostName = hostTag.substr(pos + 1);
        } else
        {
         hostNamespace = "info";
         hostName = "NoNameHOSTINFO";
        }

        OutputNode::NodeType nspace;

        if(hostNamespace == "def")
         nspace = OutputNode::DEFINITION;
        else if(hostNamespace == "info")
         nspace = OutputNode::INFORMATION;
        else if(hostNamespace == "ref")
         nspace = OutputNode::REFERENCE;
        else if(hostNamespace == "stat")
         nspace = OutputNode::STATISTICS;
        else
         nspace = OutputNode::INFORMATION;

        HostInfo::Pointer myHostInfo = HostInfo::Pointer(new HostInfo(hostName, nspace));

        //First parameter belonging to HostInfo
        TiXmlElement *tiParam = tiHostinfo->FirstChildElement();

        //save current HostInfo information to class variables
        for(; tiParam != NULL; tiParam = tiParam->NextSiblingElement())
        {

         //current parameter name
         std::string name = "";

         //current parameter value
         std::string value = "";

         //current tag value
         std::string tagName = "";

         //get name and value parameters from current xml element
         if((tiParam->Attribute("name") != NULL) && (tiParam->Attribute("value") != NULL))
         {
                name = tiParam->Attribute("name");
                value = tiParam->Attribute("value");
         }
         //get value of current xml element
         if(tiParam->Value() != NULL)
         {
                tagName = tiParam->Value();
         }

         if(name.compare("pc-library-version") == 0)
         {
                myHostInfo->mPCLibVersion = value;
         } else if(tagName.find("network-ids-names") != std::string::npos)
         {

                TiXmlElement *tiNetworkIdNames = tiParam->FirstChildElement();

                for(; tiNetworkIdNames != NULL; tiNetworkIdNames = tiNetworkIdNames->NextSiblingElement())
                {

                 std::string networkId = tiNetworkIdNames->Attribute("id");
                 std::string networkName = tiNetworkIdNames->Attribute("name");

                 std::stringstream strStream;
                 PCint iNum;

                 strStream << networkId;
                 strStream >> iNum;

                 HostInfo::NetIDName::Pointer myNetIDName = HostInfo::NetIDName::Pointer(new HostInfo::NetIDName());

                 myNetIDName->ID = iNum;
                 myNetIDName->name = networkName;

                 myHostInfo->mNetIDNames->add(myNetIDName->name, myNetIDName);

                }

         } else if(name.compare("pc-vendor") == 0)
         {
                myHostInfo->mPCVendor = value;
         } else if(name.compare("pc-extensions") == 0)
         {
                myHostInfo->mPCExtensions = value;
         } else if(name.compare("pc-number-networks") == 0)
         {
                std::stringstream strStream;
                int iNum;

                strStream << value;
                strStream >> iNum;

                myHostInfo->mPCNumNetworks = iNum;
         } else if(name.compare("pc-volatile-framelet-limit") == 0)
         {
                std::stringstream strStream;
                int iNum;

                strStream << value;
                strStream >> iNum;

                myHostInfo->mVolatileFrameletLimit = iNum;
         } else if(name.compare("pc-retain-ouput-limit") == 0)
         {
                std::stringstream strStream;
                int iNum;

                strStream << value;
                strStream >> iNum;

                myHostInfo->mRetainOutputLimit = iNum;
         } else if(tagName.find("CPUs") != std::string::npos)
         {

                TiXmlElement *tiCPU = tiParam->FirstChildElement();

                for(; tiCPU != NULL; tiCPU = tiCPU->NextSiblingElement())
                {

                 CPU::Pointer currentCPU = CPU::parseXML(tiCPU);

                 if(currentCPU.isNotNull())
                 {
                        myHostInfo->mCPUs->add(currentCPU->getName(), currentCPU);
                 }

                }
         } else if(tagName.find("GPUs") != std::string::npos)
         {
                TiXmlElement *tiGPU = tiParam->FirstChildElement();

                for(; tiGPU != NULL; tiGPU = tiGPU->NextSiblingElement())
                {

                 GPU::Pointer currentGPU = GPU::parseXML(tiGPU);

                 if(currentGPU.isNotNull())
                 {
                        myHostInfo->mGPUs->add(currentGPU->getName(), currentGPU);
                 }

                }
         }

        }

        return HostInfo::Pointer(myHostInfo);
  }

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

  //
  // Methods
  //

  void HostInfo::refreshData()
  {

        PCerr err;

        OutputNode::Pointer p;

        char c[256];
        PCstring strValue;
        PCint intValue;

        if((err = pcSystemGetInteger(PC_NUM_NETWORKS, 0, &intValue)))
        {
         Except(INTERNAL_ERROR, "HostInfo::refreshData()", pcGetErrorString(err));
        }

        mPCNumNetworks = intValue;
        sprintf(c, "%d", intValue);
        p = createChildNode("param", OutputNode::INFORMATION);
        p->setAttribute("name", "pc-number-networks");
        p->setAttribute("value", c);

        OutputNode::Pointer net = createChildNode("network-ids-names", OutputNode::INFORMATION);

        for(int i = 0; i < mPCNumNetworks; i++)
        {

         if((err = pcSystemGetInteger(PC_NETWORK_ID, i, &intValue)))
         {
                Except(INTERNAL_ERROR, "HostInfo::refreshData()", pcGetErrorString(err));
         }

         if((err = pcSystemGetString(PC_NETWORK_NAME, i, &strValue)))
         {
                Except(INTERNAL_ERROR, "HostInfo::refreshData()", pcGetErrorString(err));
         }

         NetIDName::Pointer n = NetIDName::Pointer(new NetIDName);

         n->ID = intValue;
         n->name = strValue;

         mNetIDNames->add(strValue, n);

         sprintf(c, "%d", intValue);
         std::string s1, s2;
         s1 = c;
         s2 = strValue;
         p = net->createChildNode("network-id-name", OutputNode::INFORMATION);
         p->setAttribute("name", s2);
         p->setAttribute("id", s1);
        }

        if((err = pcSystemGetString(PC_VENDOR, 0, &strValue)))
        {
         Except(INTERNAL_ERROR, "HostInfo::refreshData()", pcGetErrorString(err));
        }

        mPCVendor = strValue;
        p = createChildNode("param", OutputNode::INFORMATION);
        p->setAttribute("name", "pc-vendor");
        p->setAttribute("value", strValue);

        if((err = pcSystemGetString(PC_EXTENSIONS, 0, &strValue)))
        {
         Except(INTERNAL_ERROR, "HostInfo::refreshData()", pcGetErrorString(err));
        }
        mPCExtensions = strValue;
        p = createChildNode("param", OutputNode::INFORMATION);
        p->setAttribute("name", "pc-extensions");
        p->setAttribute("value", strValue);

        if((err = pcSystemGetInteger(PC_VOLATILE_FRAMELET_LIMIT, 0, &intValue)))
        {
         Except(INTERNAL_ERROR, "HostInfo::refreshData()", pcGetErrorString(err));
        }

        mVolatileFrameletLimit = intValue;
        sprintf(c, "%d", intValue);
        p = createChildNode("param", OutputNode::INFORMATION);
        p->setAttribute("name", "pc-volatile-framelet-limit");
        p->setAttribute("value", c);

        if((err = pcSystemGetInteger(PC_RETAIN_OUTPUT_LIMIT, 0, &intValue)))
        {
         Except(INTERNAL_ERROR, "HostInfo::refreshData()", pcGetErrorString(err));
        }

        mRetainOutputLimit = intValue;
        sprintf(c, "%d", intValue);
        p = createChildNode("param", OutputNode::INFORMATION);
        p->setAttribute("name", "pc-retain-ouput-limit");
        p->setAttribute("value", c);
        /*
         * if(PCerr err = pcSessionDestroy() != PC_NO_ERROR)
         * Except(INTERNAL_ERROR, "HostInfo::refreshData()", pcGetErrorString(err));
         *///mHostInfo->serialize2XML();

        OutputNode::Pointer cpus = createChildNode("CPUs", OutputNode::INFORMATION);
        refreshCPUs(cpus);
        OutputNode::Pointer gpus = createChildNode("GPUs", OutputNode::INFORMATION);
        refreshGPUs(gpus);

  }

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

  void HostInfo::refreshCPUs(OutputNode::Pointer & cpus)
  {

        char c;
        char type[256],
        value[256];
        int i = 0;

        CPU::Pointer cpu;

        //CPU *cpu;

        std::string str;

        bool t = true;

        FileSystemManager::CFilePointer f = FileSystemManager::getInstance()->openFileC("/proc/cpuinfo");

        while(!feof(f.getPtr()))
        {

         fread(&c, sizeof(char), 1, f.getPtr());

         if(c == ':' && i != 0)
         {
                type[i] = '\0';
                i = 0;
                fread(&c, sizeof(char), 1, f.getPtr());
                t = false;
         } else if((c == '\t'))
         {
                ;
         } else if((c == '\n' || c == ' ') && t)
         {
                ;
         }

         else if(c == '\n' && i != 0)
         {

                value[i] = '\0';
                //printf("type:|%s| value:|%s|\n", type, value);
                str = type;
                if(str == "vendor_id")
                {
                 cpu->setVendor(value);
                 OutputNode::Pointer p = cpu->createChildNode("param", OutputNode::INFORMATION);
                 p->setAttribute("name", "vendor-id");
                 p->setAttribute("value", value);
                } else if(str == "model name")
                {
                 cpu->setModel(value);
                 OutputNode::Pointer p = cpu->createChildNode("param", OutputNode::INFORMATION);
                 p->setAttribute("name", "model-name");
                 p->setAttribute("value", value);
                } else if(str == "cpu MHz")
                {
                 //TODO: not DOUBLE
                 Real clock;

                 sscanf(value, "%lf", &clock);
                 cpu->setClock(clock);
                 OutputNode::Pointer p = cpu->createChildNode("param", OutputNode::INFORMATION);
                 p->setAttribute("name", "cpu-mhz");
                 p->setAttribute("value", value);
                } else if(str == "cache size")
                {
                 u32 cache;

                 sscanf(value, "%d", &cache);
                 cpu->setCache(cache);
                 OutputNode::Pointer p = cpu->createChildNode("param", OutputNode::INFORMATION);
                 p->setAttribute("name", "cache-size");
                 p->setAttribute("value", value);
                } else if(str == "bogomips")
                {
                 //TODO: not DOUBLE
                 Real bogomips;

                 sscanf(value, "%lf", &bogomips);
                 cpu->setBogomips(bogomips);
                 OutputNode::Pointer p = cpu->createChildNode("param", OutputNode::INFORMATION);
                 p->setAttribute("name", "bogomips");
                 p->setAttribute("value", value);
                } else if(str == "flags")
                {
                 cpu->setFlags(value);
                 OutputNode::Pointer p = cpu->createChildNode("param", OutputNode::INFORMATION);
                 p->setAttribute("name", "flags");
                 p->setAttribute("value", value);
                } else if(str == "processor")
                {

                 cpu = new CPU("CPU", OutputNode::INFORMATION);
                 cpu->setAttribute("id", value);

                 mCPUs->add("CPU-" + std::string(value), cpu);

                 OutputNode::Pointer oCpu;
                 oCpu.reference(cpu.getPtr());
                 cpus->addChildNode(oCpu);

                }

                i = 0;

                t = true;
         } else
         {
                if(t)
                {
                 type[i++] = c;
                } else
                {
                 value[i++] = c;
                }

         }

        }
        FileSystemManager::getInstance()->closeFile(f);

  }

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

  void HostInfo::refreshGPUs(OutputNode::Pointer & gpus)
  {
        GPU::Pointer gpu;
        gpu = new GPU("GPU", OutputNode::INFORMATION);
        mGPUs->add("GPU", gpu);

        OutputNode::Pointer oGpu;
        oGpu.reference(gpu.getPtr());
        gpus->addChildNode(oGpu);

  }

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

}

© Copyright - 2006 (IT)² ParCompMark Dev. Team