void CudaModule::staticInit(void)
{
if (s_inited) {
return;
}
s_inited = true;
s_available = false;
checkError("cuInit", cuInit(0));
s_available = true;
s_device = selectDevice();
printDeviceInfo(s_device);
U32 flags = 0;
flags |= CU_CTX_SCHED_SPIN; // use sync() if you want to yield
#if (CUDA_VERSION >= 2030)
if (getDriverVersion() >= 23)
{
// reduce launch overhead with large localmem
flags |= CU_CTX_LMEM_RESIZE_TO_MAX;
}
#endif
// OpenGL & window context must have been initialized !
checkError("cuGLCtxCreate", cuGLCtxCreate( &s_context, flags, s_device));
checkError("cuEventCreate", cuEventCreate(&s_startEvent, 0));
checkError("cuEventCreate", cuEventCreate(&s_endEvent, 0));
}
VOID _cdecl main( ULONG argc, PCHAR argv[] )
{
char text[512] = {"Fourscore and seven years ago..."};
getDriverVersion(text, sizeof(text));
printf(text);
printf("\n");
HelloTest();
HelloNumTest();
DiagRDPMC();
}
void CudaModule::updateTexRefs(CUfunction kernel)
{
if (getDriverVersion() >= 32) {
return;
}
TexrefMap_t::iterator it;
for (it=m_texrefHash.begin(); it!=m_texrefHash.end(); ++it)
{
checkError("cuParamSetTexRef",
cuParamSetTexRef( kernel, CU_PARAM_TR_DEFAULT, it->second));
}
}
GpuCapabilitiesWindows::GraphicsDriverInformation GpuCapabilitiesWindows::getGraphicsDriverInformation() {
GraphicsDriverInformation driverInfo;
driverInfo.driverVersion = getDriverVersion();
if (driverInfo.driverVersion.versionString.length() == 0) {
driverInfo.driverVersion.d1 = 0;
driverInfo.driverVersion.d2 = 0;
driverInfo.driverVersion.d3 = 0;
driverInfo.driverVersion.d4 = 0;
driverInfo.driverVersion.version = 0;
}
driverInfo.driverDate = getDriverDate();
return driverInfo;
}
//-----------------------------------------------------------------------
void RenderSystemCapabilities::log(Log* pLog)
{
#if OGRE_PLATFORM != OGRE_PLATFORM_WINRT
pLog->logMessage("RenderSystem capabilities");
pLog->logMessage("-------------------------");
pLog->logMessage("RenderSystem Name: " + getRenderSystemName());
pLog->logMessage("GPU Vendor: " + vendorToString(getVendor()));
pLog->logMessage("Device Name: " + getDeviceName());
pLog->logMessage("Driver Version: " + getDriverVersion().toString());
pLog->logMessage(" * Fixed function pipeline: "
+ StringConverter::toString(hasCapability(RSC_FIXED_FUNCTION), true));
pLog->logMessage(
" * Hardware generation of mipmaps: "
+ StringConverter::toString(hasCapability(RSC_AUTOMIPMAP), true));
pLog->logMessage(
" * Texture blending: "
+ StringConverter::toString(hasCapability(RSC_BLENDING), true));
pLog->logMessage(
" * Anisotropic texture filtering: "
+ StringConverter::toString(hasCapability(RSC_ANISOTROPY), true));
pLog->logMessage(
" * Dot product texture operation: "
+ StringConverter::toString(hasCapability(RSC_DOT3), true));
pLog->logMessage(
" * Cube mapping: "
+ StringConverter::toString(hasCapability(RSC_CUBEMAPPING), true));
pLog->logMessage(
" * Hardware stencil buffer: "
+ StringConverter::toString(hasCapability(RSC_HWSTENCIL), true));
if (hasCapability(RSC_HWSTENCIL))
{
pLog->logMessage(
" - Stencil depth: "
+ StringConverter::toString(getStencilBufferBitDepth()));
pLog->logMessage(
" - Two sided stencil support: "
+ StringConverter::toString(hasCapability(RSC_TWO_SIDED_STENCIL), true));
pLog->logMessage(
" - Wrap stencil values: "
+ StringConverter::toString(hasCapability(RSC_STENCIL_WRAP), true));
}
pLog->logMessage(
" * Hardware vertex / index buffers: "
+ StringConverter::toString(hasCapability(RSC_VBO), true));
if(hasCapability(RSC_VBO))
{
pLog->logMessage(
" * 32-bit index buffers: "
+ StringConverter::toString(hasCapability(RSC_32BIT_INDEX), true));
}
pLog->logMessage(
" * Vertex programs: "
+ StringConverter::toString(hasCapability(RSC_VERTEX_PROGRAM), true));
pLog->logMessage(
" * Number of floating-point constants for vertex programs: "
+ StringConverter::toString(mVertexProgramConstantFloatCount));
pLog->logMessage(
" * Number of integer constants for vertex programs: "
+ StringConverter::toString(mVertexProgramConstantIntCount));
pLog->logMessage(
" * Number of boolean constants for vertex programs: "
+ StringConverter::toString(mVertexProgramConstantBoolCount));
pLog->logMessage(
" * Fragment programs: "
+ StringConverter::toString(hasCapability(RSC_FRAGMENT_PROGRAM), true));
pLog->logMessage(
" * Number of floating-point constants for fragment programs: "
+ StringConverter::toString(mFragmentProgramConstantFloatCount));
pLog->logMessage(
" * Number of integer constants for fragment programs: "
+ StringConverter::toString(mFragmentProgramConstantIntCount));
pLog->logMessage(
" * Number of boolean constants for fragment programs: "
+ StringConverter::toString(mFragmentProgramConstantBoolCount));
pLog->logMessage(
" * Geometry programs: "
+ StringConverter::toString(hasCapability(RSC_GEOMETRY_PROGRAM), true));
pLog->logMessage(
" * Number of floating-point constants for geometry programs: "
+ StringConverter::toString(mGeometryProgramConstantFloatCount));
pLog->logMessage(
" * Number of integer constants for geometry programs: "
+ StringConverter::toString(mGeometryProgramConstantIntCount));
pLog->logMessage(
" * Number of boolean constants for geometry programs: "
+ StringConverter::toString(mGeometryProgramConstantBoolCount));
pLog->logMessage(
" * Tessellation Hull programs: "
+ StringConverter::toString(hasCapability(RSC_TESSELLATION_HULL_PROGRAM), true));
pLog->logMessage(
" * Number of floating-point constants for tessellation hull programs: "
+ StringConverter::toString(mTessellationHullProgramConstantFloatCount));
pLog->logMessage(
" * Number of integer constants for tessellation hull programs: "
+ StringConverter::toString(mTessellationHullProgramConstantIntCount));
pLog->logMessage(
" * Number of boolean constants for tessellation hull programs: "
+ StringConverter::toString(mTessellationHullProgramConstantBoolCount));
pLog->logMessage(
" * Tessellation Domain programs: "
+ StringConverter::toString(hasCapability(RSC_TESSELLATION_DOMAIN_PROGRAM), true));
pLog->logMessage(
" * Number of floating-point constants for tessellation domain programs: "
+ StringConverter::toString(mTessellationDomainProgramConstantFloatCount));
pLog->logMessage(
" * Number of integer constants for tessellation domain programs: "
+ StringConverter::toString(mTessellationDomainProgramConstantIntCount));
pLog->logMessage(
" * Number of boolean constants for tessellation domain programs: "
+ StringConverter::toString(mTessellationDomainProgramConstantBoolCount));
pLog->logMessage(
" * Compute programs: "
+ StringConverter::toString(hasCapability(RSC_COMPUTE_PROGRAM), true));
pLog->logMessage(
" * Number of floating-point constants for compute programs: "
+ StringConverter::toString(mComputeProgramConstantFloatCount));
pLog->logMessage(
" * Number of integer constants for compute programs: "
+ StringConverter::toString(mComputeProgramConstantIntCount));
pLog->logMessage(
" * Number of boolean constants for compute programs: "
+ StringConverter::toString(mComputeProgramConstantBoolCount));
String profileList = "";
for(ShaderProfiles::iterator iter = mSupportedShaderProfiles.begin(), end = mSupportedShaderProfiles.end();
iter != end; ++iter)
{
profileList += " " + *iter;
}
pLog->logMessage(" * Supported Shader Profiles:" + profileList);
pLog->logMessage(
" * Texture Compression: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION), true));
if (hasCapability(RSC_TEXTURE_COMPRESSION))
{
pLog->logMessage(
" - DXT: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_DXT), true));
pLog->logMessage(
" - VTC: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_VTC), true));
pLog->logMessage(
" - PVRTC: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_PVRTC), true));
pLog->logMessage(
" - ATC: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_ATC), true));
pLog->logMessage(
" - ETC1: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_ETC1), true));
pLog->logMessage(
" - ETC2: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_ETC2), true));
pLog->logMessage(
" - BC4/BC5: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_BC4_BC5), true));
pLog->logMessage(
" - BC6H/BC7: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_BC6H_BC7), true));
}
pLog->logMessage(
" * Scissor Rectangle: "
+ StringConverter::toString(hasCapability(RSC_SCISSOR_TEST), true));
pLog->logMessage(
" * Hardware Occlusion Query: "
+ StringConverter::toString(hasCapability(RSC_HWOCCLUSION), true));
pLog->logMessage(
" * User clip planes: "
+ StringConverter::toString(hasCapability(RSC_USER_CLIP_PLANES), true));
pLog->logMessage(
" * VET_UBYTE4 vertex element type: "
+ StringConverter::toString(hasCapability(RSC_VERTEX_FORMAT_UBYTE4), true));
pLog->logMessage(
" * Infinite far plane projection: "
+ StringConverter::toString(hasCapability(RSC_INFINITE_FAR_PLANE), true));
pLog->logMessage(
" * Hardware render-to-texture: "
+ StringConverter::toString(hasCapability(RSC_HWRENDER_TO_TEXTURE), true));
pLog->logMessage(
" * Floating point textures: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_FLOAT), true));
pLog->logMessage(
" * Non-power-of-two textures: "
+ StringConverter::toString(hasCapability(RSC_NON_POWER_OF_2_TEXTURES), true)
+ (mNonPOW2TexturesLimited ? " (limited)" : ""));
pLog->logMessage(
" * 1d textures: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_1D), true));
pLog->logMessage(
" * Volume textures: "
+ StringConverter::toString(hasCapability(RSC_TEXTURE_3D), true));
pLog->logMessage(
" * Multiple Render Targets: "
+ StringConverter::toString(mNumMultiRenderTargets));
pLog->logMessage(
" - With different bit depths: " + StringConverter::toString(hasCapability(RSC_MRT_DIFFERENT_BIT_DEPTHS), true));
pLog->logMessage(
" * Point Sprites: "
+ StringConverter::toString(hasCapability(RSC_POINT_SPRITES), true));
pLog->logMessage(
" * Extended point parameters: "
+ StringConverter::toString(hasCapability(RSC_POINT_EXTENDED_PARAMETERS), true));
if(hasCapability(RSC_POINT_SPRITES))
{
pLog->logMessage(
" * Max Point Size: "
+ StringConverter::toString(mMaxPointSize));
}
pLog->logMessage(
" * Vertex texture fetch: "
+ StringConverter::toString(hasCapability(RSC_VERTEX_TEXTURE_FETCH), true));
pLog->logMessage(
" * Number of world matrices: "
+ StringConverter::toString(mNumWorldMatrices));
pLog->logMessage(
" * Number of texture units: "
+ StringConverter::toString(mNumTextureUnits));
pLog->logMessage(
" * Stencil buffer depth: "
+ StringConverter::toString(mStencilBufferBitDepth));
pLog->logMessage(
" * Number of vertex blend matrices: "
+ StringConverter::toString(mNumVertexBlendMatrices));
if (hasCapability(RSC_VERTEX_TEXTURE_FETCH))
{
pLog->logMessage(
" - Max vertex textures: "
+ StringConverter::toString(mNumVertexTextureUnits));
pLog->logMessage(
" - Vertex textures shared: "
+ StringConverter::toString(mVertexTextureUnitsShared, true));
}
pLog->logMessage(
" * Render to Vertex Buffer : "
+ StringConverter::toString(hasCapability(RSC_HWRENDER_TO_VERTEX_BUFFER), true));
pLog->logMessage(
" * Hardware Atomic Counters: "
+ StringConverter::toString(hasCapability(RSC_ATOMIC_COUNTERS), true));
if (mCategoryRelevant[CAPS_CATEGORY_GL])
{
pLog->logMessage(
" * GL 1.5 without VBO workaround: "
+ StringConverter::toString(hasCapability(RSC_GL1_5_NOVBO), true));
pLog->logMessage(
" * Frame Buffer objects: "
+ StringConverter::toString(hasCapability(RSC_FBO), true));
pLog->logMessage(
" * Frame Buffer objects (ARB extension): "
+ StringConverter::toString(hasCapability(RSC_FBO_ARB), true));
pLog->logMessage(
" * Frame Buffer objects (ATI extension): "
+ StringConverter::toString(hasCapability(RSC_FBO_ATI), true));
pLog->logMessage(
" * PBuffer support: "
+ StringConverter::toString(hasCapability(RSC_PBUFFER), true));
pLog->logMessage(
" * GL 1.5 without HW-occlusion workaround: "
+ StringConverter::toString(hasCapability(RSC_GL1_5_NOHWOCCLUSION), true));
pLog->logMessage(
" * Vertex Array Objects: "
+ StringConverter::toString(hasCapability(RSC_VAO), true));
pLog->logMessage(
" * Separate shader objects: "
+ StringConverter::toString(hasCapability(RSC_SEPARATE_SHADER_OBJECTS), true));
}
if (mCategoryRelevant[CAPS_CATEGORY_D3D9])
{
pLog->logMessage(
" * DirectX per stage constants: "
+ StringConverter::toString(hasCapability(RSC_PERSTAGECONSTANT), true));
}
#endif
}
egl::Error DisplayGLX::initialize(egl::Display *display)
{
mEGLDisplay = display;
mXDisplay = display->getNativeDisplayId();
const auto &attribMap = display->getAttributeMap();
// ANGLE_platform_angle allows the creation of a default display
// using EGL_DEFAULT_DISPLAY (= nullptr). In this case just open
// the display specified by the DISPLAY environment variable.
if (mXDisplay == EGL_DEFAULT_DISPLAY)
{
mUsesNewXDisplay = true;
mXDisplay = XOpenDisplay(NULL);
if (!mXDisplay)
{
return egl::Error(EGL_NOT_INITIALIZED, "Could not open the default X display.");
}
}
std::string glxInitError;
if (!mGLX.initialize(mXDisplay, DefaultScreen(mXDisplay), &glxInitError))
{
return egl::Error(EGL_NOT_INITIALIZED, glxInitError.c_str());
}
mHasMultisample = mGLX.minorVersion > 3 || mGLX.hasExtension("GLX_ARB_multisample");
mHasARBCreateContext = mGLX.hasExtension("GLX_ARB_create_context");
mHasARBCreateContextProfile = mGLX.hasExtension("GLX_ARB_create_context_profile");
mHasEXTCreateContextES2Profile = mGLX.hasExtension("GLX_EXT_create_context_es2_profile");
// Choose the swap_control extension to use, if any.
// The EXT version is better as it allows glXSwapInterval to be called per
// window, while we'll potentially need to change the swap interval on each
// swap buffers when using the SGI or MESA versions.
if (mGLX.hasExtension("GLX_EXT_swap_control"))
{
mSwapControl = SwapControl::EXT;
// In GLX_EXT_swap_control querying these is done on a GLXWindow so we just
// set default values.
mMinSwapInterval = 0;
mMaxSwapInterval = 4;
}
else if (mGLX.hasExtension("GLX_MESA_swap_control"))
{
// If we have the Mesa or SGI extension, assume that you can at least set
// a swap interval of 0 or 1.
mSwapControl = SwapControl::Mesa;
mMinSwapInterval = 0;
mMinSwapInterval = 1;
}
else if (mGLX.hasExtension("GLX_SGI_swap_control"))
{
mSwapControl = SwapControl::SGI;
mMinSwapInterval = 0;
mMinSwapInterval = 1;
}
else
{
mSwapControl = SwapControl::Absent;
mMinSwapInterval = 1;
mMinSwapInterval = 1;
}
if (attribMap.contains(EGL_X11_VISUAL_ID_ANGLE))
{
mRequestedVisual = static_cast<EGLint>(attribMap.get(EGL_X11_VISUAL_ID_ANGLE, -1));
// There is no direct way to get the GLXFBConfig matching an X11 visual ID
// so we have to iterate over all the GLXFBConfigs to find the right one.
int nConfigs;
int attribList[] = {
None,
};
glx::FBConfig *allConfigs = mGLX.chooseFBConfig(attribList, &nConfigs);
for (int i = 0; i < nConfigs; ++i)
{
if (getGLXFBConfigAttrib(allConfigs[i], GLX_VISUAL_ID) == mRequestedVisual)
{
mContextConfig = allConfigs[i];
break;
}
}
XFree(allConfigs);
if (mContextConfig == nullptr)
{
return egl::Error(EGL_NOT_INITIALIZED, "Invalid visual ID requested.");
}
}
else
{
// When glXMakeCurrent is called, the context and the surface must be
// compatible which in glX-speak means that their config have the same
// color buffer type, are both RGBA or ColorIndex, and their buffers have
// the same depth, if they exist.
// Since our whole EGL implementation is backed by only one GL context, this
// context must be compatible with all the GLXFBConfig corresponding to the
// EGLconfigs that we will be exposing.
int nConfigs;
int attribList[] =
{
// We want RGBA8 and DEPTH24_STENCIL8
GLX_RED_SIZE, 8,
GLX_GREEN_SIZE, 8,
GLX_BLUE_SIZE, 8,
GLX_ALPHA_SIZE, 8,
GLX_DEPTH_SIZE, 24,
GLX_STENCIL_SIZE, 8,
// We want RGBA rendering (vs COLOR_INDEX) and doublebuffer
GLX_RENDER_TYPE, GLX_RGBA_BIT,
// Double buffer is not strictly required as a non-doublebuffer
// context can work with a doublebuffered surface, but it still
// flickers and all applications want doublebuffer anyway.
GLX_DOUBLEBUFFER, True,
// All of these must be supported for full EGL support
GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT | GLX_PBUFFER_BIT | GLX_PIXMAP_BIT,
// This makes sure the config have an associated visual Id
GLX_X_RENDERABLE, True,
GLX_CONFIG_CAVEAT, GLX_NONE,
None
};
glx::FBConfig *candidates = mGLX.chooseFBConfig(attribList, &nConfigs);
if (nConfigs == 0)
{
XFree(candidates);
return egl::Error(EGL_NOT_INITIALIZED, "Could not find a decent GLX FBConfig to create the context.");
}
mContextConfig = candidates[0];
XFree(candidates);
}
const auto &eglAttributes = display->getAttributeMap();
if (mHasARBCreateContext)
{
egl::Error error = initializeContext(mContextConfig, eglAttributes, &mContext);
if (error.isError())
{
return error;
}
}
else
{
if (eglAttributes.get(EGL_PLATFORM_ANGLE_TYPE_ANGLE,
EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE) ==
EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE)
{
return egl::Error(EGL_NOT_INITIALIZED,
"Cannot create an OpenGL ES platform on GLX without the "
"GLX_ARB_create_context extension.");
}
XVisualInfo visualTemplate;
visualTemplate.visualid = getGLXFBConfigAttrib(mContextConfig, GLX_VISUAL_ID);
int numVisuals = 0;
XVisualInfo *visuals =
XGetVisualInfo(mXDisplay, VisualIDMask, &visualTemplate, &numVisuals);
if (numVisuals <= 0)
{
return egl::Error(EGL_NOT_INITIALIZED,
"Could not get the visual info from the fb config");
}
ASSERT(numVisuals == 1);
mContext = mGLX.createContext(&visuals[0], nullptr, true);
XFree(visuals);
if (!mContext)
{
return egl::Error(EGL_NOT_INITIALIZED, "Could not create GL context.");
}
}
ASSERT(mContext);
// FunctionsGL and DisplayGL need to make a few GL calls, for example to
// query the version of the context so we need to make the context current.
// glXMakeCurrent requires a GLXDrawable so we create a temporary Pbuffer
// (of size 1, 1) for the duration of these calls.
// Ideally we would want to unset the current context and destroy the pbuffer
// before going back to the application but this is TODO
// We could use a pbuffer of size (0, 0) but it fails on the Intel Mesa driver
// as commented on https://bugs.freedesktop.org/show_bug.cgi?id=38869 so we
// use (1, 1) instead.
int dummyPbufferAttribs[] =
{
GLX_PBUFFER_WIDTH, 1,
GLX_PBUFFER_HEIGHT, 1,
None,
};
mDummyPbuffer = mGLX.createPbuffer(mContextConfig, dummyPbufferAttribs);
if (!mDummyPbuffer)
{
return egl::Error(EGL_NOT_INITIALIZED, "Could not create the dummy pbuffer.");
}
if (!mGLX.makeCurrent(mDummyPbuffer, mContext))
{
return egl::Error(EGL_NOT_INITIALIZED, "Could not make the dummy pbuffer current.");
}
mFunctionsGL = new FunctionsGLGLX(mGLX.getProc);
mFunctionsGL->initialize();
// TODO(cwallez, angleproject:1303) Disable the OpenGL ES backend on Linux NVIDIA and Intel as
// it has problems on our automated testing. An OpenGL ES backend might not trigger this test if
// there is no Desktop OpenGL support, but that's not the case in our automated testing.
VendorID vendor = GetVendorID(mFunctionsGL);
bool isOpenGLES =
eglAttributes.get(EGL_PLATFORM_ANGLE_TYPE_ANGLE, EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE) ==
EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE;
if (isOpenGLES && (vendor == VENDOR_ID_INTEL || vendor == VENDOR_ID_NVIDIA))
{
return egl::Error(EGL_NOT_INITIALIZED, "Intel or NVIDIA OpenGL ES drivers are not supported.");
}
syncXCommands();
std::string rendererString =
reinterpret_cast<const char*>(mFunctionsGL->getString(GL_RENDERER));
mIsMesa = rendererString.find("Mesa") != std::string::npos;
std::string version;
getDriverVersion(&version);
return DisplayGL::initialize(display);
}
void DiGfxCaps::LogCaps()
{
DI_INFO("-------------------------");
DI_INFO("--Graphics capabilities--");
DI_INFO("-------------------------");
DI_INFO("GfxDriver: %s", getRenderSystemName().c_str());
DI_INFO("GPU Vendor: %s", vendorToString(getVendor()).c_str());
DI_INFO("Device Name: %s", getDeviceName().c_str());
DI_INFO("Driver Version: %s", getDriverVersion().toString().c_str());
DI_INFO(" * Hardware generation of mipmaps: %s", _BoolToStr(hasCapability(RSC_AUTOMIPMAP)));
DI_INFO(" * Anisotropic texture filtering: %s", _BoolToStr(hasCapability(RSC_ANISOTROPY)));
DI_INFO(" * Hardware stencil buffer: %s", _BoolToStr(hasCapability(RSC_HWSTENCIL)));
if (hasCapability(RSC_HWSTENCIL))
{
DI_INFO(" - Stencil depth: %d", getStencilBufferBitDepth());
DI_INFO(" - Two sided stencil support: %s", _BoolToStr(hasCapability(RSC_TWO_SIDED_STENCIL)));
DI_INFO(" - Wrap stencil values: %s", _BoolToStr(hasCapability(RSC_STENCIL_WRAP)));
}
DI_INFO(" * 32-bit index buffers: %s", +_BoolToStr(hasCapability(RSC_32BIT_INDEX)));
DI_INFO(" * Vertex shader: %s", _BoolToStr(hasCapability(RSC_VERTEX_PROGRAM)));
DI_INFO(" * Number of float constants for vertex shader: %d", mVertexProgramConstantFloatCount);
DI_INFO(" * Number of int constants for vertex shader: %d", mVertexProgramConstantIntCount);
DI_INFO(" * Number of bool constants for vertex shader: %d", mVertexProgramConstantBoolCount);
DI_INFO(" * Fragment shader: %s", _BoolToStr(hasCapability(RSC_FRAGMENT_PROGRAM)));
DI_INFO(" * Number of float constants for fragment shader: %d", mFragmentProgramConstantFloatCount);
DI_INFO(" * Number of int constants for fragment shader: %d", mFragmentProgramConstantIntCount);
DI_INFO(" * Number of bool constants for fragment shader: %d", mFragmentProgramConstantBoolCount);
DiString profileList = "";
for(ShaderProfiles::iterator iter = mSupportedShaderProfiles.begin(), end = mSupportedShaderProfiles.end();
iter != end; ++iter)
{
profileList += " " + *iter;
}
DI_INFO(" * Supported Shader Profiles: %s", profileList.c_str());
DI_INFO(" * Texture Compression: ", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION)));
if (hasCapability(RSC_TEXTURE_COMPRESSION))
{
DI_INFO(" - DXT: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_DXT)));
DI_INFO(" - VTC: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_VTC)));
DI_INFO(" - PVRTC: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_PVRTC)));
DI_INFO(" - ATC: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_ATC)));
DI_INFO(" - ETC1: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_ETC1)));
DI_INFO(" - ETC2: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_ETC2)));
DI_INFO(" - BC4/BC5: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_BC4_BC5)));
DI_INFO(" - BC6H/BC7: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_BC6H_BC7)));
}
DI_INFO(" * Scissor Rectangle: %s", _BoolToStr(hasCapability(RSC_SCISSOR_TEST)));
DI_INFO(" * Hardware Occlusion Query: %s", _BoolToStr(hasCapability(RSC_HWOCCLUSION)));
DI_INFO(" * User clip planes: %s", _BoolToStr(hasCapability(RSC_USER_CLIP_PLANES)));
DI_INFO(" * VET_UBYTE4 vertex element type: %s", _BoolToStr(hasCapability(RSC_VERTEX_FORMAT_UBYTE4)));
DI_INFO(" * Infinite far plane projection: %s", _BoolToStr(hasCapability(RSC_INFINITE_FAR_PLANE)));
DI_INFO(" * Hardware render-to-texture: %s", _BoolToStr(hasCapability(RSC_HWRENDER_TO_TEXTURE)));
DI_INFO(" * Floating point textures: %s", _BoolToStr(hasCapability(RSC_TEXTURE_FLOAT)));
DI_INFO(" * Non-power-of-two textures: %s %s", _BoolToStr(hasCapability(RSC_NON_POWER_OF_2_TEXTURES)),(mNonPOW2TexturesLimited ? " (limited)" : ""));
DI_INFO(" * 1D textures: %s", _BoolToStr(hasCapability(RSC_TEXTURE_1D)));
DI_INFO(" * 3D textures: %s", _BoolToStr(hasCapability(RSC_TEXTURE_3D)));
DI_INFO(" * Multiple Render Targets: %d", mNumMultiRenderTargets);
DI_INFO(" - With different bit depths: %s", _BoolToStr(hasCapability(RSC_MRT_DIFFERENT_BIT_DEPTHS)));
DI_INFO(" * Vertex texture fetch: %s", _BoolToStr(hasCapability(RSC_VERTEX_TEXTURE_FETCH)));
DI_INFO(" * Number of world matrices: %d", mNumWorldMatrices);
DI_INFO(" * Number of texture units: %d", mNumTextureUnits);
DI_INFO(" * Stencil buffer depth: %d", mStencilBufferBitDepth);
DI_INFO(" * Number of vertex blend matrices: %d", mNumVertexBlendMatrices);
DI_INFO(" * Render to Vertex Buffer : %s", _BoolToStr(hasCapability(RSC_HWRENDER_TO_VERTEX_BUFFER)));
DI_INFO(" * Hardware Atomic Counters: %s", _BoolToStr(hasCapability(RSC_ATOMIC_COUNTERS)));
if (mCategoryRelevant[CAPS_CATEGORY_GL])
{
DI_INFO(" * GL 1.5 without VBO workaround: %s"
, _BoolToStr(hasCapability(RSC_GL1_5_NOVBO)));
DI_INFO(" * Frame Buffer objects: %s"
, _BoolToStr(hasCapability(RSC_FBO)));
DI_INFO(" * Frame Buffer objects (ARB extension): %s"
, _BoolToStr(hasCapability(RSC_FBO_ARB)));
DI_INFO(" * Frame Buffer objects (ATI extension): %s"
, _BoolToStr(hasCapability(RSC_FBO_ATI)));
DI_INFO(" * PBuffer support: %s"
, _BoolToStr(hasCapability(RSC_PBUFFER)));
DI_INFO(" * GL 1.5 without HW-occlusion workaround: %s"
, _BoolToStr(hasCapability(RSC_GL1_5_NOHWOCCLUSION)));
DI_INFO(" * Vertex Array Objects: %s"
, _BoolToStr(hasCapability(RSC_VAO)));
DI_INFO(" * Separate shader objects: %s"
, _BoolToStr(hasCapability(RSC_SEPARATE_SHADER_OBJECTS)));
}
if (mCategoryRelevant[CAPS_CATEGORY_D3D9])
{
DI_INFO(" * DirectX per stage constants: %s", _BoolToStr(hasCapability(RSC_PERSTAGECONSTANT)));
}
}
void CudaModule::printDeviceInfo(CUdevice device)
{
static const struct
{
CUdevice_attribute attrib;
const char* name;
} attribs[] =
{
#define A21(ENUM, NAME) { CU_DEVICE_ATTRIBUTE_ ## ENUM, NAME },
#if (CUDA_VERSION >= 4000)
# define A40(ENUM, NAME) A21(ENUM, NAME)
#else
# define A40(ENUM, NAME) // TODO: Some of these may exist in earlier versions, too.
#endif
A21(CLOCK_RATE, "Clock rate")
A40(MEMORY_CLOCK_RATE, "Memory clock rate")
A21(MULTIPROCESSOR_COUNT, "Number of SMs")
// A40(GLOBAL_MEMORY_BUS_WIDTH, "DRAM bus width")
// A40(L2_CACHE_SIZE, "L2 cache size")
A21(MAX_THREADS_PER_BLOCK, "Max threads per block")
A40(MAX_THREADS_PER_MULTIPROCESSOR, "Max threads per SM")
A21(REGISTERS_PER_BLOCK, "Registers per block")
// A40(MAX_REGISTERS_PER_BLOCK, "Max registers per block")
A21(SHARED_MEMORY_PER_BLOCK, "Shared mem per block")
// A40(MAX_SHARED_MEMORY_PER_BLOCK, "Max shared mem per block")
A21(TOTAL_CONSTANT_MEMORY, "Constant memory")
// A21(WARP_SIZE, "Warp size")
A21(MAX_BLOCK_DIM_X, "Max blockDim.x")
// A21(MAX_BLOCK_DIM_Y, "Max blockDim.y")
// A21(MAX_BLOCK_DIM_Z, "Max blockDim.z")
A21(MAX_GRID_DIM_X, "Max gridDim.x")
// A21(MAX_GRID_DIM_Y, "Max gridDim.y")
// A21(MAX_GRID_DIM_Z, "Max gridDim.z")
// A40(MAXIMUM_TEXTURE1D_WIDTH, "Max tex1D.x")
// A40(MAXIMUM_TEXTURE2D_WIDTH, "Max tex2D.x")
// A40(MAXIMUM_TEXTURE2D_HEIGHT, "Max tex2D.y")
// A40(MAXIMUM_TEXTURE3D_WIDTH, "Max tex3D.x")
// A40(MAXIMUM_TEXTURE3D_HEIGHT, "Max tex3D.y")
// A40(MAXIMUM_TEXTURE3D_DEPTH, "Max tex3D.z")
// A40(MAXIMUM_TEXTURE1D_LAYERED_WIDTH, "Max layerTex1D.x")
// A40(MAXIMUM_TEXTURE1D_LAYERED_LAYERS, "Max layerTex1D.y")
// A40(MAXIMUM_TEXTURE2D_LAYERED_WIDTH, "Max layerTex2D.x")
// A40(MAXIMUM_TEXTURE2D_LAYERED_HEIGHT, "Max layerTex2D.y")
// A40(MAXIMUM_TEXTURE2D_LAYERED_LAYERS, "Max layerTex2D.z")
// A40(MAXIMUM_TEXTURE2D_ARRAY_WIDTH, "Max array.x")
// A40(MAXIMUM_TEXTURE2D_ARRAY_HEIGHT, "Max array.y")
// A40(MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES, "Max array.z")
// A21(MAX_PITCH, "Max memcopy pitch")
// A21(TEXTURE_ALIGNMENT, "Texture alignment")
// A40(SURFACE_ALIGNMENT, "Surface alignment")
A40(CONCURRENT_KERNELS, "Concurrent launches supported")
A21(GPU_OVERLAP, "Concurrent memcopy supported")
A40(ASYNC_ENGINE_COUNT, "Max concurrent memcopies")
// A40(KERNEL_EXEC_TIMEOUT, "Kernel launch time limited")
// A40(INTEGRATED, "Integrated with host memory")
A40(UNIFIED_ADDRESSING, "Unified addressing supported")
A40(CAN_MAP_HOST_MEMORY, "Can map host memory")
A40(ECC_ENABLED, "ECC enabled")
// A40(TCC_DRIVER, "Driver is TCC")
// A40(COMPUTE_MODE, "Compute exclusivity mode")
// A40(PCI_BUS_ID, "PCI bus ID")
// A40(PCI_DEVICE_ID, "PCI device ID")
// A40(PCI_DOMAIN_ID, "PCI domain ID")
#undef A21
#undef A40
};
char name[256];
int major;
int minor;
size_t memory;
checkError("cuDeviceGetName", cuDeviceGetName(name, FW_ARRAY_SIZE(name) - 1, device));
checkError("cuDeviceComputeCapability", cuDeviceComputeCapability(&major, &minor, device));
checkError("cuDeviceTotalMem", cuDeviceTotalMem(&memory, device));
name[FW_ARRAY_SIZE(name) - 1] = '\0';
printf("\n");
char deviceIdStr[16];
sprintf( deviceIdStr, "CUDA device %d", device);
printf("%-32s%s\n",deviceIdStr, name);
printf("%-32s%s\n", "---", "---");
int version = getDriverVersion();
printf("%-32s%d.%d\n", "CUDA driver API version", version/10, version%10);
printf("%-32s%d.%d\n", "Compute capability", major, minor);
printf("%-32s%.0f megs\n", "Total memory", (F32)memory * exp2(-20));
for (int i = 0; i < (int)FW_ARRAY_SIZE(attribs); i++)
{
int value;
if (cuDeviceGetAttribute(&value, attribs[i].attrib, device) == CUDA_SUCCESS)
printf("%-32s%d\n", attribs[i].name, value);
}
printf("\n");
}
