Page tree
Skip to end of metadata
Go to start of metadata
Content:

3Delight statistics are divided in groups of related information. For example, the "Ray Tracer" group contains all statistics that affect ray tracer operations. The following table lists all the groups as well as their JSON legalized names and comments.

GroupJSON nameDescription
Render Optionrender_optionsContains global rendering options that have been (usual) set by the user.
SystemsystemContains options related to the system/hardware on which the image has been rendered.
ProfilingprofilingContains timings for different parts of the renderer.
MemorymemoryContains information and memory profiling for different structures in the renderer.
Texture Cachetexture_cacheThe texture cache plays an important part in the overall performance of 3Delight. The cache is needed since available physical memory is usually much less than the space taken by all the textures for a certain render. The role of this cache is to keep and manage the texture data needed for rendering.
Ray Tracerray_tracerContains data related to all operations of the ray tracer.
REYESreyesContains data related to the workings of the REYES rendering engine.


Statistics Description

The following table goes through every statistic available in every group.


' * ' = deprecated.

KeywordTypeUnitsDescription
System
time_to_first_pixelrealsecsTime it take for the first pixel to appear.
network_traffictable

disk_traffictable

load_average

[real, real, real]


Load average is a gauge of how many processes are on average, concurrently demanding CPU attention. The three numbers are averages for 1, 5 and 15 minutes. Very detailed description of load averages can be obtained on Linux manpages of uptime. A good technical overview can be found here and good vulgarization can be found here.
Profiling
timingstabletimeTime taken to produce the image, for a wide range of timed categories. Different categories are explained in Profiling Categories.
memory_profiletableMMemory used to produce the image, for a wide range of categories.
peak_virtual_memoryrealMThe peak virtual memory while rendering. Note that 3Delight could consume large amounts of virtual memory on 64 bits machines. This doesn't mean that it will actually uses all the virtual space it allocated (far from it).
peak_residentrealMPeak resident memory as computed by 3Delight.
peak_from_mallocrealMPeak as returned from system allocator.
system_time[real, real, real]

cpu_usage[real, real, real]
CPU usage in %.
Netword Cache
cache_sizerealGB

As specified by the user.


used_sizerealGBAmount of space already used.
number_of_copied_filesinteger
Total number of files copied to that cache during this rendering session
number_of_failed_copiesinteger
Copies that failed for system reasons (space, permissions, etc ...)
number_of_copies_avoidedinteger
Copies avoided because files already in cache
number_of_rejected_filesinteger
Files not copied because cache is full
*number_of_copies_avoided_kbintegerKbSame as number_of_copies_avoided but in Kb.
data_not_cachedintegerKbData not cached due to lack of space.
data_copiedintegerKbTotal amount of data that has been copied to the cache during the rendering sessions.
Textures
number_of_mapsinteger
Total number of maps (textures, shadow maps, deep shadow maps, etc ...) managed.
number_of_texture_mapsinteger

number_of_shadow_mapsinteger

number_of_deep_shadow_mapsinteger

number_of_invalid_mapsinteger

number_of_file_open_operationsinteger
Total number of file open operations performed during a rendering session. Should be relatively low thanks to caching. Could be high on systems configured with not enough file descriptors.
*number_of_map_requestsinteger
Total number of maps requested
texture_access_statisticstable

texture_idsgroup
List of texture ids needed to understand texture_access_statistics
Texture Cache
cache_sizerealGBSize of RAM texture cache.
footprint_of_texturesreal
The texture footprint is the total amount of data seen by the cache during a render. It's the size the cache should be made to hold everything needed in memory. This is a good metric of how much data a scene is using. Note that the cache does not have to be that large to be fully efficient in most cases.
footprint_of_misc
GSame as footprint_for_textures but applies to other textures such as 3D textures (brick maps).
pressurereal

The cache pressure is the ratio between the footprint and the amount of data actually loaded into the cache, counting data which is loaded more than once because it was flushed. For example, at 2 each texture tile is loaded on average twice, which is actually not that bad. At 10, we're loading each tile 10 times, which is not that good anymore. A pressure of 1 indicates a fully efficient cache.

This number is directly proportional to the texture loading time described in the Profiling section above. If the pressure goes from 4 to 2 then loading time will be halved.

pressure_from_texturesreal
Pressure from 2D textures.
pressure_from_miscreal
Pressure from other kind of textures (such as 3D textures).
Scene
number_of_objectsinteger
Total number of high level objects passed to renderer.
number_of_attributesinteger
Number of RenderMan attributes needed to describe the scene.
number_of_transformsinteger
Number of transforms in the scene.
primitive_compression_ratioreal
While rendering, 3Delight uses a compression algorithm for geometric primitives residing in memory. This statistic indicates the compression ratio.
saved_memoryrealMbMemory saved thanks to compression.
REYES
number_of_mpsinteger
Total number of micro polygons generated to produce the image.
average_mps_per_gridinteger
Average number of micro polygons per grid.
grids_projectedinteger
Total number of grids projected to screen.
grids_shadedinteger
Total number of grids that have been shaded. Some projected grids might not need shading after projection because they are rejected by visibility culling.
grids_displacedinteger
Total number of displaced grids.
number_of_primitivesinteger
Total number of low-level primitives.
number_of_rejected_primitives

Total number of low-level primitives that have been efficiently rejected because they were are not seen in the image.
number_of_non_empty_bucketsinteger

average_items_per_bucketinteger
Average number of items (primitive, grid, particle, etc ...) in a bucket.
maximum_items_in_a_bucketinteger
Maximum items found in a single bucket.
distribution_of_micropolygon_areahistogram
An histogram representing the distribution of the area of micro-polygons. Distributions skewed towards lower values mean slower renders.
distribution_of_fragment_listshistogram
Depth complexity.
number_of_trimming_operationsinteger
Number of trim curves operations. Non zero when scene contains NURBS and trim curves.
maximum_mp_areareal
Maximum micro polygon area in the scene.
mininum_mp_areareal
Minimum micro polygon area in the scene.
average_mp_areareal
Average micro polygon area in the scene.
*curves_grouping_efficiencyreal
Internal.
Ray Tracer
number_of_raysinteger
Total number of traced rays.
number_of_shader_callsinteger
Total number of shader calls.
travelled_distancerealcamera space unitsTotal travelled distance for all traced rays.
number_of_arealight_probesinteger
Total number of ray probes for area light sampling.
average_objects_in_ray_pathreal
Average number of objects any each ray crosses during scene traversal. Higher values lead to slower render. Values close to a hundred can be seen when rendering fur or hair.
number_of_patch_intersection_testsinteger
Total count of intersection tests with the lowest level geometrical primitives in 3Delight.
space_partition_efficiencyreal
Proportion of rays hitting an object after they enter a space partition leaf.
bounding_volume_efficiencyreal
Proportion of rays hitting an objects they they enter objet's bounding volume.
average_ray_packet_sizereal

approximationsreal
Percentage of intersection tests that used geometric approximations.
cache_pressurereal
Pressure on displaced geometry cache.
distribution_of_ray_depthhistogram

distribution_of_shading_groupshistogram
Represents the distribution of shading group sizes. Histograms skewed to lower values represent less efficient shading.
distribution_of_ray_typestable
A table describing how many rays were traced, per type (specular, diffuse, transmission, ...). Note that this is a table, not an histogram.
distribution_of_shader_callstable

Describes how many shader calls were performed, per ray type.

bbox_intersections(real, integer)
( bounding box intersection per ray, total bbox intersection )
Point Based Subsurface Scattering
distribution_of_lookup_depthhistogram
An histogram representing the lookup depth in the hierarchical structure used to store the point-based scene representation. Histograms skewed to lower values mean faster renders. A technical statistic that is not really telling for an artist.
Space Partitioner
number_of_nodesinteger
Total number of nodes (internal and leafs) in the space partitioner.
motion_densityreal

motion_segmentsinteger

tree_depthinteger
Maximum leaf node depth in the space partitioner.
number_of_raysinteger
Total number of rays that went through the space partitioner.
average_leafs_per_rayreal
Average number of leaves a ray encounters during tress traversal.
average_internal_nodes_per_rayreal
Average number internal nodes a ray encounters during tree traversal.
*average_depth_per_leafreal

average_objects_per_leafreal

average_packet_size_at_rootreal
Ray packet size when packet is entering the root of the tree
average_packet_size_at_leafreal
Ray packet size when packet is entering a leaf of the tree
number_of_bbox_intersectionsinteger

number_of_bbox_intersections_per_rayreal
It is useful to compare this number with the average_objects_in_ray_path
Point-Based Global Illumination
number_of_queriesinteger
Total number of lookups in the point-based representation of the scene.
number_of_elements_per_queryreal
Average number of elements considered for each query. Higher numbers usually indicate slower queries/renders.
Point-Based Subsurface Scattering
number_of_nodesinteger
Total number of nodes (internal and leaf) in data structure (tree) used for point-based subsurface scattering.
tree_depthinteger

number_of_queriesinteger

number_of_leaf_computationsinteger
Number of subsurface computation performed using the leafs of the tree.
number_of_hierarchical_computationsinteger
Number of subsurface computation performed using higher (aggregate) tree levels. Using such aggregate computations accelerate overall render time.
minimum_visited_leafs_per_queryinteger

maximum_visited_leafs_per_queryinteger

average_visited_leafs_per_queryinteger

Photon Maps
number_of_photonsinteger
Total number of traced photons.
number_of_interactionsinteger
Total number of photon/surface interactions.
number_of_global_photonsinteger
Number of photons stored in global photon maps.
number_of_caustic_photonsinteger
Numbe of photons stored in caustic photon maps.
average_bouncesreal
Average number of bounces a photon does before terminating or exiting scene.
average_diffuse_depthreal
Average depth of photons stored in the global photon map.
average_caustics_depthreal
Average depth if photons stored in the specular photon map.


Profiling Categories

This statistic block gives several timings about the render. Each task shows the wall clock time it took in the total render time. Follows a description for all possible tasks.

TaskDescription
raytracer init

This task includes all the work that needs to be done before starting the space parition. Basically this means iterating through all scene objects and prepare structures for the upcoming render.
ray tracer instance init
This task counts the time that is spent on optimizing instances (when "shared instances" are enabled).
space partition init
This task counts the time it takes 3Delight to build the space partitioner (a BVH-like structure). The time spent here will go proportionally with the scene size.
surface shaders
Counts the amount of time the renderer is spending inside surface shaders. Complex shaders (as generated, for example, by comlexe shading networks in Maya or Softimage) will lead to higher times in this task.
light shaders
Counts the time spent in light shaders.
volume shaders
Counts the time spent in volume shaders.
displacement shaders
Counts the time spent in displacement shaders.
imager shaders
Counts the time spent in imager shaders.
RSL plugins
Counts the time spent in custom RSL plug-ins.
shadowmap filtering
Counts the time spent filtering shadow maps to render shadows.
dsm filtering
Same as for shadow map filtering but for deep shadow maps.
texture filtering

Counts the time spent filtering texture maps. If this times seems too high compared to total render time (>10%) it could be one of the following reasons:

  1. Textures are not properly mip-mapped. Running tdlmake is mandatory for good performance.
  2. Texture lookups are done with very narrow "width". This can only happen in custom shaders.
  3. There is simply a very large amount of textures in the scene.
point cloud filtering
Counts the time spent filtering point clouds for point-based color bleeding.
brick map filtering
Counts the time spent filtering brick maps.
texture loading
Counts the time spent loading texture tiles. Since 3Delight has a caching system for texture loading this time should be marginal compared to the total render time. If not, this probably means that the texture cache is not large enough (read the Texture Cache section).
shadow map loading
Counts the time spent loading shadow map tiles.


Example JSON Output and Parsing

Follows is an example of JSON file output by 3Delight.

 Click here to expand...
{
    "textures": {
        "number_of_map_requests": 2,
        "number_of_maps": 1,
        "number_of_environment_maps": 1,
        "number_of_texture_maps": 0,
        "number_of_deep_shadow_maps": 0,
        "number_of_shadow_maps": 0,
        "number_of_invlid_maps": 0,
        "texture_access_statistics": {
            "columns": {
                "refs": [
                    1179710
                ],
                "id": [
                    1
                ],
                "mipmap_min": [
                    0
                ],
                "footprint": [
                    13664256
                ],
                "mipmap_max": [
                    10
                ]
            }
        },
        "number_of_file_open_operations": 1,
        "texture_ids": {
            "id": 1
        }
    },
    "render_options": {},
    "system": {
        "network_traffic": {
            "columns": {
                "operation": [
                    "read",
                    "write"
                ],
                "total_mb": [
                    6.5827980041503906,
                    6.5808382034301758
                ],
                "transfer_rate": [
                    962.96930803571433,
                    962.6826171875
                ]
            }
        },
        "load_average": [
            1.7587890625,
            1.60693359375,
            1.5478515625
        ],
        "time_to_first_pixel": 0.0
    },
    "point_based_gi": {
        "number_of_elements_per_query": 0.0,
        "number_of_queries": 0.0
    },
    "profiling": {
        "cpu_usage": [
            323.58533957300125,
            4.0109569189157455,
            327.59629649191703
        ],
        "system_time": [
            23.096786999999999,
            0.28629299999999996,
            7.1377730000000001
        ],
        "timings": {
            "columns": {
                "task": [
                    "other",
                    "ReadArchive",
                    "raytracer init",
                    "raytracer instance init",
                    "space partition init",
                    "raytracing",
                    "surface shaders",
                    "surface shaders (opacity)",
                    "light shaders",
                    "volume shaders",
                    "displacement shaders",
                    "imager shaders",
                    "RSL plugins",
                    "shadowmap filtering",
                    "texture filtering",
                    "dsm filtering",
                    "point cloud filtering",
                    "brick map filtering",
                    "shadowmap loading",
                    "texture loading",
                    "RtxPlugin",
                    "dsm loading",
                    "point cloud loading",
                    "brick map loading",
                    "point cloud occlusion",
                    "display drivers",
                    "sampling",
                    "particle sampling",
                    "screen filtering",
                    "REYES",
                    "eyesplit",
                    "subsurface init",
                    "subsurface eval",
                    "procedural expansion",
                    "shader recompilation",
                    "trimming",
                    "volume shader grouping",
                    "photon tree creation",
                    "point cloud writing",
                    "raytrace hider",
                    "error reporting",
                    "file access (netcache)",
                    "DEBUG 1",
                    "DEBUG 2",
                    "DEBUG 3"
                ],
                "time": [
                    0.79713633333333289,
                    0.45662449999999971,
                    0.073952999999999963,
                    0.0,
                    0.0081679999999999999,
                    4.7672314166666556,
                    0.48777950000000014,
                    0.0052614999999999997,
                    0.14790499999999995,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.063149750000000004,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.29331975000000005,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                    0.011049999999999999,
                    0.0,
                    0.0025062499999999998,
                    0.0,
                    0.0,
                    0.0
                ]
            }
        }
    },
    "texture_cache": {
        "size": 0.984375,
        "pressure_from_textures": 1.0,
        "pressure": 1.0,
        "footprint_of_textures": 0.012725830078125,
        "pressure_from_misc": 0.0,
        "footprint_of_misc": 0.0
    },
    "scene": {
        "number_of_objects": 9,
        "number_of_attributes": 12,
        "saved_memory": 0.50068800000000002,
        "primitive_compression_ratio": 1.5388098955154419,
        "number_of_transforms": 10
    },
    "memory": {
        "peak_resident": 136.73267200000001,
        "memory_profiling": {
            "columns": {
                "peak": [
                    288,
                    0,
                    792,
                    2791968,
                    0,
                    5227604,
                    0,
                    0,
                    0,
                    0,
                    0,
                    0,
                    2232,
                    13677600,
                    0,
                    0,
                    0,
                    104130,
                    7320,
                    11199544,
                    8173,
                    5476,
                    0,
                    0,
                    0,
                    0,
                    0,
                    1086064,
                    0,
                    534688,
                    297000,
                    2928096
                ],
                "item": [
                    "unprocessed gprim",
                    "gprim",
                    "gprim (polygons)",
                    "gprim (subdiv)",
                    "gprim (curves)",
                    "gprim variables",
                    "particles",
                    "topology data",
                    "crack elimination geo",
                    "grid",
                    "shaded grid",
                    "grid AOV",
                    "texture objects",
                    "texture cache",
                    "hider and visible points",
                    "image data",
                    "buffered display data",
                    "shader code",
                    "shader instance",
                    "shader variables",
                    "attributes",
                    "transform",
                    "subsurface",
                    "point based occlusion",
                    "point cloud",
                    "photon map",
                    "inline archive",
                    "ray tracer",
                    "ray tracer cache",
                    "space partition",
                    "diffuse ray cache",
                    "misc"
                ],
                "current": [
                    288,
                    0,
                    792,
                    2790720,
                    0,
                    2502740,
                    0,
                    0,
                    0,
                    0,
                    0,
                    0,
                    2232,
                    13677600,
                    0,
                    0,
                    0,
                    104130,
                    7320,
                    0,
                    8173,
                    5476,
                    0,
                    0,
                    0,
                    0,
                    0,
                    1086064,
                    0,
                    534688,
                    1736720,
                    3694048
                ],
                "category_peak": [
                    78392,
                    0,
                    792,
                    2799864,
                    0,
                    5252364,
                    0,
                    0,
                    0,
                    0,
                    0,
                    0,
                    2232,
                    13677600,
                    0,
                    0,
                    0,
                    104130,
                    7320,
                    11979836,
                    8173,
                    5624,
                    0,
                    0,
                    0,
                    0,
                    0,
                    1086064,
                    0,
                    534688,
                    1736720,
                    3694048
                ]
            }
        },
        "peak_from_malloc": 70.071376000000001
    },
    "space_partition": {
        "number_of_bbox_intersections_per_ray": 34.664260406427871,
        "motion_segments": 1.0,
        "average_packet_size_at_leaf": 7.9934654661822959,
        "average_internal_nodes_per_ray": 1.4410851029784899,
        "number_of_rays": 874940.0,
        "number_of_nodes": 12325.0,
        "motion_density": 0.0081135902636916835,
        "tree_depth": 20.0,
        "number_of_bbox_intersections": 30329148.0,
        "average_depth_per_leaf": 14.221807561252637,
        "average_leafs_per_ray": 0.30643701282373648,
        "average_packet_size_at_root": 55.055373772967528,
        "average_objects_per_leaf": 1.6947914976472498
    },
    "ray_tracer": {
        "distribution_of_shading_groups": {
            "divisions": [
                1.0,
                2.0,
                4.0,
                8.0,
                16.0,
                32.0
            ],
            "scale": "logarithmic",
            "type": "histogram",
            "hits": [
                3889,
                1334,
                1771,
                1157,
                864,
                627,
                1175
            ]
        },
        "approximations": 32.631661953810301,
        "average_ray_packet_size": 4.2809678096469224,
        "number_of_rays": 875164.0,
        "distribution_of_ray_types": {
            "columns": {
                "type": [
                    "Specular",
                    "Transmission",
                    "Diffuse",
                    "Light",
                    "Camera",
                    "Hair",
                    "Subsurface"
                ],
                "count": [
                    125483.0,
                    300586.0,
                    0.0,
                    0.0,
                    422912.0,
                    0.0,
                    26183.0
                ],
                "percentage": [
                    14.338226892331038,
                    34.346248246043025,
                    0.0,
                    0.0,
                    48.323742749930297,
                    0.0,
                    2.9917821116956365
                ]
            }
        },
        "bbox_intersection": [
            1.5752442439733148,
            2781979.0
        ],
        "space_partition_efficiency": 16.348005064125616,
        "travelled_distance": 1881734.8848779108,
        "number_of_shader_calls": 306832.0,
        "number_of_patch_intersection_tests": 1766062.0,
        "number_of_arealight_probes": 0.0,
        "distribution_of_shader_calls": {
            "columns": {
                "type": [
                    "Specular",
                    "Transmission",
                    "Diffuse",
                    "Light",
                    "Camera",
                    "Hair",
                    "Subsurface"
                ],
                "count": [
                    50588.0,
                    157918.0,
                    0.0,
                    0.0,
                    78705.0,
                    0.0,
                    19621.0
                ],
                "percentage": [
                    16.487198206184491,
                    51.467252437816136,
                    0.0,
                    0.0,
                    25.650844761954421,
                    0.0,
                    6.3947045940449492
                ]
            }
        },
        "average_objects_in_ray_path": 3.6606990232687817,
        "bounding_volume_efficiency": 29.65598036762016,
        "cache_pressure": 0.0,
        "distribution_of_ray_depth": {
            "divisions": [
                0.0,
                1.0,
                2.0,
                3.0,
                4.0,
                5.0,
                6.0,
                7.0,
                8.0
            ],
            "scale": "linear",
            "type": "histogram",
            "hits": [
                422912,
                304513,
                108011,
                30381,
                9347,
                0,
                0,
                0,
                0,
                0
            ]
        }
    }
}



To be continued ...

Embedding Statistics Into HTML Documents

It is easy to use the JSON output format to generate nice rendering of statistics. The following example code uses HTML, Chart.js and JavaScript to generate a pie chart representing the percentage for each ray type.

Example pie chart generate using JSON statistics, HTML and Javascript.







  • No labels