Improve performance with MPxNode::preEvaluation & MPxNode::postEvaluation

With last post we talked about the Best practices while migrating your plugin to Parallel Evaluation, in this post, we will talk about the following 2 new methods, and how to make use of them to improve the performance:

• MPxNode::preEvaluation
• MPxNode::postEvaluation

Within the old DG system, because MPxNode::setDependentsDirty function is called during dirty propagation, it can be used to manage attribute dirtying, and sometimes, we can cache the computed data in this method to avoid expensive calculations in MPxNode::compute. Let’s take the sample plugin simpleEvaluationNode as an example:

Every time when the input and aTimeInput got dirty, set cachedValueIsValid to false to make it be re-calculated.

Code Snippet

1. MStatus simpleEvaluationNode::setDependentsDirty( const MPlug& plug, MPlugArray& plugArray)
2. {
3.     if (plug == input || plug == aTimeInput )
4.     {
5.         cachedValueIsValid = false;
6.     }
7.     return MPxNode::setDependentsDirty(plug, plugArray);
8. }

Within compute() method, only do the expensive calculation when cachedValueIsValid is false.

Code Snippet

1. MStatus simpleEvaluationNode::compute( const MPlug& plug, MDataBlock& data )
2. {
3.  
4.     if( plug == output )
5.     { 
6.         ... ...
7.         if ( ! cachedValueIsValid )
8.         {
9.             MTime time = inputTimeData.asTime();
10.             cachedValue = doExpensiveCalculation( inputData.asFloat() , (float) time.value() );
11.             cachedValueIsValid = true;
12.         }
13.         MDataHandle outputHandle = data.outputValue( simpleEvaluationNode::output );
14.         outputHandle.set( cachedValue );
15.         data.setClean(plug);
16.     }
17.  
18.     return MS::kSuccess;
19. }

This works well within old DG, but the EM evaluation does not propagate dirty messages, the cached data in MPxNode::setDependentsDirty will no longer applies during EM evaluating. So how to do the same thing with EM? One of the solution is MPxNode::preEvaluation.

As discussed previously, once the EG has been built, dirty propagation is disabled and the EG is re-used. Therefore, any custom logic in your plug-in that depends on setDependentsDirty no longer applies. MPxNode::preEvaluation allows your plug-in to determine which plugs/attributes are dirty and if any action is needed, you can use the new MEvaluationNode class to determine what has been dirtied.

Code Snippet

1.   MStatus simpleEvaluationNode::preEvaluation( constMDGContext& context, const MEvaluationNode& evaluationNode )
2. {
3.     MStatus status;
4.  
5.     // we use m_CachedValueIsValid only for normal context
6.     if( !context.isNormal() )
7.         return MStatus::kFailure;
8.  
9.     if( ( evaluationNode.dirtyPlugExists(input, &status) && status ) ||
10.         ( evaluationNode.dirtyPlugExists(aTimeInput, &status) && status ) )
11.     {
12.         cachedValueIsValid = false;
13.     }
14.     return MS::kSuccess;
15. }

If you want to check the whole project, please look at simpleEvaluationNode sample under devkit.

Another new method, MPxNode::postEvaluation, is called once all computations have been performed on a specific node instance. Since this method is called from a worker thread, it performs calculations for downstream graph operations without blocking other Maya processing tasks of non-dependent nodes.

Within the simpleEvaluationDraw devkit example, we can use postEvaluation method to performance heavy calculations for rendering, if this plugin is running in regular evaluation, Maya will slow down because evaluation is blocked whenever expensive calculations in postEvaluation are performed. But if you run it in Parallel Evaluation Mode, a worker thread calls the postEvaluation method and prepares data for subsequent drawing operations, so it will be much faster than in regular DG evaluation, and when testing, you will see higher frame rates in Parallel evaluation versus regular or serial evaluation. But please make sure that code in postEvaluation should be thread-safe.

Code Snippet

1.   MStatus simpleEvaluationDraw::postEvaluation( constMDGContext& context, const MEvaluationNode& evaluationNode, PostEvaluationType evalType )
2. {
3.     if( !context.isNormal() )
4.         return MStatus::kFailure;
5.  
6.     MStatus status;
7.     if(evalType == kLeaveDirty)
8.     {
9.         scaleUpToDate = false;
10.     }
11.     else if ( (evaluationNode.dirtyPlugExists(aCopies, &status) && status ) ||
12.         ( evaluationNode.dirtyPlugExists(aTimeInput, &status) && status ) )
13.     {
14.         MDataBlock block = forceCache();
15.         MDataHandle inputTimeData = block.inputValue( aTimeInput, &status );
16.         if ( status )
17.         {
18.             MDataHandle copiesData = block.inputValue( aCopies, &status );
19.             if ( status )
20.             {
21.                 // A made up calculation to slow down processing
22.                 //
23.                 MTime time = inputTimeData.asTime();
24.                 int copies = copiesData.asInt();
25.                 double t = time.value();
26.                 if ( ! scaleUpToDate )
27.                 {
28.                     scaleXBy = doExpensiveCalculation( copies, t );
29.                     // Mark the scale as up to date so that draw does not
30.                     // have to recompute it
31.                     scaleUpToDate = true;
32.                 }
33.             }
34.         }
35.     }
36.     return MStatus::kSuccess;
37. }

Please also check the simpleEvaluationDraw devkit example for the whole project.