skiatest::graphite::DawnTestContext Class Reference

#include <GraphiteDawnTestContext.h>

Inheritance diagram for skiatest::graphite::DawnTestContext:

Public Member Functions
	~DawnTestContext () override
skgpu::BackendApi	backend () override
skgpu::ContextType	contextType () override
std::unique_ptr< skgpu::graphite::Context >	makeContext (const TestOptions &) override
const skgpu::graphite::DawnBackendContext &	getBackendContext () const
void	tick () override
Public Member Functions inherited from skiatest::graphite::GraphiteTestContext
	GraphiteTestContext (const GraphiteTestContext &)=delete
GraphiteTestContext &	operator= (const GraphiteTestContext &)=delete
virtual	~GraphiteTestContext ()
bool	getMaxGpuFrameLag (int *maxFrameLag) const
void	submitRecordingAndWaitOnSync (skgpu::graphite::Context *, skgpu::graphite::Recording *)
void	syncedSubmit (skgpu::graphite::Context *)

Static Public Member Functions
static std::unique_ptr< GraphiteTestContext >	Make (wgpu::BackendType backend)

Protected Member Functions
	DawnTestContext (const skgpu::graphite::DawnBackendContext &backendContext)
Protected Member Functions inherited from skiatest::graphite::GraphiteTestContext
	GraphiteTestContext ()

Protected Attributes
skgpu::graphite::DawnBackendContext	fBackendContext
Protected Attributes inherited from skiatest::graphite::GraphiteTestContext
sk_sp< sk_gpu_test::FlushFinishTracker >	fFinishTrackers [kMaxFrameLag - 1]
int	fCurrentFlushIdx = 0

Additional Inherited Members
Static Protected Attributes inherited from skiatest::graphite::GraphiteTestContext
static constexpr int	kMaxFrameLag = 3

Detailed Description

Definition at line 22 of file GraphiteDawnTestContext.h.

Constructor & Destructor Documentation

~DawnTestContext()

skiatest::graphite::DawnTestContext::~DawnTestContext ( )

override

Definition at line 28 of file GraphiteDawnTestContext.cpp.

                                  {
    fBackendContext.fDevice = nullptr;
    tick();
}

DawnTestContext()

skiatest::graphite::DawnTestContext::DawnTestContext ( const skgpu::graphite::DawnBackendContext &  backendContext )

inlineprotected

Definition at line 41 of file GraphiteDawnTestContext.h.

            : fBackendContext(backendContext) {}

Member Function Documentation

backend()

skgpu::BackendApi skiatest::graphite::DawnTestContext::backend ( )

inlineoverridevirtual

Implements skiatest::graphite::GraphiteTestContext.

Definition at line 28 of file GraphiteDawnTestContext.h.

{ return skgpu::BackendApi::kDawn; }

contextType()

skgpu::ContextType skiatest::graphite::DawnTestContext::contextType ( )

overridevirtual

Implements skiatest::graphite::GraphiteTestContext.

Definition at line 152 of file GraphiteDawnTestContext.cpp.

                                              {
    wgpu::AdapterProperties props;
    fBackendContext.fDevice.GetAdapter().GetProperties(&props);
    switch (props.backendType) {
        case wgpu::BackendType::D3D11:
            return skgpu::ContextType::kDawn_D3D11;
 
        case wgpu::BackendType::D3D12:
            return skgpu::ContextType::kDawn_D3D12;
 
        case wgpu::BackendType::Metal:
            return skgpu::ContextType::kDawn_Metal;
 
        case wgpu::BackendType::Vulkan:
            return skgpu::ContextType::kDawn_Vulkan;
 
        case wgpu::BackendType::OpenGL:
            return skgpu::ContextType::kDawn_OpenGL;
 
        case wgpu::BackendType::OpenGLES:
            return skgpu::ContextType::kDawn_OpenGLES;
        default:
            SK_ABORT("unexpected Dawn backend");
            return skgpu::ContextType::kMock;
    }
}

getBackendContext()

const skgpu::graphite::DawnBackendContext & skiatest::graphite::DawnTestContext::getBackendContext ( ) const

inline

Definition at line 34 of file GraphiteDawnTestContext.h.

                                                                     {
        return fBackendContext;
    }

Make()

std::unique_ptr< GraphiteTestContext > skiatest::graphite::DawnTestContext::Make ( wgpu::BackendType  backend )

static

Definition at line 33 of file GraphiteDawnTestContext.cpp.

                                                                                {
    static std::unique_ptr<dawn::native::Instance> sInstance;
    static SkOnce sOnce;
 
    static constexpr const char* kToggles[] = {
        "allow_unsafe_apis",  // Needed for dual-source blending.
        "use_user_defined_labels_in_backend",
    };
    wgpu::DawnTogglesDescriptor togglesDesc;
    togglesDesc.enabledToggleCount  = std::size(kToggles);
    togglesDesc.enabledToggles      = kToggles;
 
    // Creation of Instance is cheap but calling EnumerateAdapters can be expensive the first time,
    // but then the results are cached on the Instance object. So save the Instance here so we can
    // avoid the overhead of EnumerateAdapters on every test.
    sOnce([&]{
        DawnProcTable backendProcs = dawn::native::GetProcs();
        dawnProcSetProcs(&backendProcs);
        WGPUInstanceDescriptor desc{};
        // need for WaitAny with timeout > 0
        desc.features.timedWaitAnyEnable = true;
        sInstance = std::make_unique<dawn::native::Instance>(&desc);
    });
 
    dawn::native::Adapter matchedAdaptor;
 
    wgpu::RequestAdapterOptions options;
    options.nextInChain = &togglesDesc;
    std::vector<dawn::native::Adapter> adapters = sInstance->EnumerateAdapters(&options);
    SkASSERT(!adapters.empty());
    // Sort adapters by adapterType(DiscreteGPU, IntegratedGPU, CPU) and
    // backendType(WebGPU, D3D11, D3D12, Metal, Vulkan, OpenGL, OpenGLES).
    std::sort(adapters.begin(),
              adapters.end(),
              [](dawn::native::Adapter a, dawn::native::Adapter b) {
                  wgpu::AdapterProperties propA;
                  wgpu::AdapterProperties propB;
                  a.GetProperties(&propA);
                  b.GetProperties(&propB);
                  return std::tuple(propA.adapterType, propA.backendType) <
                         std::tuple(propB.adapterType, propB.backendType);
              });
 
    for (const auto& adapter : adapters) {
        wgpu::AdapterProperties props;
        adapter.GetProperties(&props);
        if (backend == props.backendType) {
            matchedAdaptor = adapter;
            break;
        }
    }
 
    if (!matchedAdaptor) {
        return nullptr;
    }
 
#if LOG_ADAPTER
    wgpu::AdapterProperties properties;
    sAdapter.GetProperties(&properties);
    SkDebugf("GPU: %s\nDriver: %s\n", properties.name, properties.driverDescription);
#endif
 
    std::vector<wgpu::FeatureName> features;
    wgpu::Adapter adapter = matchedAdaptor.Get();
    if (adapter.HasFeature(wgpu::FeatureName::MSAARenderToSingleSampled)) {
        features.push_back(wgpu::FeatureName::MSAARenderToSingleSampled);
    }
    if (adapter.HasFeature(wgpu::FeatureName::TransientAttachments)) {
        features.push_back(wgpu::FeatureName::TransientAttachments);
    }
    if (adapter.HasFeature(wgpu::FeatureName::Unorm16TextureFormats)) {
        features.push_back(wgpu::FeatureName::Unorm16TextureFormats);
    }
    if (adapter.HasFeature(wgpu::FeatureName::DualSourceBlending)) {
        features.push_back(wgpu::FeatureName::DualSourceBlending);
    }
    if (adapter.HasFeature(wgpu::FeatureName::FramebufferFetch)) {
        features.push_back(wgpu::FeatureName::FramebufferFetch);
    }
    if (adapter.HasFeature(wgpu::FeatureName::BufferMapExtendedUsages)) {
        features.push_back(wgpu::FeatureName::BufferMapExtendedUsages);
    }
    if (adapter.HasFeature(wgpu::FeatureName::TextureCompressionETC2)) {
        features.push_back(wgpu::FeatureName::TextureCompressionETC2);
    }
    if (adapter.HasFeature(wgpu::FeatureName::TextureCompressionBC)) {
        features.push_back(wgpu::FeatureName::TextureCompressionBC);
    }
    if (adapter.HasFeature(wgpu::FeatureName::R8UnormStorage)) {
        features.push_back(wgpu::FeatureName::R8UnormStorage);
    }
 
    wgpu::DeviceDescriptor desc;
    desc.requiredFeatureCount  = features.size();
    desc.requiredFeatures      = features.data();
    desc.nextInChain           = &togglesDesc;
 
    wgpu::Device device = wgpu::Device::Acquire(matchedAdaptor.CreateDevice(&desc));
    SkASSERT(device);
    device.SetUncapturedErrorCallback(
            [](WGPUErrorType type, const char* message, void*) {
                SkDebugf("Device error: %s\n", message);
            },
            /*userdata=*/nullptr);
    device.SetDeviceLostCallback(
            [](WGPUDeviceLostReason reason, const char* message, void*) {
                if (reason != WGPUDeviceLostReason_Destroyed) {
                    SK_ABORT("Device lost: %s\n", message);
                }
            },
            /*userdata=*/nullptr);
 
    skgpu::graphite::DawnBackendContext backendContext;
    backendContext.fInstance = wgpu::Instance(sInstance->Get());
    backendContext.fDevice = device;
    backendContext.fQueue  = device.GetQueue();
    return std::unique_ptr<GraphiteTestContext>(new DawnTestContext(backendContext));
}

makeContext()

std::unique_ptr< skgpu::graphite::Context > skiatest::graphite::DawnTestContext::makeContext ( const TestOptions &  options )

overridevirtual

Implements skiatest::graphite::GraphiteTestContext.

Definition at line 179 of file GraphiteDawnTestContext.cpp.

                                                                                           {
    skgpu::graphite::ContextOptions revisedContextOptions(options.fContextOptions);
    skgpu::graphite::ContextOptionsPriv contextOptionsPriv;
    if (!options.fContextOptions.fOptionsPriv) {
        revisedContextOptions.fOptionsPriv = &contextOptionsPriv;
    }
    // Needed to make synchronous readPixels work
    revisedContextOptions.fOptionsPriv->fStoreContextRefInRecorder = true;
 
    auto backendContext = fBackendContext;
    if (options.fNeverYieldToWebGPU) {
        backendContext.fTick = nullptr;
    }
 
    return skgpu::graphite::ContextFactory::MakeDawn(backendContext, revisedContextOptions);
}

tick()

void skiatest::graphite::DawnTestContext::tick ( )

overridevirtual

Allow the GPU API to make or detect forward progress on submitted work. For most APIs this is a no-op as the API can do this on another thread.

Reimplemented from skiatest::graphite::GraphiteTestContext.

Definition at line 196 of file GraphiteDawnTestContext.cpp.

{ fBackendContext.fTick(fBackendContext.fInstance); }

Member Data Documentation

fBackendContext

skgpu::graphite::DawnBackendContext skiatest::graphite::DawnTestContext::fBackendContext

protected

Definition at line 44 of file GraphiteDawnTestContext.h.

---

The documentation for this class was generated from the following files:

• third_party/skia/tools/graphite/dawn/GraphiteDawnTestContext.h
• third_party/skia/tools/graphite/dawn/GraphiteDawnTestContext.cpp