CMemThreadMgr::~CMemThreadMgr()
{
gs_pInst=NULL;
if( !m_pThread )
return;
AddEndThreadJob();
delete m_pThread;
m_pThread=NULL;
DestroySemaphore(&m_smJobQueue);
DestroySemaphore(&m_smFetchSymbol);
DestroyLock(&m_slkJobQueue);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% D e s t r o y M a g i c k %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% DestroyMagick() destroys the GraphicsMagick environment. This function
% should be invoked in the primary (original) thread of the application's
% process while shutting down, and only after any threads which might be
% using GraphicsMagick functions have terminated.
%
% The format of the DestroyMagick function is:
%
% DestroyMagick(void)
%
%
*/
MagickExport void
DestroyMagick(void)
{
if (MagickInitialized == InitUninitialized)
return;
(void) LogMagickEvent(ConfigureEvent,GetMagickModule(),
"Destroy Magick");
MagickDestroyCommandInfo(); /* Command parser */
#if defined(HasX11)
MagickXDestroyX11Resources();
#endif
DestroyColorInfo(); /* Color database */
DestroyDelegateInfo(); /* External delegate information */
DestroyTypeInfo(); /* Font information */
DestroyMagicInfo(); /* File format detection */
DestroyMagickInfoList(); /* Coder registrations + modules */
DestroyConstitute(); /* Constitute semaphore */
DestroyMagickRegistry(); /* Registered images */
DestroyMagickResources(); /* Resource semaphore */
DestroyMagickRandomGenerator(); /* Random number generator */
DestroyTemporaryFiles(); /* Temporary files */
#if defined(MSWINDOWS)
NTGhostscriptUnLoadDLL(); /* Ghostscript DLL */
#endif /* defined(MSWINDOWS) */
/*
Destroy logging last since some components log their destruction.
*/
DestroyLogInfo(); /* Logging configuration */
DestroySemaphore(); /* Semaphores framework */
MagickInitialized=InitUninitialized;
}
CAoiThreadMgr::~CAoiThreadMgr(void)
{
ReleaseThreads();
for( uint8 uIndex=0; uIndex < m_vecThreads.size(); uIndex++ )
delete m_vecThreads[uIndex];
CAoi2LogicThreadMsgBuffer::Unit();
DestroySemaphore(&m_smJobQueue);
}
void VulkanWindowContext::destroyBuffers() {
if (fBackbuffers) {
for (uint32_t i = 0; i < fImageCount + 1; ++i) {
GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
WaitForFences(fBackendContext->fDevice, 2,
fBackbuffers[i].fUsageFences,
true, UINT64_MAX));
fBackbuffers[i].fImageIndex = -1;
GR_VK_CALL(fBackendContext->fInterface,
DestroySemaphore(fBackendContext->fDevice,
fBackbuffers[i].fAcquireSemaphore,
nullptr));
GR_VK_CALL(fBackendContext->fInterface,
DestroySemaphore(fBackendContext->fDevice,
fBackbuffers[i].fRenderSemaphore,
nullptr));
GR_VK_CALL(fBackendContext->fInterface,
FreeCommandBuffers(fBackendContext->fDevice, fCommandPool, 2,
fBackbuffers[i].fTransitionCmdBuffers));
GR_VK_CALL(fBackendContext->fInterface,
DestroyFence(fBackendContext->fDevice, fBackbuffers[i].fUsageFences[0], 0));
GR_VK_CALL(fBackendContext->fInterface,
DestroyFence(fBackendContext->fDevice, fBackbuffers[i].fUsageFences[1], 0));
}
}
delete[] fBackbuffers;
fBackbuffers = nullptr;
// Does this actually free the surfaces?
delete[] fSurfaces;
fSurfaces = nullptr;
delete[] fRenderTargets;
fRenderTargets = nullptr;
delete[] fImageLayouts;
fImageLayouts = nullptr;
delete[] fImages;
fImages = nullptr;
}
CScriptThread::~CScriptThread()
{
delete m_pScript;
DestroySemaphore(&m_smThread);
}
void HotQ::PosixSemaphore::Reset(int newInitialCount)
{
DestroySemaphore(true);
InitializeSemaphore(newInitialCount);
}
HotQ::PosixSemaphore::~PosixSemaphore()
{
DestroySemaphore(false);
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(EmptySurfaceSemaphoreTest, reporter, ctxInfo) {
GrContext* ctx = ctxInfo.grContext();
if (!ctx->caps()->fenceSyncSupport()) {
return;
}
const SkImageInfo ii = SkImageInfo::Make(MAIN_W, MAIN_H, kRGBA_8888_SkColorType,
kPremul_SkAlphaType);
sk_sp<SkSurface> mainSurface(SkSurface::MakeRenderTarget(ctx, SkBudgeted::kNo,
ii, 0, kTopLeft_GrSurfaceOrigin,
nullptr));
// Flush surface once without semaphores to make sure there is no peneding IO for it.
mainSurface->flush();
GrBackendSemaphore semaphore;
GrSemaphoresSubmitted submitted = mainSurface->flushAndSignalSemaphores(1, &semaphore);
REPORTER_ASSERT(reporter, GrSemaphoresSubmitted::kYes == submitted);
if (kOpenGL_GrBackend == ctxInfo.backend()) {
GrGLGpu* gpu = static_cast<GrGLGpu*>(ctx->contextPriv().getGpu());
const GrGLInterface* interface = gpu->glInterface();
GrGLsync sync = semaphore.glSync();
REPORTER_ASSERT(reporter, sync);
bool result;
GR_GL_CALL_RET(interface, result, IsSync(sync));
REPORTER_ASSERT(reporter, result);
}
#ifdef SK_VULKAN
if (kVulkan_GrBackend == ctxInfo.backend()) {
GrVkGpu* gpu = static_cast<GrVkGpu*>(ctx->contextPriv().getGpu());
const GrVkInterface* interface = gpu->vkInterface();
VkDevice device = gpu->device();
VkQueue queue = gpu->queue();
VkCommandPool cmdPool = gpu->cmdPool();
VkCommandBuffer cmdBuffer;
// Create Command Buffer
const VkCommandBufferAllocateInfo cmdInfo = {
VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // sType
nullptr, // pNext
cmdPool, // commandPool
VK_COMMAND_BUFFER_LEVEL_PRIMARY, // level
1 // bufferCount
};
VkResult err = GR_VK_CALL(interface, AllocateCommandBuffers(device, &cmdInfo, &cmdBuffer));
if (err) {
return;
}
VkCommandBufferBeginInfo cmdBufferBeginInfo;
memset(&cmdBufferBeginInfo, 0, sizeof(VkCommandBufferBeginInfo));
cmdBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
cmdBufferBeginInfo.pNext = nullptr;
cmdBufferBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
cmdBufferBeginInfo.pInheritanceInfo = nullptr;
GR_VK_CALL_ERRCHECK(interface, BeginCommandBuffer(cmdBuffer, &cmdBufferBeginInfo));
GR_VK_CALL_ERRCHECK(interface, EndCommandBuffer(cmdBuffer));
VkFenceCreateInfo fenceInfo;
VkFence fence;
memset(&fenceInfo, 0, sizeof(VkFenceCreateInfo));
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
err = GR_VK_CALL(interface, CreateFence(device, &fenceInfo, nullptr, &fence));
SkASSERT(!err);
VkPipelineStageFlags waitStages = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
VkSubmitInfo submitInfo;
memset(&submitInfo, 0, sizeof(VkSubmitInfo));
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.pNext = nullptr;
submitInfo.waitSemaphoreCount = 1;
VkSemaphore vkSem = semaphore.vkSemaphore();
submitInfo.pWaitSemaphores = &vkSem;
submitInfo.pWaitDstStageMask = &waitStages;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &cmdBuffer;
submitInfo.signalSemaphoreCount = 0;
submitInfo.pSignalSemaphores = nullptr;
GR_VK_CALL_ERRCHECK(interface, QueueSubmit(queue, 1, &submitInfo, fence));
err = GR_VK_CALL(interface, WaitForFences(device, 1, &fence, true, 3000000000));
REPORTER_ASSERT(reporter, err != VK_TIMEOUT);
GR_VK_CALL(interface, DestroyFence(device, fence, nullptr));
GR_VK_CALL(interface, DestroySemaphore(device, vkSem, nullptr));
// If the above test fails the wait semaphore will never be signaled which can cause the
// device to hang when tearing down (even if just tearing down GL). So we Fail here to
// kill things.
if (err == VK_TIMEOUT) {
SK_ABORT("Waiting on semaphore indefinitely");
}
}
#endif
}
