GrRenderTaskCluster.cpp File Reference

#include "src/gpu/ganesh/GrRenderTaskCluster.h"
#include "src/core/SkTHash.h"
#include "src/gpu/ganesh/GrRenderTask.h"

Go to the source code of this file.

Macros
#define	CLUSTER_DEBUGF(...)

Functions
static GrSurfaceProxy *	first_target (GrRenderTask *task)
static bool	depends_on (GrRenderTask *depender, GrRenderTask *dependee)
static bool	task_cluster_visit (GrRenderTask *task, SkTInternalLList< GrRenderTask > *llist, THashMap< GrSurfaceProxy *, GrRenderTask * > *lastTaskMap)
bool	GrClusterRenderTasks (SkSpan< const sk_sp< GrRenderTask > > input, SkTInternalLList< GrRenderTask > *llist)

Macro Definition Documentation

CLUSTER_DEBUGF

#define CLUSTER_DEBUGF

(

...

)

Definition at line 16 of file GrRenderTaskCluster.cpp.

Function Documentation

depends_on()

static bool depends_on ( GrRenderTask *  depender, GrRenderTask *  dependee  )

static

Definition at line 68 of file GrRenderTaskCluster.cpp.

                                                                       {
    // Check if depender writes to something dependee reads.
    // TODO: Establish real DAG dependencies for this during recording? E.g. when a task adds a
    // target, search backward for the last task that uses the target and add a dep.
    for (int i = 0; i < depender->numTargets(); i++) {
        if (dependee->isUsed(depender->target(i))) {
            CLUSTER_DEBUGF("Cluster: Bail, %s can't write before %s reads from %s.\n",
                           describe_task(depender).c_str(),
                           describe_task(dependee).c_str(),
                           depender->target(i)->getDebugName().c_str());
            return true;
        }
    }
    // Check for a formal dependency.
    if (depender->dependsOn(dependee)) {
        CLUSTER_DEBUGF("Cluster: Bail, %s depends on %s.\n",
                       describe_task(depender).c_str(),
                       describe_task(dependee).c_str());
        return true;
    }
    return false;
}

first_target()

static GrSurfaceProxy * first_target ( GrRenderTask *  task )

static

Definition at line 18 of file GrRenderTaskCluster.cpp.

{ return task->target(0); }

GrClusterRenderTasks()

bool GrClusterRenderTasks	(	SkSpan< const sk_sp< GrRenderTask > >	input,
		SkTInternalLList< GrRenderTask > *	llist
	)

Definition at line 159 of file GrRenderTaskCluster.cpp.

                                                                 {
    SkASSERT(llist->isEmpty());
 
    if (input.size() < 3) {
        for (const auto& t : input) {
            llist->addToTail(t.get());
        }
        return false;
    }
 
    CLUSTER_DEBUGF("Cluster: Original order is %s\n", describe_tasks(input).c_str());
 
    THashMap<GrSurfaceProxy*, GrRenderTask*> lastTaskMap;
    bool didReorder = false;
    for (const auto& t : input) {
        didReorder |= task_cluster_visit(t.get(), llist, &lastTaskMap);
        llist->addToTail(t.get());
        CLUSTER_DEBUGF("Cluster: Output order is now: %s\n", describe_tasks(*llist).c_str());
    }
 
#ifdef SK_DEBUG
    if (didReorder) {
        validate(input, *llist);
    }
#endif
 
    return didReorder;
}

task_cluster_visit()

static bool task_cluster_visit ( GrRenderTask *  task, SkTInternalLList< GrRenderTask > *  llist, THashMap< GrSurfaceProxy *, GrRenderTask * > *  lastTaskMap  )

static

Definition at line 92 of file GrRenderTaskCluster.cpp.

                                                                                      {
    CLUSTER_DEBUGF("Cluster: ***Step***\nLooking at %s\n",
                   describe_task(task).c_str());
    if (task->numTargets() != 1) {
        CLUSTER_DEBUGF("Cluster: %d targets. Emitting barriers.\n", task->numTargets());
        // Tasks with 0 or multiple targets are treated as full barriers
        // for all their targets.
        for (int j = 0; j < task->numTargets(); j++) {
            if (lastTaskMap->find(task->target(0))) {
                lastTaskMap->remove(task->target(0));
            }
        }
        return false;
    }
 
    GrSurfaceProxy* target = first_target(task);
    GrRenderTask* clusterTail = (lastTaskMap->find(target) ? *lastTaskMap->find(target) : nullptr);
    lastTaskMap->set(target, task);
 
    if (!clusterTail) {
        CLUSTER_DEBUGF("Cluster: Bail, no cluster to extend.\n");
        return false;
    }
 
    CLUSTER_DEBUGF("Cluster: clusterTail is %s.\n", describe_task(clusterTail).c_str());
 
    if (clusterTail == llist->tail()) {
        CLUSTER_DEBUGF("Cluster: Bail, cluster is already tail.\n");
        return false;
    }
    GrRenderTask* movedHead = clusterTail->fNext;
 
    // Now, let's refer to the "cluster" as the chain of tasks with the same target, that we're
    // hoping to extend by reordering. Let "moved tasks" be the ones we want to move to extend the
    // cluster.
    GrRenderTask* clusterHead = clusterTail;
    while (clusterHead->fPrev
           && 1 == clusterHead->fPrev->numTargets()
           && target == first_target(clusterHead->fPrev)) {
        clusterHead = clusterHead->fPrev;
    }
 
    // We can't reorder if any moved task depends on anything in the cluster.
    // Time complexity here is high, but making a hash set is worse in profiling.
    for (GrRenderTask* moved = movedHead; moved; moved = moved->fNext) {
        for (GrRenderTask* passed = clusterHead; passed != movedHead; passed = passed->fNext) {
            if (depends_on(moved, passed)) {
                return false;
            }
        }
    }
 
    // Grab the moved tasks and pull them before clusterHead.
    for (GrRenderTask* moved = movedHead; moved;) {
        CLUSTER_DEBUGF("Cluster: Reorder %s behind %s.\n",
                       describe_task(moved).c_str(),
                       describe_task(clusterHead).c_str());
        // Be careful to save fNext before each move.
        GrRenderTask* nextMoved = moved->fNext;
        llist->remove(moved);
        llist->addBefore(moved, clusterHead);
        moved = nextMoved;
    }
    return true;
}