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

Search this page:

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

namespace ParCompMark
{

  //
  // Constructors & destructor
  //

  GPU::GPU(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
        // - mMemorySize
        // - mLoadPerSecond
  {

        mVendor = "";
        mModel = "";
        mMemorySize = 0;
        mLoadPerSecond = 0.0;

  }

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

  GPU::~GPU()
  {
  }

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

  //
  // Class methods
  //

  GPU::Pointer GPU::parseXML(TiXmlElement * &tiGPU)
  {

        std::string gpuNamespace;
        std::string gpuName;

        std::string gpuTag(tiGPU->Value());
        std::string::size_type pos = gpuTag.find_first_of(":");
        if(pos != std::string::npos)
        {
         gpuNamespace = gpuTag.substr(0, pos);
         gpuName = gpuTag.substr(pos + 1);
        } else
        {
         gpuNamespace = "info";
         gpuName = "NoNameGPU";
        }

        OutputNode::NodeType nspace;

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

        GPU::Pointer myGPU = GPU::Pointer(new GPU(gpuName, nspace));

        TiXmlElement *tiParam = tiGPU->FirstChildElement();

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

         //TODO: store GPU information

        }

        return GPU::Pointer(myGPU);
  }

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

  //
  // Methods
  //

  void GPU::refreshData()
  {

        XDisplay::Pointer display(new XDisplay(""));

        display->initialize();

        int num = ScreenCount(display->getDisplay());

        OutputNode::Pointer p = createChildNode("screen-number", OutputNode::INFORMATION);

        p->setAttribute("screen-number", StringConverter::toString(num));

  }

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

}

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