GrFinishedFlushTest.cpp File Reference

#include "include/core/SkAlphaType.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkColorType.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkSurface.h"
#include "include/core/SkTypes.h"
#include "include/gpu/GpuTypes.h"
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/GrTypes.h"
#include "include/gpu/ganesh/SkSurfaceGanesh.h"
#include "src/gpu/ganesh/GrCaps.h"
#include "src/gpu/ganesh/GrDirectContextPriv.h"
#include "tests/CtsEnforcement.h"
#include "tests/Test.h"
#include "tools/gpu/FenceSync.h"
#include "tools/gpu/ManagedBackendTexture.h"
#include <chrono>
#include <memory>

Go to the source code of this file.

Functions
static void	testing_finished_proc (void *ctx)
static void	busy_wait_for_callback (int *count, int expectedValue, GrDirectContext *dContext, skiatest::Reporter *reporter)
	DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS (FlushFinishedProcTest, reporter, ctxInfo, CtsEnforcement::kApiLevel_T)
static void	abandon_context (void *context)
static void	async_callback (void *c, std::unique_ptr< const SkImage::AsyncReadResult > result)
	DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS (FinishedAsyncProcWhenAbandonedTest, reporter, ctxInfo, CtsEnforcement::kApiLevel_U)

Function Documentation

abandon_context()

static void abandon_context ( void *  context )

static

Definition at line 159 of file GrFinishedFlushTest.cpp.

                                           {
    ((GrDirectContext*)context)->abandonContext();
}

async_callback()

static void async_callback ( void *  c, std::unique_ptr< const SkImage::AsyncReadResult >  result  )

static

Definition at line 163 of file GrFinishedFlushTest.cpp.

                                                                                        {
    // We don't actually care about the results so just drop them without doing anything.
}

busy_wait_for_callback()

static void busy_wait_for_callback ( int *  count, int  expectedValue, GrDirectContext *  dContext, skiatest::Reporter *  reporter  )

static

Definition at line 42 of file GrFinishedFlushTest.cpp.

                                                               {
    // Busy waiting should detect that the work is done.
    auto begin = std::chrono::steady_clock::now();
    auto end = begin;
    do {
        dContext->checkAsyncWorkCompletion();
        end = std::chrono::steady_clock::now();
    } while (*count != expectedValue && (end - begin) < std::chrono::seconds(1));
    if (*count != expectedValue) {
        ERRORF(reporter, "Expected count failed to reach %d within 1 second of busy waiting.",
               expectedValue);
    }
}

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS() [1/2]

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS	(	FinishedAsyncProcWhenAbandonedTest	,
		reporter	,
		ctxInfo	,
		CtsEnforcement::kApiLevel_U
	)

Definition at line 172 of file GrFinishedFlushTest.cpp.

                                                                  {
    auto dContext = ctxInfo.directContext();
 
    SkImageInfo info =
            SkImageInfo::Make(8, 8, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
 
    auto mbet = sk_gpu_test::ManagedBackendTexture::MakeFromInfo(
            dContext, info, skgpu::Mipmapped::kNo, GrRenderable::kYes);
    if (!mbet) {
        return;
    }
 
    auto surface = SkSurfaces::WrapBackendTexture(dContext,
                                                  mbet->texture(),
                                                  kTopLeft_GrSurfaceOrigin,
                                                  /*sample count*/ 1,
                                                  kRGBA_8888_SkColorType,
                                                  /*color space*/ nullptr,
                                                  /*surface props*/ nullptr,
                                                  sk_gpu_test::ManagedBackendTexture::ReleaseProc,
                                                  mbet->releaseContext(nullptr, nullptr));
 
    if (!surface) {
        return;
    }
    SkCanvas* canvas = surface->getCanvas();
    canvas->clear(SK_ColorGREEN);
 
    // To trigger bug we must have a finish callback that abanonds the context before an asyc
    // read callbck on the same command buffer. So we add the abandon callback first and flush
    // then add the asyc to enforce this order.
    GrFlushInfo flushInfo;
    flushInfo.fFinishedProc = abandon_context;
    flushInfo.fFinishedContext = dContext;
 
    dContext->flush(flushInfo);
 
    surface->asyncRescaleAndReadPixels(info,
                                       SkIRect::MakeWH(8, 8),
                                       SkImage::RescaleGamma::kSrc,
                                       SkImage::RescaleMode::kNearest,
                                       async_callback,
                                       nullptr);
 
    surface.reset();
 
    dContext->flushAndSubmit(GrSyncCpu::kYes);
}

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS() [2/2]

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS	(	FlushFinishedProcTest	,
		reporter	,
		ctxInfo	,
		CtsEnforcement::kApiLevel_T
	)

Definition at line 57 of file GrFinishedFlushTest.cpp.

                                                                  {
    auto dContext = ctxInfo.directContext();
 
    SkImageInfo info =
            SkImageInfo::Make(8, 8, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
    sk_sp<SkSurface> surface = SkSurfaces::RenderTarget(dContext, skgpu::Budgeted::kNo, info);
    SkCanvas* canvas = surface->getCanvas();
 
    canvas->clear(SK_ColorGREEN);
    auto image = surface->makeImageSnapshot();
 
    dContext->flush();
    dContext->submit(GrSyncCpu::kYes);
 
    int count = 0;
 
    GrFlushInfo flushInfoFinishedProc;
    flushInfoFinishedProc.fFinishedProc = testing_finished_proc;
    flushInfoFinishedProc.fFinishedContext = (void*)&count;
    // There is no work on the surface so flushing may immediately call the finished proc.
    dContext->flush(surface.get(), flushInfoFinishedProc);
    dContext->submit();
    REPORTER_ASSERT(reporter, count == 0 || count == 1);
    // Busy waiting should detect that the work is done.
    busy_wait_for_callback(&count, 1, dContext, reporter);
 
    canvas->clear(SK_ColorRED);
 
    dContext->flush(surface.get(), flushInfoFinishedProc);
    dContext->submit(GrSyncCpu::kNo);
 
    bool expectAsyncCallback = dContext->priv().caps()->finishedProcAsyncCallbackSupport();
    if (expectAsyncCallback) {
        // On Vulkan the command buffer we just submitted may or may not have finished immediately
        // so the finish proc may not have been called.
        REPORTER_ASSERT(reporter, count == 1 || count == 2);
    } else {
        REPORTER_ASSERT(reporter, count == 2);
    }
    dContext->flush();
    dContext->submit(GrSyncCpu::kYes);
    REPORTER_ASSERT(reporter, count == 2);
 
    // Test flushing via the SkImage
    canvas->drawImage(image, 0, 0);
    dContext->flush(image, flushInfoFinishedProc);
    dContext->submit(GrSyncCpu::kNo);
    if (expectAsyncCallback) {
        // On Vulkan the command buffer we just submitted may or may not have finished immediately
        // so the finish proc may not have been called.
        REPORTER_ASSERT(reporter, count == 2 || count == 3);
    } else {
        REPORTER_ASSERT(reporter, count == 3);
    }
    dContext->flush();
    dContext->submit(GrSyncCpu::kYes);
    REPORTER_ASSERT(reporter, count == 3);
 
    // Test flushing via the GrDirectContext
    canvas->clear(SK_ColorBLUE);
    dContext->flush(flushInfoFinishedProc);
    dContext->submit(GrSyncCpu::kNo);
    if (expectAsyncCallback) {
        // On Vulkan the command buffer we just submitted may or may not have finished immediately
        // so the finish proc may not have been called.
        REPORTER_ASSERT(reporter, count == 3 || count == 4);
    } else {
        REPORTER_ASSERT(reporter, count == 4);
    }
    dContext->flush();
    dContext->submit(GrSyncCpu::kYes);
    REPORTER_ASSERT(reporter, count == 4);
 
    // There is no work on the surface so flushing may immediately call the finished proc.
    dContext->flush(flushInfoFinishedProc);
    dContext->submit(GrSyncCpu::kNo);
    REPORTER_ASSERT(reporter, count == 4 || count == 5);
    busy_wait_for_callback(&count, 5, dContext, reporter);
 
    count = 0;
    int count2 = 0;
    canvas->clear(SK_ColorGREEN);
    dContext->flush(surface.get(), flushInfoFinishedProc);
    dContext->submit(GrSyncCpu::kNo);
    // There is no work to be flushed here so this will return immediately, but make sure the
    // finished call from this proc isn't called till the previous surface flush also is finished.
    flushInfoFinishedProc.fFinishedContext = (void*)&count2;
    dContext->flush(flushInfoFinishedProc);
    dContext->submit(GrSyncCpu::kNo);
    REPORTER_ASSERT(reporter, count <= 1 && count2 <= count);
 
    dContext->flush();
    dContext->submit(GrSyncCpu::kYes);
 
    REPORTER_ASSERT(reporter, count == 1);
    REPORTER_ASSERT(reporter, count == count2);
}

testing_finished_proc()

static void testing_finished_proc ( void *  ctx )

static

Definition at line 37 of file GrFinishedFlushTest.cpp.

                                             {
    int* count = (int*)ctx;
    *count += 1;
}