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

Search this page:

PCMCPU.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/PCMCPU.h"

namespace ParCompMark
{

  //
  // Constructors & destructor
  //

  CPU::CPU(const std::string & name, const OutputNode::NodeType & type):
        // Parent constructor call 
  OutputNode(name               /* Name of the node */
           , type               /* Type of the node */
        )
        // You have to initialize the following attributes:
        // - mVendor
        // - mModel
        // - mClock
        // - mCache
        // - mBogomips
        // - mFlags
  {

        mVendor = "";
        mModel = "";
        mClock = 0.0;
        mCache = 0;
        mBogomips = 0.0;
        mFlags = "";

  }

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

  CPU::~CPU()
  {
  }

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

  //
  // Class methods
  //

  CPU::Pointer CPU::parseXML(TiXmlElement * &tiCPU)
  {

        //namespace of current cpu
        std::string cpuNamespace;

        //name of current cpu
        std::string cpuName;

        //set value of current cpu name and namespace
        std::string cpuTag(tiCPU->Value());
        std::string::size_type pos = cpuTag.find_first_of(":");
        if(pos != std::string::npos)
        {
         cpuNamespace = cpuTag.substr(0, pos);
         cpuName = cpuTag.substr(pos + 1);
        } else
        {
         cpuNamespace = "info";
         cpuName = "NoNameCPU";
        }

        OutputNode::NodeType nspace;

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

        //make a pointer to a newly created cpu with the use of cpu name and namespace
        CPU::Pointer myCPU = CPU::Pointer(new CPU(cpuName, nspace));

        TiXmlElement *tiParam = tiCPU->FirstChildElement();

        //saving cpu parameters
        for(; tiParam != NULL; tiParam = tiParam->NextSiblingElement())
        {
         std::string name(tiParam->Attribute("name"));
         std::string value(tiParam->Attribute("value"));

         if(name == "vendor-id")
         {
                myCPU->mVendor = value;
         } else if(name == "model-name")
         {
                myCPU->mModel = value;
         } else if(name == "cpu-mhz")
         {
                std::stringstream strStream;
                double dNum;

                strStream << value;
                strStream >> dNum;

                myCPU->mClock = dNum;
         } else if(name == "bogomips")
         {
                std::stringstream strStream;
                double dNum;

                strStream << value;
                strStream >> dNum;

                myCPU->mBogomips = dNum;
         } else if(name == "flags")
                myCPU->mFlags = value;
         else if(name == "cache-size")
         {
                std::stringstream strStream;
                int iNum;

                strStream << value;
                strStream >> iNum;

                myCPU->mCache = iNum;
         }
        }

        return CPU::Pointer(myCPU);
  }

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

  //
  // Methods
  //

  void CPU::refreshData()
  {

  }

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

}

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