Hi

I'm using Houdini 15 on my MacbookPro13 with intel Iris, it's very good that after I upgraded the OS into 10.11.2 the latest, it won't crash anymore, but super slow on a process named CVMCompiler. And I'd like to know the answer as the title, is that the reason it's super slow on my machine about OpenGL or the other reasons ? Thanks !


OpenGL Vendor: Intel Inc.
OpenGL Renderer: Intel Iris OpenGL Engine
OpenGL Version: 4.1 INTEL-10.12.13
OpenGL Shading Language: 4.10
Detected: Intel GMA Consumer (Mac version)
Unknown VRAM
Unknown driver version

Supported Extensions not in OpenGL 3.3 (Version):
GLX_SGI_swap_control
GL_ARB_gpu_shader5 (4.0)
GL_ARB_gpu_shader_fp64 (4.0)
GL_ARB_sample_shading (4.0)
GL_ARB_separate_shader_objects (4.1)
GL_ARB_tessellation_shader (4.0)
GL_ARB_texture_buffer_object_rgb32 (4.0)
GL_ARB_transform_feedback3 (4.0)
GL_ARB_vertex_attrib_64bit (4.1)
GL_EXT_texture_filter_anisotropic

Unsupported OpenGL Extensions used by Houdini:
EXT_extensions_string
GL_ARB_base_instance (4.2)
GL_ARB_buffer_storage (4.4)
GL_ARB_compatibility
GL_ARB_compute_shader (4.3)
GL_ARB_debug_output
GL_ARB_multi_bind (4.4)
GL_ARB_program_interface_query (4.3)
GL_ARB_robustness
GL_ARB_shader_image_load_store (4.2)
GL_ARB_shader_storage_buffer_object (4.3)
GL_ATI_meminfo
GL_EXT_abgr
GL_EXT_blend_minmax
GL_EXT_direct_state_access
GL_KHR_debug (4.3)
GL_NVX_gpu_memory_info

OpenGL Limits:
ELEMENTS_VERTICES 1048575
ELEMENTS_INDICES 150000
VERTEX_UNITS 16
TESS_CONTROL_TEXTURE_IMAGE_UNITS 16
TESS_EVALUATION_TEXTURE_IMAGE_UNITS 16
GEOMETRY_UNITS 16
FRAGMENT_IMAGE_UNITS 16
COMBINED_UNITS 80
TEXTURE_SIZE 16384
3D_TEXTURE_SIZE 2048
CUBE_MAP_TEXTURE_SIZE 16384
RECTANGLE_TEXTURE_SIZE 16384
TEXTURE_ARRAY_LAYERS 2048
MAX_COLOR_TEXTURE_SAMPLES 8
MAX_DEPTH_TEXTURE_SAMPLES 8
FBO_ATTACHMENTS 8
DRAW_BUFFERS 8
VIEWPORT_DIMS 16384x16384
VERTEX_UNIFORMS 4096
FRAGMENT_UNIFORMS 4096
VERTEX_ATTRIBS 16
VERTEX_OUTPUT_COMPONENTS 128
MAX_CLIP_DISTANCES 8
PATCH_VERTICES 32
TESS_GEN_LEVEL 64
TESS_PATCH_COMPONENTS 120
TESS_CONTROL_OUTPUT_COMPONENTS 128
TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS 4216
TESS_EVALUATION_OUTPUT_COMPONENTS 128
GEOMETRY_UNIFORM_COMPONENTS 4096
GEOMETRY_INPUT_COMPONENTS 128
GEOMETRY_OUTPUT_COMPONENTS 128
GEOMETRY_TOTAL_OUTPUT_COMPONENTS 16384
GEOMETRY_OUTPUT_VERTICES 1024
UNIFORM_BLOCKS 75
UNIFORM_BLOCK_SIZE 65536
UNIFORM_BUFFER_BINDINGS 75
COMBINED_VERT_UNIFORM_BLOCKS 15
COMBINED_VERT_UNIFORM_COMPS 249856
TESS_CONTROL_UNIFORM_BLOCKS 15
TESS_CONTROL_UNIFORM_COMPONENTS 4096
TESS_EVALUATION_UNIFORM_BLOCKS 15
TESS_EVALUATION_UNIFORM_COMPONENTS 4096
COMBINED_GEO_UNIFORM_BLOCKS 15
COMBINED_GEO_UNIFORM_COMPS 249856
COMBINED_FRAG_UNIFORM_BLOCKS 15
COMBINED_FRAG_UNIFORM_COMPS 249856
TRANSFORM_FEEDBACK_INT_COMPS 64
TRANSFORM_FEEDBACK_SEP_COMPS 4
TRANSFORM_FEEDBACK_SEP_ATTRIBS 4
LINE_WIDTH_RANGE 0.125 - 1
LINE_WIDTH_GRANULARITY 0.125
POINT_SIZE_RANGE 1 - 255.875
POINT_SIZE_GRANULARITY 0.125

I think what happens is you don't get support because the hardware you are using falls below the minimum requirement to run Houdini. Kind of like where I am with my MacMini.

But if Houdini works, go ahead and use it!

The CVMCompiler process running means that OpenGL is dropping to software rendering for some GL operation, which is very slow even though it may only be a small part of the redraw. Unfortunately it's difficult to determine what's causing the software fallback, as the OSX driver doesn't provide a reason for doing so. The best we can do is run Houdini under the GL profiler with “Break on: Software Fallback” and try to figure out what's made the driver unhappy. (Apple: implementing the GL_khr_debug extension would REALLY help with these issues!)

If a particular extension is not available, Houdini will either disable features depending on the extension or use a slower core-GL codepath. For example, GL_ARB_multi_bind allows binding of multiple textures with a single GL call; when unsupported, we loop through all the textures making multiple GL calls to bind them. If GL_ARB_tesselation_shader isn't implemented then “Display As: Subdivision Surface” will do the subdivision on the CPU and send the results to the GPU, rather than having the GPU do the tessellation. These are entirely optional and as long as OpenGL 3.3 is supported, Houdini will run.