GPUInfos Module::discoverGPUs( FilterPtr filter )
{
GPUInfos result;
for( Module* module = stack_; module; module = module->impl_->next_ )
{
const GPUInfos infos = module->discoverGPUs_();
for( GPUInfosCIter i = infos.begin(); i != infos.end(); ++i )
{
const GPUInfo& info = *i;
if( !filter || (*filter)( result, info ))
result.push_back( info );
}
}
return result;
}
GPUInfos Module::discover() const
{
GPUInfos result;
GPUInfo defaultInfo( "GLX" );
const char* displayEnv = getenv( "DISPLAY" );
if( displayEnv && displayEnv[0] != '\0' )
{
const std::string display( displayEnv );
if( queryDisplay_( display, defaultInfo ))
{
defaultInfo.flags = GPUInfo::FLAG_DEFAULT;
result.push_back( defaultInfo );
#ifdef __APPLE__
// OS X only has one X server, but launchd magic makes duplicate
// detection hard
return result;
#endif
}
}
// try x servers :0 - :n
for( unsigned i = 0; i < std::numeric_limits< unsigned >::max() ; ++i )
// x screens :n.0 - :n.m
for( unsigned j = 0; j < std::numeric_limits< unsigned >::max(); ++j )
{
std::stringstream stream;
stream << ':' << i << '.' << j;
GPUInfo info( "GLX" );
if( queryDisplay_( stream.str(), info ))
{
if( info != defaultInfo )
result.push_back( info );
}
else if( j == 0 && i > TRY_PORTS )
// X Server does not exist, stop query
return result;
else // X Screen does not exist, try next server
break;
}
return result;
}
GPUInfos Module::discover() const
{
GPUInfos result;
GPUInfo defaultInfo( "GLX" );
const char* displayEnv = getenv( "DISPLAY" );
if( displayEnv && displayEnv[0] != '\0' )
{
const std::string display( displayEnv );
if( queryDisplay_( display, defaultInfo ))
{
if( display[0] != ':' && display[0] != '/' /* OS X launchd */ )
{
defaultInfo.port = GPUInfo::defaultValue;
defaultInfo.device = GPUInfo::defaultValue;
}
result.push_back( defaultInfo );
}
}
// try x servers :0 - :n
for( unsigned i = 0; i < std::numeric_limits< unsigned >::max() ; ++i )
// x screens :n.0 - :n.m
for( unsigned j = 0; j < std::numeric_limits< unsigned >::max(); ++j )
{
std::stringstream stream;
stream << ':' << i << '.' << j;
GPUInfo info( "GLX" );
if( queryDisplay_( stream.str(), info ))
{
if( info != defaultInfo )
result.push_back( info );
}
else if( j == 0 && i >= TRY_PORTS )
// X Server does not exist, stop query
return result;
else // X Screen does not exist, try next server
break;
}
return result;
}
static void setKeys( lunchbox::Servus& service, const GPUInfos& gpus,
const std::string& session, const std::string& hostname )
{
service.set( "Session", session );
service.set( "Hostname", hostname );
std::ostringstream out;
out << gpus.size();
service.set( "GPU Count", out.str( ));
for( GPUInfos::const_iterator i = gpus.begin(); i != gpus.end(); ++i )
{
const GPUInfo& info = *i;
const size_t index = i - gpus.begin();
// GPU<integer> Type=GLX | WGL | WGLn | CGL
out.str("");
out << "GPU" << index << " Type";
service.set( out.str(), info.getName( ));
if( info.port != GPUInfo::defaultValue )
// GPU<integer> Port=<integer> // X11 display number, 0 otherwise
setKey( service, index, "Port", info.port );
if( info.device != GPUInfo::defaultValue )
// GPU<integer> Device=<integer> // X11 display number, 0 otherwise
setKey( service, index, "Device", info.device );
if( info.pvp[2] > 0 && info.pvp[3] > 0 )
{
setKey( service, index, "X", info.pvp[0] );
setKey( service, index, "Y", info.pvp[1] );
setKey( service, index, "Width", info.pvp[2] );
setKey( service, index, "Height", info.pvp[3] );
}
if( info.flags != 0 )
setKey( service, index, "Flags", info.flags );
}
}
int main (int argc, char * argv[])
{
std::string session( "default" );
std::string hostname;
#ifdef GPUSD_USE_BOOST
arg::variables_map vm;
arg::options_description desc("GPU service discovery daemon");
desc.add_options()
("help", "output this help message")
("session,s", arg::value< std::string >(), "set session name")
("hostname,h", arg::value< std::string >(), "set hostname")
("daemon,d", "run as daemon")
("width", arg::value< int >(), "maximum width to report")
("height", arg::value< int >(), "maximum width to report");
try
{
arg::store( arg::parse_command_line( argc, argv, desc ), vm );
arg::notify( vm );
}
catch(...)
{
std::cout << desc << std::endl;
return EXIT_SUCCESS;
}
if( vm.count( "help" ))
{
std::cout << desc << std::endl;
return EXIT_SUCCESS;
}
if( vm.count( "session" ))
session = vm["session"].as< std::string >();
if( vm.count( "hostname" ))
hostname = vm["hostname"].as< std::string >();
const bool daemon = vm.count( "daemon" ) > 0;
#else
if( argc > 1 )
std::cerr << "Ignoring command line options, compiled without "
<< "boost::program_options support" << std::endl;
const bool daemon = false;
#endif
#ifdef GPUSD_CGL
gpusd::cgl::Module::use();
#endif
#ifdef GPUSD_GLX
gpusd::glx::Module::use();
#endif
#ifdef GPUSD_WGL
gpusd::wgl::Module::use();
#endif
GPUInfos gpus = gpusd::Module::discoverGPUs();
if( gpus.empty( ))
{
std::cerr << "No GPUs found, quitting" << std::endl;
return EXIT_FAILURE;
}
if( vm.count( "width" ) )
{
const int width = vm["width"].as< int >();
if( width > 0 )
{
for( GPUInfos::iterator gpu = gpus.begin();
gpu != gpus.end(); ++gpu )
gpu->pvp[2] = std::min( gpu->pvp[2], width );
}
else
{
std::cerr << "Ignoring negative width" << std::endl;
}
}
if( vm.count( "height" ) )
{
const int height = vm["height"].as< int >();
if( height > 0 )
{
for( GPUInfos::iterator gpu = gpus.begin();
gpu != gpus.end(); ++gpu )
gpu->pvp[3] = std::min( gpu->pvp[3], height );
}
else
{
std::cerr << "Ignoring negative height" << std::endl;
}
}
lunchbox::Servus service( "_gpu-sd._tcp" );
setKeys( service, gpus, session, hostname );
if( !service.announce( 4242, "" ))
{
std::cerr << "Service announcement failed" << std::endl;
return EXIT_FAILURE;
}
if( daemon )
{
#if LUNCHBOX_VERSION_GT(1, 5, 0)
if( lunchbox::Log::setOutput( "gpusd.log" ))
lunchbox::daemonize();
#else
LBWARN << "Ignoring daemon request, need Lunchbox >= 1.5.1, got "
<< lunchbox::Version::getString() << std::endl;
#endif
for( ;; )
lunchbox::sleep( 0xFFFFFFFFu );
}
std::cout << "Press <Enter> to quit" << std::endl;
getchar();
return EXIT_SUCCESS;
}
