EXPR_Lock.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        EXPR_Lock.h (EXPR Library, C++)
 *
 * COMMENTS:    This header allows us to enable/disable locking when evaluating
 *              parameters and hscript expressions.
 */

#ifndef __EXPR_LOCK_H_INCLUDED__
#define __EXPR_LOCK_H_INCLUDED__

#include "EXPR_API.h"

#include <UT/UT_LockUtil.h>
#include <UT/UT_TaskLock.h>
#include <UT/UT_TBBSpinLock.h>
#include <SYS/SYS_AtomicInt.h>
#include <SYS/SYS_Types.h>

// Modify this to enable/disable parm expr locking
#define EXPR_LOCKS 1

#if H_BUILD_PARALLEL_COOK_MODE
class EXPR_API EXPR_StaticLock : private UT_TaskLock
{
public:

    /// Performs the functor F while inside this lock scope in UT_TaskArena.
    /// This method allows the optimization that if we're calling this while
    /// the lock is already held in the same task scope, then we can avoid
    /// creating an unnecessary task arena.
    template <typename F>
    void
    lockedExecute(const F &functor)
    {
        theStaticCounter.add(1);

        if (theIsDisabled)
        {
            functor();
        }
        else
        {
            bool was_first = false;
            (void) UT_TaskLock::lock(was_first);
            if (!was_first)
            {
                functor();
            }
            else
            {
                UT_TaskArena arena;
                arena.execute(functor);
            }
            UT_TaskLock::unlock();
        }
    }

    /// Performs the functor F while inside this lock scope in UT_TaskArena.
    /// This method allows the optimization that if we're calling this while
    /// the lock is already held in the same task scope, then we can avoid
    /// creating an unnecessary task arena.
    template <typename F>
    void
    lockedExecute(const F &functor, UT_TaskArena &arena)
    {
        theStaticCounter.add(1);

        if (theIsDisabled)
        {
            functor();
        }
        else
        {
            bool was_first = false;
            (void) UT_TaskLock::lock(was_first);
            if (!was_first)
            {
                functor();
            }
            else
            {
                arena.execute(functor);
            }
            UT_TaskLock::unlock();
        }
    }

    /// Performs the functor F while inside this lock scope OUTSIDE an arena.
    /// @note Only do this if you know functor will never spawn tasks!
    template <typename F>
    void
    lockedExecuteWithoutArena(const F &functor)
    {
        theStaticCounter.add(1);

        if (theIsDisabled)
        {
            functor();
        }
        else
        {
            UT_TaskLock::lock();
            functor();
            UT_TaskLock::unlock();
        }
    }

    using UT_TaskLock::hasLock;

    static SYS_AtomicCounter theStaticCounter;
    static bool theIsDisabled;
};
#else
    typedef UT_TaskLockWithArena    EXPR_StaticLock;
#endif

#if EXPR_LOCKS
    typedef UT_TBBSpinLock          EXPR_Lock;
    typedef EXPR_StaticLock         EXPR_GlobalStaticLock;
#else
    typedef UT_NullLock             EXPR_Lock;
    typedef UT_NullLock             EXPR_GlobalStaticLock;
#endif

typedef EXPR_Lock::Scope            EXPR_AutoLock;

/// The global evaluation lock is a global mutex for protecting any
/// non-threadsafe evaluation (both expressions and node) code. This is
/// necessary to guard against code that might access global objects.
EXPR_API EXPR_GlobalStaticLock &    ev_GlobalEvalLock();

#endif // __EXPR_LOCK_H_INCLUDED__