#include <MtlCommandBuffer.h>

Inheritance diagram for skgpu::graphite::MtlCommandBuffer:

Public Member Functions
	~MtlCommandBuffer () override

bool	setNewCommandBufferResources () override

void	addWaitSemaphores (size_t numWaitSemaphores, const BackendSemaphore *waitSemaphores) override

void	addSignalSemaphores (size_t numSignalSemaphores, const BackendSemaphore *signalSemaphores) override

bool	isFinished ()

void	waitUntilFinished ()

bool	commit ()

Public Member Functions inherited from skgpu::graphite::CommandBuffer
virtual	~CommandBuffer ()

void	trackResource (sk_sp< Resource > resource)

void	trackCommandBufferResource (sk_sp< Resource > resource)

void	resetCommandBuffer ()

void	addFinishedProc (sk_sp< RefCntedCallback > finishedProc)

void	callFinishedProcs (bool success)

virtual void	prepareSurfaceForStateUpdate (SkSurface targetSurface, const MutableTextureState newState)

void	addBuffersToAsyncMapOnSubmit (SkSpan< const sk_sp< Buffer > >)

SkSpan< const sk_sp< Buffer > >	buffersToAsyncMapOnSubmit () const

bool	addRenderPass (const RenderPassDesc &, sk_sp< Texture > colorTexture, sk_sp< Texture > resolveTexture, sk_sp< Texture > depthStencilTexture, SkRect viewport, const DrawPassList &drawPasses)

bool	addComputePass (DispatchGroupSpan dispatchGroups)

bool	copyBufferToBuffer (const Buffer *srcBuffer, size_t srcOffset, sk_sp< Buffer > dstBuffer, size_t dstOffset, size_t size)

bool	copyTextureToBuffer (sk_sp< Texture >, SkIRect srcRect, sk_sp< Buffer >, size_t bufferOffset, size_t bufferRowBytes)

bool	copyBufferToTexture (const Buffer , sk_sp< Texture >, const BufferTextureCopyData , int count)

bool	copyTextureToTexture (sk_sp< Texture > src, SkIRect srcRect, sk_sp< Texture > dst, SkIPoint dstPoint, int mipLevel)

bool	synchronizeBufferToCpu (sk_sp< Buffer >)

bool	clearBuffer (const Buffer *buffer, size_t offset, size_t size)

void	setReplayTranslation (SkIVector translation)

void	clearReplayTranslation ()

Static Public Member Functions
static std::unique_ptr< MtlCommandBuffer >	Make (id< MTLCommandQueue >, const MtlSharedContext , MtlResourceProvider )

Private Member Functions
void	onResetCommandBuffer () override

bool	onAddRenderPass (const RenderPassDesc &, const Texture colorTexture, const Texture resolveTexture, const Texture *depthStencilTexture, SkRect viewport, const DrawPassList &) override

bool	onAddComputePass (DispatchGroupSpan) override

bool	onCopyBufferToBuffer (const Buffer srcBuffer, size_t srcOffset, const Buffer dstBuffer, size_t dstOffset, size_t size) override

bool	onCopyTextureToBuffer (const Texture , SkIRect srcRect, const Buffer , size_t bufferOffset, size_t bufferRowBytes) override

bool	onCopyBufferToTexture (const Buffer , const Texture , const BufferTextureCopyData *copyData, int count) override

bool	onCopyTextureToTexture (const Texture src, SkIRect srcRect, const Texture dst, SkIPoint dstPoint, int mipLevel) override

bool	onSynchronizeBufferToCpu (const Buffer , bool outDidResultInWork) override

bool	onClearBuffer (const Buffer *, size_t offset, size_t size) override

Additional Inherited Members
Public Types inherited from skgpu::graphite::CommandBuffer
using	DrawPassList = skia_private::TArray< std::unique_ptr< DrawPass > >

using	DispatchGroupSpan = SkSpan< const std::unique_ptr< DispatchGroup > >

Protected Member Functions inherited from skgpu::graphite::CommandBuffer
	CommandBuffer ()

Protected Attributes inherited from skgpu::graphite::CommandBuffer
SkISize	fRenderPassSize

SkIVector	fReplayTranslation

Detailed Description

Definition at line 31 of file MtlCommandBuffer.h.

Constructor & Destructor Documentation

◆ ~MtlCommandBuffer()

skgpu::graphite::MtlCommandBuffer::~MtlCommandBuffer ( )

override

Definition at line 51 of file MtlCommandBuffer.mm.

                                    {
    SkASSERT(!fActiveRenderCommandEncoder);
    SkASSERT(!fActiveComputeCommandEncoder);
    SkASSERT(!fActiveBlitCommandEncoder);
}

Member Function Documentation

◆ addSignalSemaphores()

void skgpu::graphite::MtlCommandBuffer::addSignalSemaphores	(	size_t	numSignalSemaphores,
		const BackendSemaphore *	signalSemaphores
	)

overridevirtual

Reimplemented from skgpu::graphite::CommandBuffer.

Definition at line 130 of file MtlCommandBuffer.mm.

                                                                                     {
    if (!signalSemaphores) {
        SkASSERT(numSignalSemaphores == 0);
        return;
    }
 
    // Can only insert events with no active encoder
    SkASSERT(!fActiveRenderCommandEncoder);
    SkASSERT(!fActiveComputeCommandEncoder);
    this->endBlitCommandEncoder();
 
    if (@available(macOS 10.14, iOS 12.0, tvOS 12.0, *)) {
        for (size_t i = 0; i < numSignalSemaphores; ++i) {
            auto semaphore = signalSemaphores[i];
            if (semaphore.isValid() && semaphore.backend() == BackendApi::kMetal) {
                id<MTLEvent> mtlEvent = (__bridge id<MTLEvent>)semaphore.getMtlEvent();
                [(*fCommandBuffer) encodeSignalEvent: mtlEvent
                                               value: semaphore.getMtlValue()];
            }
        }
    }
}

◆ addWaitSemaphores()

void skgpu::graphite::MtlCommandBuffer::addWaitSemaphores	(	size_t	numWaitSemaphores,
		const BackendSemaphore *	waitSemaphores
	)

overridevirtual

Reimplemented from skgpu::graphite::CommandBuffer.

Definition at line 107 of file MtlCommandBuffer.mm.

                                                                                 {
    if (!waitSemaphores) {
        SkASSERT(numWaitSemaphores == 0);
        return;
    }
 
    // Can only insert events with no active encoder
    SkASSERT(!fActiveRenderCommandEncoder);
    SkASSERT(!fActiveComputeCommandEncoder);
    this->endBlitCommandEncoder();
    if (@available(macOS 10.14, iOS 12.0, tvOS 12.0, *)) {
        for (size_t i = 0; i < numWaitSemaphores; ++i) {
            auto semaphore = waitSemaphores[i];
            if (semaphore.isValid() && semaphore.backend() == BackendApi::kMetal) {
                id<MTLEvent> mtlEvent = (__bridge id<MTLEvent>)semaphore.getMtlEvent();
                [(*fCommandBuffer) encodeWaitForEvent: mtlEvent
                                                value: semaphore.getMtlValue()];
            }
        }
    }
}

◆ commit()

bool skgpu::graphite::MtlCommandBuffer::commit ( )

Definition at line 83 of file MtlCommandBuffer.mm.

                              {
    SkASSERT(!fActiveRenderCommandEncoder);
    SkASSERT(!fActiveComputeCommandEncoder);
    this->endBlitCommandEncoder();
    [(*fCommandBuffer) commit];
 
    if ((*fCommandBuffer).status == MTLCommandBufferStatusError) {
        NSString* description = (*fCommandBuffer).error.localizedDescription;
        const char* errorString = [description UTF8String];
        SKGPU_LOG_E("Failure submitting command buffer: %s", errorString);
    }
 
    return ((*fCommandBuffer).status != MTLCommandBufferStatusError);
}

◆ isFinished()

bool skgpu::graphite::MtlCommandBuffer::isFinished ( )

inline

Definition at line 45 of file MtlCommandBuffer.h.

                      {
        return (*fCommandBuffer).status == MTLCommandBufferStatusCompleted ||
               (*fCommandBuffer).status == MTLCommandBufferStatusError;
 
    }

◆ Make()

std::unique_ptr< MtlCommandBuffer > skgpu::graphite::MtlCommandBuffer::Make	(	id< MTLCommandQueue >	queue,
		const MtlSharedContext *	sharedContext,
		MtlResourceProvider *	resourceProvider
	)

static

Definition at line 30 of file MtlCommandBuffer.mm.

                                                                                                {
    auto commandBuffer = std::unique_ptr<MtlCommandBuffer>(
            new MtlCommandBuffer(queue, sharedContext, resourceProvider));
    if (!commandBuffer) {
        return nullptr;
    }
    if (!commandBuffer->createNewMTLCommandBuffer()) {
        return nullptr;
    }
    return commandBuffer;
}

◆ onAddComputePass()

bool skgpu::graphite::MtlCommandBuffer::onAddComputePass ( DispatchGroupSpan groups )

overrideprivatevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 174 of file MtlCommandBuffer.mm.

                                                                {
    this->beginComputePass();
    for (const auto& group : groups) {
        group->addResourceRefs(this);
        for (const auto& dispatch : group->dispatches()) {
            this->bindComputePipeline(group->getPipeline(dispatch.fPipelineIndex));
            for (const ResourceBinding& binding : dispatch.fBindings) {
                if (const BufferView* buffer = std::get_if<BufferView>(&binding.fResource)) {
                    this->bindBuffer(buffer->fInfo.fBuffer, buffer->fInfo.fOffset, binding.fIndex);
                } else if (const TextureIndex* texIdx =
                                   std::get_if<TextureIndex>(&binding.fResource)) {
                    SkASSERT(texIdx);
                    this->bindTexture(group->getTexture(texIdx->fValue), binding.fIndex);
                } else {
                    const SamplerIndex* samplerIdx = std::get_if<SamplerIndex>(&binding.fResource);
                    SkASSERT(samplerIdx);
                    this->bindSampler(group->getSampler(samplerIdx->fValue), binding.fIndex);
                }
            }
            SkASSERT(fActiveComputeCommandEncoder);
            for (const ComputeStep::WorkgroupBufferDesc& wgBuf : dispatch.fWorkgroupBuffers) {
                fActiveComputeCommandEncoder->setThreadgroupMemoryLength(
                        SkAlignTo(wgBuf.size, 16),
                        wgBuf.index);
            }
            if (const WorkgroupSize* globalSize =
                        std::get_if<WorkgroupSize>(&dispatch.fGlobalSizeOrIndirect)) {
                this->dispatchThreadgroups(*globalSize, dispatch.fLocalSize);
            } else {
                SkASSERT(std::holds_alternative<BufferView>(dispatch.fGlobalSizeOrIndirect));
                const BufferView& indirect =
                        *std::get_if<BufferView>(&dispatch.fGlobalSizeOrIndirect);
                this->dispatchThreadgroupsIndirect(
                        dispatch.fLocalSize, indirect.fInfo.fBuffer, indirect.fInfo.fOffset);
            }
        }
    }
    this->endComputePass();
    return true;
}

◆ onAddRenderPass()

bool skgpu::graphite::MtlCommandBuffer::onAddRenderPass	(	const RenderPassDesc &	renderPassDesc,
		const Texture *	colorTexture,
		const Texture *	resolveTexture,
		const Texture *	depthStencilTexture,
		SkRect	viewport,
		const DrawPassList &	drawPasses
	)

overrideprivatevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 154 of file MtlCommandBuffer.mm.

                                                                       {
    if (!this->beginRenderPass(renderPassDesc, colorTexture, resolveTexture, depthStencilTexture)) {
        return false;
    }
 
    this->setViewport(viewport.x(), viewport.y(), viewport.width(), viewport.height(), 0, 1);
 
    for (const auto& drawPass : drawPasses) {
        this->addDrawPass(drawPass.get());
    }
 
    this->endRenderPass();
    return true;
}

◆ onClearBuffer()

bool skgpu::graphite::MtlCommandBuffer::onClearBuffer	(	const Buffer *	buffer,
		size_t	offset,
		size_t	size
	)

overrideprivatevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 939 of file MtlCommandBuffer.mm.

                                                                                     {
    SkASSERT(!fActiveRenderCommandEncoder);
    SkASSERT(!fActiveComputeCommandEncoder);
 
    MtlBlitCommandEncoder* blitCmdEncoder = this->getBlitCommandEncoder();
    if (!blitCmdEncoder) {
        return false;
    }
 
    id<MTLBuffer> mtlBuffer = static_cast<const MtlBuffer*>(buffer)->mtlBuffer();
    blitCmdEncoder->fillBuffer(mtlBuffer, offset, size, 0);
 
    return true;
}

◆ onCopyBufferToBuffer()

bool skgpu::graphite::MtlCommandBuffer::onCopyBufferToBuffer	(	const Buffer *	srcBuffer,
		size_t	srcOffset,
		const Buffer *	dstBuffer,
		size_t	dstOffset,
		size_t	size
	)

overrideprivatevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 784 of file MtlCommandBuffer.mm.

                                                         {
    SkASSERT(!fActiveRenderCommandEncoder);
    SkASSERT(!fActiveComputeCommandEncoder);
 
    id<MTLBuffer> mtlSrcBuffer = static_cast<const MtlBuffer*>(srcBuffer)->mtlBuffer();
    id<MTLBuffer> mtlDstBuffer = static_cast<const MtlBuffer*>(dstBuffer)->mtlBuffer();
 
    MtlBlitCommandEncoder* blitCmdEncoder = this->getBlitCommandEncoder();
    if (!blitCmdEncoder) {
        return false;
    }
 
#ifdef SK_ENABLE_MTL_DEBUG_INFO
    blitCmdEncoder->pushDebugGroup(@"copyBufferToBuffer");
#endif
    blitCmdEncoder->copyBufferToBuffer(mtlSrcBuffer, srcOffset, mtlDstBuffer, dstOffset, size);
#ifdef SK_ENABLE_MTL_DEBUG_INFO
    blitCmdEncoder->popDebugGroup();
#endif
    return true;
}

◆ onCopyBufferToTexture()

bool skgpu::graphite::MtlCommandBuffer::onCopyBufferToTexture	(	const Buffer *	buffer,
		const Texture *	texture,
		const BufferTextureCopyData *	copyData,
		int	count
	)

overrideprivatevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 840 of file MtlCommandBuffer.mm.

                                                        {
    SkASSERT(!fActiveRenderCommandEncoder);
    SkASSERT(!fActiveComputeCommandEncoder);
 
    id<MTLBuffer> mtlBuffer = static_cast<const MtlBuffer*>(buffer)->mtlBuffer();
    id<MTLTexture> mtlTexture = static_cast<const MtlTexture*>(texture)->mtlTexture();
 
    MtlBlitCommandEncoder* blitCmdEncoder = this->getBlitCommandEncoder();
    if (!blitCmdEncoder) {
        return false;
    }
 
#ifdef SK_ENABLE_MTL_DEBUG_INFO
    blitCmdEncoder->pushDebugGroup(@"copyBufferToTexture");
#endif
    for (int i = 0; i < count; ++i) {
        if (!check_max_blit_width(copyData[i].fRect.width())) {
            return false;
        }
 
        blitCmdEncoder->copyFromBuffer(mtlBuffer,
                                       copyData[i].fBufferOffset,
                                       copyData[i].fBufferRowBytes,
                                       mtlTexture,
                                       copyData[i].fRect,
                                       copyData[i].fMipLevel);
    }
 
#ifdef SK_ENABLE_MTL_DEBUG_INFO
    blitCmdEncoder->popDebugGroup();
#endif
    return true;
}

◆ onCopyTextureToBuffer()

bool skgpu::graphite::MtlCommandBuffer::onCopyTextureToBuffer	(	const Texture *	texture,
		SkIRect	srcRect,
		const Buffer *	buffer,
		size_t	bufferOffset,
		size_t	bufferRowBytes
	)

overrideprivatevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 810 of file MtlCommandBuffer.mm.

                                                                    {
    SkASSERT(!fActiveRenderCommandEncoder);
    SkASSERT(!fActiveComputeCommandEncoder);
 
    if (!check_max_blit_width(srcRect.width())) {
        return false;
    }
 
    id<MTLTexture> mtlTexture = static_cast<const MtlTexture*>(texture)->mtlTexture();
    id<MTLBuffer> mtlBuffer = static_cast<const MtlBuffer*>(buffer)->mtlBuffer();
 
    MtlBlitCommandEncoder* blitCmdEncoder = this->getBlitCommandEncoder();
    if (!blitCmdEncoder) {
        return false;
    }
 
#ifdef SK_ENABLE_MTL_DEBUG_INFO
    blitCmdEncoder->pushDebugGroup(@"copyTextureToBuffer");
#endif
    blitCmdEncoder->copyFromTexture(mtlTexture, srcRect, mtlBuffer, bufferOffset, bufferRowBytes);
#ifdef SK_ENABLE_MTL_DEBUG_INFO
    blitCmdEncoder->popDebugGroup();
#endif
    return true;
}

◆ onCopyTextureToTexture()

bool skgpu::graphite::MtlCommandBuffer::onCopyTextureToTexture	(	const Texture *	src,
		SkIRect	srcRect,
		const Texture *	dst,
		SkIPoint	dstPoint,
		int	mipLevel
	)

overrideprivatevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 877 of file MtlCommandBuffer.mm.

                                                            {
    SkASSERT(!fActiveRenderCommandEncoder);
    SkASSERT(!fActiveComputeCommandEncoder);
 
    id<MTLTexture> srcMtlTexture = static_cast<const MtlTexture*>(src)->mtlTexture();
    id<MTLTexture> dstMtlTexture = static_cast<const MtlTexture*>(dst)->mtlTexture();
 
    MtlBlitCommandEncoder* blitCmdEncoder = this->getBlitCommandEncoder();
    if (!blitCmdEncoder) {
        return false;
    }
 
#ifdef SK_ENABLE_MTL_DEBUG_INFO
    blitCmdEncoder->pushDebugGroup(@"copyTextureToTexture");
#endif
 
    blitCmdEncoder->copyTextureToTexture(srcMtlTexture, srcRect, dstMtlTexture, dstPoint, mipLevel);
 
#ifdef SK_ENABLE_MTL_DEBUG_INFO
    blitCmdEncoder->popDebugGroup();
#endif
    return true;
}

◆ onResetCommandBuffer()

void skgpu::graphite::MtlCommandBuffer::onResetCommandBuffer ( )

overrideprivatevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 98 of file MtlCommandBuffer.mm.

                                            {
    fCommandBuffer.reset();
    fActiveRenderCommandEncoder.reset();
    fActiveComputeCommandEncoder.reset();
    fActiveBlitCommandEncoder.reset();
    fCurrentIndexBuffer = nil;
    fCurrentIndexBufferOffset = 0;
}

◆ onSynchronizeBufferToCpu()

bool skgpu::graphite::MtlCommandBuffer::onSynchronizeBufferToCpu	(	const Buffer *	buffer,
		bool *	outDidResultInWork
	)

overrideprivatevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 905 of file MtlCommandBuffer.mm.

                                                                                              {
#ifdef SK_BUILD_FOR_MAC
    SkASSERT(!fActiveRenderCommandEncoder);
    SkASSERT(!fActiveComputeCommandEncoder);
 
    id<MTLBuffer> mtlBuffer = static_cast<const MtlBuffer*>(buffer)->mtlBuffer();
    if ([mtlBuffer storageMode] != MTLStorageModeManaged) {
        *outDidResultInWork = false;
        return true;
    }
 
    MtlBlitCommandEncoder* blitCmdEncoder = this->getBlitCommandEncoder();
    if (!blitCmdEncoder) {
        return false;
    }
 
#ifdef SK_ENABLE_MTL_DEBUG_INFO
    blitCmdEncoder->pushDebugGroup(@"synchronizeToCpu");
#endif
    blitCmdEncoder->synchronizeResource(mtlBuffer);
#ifdef SK_ENABLE_MTL_DEBUG_INFO
    blitCmdEncoder->popDebugGroup();
#endif
 
    *outDidResultInWork = true;
    return true;
#else   // SK_BUILD_FOR_MAC
    // Explicit synchronization is never necessary on builds that are not macOS since we never use
    // discrete GPUs with managed mode buffers outside of macOS.
    *outDidResultInWork = false;
    return true;
#endif  // SK_BUILD_FOR_MAC
}

◆ setNewCommandBufferResources()

bool skgpu::graphite::MtlCommandBuffer::setNewCommandBufferResources ( )

overridevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 57 of file MtlCommandBuffer.mm.

                                                    {
    return this->createNewMTLCommandBuffer();
}

◆ waitUntilFinished()

void skgpu::graphite::MtlCommandBuffer::waitUntilFinished ( )

inline

Definition at line 50 of file MtlCommandBuffer.h.

                             {
        // TODO: it's not clear what do to if status is Enqueued. Commit and then wait?
        if ((*fCommandBuffer).status == MTLCommandBufferStatusScheduled ||
            (*fCommandBuffer).status == MTLCommandBufferStatusCommitted) {
            [(*fCommandBuffer) waitUntilCompleted];
        }
        if (!this->isFinished()) {
            SKGPU_LOG_E("Unfinished command buffer status: %d",
                        (int)(*fCommandBuffer).status);
            SkASSERT(false);
        }
    }

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

third_party/skia/src/gpu/graphite/mtl/MtlCommandBuffer.h
third_party/skia/src/gpu/graphite/mtl/MtlCommandBuffer.mm

Public Member Functions

Static Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ~MtlCommandBuffer()

Member Function Documentation

◆ addSignalSemaphores()

◆ addWaitSemaphores()

◆ commit()

◆ isFinished()

◆ Make()

◆ onAddComputePass()

◆ onAddRenderPass()

◆ onClearBuffer()

◆ onCopyBufferToBuffer()

◆ onCopyBufferToTexture()

◆ onCopyTextureToBuffer()

◆ onCopyTextureToTexture()

◆ onResetCommandBuffer()

◆ onSynchronizeBufferToCpu()

◆ setNewCommandBufferResources()

◆ waitUntilFinished()