gpuInfo.h

/* Copyright (c) 2011-2012, Stefan Eilemann <eile@eyescale.ch> 
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *  
 * This library 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 Lesser General Public License for more
 * details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef GPUSD_GPUINFO_H
#define GPUSD_GPUINFO_H

#include <climits>
#include <cstring>
#include <iostream>
#include <string>

namespace gpusd
{
    struct GPUInfo
    {
        static const unsigned defaultValue = UINT_MAX;

        static const unsigned FLAG_VIRTUALGL = 0x1;

        static const unsigned FLAG_VIRTUALGL_DISPLAY = 0x2;

        GPUInfo()
                : type( 0 ), port( defaultValue ), device( defaultValue )
                , session( "local" ), flags( 0 )
            { invalidatePVP(); }

        GPUInfo( const std::string& name )
                : type( 0 ), port( defaultValue ), device( defaultValue )
                , session( "local" ), flags( 0 )
            {
                invalidatePVP();
                strncpy( reinterpret_cast< char* >( &type ), name.c_str(), 4 );
            }

        void invalidatePVP()
            {
                pvp[0] = 0;
                pvp[1] = 0;
                pvp[2] = -1;
                pvp[3] = -1;
            }

        bool operator == ( const GPUInfo& rhs ) const 
            { 
                return ( type == rhs.type && hostname == rhs.hostname &&
                         session == rhs.session && port == rhs.port &&
                         device == rhs.device &&
                         pvp[0] == rhs.pvp[0] && pvp[1] == rhs.pvp[1] &&
                         pvp[2] == rhs.pvp[2] && pvp[3] == rhs.pvp[3] );
            }

        bool operator != ( const GPUInfo& rhs ) const 
            { 
                return !(*this == rhs );
            }

        std::string getName() const
            { return std::string( reinterpret_cast<const char*>( &type ), 4 ); }

        unsigned type;

        unsigned port;

        unsigned device;

        int pvp[4];

        std::string hostname; 
        std::string session; 

        unsigned flags; 
        unsigned unused; 
        char dummy[24]; 
    };

    inline std::ostream& operator << ( std::ostream& os, const GPUInfo& info )
    {
        if( !info.getName().empty( ))
            os << "type     " << info.getName() << std::endl;
        if( !info.hostname.empty( ))
            os << "hostname " << info.hostname << std::endl;
        if( !info.session.empty() && info.session != "local" )
            os << "session  " << info.session << std::endl;
        if( info.port != GPUInfo::defaultValue )
            os << "port     " << info.port << std::endl;
        if( info.device != GPUInfo::defaultValue )
            os << "device   " << info.device << std::endl;
        if( info.pvp[2] >0 && info.pvp[3] > 0 )
            os << "viewport [" << info.pvp[0] << ' ' << info.pvp[1] << ' '
               << info.pvp[2] << ' ' << info.pvp[3] << ']' << std::endl;
        if( info.flags != 0 )
            os << "flags    "
               << (info.flags&GPUInfo::FLAG_VIRTUALGL ? "VirtualGL" : "")
               << (info.flags&GPUInfo::FLAG_VIRTUALGL_DISPLAY ? "Display" : "")
               << std::endl;
        return os;
    }
}
#endif // GPUSD_GPUINFO_H