Merge "[Vulkan Snapshot] tryLock when an API might create extra handles" into main
diff --git a/codegen/vulkan/vulkan-docs-next/scripts/cereal/encoder.py b/codegen/vulkan/vulkan-docs-next/scripts/cereal/encoder.py
index bd88391..dadac94 100644
--- a/codegen/vulkan/vulkan-docs-next/scripts/cereal/encoder.py
+++ b/codegen/vulkan/vulkan-docs-next/scripts/cereal/encoder.py
@@ -21,7 +21,7 @@
class VkEncoder {
public:
- VkEncoder(gfxstream::guest::IOStream* stream, gfxstream::guest::HealthMonitor<>* healthMonitor = nullptr);
+ VkEncoder(gfxstream::guest::IOStream* stream);
~VkEncoder();
#include "VkEncoder.h.inl"
@@ -31,7 +31,6 @@
private:
class Impl;
std::unique_ptr<Impl> mImpl;
- gfxstream::guest::HealthMonitor<>* mHealthMonitor;
};
"""
@@ -39,8 +38,6 @@
using namespace gfxstream::vk;
-using gfxstream::guest::AutoLock;
-using gfxstream::guest::Lock;
using gfxstream::guest::BumpPool;
#include "VkEncoder.cpp.inl"
@@ -363,7 +360,6 @@
cgen.stmt("uint32_t packetSize_%s = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count" % (api.name))
else:
cgen.stmt("uint32_t packetSize_%s = 4 + 4 + count" % (api.name))
- cgen.stmt("healthMonitorAnnotation_packetSize = std::make_optional(packetSize_%s)" % (api.name))
if not doDispatchSerialize:
cgen.stmt("if (queueSubmitWithCommandsEnabled) packetSize_%s -= 8" % api.name)
@@ -375,7 +371,6 @@
if doSeqno:
cgen.stmt("uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno()")
- cgen.stmt("healthMonitorAnnotation_seqno = std::make_optional(seqno)")
cgen.stmt("memcpy(streamPtr, &opcode_%s, sizeof(uint32_t)); streamPtr += sizeof(uint32_t)" % api.name)
cgen.stmt("memcpy(streamPtr, &packetSize_%s, sizeof(uint32_t)); streamPtr += sizeof(uint32_t)" % api.name)
@@ -398,12 +393,6 @@
dispatchDone = True
- cgen.beginIf("watchdog")
- cgen.stmt("size_t watchdogBufSize = std::min<size_t>(static_cast<size_t>(packetSize_%s), kWatchdogBufferMax)" % (api.name))
- cgen.stmt("healthMonitorAnnotation_packetContents.resize(watchdogBufSize)")
- cgen.stmt("memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize)")
- cgen.endIf()
-
def emit_parameter_encode_read(typeInfo, api, cgen):
encodingParams = EncodingParameters(api)
@@ -495,31 +484,6 @@
cgen.stmt("ENCODER_DEBUG_LOG(\"%s(%s)\", %s)" % (api.name, logFormatStr, logVargsStr))
-def emit_health_watchdog(api, cgen):
- cgen.stmt("std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt")
- cgen.stmt("std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt")
- cgen.stmt("std::vector<uint8_t> healthMonitorAnnotation_packetContents")
- cgen.line("""
- auto watchdog = WATCHDOG_BUILDER(mHealthMonitor, \"%s in VkEncoder\")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert({{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert({{"packetSize", std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents", getPacketContents(
- &healthMonitorAnnotation_packetContents[0], healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
- """% (api.name)
- )
-
def emit_default_encoding(typeInfo, api, cgen):
emit_debug_log(typeInfo, api, cgen)
emit_lock(cgen)
@@ -710,7 +674,6 @@
self.module.appendHeader(self.cgenHeader.swapCode())
def emit_function_impl(cgen):
- emit_health_watchdog(api, cgen)
if api.name in custom_encodes.keys():
custom_encodes[api.name](self.typeInfo, api, cgen)
else:
diff --git a/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py b/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py
index a1abc23..6e13231 100644
--- a/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py
+++ b/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py
@@ -310,7 +310,6 @@
self.hostCommonExtraVulkanHeaders = '#include "vk_android_native_buffer_gfxstream.h"'
encoderInclude = f"""
-#include "{self.guestBaseLibDirPrefix}/AndroidHealthMonitor.h"
#include "goldfish_vk_private_defs.h"
#include <memory>
@@ -330,7 +329,6 @@
#include "{self.guestBaseLibDirPrefix}/AlignedBuf.h"
#include "{self.guestBaseLibDirPrefix}/BumpPool.h"
-#include "{self.guestBaseLibDirPrefix}/synchronization/AndroidLock.h"
#include <cutils/properties.h>
diff --git a/common/end2end/GfxstreamEnd2EndTests.h b/common/end2end/GfxstreamEnd2EndTests.h
index 6ab16ad..dbcb645 100644
--- a/common/end2end/GfxstreamEnd2EndTests.h
+++ b/common/end2end/GfxstreamEnd2EndTests.h
@@ -361,7 +361,7 @@
}
ScopedAHardwareBuffer& operator=(ScopedAHardwareBuffer&& rhs) {
- mGralloc = rhs.mGralloc;
+ std::swap(mGralloc, rhs.mGralloc);
std::swap(mHandle, rhs.mHandle);
return *this;
}
diff --git a/common/end2end/GfxstreamEnd2EndVkTests.cpp b/common/end2end/GfxstreamEnd2EndVkTests.cpp
index 7ffe1ba..c91f222 100644
--- a/common/end2end/GfxstreamEnd2EndVkTests.cpp
+++ b/common/end2end/GfxstreamEnd2EndVkTests.cpp
@@ -1087,6 +1087,15 @@
const uint32_t width = 1920;
const uint32_t height = 1080;
const auto goldenPixel = PixelR8G8B8A8(0, 255, 255, 255);
+ const auto badPixel = PixelR8G8B8A8(0, 0, 0, 255);
+
+ // Bind to a placeholder ahb before rebinding to the real one.
+ // This is to test the behavior of descriptors and make sure
+ // it removes the references to the old one when overwritten.
+ auto deletedAhb =
+ GFXSTREAM_ASSERT(ScopedAHardwareBuffer::Allocate(*mGralloc, width, height, ahbFormat));
+
+ GFXSTREAM_ASSERT(FillAhb(deletedAhb, badPixel));
auto ahb =
GFXSTREAM_ASSERT(ScopedAHardwareBuffer::Allocate(*mGralloc, width, height, ahbFormat));
@@ -1101,6 +1110,10 @@
.deviceCreateInfoPNext = &deviceFeatures,
}));
+ auto deletedAhbImage =
+ GFXSTREAM_ASSERT(CreateImageWithAhb(vk, deletedAhb, vkhpp::ImageUsageFlagBits::eSampled,
+ vkhpp::ImageLayout::eShaderReadOnlyOptimal));
+
auto ahbImage =
GFXSTREAM_ASSERT(CreateImageWithAhb(vk, ahb, vkhpp::ImageUsageFlagBits::eSampled,
vkhpp::ImageLayout::eShaderReadOnlyOptimal));
@@ -1123,9 +1136,9 @@
{{
.binding = 0,
.image = {{
- .imageView = *ahbImage.imageView,
+ .imageView = *deletedAhbImage.imageView,
.imageLayout = vkhpp::ImageLayout::eShaderReadOnlyOptimal,
- .imageSampler = *ahbImage.imageSampler,
+ .imageSampler = *deletedAhbImage.imageSampler,
}},
}}));
@@ -1137,6 +1150,24 @@
.framebuffer = &framebuffer,
}));
+ std::vector<vkhpp::WriteDescriptorSet> descriptorSetWrites;
+ vkhpp::DescriptorImageInfo descriptorImageInfo = {
+ .imageView = *ahbImage.imageView,
+ .imageLayout = vkhpp::ImageLayout::eShaderReadOnlyOptimal,
+ .sampler = *ahbImage.imageSampler,
+ };
+ descriptorSetWrites.emplace_back(vkhpp::WriteDescriptorSet{
+ .dstSet = *descriptorSet0.ds,
+ .dstBinding = 0,
+ .dstArrayElement = 0,
+ .descriptorCount = 1,
+ .descriptorType = vkhpp::DescriptorType::eCombinedImageSampler,
+ .pImageInfo = &descriptorImageInfo,
+ });
+ vk.device->updateDescriptorSets(descriptorSetWrites, {});
+ deletedAhbImage = {};
+ deletedAhb = {};
+
GFXSTREAM_ASSERT(DoCommandsImmediate(vk, [&](vkhpp::UniqueCommandBuffer& cmd) {
const std::vector<vkhpp::ClearValue> renderPassBeginClearValues = {
vkhpp::ClearValue{
diff --git a/guest/BUILD.gn b/guest/BUILD.gn
index 33e5f65..6141cb2 100644
--- a/guest/BUILD.gn
+++ b/guest/BUILD.gn
@@ -215,10 +215,6 @@
"gralloc_cb/include/gralloc_cb_bp.h",
"platform/VirtGpu.cpp",
"platform/include/VirtGpu.h",
- "platform/stub/StubSync.cpp",
- "platform/stub/StubVirtGpuBlob.cpp",
- "platform/stub/StubVirtGpuBlobMapping.cpp",
- "platform/stub/StubVirtGpuDevice.cpp",
"qemupipe/include-types/qemu_pipe_types_bp.h",
"qemupipe/include/qemu_pipe_bp.h",
"qemupipe/qemu_pipe_common.cpp",
@@ -244,7 +240,6 @@
"vulkan_enc/VulkanStreamGuest.cpp",
"vulkan_enc/VulkanStreamGuest.h",
"vulkan_enc/func_table.cpp",
- "vulkan_enc/func_table.h",
"vulkan_enc/gfxstream_vk_private.cpp",
"vulkan_enc/gfxstream_vk_private.h",
"vulkan_enc/goldfish_vk_counting_guest.cpp",
@@ -266,9 +261,6 @@
if (target_os == "fuchsia") {
sources -= [
"OpenglSystemCommon/QemuPipeStream.cpp",
- "platform/stub/StubVirtGpuBlob.cpp",
- "platform/stub/StubVirtGpuBlobMapping.cpp",
- "platform/stub/StubVirtGpuDevice.cpp",
"qemupipe/qemu_pipe_common.cpp",
"qemupipe/qemu_pipe_guest.cpp",
]
diff --git a/guest/GoldfishAddressSpace/AddressSpaceStream.cpp b/guest/GoldfishAddressSpace/AddressSpaceStream.cpp
index d7262a8..5be329c 100644
--- a/guest/GoldfishAddressSpace/AddressSpaceStream.cpp
+++ b/guest/GoldfishAddressSpace/AddressSpaceStream.cpp
@@ -34,39 +34,33 @@
static const size_t kReadSize = 512 * 1024;
static const size_t kWriteOffset = kReadSize;
-AddressSpaceStream::AddressSpaceStream(
- address_space_handle_t handle,
- uint32_t version,
- struct asg_context context,
- uint64_t ringOffset,
- uint64_t writeBufferOffset,
- struct address_space_ops ops,
- HealthMonitor<>* healthMonitor) :
- IOStream(context.ring_config->flush_interval),
- m_ops(ops),
- m_tmpBuf(0),
- m_tmpBufSize(0),
- m_tmpBufXferSize(0),
- m_usingTmpBuf(0),
- m_readBuf(0),
- m_read(0),
- m_readLeft(0),
- m_handle(handle),
- m_version(version),
- m_context(context),
- m_ringOffset(ringOffset),
- m_writeBufferOffset(writeBufferOffset),
- m_writeBufferSize(context.ring_config->buffer_size),
- m_writeBufferMask(m_writeBufferSize - 1),
- m_buf((unsigned char*)context.buffer),
- m_writeStart(m_buf),
- m_writeStep(context.ring_config->flush_interval),
- m_notifs(0),
- m_written(0),
- m_backoffIters(0),
- m_backoffFactor(1),
- m_ringStorageSize(sizeof(struct asg_ring_storage) + m_writeBufferSize),
- m_healthMonitor(healthMonitor) {
+AddressSpaceStream::AddressSpaceStream(address_space_handle_t handle, uint32_t version,
+ struct asg_context context, uint64_t ringOffset,
+ uint64_t writeBufferOffset, struct address_space_ops ops)
+ : IOStream(context.ring_config->flush_interval),
+ m_ops(ops),
+ m_tmpBuf(0),
+ m_tmpBufSize(0),
+ m_tmpBufXferSize(0),
+ m_usingTmpBuf(0),
+ m_readBuf(0),
+ m_read(0),
+ m_readLeft(0),
+ m_handle(handle),
+ m_version(version),
+ m_context(context),
+ m_ringOffset(ringOffset),
+ m_writeBufferOffset(writeBufferOffset),
+ m_writeBufferSize(context.ring_config->buffer_size),
+ m_writeBufferMask(m_writeBufferSize - 1),
+ m_buf((unsigned char*)context.buffer),
+ m_writeStart(m_buf),
+ m_writeStep(context.ring_config->flush_interval),
+ m_notifs(0),
+ m_written(0),
+ m_backoffIters(0),
+ m_backoffFactor(1),
+ m_ringStorageSize(sizeof(struct asg_ring_storage) + m_writeBufferSize) {
// We'll use this in the future, but at the moment,
// it's a potential compile Werror.
(void)m_ringStorageSize;
@@ -95,8 +89,7 @@
return m_writeStep;
}
-void *AddressSpaceStream::allocBuffer(size_t minSize) {
- auto watchdog = WATCHDOG_BUILDER(m_healthMonitor, "ASG watchdog").build();
+void* AddressSpaceStream::allocBuffer(size_t minSize) {
AEMU_SCOPED_TRACE("allocBuffer");
ensureType3Finished();
@@ -242,9 +235,7 @@
return (const unsigned char*)dst;
}
-int AddressSpaceStream::writeFully(const void *buf, size_t size)
-{
- auto watchdog = WATCHDOG_BUILDER(m_healthMonitor, "ASG watchdog").build();
+int AddressSpaceStream::writeFully(const void* buf, size_t size) {
AEMU_SCOPED_TRACE("writeFully");
ensureType3Finished();
ensureType1Finished();
@@ -308,9 +299,7 @@
return 0;
}
-int AddressSpaceStream::writeFullyAsync(const void *buf, size_t size)
-{
- auto watchdog = WATCHDOG_BUILDER(m_healthMonitor, "ASG watchdog").build();
+int AddressSpaceStream::writeFullyAsync(const void* buf, size_t size) {
AEMU_SCOPED_TRACE("writeFullyAsync");
ensureType3Finished();
ensureType1Finished();
@@ -432,7 +421,6 @@
}
void AddressSpaceStream::notifyAvailable() {
- auto watchdog = WATCHDOG_BUILDER(m_healthMonitor, "ASG watchdog").build();
AEMU_SCOPED_TRACE("PING");
struct address_space_ping request;
request.metadata = ASG_NOTIFY_AVAILABLE;
@@ -475,7 +463,6 @@
}
void AddressSpaceStream::ensureType1Finished() {
- auto watchdog = WATCHDOG_BUILDER(m_healthMonitor, "ASG watchdog").build();
AEMU_SCOPED_TRACE("ensureType1Finished");
uint32_t currAvailRead =
@@ -492,7 +479,6 @@
}
void AddressSpaceStream::ensureType3Finished() {
- auto watchdog = WATCHDOG_BUILDER(m_healthMonitor, "ASG watchdog").build();
AEMU_SCOPED_TRACE("ensureType3Finished");
uint32_t availReadLarge =
ring_buffer_available_read(
@@ -516,8 +502,6 @@
}
int AddressSpaceStream::type1Write(uint32_t bufferOffset, size_t size) {
-
- auto watchdog = WATCHDOG_BUILDER(m_healthMonitor, "ASG watchdog").build();
AEMU_SCOPED_TRACE("type1Write");
ensureType3Finished();
diff --git a/guest/GoldfishAddressSpace/GoldfishAddressSpaceStream.cpp b/guest/GoldfishAddressSpace/GoldfishAddressSpaceStream.cpp
index 0315744..f1c8330 100644
--- a/guest/GoldfishAddressSpace/GoldfishAddressSpaceStream.cpp
+++ b/guest/GoldfishAddressSpace/GoldfishAddressSpaceStream.cpp
@@ -16,8 +16,7 @@
#include "goldfish_address_space.h"
-AddressSpaceStream* createGoldfishAddressSpaceStream(size_t ignored_bufSize,
- HealthMonitor<>* healthMonitor) {
+AddressSpaceStream* createGoldfishAddressSpaceStream(size_t ignored_bufSize) {
// Ignore incoming ignored_bufSize
(void)ignored_bufSize;
@@ -122,10 +121,8 @@
.ping = goldfish_address_space_ping,
};
- AddressSpaceStream* res =
- new AddressSpaceStream(
- child_device_handle, version, context,
- ringOffset, bufferOffset, ops, healthMonitor);
+ AddressSpaceStream* res = new AddressSpaceStream(child_device_handle, version, context,
+ ringOffset, bufferOffset, ops);
return res;
-}
\ No newline at end of file
+}
diff --git a/guest/GoldfishAddressSpace/VirtioGpuAddressSpaceStream.cpp b/guest/GoldfishAddressSpace/VirtioGpuAddressSpaceStream.cpp
index 03acca8..7bd6109 100644
--- a/guest/GoldfishAddressSpace/VirtioGpuAddressSpaceStream.cpp
+++ b/guest/GoldfishAddressSpace/VirtioGpuAddressSpaceStream.cpp
@@ -14,6 +14,8 @@
#include "VirtioGpuAddressSpaceStream.h"
+#include <cutils/log.h>
+
#include "util.h"
static bool GetRingParamsFromCapset(enum VirtGpuCapset capset, const VirtGpuCaps& caps,
@@ -74,8 +76,7 @@
return true;
}
-AddressSpaceStream* createVirtioGpuAddressSpaceStream(enum VirtGpuCapset capset,
- HealthMonitor<>* healthMonitor) {
+AddressSpaceStream* createVirtioGpuAddressSpaceStream(enum VirtGpuCapset capset) {
VirtGpuResourcePtr pipe, blob;
VirtGpuResourceMappingPtr pipeMapping, blobMapping;
struct VirtGpuExecBuffer exec = {};
@@ -141,7 +142,7 @@
};
AddressSpaceStream* res =
- new AddressSpaceStream((address_space_handle_t)(-1), 1, context, 0, 0, ops, healthMonitor);
+ new AddressSpaceStream((address_space_handle_t)(-1), 1, context, 0, 0, ops);
res->setMapping(blobMapping);
res->setResourceId(contextCreate.resourceId);
diff --git a/guest/GoldfishAddressSpace/include/AddressSpaceStream.h b/guest/GoldfishAddressSpace/include/AddressSpaceStream.h
index d602598..cda1b09 100644
--- a/guest/GoldfishAddressSpace/include/AddressSpaceStream.h
+++ b/guest/GoldfishAddressSpace/include/AddressSpaceStream.h
@@ -19,38 +19,29 @@
#include "VirtGpu.h"
#include "address_space.h"
#include "address_space_graphics_types.h"
-#include "aemu/base/AndroidHealthMonitor.h"
#include "gfxstream/guest/IOStream.h"
-using gfxstream::guest::HealthMonitor;
using gfxstream::guest::IOStream;
class AddressSpaceStream : public IOStream {
public:
- explicit AddressSpaceStream(
- address_space_handle_t handle,
- uint32_t version,
- struct asg_context context,
- uint64_t ringOffset,
- uint64_t writeBufferOffset,
- struct address_space_ops ops,
- HealthMonitor<>* healthMonitor);
- ~AddressSpaceStream();
+ explicit AddressSpaceStream(address_space_handle_t handle, uint32_t version,
+ struct asg_context context, uint64_t ringOffset,
+ uint64_t writeBufferOffset, struct address_space_ops ops);
+ ~AddressSpaceStream();
- virtual size_t idealAllocSize(size_t len);
- virtual void *allocBuffer(size_t minSize);
- virtual int commitBuffer(size_t size);
- virtual const unsigned char *readFully( void *buf, size_t len);
- virtual const unsigned char *read( void *buf, size_t *inout_len);
- virtual int writeFully(const void *buf, size_t len);
- virtual int writeFullyAsync(const void *buf, size_t len);
- virtual const unsigned char *commitBufferAndReadFully(size_t size, void *buf, size_t len);
+ virtual size_t idealAllocSize(size_t len);
+ virtual void* allocBuffer(size_t minSize);
+ virtual int commitBuffer(size_t size);
+ virtual const unsigned char* readFully(void* buf, size_t len);
+ virtual const unsigned char* read(void* buf, size_t* inout_len);
+ virtual int writeFully(const void* buf, size_t len);
+ virtual int writeFullyAsync(const void* buf, size_t len);
+ virtual const unsigned char* commitBufferAndReadFully(size_t size, void* buf, size_t len);
- void setMapping(VirtGpuResourceMappingPtr mapping) { m_mapping = mapping; }
+ void setMapping(VirtGpuResourceMappingPtr mapping) { m_mapping = mapping; }
- void setResourceId(uint32_t id) {
- m_resourceId = id;
- }
+ void setResourceId(uint32_t id) { m_resourceId = id; }
private:
bool isInError() const;
@@ -99,8 +90,6 @@
size_t m_ringStorageSize;
uint32_t m_resourceId = 0;
-
- HealthMonitor<>* m_healthMonitor;
};
#endif
diff --git a/guest/GoldfishAddressSpace/include/GoldfishAddressSpaceStream.h b/guest/GoldfishAddressSpace/include/GoldfishAddressSpaceStream.h
index b4a5be3..252f023 100644
--- a/guest/GoldfishAddressSpace/include/GoldfishAddressSpaceStream.h
+++ b/guest/GoldfishAddressSpace/include/GoldfishAddressSpaceStream.h
@@ -16,4 +16,4 @@
#include "AddressSpaceStream.h"
-AddressSpaceStream* createGoldfishAddressSpaceStream(size_t bufSize, gfxstream::guest::HealthMonitor<>* healthMonitor);
+AddressSpaceStream* createGoldfishAddressSpaceStream(size_t bufSize);
diff --git a/guest/GoldfishAddressSpace/include/VirtioGpuAddressSpaceStream.h b/guest/GoldfishAddressSpace/include/VirtioGpuAddressSpaceStream.h
index 4e7b0da..c3a6241 100644
--- a/guest/GoldfishAddressSpace/include/VirtioGpuAddressSpaceStream.h
+++ b/guest/GoldfishAddressSpace/include/VirtioGpuAddressSpaceStream.h
@@ -16,5 +16,4 @@
#include "AddressSpaceStream.h"
-AddressSpaceStream* createVirtioGpuAddressSpaceStream(
- enum VirtGpuCapset capset, gfxstream::guest::HealthMonitor<>* healthMonitor);
+AddressSpaceStream* createVirtioGpuAddressSpaceStream(enum VirtGpuCapset capset);
diff --git a/guest/OpenglSystemCommon/EmulatorFeatureInfo.h b/guest/OpenglSystemCommon/EmulatorFeatureInfo.h
index f7d32e1..90b989e 100644
--- a/guest/OpenglSystemCommon/EmulatorFeatureInfo.h
+++ b/guest/OpenglSystemCommon/EmulatorFeatureInfo.h
@@ -206,13 +206,6 @@
bool hasVulkanAuxCommandMemory; // This feature tracks if vulkan command buffers should be stored in an auxiliary shared memory
};
-enum HostConnectionType {
- HOST_CONNECTION_QEMU_PIPE = 1,
- HOST_CONNECTION_ADDRESS_SPACE = 2,
- HOST_CONNECTION_VIRTIO_GPU_PIPE = 3,
- HOST_CONNECTION_VIRTIO_GPU_ADDRESS_SPACE = 4,
-};
-
enum GrallocType {
GRALLOC_TYPE_RANCHU = 0,
GRALLOC_TYPE_MINIGBM = 1,
diff --git a/guest/OpenglSystemCommon/HostConnection.cpp b/guest/OpenglSystemCommon/HostConnection.cpp
index 2e3390d..cbde7cb 100644
--- a/guest/OpenglSystemCommon/HostConnection.cpp
+++ b/guest/OpenglSystemCommon/HostConnection.cpp
@@ -17,26 +17,13 @@
#include "GoldfishAddressSpaceStream.h"
#include "VirtioGpuAddressSpaceStream.h"
-#include "aemu/base/AndroidHealthMonitor.h"
-#include "aemu/base/AndroidHealthMonitorConsumerBasic.h"
#include "aemu/base/threads/AndroidThread.h"
#if defined(__ANDROID__)
#include "android-base/properties.h"
#endif
#include "renderControl_types.h"
-#define DEBUG_HOSTCONNECTION 0
-
-#if DEBUG_HOSTCONNECTION
-#define DPRINT(fmt,...) ALOGD("%s: " fmt, __FUNCTION__, ##__VA_ARGS__);
-#else
-#define DPRINT(...)
-#endif
-
using gfxstream::guest::ChecksumCalculator;
-using gfxstream::guest::CreateHealthMonitor;
-using gfxstream::guest::HealthMonitor;
-using gfxstream::guest::HealthMonitorConsumerBasic;
using gfxstream::guest::IOStream;
#ifdef GOLDFISH_NO_GL
@@ -101,15 +88,6 @@
constexpr const auto kEglProp = "ro.hardware.egl";
-HealthMonitor<>* getGlobalHealthMonitor() {
- // Initialize HealthMonitor
- // Rather than inject as a construct arg, we keep it as a static variable in the .cpp
- // to avoid setting up dependencies in other repos (external/qemu)
- static HealthMonitorConsumerBasic sHealthMonitorConsumerBasic;
- static std::unique_ptr<HealthMonitor<>> sHealthMonitor = CreateHealthMonitor(sHealthMonitorConsumerBasic);
- return sHealthMonitor.get();
-}
-
static HostConnectionType getConnectionTypeFromProperty(enum VirtGpuCapset capset) {
#if defined(__Fuchsia__) || defined(LINUX_GUEST_BUILD)
return HOST_CONNECTION_VIRTIO_GPU_ADDRESS_SPACE;
@@ -170,17 +148,13 @@
}
HostConnection::HostConnection()
- : exitUncleanly(false),
- m_checksumHelper(),
- m_hostExtensions(),
- m_noHostError(true),
- m_rendernodeFd(-1) { }
+ : m_checksumHelper(), m_hostExtensions(), m_noHostError(true), m_rendernodeFd(-1) {}
HostConnection::~HostConnection()
{
// round-trip to ensure that queued commands have been processed
// before process pipe closure is detected.
- if (m_rcEnc && !exitUncleanly) {
+ if (m_rcEnc) {
(void)m_rcEnc->rcGetRendererVersion(m_rcEnc.get());
}
@@ -193,9 +167,9 @@
}
}
-
// static
-std::unique_ptr<HostConnection> HostConnection::connect(enum VirtGpuCapset capset) {
+std::unique_ptr<HostConnection> HostConnection::connect(enum VirtGpuCapset capset,
+ int32_t descriptor) {
const enum HostConnectionType connType = getConnectionTypeFromProperty(capset);
uint32_t noRenderControlEnc = 0;
@@ -206,7 +180,7 @@
switch (connType) {
case HOST_CONNECTION_ADDRESS_SPACE: {
#if defined(__ANDROID__)
- auto stream = createGoldfishAddressSpaceStream(STREAM_BUFFER_SIZE, getGlobalHealthMonitor());
+ auto stream = createGoldfishAddressSpaceStream(STREAM_BUFFER_SIZE);
if (!stream) {
ALOGE("Failed to create AddressSpaceStream for host connection\n");
return nullptr;
@@ -252,10 +226,9 @@
case HOST_CONNECTION_VIRTIO_GPU_ADDRESS_SPACE: {
// Use kCapsetGfxStreamVulkan for now, Ranchu HWC needs to be modified to pass in
// right capset.
- auto device = VirtGpuDevice::getInstance(kCapsetGfxStreamVulkan);
+ auto device = VirtGpuDevice::getInstance(kCapsetGfxStreamVulkan, descriptor);
auto deviceHandle = device->getDeviceHandle();
- auto stream =
- createVirtioGpuAddressSpaceStream(kCapsetGfxStreamVulkan, getGlobalHealthMonitor());
+ auto stream = createVirtioGpuAddressSpaceStream(kCapsetGfxStreamVulkan);
if (!stream) {
ALOGE("Failed to create virtgpu AddressSpaceStream\n");
return nullptr;
@@ -298,8 +271,12 @@
noRenderControlEnc = caps.vulkanCapset.noRenderControlEnc;
}
- auto fd = (connType == HOST_CONNECTION_VIRTIO_GPU_ADDRESS_SPACE) ? con->m_rendernodeFd : -1;
- processPipeInit(fd, connType, noRenderControlEnc);
+ auto handle = (connType == HOST_CONNECTION_VIRTIO_GPU_ADDRESS_SPACE) ? con->m_rendernodeFd : -1;
+ if (descriptor >= 0) {
+ handle = descriptor;
+ }
+
+ processPipeInit(handle, connType, noRenderControlEnc);
if (!noRenderControlEnc && capset == kCapsetGfxStreamVulkan) {
con->rcEncoder();
}
@@ -307,20 +284,27 @@
return con;
}
-HostConnection* HostConnection::get() { return getWithThreadInfo(getEGLThreadInfo(), kCapsetNone); }
-
-HostConnection* HostConnection::getOrCreate(enum VirtGpuCapset capset) {
- return getWithThreadInfo(getEGLThreadInfo(), capset);
+HostConnection* HostConnection::get() {
+ return getWithThreadInfo(getEGLThreadInfo(), kCapsetNone, INVALID_DESCRIPTOR);
}
-HostConnection* HostConnection::getWithThreadInfo(EGLThreadInfo* tinfo, enum VirtGpuCapset capset) {
+HostConnection* HostConnection::getOrCreate(enum VirtGpuCapset capset) {
+ return getWithThreadInfo(getEGLThreadInfo(), capset, INVALID_DESCRIPTOR);
+}
+
+HostConnection* HostConnection::getWithDescriptor(enum VirtGpuCapset capset, int32_t descriptor) {
+ return getWithThreadInfo(getEGLThreadInfo(), capset, descriptor);
+}
+
+HostConnection* HostConnection::getWithThreadInfo(EGLThreadInfo* tinfo, enum VirtGpuCapset capset,
+ int32_t descriptor) {
// Get thread info
if (!tinfo) {
return NULL;
}
if (tinfo->hostConn == NULL) {
- tinfo->hostConn = HostConnection::createUnique(capset);
+ tinfo->hostConn = HostConnection::createUnique(capset, descriptor);
}
return tinfo->hostConn.get();
@@ -335,19 +319,10 @@
tinfo->hostConn.reset();
}
-void HostConnection::exitUnclean() {
- EGLThreadInfo *tinfo = getEGLThreadInfo();
- if (!tinfo) {
- return;
- }
-
- tinfo->hostConn->exitUncleanly = true;
- tinfo->hostConn.reset();
-}
-
// static
-std::unique_ptr<HostConnection> HostConnection::createUnique(enum VirtGpuCapset capset) {
- return connect(capset);
+std::unique_ptr<HostConnection> HostConnection::createUnique(enum VirtGpuCapset capset,
+ int32_t descriptor) {
+ return connect(capset, descriptor);
}
GLEncoder *HostConnection::glEncoder()
@@ -378,7 +353,7 @@
VkEncoder* HostConnection::vkEncoder() {
if (!m_vkEnc) {
- m_vkEnc = new VkEncoder(m_stream, getGlobalHealthMonitor());
+ m_vkEnc = new VkEncoder(m_stream);
}
return m_vkEnc;
}
@@ -474,7 +449,6 @@
void HostConnection::queryAndSetHostCompositionImpl(ExtendedRCEncoderContext *rcEnc) {
const std::string& hostExtensions = queryHostExtensions(rcEnc);
- DPRINT("HostComposition ext %s", hostExtensions.c_str());
// make sure V2 is checked first before V1, as host may declare supporting both
if (hostExtensions.find(kHostCompositionV2) != std::string::npos) {
rcEnc->setHostComposition(HOST_COMPOSITION_V2);
diff --git a/guest/OpenglSystemCommon/HostConnection.h b/guest/OpenglSystemCommon/HostConnection.h
index 228df4e..7199704 100644
--- a/guest/OpenglSystemCommon/HostConnection.h
+++ b/guest/OpenglSystemCommon/HostConnection.h
@@ -111,18 +111,27 @@
struct EGLThreadInfo;
+enum HostConnectionType {
+ HOST_CONNECTION_QEMU_PIPE = 1,
+ HOST_CONNECTION_ADDRESS_SPACE = 2,
+ HOST_CONNECTION_VIRTIO_GPU_PIPE = 3,
+ HOST_CONNECTION_VIRTIO_GPU_ADDRESS_SPACE = 4,
+};
+
class HostConnection
{
public:
static HostConnection *get();
static HostConnection* getOrCreate(enum VirtGpuCapset capset = kCapsetNone);
+ static HostConnection* getWithDescriptor(enum VirtGpuCapset capset,
+ int32_t descriptor); // For testing purposes
- static HostConnection* getWithThreadInfo(EGLThreadInfo* tInfo,
- enum VirtGpuCapset capset = kCapsetNone);
+ static HostConnection* getWithThreadInfo(EGLThreadInfo* tInfo, enum VirtGpuCapset capset,
+ int32_t descriptor);
static void exit();
- static void exitUnclean(); // for testing purposes
- static std::unique_ptr<HostConnection> createUnique(enum VirtGpuCapset capset = kCapsetNone);
+ static std::unique_ptr<HostConnection> createUnique(enum VirtGpuCapset capset,
+ int32_t descriptor);
HostConnection(const HostConnection&) = delete;
~HostConnection();
@@ -158,12 +167,10 @@
#pragma clang diagnostic pop
#endif
- bool exitUncleanly; // for testing purposes
-
private:
// If the connection failed, |conn| is deleted.
// Returns NULL if connection failed.
- static std::unique_ptr<HostConnection> connect(enum VirtGpuCapset capset);
+ static std::unique_ptr<HostConnection> connect(enum VirtGpuCapset capset, int32_t descriptor);
HostConnection();
static gl_client_context_t* s_getGLContext();
diff --git a/guest/OpenglSystemCommon/ProcessPipe.cpp b/guest/OpenglSystemCommon/ProcessPipe.cpp
index 890a1cb..1c66d2a 100644
--- a/guest/OpenglSystemCommon/ProcessPipe.cpp
+++ b/guest/OpenglSystemCommon/ProcessPipe.cpp
@@ -189,12 +189,6 @@
sNeedInit = true;
}
-void refreshHostConnection() {
- HostConnection* hostConn = HostConnection::get();
- ExtendedRCEncoderContext* rcEnc = hostConn->rcEncoder();
- rcEnc->rcSetPuid(rcEnc, sProcUID);
-}
-
uint32_t* getSeqnoPtrForProcess() {
// It's assumed process pipe state has already been initialized.
return sSeqnoPtr;
diff --git a/guest/OpenglSystemCommon/ProcessPipe.h b/guest/OpenglSystemCommon/ProcessPipe.h
index cb0a44f..b17572e 100644
--- a/guest/OpenglSystemCommon/ProcessPipe.h
+++ b/guest/OpenglSystemCommon/ProcessPipe.h
@@ -15,9 +15,8 @@
//
#pragma once
-#include "EmulatorFeatureInfo.h"
-
#include <stdint.h>
+#include "HostConnection.h"
// The process pipe is used to notify the host about process exits,
// also associate all process-owned host GL resources with a process unique ID
@@ -31,8 +30,6 @@
//
// This is called when creating rcEncoder.
-struct renderControl_encoder_context_t;
-
extern bool processPipeInit(int stream_handle, HostConnectionType connType,
uint32_t noRenderControlEnc);
extern uint64_t getPuid();
@@ -40,7 +37,6 @@
// For testing purposes; this will close the current process pipe if opened, reset the state to
// initial, and open it again with the same parameters.
extern void processPipeRestart();
-extern void refreshHostConnection();
// Each process gets a sequence number field.
uint32_t* getSeqnoPtrForProcess();
diff --git a/guest/egl/egl.cpp b/guest/egl/egl.cpp
index f74c95a..92f9337 100644
--- a/guest/egl/egl.cpp
+++ b/guest/egl/egl.cpp
@@ -158,26 +158,27 @@
return ret; \
}
-#define DEFINE_AND_VALIDATE_HOST_CONNECTION_FOR_TLS(ret, tls) \
- HostConnection* hostCon = HostConnection::getWithThreadInfo(tls); \
- if (!hostCon) { \
- ALOGE("egl: Failed to get host connection\n"); \
- return ret; \
- } \
- ExtendedRCEncoderContext* rcEnc = hostCon->rcEncoder(); \
- if (!rcEnc) { \
- ALOGE("egl: Failed to get renderControl encoder context\n"); \
- return ret; \
- } \
- auto const* grallocHelper = hostCon->grallocHelper(); \
- if (!grallocHelper) { \
- ALOGE("egl: Failed to get grallocHelper\n"); \
- return ret; \
- } \
- auto* anwHelper = hostCon->anwHelper(); \
- if (!anwHelper) { \
- ALOGE("egl: Failed to get anwHelper\n"); \
- return ret; \
+#define DEFINE_AND_VALIDATE_HOST_CONNECTION_FOR_TLS(ret, tls) \
+ HostConnection* hostCon = \
+ HostConnection::getWithThreadInfo(tls, kCapsetNone, INVALID_DESCRIPTOR); \
+ if (!hostCon) { \
+ ALOGE("egl: Failed to get host connection\n"); \
+ return ret; \
+ } \
+ ExtendedRCEncoderContext* rcEnc = hostCon->rcEncoder(); \
+ if (!rcEnc) { \
+ ALOGE("egl: Failed to get renderControl encoder context\n"); \
+ return ret; \
+ } \
+ auto const* grallocHelper = hostCon->grallocHelper(); \
+ if (!grallocHelper) { \
+ ALOGE("egl: Failed to get grallocHelper\n"); \
+ return ret; \
+ } \
+ auto* anwHelper = hostCon->anwHelper(); \
+ if (!anwHelper) { \
+ ALOGE("egl: Failed to get anwHelper\n"); \
+ return ret; \
}
#define VALIDATE_CONTEXT_RETURN(context,ret) \
@@ -2608,3 +2609,13 @@
return EGL_TRUE;
}
+
+EGLBoolean eglInitializeKumquat(EGLint descriptor) {
+ HostConnection* hostCon = HostConnection::getWithDescriptor(kCapsetNone, descriptor);
+ if (!hostCon) {
+ ALOGE("egl: Failed to get kumquat connection");
+ return EGL_FALSE;
+ }
+
+ return EGL_TRUE;
+}
diff --git a/guest/egl/eglDisplay.h b/guest/egl/eglDisplay.h
index 9535027..d1d57c2 100644
--- a/guest/egl/eglDisplay.h
+++ b/guest/egl/eglDisplay.h
@@ -128,4 +128,5 @@
HostDriverCaps m_hostDriverCaps;
};
+EGLBoolean eglInitializeKumquat(EGLint descriptor);
#endif
diff --git a/guest/egl/egl_ftable.h b/guest/egl/egl_ftable.h
index 16d130c..607ef0c 100644
--- a/guest/egl/egl_ftable.h
+++ b/guest/egl/egl_ftable.h
@@ -58,7 +58,8 @@
{"eglCreateSyncKHR", (void *)eglCreateSyncKHR},
{"eglDestroySyncKHR", (void *)eglDestroySyncKHR},
{"eglClientWaitSyncKHR", (void *)eglClientWaitSyncKHR},
- {"eglGetSyncAttribKHR", (void *)eglGetSyncAttribKHR}
+ {"eglGetSyncAttribKHR", (void *)eglGetSyncAttribKHR},
+ {"eglInitializeKumquat", (void*)eglInitializeKumquat}
};
static const int egl_num_funcs = sizeof(egl_funcs_by_name) / sizeof(struct _egl_funcs_by_name);
diff --git a/guest/gralloc_cb/Android.bp b/guest/gralloc_cb/Android.bp
index 7fa1b97..1fc89aa 100644
--- a/guest/gralloc_cb/Android.bp
+++ b/guest/gralloc_cb/Android.bp
@@ -26,10 +26,8 @@
export_include_dirs: ["include"],
header_libs: [
"libcutils_headers",
- "libqemupipe-types.ranchu",
],
export_header_lib_headers: [
"libcutils_headers",
- "libqemupipe-types.ranchu",
],
}
diff --git a/guest/gralloc_cb/include/gralloc_cb_bp.h b/guest/gralloc_cb/include/gralloc_cb_bp.h
index 7817671..834ba4e 100644
--- a/guest/gralloc_cb/include/gralloc_cb_bp.h
+++ b/guest/gralloc_cb/include/gralloc_cb_bp.h
@@ -17,10 +17,8 @@
#ifndef __GRALLOC_CB_H__
#define __GRALLOC_CB_H__
-#include <cutils/native_handle.h>
-#include <qemu_pipe_types_bp.h>
-
#include <cinttypes>
+#include <cutils/native_handle.h>
const uint32_t CB_HANDLE_MAGIC_MASK = 0xFFFFFFF0;
const uint32_t CB_HANDLE_MAGIC_BASE = 0xABFABFA0;
@@ -32,6 +30,7 @@
cb_handle_t(uint32_t p_magic,
uint32_t p_hostHandle,
int32_t p_format,
+ uint32_t p_usage,
uint32_t p_drmformat,
uint32_t p_stride,
uint32_t p_bufSize,
@@ -39,6 +38,7 @@
: magic(p_magic),
hostHandle(p_hostHandle),
format(p_format),
+ usage(p_usage),
drmformat(p_drmformat),
bufferSize(p_bufSize),
stride(p_stride),
@@ -80,6 +80,7 @@
uint32_t magic; // magic number in order to validate a pointer
uint32_t hostHandle; // the host reference to this buffer
uint32_t format; // real internal pixel format format
+ uint32_t usage; // allocation usage
uint32_t drmformat; // drm format
uint32_t bufferSize;
uint32_t stride;
diff --git a/guest/magma/magma.cpp b/guest/magma/magma.cpp
index 4f4fa2c..3f1aa72 100644
--- a/guest/magma/magma.cpp
+++ b/guest/magma/magma.cpp
@@ -376,7 +376,7 @@
static std::once_flag once_flag;
std::call_once(once_flag, []() {
- auto stream = createVirtioGpuAddressSpaceStream(kCapsetGfxStreamMagma, nullptr);
+ auto stream = createVirtioGpuAddressSpaceStream(kCapsetGfxStreamMagma);
assert(stream);
// RenderThread expects flags: send zero 'clientFlags' to the host.
diff --git a/guest/platform/Android.bp b/guest/platform/Android.bp
index 1905bc2..7fe0b91 100644
--- a/guest/platform/Android.bp
+++ b/guest/platform/Android.bp
@@ -136,37 +136,3 @@
},
},
}
-
-cc_library_static {
- name: "libgfxstream_platform_stub",
- host_supported: true,
- vendor: true,
- srcs: [
- "VirtGpu.cpp",
- "stub/StubVirtGpuBlob.cpp",
- "stub/StubVirtGpuBlobMapping.cpp",
- "stub/StubVirtGpuDevice.cpp",
- "stub/StubSync.cpp",
- ],
- shared_libs: [
- "libcutils",
- "libdrm",
- "liblog",
- "libutils",
- ],
- export_shared_lib_headers: [
- "libdrm",
- ],
- export_include_dirs: [
- "include",
- ],
- cflags: [
- "-DLOG_TAG=\"platform\"",
- "-Wno-missing-field-initializers",
- "-fvisibility=default",
- "-fstrict-aliasing",
- ],
- local_include_dirs: [
- "include",
- ],
-}
diff --git a/guest/platform/VirtGpu.cpp b/guest/platform/VirtGpu.cpp
index 6cb2c58..5cf902b 100644
--- a/guest/platform/VirtGpu.cpp
+++ b/guest/platform/VirtGpu.cpp
@@ -23,7 +23,7 @@
} // namespace
-VirtGpuDevice* VirtGpuDevice::getInstance(enum VirtGpuCapset capset) {
+VirtGpuDevice* VirtGpuDevice::getInstance(enum VirtGpuCapset capset, int32_t descriptor) {
// If kCapsetNone is passed, we return a device that was created with any capset.
// Otherwise, the created device's capset must match the requested capset.
// We could support multiple capsets with a map of devices but that case isn't needed
@@ -34,7 +34,7 @@
return nullptr;
}
if (!sDevice) {
- sDevice = createPlatformVirtGpuDevice(capset);
+ sDevice = createPlatformVirtGpuDevice(capset, descriptor);
}
return sDevice;
}
@@ -45,7 +45,3 @@
sDevice = nullptr;
}
}
-
-void VirtGpuDevice::setInstanceForTesting(VirtGpuDevice* device) {
- sDevice = device;
-}
diff --git a/guest/platform/fuchsia/FuchsiaVirtGpuDevice.cpp b/guest/platform/fuchsia/FuchsiaVirtGpuDevice.cpp
index 7868ec6..91c383d 100644
--- a/guest/platform/fuchsia/FuchsiaVirtGpuDevice.cpp
+++ b/guest/platform/fuchsia/FuchsiaVirtGpuDevice.cpp
@@ -95,11 +95,10 @@
struct VirtGpuCaps FuchsiaVirtGpuDevice::getCaps(void) { return {}; }
-VirtGpuDevice* createPlatformVirtGpuDevice(enum VirtGpuCapset capset, int fd) {
+VirtGpuDevice* createPlatformVirtGpuDevice(enum VirtGpuCapset capset, int32_t descriptor) {
// We don't handle the VirtioGpuPipeStream case.
- if (fd >= 0) {
+ if (descriptor >= 0) {
ALOGE("Fuchsia: fd not handled");
- abort();
return nullptr;
}
diff --git a/guest/platform/include/VirtGpu.h b/guest/platform/include/VirtGpu.h
index b9afbdf..aee1ae8 100644
--- a/guest/platform/include/VirtGpu.h
+++ b/guest/platform/include/VirtGpu.h
@@ -141,6 +141,8 @@
struct composerCapset composerCapset;
};
+#define INVALID_DESCRIPTOR -1
+
class VirtGpuResourceMapping;
class VirtGpuResource;
using VirtGpuResourcePtr = std::shared_ptr<VirtGpuResource>;
@@ -177,30 +179,29 @@
class VirtGpuDevice {
public:
- static VirtGpuDevice* getInstance(enum VirtGpuCapset capset = kCapsetNone);
- static void resetInstance();
+ static VirtGpuDevice* getInstance(enum VirtGpuCapset capset = kCapsetNone,
+ int32_t descriptor = INVALID_DESCRIPTOR);
+ static void resetInstance();
- static void setInstanceForTesting(VirtGpuDevice* device);
+ VirtGpuDevice(enum VirtGpuCapset capset) : mCapset(capset) {}
+ virtual ~VirtGpuDevice() {}
- VirtGpuDevice(enum VirtGpuCapset capset) : mCapset(capset) {}
- virtual ~VirtGpuDevice() {}
+ enum VirtGpuCapset capset() { return mCapset; }
- enum VirtGpuCapset capset() { return mCapset; }
+ virtual int64_t getDeviceHandle(void) = 0;
- virtual int64_t getDeviceHandle(void) = 0;
+ virtual struct VirtGpuCaps getCaps(void) = 0;
- virtual struct VirtGpuCaps getCaps(void) = 0;
+ virtual VirtGpuResourcePtr createBlob(const struct VirtGpuCreateBlob& blobCreate) = 0;
+ virtual VirtGpuResourcePtr createResource(uint32_t width, uint32_t height, uint32_t stride,
+ uint32_t size, uint32_t virglFormat, uint32_t target,
+ uint32_t bind) = 0;
+ virtual VirtGpuResourcePtr importBlob(const struct VirtGpuExternalHandle& handle) = 0;
- virtual VirtGpuResourcePtr createBlob(const struct VirtGpuCreateBlob& blobCreate) = 0;
- virtual VirtGpuResourcePtr createResource(uint32_t width, uint32_t height, uint32_t stride,
- uint32_t size, uint32_t virglFormat, uint32_t target,
- uint32_t bind) = 0;
- virtual VirtGpuResourcePtr importBlob(const struct VirtGpuExternalHandle& handle) = 0;
+ virtual int execBuffer(struct VirtGpuExecBuffer& execbuffer, const VirtGpuResource* blob) = 0;
- virtual int execBuffer(struct VirtGpuExecBuffer& execbuffer, const VirtGpuResource* blob) = 0;
-
- private:
- enum VirtGpuCapset mCapset;
+ private:
+ enum VirtGpuCapset mCapset;
};
VirtGpuDevice* createPlatformVirtGpuDevice(enum VirtGpuCapset capset = kCapsetNone, int fd = -1);
diff --git a/guest/platform/kumquat/VirtGpuKumquatDevice.cpp b/guest/platform/kumquat/VirtGpuKumquatDevice.cpp
index 774c9dc..0b7263e 100644
--- a/guest/platform/kumquat/VirtGpuKumquatDevice.cpp
+++ b/guest/platform/kumquat/VirtGpuKumquatDevice.cpp
@@ -32,7 +32,8 @@
static inline uint32_t align_up(uint32_t n, uint32_t a) { return ((n + a - 1) / a) * a; }
-VirtGpuKumquatDevice::VirtGpuKumquatDevice(enum VirtGpuCapset capset, int) : VirtGpuDevice(capset) {
+VirtGpuKumquatDevice::VirtGpuKumquatDevice(enum VirtGpuCapset capset, int32_t descriptor)
+ : VirtGpuDevice(capset) {
struct VirtGpuParam params[] = {
PARAM(VIRTGPU_KUMQUAT_PARAM_3D_FEATURES),
PARAM(VIRTGPU_KUMQUAT_PARAM_CAPSET_QUERY_FIX),
@@ -51,6 +52,7 @@
struct drm_kumquat_context_init init = {0};
struct drm_kumquat_context_set_param ctx_set_params[3] = {{0}};
const char* processName = nullptr;
+ std::string gpu_socket_path = "/tmp/kumquat-gpu-";
memset(&mCaps, 0, sizeof(struct VirtGpuCaps));
@@ -58,7 +60,13 @@
processName = getprogname();
#endif
- ret = virtgpu_kumquat_init(&mVirtGpu, nullptr);
+ if (descriptor >= 0) {
+ gpu_socket_path.append(std::to_string(descriptor));
+ } else {
+ gpu_socket_path.append("0");
+ }
+
+ ret = virtgpu_kumquat_init(&mVirtGpu, gpu_socket_path.c_str());
if (ret) {
ALOGV("Failed to init virtgpu kumquat");
return;
@@ -240,6 +248,6 @@
return 0;
}
-VirtGpuDevice* createPlatformVirtGpuDevice(enum VirtGpuCapset capset, int fd) {
- return new VirtGpuKumquatDevice(capset, fd);
+VirtGpuDevice* createPlatformVirtGpuDevice(enum VirtGpuCapset capset, int32_t descriptor) {
+ return new VirtGpuKumquatDevice(capset, descriptor);
}
diff --git a/guest/platform/linux/LinuxVirtGpuDevice.cpp b/guest/platform/linux/LinuxVirtGpuDevice.cpp
index af7b05b..7e9b445 100644
--- a/guest/platform/linux/LinuxVirtGpuDevice.cpp
+++ b/guest/platform/linux/LinuxVirtGpuDevice.cpp
@@ -39,7 +39,8 @@
static inline uint32_t align_up(uint32_t n, uint32_t a) { return ((n + a - 1) / a) * a; }
-LinuxVirtGpuDevice::LinuxVirtGpuDevice(enum VirtGpuCapset capset, int fd) : VirtGpuDevice(capset) {
+LinuxVirtGpuDevice::LinuxVirtGpuDevice(enum VirtGpuCapset capset, int32_t descriptor)
+ : VirtGpuDevice(capset) {
struct VirtGpuParam params[] = {
PARAM(VIRTGPU_PARAM_3D_FEATURES), PARAM(VIRTGPU_PARAM_CAPSET_QUERY_FIX),
PARAM(VIRTGPU_PARAM_RESOURCE_BLOB), PARAM(VIRTGPU_PARAM_HOST_VISIBLE),
@@ -61,14 +62,14 @@
processName = getprogname();
#endif
- if (fd < 0) {
+ if (descriptor < 0) {
mDeviceHandle = static_cast<int64_t>(drmOpenRender(128));
if (mDeviceHandle < 0) {
ALOGE("Failed to open rendernode: %s", strerror(errno));
return;
}
} else {
- mDeviceHandle = dup(fd);
+ mDeviceHandle = dup(descriptor);
if (mDeviceHandle < 0) {
ALOGE("Failed to dup rendernode: %s", strerror(errno));
return;
@@ -257,6 +258,6 @@
return 0;
}
-VirtGpuDevice* createPlatformVirtGpuDevice(enum VirtGpuCapset capset, int fd) {
- return new LinuxVirtGpuDevice(capset, fd);
+VirtGpuDevice* createPlatformVirtGpuDevice(enum VirtGpuCapset capset, int32_t descriptor) {
+ return new LinuxVirtGpuDevice(capset, descriptor);
}
diff --git a/guest/platform/meson.build b/guest/platform/meson.build
index ba0f6d6..923145c 100644
--- a/guest/platform/meson.build
+++ b/guest/platform/meson.build
@@ -6,5 +6,4 @@
subdir('kumquat')
else
subdir('linux')
- subdir('stub')
endif
diff --git a/guest/platform/rutabaga/RutabagaVirtGpuDevice.cpp b/guest/platform/rutabaga/RutabagaVirtGpuDevice.cpp
index 4ae1636..3e24190 100644
--- a/guest/platform/rutabaga/RutabagaVirtGpuDevice.cpp
+++ b/guest/platform/rutabaga/RutabagaVirtGpuDevice.cpp
@@ -150,7 +150,7 @@
} // namespace gfxstream
-VirtGpuDevice* createPlatformVirtGpuDevice(enum VirtGpuCapset capset, int) {
+VirtGpuDevice* createPlatformVirtGpuDevice(enum VirtGpuCapset capset, int32_t) {
std::shared_ptr<gfxstream::EmulatedVirtioGpu> emulation = gfxstream::EmulatedVirtioGpu::Get();
if (!emulation) {
ALOGE("Failed to create RutabagaVirtGpuDevice: failed to get emulation layer.");
diff --git a/guest/platform/stub/StubSync.cpp b/guest/platform/stub/StubSync.cpp
deleted file mode 100644
index 96ca11a..0000000
--- a/guest/platform/stub/StubSync.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright 2023 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "StubSync.h"
-
-namespace gfxstream {
-
-StubSyncHelper::StubSyncHelper() {}
-
-int StubSyncHelper::wait(int, int) {
- return -1;
-}
-
-int StubSyncHelper::dup(int) {
- return -1;
-}
-
-int StubSyncHelper::close(int) {
- return -1;
-}
-
-SyncHelper* createPlatformSyncHelper() {
- return new StubSyncHelper();
-}
-
-} // namespace gfxstream
diff --git a/guest/platform/stub/StubSync.h b/guest/platform/stub/StubSync.h
deleted file mode 100644
index b081ac5..0000000
--- a/guest/platform/stub/StubSync.h
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright 2023 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either expresso or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include "Sync.h"
-
-namespace gfxstream {
-
-class StubSyncHelper : public SyncHelper {
- public:
- StubSyncHelper();
-
- int wait(int syncFd, int timeoutMilliseconds) override;
-
- int dup(int syncFd) override;
-
- int close(int syncFd) override;
-};
-
-} // namespace gfxstream
diff --git a/guest/platform/stub/StubVirtGpu.h b/guest/platform/stub/StubVirtGpu.h
deleted file mode 100644
index c8f8178..0000000
--- a/guest/platform/stub/StubVirtGpu.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * Copyright 2023 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "VirtGpu.h"
-
-class StubVirtGpuResource : public std::enable_shared_from_this<StubVirtGpuResource>,
- public VirtGpuResource {
- public:
- StubVirtGpuResource(int64_t deviceHandle, uint32_t blobHandle, uint32_t resourceHandle,
- uint64_t size);
- ~StubVirtGpuResource();
-
- uint32_t getResourceHandle() const override;
- uint32_t getBlobHandle() const override;
- int wait(void) override;
-
- VirtGpuResourceMappingPtr createMapping(void) override;
- int exportBlob(struct VirtGpuExternalHandle& handle) override;
-
- int transferFromHost(uint32_t x, uint32_t y, uint32_t w, uint32_t h) override;
- int transferToHost(uint32_t x, uint32_t y, uint32_t w, uint32_t h) override;
-
- private:
- // Not owned. Really should use a ScopedFD for this, but doesn't matter since we have a
- // singleton deviceimplemenentation anyways.
- int64_t mDeviceHandle;
-
- uint32_t mBlobHandle;
- uint32_t mResourceHandle;
- uint64_t mSize;
-};
-
-class StubVirtGpuResourceMapping : public VirtGpuResourceMapping {
- public:
- StubVirtGpuResourceMapping(VirtGpuResourcePtr blob, uint8_t* ptr, uint64_t size);
- ~StubVirtGpuResourceMapping(void);
-
- uint8_t* asRawPtr(void) override;
-
- private:
- VirtGpuResourcePtr mBlob;
- uint8_t* mPtr;
- uint64_t mSize;
-};
-
-class StubVirtGpuDevice : public VirtGpuDevice {
- public:
- StubVirtGpuDevice(enum VirtGpuCapset capset);
- virtual ~StubVirtGpuDevice();
-
- int64_t getDeviceHandle(void) override;
-
- struct VirtGpuCaps getCaps(void) override;
-
- VirtGpuResourcePtr createBlob(const struct VirtGpuCreateBlob& blobCreate) override;
- VirtGpuResourcePtr createResource(uint32_t width, uint32_t height, uint32_t stride,
- uint32_t size, uint32_t virglFormat, uint32_t target,
- uint32_t bind);
- VirtGpuResourcePtr importBlob(const struct VirtGpuExternalHandle& handle) override;
-
- int execBuffer(struct VirtGpuExecBuffer& execbuffer, const VirtGpuResource* blob) override;
-
- virtual VirtGpuResourcePtr createColorBuffer(int width, int height, uint32_t glFormat);
- virtual VirtGpuResourcePtr createColorBuffer(int size);
-
- private:
- int64_t mDeviceHandle;
-
- struct VirtGpuCaps mCaps;
-};
diff --git a/guest/platform/stub/StubVirtGpuBlob.cpp b/guest/platform/stub/StubVirtGpuBlob.cpp
deleted file mode 100644
index 588d49b..0000000
--- a/guest/platform/stub/StubVirtGpuBlob.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "StubVirtGpu.h"
-
-StubVirtGpuResource::StubVirtGpuResource(int64_t deviceHandle, uint32_t blobHandle,
- uint32_t resourceHandle, uint64_t size)
- : mDeviceHandle(deviceHandle),
- mBlobHandle(blobHandle),
- mResourceHandle(resourceHandle),
- mSize(size) {}
-
-StubVirtGpuResource::~StubVirtGpuResource() {
- // Unimplemented stub
-}
-
-uint32_t StubVirtGpuResource::getBlobHandle() const { return 0; }
-
-uint32_t StubVirtGpuResource::getResourceHandle() const { return 0; }
-
-VirtGpuResourceMappingPtr StubVirtGpuResource::createMapping() { return nullptr; }
-
-int StubVirtGpuResource::wait() { return -1; }
-
-int StubVirtGpuResource::transferFromHost(uint32_t, uint32_t, uint32_t, uint32_t) { return -1; }
-
-int StubVirtGpuResource::transferToHost(uint32_t, uint32_t, uint32_t, uint32_t) { return -1; }
diff --git a/guest/platform/stub/StubVirtGpuBlobMapping.cpp b/guest/platform/stub/StubVirtGpuBlobMapping.cpp
deleted file mode 100644
index a17f052..0000000
--- a/guest/platform/stub/StubVirtGpuBlobMapping.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "StubVirtGpu.h"
-
-StubVirtGpuResourceMapping::StubVirtGpuResourceMapping(VirtGpuResourcePtr blob, uint8_t* ptr,
- uint64_t size)
- : mBlob(blob), mPtr(ptr), mSize(size) {}
-
-StubVirtGpuResourceMapping::~StubVirtGpuResourceMapping(void) {
- // Unimplemented for now
- (void) mPtr;
- (void) mSize;
- (void) mBlob;
-}
-
-uint8_t* StubVirtGpuResourceMapping::asRawPtr(void) { return nullptr; }
diff --git a/guest/platform/stub/StubVirtGpuDevice.cpp b/guest/platform/stub/StubVirtGpuDevice.cpp
deleted file mode 100644
index f642b25..0000000
--- a/guest/platform/stub/StubVirtGpuDevice.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "StubVirtGpu.h"
-
-StubVirtGpuDevice::StubVirtGpuDevice(enum VirtGpuCapset capset) : VirtGpuDevice(capset) {
- // Unimplemented stub
-}
-
-struct VirtGpuCaps StubVirtGpuDevice::getCaps(void) { return mCaps; }
-
-int64_t StubVirtGpuDevice::getDeviceHandle(void) {
- return mDeviceHandle;
-}
-
-VirtGpuResourcePtr StubVirtGpuDevice::createResource(uint32_t width, uint32_t height,
- uint32_t stride, uint32_t size,
- uint32_t virglFormat, uint32_t target,
- uint32_t bind) {
- (void)width;
- (void)height;
- (void)stride;
- (void)size;
- (void)virglFormat;
- (void)target;
- (void)bind;
- return nullptr;
-}
-
-VirtGpuResourcePtr StubVirtGpuDevice::createBlob(const struct VirtGpuCreateBlob&) {
- return nullptr;
-}
-
-VirtGpuResourcePtr StubVirtGpuDevice::importBlob(const struct VirtGpuExternalHandle&) {
- return nullptr;
-}
-
-int StubVirtGpuDevice::execBuffer(struct VirtGpuExecBuffer&, const VirtGpuResource*) { return -1; }
-
-VirtGpuResourcePtr createColorBuffer(int, int, uint32_t) { return nullptr; }
-
-VirtGpuResourcePtr createColorBuffer(int) { return nullptr; }
-
-StubVirtGpuDevice::~StubVirtGpuDevice() {
- // Unimplemented stub
-}
-
-VirtGpuDevice* createPlatformVirtGpuDevice(enum VirtGpuCapset capset, int) {
- return new StubVirtGpuDevice(capset);
-}
diff --git a/guest/platform/stub/meson.build b/guest/platform/stub/meson.build
deleted file mode 100644
index 1db61a6..0000000
--- a/guest/platform/stub/meson.build
+++ /dev/null
@@ -1,18 +0,0 @@
-# Copyright 2022 Android Open Source Project
-# SPDX-License-Identifier: MIT
-
-files_lib_platform = files(
- '../VirtGpu.cpp',
- 'StubVirtGpuDevice.cpp',
- 'StubVirtGpuBlobMapping.cpp',
- 'StubVirtGpuBlob.cpp',
- 'StubSync.cpp',
-)
-
-lib_platform_stub = static_library(
- 'stub_platform',
- files_lib_platform,
- cpp_args: gfxstream_guest_args,
- include_directories: [inc_platform, inc_android_compat],
- dependencies: drm_dep,
-)
diff --git a/guest/rendercontrol/RenderControl.cpp b/guest/rendercontrol/RenderControl.cpp
index ade2447..ee2598a 100644
--- a/guest/rendercontrol/RenderControl.cpp
+++ b/guest/rendercontrol/RenderControl.cpp
@@ -48,7 +48,8 @@
class RenderControlDeviceImpl {
public:
- RenderControlDeviceImpl() : mHostConnection(HostConnection::createUnique()) {}
+ RenderControlDeviceImpl()
+ : mHostConnection(HostConnection::createUnique(kCapsetNone, INVALID_DESCRIPTOR)) {}
RenderControlDeviceImpl(const RenderControlDeviceImpl& rhs) = delete;
RenderControlDeviceImpl& operator=(const RenderControlDeviceImpl& rhs) = delete;
diff --git a/guest/vulkan/gfxstream_vk_device.cpp b/guest/vulkan/gfxstream_vk_device.cpp
index 4c022e8..5b51e50 100644
--- a/guest/vulkan/gfxstream_vk_device.cpp
+++ b/guest/vulkan/gfxstream_vk_device.cpp
@@ -99,6 +99,18 @@
return VK_SUCCESS;
}
+#if defined(END2END_TESTS)
+static VkResult vkInitializeKumquat(uint32_t descriptor) {
+ HostConnection* hostCon = HostConnection::getWithDescriptor(kCapsetGfxStreamVulkan, descriptor);
+ if (!hostCon) {
+ mesa_loge("failed to get kumquat connection");
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+ return VK_SUCCESS;
+}
+#endif
+
static bool isMesaOnlyInstanceExtension(const char* name) {
for (auto mesaExt : kMesaOnlyInstanceExtension) {
if (!strncmp(mesaExt, name, VK_MAX_EXTENSION_NAME_SIZE)) return true;
@@ -634,6 +646,13 @@
PFN_vkVoidFunction gfxstream_vk_GetInstanceProcAddr(VkInstance _instance, const char* pName) {
VK_FROM_HANDLE(gfxstream_vk_instance, instance, _instance);
+
+#if defined(END2END_TESTS)
+ if (strcmp(pName, "vkInitializeKumquat") == 0) {
+ return (PFN_vkVoidFunction)vkInitializeKumquat;
+ }
+#endif
+
return vk_instance_get_proc_addr(&instance->vk, &gfxstream_vk_instance_entrypoints, pName);
}
diff --git a/guest/vulkan_enc/AndroidHardwareBuffer.cpp b/guest/vulkan_enc/AndroidHardwareBuffer.cpp
index f8e4e41..1a5d93a 100644
--- a/guest/vulkan_enc/AndroidHardwareBuffer.cpp
+++ b/guest/vulkan_enc/AndroidHardwareBuffer.cpp
@@ -43,22 +43,29 @@
const VkImageUsageFlags vk_usage) {
uint64_t ahw_usage = 0;
- if (vk_usage & VK_IMAGE_USAGE_SAMPLED_BIT) ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
-
- if (vk_usage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)
+ if (vk_usage & VK_IMAGE_USAGE_SAMPLED_BIT) {
ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
-
- if (vk_usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
+ }
+ if (vk_usage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT) {
+ ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
+ }
+ if (vk_usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) {
ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT;
-
- if (vk_create & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)
+ }
+ if (vk_usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {
+ ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT;
+ }
+ if (vk_create & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) {
ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP;
-
- if (vk_create & VK_IMAGE_CREATE_PROTECTED_BIT)
+ }
+ if (vk_create & VK_IMAGE_CREATE_PROTECTED_BIT) {
ahw_usage |= AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT;
+ }
/* No usage bits set - set at least one GPU usage. */
- if (ahw_usage == 0) ahw_usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
+ if (ahw_usage == 0) {
+ ahw_usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
+ }
return ahw_usage;
}
diff --git a/guest/vulkan_enc/VkEncoder.cpp b/guest/vulkan_enc/VkEncoder.cpp
index 0e41d65..a178049 100644
--- a/guest/vulkan_enc/VkEncoder.cpp
+++ b/guest/vulkan_enc/VkEncoder.cpp
@@ -47,7 +47,6 @@
#include "VulkanStreamGuest.h"
#include "aemu/base/AlignedBuf.h"
#include "aemu/base/BumpPool.h"
-#include "aemu/base/synchronization/AndroidLock.h"
#include "gfxstream/guest/IOStream.h"
#include "goldfish_vk_counting_guest.h"
#include "goldfish_vk_deepcopy_guest.h"
@@ -61,9 +60,7 @@
using namespace gfxstream::vk;
-using gfxstream::guest::AutoLock;
using gfxstream::guest::BumpPool;
-using gfxstream::guest::Lock;
#include "VkEncoder.cpp.inl"
@@ -79,33 +76,6 @@
VkResult VkEncoder::vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkInstance* pInstance,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateInstance in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCreateInstance(pCreateInfo:%p, pAllocator:%p, pInstance:%p)", pCreateInfo,
pAllocator, pInstance);
(void)doLock;
@@ -152,14 +122,12 @@
*countPtr += 8;
}
uint32_t packetSize_vkCreateInstance = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateInstance);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateInstance);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateInstance = OP_vkCreateInstance;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateInstance, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateInstance, sizeof(uint32_t));
@@ -186,12 +154,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCreateInstance), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_2;
stream->read((uint64_t*)&cgen_var_2, 8);
@@ -212,33 +174,6 @@
void VkEncoder::vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyInstance in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroyInstance(instance:%p, pAllocator:%p)", instance, pAllocator);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -274,14 +209,12 @@
}
uint32_t packetSize_vkDestroyInstance =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyInstance);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyInstance);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyInstance = OP_vkDestroyInstance;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyInstance, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyInstance, sizeof(uint32_t));
@@ -304,12 +237,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkDestroyInstance), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkInstance((VkInstance*)&instance);
stream->flush();
++encodeCount;
@@ -323,33 +250,6 @@
VkResult VkEncoder::vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount,
VkPhysicalDevice* pPhysicalDevices,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkEnumeratePhysicalDevices in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkEnumeratePhysicalDevices(instance:%p, pPhysicalDeviceCount:%p, pPhysicalDevices:%p)",
instance, pPhysicalDeviceCount, pPhysicalDevices);
@@ -381,14 +281,12 @@
}
uint32_t packetSize_vkEnumeratePhysicalDevices =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkEnumeratePhysicalDevices);
uint8_t* streamPtr = stream->reserve(packetSize_vkEnumeratePhysicalDevices);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkEnumeratePhysicalDevices = OP_vkEnumeratePhysicalDevices;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkEnumeratePhysicalDevices, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkEnumeratePhysicalDevices, sizeof(uint32_t));
@@ -429,12 +327,6 @@
}
}
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkEnumeratePhysicalDevices), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pPhysicalDeviceCount;
check_pPhysicalDeviceCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -474,33 +366,6 @@
void VkEncoder::vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures* pFeatures, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPhysicalDeviceFeatures in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetPhysicalDeviceFeatures(physicalDevice:%p, pFeatures:%p)",
physicalDevice, pFeatures);
(void)doLock;
@@ -521,14 +386,12 @@
}
uint32_t packetSize_vkGetPhysicalDeviceFeatures =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetPhysicalDeviceFeatures);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceFeatures);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceFeatures = OP_vkGetPhysicalDeviceFeatures;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceFeatures, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceFeatures, sizeof(uint32_t));
@@ -543,12 +406,6 @@
*streamPtrPtr += 1 * 8;
reservedmarshal_VkPhysicalDeviceFeatures(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkPhysicalDeviceFeatures*)(pFeatures), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceFeatures), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkPhysicalDeviceFeatures(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkPhysicalDeviceFeatures*)(pFeatures));
if (pFeatures) {
@@ -567,33 +424,6 @@
VkFormat format,
VkFormatProperties* pFormatProperties,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPhysicalDeviceFormatProperties in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceFormatProperties(physicalDevice:%p, format:%d, pFormatProperties:%p)",
physicalDevice, format, pFormatProperties);
@@ -618,15 +448,12 @@
}
uint32_t packetSize_vkGetPhysicalDeviceFormatProperties =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceFormatProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceFormatProperties);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceFormatProperties = OP_vkGetPhysicalDeviceFormatProperties;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceFormatProperties, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceFormatProperties, sizeof(uint32_t));
@@ -643,13 +470,6 @@
*streamPtrPtr += sizeof(VkFormat);
reservedmarshal_VkFormatProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkFormatProperties*)(pFormatProperties), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetPhysicalDeviceFormatProperties),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkFormatProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkFormatProperties*)(pFormatProperties));
if (pFormatProperties) {
@@ -668,33 +488,6 @@
VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling,
VkImageUsageFlags usage, VkImageCreateFlags flags,
VkImageFormatProperties* pImageFormatProperties, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPhysicalDeviceImageFormatProperties in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceImageFormatProperties(physicalDevice:%p, format:%d, usage:%d, "
"flags:%d, pImageFormatProperties:%p)",
@@ -732,8 +525,6 @@
}
uint32_t packetSize_vkGetPhysicalDeviceImageFormatProperties =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceImageFormatProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceImageFormatProperties);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -741,7 +532,6 @@
OP_vkGetPhysicalDeviceImageFormatProperties;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceImageFormatProperties, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceImageFormatProperties, sizeof(uint32_t));
@@ -767,13 +557,6 @@
reservedmarshal_VkImageFormatProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkImageFormatProperties*)(pImageFormatProperties),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceImageFormatProperties),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkImageFormatProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkImageFormatProperties*)(pImageFormatProperties));
if (pImageFormatProperties) {
@@ -794,33 +577,6 @@
void VkEncoder::vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties* pProperties,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPhysicalDeviceProperties in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetPhysicalDeviceProperties(physicalDevice:%p, pProperties:%p)",
physicalDevice, pProperties);
(void)doLock;
@@ -841,15 +597,12 @@
}
uint32_t packetSize_vkGetPhysicalDeviceProperties =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceProperties);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceProperties = OP_vkGetPhysicalDeviceProperties;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceProperties, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceProperties, sizeof(uint32_t));
@@ -865,12 +618,6 @@
reservedmarshal_VkPhysicalDeviceProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkPhysicalDeviceProperties*)(pProperties),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceProperties), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkPhysicalDeviceProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkPhysicalDeviceProperties*)(pProperties));
if (pProperties) {
@@ -889,33 +636,6 @@
void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties* pQueueFamilyProperties, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPhysicalDeviceQueueFamilyProperties in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice:%p, pQueueFamilyPropertyCount:%p, "
"pQueueFamilyProperties:%p)",
@@ -952,8 +672,6 @@
}
uint32_t packetSize_vkGetPhysicalDeviceQueueFamilyProperties =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceQueueFamilyProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceQueueFamilyProperties);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -961,7 +679,6 @@
OP_vkGetPhysicalDeviceQueueFamilyProperties;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceQueueFamilyProperties, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceQueueFamilyProperties, sizeof(uint32_t));
@@ -995,13 +712,6 @@
(VkQueueFamilyProperties*)(pQueueFamilyProperties + i), streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceQueueFamilyProperties),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pQueueFamilyPropertyCount;
check_pQueueFamilyPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -1046,33 +756,6 @@
void VkEncoder::vkGetPhysicalDeviceMemoryProperties(
VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPhysicalDeviceMemoryProperties in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceMemoryProperties(physicalDevice:%p, pMemoryProperties:%p)",
physicalDevice, pMemoryProperties);
@@ -1095,15 +778,12 @@
}
uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceMemoryProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceMemoryProperties);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceMemoryProperties = OP_vkGetPhysicalDeviceMemoryProperties;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceMemoryProperties, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceMemoryProperties, sizeof(uint32_t));
@@ -1119,13 +799,6 @@
reservedmarshal_VkPhysicalDeviceMemoryProperties(
stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetPhysicalDeviceMemoryProperties),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkPhysicalDeviceMemoryProperties(
stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties));
if (pMemoryProperties) {
@@ -1142,33 +815,6 @@
PFN_vkVoidFunction VkEncoder::vkGetInstanceProcAddr(VkInstance instance, const char* pName,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetInstanceProcAddr in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetInstanceProcAddr(instance:%p, pName:%p)", instance, pName);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -1190,14 +836,12 @@
}
uint32_t packetSize_vkGetInstanceProcAddr =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetInstanceProcAddr);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetInstanceProcAddr);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetInstanceProcAddr = OP_vkGetInstanceProcAddr;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetInstanceProcAddr, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetInstanceProcAddr, sizeof(uint32_t));
@@ -1218,12 +862,6 @@
memcpy(*streamPtrPtr, (char*)local_pName, l);
*streamPtrPtr += l;
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetInstanceProcAddr), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
PFN_vkVoidFunction vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
stream->read(&vkGetInstanceProcAddr_PFN_vkVoidFunction_return, sizeof(PFN_vkVoidFunction));
++encodeCount;
@@ -1237,33 +875,6 @@
PFN_vkVoidFunction VkEncoder::vkGetDeviceProcAddr(VkDevice device, const char* pName,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetDeviceProcAddr in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetDeviceProcAddr(device:%p, pName:%p)", device, pName);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -1285,14 +896,12 @@
}
uint32_t packetSize_vkGetDeviceProcAddr =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetDeviceProcAddr);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceProcAddr);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDeviceProcAddr = OP_vkGetDeviceProcAddr;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetDeviceProcAddr, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetDeviceProcAddr, sizeof(uint32_t));
@@ -1313,12 +922,6 @@
memcpy(*streamPtrPtr, (char*)local_pName, l);
*streamPtrPtr += l;
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetDeviceProcAddr), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
PFN_vkVoidFunction vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
stream->read(&vkGetDeviceProcAddr_PFN_vkVoidFunction_return, sizeof(PFN_vkVoidFunction));
++encodeCount;
@@ -1334,33 +937,6 @@
const VkDeviceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkDevice* pDevice,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateDevice in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCreateDevice(physicalDevice:%p, pCreateInfo:%p, pAllocator:%p, pDevice:%p)",
physicalDevice, pCreateInfo, pAllocator, pDevice);
@@ -1412,14 +988,12 @@
*countPtr += 8;
}
uint32_t packetSize_vkCreateDevice = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateDevice);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateDevice);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateDevice = OP_vkCreateDevice;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateDevice, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateDevice, sizeof(uint32_t));
@@ -1450,12 +1024,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCreateDevice), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -1476,33 +1044,6 @@
void VkEncoder::vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyDevice in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroyDevice(device:%p, pAllocator:%p)", device, pAllocator);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -1538,14 +1079,12 @@
}
}
uint32_t packetSize_vkDestroyDevice = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyDevice);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyDevice);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyDevice = OP_vkDestroyDevice;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyDevice, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyDevice, sizeof(uint32_t));
@@ -1568,12 +1107,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkDestroyDevice), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkDevice((VkDevice*)&device);
stream->flush();
++encodeCount;
@@ -1588,33 +1121,6 @@
uint32_t* pPropertyCount,
VkExtensionProperties* pProperties,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkEnumerateInstanceExtensionProperties in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkEnumerateInstanceExtensionProperties(pLayerName:%p, pPropertyCount:%p, pProperties:%p)",
pLayerName, pPropertyCount, pProperties);
@@ -1658,8 +1164,6 @@
}
uint32_t packetSize_vkEnumerateInstanceExtensionProperties =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkEnumerateInstanceExtensionProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkEnumerateInstanceExtensionProperties);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -1667,7 +1171,6 @@
OP_vkEnumerateInstanceExtensionProperties;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkEnumerateInstanceExtensionProperties, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkEnumerateInstanceExtensionProperties, sizeof(uint32_t));
@@ -1723,13 +1226,6 @@
streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkEnumerateInstanceExtensionProperties),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -1777,33 +1273,6 @@
uint32_t* pPropertyCount,
VkExtensionProperties* pProperties,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkEnumerateDeviceExtensionProperties in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkEnumerateDeviceExtensionProperties(physicalDevice:%p, pLayerName:%p, pPropertyCount:%p, "
"pProperties:%p)",
@@ -1852,15 +1321,12 @@
}
uint32_t packetSize_vkEnumerateDeviceExtensionProperties =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkEnumerateDeviceExtensionProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkEnumerateDeviceExtensionProperties);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkEnumerateDeviceExtensionProperties = OP_vkEnumerateDeviceExtensionProperties;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkEnumerateDeviceExtensionProperties, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkEnumerateDeviceExtensionProperties, sizeof(uint32_t));
@@ -1920,13 +1386,6 @@
streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkEnumerateDeviceExtensionProperties),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -1972,33 +1431,6 @@
VkResult VkEncoder::vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount,
VkLayerProperties* pProperties,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkEnumerateInstanceLayerProperties in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkEnumerateInstanceLayerProperties(pPropertyCount:%p, pProperties:%p)",
pPropertyCount, pProperties);
(void)doLock;
@@ -2028,15 +1460,12 @@
}
uint32_t packetSize_vkEnumerateInstanceLayerProperties =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkEnumerateInstanceLayerProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkEnumerateInstanceLayerProperties);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkEnumerateInstanceLayerProperties = OP_vkEnumerateInstanceLayerProperties;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkEnumerateInstanceLayerProperties, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkEnumerateInstanceLayerProperties, sizeof(uint32_t));
@@ -2065,12 +1494,6 @@
(VkLayerProperties*)(pProperties + i), streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkEnumerateInstanceLayerProperties), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -2117,33 +1540,6 @@
uint32_t* pPropertyCount,
VkLayerProperties* pProperties,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkEnumerateDeviceLayerProperties in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkEnumerateDeviceLayerProperties(physicalDevice:%p, pPropertyCount:%p, pProperties:%p)",
physicalDevice, pPropertyCount, pProperties);
@@ -2178,15 +1574,12 @@
}
uint32_t packetSize_vkEnumerateDeviceLayerProperties =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkEnumerateDeviceLayerProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkEnumerateDeviceLayerProperties);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkEnumerateDeviceLayerProperties = OP_vkEnumerateDeviceLayerProperties;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkEnumerateDeviceLayerProperties, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkEnumerateDeviceLayerProperties, sizeof(uint32_t));
@@ -2219,12 +1612,6 @@
(VkLayerProperties*)(pProperties + i), streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkEnumerateDeviceLayerProperties), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -2269,33 +1656,6 @@
void VkEncoder::vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex,
VkQueue* pQueue, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetDeviceQueue in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetDeviceQueue(device:%p, queueFamilyIndex:%d, queueIndex:%d, pQueue:%p)",
device, queueFamilyIndex, queueIndex, pQueue);
(void)doLock;
@@ -2321,14 +1681,12 @@
*countPtr += 8;
}
uint32_t packetSize_vkGetDeviceQueue = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetDeviceQueue);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceQueue);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDeviceQueue = OP_vkGetDeviceQueue;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetDeviceQueue, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetDeviceQueue, sizeof(uint32_t));
@@ -2351,12 +1709,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetDeviceQueue), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_2;
stream->read((uint64_t*)&cgen_var_2, 8);
@@ -2373,33 +1725,6 @@
VkResult VkEncoder::vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits,
VkFence fence, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkQueueSubmit in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkQueueSubmit(queue:%p, submitCount:%d, pSubmits:%p, fence:%p)", queue,
submitCount, pSubmits, fence);
(void)doLock;
@@ -2442,14 +1767,12 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkQueueSubmit = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkQueueSubmit);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueSubmit);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueSubmit = OP_vkQueueSubmit;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkQueueSubmit, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkQueueSubmit, sizeof(uint32_t));
@@ -2472,12 +1795,6 @@
*&cgen_var_1 = get_host_u64_VkFence((*&local_fence));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkQueueSubmit), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
stream->read(&vkQueueSubmit_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -2490,33 +1807,6 @@
}
VkResult VkEncoder::vkQueueWaitIdle(VkQueue queue, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkQueueWaitIdle in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkQueueWaitIdle(queue:%p)", queue);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -2533,14 +1823,12 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkQueueWaitIdle = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkQueueWaitIdle);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueWaitIdle);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueWaitIdle = OP_vkQueueWaitIdle;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkQueueWaitIdle, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkQueueWaitIdle, sizeof(uint32_t));
@@ -2553,12 +1841,6 @@
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkQueueWaitIdle), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
stream->read(&vkQueueWaitIdle_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -2571,33 +1853,6 @@
}
VkResult VkEncoder::vkDeviceWaitIdle(VkDevice device, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDeviceWaitIdle in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDeviceWaitIdle(device:%p)", device);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -2614,14 +1869,12 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkDeviceWaitIdle = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDeviceWaitIdle);
uint8_t* streamPtr = stream->reserve(packetSize_vkDeviceWaitIdle);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDeviceWaitIdle = OP_vkDeviceWaitIdle;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDeviceWaitIdle, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDeviceWaitIdle, sizeof(uint32_t));
@@ -2634,12 +1887,6 @@
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkDeviceWaitIdle), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
stream->read(&vkDeviceWaitIdle_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -2654,33 +1901,6 @@
VkResult VkEncoder::vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
const VkAllocationCallbacks* pAllocator,
VkDeviceMemory* pMemory, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkAllocateMemory in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkAllocateMemory(device:%p, pAllocateInfo:%p, pAllocator:%p, pMemory:%p)",
device, pAllocateInfo, pAllocator, pMemory);
(void)doLock;
@@ -2732,14 +1952,12 @@
*countPtr += 8;
}
uint32_t packetSize_vkAllocateMemory = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkAllocateMemory);
uint8_t* streamPtr = stream->reserve(packetSize_vkAllocateMemory);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkAllocateMemory = OP_vkAllocateMemory;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkAllocateMemory, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkAllocateMemory, sizeof(uint32_t));
@@ -2771,12 +1989,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkAllocateMemory), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -2796,33 +2008,6 @@
void VkEncoder::vkFreeMemory(VkDevice device, VkDeviceMemory memory,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkFreeMemory in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkFreeMemory(device:%p, memory:%p, pAllocator:%p)", device, memory,
pAllocator);
(void)doLock;
@@ -2861,14 +2046,12 @@
}
}
uint32_t packetSize_vkFreeMemory = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkFreeMemory);
uint8_t* streamPtr = stream->reserve(packetSize_vkFreeMemory);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkFreeMemory = OP_vkFreeMemory;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkFreeMemory, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkFreeMemory, sizeof(uint32_t));
@@ -2895,12 +2078,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkFreeMemory), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkDeviceMemory((VkDeviceMemory*)&memory);
stream->flush();
++encodeCount;
@@ -2914,33 +2091,6 @@
VkResult VkEncoder::vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset,
VkDeviceSize size, VkMemoryMapFlags flags, void** ppData,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkMapMemory in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
(void)doLock;
VkResult vkMapMemory_VkResult_return = (VkResult)0;
vkMapMemory_VkResult_return = sResourceTracker->on_vkMapMemory(this, VK_SUCCESS, device, memory,
@@ -2949,33 +2099,6 @@
}
void VkEncoder::vkUnmapMemory(VkDevice device, VkDeviceMemory memory, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkUnmapMemory in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
(void)doLock;
sResourceTracker->on_vkUnmapMemory(this, device, memory);
}
@@ -2983,33 +2106,6 @@
VkResult VkEncoder::vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
const VkMappedMemoryRange* pMemoryRanges,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkFlushMappedMemoryRanges in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
(void)doLock;
bool queueSubmitWithCommandsEnabled =
sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
@@ -3052,14 +2148,12 @@
}
uint32_t packetSize_vkFlushMappedMemoryRanges =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkFlushMappedMemoryRanges);
uint8_t* streamPtr = stream->reserve(packetSize_vkFlushMappedMemoryRanges);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkFlushMappedMemoryRanges = OP_vkFlushMappedMemoryRanges;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkFlushMappedMemoryRanges, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkFlushMappedMemoryRanges, sizeof(uint32_t));
@@ -3079,12 +2173,6 @@
(VkMappedMemoryRange*)(local_pMemoryRanges + i),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkFlushMappedMemoryRanges), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
if (!sResourceTracker->usingDirectMapping()) {
for (uint32_t i = 0; i < memoryRangeCount; ++i) {
auto range = pMemoryRanges[i];
@@ -3123,33 +2211,6 @@
VkResult VkEncoder::vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
const VkMappedMemoryRange* pMemoryRanges,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkInvalidateMappedMemoryRanges in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
(void)doLock;
bool queueSubmitWithCommandsEnabled =
sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
@@ -3192,15 +2253,12 @@
}
uint32_t packetSize_vkInvalidateMappedMemoryRanges =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkInvalidateMappedMemoryRanges);
uint8_t* streamPtr = stream->reserve(packetSize_vkInvalidateMappedMemoryRanges);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkInvalidateMappedMemoryRanges = OP_vkInvalidateMappedMemoryRanges;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkInvalidateMappedMemoryRanges, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkInvalidateMappedMemoryRanges, sizeof(uint32_t));
@@ -3220,12 +2278,6 @@
(VkMappedMemoryRange*)(local_pMemoryRanges + i),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkInvalidateMappedMemoryRanges), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
stream->read(&vkInvalidateMappedMemoryRanges_VkResult_return, sizeof(VkResult));
if (!sResourceTracker->usingDirectMapping()) {
@@ -3264,33 +2316,6 @@
void VkEncoder::vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
VkDeviceSize* pCommittedMemoryInBytes,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetDeviceMemoryCommitment in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetDeviceMemoryCommitment(device:%p, memory:%p, pCommittedMemoryInBytes:%p)", device,
memory, pCommittedMemoryInBytes);
@@ -3318,14 +2343,12 @@
}
uint32_t packetSize_vkGetDeviceMemoryCommitment =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetDeviceMemoryCommitment);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceMemoryCommitment);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDeviceMemoryCommitment = OP_vkGetDeviceMemoryCommitment;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetDeviceMemoryCommitment, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetDeviceMemoryCommitment, sizeof(uint32_t));
@@ -3344,12 +2367,6 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize));
*streamPtrPtr += sizeof(VkDeviceSize);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetDeviceMemoryCommitment), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->read((VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize));
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -3361,33 +2378,6 @@
VkResult VkEncoder::vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
VkDeviceSize memoryOffset, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkBindBufferMemory in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkBindBufferMemory(device:%p, buffer:%p, memory:%p, memoryOffset:%ld)",
device, buffer, memory, memoryOffset);
(void)doLock;
@@ -3420,14 +2410,12 @@
}
uint32_t packetSize_vkBindBufferMemory =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkBindBufferMemory);
uint8_t* streamPtr = stream->reserve(packetSize_vkBindBufferMemory);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkBindBufferMemory = OP_vkBindBufferMemory;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkBindBufferMemory, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkBindBufferMemory, sizeof(uint32_t));
@@ -3450,12 +2438,6 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize));
*streamPtrPtr += sizeof(VkDeviceSize);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkBindBufferMemory), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkBindBufferMemory_VkResult_return = (VkResult)0;
stream->read(&vkBindBufferMemory_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -3469,33 +2451,6 @@
VkResult VkEncoder::vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory,
VkDeviceSize memoryOffset, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkBindImageMemory in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkBindImageMemory(device:%p, image:%p, memory:%p, memoryOffset:%ld)", device,
image, memory, memoryOffset);
(void)doLock;
@@ -3528,14 +2483,12 @@
}
uint32_t packetSize_vkBindImageMemory =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkBindImageMemory);
uint8_t* streamPtr = stream->reserve(packetSize_vkBindImageMemory);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkBindImageMemory = OP_vkBindImageMemory;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkBindImageMemory, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkBindImageMemory, sizeof(uint32_t));
@@ -3558,12 +2511,6 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize));
*streamPtrPtr += sizeof(VkDeviceSize);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkBindImageMemory), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkBindImageMemory_VkResult_return = (VkResult)0;
stream->read(&vkBindImageMemory_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -3578,33 +2525,6 @@
void VkEncoder::vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
VkMemoryRequirements* pMemoryRequirements,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetBufferMemoryRequirements in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetBufferMemoryRequirements(device:%p, buffer:%p, pMemoryRequirements:%p)",
device, buffer, pMemoryRequirements);
(void)doLock;
@@ -3629,15 +2549,12 @@
}
uint32_t packetSize_vkGetBufferMemoryRequirements =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetBufferMemoryRequirements);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferMemoryRequirements);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetBufferMemoryRequirements = OP_vkGetBufferMemoryRequirements;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetBufferMemoryRequirements, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetBufferMemoryRequirements, sizeof(uint32_t));
@@ -3657,12 +2574,6 @@
reservedmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements*)(pMemoryRequirements),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetBufferMemoryRequirements), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements*)(pMemoryRequirements));
if (pMemoryRequirements) {
@@ -3680,33 +2591,6 @@
void VkEncoder::vkGetImageMemoryRequirements(VkDevice device, VkImage image,
VkMemoryRequirements* pMemoryRequirements,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetImageMemoryRequirements in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetImageMemoryRequirements(device:%p, image:%p, pMemoryRequirements:%p)",
device, image, pMemoryRequirements);
(void)doLock;
@@ -3731,15 +2615,12 @@
}
uint32_t packetSize_vkGetImageMemoryRequirements =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetImageMemoryRequirements);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageMemoryRequirements);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetImageMemoryRequirements = OP_vkGetImageMemoryRequirements;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetImageMemoryRequirements, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetImageMemoryRequirements, sizeof(uint32_t));
@@ -3759,12 +2640,6 @@
reservedmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements*)(pMemoryRequirements),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetImageMemoryRequirements), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements*)(pMemoryRequirements));
if (pMemoryRequirements) {
@@ -3782,33 +2657,6 @@
void VkEncoder::vkGetImageSparseMemoryRequirements(
VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements* pSparseMemoryRequirements, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetImageSparseMemoryRequirements in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetImageSparseMemoryRequirements(device:%p, image:%p, pSparseMemoryRequirementCount:%p, "
"pSparseMemoryRequirements:%p)",
@@ -3850,15 +2698,12 @@
}
uint32_t packetSize_vkGetImageSparseMemoryRequirements =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetImageSparseMemoryRequirements);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageSparseMemoryRequirements);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetImageSparseMemoryRequirements = OP_vkGetImageSparseMemoryRequirements;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetImageSparseMemoryRequirements, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetImageSparseMemoryRequirements, sizeof(uint32_t));
@@ -3896,12 +2741,6 @@
(VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i), streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetImageSparseMemoryRequirements), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pSparseMemoryRequirementCount;
check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -3950,34 +2789,6 @@
VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling,
uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor,
- "vkGetPhysicalDeviceSparseImageFormatProperties in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice:%p, format:%d, usage:%d, "
"pPropertyCount:%p, pProperties:%p)",
@@ -4029,8 +2840,6 @@
}
uint32_t packetSize_vkGetPhysicalDeviceSparseImageFormatProperties =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceSparseImageFormatProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceSparseImageFormatProperties);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -4038,7 +2847,6 @@
OP_vkGetPhysicalDeviceSparseImageFormatProperties;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSparseImageFormatProperties, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSparseImageFormatProperties, sizeof(uint32_t));
@@ -4082,13 +2890,6 @@
(VkSparseImageFormatProperties*)(pProperties + i), streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceSparseImageFormatProperties),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -4132,33 +2933,6 @@
VkResult VkEncoder::vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
const VkBindSparseInfo* pBindInfo, VkFence fence,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkQueueBindSparse in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkQueueBindSparse(queue:%p, bindInfoCount:%d, pBindInfo:%p, fence:%p)",
queue, bindInfoCount, pBindInfo, fence);
(void)doLock;
@@ -4204,14 +2978,12 @@
}
uint32_t packetSize_vkQueueBindSparse =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkQueueBindSparse);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueBindSparse);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueBindSparse = OP_vkQueueBindSparse;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkQueueBindSparse, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkQueueBindSparse, sizeof(uint32_t));
@@ -4234,12 +3006,6 @@
*&cgen_var_1 = get_host_u64_VkFence((*&local_fence));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkQueueBindSparse), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
stream->read(&vkQueueBindSparse_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -4254,33 +3020,6 @@
VkResult VkEncoder::vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkFence* pFence,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateFence in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCreateFence(device:%p, pCreateInfo:%p, pAllocator:%p, pFence:%p)", device,
pCreateInfo, pAllocator, pFence);
(void)doLock;
@@ -4331,14 +3070,12 @@
*countPtr += 8;
}
uint32_t packetSize_vkCreateFence = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateFence);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateFence);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateFence = OP_vkCreateFence;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateFence, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateFence, sizeof(uint32_t));
@@ -4369,12 +3106,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCreateFence), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -4393,33 +3124,6 @@
void VkEncoder::vkDestroyFence(VkDevice device, VkFence fence,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyFence in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroyFence(device:%p, fence:%p, pAllocator:%p)", device, fence,
pAllocator);
(void)doLock;
@@ -4459,14 +3163,12 @@
}
}
uint32_t packetSize_vkDestroyFence = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyFence);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyFence);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyFence = OP_vkDestroyFence;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyFence, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyFence, sizeof(uint32_t));
@@ -4493,12 +3195,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkDestroyFence), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkFence((VkFence*)&fence);
stream->flush();
++encodeCount;
@@ -4511,33 +3207,6 @@
VkResult VkEncoder::vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkResetFences in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkResetFences(device:%p, fenceCount:%d, pFences:%p)", device, fenceCount,
pFences);
(void)doLock;
@@ -4564,14 +3233,12 @@
}
}
uint32_t packetSize_vkResetFences = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkResetFences);
uint8_t* streamPtr = stream->reserve(packetSize_vkResetFences);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkResetFences = OP_vkResetFences;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkResetFences, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkResetFences, sizeof(uint32_t));
@@ -4594,12 +3261,6 @@
}
*streamPtrPtr += 8 * ((fenceCount));
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkResetFences), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkResetFences_VkResult_return = (VkResult)0;
stream->read(&vkResetFences_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -4612,33 +3273,6 @@
}
VkResult VkEncoder::vkGetFenceStatus(VkDevice device, VkFence fence, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetFenceStatus in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetFenceStatus(device:%p, fence:%p)", device, fence);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -4659,14 +3293,12 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkGetFenceStatus = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetFenceStatus);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetFenceStatus);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetFenceStatus = OP_vkGetFenceStatus;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetFenceStatus, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetFenceStatus, sizeof(uint32_t));
@@ -4683,12 +3315,6 @@
*&cgen_var_1 = get_host_u64_VkFence((*&local_fence));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetFenceStatus), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
stream->read(&vkGetFenceStatus_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -4702,33 +3328,6 @@
VkResult VkEncoder::vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences,
VkBool32 waitAll, uint64_t timeout, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkWaitForFences in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkWaitForFences(device:%p, fenceCount:%d, pFences:%p, waitAll:%d, timeout:%ld)", device,
fenceCount, pFences, waitAll, timeout);
@@ -4762,14 +3361,12 @@
*countPtr += sizeof(uint64_t);
}
uint32_t packetSize_vkWaitForFences = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkWaitForFences);
uint8_t* streamPtr = stream->reserve(packetSize_vkWaitForFences);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkWaitForFences = OP_vkWaitForFences;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkWaitForFences, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkWaitForFences, sizeof(uint32_t));
@@ -4796,12 +3393,6 @@
*streamPtrPtr += sizeof(VkBool32);
memcpy(*streamPtrPtr, (uint64_t*)&local_timeout, sizeof(uint64_t));
*streamPtrPtr += sizeof(uint64_t);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkWaitForFences), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkWaitForFences_VkResult_return = (VkResult)0;
stream->read(&vkWaitForFences_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -4816,33 +3407,6 @@
VkResult VkEncoder::vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSemaphore* pSemaphore, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateSemaphore in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCreateSemaphore(device:%p, pCreateInfo:%p, pAllocator:%p, pSemaphore:%p)",
device, pCreateInfo, pAllocator, pSemaphore);
(void)doLock;
@@ -4895,14 +3459,12 @@
}
uint32_t packetSize_vkCreateSemaphore =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateSemaphore);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateSemaphore);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateSemaphore = OP_vkCreateSemaphore;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateSemaphore, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateSemaphore, sizeof(uint32_t));
@@ -4934,12 +3496,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCreateSemaphore), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -4958,33 +3514,6 @@
void VkEncoder::vkDestroySemaphore(VkDevice device, VkSemaphore semaphore,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroySemaphore in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroySemaphore(device:%p, semaphore:%p, pAllocator:%p)", device,
semaphore, pAllocator);
(void)doLock;
@@ -5025,14 +3554,12 @@
}
uint32_t packetSize_vkDestroySemaphore =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroySemaphore);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroySemaphore);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroySemaphore = OP_vkDestroySemaphore;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroySemaphore, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroySemaphore, sizeof(uint32_t));
@@ -5059,12 +3586,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkDestroySemaphore), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkSemaphore((VkSemaphore*)&semaphore);
stream->flush();
++encodeCount;
@@ -5078,33 +3599,6 @@
VkResult VkEncoder::vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkEvent* pEvent,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateEvent in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCreateEvent(device:%p, pCreateInfo:%p, pAllocator:%p, pEvent:%p)", device,
pCreateInfo, pAllocator, pEvent);
(void)doLock;
@@ -5155,14 +3649,12 @@
*countPtr += 8;
}
uint32_t packetSize_vkCreateEvent = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateEvent);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateEvent);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateEvent = OP_vkCreateEvent;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateEvent, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateEvent, sizeof(uint32_t));
@@ -5193,12 +3685,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCreateEvent), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -5217,33 +3703,6 @@
void VkEncoder::vkDestroyEvent(VkDevice device, VkEvent event,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyEvent in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroyEvent(device:%p, event:%p, pAllocator:%p)", device, event,
pAllocator);
(void)doLock;
@@ -5283,14 +3742,12 @@
}
}
uint32_t packetSize_vkDestroyEvent = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyEvent);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyEvent);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyEvent = OP_vkDestroyEvent;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyEvent, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyEvent, sizeof(uint32_t));
@@ -5317,12 +3774,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkDestroyEvent), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkEvent((VkEvent*)&event);
stream->flush();
++encodeCount;
@@ -5334,33 +3785,6 @@
}
VkResult VkEncoder::vkGetEventStatus(VkDevice device, VkEvent event, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetEventStatus in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetEventStatus(device:%p, event:%p)", device, event);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -5381,14 +3805,12 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkGetEventStatus = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetEventStatus);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetEventStatus);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetEventStatus = OP_vkGetEventStatus;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetEventStatus, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetEventStatus, sizeof(uint32_t));
@@ -5405,12 +3827,6 @@
*&cgen_var_1 = get_host_u64_VkEvent((*&local_event));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetEventStatus), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
stream->read(&vkGetEventStatus_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -5423,33 +3839,6 @@
}
VkResult VkEncoder::vkSetEvent(VkDevice device, VkEvent event, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkSetEvent in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkSetEvent(device:%p, event:%p)", device, event);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -5470,14 +3859,12 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkSetEvent = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkSetEvent);
uint8_t* streamPtr = stream->reserve(packetSize_vkSetEvent);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkSetEvent = OP_vkSetEvent;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkSetEvent, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkSetEvent, sizeof(uint32_t));
@@ -5494,12 +3881,6 @@
*&cgen_var_1 = get_host_u64_VkEvent((*&local_event));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkSetEvent), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkSetEvent_VkResult_return = (VkResult)0;
stream->read(&vkSetEvent_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -5512,33 +3893,6 @@
}
VkResult VkEncoder::vkResetEvent(VkDevice device, VkEvent event, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkResetEvent in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkResetEvent(device:%p, event:%p)", device, event);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -5559,14 +3913,12 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkResetEvent = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkResetEvent);
uint8_t* streamPtr = stream->reserve(packetSize_vkResetEvent);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkResetEvent = OP_vkResetEvent;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkResetEvent, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkResetEvent, sizeof(uint32_t));
@@ -5583,12 +3935,6 @@
*&cgen_var_1 = get_host_u64_VkEvent((*&local_event));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkResetEvent), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkResetEvent_VkResult_return = (VkResult)0;
stream->read(&vkResetEvent_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -5603,33 +3949,6 @@
VkResult VkEncoder::vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkQueryPool* pQueryPool, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateQueryPool in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCreateQueryPool(device:%p, pCreateInfo:%p, pAllocator:%p, pQueryPool:%p)",
device, pCreateInfo, pAllocator, pQueryPool);
(void)doLock;
@@ -5682,14 +4001,12 @@
}
uint32_t packetSize_vkCreateQueryPool =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateQueryPool);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateQueryPool);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateQueryPool = OP_vkCreateQueryPool;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateQueryPool, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateQueryPool, sizeof(uint32_t));
@@ -5721,12 +4038,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCreateQueryPool), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -5745,33 +4056,6 @@
void VkEncoder::vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyQueryPool in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroyQueryPool(device:%p, queryPool:%p, pAllocator:%p)", device,
queryPool, pAllocator);
(void)doLock;
@@ -5812,14 +4096,12 @@
}
uint32_t packetSize_vkDestroyQueryPool =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyQueryPool);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyQueryPool);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyQueryPool = OP_vkDestroyQueryPool;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyQueryPool, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyQueryPool, sizeof(uint32_t));
@@ -5846,12 +4128,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkDestroyQueryPool), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkQueryPool((VkQueryPool*)&queryPool);
stream->flush();
++encodeCount;
@@ -5866,33 +4142,6 @@
uint32_t firstQuery, uint32_t queryCount, size_t dataSize,
void* pData, VkDeviceSize stride,
VkQueryResultFlags flags, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetQueryPoolResults in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetQueryPoolResults(device:%p, queryPool:%p, firstQuery:%d, queryCount:%d, "
"dataSize:%ld, pData:%p, stride:%ld, flags:%d)",
@@ -5933,14 +4182,12 @@
}
uint32_t packetSize_vkGetQueryPoolResults =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetQueryPoolResults);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetQueryPoolResults);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetQueryPoolResults = OP_vkGetQueryPoolResults;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetQueryPoolResults, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetQueryPoolResults, sizeof(uint32_t));
@@ -5971,12 +4218,6 @@
*streamPtrPtr += sizeof(VkDeviceSize);
memcpy(*streamPtrPtr, (VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
*streamPtrPtr += sizeof(VkQueryResultFlags);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetQueryPoolResults), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->read((void*)pData, ((dataSize)) * sizeof(uint8_t));
VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0;
stream->read(&vkGetQueryPoolResults_VkResult_return, sizeof(VkResult));
@@ -5992,33 +4233,6 @@
VkResult VkEncoder::vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateBuffer in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCreateBuffer(device:%p, pCreateInfo:%p, pAllocator:%p, pBuffer:%p)",
device, pCreateInfo, pAllocator, pBuffer);
(void)doLock;
@@ -6069,14 +4283,12 @@
*countPtr += 8;
}
uint32_t packetSize_vkCreateBuffer = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateBuffer);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateBuffer);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateBuffer = OP_vkCreateBuffer;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateBuffer, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateBuffer, sizeof(uint32_t));
@@ -6107,12 +4319,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCreateBuffer), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -6131,33 +4337,6 @@
void VkEncoder::vkDestroyBuffer(VkDevice device, VkBuffer buffer,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyBuffer in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroyBuffer(device:%p, buffer:%p, pAllocator:%p)", device, buffer,
pAllocator);
(void)doLock;
@@ -6197,14 +4376,12 @@
}
}
uint32_t packetSize_vkDestroyBuffer = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyBuffer);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyBuffer);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyBuffer = OP_vkDestroyBuffer;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyBuffer, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyBuffer, sizeof(uint32_t));
@@ -6231,12 +4408,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkDestroyBuffer), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkBuffer((VkBuffer*)&buffer);
stream->flush();
++encodeCount;
@@ -6250,33 +4421,6 @@
VkResult VkEncoder::vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkBufferView* pView,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateBufferView in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCreateBufferView(device:%p, pCreateInfo:%p, pAllocator:%p, pView:%p)",
device, pCreateInfo, pAllocator, pView);
(void)doLock;
@@ -6329,14 +4473,12 @@
}
uint32_t packetSize_vkCreateBufferView =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateBufferView);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateBufferView);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateBufferView = OP_vkCreateBufferView;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateBufferView, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateBufferView, sizeof(uint32_t));
@@ -6368,12 +4510,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCreateBufferView), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -6392,33 +4528,6 @@
void VkEncoder::vkDestroyBufferView(VkDevice device, VkBufferView bufferView,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyBufferView in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroyBufferView(device:%p, bufferView:%p, pAllocator:%p)", device,
bufferView, pAllocator);
(void)doLock;
@@ -6459,14 +4568,12 @@
}
uint32_t packetSize_vkDestroyBufferView =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyBufferView);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyBufferView);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyBufferView = OP_vkDestroyBufferView;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyBufferView, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyBufferView, sizeof(uint32_t));
@@ -6493,12 +4600,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkDestroyBufferView), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkBufferView((VkBufferView*)&bufferView);
stream->flush();
++encodeCount;
@@ -6512,33 +4613,6 @@
VkResult VkEncoder::vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkImage* pImage,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateImage in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
(void)doLock;
bool queueSubmitWithCommandsEnabled =
sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
@@ -6589,14 +4663,12 @@
*countPtr += 8;
}
uint32_t packetSize_vkCreateImage = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateImage);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateImage);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateImage = OP_vkCreateImage;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateImage, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateImage, sizeof(uint32_t));
@@ -6627,12 +4699,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCreateImage), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -6651,33 +4717,6 @@
void VkEncoder::vkDestroyImage(VkDevice device, VkImage image,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyImage in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroyImage(device:%p, image:%p, pAllocator:%p)", device, image,
pAllocator);
(void)doLock;
@@ -6717,14 +4756,12 @@
}
}
uint32_t packetSize_vkDestroyImage = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyImage);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyImage);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyImage = OP_vkDestroyImage;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyImage, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyImage, sizeof(uint32_t));
@@ -6751,12 +4788,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkDestroyImage), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkImage((VkImage*)&image);
stream->flush();
++encodeCount;
@@ -6770,33 +4801,6 @@
void VkEncoder::vkGetImageSubresourceLayout(VkDevice device, VkImage image,
const VkImageSubresource* pSubresource,
VkSubresourceLayout* pLayout, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetImageSubresourceLayout in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetImageSubresourceLayout(device:%p, image:%p, pSubresource:%p, pLayout:%p)", device,
image, pSubresource, pLayout);
@@ -6835,14 +4839,12 @@
}
uint32_t packetSize_vkGetImageSubresourceLayout =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetImageSubresourceLayout);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageSubresourceLayout);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetImageSubresourceLayout = OP_vkGetImageSubresourceLayout;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetImageSubresourceLayout, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetImageSubresourceLayout, sizeof(uint32_t));
@@ -6863,12 +4865,6 @@
(VkImageSubresource*)(local_pSubresource), streamPtrPtr);
reservedmarshal_VkSubresourceLayout(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkSubresourceLayout*)(pLayout), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetImageSubresourceLayout), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkSubresourceLayout(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkSubresourceLayout*)(pLayout));
if (pLayout) {
@@ -6885,33 +4881,6 @@
VkResult VkEncoder::vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkImageView* pView,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateImageView in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCreateImageView(device:%p, pCreateInfo:%p, pAllocator:%p, pView:%p)",
device, pCreateInfo, pAllocator, pView);
(void)doLock;
@@ -6964,14 +4933,12 @@
}
uint32_t packetSize_vkCreateImageView =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateImageView);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateImageView);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateImageView = OP_vkCreateImageView;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateImageView, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateImageView, sizeof(uint32_t));
@@ -7003,12 +4970,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCreateImageView), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -7027,33 +4988,6 @@
void VkEncoder::vkDestroyImageView(VkDevice device, VkImageView imageView,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyImageView in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroyImageView(device:%p, imageView:%p, pAllocator:%p)", device,
imageView, pAllocator);
(void)doLock;
@@ -7094,14 +5028,12 @@
}
uint32_t packetSize_vkDestroyImageView =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyImageView);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyImageView);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyImageView = OP_vkDestroyImageView;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyImageView, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyImageView, sizeof(uint32_t));
@@ -7128,12 +5060,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkDestroyImageView), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkImageView((VkImageView*)&imageView);
stream->flush();
++encodeCount;
@@ -7148,33 +5074,6 @@
const VkShaderModuleCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkShaderModule* pShaderModule, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateShaderModule in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCreateShaderModule(device:%p, pCreateInfo:%p, pAllocator:%p, pShaderModule:%p)", device,
pCreateInfo, pAllocator, pShaderModule);
@@ -7228,14 +5127,12 @@
}
uint32_t packetSize_vkCreateShaderModule =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateShaderModule);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateShaderModule);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateShaderModule = OP_vkCreateShaderModule;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateShaderModule, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateShaderModule, sizeof(uint32_t));
@@ -7267,12 +5164,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCreateShaderModule), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -7292,33 +5183,6 @@
void VkEncoder::vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyShaderModule in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroyShaderModule(device:%p, shaderModule:%p, pAllocator:%p)", device,
shaderModule, pAllocator);
(void)doLock;
@@ -7359,14 +5223,12 @@
}
uint32_t packetSize_vkDestroyShaderModule =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyShaderModule);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyShaderModule);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyShaderModule = OP_vkDestroyShaderModule;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyShaderModule, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyShaderModule, sizeof(uint32_t));
@@ -7393,12 +5255,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkDestroyShaderModule), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkShaderModule((VkShaderModule*)&shaderModule);
stream->flush();
++encodeCount;
@@ -7413,33 +5269,6 @@
const VkPipelineCacheCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkPipelineCache* pPipelineCache, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreatePipelineCache in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCreatePipelineCache(device:%p, pCreateInfo:%p, pAllocator:%p, pPipelineCache:%p)",
device, pCreateInfo, pAllocator, pPipelineCache);
@@ -7493,14 +5322,12 @@
}
uint32_t packetSize_vkCreatePipelineCache =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreatePipelineCache);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreatePipelineCache);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreatePipelineCache = OP_vkCreatePipelineCache;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreatePipelineCache, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreatePipelineCache, sizeof(uint32_t));
@@ -7532,12 +5359,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCreatePipelineCache), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -7557,33 +5378,6 @@
void VkEncoder::vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyPipelineCache in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroyPipelineCache(device:%p, pipelineCache:%p, pAllocator:%p)", device,
pipelineCache, pAllocator);
(void)doLock;
@@ -7624,14 +5418,12 @@
}
uint32_t packetSize_vkDestroyPipelineCache =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyPipelineCache);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyPipelineCache);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyPipelineCache = OP_vkDestroyPipelineCache;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyPipelineCache, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyPipelineCache, sizeof(uint32_t));
@@ -7658,12 +5450,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkDestroyPipelineCache), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkPipelineCache(
(VkPipelineCache*)&pipelineCache);
stream->flush();
@@ -7677,33 +5463,6 @@
VkResult VkEncoder::vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
size_t* pDataSize, void* pData, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPipelineCacheData in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetPipelineCacheData(device:%p, pipelineCache:%p, pDataSize:%p, pData:%p)",
device, pipelineCache, pDataSize, pData);
(void)doLock;
@@ -7738,14 +5497,12 @@
}
uint32_t packetSize_vkGetPipelineCacheData =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetPipelineCacheData);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPipelineCacheData);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPipelineCacheData = OP_vkGetPipelineCacheData;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPipelineCacheData, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPipelineCacheData, sizeof(uint32_t));
@@ -7782,12 +5539,6 @@
memcpy(*streamPtrPtr, (void*)pData, (*(pDataSize)) * sizeof(uint8_t));
*streamPtrPtr += (*(pDataSize)) * sizeof(uint8_t);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPipelineCacheData), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
size_t* check_pDataSize;
check_pDataSize = (size_t*)(uintptr_t)stream->getBe64();
@@ -7820,33 +5571,6 @@
VkResult VkEncoder::vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkMergePipelineCaches in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkMergePipelineCaches(device:%p, dstCache:%p, srcCacheCount:%d, pSrcCaches:%p)", device,
dstCache, srcCacheCount, pSrcCaches);
@@ -7879,14 +5603,12 @@
}
uint32_t packetSize_vkMergePipelineCaches =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkMergePipelineCaches);
uint8_t* streamPtr = stream->reserve(packetSize_vkMergePipelineCaches);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkMergePipelineCaches = OP_vkMergePipelineCaches;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkMergePipelineCaches, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkMergePipelineCaches, sizeof(uint32_t));
@@ -7913,12 +5635,6 @@
}
*streamPtrPtr += 8 * ((srcCacheCount));
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkMergePipelineCaches), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0;
stream->read(&vkMergePipelineCaches_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -7935,33 +5651,6 @@
const VkGraphicsPipelineCreateInfo* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateGraphicsPipelines in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCreateGraphicsPipelines(device:%p, pipelineCache:%p, createInfoCount:%d, "
"pCreateInfos:%p, pAllocator:%p, pPipelines:%p)",
@@ -8032,14 +5721,12 @@
}
uint32_t packetSize_vkCreateGraphicsPipelines =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateGraphicsPipelines);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateGraphicsPipelines);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateGraphicsPipelines = OP_vkCreateGraphicsPipelines;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateGraphicsPipelines, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateGraphicsPipelines, sizeof(uint32_t));
@@ -8083,12 +5770,6 @@
*streamPtrPtr += 8 * ((createInfoCount));
}
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCreateGraphicsPipelines), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
if (((createInfoCount))) {
uint64_t* cgen_var_4;
@@ -8114,33 +5795,6 @@
const VkComputePipelineCreateInfo* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateComputePipelines in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCreateComputePipelines(device:%p, pipelineCache:%p, createInfoCount:%d, "
"pCreateInfos:%p, pAllocator:%p, pPipelines:%p)",
@@ -8211,14 +5865,12 @@
}
uint32_t packetSize_vkCreateComputePipelines =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateComputePipelines);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateComputePipelines);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateComputePipelines = OP_vkCreateComputePipelines;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateComputePipelines, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateComputePipelines, sizeof(uint32_t));
@@ -8262,12 +5914,6 @@
*streamPtrPtr += 8 * ((createInfoCount));
}
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCreateComputePipelines), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
if (((createInfoCount))) {
uint64_t* cgen_var_4;
@@ -8290,33 +5936,6 @@
void VkEncoder::vkDestroyPipeline(VkDevice device, VkPipeline pipeline,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyPipeline in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroyPipeline(device:%p, pipeline:%p, pAllocator:%p)", device, pipeline,
pAllocator);
(void)doLock;
@@ -8357,14 +5976,12 @@
}
uint32_t packetSize_vkDestroyPipeline =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyPipeline);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyPipeline);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyPipeline = OP_vkDestroyPipeline;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyPipeline, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyPipeline, sizeof(uint32_t));
@@ -8391,12 +6008,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkDestroyPipeline), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkPipeline((VkPipeline*)&pipeline);
stream->flush();
++encodeCount;
@@ -8411,33 +6022,6 @@
const VkPipelineLayoutCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkPipelineLayout* pPipelineLayout, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreatePipelineLayout in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCreatePipelineLayout(device:%p, pCreateInfo:%p, pAllocator:%p, pPipelineLayout:%p)",
device, pCreateInfo, pAllocator, pPipelineLayout);
@@ -8492,14 +6076,12 @@
}
uint32_t packetSize_vkCreatePipelineLayout =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreatePipelineLayout);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreatePipelineLayout);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreatePipelineLayout = OP_vkCreatePipelineLayout;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreatePipelineLayout, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreatePipelineLayout, sizeof(uint32_t));
@@ -8531,12 +6113,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCreatePipelineLayout), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -8556,33 +6132,6 @@
void VkEncoder::vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyPipelineLayout in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroyPipelineLayout(device:%p, pipelineLayout:%p, pAllocator:%p)",
device, pipelineLayout, pAllocator);
(void)doLock;
@@ -8623,14 +6172,12 @@
}
uint32_t packetSize_vkDestroyPipelineLayout =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyPipelineLayout);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyPipelineLayout);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyPipelineLayout = OP_vkDestroyPipelineLayout;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyPipelineLayout, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyPipelineLayout, sizeof(uint32_t));
@@ -8657,12 +6204,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkDestroyPipelineLayout), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkPipelineLayout(
(VkPipelineLayout*)&pipelineLayout);
stream->flush();
@@ -8677,33 +6218,6 @@
VkResult VkEncoder::vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkSampler* pSampler,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateSampler in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCreateSampler(device:%p, pCreateInfo:%p, pAllocator:%p, pSampler:%p)",
device, pCreateInfo, pAllocator, pSampler);
(void)doLock;
@@ -8754,14 +6268,12 @@
*countPtr += 8;
}
uint32_t packetSize_vkCreateSampler = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateSampler);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateSampler);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateSampler = OP_vkCreateSampler;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateSampler, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateSampler, sizeof(uint32_t));
@@ -8792,12 +6304,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCreateSampler), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -8816,33 +6322,6 @@
void VkEncoder::vkDestroySampler(VkDevice device, VkSampler sampler,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroySampler in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroySampler(device:%p, sampler:%p, pAllocator:%p)", device, sampler,
pAllocator);
(void)doLock;
@@ -8882,14 +6361,12 @@
}
}
uint32_t packetSize_vkDestroySampler = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroySampler);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroySampler);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroySampler = OP_vkDestroySampler;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroySampler, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroySampler, sizeof(uint32_t));
@@ -8916,12 +6393,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkDestroySampler), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkSampler((VkSampler*)&sampler);
stream->flush();
++encodeCount;
@@ -8937,33 +6408,6 @@
const VkAllocationCallbacks* pAllocator,
VkDescriptorSetLayout* pSetLayout,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateDescriptorSetLayout in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCreateDescriptorSetLayout(device:%p, pCreateInfo:%p, pAllocator:%p, pSetLayout:%p)",
device, pCreateInfo, pAllocator, pSetLayout);
@@ -9019,14 +6463,12 @@
}
uint32_t packetSize_vkCreateDescriptorSetLayout =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateDescriptorSetLayout);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateDescriptorSetLayout);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateDescriptorSetLayout = OP_vkCreateDescriptorSetLayout;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateDescriptorSetLayout, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateDescriptorSetLayout, sizeof(uint32_t));
@@ -9058,12 +6500,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCreateDescriptorSetLayout), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -9085,33 +6521,6 @@
VkDescriptorSetLayout descriptorSetLayout,
const VkAllocationCallbacks* pAllocator,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyDescriptorSetLayout in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkDestroyDescriptorSetLayout(device:%p, descriptorSetLayout:%p, pAllocator:%p)", device,
descriptorSetLayout, pAllocator);
@@ -9153,15 +6562,12 @@
}
uint32_t packetSize_vkDestroyDescriptorSetLayout =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkDestroyDescriptorSetLayout);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyDescriptorSetLayout);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyDescriptorSetLayout = OP_vkDestroyDescriptorSetLayout;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyDescriptorSetLayout, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyDescriptorSetLayout, sizeof(uint32_t));
@@ -9188,12 +6594,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkDestroyDescriptorSetLayout), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkDescriptorSetLayout(
(VkDescriptorSetLayout*)&descriptorSetLayout);
stream->flush();
@@ -9209,33 +6609,6 @@
const VkDescriptorPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorPool* pDescriptorPool, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateDescriptorPool in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCreateDescriptorPool(device:%p, pCreateInfo:%p, pAllocator:%p, pDescriptorPool:%p)",
device, pCreateInfo, pAllocator, pDescriptorPool);
@@ -9290,14 +6663,12 @@
}
uint32_t packetSize_vkCreateDescriptorPool =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateDescriptorPool);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateDescriptorPool);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateDescriptorPool = OP_vkCreateDescriptorPool;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateDescriptorPool, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateDescriptorPool, sizeof(uint32_t));
@@ -9329,12 +6700,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCreateDescriptorPool), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -9354,33 +6719,6 @@
void VkEncoder::vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyDescriptorPool in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroyDescriptorPool(device:%p, descriptorPool:%p, pAllocator:%p)",
device, descriptorPool, pAllocator);
(void)doLock;
@@ -9421,14 +6759,12 @@
}
uint32_t packetSize_vkDestroyDescriptorPool =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyDescriptorPool);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyDescriptorPool);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyDescriptorPool = OP_vkDestroyDescriptorPool;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyDescriptorPool, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyDescriptorPool, sizeof(uint32_t));
@@ -9455,12 +6791,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkDestroyDescriptorPool), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkDescriptorPool(
(VkDescriptorPool*)&descriptorPool);
stream->flush();
@@ -9474,33 +6804,6 @@
VkResult VkEncoder::vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
VkDescriptorPoolResetFlags flags, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkResetDescriptorPool in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkResetDescriptorPool(device:%p, descriptorPool:%p, flags:%d)", device,
descriptorPool, flags);
(void)doLock;
@@ -9526,14 +6829,12 @@
}
uint32_t packetSize_vkResetDescriptorPool =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkResetDescriptorPool);
uint8_t* streamPtr = stream->reserve(packetSize_vkResetDescriptorPool);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkResetDescriptorPool = OP_vkResetDescriptorPool;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkResetDescriptorPool, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkResetDescriptorPool, sizeof(uint32_t));
@@ -9553,12 +6854,6 @@
memcpy(*streamPtrPtr, (VkDescriptorPoolResetFlags*)&local_flags,
sizeof(VkDescriptorPoolResetFlags));
*streamPtrPtr += sizeof(VkDescriptorPoolResetFlags);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkResetDescriptorPool), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0;
stream->read(&vkResetDescriptorPool_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -9573,33 +6868,6 @@
VkResult VkEncoder::vkAllocateDescriptorSets(VkDevice device,
const VkDescriptorSetAllocateInfo* pAllocateInfo,
VkDescriptorSet* pDescriptorSets, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkAllocateDescriptorSets in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkAllocateDescriptorSets(device:%p, pAllocateInfo:%p, pDescriptorSets:%p)",
device, pAllocateInfo, pDescriptorSets);
(void)doLock;
@@ -9636,14 +6904,12 @@
}
uint32_t packetSize_vkAllocateDescriptorSets =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkAllocateDescriptorSets);
uint8_t* streamPtr = stream->reserve(packetSize_vkAllocateDescriptorSets);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkAllocateDescriptorSets = OP_vkAllocateDescriptorSets;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkAllocateDescriptorSets, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkAllocateDescriptorSets, sizeof(uint32_t));
@@ -9669,12 +6935,6 @@
*streamPtrPtr += 8 * pAllocateInfo->descriptorSetCount;
}
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkAllocateDescriptorSets), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
if (pAllocateInfo->descriptorSetCount) {
uint64_t* cgen_var_2;
@@ -9698,33 +6958,6 @@
VkResult VkEncoder::vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
uint32_t descriptorSetCount,
const VkDescriptorSet* pDescriptorSets, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkFreeDescriptorSets in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkFreeDescriptorSets(device:%p, descriptorPool:%p, descriptorSetCount:%d, "
"pDescriptorSets:%p)",
@@ -9762,14 +6995,12 @@
}
uint32_t packetSize_vkFreeDescriptorSets =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkFreeDescriptorSets);
uint8_t* streamPtr = stream->reserve(packetSize_vkFreeDescriptorSets);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkFreeDescriptorSets = OP_vkFreeDescriptorSets;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkFreeDescriptorSets, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkFreeDescriptorSets, sizeof(uint32_t));
@@ -9803,12 +7034,6 @@
*streamPtrPtr += 8 * ((descriptorSetCount));
}
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkFreeDescriptorSets), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkFreeDescriptorSets_VkResult_return = (VkResult)0;
stream->read(&vkFreeDescriptorSets_VkResult_return, sizeof(VkResult));
if (pDescriptorSets) {
@@ -9829,33 +7054,6 @@
uint32_t descriptorCopyCount,
const VkCopyDescriptorSet* pDescriptorCopies,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkUpdateDescriptorSets in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkUpdateDescriptorSets(device:%p, descriptorWriteCount:%d, pDescriptorWrites:%p, "
"descriptorCopyCount:%d, pDescriptorCopies:%p)",
@@ -9924,14 +7122,12 @@
}
uint32_t packetSize_vkUpdateDescriptorSets =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkUpdateDescriptorSets);
uint8_t* streamPtr = stream->reserve(packetSize_vkUpdateDescriptorSets);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkUpdateDescriptorSets = OP_vkUpdateDescriptorSets;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkUpdateDescriptorSets, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkUpdateDescriptorSets, sizeof(uint32_t));
@@ -9958,12 +7154,6 @@
(VkCopyDescriptorSet*)(local_pDescriptorCopies + i),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkUpdateDescriptorSets), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->flush();
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -9976,33 +7166,6 @@
VkResult VkEncoder::vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkFramebuffer* pFramebuffer, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateFramebuffer in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCreateFramebuffer(device:%p, pCreateInfo:%p, pAllocator:%p, pFramebuffer:%p)", device,
pCreateInfo, pAllocator, pFramebuffer);
@@ -10056,14 +7219,12 @@
}
uint32_t packetSize_vkCreateFramebuffer =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateFramebuffer);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateFramebuffer);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateFramebuffer = OP_vkCreateFramebuffer;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateFramebuffer, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateFramebuffer, sizeof(uint32_t));
@@ -10095,12 +7256,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCreateFramebuffer), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -10120,33 +7275,6 @@
void VkEncoder::vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyFramebuffer in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroyFramebuffer(device:%p, framebuffer:%p, pAllocator:%p)", device,
framebuffer, pAllocator);
(void)doLock;
@@ -10187,14 +7315,12 @@
}
uint32_t packetSize_vkDestroyFramebuffer =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyFramebuffer);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyFramebuffer);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyFramebuffer = OP_vkDestroyFramebuffer;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyFramebuffer, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyFramebuffer, sizeof(uint32_t));
@@ -10221,12 +7347,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkDestroyFramebuffer), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkFramebuffer((VkFramebuffer*)&framebuffer);
stream->flush();
++encodeCount;
@@ -10240,33 +7360,6 @@
VkResult VkEncoder::vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkRenderPass* pRenderPass, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateRenderPass in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCreateRenderPass(device:%p, pCreateInfo:%p, pAllocator:%p, pRenderPass:%p)", device,
pCreateInfo, pAllocator, pRenderPass);
@@ -10320,14 +7413,12 @@
}
uint32_t packetSize_vkCreateRenderPass =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateRenderPass);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateRenderPass);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateRenderPass = OP_vkCreateRenderPass;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateRenderPass, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateRenderPass, sizeof(uint32_t));
@@ -10359,12 +7450,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCreateRenderPass), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -10384,33 +7469,6 @@
void VkEncoder::vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyRenderPass in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroyRenderPass(device:%p, renderPass:%p, pAllocator:%p)", device,
renderPass, pAllocator);
(void)doLock;
@@ -10451,14 +7509,12 @@
}
uint32_t packetSize_vkDestroyRenderPass =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyRenderPass);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyRenderPass);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyRenderPass = OP_vkDestroyRenderPass;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyRenderPass, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyRenderPass, sizeof(uint32_t));
@@ -10485,12 +7541,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkDestroyRenderPass), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkRenderPass((VkRenderPass*)&renderPass);
stream->flush();
++encodeCount;
@@ -10503,33 +7553,6 @@
void VkEncoder::vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
VkExtent2D* pGranularity, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetRenderAreaGranularity in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetRenderAreaGranularity(device:%p, renderPass:%p, pGranularity:%p)",
device, renderPass, pGranularity);
(void)doLock;
@@ -10554,14 +7577,12 @@
}
uint32_t packetSize_vkGetRenderAreaGranularity =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetRenderAreaGranularity);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetRenderAreaGranularity);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetRenderAreaGranularity = OP_vkGetRenderAreaGranularity;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetRenderAreaGranularity, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetRenderAreaGranularity, sizeof(uint32_t));
@@ -10580,12 +7601,6 @@
*streamPtrPtr += 1 * 8;
reservedmarshal_VkExtent2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pGranularity),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetRenderAreaGranularity), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkExtent2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pGranularity));
if (pGranularity) {
transform_fromhost_VkExtent2D(sResourceTracker, (VkExtent2D*)(pGranularity));
@@ -10601,33 +7616,6 @@
VkResult VkEncoder::vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkCommandPool* pCommandPool, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateCommandPool in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCreateCommandPool(device:%p, pCreateInfo:%p, pAllocator:%p, pCommandPool:%p)", device,
pCreateInfo, pAllocator, pCommandPool);
@@ -10681,14 +7669,12 @@
}
uint32_t packetSize_vkCreateCommandPool =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateCommandPool);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateCommandPool);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateCommandPool = OP_vkCreateCommandPool;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateCommandPool, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateCommandPool, sizeof(uint32_t));
@@ -10720,12 +7706,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCreateCommandPool), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -10745,33 +7725,6 @@
void VkEncoder::vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyCommandPool in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroyCommandPool(device:%p, commandPool:%p, pAllocator:%p)", device,
commandPool, pAllocator);
(void)doLock;
@@ -10812,14 +7765,12 @@
}
uint32_t packetSize_vkDestroyCommandPool =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyCommandPool);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyCommandPool);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyCommandPool = OP_vkDestroyCommandPool;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyCommandPool, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyCommandPool, sizeof(uint32_t));
@@ -10846,12 +7797,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkDestroyCommandPool), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkCommandPool((VkCommandPool*)&commandPool);
stream->flush();
++encodeCount;
@@ -10864,33 +7809,6 @@
VkResult VkEncoder::vkResetCommandPool(VkDevice device, VkCommandPool commandPool,
VkCommandPoolResetFlags flags, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkResetCommandPool in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkResetCommandPool(device:%p, commandPool:%p, flags:%d)", device,
commandPool, flags);
(void)doLock;
@@ -10916,14 +7834,12 @@
}
uint32_t packetSize_vkResetCommandPool =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkResetCommandPool);
uint8_t* streamPtr = stream->reserve(packetSize_vkResetCommandPool);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkResetCommandPool = OP_vkResetCommandPool;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkResetCommandPool, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkResetCommandPool, sizeof(uint32_t));
@@ -10942,12 +7858,6 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkCommandPoolResetFlags*)&local_flags, sizeof(VkCommandPoolResetFlags));
*streamPtrPtr += sizeof(VkCommandPoolResetFlags);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkResetCommandPool), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkResetCommandPool_VkResult_return = (VkResult)0;
stream->read(&vkResetCommandPool_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -10962,33 +7872,6 @@
VkResult VkEncoder::vkAllocateCommandBuffers(VkDevice device,
const VkCommandBufferAllocateInfo* pAllocateInfo,
VkCommandBuffer* pCommandBuffers, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkAllocateCommandBuffers in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkAllocateCommandBuffers(device:%p, pAllocateInfo:%p, pCommandBuffers:%p)",
device, pAllocateInfo, pCommandBuffers);
(void)doLock;
@@ -11025,14 +7908,12 @@
}
uint32_t packetSize_vkAllocateCommandBuffers =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkAllocateCommandBuffers);
uint8_t* streamPtr = stream->reserve(packetSize_vkAllocateCommandBuffers);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkAllocateCommandBuffers = OP_vkAllocateCommandBuffers;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkAllocateCommandBuffers, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkAllocateCommandBuffers, sizeof(uint32_t));
@@ -11058,12 +7939,6 @@
*streamPtrPtr += 8 * pAllocateInfo->commandBufferCount;
}
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkAllocateCommandBuffers), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
if (pAllocateInfo->commandBufferCount) {
uint64_t* cgen_var_2;
@@ -11087,33 +7962,6 @@
void VkEncoder::vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool,
uint32_t commandBufferCount,
const VkCommandBuffer* pCommandBuffers, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkFreeCommandBuffers in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkFreeCommandBuffers(device:%p, commandPool:%p, commandBufferCount:%d, "
"pCommandBuffers:%p)",
@@ -11151,14 +7999,12 @@
}
uint32_t packetSize_vkFreeCommandBuffers =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkFreeCommandBuffers);
uint8_t* streamPtr = stream->reserve(packetSize_vkFreeCommandBuffers);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkFreeCommandBuffers = OP_vkFreeCommandBuffers;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkFreeCommandBuffers, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkFreeCommandBuffers, sizeof(uint32_t));
@@ -11192,12 +8038,6 @@
*streamPtrPtr += 8 * ((commandBufferCount));
}
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkFreeCommandBuffers), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
if (pCommandBuffers) {
sResourceTracker->destroyMapping()->mapHandles_VkCommandBuffer(
(VkCommandBuffer*)pCommandBuffers, ((commandBufferCount)));
@@ -11214,33 +8054,6 @@
VkResult VkEncoder::vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
const VkCommandBufferBeginInfo* pBeginInfo,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkBeginCommandBuffer in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkBeginCommandBuffer(commandBuffer:%p, pBeginInfo:%p)", commandBuffer,
pBeginInfo);
(void)doLock;
@@ -11272,7 +8085,6 @@
(VkCommandBufferBeginInfo*)(local_pBeginInfo), countPtr);
}
uint32_t packetSize_vkBeginCommandBuffer = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkBeginCommandBuffer);
if (queueSubmitWithCommandsEnabled) packetSize_vkBeginCommandBuffer -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkBeginCommandBuffer);
uint8_t* packetBeginPtr = streamPtr;
@@ -11291,12 +8103,6 @@
reservedmarshal_VkCommandBufferBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkCommandBufferBeginInfo*)(local_pBeginInfo),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkBeginCommandBuffer), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
stream->read(&vkBeginCommandBuffer_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -11309,33 +8115,6 @@
}
VkResult VkEncoder::vkEndCommandBuffer(VkCommandBuffer commandBuffer, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkEndCommandBuffer in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkEndCommandBuffer(commandBuffer:%p)", commandBuffer);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -11352,7 +8131,6 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkEndCommandBuffer = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkEndCommandBuffer);
if (queueSubmitWithCommandsEnabled) packetSize_vkEndCommandBuffer -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkEndCommandBuffer);
uint8_t* packetBeginPtr = streamPtr;
@@ -11368,12 +8146,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkEndCommandBuffer), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
stream->read(&vkEndCommandBuffer_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -11387,33 +8159,6 @@
VkResult VkEncoder::vkResetCommandBuffer(VkCommandBuffer commandBuffer,
VkCommandBufferResetFlags flags, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkResetCommandBuffer in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkResetCommandBuffer(commandBuffer:%p, flags:%d)", commandBuffer, flags);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -11433,7 +8178,6 @@
*countPtr += sizeof(VkCommandBufferResetFlags);
}
uint32_t packetSize_vkResetCommandBuffer = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkResetCommandBuffer);
if (queueSubmitWithCommandsEnabled) packetSize_vkResetCommandBuffer -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkResetCommandBuffer);
uint8_t* packetBeginPtr = streamPtr;
@@ -11452,12 +8196,6 @@
memcpy(*streamPtrPtr, (VkCommandBufferResetFlags*)&local_flags,
sizeof(VkCommandBufferResetFlags));
*streamPtrPtr += sizeof(VkCommandBufferResetFlags);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkResetCommandBuffer), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
stream->read(&vkResetCommandBuffer_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -11472,33 +8210,6 @@
void VkEncoder::vkCmdBindPipeline(VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdBindPipeline in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdBindPipeline(commandBuffer:%p, pipeline:%p)", commandBuffer, pipeline);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -11522,7 +8233,6 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkCmdBindPipeline = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBindPipeline);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBindPipeline -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBindPipeline);
uint8_t* packetBeginPtr = streamPtr;
@@ -11545,12 +8255,6 @@
*&cgen_var_0 = get_host_u64_VkPipeline((*&local_pipeline));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdBindPipeline), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -11562,33 +8266,6 @@
void VkEncoder::vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
uint32_t viewportCount, const VkViewport* pViewports,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetViewport in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdSetViewport(commandBuffer:%p, firstViewport:%d, viewportCount:%d, pViewports:%p)",
commandBuffer, firstViewport, viewportCount, pViewports);
@@ -11631,7 +8308,6 @@
}
}
uint32_t packetSize_vkCmdSetViewport = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetViewport);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetViewport -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetViewport);
uint8_t* packetBeginPtr = streamPtr;
@@ -11655,12 +8331,6 @@
reservedmarshal_VkViewport(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkViewport*)(local_pViewports + i), streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdSetViewport), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -11671,33 +8341,6 @@
void VkEncoder::vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
uint32_t scissorCount, const VkRect2D* pScissors, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetScissor in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdSetScissor(commandBuffer:%p, firstScissor:%d, scissorCount:%d, pScissors:%p)",
commandBuffer, firstScissor, scissorCount, pScissors);
@@ -11740,7 +8383,6 @@
}
}
uint32_t packetSize_vkCmdSetScissor = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetScissor);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetScissor -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetScissor);
uint8_t* packetBeginPtr = streamPtr;
@@ -11764,12 +8406,6 @@
reservedmarshal_VkRect2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkRect2D*)(local_pScissors + i), streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdSetScissor), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -11779,33 +8415,6 @@
}
void VkEncoder::vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetLineWidth in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetLineWidth(commandBuffer:%p, lineWidth:%f)", commandBuffer,
lineWidth);
(void)doLock;
@@ -11826,7 +8435,6 @@
*countPtr += sizeof(float);
}
uint32_t packetSize_vkCmdSetLineWidth = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetLineWidth);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetLineWidth -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetLineWidth);
uint8_t* packetBeginPtr = streamPtr;
@@ -11844,12 +8452,6 @@
}
memcpy(*streamPtrPtr, (float*)&local_lineWidth, sizeof(float));
*streamPtrPtr += sizeof(float);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdSetLineWidth), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -11861,33 +8463,6 @@
void VkEncoder::vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
float depthBiasClamp, float depthBiasSlopeFactor,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetDepthBias in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdSetDepthBias(commandBuffer:%p, depthBiasConstantFactor:%f, depthBiasClamp:%f, "
"depthBiasSlopeFactor:%f)",
@@ -11916,7 +8491,6 @@
*countPtr += sizeof(float);
}
uint32_t packetSize_vkCmdSetDepthBias = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetDepthBias);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDepthBias -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDepthBias);
uint8_t* packetBeginPtr = streamPtr;
@@ -11938,12 +8512,6 @@
*streamPtrPtr += sizeof(float);
memcpy(*streamPtrPtr, (float*)&local_depthBiasSlopeFactor, sizeof(float));
*streamPtrPtr += sizeof(float);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdSetDepthBias), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -11954,33 +8522,6 @@
void VkEncoder::vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4],
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetBlendConstants in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetBlendConstants(commandBuffer:%p, blendConstants:%f)", commandBuffer,
blendConstants);
(void)doLock;
@@ -12001,7 +8542,6 @@
*countPtr += 4 * sizeof(float);
}
uint32_t packetSize_vkCmdSetBlendConstants = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetBlendConstants);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetBlendConstants -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetBlendConstants);
uint8_t* packetBeginPtr = streamPtr;
@@ -12019,12 +8559,6 @@
}
memcpy(*streamPtrPtr, (float*)local_blendConstants, 4 * sizeof(float));
*streamPtrPtr += 4 * sizeof(float);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetBlendConstants), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -12035,33 +8569,6 @@
void VkEncoder::vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
float maxDepthBounds, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetDepthBounds in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetDepthBounds(commandBuffer:%p, minDepthBounds:%f, maxDepthBounds:%f)",
commandBuffer, minDepthBounds, maxDepthBounds);
(void)doLock;
@@ -12085,7 +8592,6 @@
*countPtr += sizeof(float);
}
uint32_t packetSize_vkCmdSetDepthBounds = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetDepthBounds);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDepthBounds -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDepthBounds);
uint8_t* packetBeginPtr = streamPtr;
@@ -12105,12 +8611,6 @@
*streamPtrPtr += sizeof(float);
memcpy(*streamPtrPtr, (float*)&local_maxDepthBounds, sizeof(float));
*streamPtrPtr += sizeof(float);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetDepthBounds), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -12122,33 +8622,6 @@
void VkEncoder::vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask, uint32_t compareMask,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetStencilCompareMask in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetStencilCompareMask(commandBuffer:%p, faceMask:%d, compareMask:%d)",
commandBuffer, faceMask, compareMask);
(void)doLock;
@@ -12172,7 +8645,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdSetStencilCompareMask = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetStencilCompareMask);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetStencilCompareMask -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetStencilCompareMask);
uint8_t* packetBeginPtr = streamPtr;
@@ -12192,12 +8664,6 @@
*streamPtrPtr += sizeof(VkStencilFaceFlags);
memcpy(*streamPtrPtr, (uint32_t*)&local_compareMask, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetStencilCompareMask), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -12208,33 +8674,6 @@
void VkEncoder::vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
uint32_t writeMask, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetStencilWriteMask in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetStencilWriteMask(commandBuffer:%p, faceMask:%d, writeMask:%d)",
commandBuffer, faceMask, writeMask);
(void)doLock;
@@ -12258,7 +8697,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdSetStencilWriteMask = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetStencilWriteMask);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetStencilWriteMask -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetStencilWriteMask);
uint8_t* packetBeginPtr = streamPtr;
@@ -12278,12 +8716,6 @@
*streamPtrPtr += sizeof(VkStencilFaceFlags);
memcpy(*streamPtrPtr, (uint32_t*)&local_writeMask, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetStencilWriteMask), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -12294,33 +8726,6 @@
void VkEncoder::vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
uint32_t reference, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetStencilReference in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetStencilReference(commandBuffer:%p, faceMask:%d, reference:%d)",
commandBuffer, faceMask, reference);
(void)doLock;
@@ -12344,7 +8749,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdSetStencilReference = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetStencilReference);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetStencilReference -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetStencilReference);
uint8_t* packetBeginPtr = streamPtr;
@@ -12364,12 +8768,6 @@
*streamPtrPtr += sizeof(VkStencilFaceFlags);
memcpy(*streamPtrPtr, (uint32_t*)&local_reference, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetStencilReference), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -12382,33 +8780,6 @@
VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets,
uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdBindDescriptorSets in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdBindDescriptorSets(commandBuffer:%p, layout:%p, firstSet:%d, descriptorSetCount:%d, "
"pDescriptorSets:%p, dynamicOffsetCount:%d, pDynamicOffsets:%p)",
@@ -12455,7 +8826,6 @@
*countPtr += ((dynamicOffsetCount)) * sizeof(uint32_t);
}
uint32_t packetSize_vkCmdBindDescriptorSets = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBindDescriptorSets);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBindDescriptorSets -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBindDescriptorSets);
uint8_t* packetBeginPtr = streamPtr;
@@ -12495,12 +8865,6 @@
memcpy(*streamPtrPtr, (uint32_t*)local_pDynamicOffsets,
((dynamicOffsetCount)) * sizeof(uint32_t));
*streamPtrPtr += ((dynamicOffsetCount)) * sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdBindDescriptorSets), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -12511,33 +8875,6 @@
void VkEncoder::vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer,
VkDeviceSize offset, VkIndexType indexType, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdBindIndexBuffer in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdBindIndexBuffer(commandBuffer:%p, buffer:%p, offset:%ld)",
commandBuffer, buffer, offset);
(void)doLock;
@@ -12565,7 +8902,6 @@
*countPtr += sizeof(VkIndexType);
}
uint32_t packetSize_vkCmdBindIndexBuffer = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBindIndexBuffer);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBindIndexBuffer -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBindIndexBuffer);
uint8_t* packetBeginPtr = streamPtr;
@@ -12589,12 +8925,6 @@
*streamPtrPtr += sizeof(VkDeviceSize);
memcpy(*streamPtrPtr, (VkIndexType*)&local_indexType, sizeof(VkIndexType));
*streamPtrPtr += sizeof(VkIndexType);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdBindIndexBuffer), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -12606,33 +8936,6 @@
void VkEncoder::vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
uint32_t bindingCount, const VkBuffer* pBuffers,
const VkDeviceSize* pOffsets, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdBindVertexBuffers in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdBindVertexBuffers(commandBuffer:%p, firstBinding:%d, bindingCount:%d, pBuffers:%p, "
"pOffsets:%p)",
@@ -12668,7 +8971,6 @@
*countPtr += ((bindingCount)) * sizeof(VkDeviceSize);
}
uint32_t packetSize_vkCmdBindVertexBuffers = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBindVertexBuffers);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBindVertexBuffers -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBindVertexBuffers);
uint8_t* packetBeginPtr = streamPtr;
@@ -12698,12 +9000,6 @@
}
memcpy(*streamPtrPtr, (VkDeviceSize*)local_pOffsets, ((bindingCount)) * sizeof(VkDeviceSize));
*streamPtrPtr += ((bindingCount)) * sizeof(VkDeviceSize);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdBindVertexBuffers), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -12715,33 +9011,6 @@
void VkEncoder::vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount,
uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdDraw in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdDraw(commandBuffer:%p, vertexCount:%d, instanceCount:%d, firstVertex:%d, "
"firstInstance:%d)",
@@ -12773,7 +9042,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDraw = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDraw);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDraw -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDraw);
uint8_t* packetBeginPtr = streamPtr;
@@ -12797,12 +9065,6 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_firstInstance, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdDraw), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -12814,33 +9076,6 @@
void VkEncoder::vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset,
uint32_t firstInstance, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdDrawIndexed in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdDrawIndexed(commandBuffer:%p, indexCount:%d, instanceCount:%d, firstIndex:%d, "
"vertexOffset:%d, firstInstance:%d)",
@@ -12875,7 +9110,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDrawIndexed = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDrawIndexed);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawIndexed -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawIndexed);
uint8_t* packetBeginPtr = streamPtr;
@@ -12901,12 +9135,6 @@
*streamPtrPtr += sizeof(int32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_firstInstance, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdDrawIndexed), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -12918,33 +9146,6 @@
void VkEncoder::vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
VkDeviceSize offset, uint32_t drawCount, uint32_t stride,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdDrawIndirect in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdDrawIndirect(commandBuffer:%p, buffer:%p, offset:%ld, drawCount:%d, stride:%d)",
commandBuffer, buffer, offset, drawCount, stride);
@@ -12976,7 +9177,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDrawIndirect = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDrawIndirect);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawIndirect -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawIndirect);
uint8_t* packetBeginPtr = streamPtr;
@@ -13002,12 +9202,6 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_stride, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdDrawIndirect), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -13019,33 +9213,6 @@
void VkEncoder::vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
VkDeviceSize offset, uint32_t drawCount, uint32_t stride,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdDrawIndexedIndirect in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdDrawIndexedIndirect(commandBuffer:%p, buffer:%p, offset:%ld, drawCount:%d, "
"stride:%d)",
@@ -13078,7 +9245,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDrawIndexedIndirect = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDrawIndexedIndirect);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawIndexedIndirect -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawIndexedIndirect);
uint8_t* packetBeginPtr = streamPtr;
@@ -13104,12 +9270,6 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_stride, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdDrawIndexedIndirect), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -13120,33 +9280,6 @@
void VkEncoder::vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX,
uint32_t groupCountY, uint32_t groupCountZ, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdDispatch in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdDispatch(commandBuffer:%p, groupCountX:%d, groupCountY:%d, groupCountZ:%d)",
commandBuffer, groupCountX, groupCountY, groupCountZ);
@@ -13174,7 +9307,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDispatch = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDispatch);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDispatch -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDispatch);
uint8_t* packetBeginPtr = streamPtr;
@@ -13196,12 +9328,6 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_groupCountZ, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdDispatch), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -13212,33 +9338,6 @@
void VkEncoder::vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
VkDeviceSize offset, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdDispatchIndirect in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdDispatchIndirect(commandBuffer:%p, buffer:%p, offset:%ld)",
commandBuffer, buffer, offset);
(void)doLock;
@@ -13263,7 +9362,6 @@
*countPtr += sizeof(VkDeviceSize);
}
uint32_t packetSize_vkCmdDispatchIndirect = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDispatchIndirect);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDispatchIndirect -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDispatchIndirect);
uint8_t* packetBeginPtr = streamPtr;
@@ -13285,12 +9383,6 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
*streamPtrPtr += sizeof(VkDeviceSize);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdDispatchIndirect), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -13302,33 +9394,6 @@
void VkEncoder::vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
VkBuffer dstBuffer, uint32_t regionCount,
const VkBufferCopy* pRegions, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdCopyBuffer in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdCopyBuffer(commandBuffer:%p, srcBuffer:%p, dstBuffer:%p, regionCount:%d, "
"pRegions:%p)",
@@ -13377,7 +9442,6 @@
}
}
uint32_t packetSize_vkCmdCopyBuffer = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyBuffer);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyBuffer -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyBuffer);
uint8_t* packetBeginPtr = streamPtr;
@@ -13407,12 +9471,6 @@
reservedmarshal_VkBufferCopy(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkBufferCopy*)(local_pRegions + i), streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdCopyBuffer), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -13425,33 +9483,6 @@
VkImageLayout srcImageLayout, VkImage dstImage,
VkImageLayout dstImageLayout, uint32_t regionCount,
const VkImageCopy* pRegions, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdCopyImage in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdCopyImage(commandBuffer:%p, srcImage:%p, srcImageLayout:%d, dstImage:%p, "
"dstImageLayout:%d, regionCount:%d, pRegions:%p)",
@@ -13506,7 +9537,6 @@
}
}
uint32_t packetSize_vkCmdCopyImage = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyImage);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyImage -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyImage);
uint8_t* packetBeginPtr = streamPtr;
@@ -13540,12 +9570,6 @@
reservedmarshal_VkImageCopy(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkImageCopy*)(local_pRegions + i), streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdCopyImage), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -13558,33 +9582,6 @@
VkImageLayout srcImageLayout, VkImage dstImage,
VkImageLayout dstImageLayout, uint32_t regionCount,
const VkImageBlit* pRegions, VkFilter filter, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdBlitImage in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdBlitImage(commandBuffer:%p, srcImage:%p, srcImageLayout:%d, dstImage:%p, "
"dstImageLayout:%d, regionCount:%d, pRegions:%p)",
@@ -13642,7 +9639,6 @@
*countPtr += sizeof(VkFilter);
}
uint32_t packetSize_vkCmdBlitImage = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBlitImage);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBlitImage -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBlitImage);
uint8_t* packetBeginPtr = streamPtr;
@@ -13678,12 +9674,6 @@
}
memcpy(*streamPtrPtr, (VkFilter*)&local_filter, sizeof(VkFilter));
*streamPtrPtr += sizeof(VkFilter);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdBlitImage), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -13696,33 +9686,6 @@
VkImage dstImage, VkImageLayout dstImageLayout,
uint32_t regionCount, const VkBufferImageCopy* pRegions,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdCopyBufferToImage in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdCopyBufferToImage(commandBuffer:%p, srcBuffer:%p, dstImage:%p, dstImageLayout:%d, "
"regionCount:%d, pRegions:%p)",
@@ -13776,7 +9739,6 @@
}
}
uint32_t packetSize_vkCmdCopyBufferToImage = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyBufferToImage);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyBufferToImage -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyBufferToImage);
uint8_t* packetBeginPtr = streamPtr;
@@ -13808,12 +9770,6 @@
reservedmarshal_VkBufferImageCopy(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkBufferImageCopy*)(local_pRegions + i), streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdCopyBufferToImage), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -13826,33 +9782,6 @@
VkImageLayout srcImageLayout, VkBuffer dstBuffer,
uint32_t regionCount, const VkBufferImageCopy* pRegions,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdCopyImageToBuffer in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdCopyImageToBuffer(commandBuffer:%p, srcImage:%p, srcImageLayout:%d, dstBuffer:%p, "
"regionCount:%d, pRegions:%p)",
@@ -13906,7 +9835,6 @@
}
}
uint32_t packetSize_vkCmdCopyImageToBuffer = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyImageToBuffer);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyImageToBuffer -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyImageToBuffer);
uint8_t* packetBeginPtr = streamPtr;
@@ -13938,12 +9866,6 @@
reservedmarshal_VkBufferImageCopy(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkBufferImageCopy*)(local_pRegions + i), streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdCopyImageToBuffer), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -13955,33 +9877,6 @@
void VkEncoder::vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdUpdateBuffer in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdUpdateBuffer(commandBuffer:%p, dstBuffer:%p, dstOffset:%ld, dataSize:%ld, pData:%p)",
commandBuffer, dstBuffer, dstOffset, dataSize, pData);
@@ -14014,7 +9909,6 @@
*countPtr += ((dataSize)) * sizeof(uint8_t);
}
uint32_t packetSize_vkCmdUpdateBuffer = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdUpdateBuffer);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdUpdateBuffer -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdUpdateBuffer);
uint8_t* packetBeginPtr = streamPtr;
@@ -14040,12 +9934,6 @@
*streamPtrPtr += sizeof(VkDeviceSize);
memcpy(*streamPtrPtr, (void*)local_pData, ((dataSize)) * sizeof(uint8_t));
*streamPtrPtr += ((dataSize)) * sizeof(uint8_t);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdUpdateBuffer), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -14057,33 +9945,6 @@
void VkEncoder::vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdFillBuffer in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdFillBuffer(commandBuffer:%p, dstBuffer:%p, dstOffset:%ld, size:%ld, data:%d)",
commandBuffer, dstBuffer, dstOffset, size, data);
@@ -14115,7 +9976,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdFillBuffer = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdFillBuffer);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdFillBuffer -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdFillBuffer);
uint8_t* packetBeginPtr = streamPtr;
@@ -14141,12 +10001,6 @@
*streamPtrPtr += sizeof(VkDeviceSize);
memcpy(*streamPtrPtr, (uint32_t*)&local_data, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdFillBuffer), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -14159,33 +10013,6 @@
VkImageLayout imageLayout, const VkClearColorValue* pColor,
uint32_t rangeCount, const VkImageSubresourceRange* pRanges,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdClearColorImage in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdClearColorImage(commandBuffer:%p, image:%p, imageLayout:%d, pColor:%p, "
"rangeCount:%d, pRanges:%p)",
@@ -14247,7 +10074,6 @@
}
}
uint32_t packetSize_vkCmdClearColorImage = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdClearColorImage);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdClearColorImage -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdClearColorImage);
uint8_t* packetBeginPtr = streamPtr;
@@ -14278,12 +10104,6 @@
(VkImageSubresourceRange*)(local_pRanges + i),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdClearColorImage), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -14298,33 +10118,6 @@
uint32_t rangeCount,
const VkImageSubresourceRange* pRanges,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdClearDepthStencilImage in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdClearDepthStencilImage(commandBuffer:%p, image:%p, imageLayout:%d, pDepthStencil:%p, "
"rangeCount:%d, pRanges:%p)",
@@ -14388,7 +10181,6 @@
}
}
uint32_t packetSize_vkCmdClearDepthStencilImage = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdClearDepthStencilImage);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdClearDepthStencilImage -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdClearDepthStencilImage);
uint8_t* packetBeginPtr = streamPtr;
@@ -14420,12 +10212,6 @@
(VkImageSubresourceRange*)(local_pRanges + i),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdClearDepthStencilImage), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -14437,33 +10223,6 @@
void VkEncoder::vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
const VkClearAttachment* pAttachments, uint32_t rectCount,
const VkClearRect* pRects, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdClearAttachments in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdClearAttachments(commandBuffer:%p, attachmentCount:%d, pAttachments:%p, "
"rectCount:%d, pRects:%p)",
@@ -14527,7 +10286,6 @@
}
}
uint32_t packetSize_vkCmdClearAttachments = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdClearAttachments);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdClearAttachments -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdClearAttachments);
uint8_t* packetBeginPtr = streamPtr;
@@ -14556,12 +10314,6 @@
reservedmarshal_VkClearRect(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkClearRect*)(local_pRects + i), streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdClearAttachments), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -14574,33 +10326,6 @@
VkImageLayout srcImageLayout, VkImage dstImage,
VkImageLayout dstImageLayout, uint32_t regionCount,
const VkImageResolve* pRegions, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdResolveImage in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdResolveImage(commandBuffer:%p, srcImage:%p, srcImageLayout:%d, dstImage:%p, "
"dstImageLayout:%d, regionCount:%d, pRegions:%p)",
@@ -14657,7 +10382,6 @@
}
}
uint32_t packetSize_vkCmdResolveImage = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdResolveImage);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdResolveImage -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdResolveImage);
uint8_t* packetBeginPtr = streamPtr;
@@ -14691,12 +10415,6 @@
reservedmarshal_VkImageResolve(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkImageResolve*)(local_pRegions + i), streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdResolveImage), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -14707,33 +10425,6 @@
void VkEncoder::vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
VkPipelineStageFlags stageMask, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetEvent in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetEvent(commandBuffer:%p, event:%p, stageMask:%d)", commandBuffer,
event, stageMask);
(void)doLock;
@@ -14758,7 +10449,6 @@
*countPtr += sizeof(VkPipelineStageFlags);
}
uint32_t packetSize_vkCmdSetEvent = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetEvent);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetEvent -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetEvent);
uint8_t* packetBeginPtr = streamPtr;
@@ -14780,12 +10470,6 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
*streamPtrPtr += sizeof(VkPipelineStageFlags);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdSetEvent), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -14796,33 +10480,6 @@
void VkEncoder::vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
VkPipelineStageFlags stageMask, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdResetEvent in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdResetEvent(commandBuffer:%p, event:%p, stageMask:%d)", commandBuffer,
event, stageMask);
(void)doLock;
@@ -14847,7 +10504,6 @@
*countPtr += sizeof(VkPipelineStageFlags);
}
uint32_t packetSize_vkCmdResetEvent = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdResetEvent);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdResetEvent -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdResetEvent);
uint8_t* packetBeginPtr = streamPtr;
@@ -14869,12 +10525,6 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
*streamPtrPtr += sizeof(VkPipelineStageFlags);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdResetEvent), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -14891,33 +10541,6 @@
const VkBufferMemoryBarrier* pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier* pImageMemoryBarriers, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdWaitEvents in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdWaitEvents(commandBuffer:%p, eventCount:%d, pEvents:%p, srcStageMask:%d, "
"dstStageMask:%d, memoryBarrierCount:%d, pMemoryBarriers:%p, bufferMemoryBarrierCount:%d, "
@@ -15028,7 +10651,6 @@
}
}
uint32_t packetSize_vkCmdWaitEvents = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdWaitEvents);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdWaitEvents -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdWaitEvents);
uint8_t* packetBeginPtr = streamPtr;
@@ -15079,12 +10701,6 @@
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i), streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdWaitEvents), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -15100,33 +10716,6 @@
uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdPipelineBarrier in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdPipelineBarrier(commandBuffer:%p, srcStageMask:%d, dstStageMask:%d, "
"dependencyFlags:%d, memoryBarrierCount:%d, pMemoryBarriers:%p, "
@@ -15232,7 +10821,6 @@
}
}
uint32_t packetSize_vkCmdPipelineBarrier = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdPipelineBarrier);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdPipelineBarrier -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdPipelineBarrier);
uint8_t* packetBeginPtr = streamPtr;
@@ -15275,12 +10863,6 @@
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i), streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdPipelineBarrier), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -15291,33 +10873,6 @@
void VkEncoder::vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
uint32_t query, VkQueryControlFlags flags, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdBeginQuery in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdBeginQuery(commandBuffer:%p, queryPool:%p, query:%d, flags:%d)",
commandBuffer, queryPool, query, flags);
(void)doLock;
@@ -15345,7 +10900,6 @@
*countPtr += sizeof(VkQueryControlFlags);
}
uint32_t packetSize_vkCmdBeginQuery = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBeginQuery);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginQuery -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBeginQuery);
uint8_t* packetBeginPtr = streamPtr;
@@ -15369,12 +10923,6 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (VkQueryControlFlags*)&local_flags, sizeof(VkQueryControlFlags));
*streamPtrPtr += sizeof(VkQueryControlFlags);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdBeginQuery), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -15385,33 +10933,6 @@
void VkEncoder::vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdEndQuery in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdEndQuery(commandBuffer:%p, queryPool:%p, query:%d)", commandBuffer,
queryPool, query);
(void)doLock;
@@ -15436,7 +10957,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdEndQuery = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdEndQuery);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEndQuery -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdEndQuery);
uint8_t* packetBeginPtr = streamPtr;
@@ -15458,12 +10978,6 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_query, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdEndQuery), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -15474,33 +10988,6 @@
void VkEncoder::vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
uint32_t firstQuery, uint32_t queryCount, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdResetQueryPool in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdResetQueryPool(commandBuffer:%p, queryPool:%p, firstQuery:%d, queryCount:%d)",
commandBuffer, queryPool, firstQuery, queryCount);
@@ -15529,7 +11016,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdResetQueryPool = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdResetQueryPool);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdResetQueryPool -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdResetQueryPool);
uint8_t* packetBeginPtr = streamPtr;
@@ -15553,12 +11039,6 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_queryCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdResetQueryPool), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -15570,33 +11050,6 @@
void VkEncoder::vkCmdWriteTimestamp(VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool,
uint32_t query, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdWriteTimestamp in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdWriteTimestamp(commandBuffer:%p, queryPool:%p, query:%d)",
commandBuffer, queryPool, query);
(void)doLock;
@@ -15624,7 +11077,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdWriteTimestamp = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdWriteTimestamp);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdWriteTimestamp -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdWriteTimestamp);
uint8_t* packetBeginPtr = streamPtr;
@@ -15649,12 +11101,6 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_query, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdWriteTimestamp), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -15668,33 +11114,6 @@
VkBuffer dstBuffer, VkDeviceSize dstOffset,
VkDeviceSize stride, VkQueryResultFlags flags,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdCopyQueryPoolResults in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdCopyQueryPoolResults(commandBuffer:%p, queryPool:%p, firstQuery:%d, queryCount:%d, "
"dstBuffer:%p, dstOffset:%ld, stride:%ld, flags:%d)",
@@ -15737,7 +11156,6 @@
*countPtr += sizeof(VkQueryResultFlags);
}
uint32_t packetSize_vkCmdCopyQueryPoolResults = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyQueryPoolResults);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyQueryPoolResults -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyQueryPoolResults);
uint8_t* packetBeginPtr = streamPtr;
@@ -15771,12 +11189,6 @@
*streamPtrPtr += sizeof(VkDeviceSize);
memcpy(*streamPtrPtr, (VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
*streamPtrPtr += sizeof(VkQueryResultFlags);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdCopyQueryPoolResults), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -15788,33 +11200,6 @@
void VkEncoder::vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
const void* pValues, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdPushConstants in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdPushConstants(commandBuffer:%p, layout:%p, stageFlags:%d, offset:%d, size:%d, "
"pValues:%p)",
@@ -15851,7 +11236,6 @@
*countPtr += ((size)) * sizeof(uint8_t);
}
uint32_t packetSize_vkCmdPushConstants = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdPushConstants);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdPushConstants -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdPushConstants);
uint8_t* packetBeginPtr = streamPtr;
@@ -15879,12 +11263,6 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (void*)local_pValues, ((size)) * sizeof(uint8_t));
*streamPtrPtr += ((size)) * sizeof(uint8_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdPushConstants), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -15896,33 +11274,6 @@
void VkEncoder::vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
VkSubpassContents contents, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdBeginRenderPass in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdBeginRenderPass(commandBuffer:%p, pRenderPassBegin:%p)", commandBuffer,
pRenderPassBegin);
(void)doLock;
@@ -15957,7 +11308,6 @@
*countPtr += sizeof(VkSubpassContents);
}
uint32_t packetSize_vkCmdBeginRenderPass = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBeginRenderPass);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginRenderPass -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBeginRenderPass);
uint8_t* packetBeginPtr = streamPtr;
@@ -15978,12 +11328,6 @@
streamPtrPtr);
memcpy(*streamPtrPtr, (VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
*streamPtrPtr += sizeof(VkSubpassContents);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdBeginRenderPass), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -15994,33 +11338,6 @@
void VkEncoder::vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdNextSubpass in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdNextSubpass(commandBuffer:%p)", commandBuffer);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -16040,7 +11357,6 @@
*countPtr += sizeof(VkSubpassContents);
}
uint32_t packetSize_vkCmdNextSubpass = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdNextSubpass);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdNextSubpass -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdNextSubpass);
uint8_t* packetBeginPtr = streamPtr;
@@ -16058,12 +11374,6 @@
}
memcpy(*streamPtrPtr, (VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
*streamPtrPtr += sizeof(VkSubpassContents);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdNextSubpass), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -16073,33 +11383,6 @@
}
void VkEncoder::vkCmdEndRenderPass(VkCommandBuffer commandBuffer, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdEndRenderPass in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdEndRenderPass(commandBuffer:%p)", commandBuffer);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -16116,7 +11399,6 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkCmdEndRenderPass = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdEndRenderPass);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEndRenderPass -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdEndRenderPass);
uint8_t* packetBeginPtr = streamPtr;
@@ -16132,12 +11414,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdEndRenderPass), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -16148,33 +11424,6 @@
void VkEncoder::vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
const VkCommandBuffer* pCommandBuffers, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdExecuteCommands in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdExecuteCommands(commandBuffer:%p, commandBufferCount:%d, pCommandBuffers:%p)",
commandBuffer, commandBufferCount, pCommandBuffers);
@@ -16202,7 +11451,6 @@
}
}
uint32_t packetSize_vkCmdExecuteCommands = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdExecuteCommands);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdExecuteCommands -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdExecuteCommands);
uint8_t* packetBeginPtr = streamPtr;
@@ -16228,12 +11476,6 @@
}
*streamPtrPtr += 8 * ((commandBufferCount));
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdExecuteCommands), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -16245,33 +11487,6 @@
#endif
#ifdef VK_VERSION_1_1
VkResult VkEncoder::vkEnumerateInstanceVersion(uint32_t* pApiVersion, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkEnumerateInstanceVersion in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkEnumerateInstanceVersion(pApiVersion:%p)", pApiVersion);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -16284,14 +11499,12 @@
{ *countPtr += sizeof(uint32_t); }
uint32_t packetSize_vkEnumerateInstanceVersion =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkEnumerateInstanceVersion);
uint8_t* streamPtr = stream->reserve(packetSize_vkEnumerateInstanceVersion);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkEnumerateInstanceVersion = OP_vkEnumerateInstanceVersion;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkEnumerateInstanceVersion, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkEnumerateInstanceVersion, sizeof(uint32_t));
@@ -16302,12 +11515,6 @@
}
memcpy(*streamPtrPtr, (uint32_t*)pApiVersion, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkEnumerateInstanceVersion), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->read((uint32_t*)pApiVersion, sizeof(uint32_t));
VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
stream->read(&vkEnumerateInstanceVersion_VkResult_return, sizeof(VkResult));
@@ -16322,33 +11529,6 @@
VkResult VkEncoder::vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
const VkBindBufferMemoryInfo* pBindInfos, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkBindBufferMemory2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkBindBufferMemory2(device:%p, bindInfoCount:%d, pBindInfos:%p)", device,
bindInfoCount, pBindInfos);
(void)doLock;
@@ -16390,14 +11570,12 @@
}
uint32_t packetSize_vkBindBufferMemory2 =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkBindBufferMemory2);
uint8_t* streamPtr = stream->reserve(packetSize_vkBindBufferMemory2);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkBindBufferMemory2 = OP_vkBindBufferMemory2;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkBindBufferMemory2, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkBindBufferMemory2, sizeof(uint32_t));
@@ -16417,12 +11595,6 @@
(VkBindBufferMemoryInfo*)(local_pBindInfos + i),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkBindBufferMemory2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
stream->read(&vkBindBufferMemory2_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -16436,33 +11608,6 @@
VkResult VkEncoder::vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
const VkBindImageMemoryInfo* pBindInfos, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkBindImageMemory2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
(void)doLock;
bool queueSubmitWithCommandsEnabled =
sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
@@ -16504,14 +11649,12 @@
}
uint32_t packetSize_vkBindImageMemory2 =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkBindImageMemory2);
uint8_t* streamPtr = stream->reserve(packetSize_vkBindImageMemory2);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkBindImageMemory2 = OP_vkBindImageMemory2;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkBindImageMemory2, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkBindImageMemory2, sizeof(uint32_t));
@@ -16531,12 +11674,6 @@
(VkBindImageMemoryInfo*)(local_pBindInfos + i),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkBindImageMemory2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
stream->read(&vkBindImageMemory2_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -16553,33 +11690,6 @@
uint32_t remoteDeviceIndex,
VkPeerMemoryFeatureFlags* pPeerMemoryFeatures,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetDeviceGroupPeerMemoryFeatures in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetDeviceGroupPeerMemoryFeatures(device:%p, heapIndex:%d, localDeviceIndex:%d, "
"remoteDeviceIndex:%d, pPeerMemoryFeatures:%p)",
@@ -16610,15 +11720,12 @@
}
uint32_t packetSize_vkGetDeviceGroupPeerMemoryFeatures =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetDeviceGroupPeerMemoryFeatures);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceGroupPeerMemoryFeatures);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDeviceGroupPeerMemoryFeatures = OP_vkGetDeviceGroupPeerMemoryFeatures;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetDeviceGroupPeerMemoryFeatures, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetDeviceGroupPeerMemoryFeatures, sizeof(uint32_t));
@@ -16640,12 +11747,6 @@
memcpy(*streamPtrPtr, (VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures,
sizeof(VkPeerMemoryFeatureFlags));
*streamPtrPtr += sizeof(VkPeerMemoryFeatureFlags);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetDeviceGroupPeerMemoryFeatures), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->read((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -16657,33 +11758,6 @@
void VkEncoder::vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetDeviceMask in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetDeviceMask(commandBuffer:%p, deviceMask:%d)", commandBuffer,
deviceMask);
(void)doLock;
@@ -16704,7 +11778,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdSetDeviceMask = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetDeviceMask);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDeviceMask -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDeviceMask);
uint8_t* packetBeginPtr = streamPtr;
@@ -16722,12 +11795,6 @@
}
memcpy(*streamPtrPtr, (uint32_t*)&local_deviceMask, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetDeviceMask), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -16739,33 +11806,6 @@
void VkEncoder::vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX,
uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX,
uint32_t groupCountY, uint32_t groupCountZ, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdDispatchBase in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdDispatchBase(commandBuffer:%p, baseGroupX:%d, baseGroupY:%d, baseGroupZ:%d, "
"groupCountX:%d, groupCountY:%d, groupCountZ:%d)",
@@ -16803,7 +11843,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDispatchBase = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDispatchBase);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDispatchBase -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDispatchBase);
uint8_t* packetBeginPtr = streamPtr;
@@ -16831,12 +11870,6 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_groupCountZ, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdDispatchBase), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -16848,33 +11881,6 @@
VkResult VkEncoder::vkEnumeratePhysicalDeviceGroups(
VkInstance instance, uint32_t* pPhysicalDeviceGroupCount,
VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkEnumeratePhysicalDeviceGroups in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkEnumeratePhysicalDeviceGroups(instance:%p, pPhysicalDeviceGroupCount:%p, "
"pPhysicalDeviceGroupProperties:%p)",
@@ -16912,15 +11918,12 @@
}
uint32_t packetSize_vkEnumeratePhysicalDeviceGroups =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkEnumeratePhysicalDeviceGroups);
uint8_t* streamPtr = stream->reserve(packetSize_vkEnumeratePhysicalDeviceGroups);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkEnumeratePhysicalDeviceGroups = OP_vkEnumeratePhysicalDeviceGroups;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkEnumeratePhysicalDeviceGroups, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkEnumeratePhysicalDeviceGroups, sizeof(uint32_t));
@@ -16955,12 +11958,6 @@
streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkEnumeratePhysicalDeviceGroups), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pPhysicalDeviceGroupCount;
check_pPhysicalDeviceGroupCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -17012,33 +12009,6 @@
const VkImageMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetImageMemoryRequirements2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetImageMemoryRequirements2(device:%p, pInfo:%p, pMemoryRequirements:%p)",
device, pInfo, pMemoryRequirements);
(void)doLock;
@@ -17074,15 +12044,12 @@
}
uint32_t packetSize_vkGetImageMemoryRequirements2 =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetImageMemoryRequirements2);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageMemoryRequirements2);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetImageMemoryRequirements2 = OP_vkGetImageMemoryRequirements2;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetImageMemoryRequirements2, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetImageMemoryRequirements2, sizeof(uint32_t));
@@ -17101,12 +12068,6 @@
reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements2*)(pMemoryRequirements),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetImageMemoryRequirements2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements2*)(pMemoryRequirements));
if (pMemoryRequirements) {
@@ -17125,33 +12086,6 @@
const VkBufferMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetBufferMemoryRequirements2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetBufferMemoryRequirements2(device:%p, pInfo:%p, pMemoryRequirements:%p)",
device, pInfo, pMemoryRequirements);
(void)doLock;
@@ -17187,15 +12121,12 @@
}
uint32_t packetSize_vkGetBufferMemoryRequirements2 =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetBufferMemoryRequirements2);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferMemoryRequirements2);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetBufferMemoryRequirements2 = OP_vkGetBufferMemoryRequirements2;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetBufferMemoryRequirements2, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetBufferMemoryRequirements2, sizeof(uint32_t));
@@ -17214,12 +12145,6 @@
reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements2*)(pMemoryRequirements),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetBufferMemoryRequirements2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements2*)(pMemoryRequirements));
if (pMemoryRequirements) {
@@ -17238,33 +12163,6 @@
VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetImageSparseMemoryRequirements2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetImageSparseMemoryRequirements2(device:%p, pInfo:%p, "
"pSparseMemoryRequirementCount:%p, pSparseMemoryRequirements:%p)",
@@ -17318,15 +12216,12 @@
}
uint32_t packetSize_vkGetImageSparseMemoryRequirements2 =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetImageSparseMemoryRequirements2);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageSparseMemoryRequirements2);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetImageSparseMemoryRequirements2 = OP_vkGetImageSparseMemoryRequirements2;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetImageSparseMemoryRequirements2, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetImageSparseMemoryRequirements2, sizeof(uint32_t));
@@ -17363,13 +12258,6 @@
(VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetImageSparseMemoryRequirements2),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pSparseMemoryRequirementCount;
check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -17417,33 +12305,6 @@
void VkEncoder::vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures2* pFeatures,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPhysicalDeviceFeatures2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetPhysicalDeviceFeatures2(physicalDevice:%p, pFeatures:%p)",
physicalDevice, pFeatures);
(void)doLock;
@@ -17464,15 +12325,12 @@
}
uint32_t packetSize_vkGetPhysicalDeviceFeatures2 =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceFeatures2);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceFeatures2);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceFeatures2 = OP_vkGetPhysicalDeviceFeatures2;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceFeatures2, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceFeatures2, sizeof(uint32_t));
@@ -17487,12 +12345,6 @@
*streamPtrPtr += 1 * 8;
reservedmarshal_VkPhysicalDeviceFeatures2(
stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFeatures2*)(pFeatures), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceFeatures2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkPhysicalDeviceFeatures2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkPhysicalDeviceFeatures2*)(pFeatures));
if (pFeatures) {
@@ -17511,33 +12363,6 @@
void VkEncoder::vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties2* pProperties,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPhysicalDeviceProperties2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetPhysicalDeviceProperties2(physicalDevice:%p, pProperties:%p)",
physicalDevice, pProperties);
(void)doLock;
@@ -17558,15 +12383,12 @@
}
uint32_t packetSize_vkGetPhysicalDeviceProperties2 =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceProperties2);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceProperties2);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceProperties2 = OP_vkGetPhysicalDeviceProperties2;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceProperties2, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceProperties2, sizeof(uint32_t));
@@ -17582,12 +12404,6 @@
reservedmarshal_VkPhysicalDeviceProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkPhysicalDeviceProperties2*)(pProperties),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceProperties2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkPhysicalDeviceProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkPhysicalDeviceProperties2*)(pProperties));
if (pProperties) {
@@ -17607,33 +12423,6 @@
VkFormat format,
VkFormatProperties2* pFormatProperties,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPhysicalDeviceFormatProperties2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceFormatProperties2(physicalDevice:%p, format:%d, pFormatProperties:%p)",
physicalDevice, format, pFormatProperties);
@@ -17658,15 +12447,12 @@
}
uint32_t packetSize_vkGetPhysicalDeviceFormatProperties2 =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceFormatProperties2);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceFormatProperties2);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceFormatProperties2 = OP_vkGetPhysicalDeviceFormatProperties2;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceFormatProperties2, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceFormatProperties2, sizeof(uint32_t));
@@ -17683,13 +12469,6 @@
*streamPtrPtr += sizeof(VkFormat);
reservedmarshal_VkFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkFormatProperties2*)(pFormatProperties), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetPhysicalDeviceFormatProperties2),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkFormatProperties2*)(pFormatProperties));
if (pFormatProperties) {
@@ -17707,33 +12486,6 @@
VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties2(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
VkImageFormatProperties2* pImageFormatProperties, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPhysicalDeviceImageFormatProperties2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceImageFormatProperties2(physicalDevice:%p, pImageFormatInfo:%p, "
"pImageFormatProperties:%p)",
@@ -17773,8 +12525,6 @@
}
uint32_t packetSize_vkGetPhysicalDeviceImageFormatProperties2 =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceImageFormatProperties2);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceImageFormatProperties2);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -17782,7 +12532,6 @@
OP_vkGetPhysicalDeviceImageFormatProperties2;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceImageFormatProperties2, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceImageFormatProperties2, sizeof(uint32_t));
@@ -17801,13 +12550,6 @@
reservedmarshal_VkImageFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkImageFormatProperties2*)(pImageFormatProperties),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceImageFormatProperties2),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkImageFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkImageFormatProperties2*)(pImageFormatProperties));
if (pImageFormatProperties) {
@@ -17828,33 +12570,6 @@
void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2(
VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties2* pQueueFamilyProperties, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPhysicalDeviceQueueFamilyProperties2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice:%p, "
"pQueueFamilyPropertyCount:%p, pQueueFamilyProperties:%p)",
@@ -17891,8 +12606,6 @@
}
uint32_t packetSize_vkGetPhysicalDeviceQueueFamilyProperties2 =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceQueueFamilyProperties2);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceQueueFamilyProperties2);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -17900,7 +12613,6 @@
OP_vkGetPhysicalDeviceQueueFamilyProperties2;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceQueueFamilyProperties2, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceQueueFamilyProperties2, sizeof(uint32_t));
@@ -17934,13 +12646,6 @@
(VkQueueFamilyProperties2*)(pQueueFamilyProperties + i), streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceQueueFamilyProperties2),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pQueueFamilyPropertyCount;
check_pQueueFamilyPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -17985,33 +12690,6 @@
void VkEncoder::vkGetPhysicalDeviceMemoryProperties2(
VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPhysicalDeviceMemoryProperties2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceMemoryProperties2(physicalDevice:%p, pMemoryProperties:%p)",
physicalDevice, pMemoryProperties);
@@ -18034,15 +12712,12 @@
}
uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties2 =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceMemoryProperties2);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceMemoryProperties2);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceMemoryProperties2 = OP_vkGetPhysicalDeviceMemoryProperties2;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceMemoryProperties2, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceMemoryProperties2, sizeof(uint32_t));
@@ -18058,13 +12733,6 @@
reservedmarshal_VkPhysicalDeviceMemoryProperties2(
stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetPhysicalDeviceMemoryProperties2),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkPhysicalDeviceMemoryProperties2(
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
@@ -18083,34 +12751,6 @@
void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor,
- "vkGetPhysicalDeviceSparseImageFormatProperties2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice:%p, pFormatInfo:%p, "
"pPropertyCount:%p, pProperties:%p)",
@@ -18163,8 +12803,6 @@
}
uint32_t packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2 =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2);
uint8_t* streamPtr =
stream->reserve(packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2);
uint8_t* packetBeginPtr = streamPtr;
@@ -18173,7 +12811,6 @@
OP_vkGetPhysicalDeviceSparseImageFormatProperties2;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSparseImageFormatProperties2, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2,
@@ -18211,13 +12848,6 @@
(VkSparseImageFormatProperties2*)(pProperties + i), streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -18260,33 +12890,6 @@
void VkEncoder::vkTrimCommandPool(VkDevice device, VkCommandPool commandPool,
VkCommandPoolTrimFlags flags, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkTrimCommandPool in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkTrimCommandPool(device:%p, commandPool:%p, flags:%d)", device, commandPool,
flags);
(void)doLock;
@@ -18312,14 +12915,12 @@
}
uint32_t packetSize_vkTrimCommandPool =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkTrimCommandPool);
uint8_t* streamPtr = stream->reserve(packetSize_vkTrimCommandPool);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkTrimCommandPool = OP_vkTrimCommandPool;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkTrimCommandPool, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkTrimCommandPool, sizeof(uint32_t));
@@ -18338,12 +12939,6 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
*streamPtrPtr += sizeof(VkCommandPoolTrimFlags);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkTrimCommandPool), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->flush();
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -18355,33 +12950,6 @@
void VkEncoder::vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo,
VkQueue* pQueue, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetDeviceQueue2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetDeviceQueue2(device:%p, pQueueInfo:%p, pQueue:%p)", device, pQueueInfo,
pQueue);
(void)doLock;
@@ -18415,14 +12983,12 @@
}
uint32_t packetSize_vkGetDeviceQueue2 =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetDeviceQueue2);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceQueue2);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDeviceQueue2 = OP_vkGetDeviceQueue2;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetDeviceQueue2, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetDeviceQueue2, sizeof(uint32_t));
@@ -18443,12 +13009,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetDeviceQueue2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_2;
stream->read((uint64_t*)&cgen_var_2, 8);
@@ -18467,33 +13027,6 @@
VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateSamplerYcbcrConversion in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCreateSamplerYcbcrConversion(device:%p, pCreateInfo:%p, pAllocator:%p, "
"pYcbcrConversion:%p)",
@@ -18550,15 +13083,12 @@
}
uint32_t packetSize_vkCreateSamplerYcbcrConversion =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCreateSamplerYcbcrConversion);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateSamplerYcbcrConversion);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateSamplerYcbcrConversion = OP_vkCreateSamplerYcbcrConversion;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateSamplerYcbcrConversion, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateSamplerYcbcrConversion, sizeof(uint32_t));
@@ -18590,12 +13120,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCreateSamplerYcbcrConversion), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -18617,33 +13141,6 @@
VkSamplerYcbcrConversion ycbcrConversion,
const VkAllocationCallbacks* pAllocator,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroySamplerYcbcrConversion in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkDestroySamplerYcbcrConversion(device:%p, ycbcrConversion:%p, pAllocator:%p)", device,
ycbcrConversion, pAllocator);
@@ -18685,15 +13182,12 @@
}
uint32_t packetSize_vkDestroySamplerYcbcrConversion =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkDestroySamplerYcbcrConversion);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroySamplerYcbcrConversion);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroySamplerYcbcrConversion = OP_vkDestroySamplerYcbcrConversion;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroySamplerYcbcrConversion, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroySamplerYcbcrConversion, sizeof(uint32_t));
@@ -18720,12 +13214,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkDestroySamplerYcbcrConversion), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkSamplerYcbcrConversion(
(VkSamplerYcbcrConversion*)&ycbcrConversion);
stream->flush();
@@ -18741,33 +13229,6 @@
VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateDescriptorUpdateTemplate in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCreateDescriptorUpdateTemplate(device:%p, pCreateInfo:%p, pAllocator:%p, "
"pDescriptorUpdateTemplate:%p)",
@@ -18824,15 +13285,12 @@
}
uint32_t packetSize_vkCreateDescriptorUpdateTemplate =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCreateDescriptorUpdateTemplate);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateDescriptorUpdateTemplate);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateDescriptorUpdateTemplate = OP_vkCreateDescriptorUpdateTemplate;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateDescriptorUpdateTemplate, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateDescriptorUpdateTemplate, sizeof(uint32_t));
@@ -18864,12 +13322,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCreateDescriptorUpdateTemplate), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -18893,33 +13345,6 @@
void VkEncoder::vkDestroyDescriptorUpdateTemplate(
VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyDescriptorUpdateTemplate in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkDestroyDescriptorUpdateTemplate(device:%p, descriptorUpdateTemplate:%p, pAllocator:%p)",
device, descriptorUpdateTemplate, pAllocator);
@@ -18961,15 +13386,12 @@
}
uint32_t packetSize_vkDestroyDescriptorUpdateTemplate =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkDestroyDescriptorUpdateTemplate);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyDescriptorUpdateTemplate);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyDescriptorUpdateTemplate = OP_vkDestroyDescriptorUpdateTemplate;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyDescriptorUpdateTemplate, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyDescriptorUpdateTemplate, sizeof(uint32_t));
@@ -18996,12 +13418,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkDestroyDescriptorUpdateTemplate), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkDescriptorUpdateTemplate(
(VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate);
stream->flush();
@@ -19016,33 +13432,6 @@
void VkEncoder::vkUpdateDescriptorSetWithTemplate(
VkDevice device, VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkUpdateDescriptorSetWithTemplate in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkUpdateDescriptorSetWithTemplate(device:%p, descriptorSet:%p, "
"descriptorUpdateTemplate:%p, pData:%p)",
@@ -19079,15 +13468,12 @@
}
uint32_t packetSize_vkUpdateDescriptorSetWithTemplate =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkUpdateDescriptorSetWithTemplate);
uint8_t* streamPtr = stream->reserve(packetSize_vkUpdateDescriptorSetWithTemplate);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkUpdateDescriptorSetWithTemplate = OP_vkUpdateDescriptorSetWithTemplate;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkUpdateDescriptorSetWithTemplate, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkUpdateDescriptorSetWithTemplate, sizeof(uint32_t));
@@ -19117,12 +13503,6 @@
memcpy(*streamPtrPtr, (void*)local_pData, sizeof(uint8_t));
*streamPtrPtr += sizeof(uint8_t);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkUpdateDescriptorSetWithTemplate), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->flush();
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -19135,33 +13515,6 @@
void VkEncoder::vkGetPhysicalDeviceExternalBufferProperties(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
VkExternalBufferProperties* pExternalBufferProperties, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPhysicalDeviceExternalBufferProperties in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceExternalBufferProperties(physicalDevice:%p, pExternalBufferInfo:%p, "
"pExternalBufferProperties:%p)",
@@ -19203,8 +13556,6 @@
}
uint32_t packetSize_vkGetPhysicalDeviceExternalBufferProperties =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceExternalBufferProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceExternalBufferProperties);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -19212,7 +13563,6 @@
OP_vkGetPhysicalDeviceExternalBufferProperties;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceExternalBufferProperties, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceExternalBufferProperties, sizeof(uint32_t));
@@ -19231,13 +13581,6 @@
reservedmarshal_VkExternalBufferProperties(
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkExternalBufferProperties*)(pExternalBufferProperties), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceExternalBufferProperties),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkExternalBufferProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkExternalBufferProperties*)(pExternalBufferProperties));
if (pExternalBufferProperties) {
@@ -19257,33 +13600,6 @@
void VkEncoder::vkGetPhysicalDeviceExternalFenceProperties(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
VkExternalFenceProperties* pExternalFenceProperties, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPhysicalDeviceExternalFenceProperties in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceExternalFenceProperties(physicalDevice:%p, pExternalFenceInfo:%p, "
"pExternalFenceProperties:%p)",
@@ -19323,8 +13639,6 @@
}
uint32_t packetSize_vkGetPhysicalDeviceExternalFenceProperties =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceExternalFenceProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceExternalFenceProperties);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -19332,7 +13646,6 @@
OP_vkGetPhysicalDeviceExternalFenceProperties;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceExternalFenceProperties, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceExternalFenceProperties, sizeof(uint32_t));
@@ -19351,13 +13664,6 @@
reservedmarshal_VkExternalFenceProperties(
stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalFenceProperties*)(pExternalFenceProperties),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceExternalFenceProperties),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkExternalFenceProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkExternalFenceProperties*)(pExternalFenceProperties));
if (pExternalFenceProperties) {
@@ -19376,34 +13682,6 @@
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
VkExternalSemaphoreProperties* pExternalSemaphoreProperties, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor,
- "vkGetPhysicalDeviceExternalSemaphoreProperties in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice:%p, "
"pExternalSemaphoreInfo:%p, pExternalSemaphoreProperties:%p)",
@@ -19444,8 +13722,6 @@
}
uint32_t packetSize_vkGetPhysicalDeviceExternalSemaphoreProperties =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceExternalSemaphoreProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceExternalSemaphoreProperties);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -19453,7 +13729,6 @@
OP_vkGetPhysicalDeviceExternalSemaphoreProperties;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceExternalSemaphoreProperties, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceExternalSemaphoreProperties, sizeof(uint32_t));
@@ -19472,13 +13747,6 @@
reservedmarshal_VkExternalSemaphoreProperties(
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceExternalSemaphoreProperties),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkExternalSemaphoreProperties(
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
@@ -19500,33 +13768,6 @@
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
VkDescriptorSetLayoutSupport* pSupport,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetDescriptorSetLayoutSupport in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetDescriptorSetLayoutSupport(device:%p, pCreateInfo:%p, pSupport:%p)",
device, pCreateInfo, pSupport);
(void)doLock;
@@ -19563,15 +13804,12 @@
}
uint32_t packetSize_vkGetDescriptorSetLayoutSupport =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetDescriptorSetLayoutSupport);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDescriptorSetLayoutSupport);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDescriptorSetLayoutSupport = OP_vkGetDescriptorSetLayoutSupport;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetDescriptorSetLayoutSupport, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetDescriptorSetLayoutSupport, sizeof(uint32_t));
@@ -19590,12 +13828,6 @@
reservedmarshal_VkDescriptorSetLayoutSupport(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkDescriptorSetLayoutSupport*)(pSupport),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetDescriptorSetLayoutSupport), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkDescriptorSetLayoutSupport(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkDescriptorSetLayoutSupport*)(pSupport));
if (pSupport) {
@@ -19616,33 +13848,6 @@
VkDeviceSize offset, VkBuffer countBuffer,
VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
uint32_t stride, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdDrawIndirectCount in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdDrawIndirectCount(commandBuffer:%p, buffer:%p, offset:%ld, countBuffer:%p, "
"countBufferOffset:%ld, maxDrawCount:%d, stride:%d)",
@@ -19682,7 +13887,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDrawIndirectCount = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDrawIndirectCount);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawIndirectCount -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawIndirectCount);
uint8_t* packetBeginPtr = streamPtr;
@@ -19714,12 +13918,6 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_stride, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdDrawIndirectCount), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -19732,33 +13930,6 @@
VkDeviceSize offset, VkBuffer countBuffer,
VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
uint32_t stride, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdDrawIndexedIndirectCount in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdDrawIndexedIndirectCount(commandBuffer:%p, buffer:%p, offset:%ld, countBuffer:%p, "
"countBufferOffset:%ld, maxDrawCount:%d, stride:%d)",
@@ -19798,8 +13969,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDrawIndexedIndirectCount = 4 + 4 + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCmdDrawIndexedIndirectCount);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawIndexedIndirectCount -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawIndexedIndirectCount);
uint8_t* packetBeginPtr = streamPtr;
@@ -19831,12 +14000,6 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_stride, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdDrawIndexedIndirectCount), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -19848,33 +14011,6 @@
VkResult VkEncoder::vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkRenderPass* pRenderPass, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateRenderPass2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCreateRenderPass2(device:%p, pCreateInfo:%p, pAllocator:%p, pRenderPass:%p)", device,
pCreateInfo, pAllocator, pRenderPass);
@@ -19928,14 +14064,12 @@
}
uint32_t packetSize_vkCreateRenderPass2 =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateRenderPass2);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateRenderPass2);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateRenderPass2 = OP_vkCreateRenderPass2;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateRenderPass2, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateRenderPass2, sizeof(uint32_t));
@@ -19967,12 +14101,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCreateRenderPass2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -19994,33 +14122,6 @@
const VkRenderPassBeginInfo* pRenderPassBegin,
const VkSubpassBeginInfo* pSubpassBeginInfo,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdBeginRenderPass2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdBeginRenderPass2(commandBuffer:%p, pRenderPassBegin:%p, pSubpassBeginInfo:%p)",
commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
@@ -20067,7 +14168,6 @@
(VkSubpassBeginInfo*)(local_pSubpassBeginInfo), countPtr);
}
uint32_t packetSize_vkCmdBeginRenderPass2 = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBeginRenderPass2);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginRenderPass2 -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBeginRenderPass2);
uint8_t* packetBeginPtr = streamPtr;
@@ -20089,12 +14189,6 @@
reservedmarshal_VkSubpassBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkSubpassBeginInfo*)(local_pSubpassBeginInfo),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdBeginRenderPass2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -20106,33 +14200,6 @@
void VkEncoder::vkCmdNextSubpass2(VkCommandBuffer commandBuffer,
const VkSubpassBeginInfo* pSubpassBeginInfo,
const VkSubpassEndInfo* pSubpassEndInfo, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdNextSubpass2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdNextSubpass2(commandBuffer:%p, pSubpassBeginInfo:%p, pSubpassEndInfo:%p)",
commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
@@ -20178,7 +14245,6 @@
(VkSubpassEndInfo*)(local_pSubpassEndInfo), countPtr);
}
uint32_t packetSize_vkCmdNextSubpass2 = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdNextSubpass2);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdNextSubpass2 -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdNextSubpass2);
uint8_t* packetBeginPtr = streamPtr;
@@ -20199,12 +14265,6 @@
streamPtrPtr);
reservedmarshal_VkSubpassEndInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkSubpassEndInfo*)(local_pSubpassEndInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdNextSubpass2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -20215,33 +14275,6 @@
void VkEncoder::vkCmdEndRenderPass2(VkCommandBuffer commandBuffer,
const VkSubpassEndInfo* pSubpassEndInfo, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdEndRenderPass2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdEndRenderPass2(commandBuffer:%p, pSubpassEndInfo:%p)", commandBuffer,
pSubpassEndInfo);
(void)doLock;
@@ -20272,7 +14305,6 @@
(VkSubpassEndInfo*)(local_pSubpassEndInfo), countPtr);
}
uint32_t packetSize_vkCmdEndRenderPass2 = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdEndRenderPass2);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEndRenderPass2 -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdEndRenderPass2);
uint8_t* packetBeginPtr = streamPtr;
@@ -20290,12 +14322,6 @@
}
reservedmarshal_VkSubpassEndInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkSubpassEndInfo*)(local_pSubpassEndInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdEndRenderPass2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -20306,33 +14332,6 @@
void VkEncoder::vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
uint32_t queryCount, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkResetQueryPool in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkResetQueryPool(device:%p, queryPool:%p, firstQuery:%d, queryCount:%d)",
device, queryPool, firstQuery, queryCount);
(void)doLock;
@@ -20360,14 +14359,12 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkResetQueryPool = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkResetQueryPool);
uint8_t* streamPtr = stream->reserve(packetSize_vkResetQueryPool);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkResetQueryPool = OP_vkResetQueryPool;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkResetQueryPool, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkResetQueryPool, sizeof(uint32_t));
@@ -20388,12 +14385,6 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_queryCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkResetQueryPool), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->flush();
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -20405,33 +14396,6 @@
VkResult VkEncoder::vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore,
uint64_t* pValue, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetSemaphoreCounterValue in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetSemaphoreCounterValue(device:%p, semaphore:%p, pValue:%p)", device,
semaphore, pValue);
(void)doLock;
@@ -20455,14 +14419,12 @@
}
uint32_t packetSize_vkGetSemaphoreCounterValue =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetSemaphoreCounterValue);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetSemaphoreCounterValue);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetSemaphoreCounterValue = OP_vkGetSemaphoreCounterValue;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetSemaphoreCounterValue, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetSemaphoreCounterValue, sizeof(uint32_t));
@@ -20481,12 +14443,6 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint64_t*)pValue, sizeof(uint64_t));
*streamPtrPtr += sizeof(uint64_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetSemaphoreCounterValue), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->read((uint64_t*)pValue, sizeof(uint64_t));
VkResult vkGetSemaphoreCounterValue_VkResult_return = (VkResult)0;
stream->read(&vkGetSemaphoreCounterValue_VkResult_return, sizeof(VkResult));
@@ -20501,33 +14457,6 @@
VkResult VkEncoder::vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo,
uint64_t timeout, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkWaitSemaphores in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkWaitSemaphores(device:%p, pWaitInfo:%p, timeout:%ld)", device, pWaitInfo,
timeout);
(void)doLock;
@@ -20561,14 +14490,12 @@
*countPtr += sizeof(uint64_t);
}
uint32_t packetSize_vkWaitSemaphores = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkWaitSemaphores);
uint8_t* streamPtr = stream->reserve(packetSize_vkWaitSemaphores);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkWaitSemaphores = OP_vkWaitSemaphores;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkWaitSemaphores, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkWaitSemaphores, sizeof(uint32_t));
@@ -20585,12 +14512,6 @@
(VkSemaphoreWaitInfo*)(local_pWaitInfo), streamPtrPtr);
memcpy(*streamPtrPtr, (uint64_t*)&local_timeout, sizeof(uint64_t));
*streamPtrPtr += sizeof(uint64_t);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkWaitSemaphores), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkWaitSemaphores_VkResult_return = (VkResult)0;
stream->read(&vkWaitSemaphores_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -20604,33 +14525,6 @@
VkResult VkEncoder::vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkSignalSemaphore in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkSignalSemaphore(device:%p, pSignalInfo:%p)", device, pSignalInfo);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -20662,14 +14556,12 @@
}
uint32_t packetSize_vkSignalSemaphore =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkSignalSemaphore);
uint8_t* streamPtr = stream->reserve(packetSize_vkSignalSemaphore);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkSignalSemaphore = OP_vkSignalSemaphore;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkSignalSemaphore, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkSignalSemaphore, sizeof(uint32_t));
@@ -20685,12 +14577,6 @@
reservedmarshal_VkSemaphoreSignalInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkSemaphoreSignalInfo*)(local_pSignalInfo),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkSignalSemaphore), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkSignalSemaphore_VkResult_return = (VkResult)0;
stream->read(&vkSignalSemaphore_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -20705,33 +14591,6 @@
VkDeviceAddress VkEncoder::vkGetBufferDeviceAddress(VkDevice device,
const VkBufferDeviceAddressInfo* pInfo,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetBufferDeviceAddress in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetBufferDeviceAddress(device:%p, pInfo:%p)", device, pInfo);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -20763,14 +14622,12 @@
}
uint32_t packetSize_vkGetBufferDeviceAddress =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetBufferDeviceAddress);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferDeviceAddress);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetBufferDeviceAddress = OP_vkGetBufferDeviceAddress;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetBufferDeviceAddress, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetBufferDeviceAddress, sizeof(uint32_t));
@@ -20786,12 +14643,6 @@
reservedmarshal_VkBufferDeviceAddressInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkBufferDeviceAddressInfo*)(local_pInfo),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetBufferDeviceAddress), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkDeviceAddress vkGetBufferDeviceAddress_VkDeviceAddress_return = (VkDeviceAddress)0;
stream->read(&vkGetBufferDeviceAddress_VkDeviceAddress_return, sizeof(VkDeviceAddress));
++encodeCount;
@@ -20806,33 +14657,6 @@
uint64_t VkEncoder::vkGetBufferOpaqueCaptureAddress(VkDevice device,
const VkBufferDeviceAddressInfo* pInfo,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetBufferOpaqueCaptureAddress in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetBufferOpaqueCaptureAddress(device:%p, pInfo:%p)", device, pInfo);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -20864,15 +14688,12 @@
}
uint32_t packetSize_vkGetBufferOpaqueCaptureAddress =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetBufferOpaqueCaptureAddress);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferOpaqueCaptureAddress);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetBufferOpaqueCaptureAddress = OP_vkGetBufferOpaqueCaptureAddress;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetBufferOpaqueCaptureAddress, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetBufferOpaqueCaptureAddress, sizeof(uint32_t));
@@ -20888,12 +14709,6 @@
reservedmarshal_VkBufferDeviceAddressInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkBufferDeviceAddressInfo*)(local_pInfo),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetBufferOpaqueCaptureAddress), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
uint64_t vkGetBufferOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
stream->read(&vkGetBufferOpaqueCaptureAddress_uint64_t_return, sizeof(uint64_t));
++encodeCount;
@@ -20907,33 +14722,6 @@
uint64_t VkEncoder::vkGetDeviceMemoryOpaqueCaptureAddress(
VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetDeviceMemoryOpaqueCaptureAddress in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetDeviceMemoryOpaqueCaptureAddress(device:%p, pInfo:%p)", device, pInfo);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -20967,8 +14755,6 @@
}
uint32_t packetSize_vkGetDeviceMemoryOpaqueCaptureAddress =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetDeviceMemoryOpaqueCaptureAddress);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceMemoryOpaqueCaptureAddress);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -20976,7 +14762,6 @@
OP_vkGetDeviceMemoryOpaqueCaptureAddress;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetDeviceMemoryOpaqueCaptureAddress, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetDeviceMemoryOpaqueCaptureAddress, sizeof(uint32_t));
@@ -20992,13 +14777,6 @@
reservedmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetDeviceMemoryOpaqueCaptureAddress),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
uint64_t vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
stream->read(&vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return, sizeof(uint64_t));
++encodeCount;
@@ -21015,33 +14793,6 @@
VkResult VkEncoder::vkGetPhysicalDeviceToolProperties(
VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
VkPhysicalDeviceToolProperties* pToolProperties, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPhysicalDeviceToolProperties in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceToolProperties(physicalDevice:%p, pToolCount:%p, pToolProperties:%p)",
physicalDevice, pToolCount, pToolProperties);
@@ -21077,15 +14828,12 @@
}
uint32_t packetSize_vkGetPhysicalDeviceToolProperties =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceToolProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceToolProperties);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceToolProperties = OP_vkGetPhysicalDeviceToolProperties;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceToolProperties, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceToolProperties, sizeof(uint32_t));
@@ -21119,12 +14867,6 @@
(VkPhysicalDeviceToolProperties*)(pToolProperties + i), streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceToolProperties), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pToolCount;
check_pToolCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -21172,33 +14914,6 @@
const VkPrivateDataSlotCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkPrivateDataSlot* pPrivateDataSlot, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreatePrivateDataSlot in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCreatePrivateDataSlot(device:%p, pCreateInfo:%p, pAllocator:%p, pPrivateDataSlot:%p)",
device, pCreateInfo, pAllocator, pPrivateDataSlot);
@@ -21252,14 +14967,12 @@
}
uint32_t packetSize_vkCreatePrivateDataSlot =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreatePrivateDataSlot);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreatePrivateDataSlot);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreatePrivateDataSlot = OP_vkCreatePrivateDataSlot;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreatePrivateDataSlot, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreatePrivateDataSlot, sizeof(uint32_t));
@@ -21289,12 +15002,6 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
gfxstream::guest::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCreatePrivateDataSlot), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
(*pPrivateDataSlot) = (VkPrivateDataSlot)stream->getBe64();
VkResult vkCreatePrivateDataSlot_VkResult_return = (VkResult)0;
stream->read(&vkCreatePrivateDataSlot_VkResult_return, sizeof(VkResult));
@@ -21309,33 +15016,6 @@
void VkEncoder::vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyPrivateDataSlot in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroyPrivateDataSlot(device:%p, pAllocator:%p)", device, pAllocator);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -21374,14 +15054,12 @@
}
uint32_t packetSize_vkDestroyPrivateDataSlot =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyPrivateDataSlot);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyPrivateDataSlot);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyPrivateDataSlot = OP_vkDestroyPrivateDataSlot;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyPrivateDataSlot, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyPrivateDataSlot, sizeof(uint32_t));
@@ -21408,12 +15086,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkDestroyPrivateDataSlot), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->flush();
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -21426,33 +15098,6 @@
VkResult VkEncoder::vkSetPrivateData(VkDevice device, VkObjectType objectType,
uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
uint64_t data, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkSetPrivateData in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkSetPrivateData(device:%p, objectHandle:%ld, data:%ld)", device,
objectHandle, data);
(void)doLock;
@@ -21482,14 +15127,12 @@
*countPtr += sizeof(uint64_t);
}
uint32_t packetSize_vkSetPrivateData = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkSetPrivateData);
uint8_t* streamPtr = stream->reserve(packetSize_vkSetPrivateData);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkSetPrivateData = OP_vkSetPrivateData;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkSetPrivateData, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkSetPrivateData, sizeof(uint32_t));
@@ -21512,12 +15155,6 @@
*streamPtrPtr += 8;
memcpy(*streamPtrPtr, (uint64_t*)&local_data, sizeof(uint64_t));
*streamPtrPtr += sizeof(uint64_t);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkSetPrivateData), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkSetPrivateData_VkResult_return = (VkResult)0;
stream->read(&vkSetPrivateData_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -21532,33 +15169,6 @@
void VkEncoder::vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
VkPrivateDataSlot privateDataSlot, uint64_t* pData,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPrivateData in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetPrivateData(device:%p, objectHandle:%ld, pData:%p)", device,
objectHandle, pData);
(void)doLock;
@@ -21586,14 +15196,12 @@
*countPtr += sizeof(uint64_t);
}
uint32_t packetSize_vkGetPrivateData = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetPrivateData);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPrivateData);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPrivateData = OP_vkGetPrivateData;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPrivateData, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPrivateData, sizeof(uint32_t));
@@ -21616,12 +15224,6 @@
*streamPtrPtr += 8;
memcpy(*streamPtrPtr, (uint64_t*)pData, sizeof(uint64_t));
*streamPtrPtr += sizeof(uint64_t);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetPrivateData), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->read((uint64_t*)pData, sizeof(uint64_t));
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -21633,33 +15235,6 @@
void VkEncoder::vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
const VkDependencyInfo* pDependencyInfo, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetEvent2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetEvent2(commandBuffer:%p, event:%p, pDependencyInfo:%p)",
commandBuffer, event, pDependencyInfo);
(void)doLock;
@@ -21694,7 +15269,6 @@
(VkDependencyInfo*)(local_pDependencyInfo), countPtr);
}
uint32_t packetSize_vkCmdSetEvent2 = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetEvent2);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetEvent2 -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetEvent2);
uint8_t* packetBeginPtr = streamPtr;
@@ -21716,12 +15290,6 @@
*streamPtrPtr += 1 * 8;
reservedmarshal_VkDependencyInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkDependencyInfo*)(local_pDependencyInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdSetEvent2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -21732,33 +15300,6 @@
void VkEncoder::vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
VkPipelineStageFlags2 stageMask, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdResetEvent2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdResetEvent2(commandBuffer:%p, event:%p)", commandBuffer, event);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -21782,7 +15323,6 @@
*countPtr += sizeof(VkPipelineStageFlags2);
}
uint32_t packetSize_vkCmdResetEvent2 = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdResetEvent2);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdResetEvent2 -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdResetEvent2);
uint8_t* packetBeginPtr = streamPtr;
@@ -21804,12 +15344,6 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkPipelineStageFlags2*)&local_stageMask, sizeof(VkPipelineStageFlags2));
*streamPtrPtr += sizeof(VkPipelineStageFlags2);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdResetEvent2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -21821,33 +15355,6 @@
void VkEncoder::vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount,
const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdWaitEvents2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdWaitEvents2(commandBuffer:%p, eventCount:%d, pEvents:%p, pDependencyInfos:%p)",
commandBuffer, eventCount, pEvents, pDependencyInfos);
@@ -21895,7 +15402,6 @@
}
}
uint32_t packetSize_vkCmdWaitEvents2 = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdWaitEvents2);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdWaitEvents2 -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdWaitEvents2);
uint8_t* packetBeginPtr = streamPtr;
@@ -21926,12 +15432,6 @@
(VkDependencyInfo*)(local_pDependencyInfos + i),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdWaitEvents2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -21942,33 +15442,6 @@
void VkEncoder::vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer,
const VkDependencyInfo* pDependencyInfo, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdPipelineBarrier2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdPipelineBarrier2(commandBuffer:%p, pDependencyInfo:%p)", commandBuffer,
pDependencyInfo);
(void)doLock;
@@ -21999,7 +15472,6 @@
(VkDependencyInfo*)(local_pDependencyInfo), countPtr);
}
uint32_t packetSize_vkCmdPipelineBarrier2 = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdPipelineBarrier2);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdPipelineBarrier2 -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdPipelineBarrier2);
uint8_t* packetBeginPtr = streamPtr;
@@ -22017,12 +15489,6 @@
}
reservedmarshal_VkDependencyInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkDependencyInfo*)(local_pDependencyInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdPipelineBarrier2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -22033,33 +15499,6 @@
void VkEncoder::vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
VkQueryPool queryPool, uint32_t query, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdWriteTimestamp2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdWriteTimestamp2(commandBuffer:%p, queryPool:%p, query:%d)",
commandBuffer, queryPool, query);
(void)doLock;
@@ -22087,7 +15526,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdWriteTimestamp2 = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdWriteTimestamp2);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdWriteTimestamp2 -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdWriteTimestamp2);
uint8_t* packetBeginPtr = streamPtr;
@@ -22111,12 +15549,6 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_query, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdWriteTimestamp2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -22127,33 +15559,6 @@
VkResult VkEncoder::vkQueueSubmit2(VkQueue queue, uint32_t submitCount,
const VkSubmitInfo2* pSubmits, VkFence fence, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkQueueSubmit2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkQueueSubmit2(queue:%p, submitCount:%d, pSubmits:%p, fence:%p)", queue,
submitCount, pSubmits, fence);
(void)doLock;
@@ -22196,14 +15601,12 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkQueueSubmit2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkQueueSubmit2);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueSubmit2);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueSubmit2 = OP_vkQueueSubmit2;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkQueueSubmit2, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkQueueSubmit2, sizeof(uint32_t));
@@ -22226,12 +15629,6 @@
*&cgen_var_1 = get_host_u64_VkFence((*&local_fence));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkQueueSubmit2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkQueueSubmit2_VkResult_return = (VkResult)0;
stream->read(&vkQueueSubmit2_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -22245,33 +15642,6 @@
void VkEncoder::vkCmdCopyBuffer2(VkCommandBuffer commandBuffer,
const VkCopyBufferInfo2* pCopyBufferInfo, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdCopyBuffer2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdCopyBuffer2(commandBuffer:%p, pCopyBufferInfo:%p)", commandBuffer,
pCopyBufferInfo);
(void)doLock;
@@ -22302,7 +15672,6 @@
(VkCopyBufferInfo2*)(local_pCopyBufferInfo), countPtr);
}
uint32_t packetSize_vkCmdCopyBuffer2 = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyBuffer2);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyBuffer2 -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyBuffer2);
uint8_t* packetBeginPtr = streamPtr;
@@ -22320,12 +15689,6 @@
}
reservedmarshal_VkCopyBufferInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkCopyBufferInfo2*)(local_pCopyBufferInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdCopyBuffer2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -22336,33 +15699,6 @@
void VkEncoder::vkCmdCopyImage2(VkCommandBuffer commandBuffer,
const VkCopyImageInfo2* pCopyImageInfo, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdCopyImage2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdCopyImage2(commandBuffer:%p, pCopyImageInfo:%p)", commandBuffer,
pCopyImageInfo);
(void)doLock;
@@ -22393,7 +15729,6 @@
(VkCopyImageInfo2*)(local_pCopyImageInfo), countPtr);
}
uint32_t packetSize_vkCmdCopyImage2 = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyImage2);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyImage2 -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyImage2);
uint8_t* packetBeginPtr = streamPtr;
@@ -22411,12 +15746,6 @@
}
reservedmarshal_VkCopyImageInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkCopyImageInfo2*)(local_pCopyImageInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdCopyImage2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -22428,33 +15757,6 @@
void VkEncoder::vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer,
const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdCopyBufferToImage2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdCopyBufferToImage2(commandBuffer:%p, pCopyBufferToImageInfo:%p)",
commandBuffer, pCopyBufferToImageInfo);
(void)doLock;
@@ -22488,7 +15790,6 @@
countPtr);
}
uint32_t packetSize_vkCmdCopyBufferToImage2 = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyBufferToImage2);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyBufferToImage2 -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyBufferToImage2);
uint8_t* packetBeginPtr = streamPtr;
@@ -22507,12 +15808,6 @@
reservedmarshal_VkCopyBufferToImageInfo2(
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkCopyBufferToImageInfo2*)(local_pCopyBufferToImageInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdCopyBufferToImage2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -22524,33 +15819,6 @@
void VkEncoder::vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer,
const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdCopyImageToBuffer2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdCopyImageToBuffer2(commandBuffer:%p, pCopyImageToBufferInfo:%p)",
commandBuffer, pCopyImageToBufferInfo);
(void)doLock;
@@ -22584,7 +15852,6 @@
countPtr);
}
uint32_t packetSize_vkCmdCopyImageToBuffer2 = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyImageToBuffer2);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyImageToBuffer2 -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyImageToBuffer2);
uint8_t* packetBeginPtr = streamPtr;
@@ -22603,12 +15870,6 @@
reservedmarshal_VkCopyImageToBufferInfo2(
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkCopyImageToBufferInfo2*)(local_pCopyImageToBufferInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdCopyImageToBuffer2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -22619,33 +15880,6 @@
void VkEncoder::vkCmdBlitImage2(VkCommandBuffer commandBuffer,
const VkBlitImageInfo2* pBlitImageInfo, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdBlitImage2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdBlitImage2(commandBuffer:%p, pBlitImageInfo:%p)", commandBuffer,
pBlitImageInfo);
(void)doLock;
@@ -22676,7 +15910,6 @@
(VkBlitImageInfo2*)(local_pBlitImageInfo), countPtr);
}
uint32_t packetSize_vkCmdBlitImage2 = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBlitImage2);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBlitImage2 -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBlitImage2);
uint8_t* packetBeginPtr = streamPtr;
@@ -22694,12 +15927,6 @@
}
reservedmarshal_VkBlitImageInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkBlitImageInfo2*)(local_pBlitImageInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdBlitImage2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -22710,33 +15937,6 @@
void VkEncoder::vkCmdResolveImage2(VkCommandBuffer commandBuffer,
const VkResolveImageInfo2* pResolveImageInfo, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdResolveImage2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdResolveImage2(commandBuffer:%p, pResolveImageInfo:%p)", commandBuffer,
pResolveImageInfo);
(void)doLock;
@@ -22768,7 +15968,6 @@
(VkResolveImageInfo2*)(local_pResolveImageInfo), countPtr);
}
uint32_t packetSize_vkCmdResolveImage2 = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdResolveImage2);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdResolveImage2 -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdResolveImage2);
uint8_t* packetBeginPtr = streamPtr;
@@ -22787,12 +15986,6 @@
reservedmarshal_VkResolveImageInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkResolveImageInfo2*)(local_pResolveImageInfo),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdResolveImage2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -22803,33 +15996,6 @@
void VkEncoder::vkCmdBeginRendering(VkCommandBuffer commandBuffer,
const VkRenderingInfo* pRenderingInfo, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdBeginRendering in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdBeginRendering(commandBuffer:%p, pRenderingInfo:%p)", commandBuffer,
pRenderingInfo);
(void)doLock;
@@ -22860,7 +16026,6 @@
(VkRenderingInfo*)(local_pRenderingInfo), countPtr);
}
uint32_t packetSize_vkCmdBeginRendering = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBeginRendering);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginRendering -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBeginRendering);
uint8_t* packetBeginPtr = streamPtr;
@@ -22878,12 +16043,6 @@
}
reservedmarshal_VkRenderingInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkRenderingInfo*)(local_pRenderingInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdBeginRendering), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -22893,33 +16052,6 @@
}
void VkEncoder::vkCmdEndRendering(VkCommandBuffer commandBuffer, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdEndRendering in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdEndRendering(commandBuffer:%p)", commandBuffer);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -22936,7 +16068,6 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkCmdEndRendering = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdEndRendering);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEndRendering -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdEndRendering);
uint8_t* packetBeginPtr = streamPtr;
@@ -22952,12 +16083,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdEndRendering), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -22968,33 +16093,6 @@
void VkEncoder::vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetCullMode in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetCullMode(commandBuffer:%p, cullMode:%d)", commandBuffer, cullMode);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -23014,7 +16112,6 @@
*countPtr += sizeof(VkCullModeFlags);
}
uint32_t packetSize_vkCmdSetCullMode = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetCullMode);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetCullMode -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetCullMode);
uint8_t* packetBeginPtr = streamPtr;
@@ -23032,12 +16129,6 @@
}
memcpy(*streamPtrPtr, (VkCullModeFlags*)&local_cullMode, sizeof(VkCullModeFlags));
*streamPtrPtr += sizeof(VkCullModeFlags);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdSetCullMode), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -23048,33 +16139,6 @@
void VkEncoder::vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetFrontFace in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetFrontFace(commandBuffer:%p)", commandBuffer);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -23094,7 +16158,6 @@
*countPtr += sizeof(VkFrontFace);
}
uint32_t packetSize_vkCmdSetFrontFace = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetFrontFace);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetFrontFace -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetFrontFace);
uint8_t* packetBeginPtr = streamPtr;
@@ -23112,12 +16175,6 @@
}
memcpy(*streamPtrPtr, (VkFrontFace*)&local_frontFace, sizeof(VkFrontFace));
*streamPtrPtr += sizeof(VkFrontFace);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdSetFrontFace), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -23128,33 +16185,6 @@
void VkEncoder::vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer,
VkPrimitiveTopology primitiveTopology, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetPrimitiveTopology in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetPrimitiveTopology(commandBuffer:%p)", commandBuffer);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -23174,7 +16204,6 @@
*countPtr += sizeof(VkPrimitiveTopology);
}
uint32_t packetSize_vkCmdSetPrimitiveTopology = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetPrimitiveTopology);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetPrimitiveTopology -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetPrimitiveTopology);
uint8_t* packetBeginPtr = streamPtr;
@@ -23193,12 +16222,6 @@
memcpy(*streamPtrPtr, (VkPrimitiveTopology*)&local_primitiveTopology,
sizeof(VkPrimitiveTopology));
*streamPtrPtr += sizeof(VkPrimitiveTopology);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetPrimitiveTopology), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -23209,33 +16232,6 @@
void VkEncoder::vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount,
const VkViewport* pViewports, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetViewportWithCount in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdSetViewportWithCount(commandBuffer:%p, viewportCount:%d, pViewports:%p)",
commandBuffer, viewportCount, pViewports);
@@ -23275,7 +16271,6 @@
}
}
uint32_t packetSize_vkCmdSetViewportWithCount = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetViewportWithCount);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetViewportWithCount -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetViewportWithCount);
uint8_t* packetBeginPtr = streamPtr;
@@ -23297,12 +16292,6 @@
reservedmarshal_VkViewport(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkViewport*)(local_pViewports + i), streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetViewportWithCount), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -23313,33 +16302,6 @@
void VkEncoder::vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount,
const VkRect2D* pScissors, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetScissorWithCount in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetScissorWithCount(commandBuffer:%p, scissorCount:%d, pScissors:%p)",
commandBuffer, scissorCount, pScissors);
(void)doLock;
@@ -23378,7 +16340,6 @@
}
}
uint32_t packetSize_vkCmdSetScissorWithCount = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetScissorWithCount);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetScissorWithCount -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetScissorWithCount);
uint8_t* packetBeginPtr = streamPtr;
@@ -23400,12 +16361,6 @@
reservedmarshal_VkRect2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkRect2D*)(local_pScissors + i), streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetScissorWithCount), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -23418,33 +16373,6 @@
uint32_t bindingCount, const VkBuffer* pBuffers,
const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
const VkDeviceSize* pStrides, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdBindVertexBuffers2 in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdBindVertexBuffers2(commandBuffer:%p, firstBinding:%d, bindingCount:%d, pBuffers:%p, "
"pOffsets:%p, pSizes:%p, pStrides:%p)",
@@ -23500,7 +16428,6 @@
}
}
uint32_t packetSize_vkCmdBindVertexBuffers2 = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBindVertexBuffers2);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBindVertexBuffers2 -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBindVertexBuffers2);
uint8_t* packetBeginPtr = streamPtr;
@@ -23556,12 +16483,6 @@
((bindingCount)) * sizeof(VkDeviceSize));
*streamPtrPtr += ((bindingCount)) * sizeof(VkDeviceSize);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdBindVertexBuffers2), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -23572,33 +16493,6 @@
void VkEncoder::vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetDepthTestEnable in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetDepthTestEnable(commandBuffer:%p, depthTestEnable:%d)",
commandBuffer, depthTestEnable);
(void)doLock;
@@ -23619,7 +16513,6 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetDepthTestEnable = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetDepthTestEnable);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDepthTestEnable -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDepthTestEnable);
uint8_t* packetBeginPtr = streamPtr;
@@ -23637,12 +16530,6 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_depthTestEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetDepthTestEnable), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -23653,33 +16540,6 @@
void VkEncoder::vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetDepthWriteEnable in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetDepthWriteEnable(commandBuffer:%p, depthWriteEnable:%d)",
commandBuffer, depthWriteEnable);
(void)doLock;
@@ -23700,7 +16560,6 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetDepthWriteEnable = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetDepthWriteEnable);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDepthWriteEnable -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDepthWriteEnable);
uint8_t* packetBeginPtr = streamPtr;
@@ -23718,12 +16577,6 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_depthWriteEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetDepthWriteEnable), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -23734,33 +16587,6 @@
void VkEncoder::vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetDepthCompareOp in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetDepthCompareOp(commandBuffer:%p)", commandBuffer);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -23780,7 +16606,6 @@
*countPtr += sizeof(VkCompareOp);
}
uint32_t packetSize_vkCmdSetDepthCompareOp = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetDepthCompareOp);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDepthCompareOp -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDepthCompareOp);
uint8_t* packetBeginPtr = streamPtr;
@@ -23798,12 +16623,6 @@
}
memcpy(*streamPtrPtr, (VkCompareOp*)&local_depthCompareOp, sizeof(VkCompareOp));
*streamPtrPtr += sizeof(VkCompareOp);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetDepthCompareOp), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -23814,33 +16633,6 @@
void VkEncoder::vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer,
VkBool32 depthBoundsTestEnable, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetDepthBoundsTestEnable in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetDepthBoundsTestEnable(commandBuffer:%p, depthBoundsTestEnable:%d)",
commandBuffer, depthBoundsTestEnable);
(void)doLock;
@@ -23861,8 +16653,6 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetDepthBoundsTestEnable = 4 + 4 + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCmdSetDepthBoundsTestEnable);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDepthBoundsTestEnable -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDepthBoundsTestEnable);
uint8_t* packetBeginPtr = streamPtr;
@@ -23880,12 +16670,6 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_depthBoundsTestEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetDepthBoundsTestEnable), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -23896,33 +16680,6 @@
void VkEncoder::vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetStencilTestEnable in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetStencilTestEnable(commandBuffer:%p, stencilTestEnable:%d)",
commandBuffer, stencilTestEnable);
(void)doLock;
@@ -23943,7 +16700,6 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetStencilTestEnable = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetStencilTestEnable);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetStencilTestEnable -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetStencilTestEnable);
uint8_t* packetBeginPtr = streamPtr;
@@ -23961,12 +16717,6 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_stencilTestEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetStencilTestEnable), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -23978,33 +16728,6 @@
void VkEncoder::vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp,
VkCompareOp compareOp, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetStencilOp in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetStencilOp(commandBuffer:%p, faceMask:%d)", commandBuffer, faceMask);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -24036,7 +16759,6 @@
*countPtr += sizeof(VkCompareOp);
}
uint32_t packetSize_vkCmdSetStencilOp = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetStencilOp);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetStencilOp -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetStencilOp);
uint8_t* packetBeginPtr = streamPtr;
@@ -24062,12 +16784,6 @@
*streamPtrPtr += sizeof(VkStencilOp);
memcpy(*streamPtrPtr, (VkCompareOp*)&local_compareOp, sizeof(VkCompareOp));
*streamPtrPtr += sizeof(VkCompareOp);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdSetStencilOp), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -24078,33 +16794,6 @@
void VkEncoder::vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer,
VkBool32 rasterizerDiscardEnable, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetRasterizerDiscardEnable in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdSetRasterizerDiscardEnable(commandBuffer:%p, rasterizerDiscardEnable:%d)",
commandBuffer, rasterizerDiscardEnable);
@@ -24126,8 +16815,6 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetRasterizerDiscardEnable = 4 + 4 + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCmdSetRasterizerDiscardEnable);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetRasterizerDiscardEnable -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetRasterizerDiscardEnable);
uint8_t* packetBeginPtr = streamPtr;
@@ -24145,12 +16832,6 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_rasterizerDiscardEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetRasterizerDiscardEnable), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -24161,33 +16842,6 @@
void VkEncoder::vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetDepthBiasEnable in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetDepthBiasEnable(commandBuffer:%p, depthBiasEnable:%d)",
commandBuffer, depthBiasEnable);
(void)doLock;
@@ -24208,7 +16862,6 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetDepthBiasEnable = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetDepthBiasEnable);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDepthBiasEnable -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDepthBiasEnable);
uint8_t* packetBeginPtr = streamPtr;
@@ -24226,12 +16879,6 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_depthBiasEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetDepthBiasEnable), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -24242,33 +16889,6 @@
void VkEncoder::vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer,
VkBool32 primitiveRestartEnable, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetPrimitiveRestartEnable in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetPrimitiveRestartEnable(commandBuffer:%p, primitiveRestartEnable:%d)",
commandBuffer, primitiveRestartEnable);
(void)doLock;
@@ -24289,8 +16909,6 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetPrimitiveRestartEnable = 4 + 4 + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCmdSetPrimitiveRestartEnable);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetPrimitiveRestartEnable -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetPrimitiveRestartEnable);
uint8_t* packetBeginPtr = streamPtr;
@@ -24308,12 +16926,6 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_primitiveRestartEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetPrimitiveRestartEnable), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -24326,33 +16938,6 @@
const VkDeviceBufferMemoryRequirements* pInfo,
VkMemoryRequirements2* pMemoryRequirements,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetDeviceBufferMemoryRequirements in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetDeviceBufferMemoryRequirements(device:%p, pInfo:%p, pMemoryRequirements:%p)", device,
pInfo, pMemoryRequirements);
@@ -24389,15 +16974,12 @@
}
uint32_t packetSize_vkGetDeviceBufferMemoryRequirements =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetDeviceBufferMemoryRequirements);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceBufferMemoryRequirements);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDeviceBufferMemoryRequirements = OP_vkGetDeviceBufferMemoryRequirements;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetDeviceBufferMemoryRequirements, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetDeviceBufferMemoryRequirements, sizeof(uint32_t));
@@ -24416,13 +16998,6 @@
reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements2*)(pMemoryRequirements),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetDeviceBufferMemoryRequirements),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements2*)(pMemoryRequirements));
if (pMemoryRequirements) {
@@ -24441,33 +17016,6 @@
const VkDeviceImageMemoryRequirements* pInfo,
VkMemoryRequirements2* pMemoryRequirements,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetDeviceImageMemoryRequirements in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetDeviceImageMemoryRequirements(device:%p, pInfo:%p, pMemoryRequirements:%p)", device,
pInfo, pMemoryRequirements);
@@ -24504,15 +17052,12 @@
}
uint32_t packetSize_vkGetDeviceImageMemoryRequirements =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetDeviceImageMemoryRequirements);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceImageMemoryRequirements);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDeviceImageMemoryRequirements = OP_vkGetDeviceImageMemoryRequirements;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetDeviceImageMemoryRequirements, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetDeviceImageMemoryRequirements, sizeof(uint32_t));
@@ -24531,12 +17076,6 @@
reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements2*)(pMemoryRequirements),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetDeviceImageMemoryRequirements), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements2*)(pMemoryRequirements));
if (pMemoryRequirements) {
@@ -24555,33 +17094,6 @@
VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetDeviceImageSparseMemoryRequirements in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetDeviceImageSparseMemoryRequirements(device:%p, pInfo:%p, "
"pSparseMemoryRequirementCount:%p, pSparseMemoryRequirements:%p)",
@@ -24634,8 +17146,6 @@
}
uint32_t packetSize_vkGetDeviceImageSparseMemoryRequirements =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetDeviceImageSparseMemoryRequirements);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceImageSparseMemoryRequirements);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -24643,7 +17153,6 @@
OP_vkGetDeviceImageSparseMemoryRequirements;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetDeviceImageSparseMemoryRequirements, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetDeviceImageSparseMemoryRequirements, sizeof(uint32_t));
@@ -24680,13 +17189,6 @@
(VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetDeviceImageSparseMemoryRequirements),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pSparseMemoryRequirementCount;
check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -24735,33 +17237,6 @@
#ifdef VK_KHR_dynamic_rendering
void VkEncoder::vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer,
const VkRenderingInfo* pRenderingInfo, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdBeginRenderingKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdBeginRenderingKHR(commandBuffer:%p, pRenderingInfo:%p)", commandBuffer,
pRenderingInfo);
(void)doLock;
@@ -24792,7 +17267,6 @@
(VkRenderingInfo*)(local_pRenderingInfo), countPtr);
}
uint32_t packetSize_vkCmdBeginRenderingKHR = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBeginRenderingKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginRenderingKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBeginRenderingKHR);
uint8_t* packetBeginPtr = streamPtr;
@@ -24810,12 +17284,6 @@
}
reservedmarshal_VkRenderingInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkRenderingInfo*)(local_pRenderingInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdBeginRenderingKHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -24825,33 +17293,6 @@
}
void VkEncoder::vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdEndRenderingKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdEndRenderingKHR(commandBuffer:%p)", commandBuffer);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -24868,7 +17309,6 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkCmdEndRenderingKHR = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdEndRenderingKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEndRenderingKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdEndRenderingKHR);
uint8_t* packetBeginPtr = streamPtr;
@@ -24884,12 +17324,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdEndRenderingKHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -24903,33 +17337,6 @@
void VkEncoder::vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures2* pFeatures,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPhysicalDeviceFeatures2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetPhysicalDeviceFeatures2KHR(physicalDevice:%p, pFeatures:%p)",
physicalDevice, pFeatures);
(void)doLock;
@@ -24950,15 +17357,12 @@
}
uint32_t packetSize_vkGetPhysicalDeviceFeatures2KHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceFeatures2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceFeatures2KHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceFeatures2KHR = OP_vkGetPhysicalDeviceFeatures2KHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceFeatures2KHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceFeatures2KHR, sizeof(uint32_t));
@@ -24973,12 +17377,6 @@
*streamPtrPtr += 1 * 8;
reservedmarshal_VkPhysicalDeviceFeatures2(
stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFeatures2*)(pFeatures), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceFeatures2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkPhysicalDeviceFeatures2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkPhysicalDeviceFeatures2*)(pFeatures));
if (pFeatures) {
@@ -24997,33 +17395,6 @@
void VkEncoder::vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties2* pProperties,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPhysicalDeviceProperties2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetPhysicalDeviceProperties2KHR(physicalDevice:%p, pProperties:%p)",
physicalDevice, pProperties);
(void)doLock;
@@ -25044,15 +17415,12 @@
}
uint32_t packetSize_vkGetPhysicalDeviceProperties2KHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceProperties2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceProperties2KHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceProperties2KHR = OP_vkGetPhysicalDeviceProperties2KHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceProperties2KHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceProperties2KHR, sizeof(uint32_t));
@@ -25068,12 +17436,6 @@
reservedmarshal_VkPhysicalDeviceProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkPhysicalDeviceProperties2*)(pProperties),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceProperties2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkPhysicalDeviceProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkPhysicalDeviceProperties2*)(pProperties));
if (pProperties) {
@@ -25093,33 +17455,6 @@
VkFormat format,
VkFormatProperties2* pFormatProperties,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPhysicalDeviceFormatProperties2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice:%p, format:%d, "
"pFormatProperties:%p)",
@@ -25145,8 +17480,6 @@
}
uint32_t packetSize_vkGetPhysicalDeviceFormatProperties2KHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceFormatProperties2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceFormatProperties2KHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -25154,7 +17487,6 @@
OP_vkGetPhysicalDeviceFormatProperties2KHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceFormatProperties2KHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceFormatProperties2KHR, sizeof(uint32_t));
@@ -25171,13 +17503,6 @@
*streamPtrPtr += sizeof(VkFormat);
reservedmarshal_VkFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkFormatProperties2*)(pFormatProperties), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceFormatProperties2KHR),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkFormatProperties2*)(pFormatProperties));
if (pFormatProperties) {
@@ -25195,34 +17520,6 @@
VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties2KHR(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
VkImageFormatProperties2* pImageFormatProperties, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor,
- "vkGetPhysicalDeviceImageFormatProperties2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice:%p, pImageFormatInfo:%p, "
"pImageFormatProperties:%p)",
@@ -25262,8 +17559,6 @@
}
uint32_t packetSize_vkGetPhysicalDeviceImageFormatProperties2KHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceImageFormatProperties2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceImageFormatProperties2KHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -25271,7 +17566,6 @@
OP_vkGetPhysicalDeviceImageFormatProperties2KHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceImageFormatProperties2KHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceImageFormatProperties2KHR, sizeof(uint32_t));
@@ -25290,13 +17584,6 @@
reservedmarshal_VkImageFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkImageFormatProperties2*)(pImageFormatProperties),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceImageFormatProperties2KHR),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkImageFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkImageFormatProperties2*)(pImageFormatProperties));
if (pImageFormatProperties) {
@@ -25317,34 +17604,6 @@
void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2KHR(
VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties2* pQueueFamilyProperties, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor,
- "vkGetPhysicalDeviceQueueFamilyProperties2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice:%p, "
"pQueueFamilyPropertyCount:%p, pQueueFamilyProperties:%p)",
@@ -25381,8 +17640,6 @@
}
uint32_t packetSize_vkGetPhysicalDeviceQueueFamilyProperties2KHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceQueueFamilyProperties2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceQueueFamilyProperties2KHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -25390,7 +17647,6 @@
OP_vkGetPhysicalDeviceQueueFamilyProperties2KHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceQueueFamilyProperties2KHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceQueueFamilyProperties2KHR, sizeof(uint32_t));
@@ -25424,13 +17680,6 @@
(VkQueueFamilyProperties2*)(pQueueFamilyProperties + i), streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceQueueFamilyProperties2KHR),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pQueueFamilyPropertyCount;
check_pQueueFamilyPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -25475,33 +17724,6 @@
void VkEncoder::vkGetPhysicalDeviceMemoryProperties2KHR(
VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPhysicalDeviceMemoryProperties2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice:%p, pMemoryProperties:%p)",
physicalDevice, pMemoryProperties);
@@ -25524,8 +17746,6 @@
}
uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties2KHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceMemoryProperties2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceMemoryProperties2KHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -25533,7 +17753,6 @@
OP_vkGetPhysicalDeviceMemoryProperties2KHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceMemoryProperties2KHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceMemoryProperties2KHR, sizeof(uint32_t));
@@ -25549,13 +17768,6 @@
reservedmarshal_VkPhysicalDeviceMemoryProperties2(
stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceMemoryProperties2KHR),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkPhysicalDeviceMemoryProperties2(
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
@@ -25574,34 +17786,6 @@
void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor,
- "vkGetPhysicalDeviceSparseImageFormatProperties2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice:%p, pFormatInfo:%p, "
"pPropertyCount:%p, pProperties:%p)",
@@ -25654,8 +17838,6 @@
}
uint32_t packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2KHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2KHR);
uint8_t* streamPtr =
stream->reserve(packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2KHR);
uint8_t* packetBeginPtr = streamPtr;
@@ -25664,7 +17846,6 @@
OP_vkGetPhysicalDeviceSparseImageFormatProperties2KHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSparseImageFormatProperties2KHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,
@@ -25702,13 +17883,6 @@
(VkSparseImageFormatProperties2*)(pProperties + i), streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2KHR),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -25753,33 +17927,6 @@
#ifdef VK_KHR_maintenance1
void VkEncoder::vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool,
VkCommandPoolTrimFlags flags, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkTrimCommandPoolKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkTrimCommandPoolKHR(device:%p, commandPool:%p, flags:%d)", device,
commandPool, flags);
(void)doLock;
@@ -25805,14 +17952,12 @@
}
uint32_t packetSize_vkTrimCommandPoolKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkTrimCommandPoolKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkTrimCommandPoolKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkTrimCommandPoolKHR = OP_vkTrimCommandPoolKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkTrimCommandPoolKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkTrimCommandPoolKHR, sizeof(uint32_t));
@@ -25831,12 +17976,6 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
*streamPtrPtr += sizeof(VkCommandPoolTrimFlags);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkTrimCommandPoolKHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->flush();
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -25851,34 +17990,6 @@
void VkEncoder::vkGetPhysicalDeviceExternalBufferPropertiesKHR(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
VkExternalBufferProperties* pExternalBufferProperties, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor,
- "vkGetPhysicalDeviceExternalBufferPropertiesKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice:%p, pExternalBufferInfo:%p, "
"pExternalBufferProperties:%p)",
@@ -25920,8 +18031,6 @@
}
uint32_t packetSize_vkGetPhysicalDeviceExternalBufferPropertiesKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceExternalBufferPropertiesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceExternalBufferPropertiesKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -25929,7 +18038,6 @@
OP_vkGetPhysicalDeviceExternalBufferPropertiesKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceExternalBufferPropertiesKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceExternalBufferPropertiesKHR, sizeof(uint32_t));
@@ -25948,13 +18056,6 @@
reservedmarshal_VkExternalBufferProperties(
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkExternalBufferProperties*)(pExternalBufferProperties), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceExternalBufferPropertiesKHR),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkExternalBufferProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkExternalBufferProperties*)(pExternalBufferProperties));
if (pExternalBufferProperties) {
@@ -25977,34 +18078,6 @@
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
VkExternalSemaphoreProperties* pExternalSemaphoreProperties, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor,
- "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice:%p, "
"pExternalSemaphoreInfo:%p, pExternalSemaphoreProperties:%p)",
@@ -26045,8 +18118,6 @@
}
uint32_t packetSize_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR);
uint8_t* streamPtr =
stream->reserve(packetSize_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR);
uint8_t* packetBeginPtr = streamPtr;
@@ -26055,7 +18126,6 @@
OP_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,
@@ -26075,13 +18145,6 @@
reservedmarshal_VkExternalSemaphoreProperties(
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkExternalSemaphoreProperties(
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
@@ -26104,33 +18167,6 @@
VkResult VkEncoder::vkImportSemaphoreFdKHR(VkDevice device,
const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkImportSemaphoreFdKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkImportSemaphoreFdKHR(device:%p, pImportSemaphoreFdInfo:%p)", device,
pImportSemaphoreFdInfo);
(void)doLock;
@@ -26165,14 +18201,12 @@
}
uint32_t packetSize_vkImportSemaphoreFdKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkImportSemaphoreFdKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkImportSemaphoreFdKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkImportSemaphoreFdKHR = OP_vkImportSemaphoreFdKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkImportSemaphoreFdKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkImportSemaphoreFdKHR, sizeof(uint32_t));
@@ -26188,12 +18222,6 @@
reservedmarshal_VkImportSemaphoreFdInfoKHR(
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkImportSemaphoreFdKHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
stream->read(&vkImportSemaphoreFdKHR_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -26207,33 +18235,6 @@
VkResult VkEncoder::vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
int* pFd, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetSemaphoreFdKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetSemaphoreFdKHR(device:%p, pGetFdInfo:%p, pFd:%p)", device, pGetFdInfo,
pFd);
(void)doLock;
@@ -26267,14 +18268,12 @@
}
uint32_t packetSize_vkGetSemaphoreFdKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetSemaphoreFdKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetSemaphoreFdKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetSemaphoreFdKHR = OP_vkGetSemaphoreFdKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetSemaphoreFdKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetSemaphoreFdKHR, sizeof(uint32_t));
@@ -26292,12 +18291,6 @@
streamPtrPtr);
memcpy(*streamPtrPtr, (int*)pFd, sizeof(int));
*streamPtrPtr += sizeof(int);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetSemaphoreFdKHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->read((int*)pFd, sizeof(int));
VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetSemaphoreFdKHR_VkResult_return, sizeof(VkResult));
@@ -26316,33 +18309,6 @@
VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateDescriptorUpdateTemplateKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCreateDescriptorUpdateTemplateKHR(device:%p, pCreateInfo:%p, pAllocator:%p, "
"pDescriptorUpdateTemplate:%p)",
@@ -26399,15 +18365,12 @@
}
uint32_t packetSize_vkCreateDescriptorUpdateTemplateKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCreateDescriptorUpdateTemplateKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateDescriptorUpdateTemplateKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateDescriptorUpdateTemplateKHR = OP_vkCreateDescriptorUpdateTemplateKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateDescriptorUpdateTemplateKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateDescriptorUpdateTemplateKHR, sizeof(uint32_t));
@@ -26439,13 +18402,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCreateDescriptorUpdateTemplateKHR),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -26469,33 +18425,6 @@
void VkEncoder::vkDestroyDescriptorUpdateTemplateKHR(
VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyDescriptorUpdateTemplateKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkDestroyDescriptorUpdateTemplateKHR(device:%p, descriptorUpdateTemplate:%p, "
"pAllocator:%p)",
@@ -26538,15 +18467,12 @@
}
uint32_t packetSize_vkDestroyDescriptorUpdateTemplateKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkDestroyDescriptorUpdateTemplateKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyDescriptorUpdateTemplateKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyDescriptorUpdateTemplateKHR = OP_vkDestroyDescriptorUpdateTemplateKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyDescriptorUpdateTemplateKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyDescriptorUpdateTemplateKHR, sizeof(uint32_t));
@@ -26573,13 +18499,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkDestroyDescriptorUpdateTemplateKHR),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkDescriptorUpdateTemplate(
(VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate);
stream->flush();
@@ -26594,33 +18513,6 @@
void VkEncoder::vkUpdateDescriptorSetWithTemplateKHR(
VkDevice device, VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkUpdateDescriptorSetWithTemplateKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkUpdateDescriptorSetWithTemplateKHR(device:%p, descriptorSet:%p, "
"descriptorUpdateTemplate:%p, pData:%p)",
@@ -26657,15 +18549,12 @@
}
uint32_t packetSize_vkUpdateDescriptorSetWithTemplateKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkUpdateDescriptorSetWithTemplateKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkUpdateDescriptorSetWithTemplateKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkUpdateDescriptorSetWithTemplateKHR = OP_vkUpdateDescriptorSetWithTemplateKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkUpdateDescriptorSetWithTemplateKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkUpdateDescriptorSetWithTemplateKHR, sizeof(uint32_t));
@@ -26695,13 +18584,6 @@
memcpy(*streamPtrPtr, (void*)local_pData, sizeof(uint8_t));
*streamPtrPtr += sizeof(uint8_t);
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkUpdateDescriptorSetWithTemplateKHR),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->flush();
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -26717,33 +18599,6 @@
const VkRenderPassCreateInfo2* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkRenderPass* pRenderPass, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateRenderPass2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCreateRenderPass2KHR(device:%p, pCreateInfo:%p, pAllocator:%p, pRenderPass:%p)", device,
pCreateInfo, pAllocator, pRenderPass);
@@ -26797,14 +18652,12 @@
}
uint32_t packetSize_vkCreateRenderPass2KHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateRenderPass2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateRenderPass2KHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateRenderPass2KHR = OP_vkCreateRenderPass2KHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateRenderPass2KHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateRenderPass2KHR, sizeof(uint32_t));
@@ -26836,12 +18689,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCreateRenderPass2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -26863,33 +18710,6 @@
const VkRenderPassBeginInfo* pRenderPassBegin,
const VkSubpassBeginInfo* pSubpassBeginInfo,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdBeginRenderPass2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdBeginRenderPass2KHR(commandBuffer:%p, pRenderPassBegin:%p, pSubpassBeginInfo:%p)",
commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
@@ -26936,7 +18756,6 @@
(VkSubpassBeginInfo*)(local_pSubpassBeginInfo), countPtr);
}
uint32_t packetSize_vkCmdBeginRenderPass2KHR = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBeginRenderPass2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginRenderPass2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBeginRenderPass2KHR);
uint8_t* packetBeginPtr = streamPtr;
@@ -26958,12 +18777,6 @@
reservedmarshal_VkSubpassBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkSubpassBeginInfo*)(local_pSubpassBeginInfo),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdBeginRenderPass2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -26975,33 +18788,6 @@
void VkEncoder::vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
const VkSubpassBeginInfo* pSubpassBeginInfo,
const VkSubpassEndInfo* pSubpassEndInfo, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdNextSubpass2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdNextSubpass2KHR(commandBuffer:%p, pSubpassBeginInfo:%p, pSubpassEndInfo:%p)",
commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
@@ -27047,7 +18833,6 @@
(VkSubpassEndInfo*)(local_pSubpassEndInfo), countPtr);
}
uint32_t packetSize_vkCmdNextSubpass2KHR = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdNextSubpass2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdNextSubpass2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdNextSubpass2KHR);
uint8_t* packetBeginPtr = streamPtr;
@@ -27068,12 +18853,6 @@
streamPtrPtr);
reservedmarshal_VkSubpassEndInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkSubpassEndInfo*)(local_pSubpassEndInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdNextSubpass2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -27084,33 +18863,6 @@
void VkEncoder::vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
const VkSubpassEndInfo* pSubpassEndInfo, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdEndRenderPass2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdEndRenderPass2KHR(commandBuffer:%p, pSubpassEndInfo:%p)", commandBuffer,
pSubpassEndInfo);
(void)doLock;
@@ -27141,7 +18893,6 @@
(VkSubpassEndInfo*)(local_pSubpassEndInfo), countPtr);
}
uint32_t packetSize_vkCmdEndRenderPass2KHR = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdEndRenderPass2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEndRenderPass2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdEndRenderPass2KHR);
uint8_t* packetBeginPtr = streamPtr;
@@ -27159,12 +18910,6 @@
}
reservedmarshal_VkSubpassEndInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkSubpassEndInfo*)(local_pSubpassEndInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdEndRenderPass2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -27178,34 +18923,6 @@
void VkEncoder::vkGetPhysicalDeviceExternalFencePropertiesKHR(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
VkExternalFenceProperties* pExternalFenceProperties, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor,
- "vkGetPhysicalDeviceExternalFencePropertiesKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice:%p, pExternalFenceInfo:%p, "
"pExternalFenceProperties:%p)",
@@ -27245,8 +18962,6 @@
}
uint32_t packetSize_vkGetPhysicalDeviceExternalFencePropertiesKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceExternalFencePropertiesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceExternalFencePropertiesKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -27254,7 +18969,6 @@
OP_vkGetPhysicalDeviceExternalFencePropertiesKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceExternalFencePropertiesKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceExternalFencePropertiesKHR, sizeof(uint32_t));
@@ -27273,13 +18987,6 @@
reservedmarshal_VkExternalFenceProperties(
stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalFenceProperties*)(pExternalFenceProperties),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPhysicalDeviceExternalFencePropertiesKHR),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkExternalFenceProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkExternalFenceProperties*)(pExternalFenceProperties));
if (pExternalFenceProperties) {
@@ -27299,33 +19006,6 @@
VkResult VkEncoder::vkImportFenceFdKHR(VkDevice device,
const VkImportFenceFdInfoKHR* pImportFenceFdInfo,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkImportFenceFdKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkImportFenceFdKHR(device:%p, pImportFenceFdInfo:%p)", device,
pImportFenceFdInfo);
(void)doLock;
@@ -27358,14 +19038,12 @@
}
uint32_t packetSize_vkImportFenceFdKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkImportFenceFdKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkImportFenceFdKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkImportFenceFdKHR = OP_vkImportFenceFdKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkImportFenceFdKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkImportFenceFdKHR, sizeof(uint32_t));
@@ -27381,12 +19059,6 @@
reservedmarshal_VkImportFenceFdInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkImportFenceFdKHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
stream->read(&vkImportFenceFdKHR_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -27400,33 +19072,6 @@
VkResult VkEncoder::vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo,
int* pFd, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetFenceFdKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetFenceFdKHR(device:%p, pGetFdInfo:%p, pFd:%p)", device, pGetFdInfo, pFd);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -27457,14 +19102,12 @@
*countPtr += sizeof(int);
}
uint32_t packetSize_vkGetFenceFdKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetFenceFdKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetFenceFdKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetFenceFdKHR = OP_vkGetFenceFdKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetFenceFdKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetFenceFdKHR, sizeof(uint32_t));
@@ -27481,12 +19124,6 @@
(VkFenceGetFdInfoKHR*)(local_pGetFdInfo), streamPtrPtr);
memcpy(*streamPtrPtr, (int*)pFd, sizeof(int));
*streamPtrPtr += sizeof(int);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetFenceFdKHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->read((int*)pFd, sizeof(int));
VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetFenceFdKHR_VkResult_return, sizeof(VkResult));
@@ -27505,33 +19142,6 @@
const VkImageMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetImageMemoryRequirements2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetImageMemoryRequirements2KHR(device:%p, pInfo:%p, pMemoryRequirements:%p)", device,
pInfo, pMemoryRequirements);
@@ -27568,15 +19178,12 @@
}
uint32_t packetSize_vkGetImageMemoryRequirements2KHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetImageMemoryRequirements2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageMemoryRequirements2KHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetImageMemoryRequirements2KHR = OP_vkGetImageMemoryRequirements2KHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetImageMemoryRequirements2KHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetImageMemoryRequirements2KHR, sizeof(uint32_t));
@@ -27595,12 +19202,6 @@
reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements2*)(pMemoryRequirements),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetImageMemoryRequirements2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements2*)(pMemoryRequirements));
if (pMemoryRequirements) {
@@ -27619,33 +19220,6 @@
const VkBufferMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetBufferMemoryRequirements2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetBufferMemoryRequirements2KHR(device:%p, pInfo:%p, pMemoryRequirements:%p)", device,
pInfo, pMemoryRequirements);
@@ -27682,15 +19256,12 @@
}
uint32_t packetSize_vkGetBufferMemoryRequirements2KHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetBufferMemoryRequirements2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferMemoryRequirements2KHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetBufferMemoryRequirements2KHR = OP_vkGetBufferMemoryRequirements2KHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetBufferMemoryRequirements2KHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetBufferMemoryRequirements2KHR, sizeof(uint32_t));
@@ -27709,12 +19280,6 @@
reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements2*)(pMemoryRequirements),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetBufferMemoryRequirements2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements2*)(pMemoryRequirements));
if (pMemoryRequirements) {
@@ -27733,33 +19298,6 @@
VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetImageSparseMemoryRequirements2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetImageSparseMemoryRequirements2KHR(device:%p, pInfo:%p, "
"pSparseMemoryRequirementCount:%p, pSparseMemoryRequirements:%p)",
@@ -27813,8 +19351,6 @@
}
uint32_t packetSize_vkGetImageSparseMemoryRequirements2KHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetImageSparseMemoryRequirements2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageSparseMemoryRequirements2KHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -27822,7 +19358,6 @@
OP_vkGetImageSparseMemoryRequirements2KHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetImageSparseMemoryRequirements2KHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetImageSparseMemoryRequirements2KHR, sizeof(uint32_t));
@@ -27859,13 +19394,6 @@
(VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetImageSparseMemoryRequirements2KHR),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pSparseMemoryRequirementCount;
check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -27916,33 +19444,6 @@
VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateSamplerYcbcrConversionKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCreateSamplerYcbcrConversionKHR(device:%p, pCreateInfo:%p, pAllocator:%p, "
"pYcbcrConversion:%p)",
@@ -27999,15 +19500,12 @@
}
uint32_t packetSize_vkCreateSamplerYcbcrConversionKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCreateSamplerYcbcrConversionKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateSamplerYcbcrConversionKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateSamplerYcbcrConversionKHR = OP_vkCreateSamplerYcbcrConversionKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateSamplerYcbcrConversionKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateSamplerYcbcrConversionKHR, sizeof(uint32_t));
@@ -28039,12 +19537,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCreateSamplerYcbcrConversionKHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -28066,33 +19558,6 @@
VkSamplerYcbcrConversion ycbcrConversion,
const VkAllocationCallbacks* pAllocator,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroySamplerYcbcrConversionKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkDestroySamplerYcbcrConversionKHR(device:%p, ycbcrConversion:%p, pAllocator:%p)", device,
ycbcrConversion, pAllocator);
@@ -28134,15 +19599,12 @@
}
uint32_t packetSize_vkDestroySamplerYcbcrConversionKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkDestroySamplerYcbcrConversionKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroySamplerYcbcrConversionKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroySamplerYcbcrConversionKHR = OP_vkDestroySamplerYcbcrConversionKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroySamplerYcbcrConversionKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroySamplerYcbcrConversionKHR, sizeof(uint32_t));
@@ -28169,12 +19631,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkDestroySamplerYcbcrConversionKHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
sResourceTracker->destroyMapping()->mapHandles_VkSamplerYcbcrConversion(
(VkSamplerYcbcrConversion*)&ycbcrConversion);
stream->flush();
@@ -28191,33 +19647,6 @@
VkResult VkEncoder::vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
const VkBindBufferMemoryInfo* pBindInfos,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkBindBufferMemory2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkBindBufferMemory2KHR(device:%p, bindInfoCount:%d, pBindInfos:%p)", device,
bindInfoCount, pBindInfos);
(void)doLock;
@@ -28259,14 +19688,12 @@
}
uint32_t packetSize_vkBindBufferMemory2KHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkBindBufferMemory2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkBindBufferMemory2KHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkBindBufferMemory2KHR = OP_vkBindBufferMemory2KHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkBindBufferMemory2KHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkBindBufferMemory2KHR, sizeof(uint32_t));
@@ -28286,12 +19713,6 @@
(VkBindBufferMemoryInfo*)(local_pBindInfos + i),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkBindBufferMemory2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
stream->read(&vkBindBufferMemory2KHR_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -28306,33 +19727,6 @@
VkResult VkEncoder::vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
const VkBindImageMemoryInfo* pBindInfos,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkBindImageMemory2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkBindImageMemory2KHR(device:%p, bindInfoCount:%d, pBindInfos:%p)", device,
bindInfoCount, pBindInfos);
(void)doLock;
@@ -28374,14 +19768,12 @@
}
uint32_t packetSize_vkBindImageMemory2KHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkBindImageMemory2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkBindImageMemory2KHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkBindImageMemory2KHR = OP_vkBindImageMemory2KHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkBindImageMemory2KHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkBindImageMemory2KHR, sizeof(uint32_t));
@@ -28401,12 +19793,6 @@
(VkBindImageMemoryInfo*)(local_pBindInfos + i),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkBindImageMemory2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
stream->read(&vkBindImageMemory2KHR_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -28423,33 +19809,6 @@
void VkEncoder::vkGetDescriptorSetLayoutSupportKHR(
VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
VkDescriptorSetLayoutSupport* pSupport, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetDescriptorSetLayoutSupportKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetDescriptorSetLayoutSupportKHR(device:%p, pCreateInfo:%p, pSupport:%p)",
device, pCreateInfo, pSupport);
(void)doLock;
@@ -28486,15 +19845,12 @@
}
uint32_t packetSize_vkGetDescriptorSetLayoutSupportKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetDescriptorSetLayoutSupportKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDescriptorSetLayoutSupportKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDescriptorSetLayoutSupportKHR = OP_vkGetDescriptorSetLayoutSupportKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetDescriptorSetLayoutSupportKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetDescriptorSetLayoutSupportKHR, sizeof(uint32_t));
@@ -28513,12 +19869,6 @@
reservedmarshal_VkDescriptorSetLayoutSupport(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkDescriptorSetLayoutSupport*)(pSupport),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetDescriptorSetLayoutSupportKHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkDescriptorSetLayoutSupport(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkDescriptorSetLayoutSupport*)(pSupport));
if (pSupport) {
@@ -28538,33 +19888,6 @@
VkDeviceAddress VkEncoder::vkGetBufferDeviceAddressKHR(VkDevice device,
const VkBufferDeviceAddressInfo* pInfo,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetBufferDeviceAddressKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetBufferDeviceAddressKHR(device:%p, pInfo:%p)", device, pInfo);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -28596,14 +19919,12 @@
}
uint32_t packetSize_vkGetBufferDeviceAddressKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetBufferDeviceAddressKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferDeviceAddressKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetBufferDeviceAddressKHR = OP_vkGetBufferDeviceAddressKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetBufferDeviceAddressKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetBufferDeviceAddressKHR, sizeof(uint32_t));
@@ -28619,12 +19940,6 @@
reservedmarshal_VkBufferDeviceAddressInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkBufferDeviceAddressInfo*)(local_pInfo),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetBufferDeviceAddressKHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkDeviceAddress vkGetBufferDeviceAddressKHR_VkDeviceAddress_return = (VkDeviceAddress)0;
stream->read(&vkGetBufferDeviceAddressKHR_VkDeviceAddress_return, sizeof(VkDeviceAddress));
++encodeCount;
@@ -28639,33 +19954,6 @@
uint64_t VkEncoder::vkGetBufferOpaqueCaptureAddressKHR(VkDevice device,
const VkBufferDeviceAddressInfo* pInfo,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetBufferOpaqueCaptureAddressKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetBufferOpaqueCaptureAddressKHR(device:%p, pInfo:%p)", device, pInfo);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -28697,15 +19985,12 @@
}
uint32_t packetSize_vkGetBufferOpaqueCaptureAddressKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetBufferOpaqueCaptureAddressKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferOpaqueCaptureAddressKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetBufferOpaqueCaptureAddressKHR = OP_vkGetBufferOpaqueCaptureAddressKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetBufferOpaqueCaptureAddressKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetBufferOpaqueCaptureAddressKHR, sizeof(uint32_t));
@@ -28721,12 +20006,6 @@
reservedmarshal_VkBufferDeviceAddressInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkBufferDeviceAddressInfo*)(local_pInfo),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetBufferOpaqueCaptureAddressKHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
uint64_t vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
stream->read(&vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return, sizeof(uint64_t));
++encodeCount;
@@ -28740,33 +20019,6 @@
uint64_t VkEncoder::vkGetDeviceMemoryOpaqueCaptureAddressKHR(
VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetDeviceMemoryOpaqueCaptureAddressKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetDeviceMemoryOpaqueCaptureAddressKHR(device:%p, pInfo:%p)", device,
pInfo);
(void)doLock;
@@ -28801,8 +20053,6 @@
}
uint32_t packetSize_vkGetDeviceMemoryOpaqueCaptureAddressKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetDeviceMemoryOpaqueCaptureAddressKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceMemoryOpaqueCaptureAddressKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -28810,7 +20060,6 @@
OP_vkGetDeviceMemoryOpaqueCaptureAddressKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetDeviceMemoryOpaqueCaptureAddressKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetDeviceMemoryOpaqueCaptureAddressKHR, sizeof(uint32_t));
@@ -28826,13 +20075,6 @@
reservedmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetDeviceMemoryOpaqueCaptureAddressKHR),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
stream->read(&vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return, sizeof(uint64_t));
++encodeCount;
@@ -28849,33 +20091,6 @@
VkResult VkEncoder::vkGetPipelineExecutablePropertiesKHR(
VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount,
VkPipelineExecutablePropertiesKHR* pProperties, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPipelineExecutablePropertiesKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPipelineExecutablePropertiesKHR(device:%p, pPipelineInfo:%p, pExecutableCount:%p, "
"pProperties:%p)",
@@ -28925,15 +20140,12 @@
}
uint32_t packetSize_vkGetPipelineExecutablePropertiesKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPipelineExecutablePropertiesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPipelineExecutablePropertiesKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPipelineExecutablePropertiesKHR = OP_vkGetPipelineExecutablePropertiesKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPipelineExecutablePropertiesKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPipelineExecutablePropertiesKHR, sizeof(uint32_t));
@@ -28969,13 +20181,6 @@
(VkPipelineExecutablePropertiesKHR*)(pProperties + i), streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetPipelineExecutablePropertiesKHR),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pExecutableCount;
check_pExecutableCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -29022,33 +20227,6 @@
VkResult VkEncoder::vkGetPipelineExecutableStatisticsKHR(
VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount,
VkPipelineExecutableStatisticKHR* pStatistics, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPipelineExecutableStatisticsKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPipelineExecutableStatisticsKHR(device:%p, pExecutableInfo:%p, pStatisticCount:%p, "
"pStatistics:%p)",
@@ -29100,15 +20278,12 @@
}
uint32_t packetSize_vkGetPipelineExecutableStatisticsKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPipelineExecutableStatisticsKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPipelineExecutableStatisticsKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPipelineExecutableStatisticsKHR = OP_vkGetPipelineExecutableStatisticsKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPipelineExecutableStatisticsKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPipelineExecutableStatisticsKHR, sizeof(uint32_t));
@@ -29145,13 +20320,6 @@
(VkPipelineExecutableStatisticKHR*)(pStatistics + i), streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetPipelineExecutableStatisticsKHR),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pStatisticCount;
check_pStatisticCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -29199,34 +20367,6 @@
VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo,
uint32_t* pInternalRepresentationCount,
VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor,
- "vkGetPipelineExecutableInternalRepresentationsKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPipelineExecutableInternalRepresentationsKHR(device:%p, pExecutableInfo:%p, "
"pInternalRepresentationCount:%p, pInternalRepresentations:%p)",
@@ -29280,8 +20420,6 @@
}
uint32_t packetSize_vkGetPipelineExecutableInternalRepresentationsKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPipelineExecutableInternalRepresentationsKHR);
uint8_t* streamPtr =
stream->reserve(packetSize_vkGetPipelineExecutableInternalRepresentationsKHR);
uint8_t* packetBeginPtr = streamPtr;
@@ -29290,7 +20428,6 @@
OP_vkGetPipelineExecutableInternalRepresentationsKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPipelineExecutableInternalRepresentationsKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPipelineExecutableInternalRepresentationsKHR,
@@ -29329,13 +20466,6 @@
streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPipelineExecutableInternalRepresentationsKHR),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pInternalRepresentationCount;
check_pInternalRepresentationCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -29388,33 +20518,6 @@
#ifdef VK_KHR_synchronization2
void VkEncoder::vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
const VkDependencyInfo* pDependencyInfo, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetEvent2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetEvent2KHR(commandBuffer:%p, event:%p, pDependencyInfo:%p)",
commandBuffer, event, pDependencyInfo);
(void)doLock;
@@ -29449,7 +20552,6 @@
(VkDependencyInfo*)(local_pDependencyInfo), countPtr);
}
uint32_t packetSize_vkCmdSetEvent2KHR = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetEvent2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetEvent2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetEvent2KHR);
uint8_t* packetBeginPtr = streamPtr;
@@ -29471,12 +20573,6 @@
*streamPtrPtr += 1 * 8;
reservedmarshal_VkDependencyInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkDependencyInfo*)(local_pDependencyInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdSetEvent2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -29487,33 +20583,6 @@
void VkEncoder::vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
VkPipelineStageFlags2 stageMask, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdResetEvent2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdResetEvent2KHR(commandBuffer:%p, event:%p)", commandBuffer, event);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -29537,7 +20606,6 @@
*countPtr += sizeof(VkPipelineStageFlags2);
}
uint32_t packetSize_vkCmdResetEvent2KHR = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdResetEvent2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdResetEvent2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdResetEvent2KHR);
uint8_t* packetBeginPtr = streamPtr;
@@ -29559,12 +20627,6 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkPipelineStageFlags2*)&local_stageMask, sizeof(VkPipelineStageFlags2));
*streamPtrPtr += sizeof(VkPipelineStageFlags2);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdResetEvent2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -29576,33 +20638,6 @@
void VkEncoder::vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount,
const VkEvent* pEvents,
const VkDependencyInfo* pDependencyInfos, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdWaitEvents2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdWaitEvents2KHR(commandBuffer:%p, eventCount:%d, pEvents:%p, pDependencyInfos:%p)",
commandBuffer, eventCount, pEvents, pDependencyInfos);
@@ -29650,7 +20685,6 @@
}
}
uint32_t packetSize_vkCmdWaitEvents2KHR = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdWaitEvents2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdWaitEvents2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdWaitEvents2KHR);
uint8_t* packetBeginPtr = streamPtr;
@@ -29681,12 +20715,6 @@
(VkDependencyInfo*)(local_pDependencyInfos + i),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdWaitEvents2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -29697,33 +20725,6 @@
void VkEncoder::vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,
const VkDependencyInfo* pDependencyInfo, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdPipelineBarrier2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdPipelineBarrier2KHR(commandBuffer:%p, pDependencyInfo:%p)",
commandBuffer, pDependencyInfo);
(void)doLock;
@@ -29754,7 +20755,6 @@
(VkDependencyInfo*)(local_pDependencyInfo), countPtr);
}
uint32_t packetSize_vkCmdPipelineBarrier2KHR = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdPipelineBarrier2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdPipelineBarrier2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdPipelineBarrier2KHR);
uint8_t* packetBeginPtr = streamPtr;
@@ -29772,12 +20772,6 @@
}
reservedmarshal_VkDependencyInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkDependencyInfo*)(local_pDependencyInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdPipelineBarrier2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -29788,33 +20782,6 @@
void VkEncoder::vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
VkQueryPool queryPool, uint32_t query, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdWriteTimestamp2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdWriteTimestamp2KHR(commandBuffer:%p, queryPool:%p, query:%d)",
commandBuffer, queryPool, query);
(void)doLock;
@@ -29842,7 +20809,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdWriteTimestamp2KHR = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdWriteTimestamp2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdWriteTimestamp2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdWriteTimestamp2KHR);
uint8_t* packetBeginPtr = streamPtr;
@@ -29866,12 +20832,6 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_query, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdWriteTimestamp2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -29883,33 +20843,6 @@
VkResult VkEncoder::vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount,
const VkSubmitInfo2* pSubmits, VkFence fence,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkQueueSubmit2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkQueueSubmit2KHR(queue:%p, submitCount:%d, pSubmits:%p, fence:%p)", queue,
submitCount, pSubmits, fence);
(void)doLock;
@@ -29953,14 +20886,12 @@
}
uint32_t packetSize_vkQueueSubmit2KHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkQueueSubmit2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueSubmit2KHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueSubmit2KHR = OP_vkQueueSubmit2KHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkQueueSubmit2KHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkQueueSubmit2KHR, sizeof(uint32_t));
@@ -29983,12 +20914,6 @@
*&cgen_var_1 = get_host_u64_VkFence((*&local_fence));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkQueueSubmit2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkQueueSubmit2KHR_VkResult_return = (VkResult)0;
stream->read(&vkQueueSubmit2KHR_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -30004,33 +20929,6 @@
VkPipelineStageFlags2 stage, VkBuffer dstBuffer,
VkDeviceSize dstOffset, uint32_t marker,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdWriteBufferMarker2AMD in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdWriteBufferMarker2AMD(commandBuffer:%p, dstBuffer:%p, dstOffset:%ld, marker:%d)",
commandBuffer, dstBuffer, dstOffset, marker);
@@ -30062,7 +20960,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdWriteBufferMarker2AMD = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdWriteBufferMarker2AMD);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdWriteBufferMarker2AMD -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdWriteBufferMarker2AMD);
uint8_t* packetBeginPtr = streamPtr;
@@ -30088,12 +20985,6 @@
*streamPtrPtr += sizeof(VkDeviceSize);
memcpy(*streamPtrPtr, (uint32_t*)&local_marker, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdWriteBufferMarker2AMD), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -30104,33 +20995,6 @@
void VkEncoder::vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount,
VkCheckpointData2NV* pCheckpointData, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetQueueCheckpointData2NV in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetQueueCheckpointData2NV(queue:%p, pCheckpointDataCount:%p, pCheckpointData:%p)", queue,
pCheckpointDataCount, pCheckpointData);
@@ -30166,14 +21030,12 @@
}
uint32_t packetSize_vkGetQueueCheckpointData2NV =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetQueueCheckpointData2NV);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetQueueCheckpointData2NV);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetQueueCheckpointData2NV = OP_vkGetQueueCheckpointData2NV;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetQueueCheckpointData2NV, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetQueueCheckpointData2NV, sizeof(uint32_t));
@@ -30207,12 +21069,6 @@
streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetQueueCheckpointData2NV), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pCheckpointDataCount;
check_pCheckpointDataCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -30256,33 +21112,6 @@
#ifdef VK_KHR_copy_commands2
void VkEncoder::vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
const VkCopyBufferInfo2* pCopyBufferInfo, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdCopyBuffer2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdCopyBuffer2KHR(commandBuffer:%p, pCopyBufferInfo:%p)", commandBuffer,
pCopyBufferInfo);
(void)doLock;
@@ -30313,7 +21142,6 @@
(VkCopyBufferInfo2*)(local_pCopyBufferInfo), countPtr);
}
uint32_t packetSize_vkCmdCopyBuffer2KHR = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyBuffer2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyBuffer2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyBuffer2KHR);
uint8_t* packetBeginPtr = streamPtr;
@@ -30331,12 +21159,6 @@
}
reservedmarshal_VkCopyBufferInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkCopyBufferInfo2*)(local_pCopyBufferInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdCopyBuffer2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -30347,33 +21169,6 @@
void VkEncoder::vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer,
const VkCopyImageInfo2* pCopyImageInfo, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdCopyImage2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdCopyImage2KHR(commandBuffer:%p, pCopyImageInfo:%p)", commandBuffer,
pCopyImageInfo);
(void)doLock;
@@ -30404,7 +21199,6 @@
(VkCopyImageInfo2*)(local_pCopyImageInfo), countPtr);
}
uint32_t packetSize_vkCmdCopyImage2KHR = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyImage2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyImage2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyImage2KHR);
uint8_t* packetBeginPtr = streamPtr;
@@ -30422,12 +21216,6 @@
}
reservedmarshal_VkCopyImageInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkCopyImageInfo2*)(local_pCopyImageInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdCopyImage2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -30439,33 +21227,6 @@
void VkEncoder::vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer,
const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdCopyBufferToImage2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdCopyBufferToImage2KHR(commandBuffer:%p, pCopyBufferToImageInfo:%p)",
commandBuffer, pCopyBufferToImageInfo);
(void)doLock;
@@ -30499,7 +21260,6 @@
countPtr);
}
uint32_t packetSize_vkCmdCopyBufferToImage2KHR = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyBufferToImage2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyBufferToImage2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyBufferToImage2KHR);
uint8_t* packetBeginPtr = streamPtr;
@@ -30518,12 +21278,6 @@
reservedmarshal_VkCopyBufferToImageInfo2(
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkCopyBufferToImageInfo2*)(local_pCopyBufferToImageInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdCopyBufferToImage2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -30535,33 +21289,6 @@
void VkEncoder::vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer,
const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdCopyImageToBuffer2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdCopyImageToBuffer2KHR(commandBuffer:%p, pCopyImageToBufferInfo:%p)",
commandBuffer, pCopyImageToBufferInfo);
(void)doLock;
@@ -30595,7 +21322,6 @@
countPtr);
}
uint32_t packetSize_vkCmdCopyImageToBuffer2KHR = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyImageToBuffer2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyImageToBuffer2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyImageToBuffer2KHR);
uint8_t* packetBeginPtr = streamPtr;
@@ -30614,12 +21340,6 @@
reservedmarshal_VkCopyImageToBufferInfo2(
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkCopyImageToBufferInfo2*)(local_pCopyImageToBufferInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdCopyImageToBuffer2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -30630,33 +21350,6 @@
void VkEncoder::vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer,
const VkBlitImageInfo2* pBlitImageInfo, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdBlitImage2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdBlitImage2KHR(commandBuffer:%p, pBlitImageInfo:%p)", commandBuffer,
pBlitImageInfo);
(void)doLock;
@@ -30687,7 +21380,6 @@
(VkBlitImageInfo2*)(local_pBlitImageInfo), countPtr);
}
uint32_t packetSize_vkCmdBlitImage2KHR = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBlitImage2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBlitImage2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBlitImage2KHR);
uint8_t* packetBeginPtr = streamPtr;
@@ -30705,12 +21397,6 @@
}
reservedmarshal_VkBlitImageInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkBlitImageInfo2*)(local_pBlitImageInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdBlitImage2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -30722,33 +21408,6 @@
void VkEncoder::vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer,
const VkResolveImageInfo2* pResolveImageInfo,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdResolveImage2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdResolveImage2KHR(commandBuffer:%p, pResolveImageInfo:%p)",
commandBuffer, pResolveImageInfo);
(void)doLock;
@@ -30780,7 +21439,6 @@
(VkResolveImageInfo2*)(local_pResolveImageInfo), countPtr);
}
uint32_t packetSize_vkCmdResolveImage2KHR = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdResolveImage2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdResolveImage2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdResolveImage2KHR);
uint8_t* packetBeginPtr = streamPtr;
@@ -30799,12 +21457,6 @@
reservedmarshal_VkResolveImageInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkResolveImageInfo2*)(local_pResolveImageInfo),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdResolveImage2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -30818,33 +21470,6 @@
void VkEncoder::vkGetDeviceBufferMemoryRequirementsKHR(
VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo,
VkMemoryRequirements2* pMemoryRequirements, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetDeviceBufferMemoryRequirementsKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetDeviceBufferMemoryRequirementsKHR(device:%p, pInfo:%p, pMemoryRequirements:%p)",
device, pInfo, pMemoryRequirements);
@@ -30881,8 +21506,6 @@
}
uint32_t packetSize_vkGetDeviceBufferMemoryRequirementsKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetDeviceBufferMemoryRequirementsKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceBufferMemoryRequirementsKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -30890,7 +21513,6 @@
OP_vkGetDeviceBufferMemoryRequirementsKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetDeviceBufferMemoryRequirementsKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetDeviceBufferMemoryRequirementsKHR, sizeof(uint32_t));
@@ -30909,13 +21531,6 @@
reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements2*)(pMemoryRequirements),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetDeviceBufferMemoryRequirementsKHR),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements2*)(pMemoryRequirements));
if (pMemoryRequirements) {
@@ -30934,33 +21549,6 @@
const VkDeviceImageMemoryRequirements* pInfo,
VkMemoryRequirements2* pMemoryRequirements,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetDeviceImageMemoryRequirementsKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetDeviceImageMemoryRequirementsKHR(device:%p, pInfo:%p, pMemoryRequirements:%p)",
device, pInfo, pMemoryRequirements);
@@ -30997,8 +21585,6 @@
}
uint32_t packetSize_vkGetDeviceImageMemoryRequirementsKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetDeviceImageMemoryRequirementsKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceImageMemoryRequirementsKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -31006,7 +21592,6 @@
OP_vkGetDeviceImageMemoryRequirementsKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetDeviceImageMemoryRequirementsKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetDeviceImageMemoryRequirementsKHR, sizeof(uint32_t));
@@ -31025,13 +21610,6 @@
reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements2*)(pMemoryRequirements),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetDeviceImageMemoryRequirementsKHR),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements2*)(pMemoryRequirements));
if (pMemoryRequirements) {
@@ -31050,33 +21628,6 @@
VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetDeviceImageSparseMemoryRequirementsKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetDeviceImageSparseMemoryRequirementsKHR(device:%p, pInfo:%p, "
"pSparseMemoryRequirementCount:%p, pSparseMemoryRequirements:%p)",
@@ -31129,8 +21680,6 @@
}
uint32_t packetSize_vkGetDeviceImageSparseMemoryRequirementsKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetDeviceImageSparseMemoryRequirementsKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceImageSparseMemoryRequirementsKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -31138,7 +21687,6 @@
OP_vkGetDeviceImageSparseMemoryRequirementsKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetDeviceImageSparseMemoryRequirementsKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetDeviceImageSparseMemoryRequirementsKHR, sizeof(uint32_t));
@@ -31175,13 +21723,6 @@
(VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetDeviceImageSparseMemoryRequirementsKHR),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pSparseMemoryRequirementCount;
check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -31231,33 +21772,6 @@
void VkEncoder::vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
VkDeviceSize offset, VkDeviceSize size,
VkIndexType indexType, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdBindIndexBuffer2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdBindIndexBuffer2KHR(commandBuffer:%p, buffer:%p, offset:%ld, size:%ld)",
commandBuffer, buffer, offset, size);
(void)doLock;
@@ -31288,7 +21802,6 @@
*countPtr += sizeof(VkIndexType);
}
uint32_t packetSize_vkCmdBindIndexBuffer2KHR = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBindIndexBuffer2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBindIndexBuffer2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBindIndexBuffer2KHR);
uint8_t* packetBeginPtr = streamPtr;
@@ -31314,12 +21827,6 @@
*streamPtrPtr += sizeof(VkDeviceSize);
memcpy(*streamPtrPtr, (VkIndexType*)&local_indexType, sizeof(VkIndexType));
*streamPtrPtr += sizeof(VkIndexType);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdBindIndexBuffer2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -31331,33 +21838,6 @@
void VkEncoder::vkGetRenderingAreaGranularityKHR(VkDevice device,
const VkRenderingAreaInfoKHR* pRenderingAreaInfo,
VkExtent2D* pGranularity, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetRenderingAreaGranularityKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetRenderingAreaGranularityKHR(device:%p, pRenderingAreaInfo:%p, pGranularity:%p)",
device, pRenderingAreaInfo, pGranularity);
@@ -31393,15 +21873,12 @@
}
uint32_t packetSize_vkGetRenderingAreaGranularityKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetRenderingAreaGranularityKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetRenderingAreaGranularityKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetRenderingAreaGranularityKHR = OP_vkGetRenderingAreaGranularityKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetRenderingAreaGranularityKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetRenderingAreaGranularityKHR, sizeof(uint32_t));
@@ -31419,12 +21896,6 @@
streamPtrPtr);
reservedmarshal_VkExtent2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pGranularity),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetRenderingAreaGranularityKHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkExtent2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pGranularity));
if (pGranularity) {
transform_fromhost_VkExtent2D(sResourceTracker, (VkExtent2D*)(pGranularity));
@@ -31441,33 +21912,6 @@
const VkDeviceImageSubresourceInfoKHR* pInfo,
VkSubresourceLayout2KHR* pLayout,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetDeviceImageSubresourceLayoutKHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetDeviceImageSubresourceLayoutKHR(device:%p, pInfo:%p, pLayout:%p)",
device, pInfo, pLayout);
(void)doLock;
@@ -31503,15 +21947,12 @@
}
uint32_t packetSize_vkGetDeviceImageSubresourceLayoutKHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetDeviceImageSubresourceLayoutKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceImageSubresourceLayoutKHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDeviceImageSubresourceLayoutKHR = OP_vkGetDeviceImageSubresourceLayoutKHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetDeviceImageSubresourceLayoutKHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetDeviceImageSubresourceLayoutKHR, sizeof(uint32_t));
@@ -31529,13 +21970,6 @@
streamPtrPtr);
reservedmarshal_VkSubresourceLayout2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkSubresourceLayout2KHR*)(pLayout), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetDeviceImageSubresourceLayoutKHR),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkSubresourceLayout2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkSubresourceLayout2KHR*)(pLayout));
if (pLayout) {
@@ -31553,33 +21987,6 @@
void VkEncoder::vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image,
const VkImageSubresource2KHR* pSubresource,
VkSubresourceLayout2KHR* pLayout, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetImageSubresourceLayout2KHR in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetImageSubresourceLayout2KHR(device:%p, image:%p, pSubresource:%p, pLayout:%p)", device,
image, pSubresource, pLayout);
@@ -31619,15 +22026,12 @@
}
uint32_t packetSize_vkGetImageSubresourceLayout2KHR =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetImageSubresourceLayout2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageSubresourceLayout2KHR);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetImageSubresourceLayout2KHR = OP_vkGetImageSubresourceLayout2KHR;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetImageSubresourceLayout2KHR, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetImageSubresourceLayout2KHR, sizeof(uint32_t));
@@ -31649,12 +22053,6 @@
streamPtrPtr);
reservedmarshal_VkSubresourceLayout2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkSubresourceLayout2KHR*)(pLayout), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetImageSubresourceLayout2KHR), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkSubresourceLayout2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkSubresourceLayout2KHR*)(pLayout));
if (pLayout) {
@@ -31674,33 +22072,6 @@
VkResult VkEncoder::vkGetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format,
VkImageUsageFlags imageUsage,
int* grallocUsage, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetSwapchainGrallocUsageANDROID in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetSwapchainGrallocUsageANDROID(device:%p, format:%d, imageUsage:%d, grallocUsage:%p)",
device, format, imageUsage, grallocUsage);
@@ -31727,15 +22098,12 @@
}
uint32_t packetSize_vkGetSwapchainGrallocUsageANDROID =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetSwapchainGrallocUsageANDROID);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetSwapchainGrallocUsageANDROID);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetSwapchainGrallocUsageANDROID = OP_vkGetSwapchainGrallocUsageANDROID;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetSwapchainGrallocUsageANDROID, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetSwapchainGrallocUsageANDROID, sizeof(uint32_t));
@@ -31754,12 +22122,6 @@
*streamPtrPtr += sizeof(VkImageUsageFlags);
memcpy(*streamPtrPtr, (int*)grallocUsage, sizeof(int));
*streamPtrPtr += sizeof(int);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetSwapchainGrallocUsageANDROID), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->read((int*)grallocUsage, sizeof(int));
VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
stream->read(&vkGetSwapchainGrallocUsageANDROID_VkResult_return, sizeof(VkResult));
@@ -31774,33 +22136,6 @@
VkResult VkEncoder::vkAcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd,
VkSemaphore semaphore, VkFence fence, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkAcquireImageANDROID in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
(void)doLock;
bool queueSubmitWithCommandsEnabled =
sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
@@ -31834,14 +22169,12 @@
}
uint32_t packetSize_vkAcquireImageANDROID =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkAcquireImageANDROID);
uint8_t* streamPtr = stream->reserve(packetSize_vkAcquireImageANDROID);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkAcquireImageANDROID = OP_vkAcquireImageANDROID;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkAcquireImageANDROID, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkAcquireImageANDROID, sizeof(uint32_t));
@@ -31868,12 +22201,6 @@
*&cgen_var_3 = get_host_u64_VkFence((*&local_fence));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_3, 1 * 8);
*streamPtrPtr += 1 * 8;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkAcquireImageANDROID), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
stream->read(&vkAcquireImageANDROID_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -31889,33 +22216,6 @@
const VkSemaphore* pWaitSemaphores,
VkImage image, int* pNativeFenceFd,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkQueueSignalReleaseImageANDROID in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkQueueSignalReleaseImageANDROID(queue:%p, waitSemaphoreCount:%d, pWaitSemaphores:%p, "
"image:%p, pNativeFenceFd:%p)",
@@ -31954,15 +22254,12 @@
}
uint32_t packetSize_vkQueueSignalReleaseImageANDROID =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkQueueSignalReleaseImageANDROID);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueSignalReleaseImageANDROID);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueSignalReleaseImageANDROID = OP_vkQueueSignalReleaseImageANDROID;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkQueueSignalReleaseImageANDROID, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkQueueSignalReleaseImageANDROID, sizeof(uint32_t));
@@ -31998,12 +22295,6 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (int*)pNativeFenceFd, sizeof(int));
*streamPtrPtr += sizeof(int);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkQueueSignalReleaseImageANDROID), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->read((int*)pNativeFenceFd, sizeof(int));
VkResult vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0;
stream->read(&vkQueueSignalReleaseImageANDROID_VkResult_return, sizeof(VkResult));
@@ -32021,33 +22312,6 @@
VkDevice device, VkFormat format, VkImageUsageFlags imageUsage,
VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage,
uint64_t* grallocProducerUsage, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetSwapchainGrallocUsage2ANDROID in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetSwapchainGrallocUsage2ANDROID(device:%p, format:%d, imageUsage:%d, "
"grallocConsumerUsage:%p, grallocProducerUsage:%p)",
@@ -32079,15 +22343,12 @@
}
uint32_t packetSize_vkGetSwapchainGrallocUsage2ANDROID =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetSwapchainGrallocUsage2ANDROID);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetSwapchainGrallocUsage2ANDROID);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetSwapchainGrallocUsage2ANDROID = OP_vkGetSwapchainGrallocUsage2ANDROID;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetSwapchainGrallocUsage2ANDROID, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetSwapchainGrallocUsage2ANDROID, sizeof(uint32_t));
@@ -32111,12 +22372,6 @@
*streamPtrPtr += sizeof(uint64_t);
memcpy(*streamPtrPtr, (uint64_t*)grallocProducerUsage, sizeof(uint64_t));
*streamPtrPtr += sizeof(uint64_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetSwapchainGrallocUsage2ANDROID), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->read((uint64_t*)grallocConsumerUsage, sizeof(uint64_t));
stream->read((uint64_t*)grallocProducerUsage, sizeof(uint64_t));
VkResult vkGetSwapchainGrallocUsage2ANDROID_VkResult_return = (VkResult)0;
@@ -32137,33 +22392,6 @@
const VkBuffer* pBuffers,
const VkDeviceSize* pOffsets,
const VkDeviceSize* pSizes, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdBindTransformFeedbackBuffersEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdBindTransformFeedbackBuffersEXT(commandBuffer:%p, firstBinding:%d, bindingCount:%d, "
"pBuffers:%p, pOffsets:%p, pSizes:%p)",
@@ -32207,8 +22435,6 @@
}
}
uint32_t packetSize_vkCmdBindTransformFeedbackBuffersEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCmdBindTransformFeedbackBuffersEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBindTransformFeedbackBuffersEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBindTransformFeedbackBuffersEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -32247,13 +22473,6 @@
memcpy(*streamPtrPtr, (VkDeviceSize*)local_pSizes, ((bindingCount)) * sizeof(VkDeviceSize));
*streamPtrPtr += ((bindingCount)) * sizeof(VkDeviceSize);
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCmdBindTransformFeedbackBuffersEXT),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -32265,33 +22484,6 @@
void VkEncoder::vkCmdBeginTransformFeedbackEXT(
VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount,
const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdBeginTransformFeedbackEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdBeginTransformFeedbackEXT(commandBuffer:%p, firstCounterBuffer:%d, "
"counterBufferCount:%d, pCounterBuffers:%p, pCounterBufferOffsets:%p)",
@@ -32336,8 +22528,6 @@
}
}
uint32_t packetSize_vkCmdBeginTransformFeedbackEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCmdBeginTransformFeedbackEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginTransformFeedbackEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBeginTransformFeedbackEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -32382,12 +22572,6 @@
((counterBufferCount)) * sizeof(VkDeviceSize));
*streamPtrPtr += ((counterBufferCount)) * sizeof(VkDeviceSize);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdBeginTransformFeedbackEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -32399,33 +22583,6 @@
void VkEncoder::vkCmdEndTransformFeedbackEXT(
VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount,
const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdEndTransformFeedbackEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdEndTransformFeedbackEXT(commandBuffer:%p, firstCounterBuffer:%d, "
"counterBufferCount:%d, pCounterBuffers:%p, pCounterBufferOffsets:%p)",
@@ -32470,8 +22627,6 @@
}
}
uint32_t packetSize_vkCmdEndTransformFeedbackEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCmdEndTransformFeedbackEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEndTransformFeedbackEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdEndTransformFeedbackEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -32516,12 +22671,6 @@
((counterBufferCount)) * sizeof(VkDeviceSize));
*streamPtrPtr += ((counterBufferCount)) * sizeof(VkDeviceSize);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdEndTransformFeedbackEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -32533,33 +22682,6 @@
void VkEncoder::vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
uint32_t query, VkQueryControlFlags flags, uint32_t index,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdBeginQueryIndexedEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdBeginQueryIndexedEXT(commandBuffer:%p, queryPool:%p, query:%d, flags:%d, index:%d)",
commandBuffer, queryPool, query, flags, index);
@@ -32591,7 +22713,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdBeginQueryIndexedEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBeginQueryIndexedEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginQueryIndexedEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBeginQueryIndexedEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -32617,12 +22738,6 @@
*streamPtrPtr += sizeof(VkQueryControlFlags);
memcpy(*streamPtrPtr, (uint32_t*)&local_index, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdBeginQueryIndexedEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -32633,33 +22748,6 @@
void VkEncoder::vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
uint32_t query, uint32_t index, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdEndQueryIndexedEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdEndQueryIndexedEXT(commandBuffer:%p, queryPool:%p, query:%d, index:%d)",
commandBuffer, queryPool, query, index);
(void)doLock;
@@ -32687,7 +22775,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdEndQueryIndexedEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdEndQueryIndexedEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEndQueryIndexedEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdEndQueryIndexedEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -32711,12 +22798,6 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_index, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdEndQueryIndexedEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -32730,33 +22811,6 @@
VkDeviceSize counterBufferOffset,
uint32_t counterOffset, uint32_t vertexStride,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdDrawIndirectByteCountEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdDrawIndirectByteCountEXT(commandBuffer:%p, instanceCount:%d, firstInstance:%d, "
"counterBuffer:%p, counterBufferOffset:%ld, counterOffset:%d, vertexStride:%d)",
@@ -32796,8 +22850,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDrawIndirectByteCountEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCmdDrawIndirectByteCountEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawIndirectByteCountEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawIndirectByteCountEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -32827,12 +22879,6 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_vertexStride, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdDrawIndirectByteCountEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -32846,33 +22892,6 @@
VkResult VkEncoder::vkGetPhysicalDeviceToolPropertiesEXT(
VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
VkPhysicalDeviceToolProperties* pToolProperties, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPhysicalDeviceToolPropertiesEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice:%p, pToolCount:%p, "
"pToolProperties:%p)",
@@ -32909,15 +22928,12 @@
}
uint32_t packetSize_vkGetPhysicalDeviceToolPropertiesEXT =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetPhysicalDeviceToolPropertiesEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceToolPropertiesEXT);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceToolPropertiesEXT = OP_vkGetPhysicalDeviceToolPropertiesEXT;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPhysicalDeviceToolPropertiesEXT, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceToolPropertiesEXT, sizeof(uint32_t));
@@ -32951,13 +22967,6 @@
(VkPhysicalDeviceToolProperties*)(pToolProperties + i), streamPtrPtr);
}
}
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetPhysicalDeviceToolPropertiesEXT),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint32_t* check_pToolCount;
check_pToolCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -33005,33 +23014,6 @@
#ifdef VK_EXT_line_rasterization
void VkEncoder::vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
uint16_t lineStipplePattern, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetLineStippleEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdSetLineStippleEXT(commandBuffer:%p, lineStippleFactor:%d, lineStipplePattern:%d)",
commandBuffer, lineStippleFactor, lineStipplePattern);
@@ -33056,7 +23038,6 @@
*countPtr += sizeof(uint16_t);
}
uint32_t packetSize_vkCmdSetLineStippleEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetLineStippleEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetLineStippleEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetLineStippleEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -33076,12 +23057,6 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint16_t*)&local_lineStipplePattern, sizeof(uint16_t));
*streamPtrPtr += sizeof(uint16_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetLineStippleEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -33094,33 +23069,6 @@
#ifdef VK_EXT_extended_dynamic_state
void VkEncoder::vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetCullModeEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetCullModeEXT(commandBuffer:%p, cullMode:%d)", commandBuffer,
cullMode);
(void)doLock;
@@ -33141,7 +23089,6 @@
*countPtr += sizeof(VkCullModeFlags);
}
uint32_t packetSize_vkCmdSetCullModeEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetCullModeEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetCullModeEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetCullModeEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -33159,12 +23106,6 @@
}
memcpy(*streamPtrPtr, (VkCullModeFlags*)&local_cullMode, sizeof(VkCullModeFlags));
*streamPtrPtr += sizeof(VkCullModeFlags);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetCullModeEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -33175,33 +23116,6 @@
void VkEncoder::vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetFrontFaceEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetFrontFaceEXT(commandBuffer:%p)", commandBuffer);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -33221,7 +23135,6 @@
*countPtr += sizeof(VkFrontFace);
}
uint32_t packetSize_vkCmdSetFrontFaceEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetFrontFaceEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetFrontFaceEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetFrontFaceEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -33239,12 +23152,6 @@
}
memcpy(*streamPtrPtr, (VkFrontFace*)&local_frontFace, sizeof(VkFrontFace));
*streamPtrPtr += sizeof(VkFrontFace);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetFrontFaceEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -33256,33 +23163,6 @@
void VkEncoder::vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
VkPrimitiveTopology primitiveTopology,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetPrimitiveTopologyEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetPrimitiveTopologyEXT(commandBuffer:%p)", commandBuffer);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -33302,8 +23182,6 @@
*countPtr += sizeof(VkPrimitiveTopology);
}
uint32_t packetSize_vkCmdSetPrimitiveTopologyEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCmdSetPrimitiveTopologyEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetPrimitiveTopologyEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetPrimitiveTopologyEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -33322,12 +23200,6 @@
memcpy(*streamPtrPtr, (VkPrimitiveTopology*)&local_primitiveTopology,
sizeof(VkPrimitiveTopology));
*streamPtrPtr += sizeof(VkPrimitiveTopology);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetPrimitiveTopologyEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -33338,33 +23210,6 @@
void VkEncoder::vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount,
const VkViewport* pViewports, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetViewportWithCountEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdSetViewportWithCountEXT(commandBuffer:%p, viewportCount:%d, pViewports:%p)",
commandBuffer, viewportCount, pViewports);
@@ -33404,8 +23249,6 @@
}
}
uint32_t packetSize_vkCmdSetViewportWithCountEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCmdSetViewportWithCountEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetViewportWithCountEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetViewportWithCountEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -33427,12 +23270,6 @@
reservedmarshal_VkViewport(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkViewport*)(local_pViewports + i), streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetViewportWithCountEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -33443,33 +23280,6 @@
void VkEncoder::vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount,
const VkRect2D* pScissors, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetScissorWithCountEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdSetScissorWithCountEXT(commandBuffer:%p, scissorCount:%d, pScissors:%p)",
commandBuffer, scissorCount, pScissors);
@@ -33509,7 +23319,6 @@
}
}
uint32_t packetSize_vkCmdSetScissorWithCountEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetScissorWithCountEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetScissorWithCountEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetScissorWithCountEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -33531,12 +23340,6 @@
reservedmarshal_VkRect2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkRect2D*)(local_pScissors + i), streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetScissorWithCountEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -33549,33 +23352,6 @@
uint32_t bindingCount, const VkBuffer* pBuffers,
const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
const VkDeviceSize* pStrides, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdBindVertexBuffers2EXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdBindVertexBuffers2EXT(commandBuffer:%p, firstBinding:%d, bindingCount:%d, "
"pBuffers:%p, pOffsets:%p, pSizes:%p, pStrides:%p)",
@@ -33631,7 +23407,6 @@
}
}
uint32_t packetSize_vkCmdBindVertexBuffers2EXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBindVertexBuffers2EXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBindVertexBuffers2EXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBindVertexBuffers2EXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -33687,12 +23462,6 @@
((bindingCount)) * sizeof(VkDeviceSize));
*streamPtrPtr += ((bindingCount)) * sizeof(VkDeviceSize);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdBindVertexBuffers2EXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -33703,33 +23472,6 @@
void VkEncoder::vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetDepthTestEnableEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetDepthTestEnableEXT(commandBuffer:%p, depthTestEnable:%d)",
commandBuffer, depthTestEnable);
(void)doLock;
@@ -33750,7 +23492,6 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetDepthTestEnableEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetDepthTestEnableEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDepthTestEnableEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDepthTestEnableEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -33768,12 +23509,6 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_depthTestEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetDepthTestEnableEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -33784,33 +23519,6 @@
void VkEncoder::vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,
VkBool32 depthWriteEnable, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetDepthWriteEnableEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetDepthWriteEnableEXT(commandBuffer:%p, depthWriteEnable:%d)",
commandBuffer, depthWriteEnable);
(void)doLock;
@@ -33831,7 +23539,6 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetDepthWriteEnableEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetDepthWriteEnableEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDepthWriteEnableEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDepthWriteEnableEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -33849,12 +23556,6 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_depthWriteEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetDepthWriteEnableEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -33865,33 +23566,6 @@
void VkEncoder::vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetDepthCompareOpEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetDepthCompareOpEXT(commandBuffer:%p)", commandBuffer);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -33911,7 +23585,6 @@
*countPtr += sizeof(VkCompareOp);
}
uint32_t packetSize_vkCmdSetDepthCompareOpEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetDepthCompareOpEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDepthCompareOpEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDepthCompareOpEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -33929,12 +23602,6 @@
}
memcpy(*streamPtrPtr, (VkCompareOp*)&local_depthCompareOp, sizeof(VkCompareOp));
*streamPtrPtr += sizeof(VkCompareOp);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetDepthCompareOpEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -33945,33 +23612,6 @@
void VkEncoder::vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
VkBool32 depthBoundsTestEnable, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetDepthBoundsTestEnableEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdSetDepthBoundsTestEnableEXT(commandBuffer:%p, depthBoundsTestEnable:%d)",
commandBuffer, depthBoundsTestEnable);
@@ -33993,8 +23633,6 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetDepthBoundsTestEnableEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCmdSetDepthBoundsTestEnableEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDepthBoundsTestEnableEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDepthBoundsTestEnableEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -34012,12 +23650,6 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_depthBoundsTestEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetDepthBoundsTestEnableEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -34028,33 +23660,6 @@
void VkEncoder::vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,
VkBool32 stencilTestEnable, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetStencilTestEnableEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetStencilTestEnableEXT(commandBuffer:%p, stencilTestEnable:%d)",
commandBuffer, stencilTestEnable);
(void)doLock;
@@ -34075,8 +23680,6 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetStencilTestEnableEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCmdSetStencilTestEnableEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetStencilTestEnableEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetStencilTestEnableEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -34094,12 +23697,6 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_stencilTestEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetStencilTestEnableEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -34112,33 +23709,6 @@
VkStencilOp failOp, VkStencilOp passOp,
VkStencilOp depthFailOp, VkCompareOp compareOp,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetStencilOpEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetStencilOpEXT(commandBuffer:%p, faceMask:%d)", commandBuffer,
faceMask);
(void)doLock;
@@ -34171,7 +23741,6 @@
*countPtr += sizeof(VkCompareOp);
}
uint32_t packetSize_vkCmdSetStencilOpEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetStencilOpEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetStencilOpEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetStencilOpEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -34197,12 +23766,6 @@
*streamPtrPtr += sizeof(VkStencilOp);
memcpy(*streamPtrPtr, (VkCompareOp*)&local_compareOp, sizeof(VkCompareOp));
*streamPtrPtr += sizeof(VkCompareOp);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetStencilOpEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -34216,33 +23779,6 @@
VkResult VkEncoder::vkCopyMemoryToImageEXT(VkDevice device,
const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCopyMemoryToImageEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCopyMemoryToImageEXT(device:%p, pCopyMemoryToImageInfo:%p)", device,
pCopyMemoryToImageInfo);
(void)doLock;
@@ -34277,14 +23813,12 @@
}
uint32_t packetSize_vkCopyMemoryToImageEXT =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCopyMemoryToImageEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkCopyMemoryToImageEXT);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCopyMemoryToImageEXT = OP_vkCopyMemoryToImageEXT;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCopyMemoryToImageEXT, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCopyMemoryToImageEXT, sizeof(uint32_t));
@@ -34300,12 +23834,6 @@
reservedmarshal_VkCopyMemoryToImageInfoEXT(
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkCopyMemoryToImageInfoEXT*)(local_pCopyMemoryToImageInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCopyMemoryToImageEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkCopyMemoryToImageEXT_VkResult_return = (VkResult)0;
stream->read(&vkCopyMemoryToImageEXT_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -34320,33 +23848,6 @@
VkResult VkEncoder::vkCopyImageToMemoryEXT(VkDevice device,
const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCopyImageToMemoryEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCopyImageToMemoryEXT(device:%p, pCopyImageToMemoryInfo:%p)", device,
pCopyImageToMemoryInfo);
(void)doLock;
@@ -34381,14 +23882,12 @@
}
uint32_t packetSize_vkCopyImageToMemoryEXT =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCopyImageToMemoryEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkCopyImageToMemoryEXT);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCopyImageToMemoryEXT = OP_vkCopyImageToMemoryEXT;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCopyImageToMemoryEXT, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCopyImageToMemoryEXT, sizeof(uint32_t));
@@ -34404,12 +23903,6 @@
reservedmarshal_VkCopyImageToMemoryInfoEXT(
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkCopyImageToMemoryInfoEXT*)(local_pCopyImageToMemoryInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCopyImageToMemoryEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkCopyImageToMemoryEXT_VkResult_return = (VkResult)0;
stream->read(&vkCopyImageToMemoryEXT_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -34424,33 +23917,6 @@
VkResult VkEncoder::vkCopyImageToImageEXT(VkDevice device,
const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCopyImageToImageEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCopyImageToImageEXT(device:%p, pCopyImageToImageInfo:%p)", device,
pCopyImageToImageInfo);
(void)doLock;
@@ -34485,14 +23951,12 @@
}
uint32_t packetSize_vkCopyImageToImageEXT =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCopyImageToImageEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkCopyImageToImageEXT);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCopyImageToImageEXT = OP_vkCopyImageToImageEXT;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCopyImageToImageEXT, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCopyImageToImageEXT, sizeof(uint32_t));
@@ -34508,12 +23972,6 @@
reservedmarshal_VkCopyImageToImageInfoEXT(
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkCopyImageToImageInfoEXT*)(local_pCopyImageToImageInfo), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCopyImageToImageEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkCopyImageToImageEXT_VkResult_return = (VkResult)0;
stream->read(&vkCopyImageToImageEXT_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -34528,33 +23986,6 @@
VkResult VkEncoder::vkTransitionImageLayoutEXT(
VkDevice device, uint32_t transitionCount,
const VkHostImageLayoutTransitionInfoEXT* pTransitions, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkTransitionImageLayoutEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkTransitionImageLayoutEXT(device:%p, transitionCount:%d, pTransitions:%p)",
device, transitionCount, pTransitions);
(void)doLock;
@@ -34598,14 +24029,12 @@
}
uint32_t packetSize_vkTransitionImageLayoutEXT =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkTransitionImageLayoutEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkTransitionImageLayoutEXT);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkTransitionImageLayoutEXT = OP_vkTransitionImageLayoutEXT;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkTransitionImageLayoutEXT, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkTransitionImageLayoutEXT, sizeof(uint32_t));
@@ -34625,12 +24054,6 @@
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkHostImageLayoutTransitionInfoEXT*)(local_pTransitions + i), streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkTransitionImageLayoutEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkTransitionImageLayoutEXT_VkResult_return = (VkResult)0;
stream->read(&vkTransitionImageLayoutEXT_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -34645,33 +24068,6 @@
void VkEncoder::vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image,
const VkImageSubresource2KHR* pSubresource,
VkSubresourceLayout2KHR* pLayout, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetImageSubresourceLayout2EXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetImageSubresourceLayout2EXT(device:%p, image:%p, pSubresource:%p, pLayout:%p)", device,
image, pSubresource, pLayout);
@@ -34711,15 +24107,12 @@
}
uint32_t packetSize_vkGetImageSubresourceLayout2EXT =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetImageSubresourceLayout2EXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageSubresourceLayout2EXT);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetImageSubresourceLayout2EXT = OP_vkGetImageSubresourceLayout2EXT;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetImageSubresourceLayout2EXT, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetImageSubresourceLayout2EXT, sizeof(uint32_t));
@@ -34741,12 +24134,6 @@
streamPtrPtr);
reservedmarshal_VkSubresourceLayout2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkSubresourceLayout2KHR*)(pLayout), streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetImageSubresourceLayout2EXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
unmarshal_VkSubresourceLayout2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkSubresourceLayout2KHR*)(pLayout));
if (pLayout) {
@@ -34768,33 +24155,6 @@
const VkAllocationCallbacks* pAllocator,
VkPrivateDataSlot* pPrivateDataSlot,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreatePrivateDataSlotEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCreatePrivateDataSlotEXT(device:%p, pCreateInfo:%p, pAllocator:%p, pPrivateDataSlot:%p)",
device, pCreateInfo, pAllocator, pPrivateDataSlot);
@@ -34848,14 +24208,12 @@
}
uint32_t packetSize_vkCreatePrivateDataSlotEXT =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreatePrivateDataSlotEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreatePrivateDataSlotEXT);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreatePrivateDataSlotEXT = OP_vkCreatePrivateDataSlotEXT;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreatePrivateDataSlotEXT, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreatePrivateDataSlotEXT, sizeof(uint32_t));
@@ -34885,12 +24243,6 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
gfxstream::guest::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCreatePrivateDataSlotEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
(*pPrivateDataSlot) = (VkPrivateDataSlot)stream->getBe64();
VkResult vkCreatePrivateDataSlotEXT_VkResult_return = (VkResult)0;
stream->read(&vkCreatePrivateDataSlotEXT_VkResult_return, sizeof(VkResult));
@@ -34906,33 +24258,6 @@
void VkEncoder::vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot,
const VkAllocationCallbacks* pAllocator,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkDestroyPrivateDataSlotEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkDestroyPrivateDataSlotEXT(device:%p, pAllocator:%p)", device, pAllocator);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -34971,14 +24296,12 @@
}
uint32_t packetSize_vkDestroyPrivateDataSlotEXT =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyPrivateDataSlotEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyPrivateDataSlotEXT);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyPrivateDataSlotEXT = OP_vkDestroyPrivateDataSlotEXT;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkDestroyPrivateDataSlotEXT, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkDestroyPrivateDataSlotEXT, sizeof(uint32_t));
@@ -35005,12 +24328,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkDestroyPrivateDataSlotEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->flush();
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -35023,33 +24340,6 @@
VkResult VkEncoder::vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType,
uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
uint64_t data, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkSetPrivateDataEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkSetPrivateDataEXT(device:%p, objectHandle:%ld, data:%ld)", device,
objectHandle, data);
(void)doLock;
@@ -35080,14 +24370,12 @@
}
uint32_t packetSize_vkSetPrivateDataEXT =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkSetPrivateDataEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkSetPrivateDataEXT);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkSetPrivateDataEXT = OP_vkSetPrivateDataEXT;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkSetPrivateDataEXT, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkSetPrivateDataEXT, sizeof(uint32_t));
@@ -35110,12 +24398,6 @@
*streamPtrPtr += 8;
memcpy(*streamPtrPtr, (uint64_t*)&local_data, sizeof(uint64_t));
*streamPtrPtr += sizeof(uint64_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkSetPrivateDataEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkSetPrivateDataEXT_VkResult_return = (VkResult)0;
stream->read(&vkSetPrivateDataEXT_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -35130,33 +24412,6 @@
void VkEncoder::vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
VkPrivateDataSlot privateDataSlot, uint64_t* pData,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetPrivateDataEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetPrivateDataEXT(device:%p, objectHandle:%ld, pData:%p)", device,
objectHandle, pData);
(void)doLock;
@@ -35185,14 +24440,12 @@
}
uint32_t packetSize_vkGetPrivateDataEXT =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetPrivateDataEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPrivateDataEXT);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPrivateDataEXT = OP_vkGetPrivateDataEXT;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetPrivateDataEXT, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetPrivateDataEXT, sizeof(uint32_t));
@@ -35215,12 +24468,6 @@
*streamPtrPtr += 8;
memcpy(*streamPtrPtr, (uint64_t*)pData, sizeof(uint64_t));
*streamPtrPtr += sizeof(uint64_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetPrivateDataEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->read((uint64_t*)pData, sizeof(uint64_t));
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -35234,33 +24481,6 @@
#ifdef VK_EXT_extended_dynamic_state2
void VkEncoder::vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer,
uint32_t patchControlPoints, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetPatchControlPointsEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetPatchControlPointsEXT(commandBuffer:%p, patchControlPoints:%d)",
commandBuffer, patchControlPoints);
(void)doLock;
@@ -35281,8 +24501,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdSetPatchControlPointsEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCmdSetPatchControlPointsEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetPatchControlPointsEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetPatchControlPointsEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -35300,12 +24518,6 @@
}
memcpy(*streamPtrPtr, (uint32_t*)&local_patchControlPoints, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetPatchControlPointsEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -35317,33 +24529,6 @@
void VkEncoder::vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,
VkBool32 rasterizerDiscardEnable,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetRasterizerDiscardEnableEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdSetRasterizerDiscardEnableEXT(commandBuffer:%p, rasterizerDiscardEnable:%d)",
commandBuffer, rasterizerDiscardEnable);
@@ -35365,8 +24550,6 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetRasterizerDiscardEnableEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCmdSetRasterizerDiscardEnableEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetRasterizerDiscardEnableEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetRasterizerDiscardEnableEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -35384,12 +24567,6 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_rasterizerDiscardEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetRasterizerDiscardEnableEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -35400,33 +24577,6 @@
void VkEncoder::vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetDepthBiasEnableEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetDepthBiasEnableEXT(commandBuffer:%p, depthBiasEnable:%d)",
commandBuffer, depthBiasEnable);
(void)doLock;
@@ -35447,7 +24597,6 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetDepthBiasEnableEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetDepthBiasEnableEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDepthBiasEnableEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDepthBiasEnableEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -35465,12 +24614,6 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_depthBiasEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetDepthBiasEnableEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -35481,33 +24624,6 @@
void VkEncoder::vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetLogicOpEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkCmdSetLogicOpEXT(commandBuffer:%p)", commandBuffer);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -35527,7 +24643,6 @@
*countPtr += sizeof(VkLogicOp);
}
uint32_t packetSize_vkCmdSetLogicOpEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetLogicOpEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetLogicOpEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetLogicOpEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -35545,12 +24660,6 @@
}
memcpy(*streamPtrPtr, (VkLogicOp*)&local_logicOp, sizeof(VkLogicOp));
*streamPtrPtr += sizeof(VkLogicOp);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetLogicOpEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -35562,33 +24671,6 @@
void VkEncoder::vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,
VkBool32 primitiveRestartEnable,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetPrimitiveRestartEnableEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdSetPrimitiveRestartEnableEXT(commandBuffer:%p, primitiveRestartEnable:%d)",
commandBuffer, primitiveRestartEnable);
@@ -35610,8 +24692,6 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetPrimitiveRestartEnableEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCmdSetPrimitiveRestartEnableEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetPrimitiveRestartEnableEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetPrimitiveRestartEnableEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -35629,12 +24709,6 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_primitiveRestartEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetPrimitiveRestartEnableEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -35647,33 +24721,6 @@
#ifdef VK_EXT_color_write_enable
void VkEncoder::vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
const VkBool32* pColorWriteEnables, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCmdSetColorWriteEnableEXT in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCmdSetColorWriteEnableEXT(commandBuffer:%p, attachmentCount:%d, pColorWriteEnables:%p)",
commandBuffer, attachmentCount, pColorWriteEnables);
@@ -35699,7 +24746,6 @@
*countPtr += ((attachmentCount)) * sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetColorWriteEnableEXT = 4 + 4 + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetColorWriteEnableEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetColorWriteEnableEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetColorWriteEnableEXT);
uint8_t* packetBeginPtr = streamPtr;
@@ -35720,12 +24766,6 @@
memcpy(*streamPtrPtr, (VkBool32*)local_pColorWriteEnables,
((attachmentCount)) * sizeof(VkBool32));
*streamPtrPtr += ((attachmentCount)) * sizeof(VkBool32);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCmdSetColorWriteEnableEXT), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -35738,33 +24778,6 @@
#ifdef VK_GOOGLE_gfxstream
VkResult VkEncoder::vkMapMemoryIntoAddressSpaceGOOGLE(VkDevice device, VkDeviceMemory memory,
uint64_t* pAddress, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkMapMemoryIntoAddressSpaceGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkMapMemoryIntoAddressSpaceGOOGLE(device:%p, memory:%p, pAddress:%p)",
device, memory, pAddress);
(void)doLock;
@@ -35797,15 +24810,12 @@
}
uint32_t packetSize_vkMapMemoryIntoAddressSpaceGOOGLE =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkMapMemoryIntoAddressSpaceGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkMapMemoryIntoAddressSpaceGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkMapMemoryIntoAddressSpaceGOOGLE = OP_vkMapMemoryIntoAddressSpaceGOOGLE;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkMapMemoryIntoAddressSpaceGOOGLE, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkMapMemoryIntoAddressSpaceGOOGLE, sizeof(uint32_t));
@@ -35831,12 +24841,6 @@
memcpy(*streamPtrPtr, (uint64_t*)pAddress, sizeof(uint64_t));
*streamPtrPtr += sizeof(uint64_t);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkMapMemoryIntoAddressSpaceGOOGLE), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint64_t* check_pAddress;
check_pAddress = (uint64_t*)(uintptr_t)stream->getBe64();
@@ -35866,34 +24870,6 @@
const uint32_t* pBufferInfoEntryIndices, const uint32_t* pBufferViewEntryIndices,
const VkDescriptorImageInfo* pImageInfos, const VkDescriptorBufferInfo* pBufferInfos,
const VkBufferView* pBufferViews, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor,
- "vkUpdateDescriptorSetWithTemplateSizedGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkUpdateDescriptorSetWithTemplateSizedGOOGLE(device:%p, descriptorSet:%p, "
"descriptorUpdateTemplate:%p, imageInfoCount:%d, bufferInfoCount:%d, bufferViewCount:%d, "
@@ -36019,8 +24995,6 @@
}
uint32_t packetSize_vkUpdateDescriptorSetWithTemplateSizedGOOGLE =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkUpdateDescriptorSetWithTemplateSizedGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkUpdateDescriptorSetWithTemplateSizedGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -36028,7 +25002,6 @@
OP_vkUpdateDescriptorSetWithTemplateSizedGOOGLE;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkUpdateDescriptorSetWithTemplateSizedGOOGLE, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkUpdateDescriptorSetWithTemplateSizedGOOGLE, sizeof(uint32_t));
@@ -36124,13 +25097,6 @@
*streamPtrPtr += 8 * ((bufferViewCount));
}
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkUpdateDescriptorSetWithTemplateSizedGOOGLE),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->flush();
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -36143,33 +25109,6 @@
void VkEncoder::vkBeginCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
const VkCommandBufferBeginInfo* pBeginInfo,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkBeginCommandBufferAsyncGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkBeginCommandBufferAsyncGOOGLE(commandBuffer:%p, pBeginInfo:%p)",
commandBuffer, pBeginInfo);
(void)doLock;
@@ -36201,8 +25140,6 @@
(VkCommandBufferBeginInfo*)(local_pBeginInfo), countPtr);
}
uint32_t packetSize_vkBeginCommandBufferAsyncGOOGLE = 4 + 4 + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkBeginCommandBufferAsyncGOOGLE);
if (queueSubmitWithCommandsEnabled) packetSize_vkBeginCommandBufferAsyncGOOGLE -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkBeginCommandBufferAsyncGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
@@ -36221,12 +25158,6 @@
reservedmarshal_VkCommandBufferBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkCommandBufferBeginInfo*)(local_pBeginInfo),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkBeginCommandBufferAsyncGOOGLE), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -36236,33 +25167,6 @@
}
void VkEncoder::vkEndCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkEndCommandBufferAsyncGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkEndCommandBufferAsyncGOOGLE(commandBuffer:%p)", commandBuffer);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -36279,8 +25183,6 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkEndCommandBufferAsyncGOOGLE = 4 + 4 + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkEndCommandBufferAsyncGOOGLE);
if (queueSubmitWithCommandsEnabled) packetSize_vkEndCommandBufferAsyncGOOGLE -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkEndCommandBufferAsyncGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
@@ -36296,12 +25198,6 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkEndCommandBufferAsyncGOOGLE), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->flush();
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -36313,33 +25209,6 @@
void VkEncoder::vkResetCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
VkCommandBufferResetFlags flags, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkResetCommandBufferAsyncGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkResetCommandBufferAsyncGOOGLE(commandBuffer:%p, flags:%d)", commandBuffer,
flags);
(void)doLock;
@@ -36360,8 +25229,6 @@
*countPtr += sizeof(VkCommandBufferResetFlags);
}
uint32_t packetSize_vkResetCommandBufferAsyncGOOGLE = 4 + 4 + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkResetCommandBufferAsyncGOOGLE);
if (queueSubmitWithCommandsEnabled) packetSize_vkResetCommandBufferAsyncGOOGLE -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkResetCommandBufferAsyncGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
@@ -36380,12 +25247,6 @@
memcpy(*streamPtrPtr, (VkCommandBufferResetFlags*)&local_flags,
sizeof(VkCommandBufferResetFlags));
*streamPtrPtr += sizeof(VkCommandBufferResetFlags);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkResetCommandBufferAsyncGOOGLE), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -36396,33 +25257,6 @@
void VkEncoder::vkCommandBufferHostSyncGOOGLE(VkCommandBuffer commandBuffer, uint32_t needHostSync,
uint32_t sequenceNumber, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCommandBufferHostSyncGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCommandBufferHostSyncGOOGLE(commandBuffer:%p, needHostSync:%d, sequenceNumber:%d)",
commandBuffer, needHostSync, sequenceNumber);
@@ -36447,8 +25281,6 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCommandBufferHostSyncGOOGLE = 4 + 4 + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCommandBufferHostSyncGOOGLE);
if (queueSubmitWithCommandsEnabled) packetSize_vkCommandBufferHostSyncGOOGLE -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCommandBufferHostSyncGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
@@ -36468,12 +25300,6 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_sequenceNumber, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCommandBufferHostSyncGOOGLE), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
@@ -36485,33 +25311,6 @@
VkResult VkEncoder::vkCreateImageWithRequirementsGOOGLE(
VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
VkImage* pImage, VkMemoryRequirements* pMemoryRequirements, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateImageWithRequirementsGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
(void)doLock;
bool queueSubmitWithCommandsEnabled =
sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
@@ -36565,15 +25364,12 @@
}
uint32_t packetSize_vkCreateImageWithRequirementsGOOGLE =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCreateImageWithRequirementsGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateImageWithRequirementsGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateImageWithRequirementsGOOGLE = OP_vkCreateImageWithRequirementsGOOGLE;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateImageWithRequirementsGOOGLE, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateImageWithRequirementsGOOGLE, sizeof(uint32_t));
@@ -36607,13 +25403,6 @@
reservedmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements*)(pMemoryRequirements),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCreateImageWithRequirementsGOOGLE),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -36639,33 +25428,6 @@
VkResult VkEncoder::vkCreateBufferWithRequirementsGOOGLE(
VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
VkBuffer* pBuffer, VkMemoryRequirements* pMemoryRequirements, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCreateBufferWithRequirementsGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCreateBufferWithRequirementsGOOGLE(device:%p, pCreateInfo:%p, pAllocator:%p, "
"pBuffer:%p, pMemoryRequirements:%p)",
@@ -36721,15 +25483,12 @@
}
uint32_t packetSize_vkCreateBufferWithRequirementsGOOGLE =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCreateBufferWithRequirementsGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateBufferWithRequirementsGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateBufferWithRequirementsGOOGLE = OP_vkCreateBufferWithRequirementsGOOGLE;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCreateBufferWithRequirementsGOOGLE, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCreateBufferWithRequirementsGOOGLE, sizeof(uint32_t));
@@ -36763,13 +25522,6 @@
reservedmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkMemoryRequirements*)(pMemoryRequirements),
streamPtrPtr);
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkCreateBufferWithRequirementsGOOGLE),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
@@ -36795,33 +25547,6 @@
VkResult VkEncoder::vkGetMemoryHostAddressInfoGOOGLE(VkDevice device, VkDeviceMemory memory,
uint64_t* pAddress, uint64_t* pSize,
uint64_t* pHostmemId, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetMemoryHostAddressInfoGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetMemoryHostAddressInfoGOOGLE(device:%p, memory:%p, pAddress:%p, pSize:%p, "
"pHostmemId:%p)",
@@ -36864,15 +25589,12 @@
}
uint32_t packetSize_vkGetMemoryHostAddressInfoGOOGLE =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetMemoryHostAddressInfoGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetMemoryHostAddressInfoGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetMemoryHostAddressInfoGOOGLE = OP_vkGetMemoryHostAddressInfoGOOGLE;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetMemoryHostAddressInfoGOOGLE, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetMemoryHostAddressInfoGOOGLE, sizeof(uint32_t));
@@ -36916,12 +25638,6 @@
memcpy(*streamPtrPtr, (uint64_t*)pHostmemId, sizeof(uint64_t));
*streamPtrPtr += sizeof(uint64_t);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetMemoryHostAddressInfoGOOGLE), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
// WARNING PTR CHECK
uint64_t* check_pAddress;
check_pAddress = (uint64_t*)(uintptr_t)stream->getBe64();
@@ -36963,33 +25679,6 @@
VkResult VkEncoder::vkFreeMemorySyncGOOGLE(VkDevice device, VkDeviceMemory memory,
const VkAllocationCallbacks* pAllocator,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkFreeMemorySyncGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkFreeMemorySyncGOOGLE(device:%p, memory:%p, pAllocator:%p)", device, memory,
pAllocator);
(void)doLock;
@@ -37029,14 +25718,12 @@
}
uint32_t packetSize_vkFreeMemorySyncGOOGLE =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkFreeMemorySyncGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkFreeMemorySyncGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkFreeMemorySyncGOOGLE = OP_vkFreeMemorySyncGOOGLE;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkFreeMemorySyncGOOGLE, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkFreeMemorySyncGOOGLE, sizeof(uint32_t));
@@ -37063,12 +25750,6 @@
(VkAllocationCallbacks*)(local_pAllocator),
streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkFreeMemorySyncGOOGLE), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkFreeMemorySyncGOOGLE_VkResult_return = (VkResult)0;
stream->read(&vkFreeMemorySyncGOOGLE_VkResult_return, sizeof(VkResult));
sResourceTracker->destroyMapping()->mapHandles_VkDeviceMemory((VkDeviceMemory*)&memory);
@@ -37083,33 +25764,6 @@
void VkEncoder::vkQueueHostSyncGOOGLE(VkQueue queue, uint32_t needHostSync, uint32_t sequenceNumber,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkQueueHostSyncGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkQueueHostSyncGOOGLE(queue:%p, needHostSync:%d, sequenceNumber:%d)", queue,
needHostSync, sequenceNumber);
(void)doLock;
@@ -37134,14 +25788,12 @@
}
uint32_t packetSize_vkQueueHostSyncGOOGLE =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkQueueHostSyncGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueHostSyncGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueHostSyncGOOGLE = OP_vkQueueHostSyncGOOGLE;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkQueueHostSyncGOOGLE, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkQueueHostSyncGOOGLE, sizeof(uint32_t));
@@ -37158,12 +25810,6 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_sequenceNumber, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkQueueHostSyncGOOGLE), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->flush();
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -37176,33 +25822,6 @@
void VkEncoder::vkQueueSubmitAsyncGOOGLE(VkQueue queue, uint32_t submitCount,
const VkSubmitInfo* pSubmits, VkFence fence,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkQueueSubmitAsyncGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkQueueSubmitAsyncGOOGLE(queue:%p, submitCount:%d, pSubmits:%p, fence:%p)",
queue, submitCount, pSubmits, fence);
(void)doLock;
@@ -37246,14 +25865,12 @@
}
uint32_t packetSize_vkQueueSubmitAsyncGOOGLE =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkQueueSubmitAsyncGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueSubmitAsyncGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueSubmitAsyncGOOGLE = OP_vkQueueSubmitAsyncGOOGLE;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkQueueSubmitAsyncGOOGLE, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkQueueSubmitAsyncGOOGLE, sizeof(uint32_t));
@@ -37276,12 +25893,6 @@
*&cgen_var_1 = get_host_u64_VkFence((*&local_fence));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkQueueSubmitAsyncGOOGLE), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->flush();
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -37292,33 +25903,6 @@
}
void VkEncoder::vkQueueWaitIdleAsyncGOOGLE(VkQueue queue, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkQueueWaitIdleAsyncGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkQueueWaitIdleAsyncGOOGLE(queue:%p)", queue);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -37336,14 +25920,12 @@
}
uint32_t packetSize_vkQueueWaitIdleAsyncGOOGLE =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkQueueWaitIdleAsyncGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueWaitIdleAsyncGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueWaitIdleAsyncGOOGLE = OP_vkQueueWaitIdleAsyncGOOGLE;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkQueueWaitIdleAsyncGOOGLE, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkQueueWaitIdleAsyncGOOGLE, sizeof(uint32_t));
@@ -37356,12 +25938,6 @@
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkQueueWaitIdleAsyncGOOGLE), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->flush();
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -37374,33 +25950,6 @@
void VkEncoder::vkQueueBindSparseAsyncGOOGLE(VkQueue queue, uint32_t bindInfoCount,
const VkBindSparseInfo* pBindInfo, VkFence fence,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkQueueBindSparseAsyncGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkQueueBindSparseAsyncGOOGLE(queue:%p, bindInfoCount:%d, pBindInfo:%p, fence:%p)", queue,
bindInfoCount, pBindInfo, fence);
@@ -37447,15 +25996,12 @@
}
uint32_t packetSize_vkQueueBindSparseAsyncGOOGLE =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkQueueBindSparseAsyncGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueBindSparseAsyncGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueBindSparseAsyncGOOGLE = OP_vkQueueBindSparseAsyncGOOGLE;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkQueueBindSparseAsyncGOOGLE, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkQueueBindSparseAsyncGOOGLE, sizeof(uint32_t));
@@ -37478,12 +26024,6 @@
*&cgen_var_1 = get_host_u64_VkFence((*&local_fence));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkQueueBindSparseAsyncGOOGLE), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->flush();
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -37496,33 +26036,6 @@
void VkEncoder::vkGetLinearImageLayoutGOOGLE(VkDevice device, VkFormat format,
VkDeviceSize* pOffset,
VkDeviceSize* pRowPitchAlignment, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetLinearImageLayoutGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetLinearImageLayoutGOOGLE(device:%p, format:%d, pOffset:%p, pRowPitchAlignment:%p)",
device, format, pOffset, pRowPitchAlignment);
@@ -37547,15 +26060,12 @@
}
uint32_t packetSize_vkGetLinearImageLayoutGOOGLE =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetLinearImageLayoutGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetLinearImageLayoutGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetLinearImageLayoutGOOGLE = OP_vkGetLinearImageLayoutGOOGLE;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetLinearImageLayoutGOOGLE, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetLinearImageLayoutGOOGLE, sizeof(uint32_t));
@@ -37574,12 +26084,6 @@
*streamPtrPtr += sizeof(VkDeviceSize);
memcpy(*streamPtrPtr, (VkDeviceSize*)pRowPitchAlignment, sizeof(VkDeviceSize));
*streamPtrPtr += sizeof(VkDeviceSize);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetLinearImageLayoutGOOGLE), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->read((VkDeviceSize*)pOffset, sizeof(VkDeviceSize));
stream->read((VkDeviceSize*)pRowPitchAlignment, sizeof(VkDeviceSize));
++encodeCount;
@@ -37593,33 +26097,6 @@
void VkEncoder::vkGetLinearImageLayout2GOOGLE(VkDevice device, const VkImageCreateInfo* pCreateInfo,
VkDeviceSize* pOffset,
VkDeviceSize* pRowPitchAlignment, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetLinearImageLayout2GOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkGetLinearImageLayout2GOOGLE(device:%p, pCreateInfo:%p, pOffset:%p, "
"pRowPitchAlignment:%p)",
@@ -37656,15 +26133,12 @@
}
uint32_t packetSize_vkGetLinearImageLayout2GOOGLE =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkGetLinearImageLayout2GOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetLinearImageLayout2GOOGLE);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetLinearImageLayout2GOOGLE = OP_vkGetLinearImageLayout2GOOGLE;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetLinearImageLayout2GOOGLE, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetLinearImageLayout2GOOGLE, sizeof(uint32_t));
@@ -37683,12 +26157,6 @@
*streamPtrPtr += sizeof(VkDeviceSize);
memcpy(*streamPtrPtr, (VkDeviceSize*)pRowPitchAlignment, sizeof(VkDeviceSize));
*streamPtrPtr += sizeof(VkDeviceSize);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetLinearImageLayout2GOOGLE), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->read((VkDeviceSize*)pOffset, sizeof(VkDeviceSize));
stream->read((VkDeviceSize*)pRowPitchAlignment, sizeof(VkDeviceSize));
++encodeCount;
@@ -37702,33 +26170,6 @@
void VkEncoder::vkQueueFlushCommandsGOOGLE(VkQueue queue, VkCommandBuffer commandBuffer,
VkDeviceSize dataSize, const void* pData,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkQueueFlushCommandsGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
#include "vkQueueFlushCommandsGOOGLE_encode_impl.cpp.inl"
}
@@ -37739,33 +26180,6 @@
const uint32_t* pDescriptorSetPendingAllocation,
const uint32_t* pDescriptorWriteStartingIndices, uint32_t pendingDescriptorWriteCount,
const VkWriteDescriptorSet* pPendingDescriptorWrites, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkQueueCommitDescriptorSetUpdatesGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkQueueCommitDescriptorSetUpdatesGOOGLE(queue:%p, descriptorPoolCount:%d, "
"pDescriptorPools:%p, descriptorSetCount:%d, pSetLayouts:%p, pDescriptorSetPoolIds:%p, "
@@ -37850,8 +26264,6 @@
}
uint32_t packetSize_vkQueueCommitDescriptorSetUpdatesGOOGLE =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkQueueCommitDescriptorSetUpdatesGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueCommitDescriptorSetUpdatesGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -37859,7 +26271,6 @@
OP_vkQueueCommitDescriptorSetUpdatesGOOGLE;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkQueueCommitDescriptorSetUpdatesGOOGLE, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkQueueCommitDescriptorSetUpdatesGOOGLE, sizeof(uint32_t));
@@ -37911,13 +26322,6 @@
stream, VK_STRUCTURE_TYPE_MAX_ENUM,
(VkWriteDescriptorSet*)(local_pPendingDescriptorWrites + i), streamPtrPtr);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkQueueCommitDescriptorSetUpdatesGOOGLE),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->flush();
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -37930,33 +26334,6 @@
void VkEncoder::vkCollectDescriptorPoolIdsGOOGLE(VkDevice device, VkDescriptorPool descriptorPool,
uint32_t* pPoolIdCount, uint64_t* pPoolIds,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkCollectDescriptorPoolIdsGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkCollectDescriptorPoolIdsGOOGLE(device:%p, descriptorPool:%p, pPoolIdCount:%p, "
"pPoolIds:%p)",
@@ -37989,15 +26366,12 @@
}
uint32_t packetSize_vkCollectDescriptorPoolIdsGOOGLE =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkCollectDescriptorPoolIdsGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkCollectDescriptorPoolIdsGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCollectDescriptorPoolIdsGOOGLE = OP_vkCollectDescriptorPoolIdsGOOGLE;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkCollectDescriptorPoolIdsGOOGLE, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkCollectDescriptorPoolIdsGOOGLE, sizeof(uint32_t));
@@ -38025,12 +26399,6 @@
memcpy(*streamPtrPtr, (uint64_t*)pPoolIds, (*(pPoolIdCount)) * sizeof(uint64_t));
*streamPtrPtr += (*(pPoolIdCount)) * sizeof(uint64_t);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkCollectDescriptorPoolIdsGOOGLE), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->read((uint32_t*)pPoolIdCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t* check_pPoolIds;
@@ -38053,33 +26421,6 @@
uint32_t waitSemaphoreCount,
const VkSemaphore* pWaitSemaphores,
VkImage image, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(queue:%p, waitSemaphoreCount:%d, "
"pWaitSemaphores:%p, image:%p)",
@@ -38117,8 +26458,6 @@
}
uint32_t packetSize_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -38126,7 +26465,6 @@
OP_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE, sizeof(uint32_t));
@@ -38160,13 +26498,6 @@
*&cgen_var_2 = get_host_u64_VkImage((*&local_image));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 1 * 8);
*streamPtrPtr += 1 * 8;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->flush();
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -38181,33 +26512,6 @@
VkDeviceMemory deviceMemory,
VkDeviceSize dataOffset,
VkDeviceSize dataSize, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkQueueFlushCommandsFromAuxMemoryGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkQueueFlushCommandsFromAuxMemoryGOOGLE(queue:%p, commandBuffer:%p, deviceMemory:%p, "
"dataOffset:%ld, dataSize:%ld)",
@@ -38242,8 +26546,6 @@
}
uint32_t packetSize_vkQueueFlushCommandsFromAuxMemoryGOOGLE =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkQueueFlushCommandsFromAuxMemoryGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueFlushCommandsFromAuxMemoryGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -38251,7 +26553,6 @@
OP_vkQueueFlushCommandsFromAuxMemoryGOOGLE;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkQueueFlushCommandsFromAuxMemoryGOOGLE, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkQueueFlushCommandsFromAuxMemoryGOOGLE, sizeof(uint32_t));
@@ -38276,13 +26577,6 @@
*streamPtrPtr += sizeof(VkDeviceSize);
memcpy(*streamPtrPtr, (VkDeviceSize*)&local_dataSize, sizeof(VkDeviceSize));
*streamPtrPtr += sizeof(VkDeviceSize);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkQueueFlushCommandsFromAuxMemoryGOOGLE),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->flush();
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -38293,33 +26587,6 @@
}
VkResult VkEncoder::vkGetBlobGOOGLE(VkDevice device, VkDeviceMemory memory, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetBlobGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetBlobGOOGLE(device:%p, memory:%p)", device, memory);
(void)doLock;
bool queueSubmitWithCommandsEnabled =
@@ -38343,14 +26610,12 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkGetBlobGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetBlobGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBlobGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetBlobGOOGLE = OP_vkGetBlobGOOGLE;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetBlobGOOGLE, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetBlobGOOGLE, sizeof(uint32_t));
@@ -38367,12 +26632,6 @@
*&cgen_var_1 = get_host_u64_VkDeviceMemory((*&local_memory));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- if (watchdog) {
- size_t watchdogBufSize =
- std::min<size_t>(static_cast<size_t>(packetSize_vkGetBlobGOOGLE), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkGetBlobGOOGLE_VkResult_return = (VkResult)0;
stream->read(&vkGetBlobGOOGLE_VkResult_return, sizeof(VkResult));
++encodeCount;
@@ -38392,34 +26651,6 @@
const uint32_t* pBufferViewEntryIndices, const VkDescriptorImageInfo* pImageInfos,
const VkDescriptorBufferInfo* pBufferInfos, const VkBufferView* pBufferViews,
const uint8_t* pInlineUniformBlockData, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor,
- "vkUpdateDescriptorSetWithTemplateSized2GOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG(
"vkUpdateDescriptorSetWithTemplateSized2GOOGLE(device:%p, descriptorSet:%p, "
"descriptorUpdateTemplate:%p, imageInfoCount:%d, bufferInfoCount:%d, bufferViewCount:%d, "
@@ -38557,8 +26788,6 @@
}
uint32_t packetSize_vkUpdateDescriptorSetWithTemplateSized2GOOGLE =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkUpdateDescriptorSetWithTemplateSized2GOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkUpdateDescriptorSetWithTemplateSized2GOOGLE);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
@@ -38566,7 +26795,6 @@
OP_vkUpdateDescriptorSetWithTemplateSized2GOOGLE;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkUpdateDescriptorSetWithTemplateSized2GOOGLE, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkUpdateDescriptorSetWithTemplateSized2GOOGLE, sizeof(uint32_t));
@@ -38674,13 +26902,6 @@
((inlineUniformBlockCount)) * sizeof(uint8_t));
*streamPtrPtr += ((inlineUniformBlockCount)) * sizeof(uint8_t);
}
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkUpdateDescriptorSetWithTemplateSized2GOOGLE),
- kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->flush();
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -38693,33 +26914,6 @@
void VkEncoder::vkQueueSubmitAsync2GOOGLE(VkQueue queue, uint32_t submitCount,
const VkSubmitInfo2* pSubmits, VkFence fence,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkQueueSubmitAsync2GOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkQueueSubmitAsync2GOOGLE(queue:%p, submitCount:%d, pSubmits:%p, fence:%p)",
queue, submitCount, pSubmits, fence);
(void)doLock;
@@ -38763,14 +26957,12 @@
}
uint32_t packetSize_vkQueueSubmitAsync2GOOGLE =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkQueueSubmitAsync2GOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueSubmitAsync2GOOGLE);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueSubmitAsync2GOOGLE = OP_vkQueueSubmitAsync2GOOGLE;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkQueueSubmitAsync2GOOGLE, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkQueueSubmitAsync2GOOGLE, sizeof(uint32_t));
@@ -38793,12 +26985,6 @@
*&cgen_var_1 = get_host_u64_VkFence((*&local_fence));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkQueueSubmitAsync2GOOGLE), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
stream->flush();
++encodeCount;
if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
@@ -38810,33 +26996,6 @@
VkResult VkEncoder::vkGetSemaphoreGOOGLE(VkDevice device, VkSemaphore semaphore, uint64_t syncId,
uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkGetSemaphoreGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
ENCODER_DEBUG_LOG("vkGetSemaphoreGOOGLE(device:%p, semaphore:%p, syncId:%ld)", device,
semaphore, syncId);
(void)doLock;
@@ -38862,14 +27021,12 @@
}
uint32_t packetSize_vkGetSemaphoreGOOGLE =
4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetSemaphoreGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetSemaphoreGOOGLE);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetSemaphoreGOOGLE = OP_vkGetSemaphoreGOOGLE;
uint32_t seqno;
if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkGetSemaphoreGOOGLE, sizeof(uint32_t));
streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkGetSemaphoreGOOGLE, sizeof(uint32_t));
@@ -38888,12 +27045,6 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint64_t*)&local_syncId, sizeof(uint64_t));
*streamPtrPtr += sizeof(uint64_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkGetSemaphoreGOOGLE), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
VkResult vkGetSemaphoreGOOGLE_VkResult_return = (VkResult)0;
stream->read(&vkGetSemaphoreGOOGLE_VkResult_return, sizeof(VkResult));
++encodeCount;
diff --git a/guest/vulkan_enc/VkEncoder.cpp.inl b/guest/vulkan_enc/VkEncoder.cpp.inl
index a6490d9..178ed4e 100644
--- a/guest/vulkan_enc/VkEncoder.cpp.inl
+++ b/guest/vulkan_enc/VkEncoder.cpp.inl
@@ -25,7 +25,6 @@
void log(const char* text) {
if (!m_logEncodes) return;
- ALOGD("encoder log: %s", text);
}
void flush() {
@@ -54,15 +53,8 @@
VkEncoder::~VkEncoder() {}
-struct EncoderAutoLock {
- EncoderAutoLock(VkEncoder* enc) : mEnc(enc) { mEnc->lock(); }
- ~EncoderAutoLock() { mEnc->unlock(); }
- VkEncoder* mEnc;
-};
-
-VkEncoder::VkEncoder(gfxstream::guest::IOStream* stream,
- gfxstream::guest::HealthMonitor<>* healthMonitor)
- : mImpl(new VkEncoder::Impl(stream)), mHealthMonitor(healthMonitor) {}
+VkEncoder::VkEncoder(gfxstream::guest::IOStream* stream)
+ : mImpl(new VkEncoder::Impl(stream)) {}
void VkEncoder::flush() { mImpl->flush(); }
diff --git a/guest/vulkan_enc/VkEncoder.h b/guest/vulkan_enc/VkEncoder.h
index 89728e3..d40042a 100644
--- a/guest/vulkan_enc/VkEncoder.h
+++ b/guest/vulkan_enc/VkEncoder.h
@@ -34,7 +34,6 @@
#include <memory>
-#include "aemu/base/AndroidHealthMonitor.h"
#include "goldfish_vk_private_defs.h"
#include "vk_android_native_buffer_gfxstream.h"
#include "vulkan_gfxstream.h"
@@ -50,8 +49,7 @@
class VkEncoder {
public:
- VkEncoder(gfxstream::guest::IOStream* stream,
- gfxstream::guest::HealthMonitor<>* healthMonitor = nullptr);
+ VkEncoder(gfxstream::guest::IOStream* stream);
~VkEncoder();
#include "VkEncoder.h.inl"
@@ -1032,7 +1030,6 @@
private:
class Impl;
std::unique_ptr<Impl> mImpl;
- gfxstream::guest::HealthMonitor<>* mHealthMonitor;
};
} // namespace vk
diff --git a/guest/vulkan_enc/func_table.h b/guest/vulkan_enc/func_table.h
deleted file mode 100644
index 370a866..0000000
--- a/guest/vulkan_enc/func_table.h
+++ /dev/null
@@ -1,222 +0,0 @@
-// Copyright (C) 2018 The Android Open Source Project
-// Copyright (C) 2018 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Autogenerated module func_table
-//
-// (header) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
-//
-// Please do not modify directly;
-// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
-// or directly from Python by defining:
-// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
-// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
-// CEREAL_OUTPUT_DIR: Where to put the generated sources.
-//
-// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
-// $CEREAL_OUTPUT_DIR
-//
-#pragma once
-#include <vulkan/vulkan.h>
-
-#include "vk_android_native_buffer_gfxstream.h"
-#include "vulkan_gfxstream.h"
-
-namespace gfxstream {
-namespace vk {
-
-#ifdef VK_VERSION_1_0
-#endif
-#ifdef VK_VERSION_1_1
-#endif
-#ifdef VK_VERSION_1_2
-#endif
-#ifdef VK_VERSION_1_3
-#endif
-#ifdef VK_KHR_surface
-#endif
-#ifdef VK_KHR_swapchain
-#endif
-#ifdef VK_KHR_xcb_surface
-#endif
-#ifdef VK_KHR_android_surface
-#endif
-#ifdef VK_KHR_win32_surface
-#endif
-#ifdef VK_KHR_dynamic_rendering
-#endif
-#ifdef VK_KHR_get_physical_device_properties2
-#endif
-#ifdef VK_KHR_maintenance1
-#endif
-#ifdef VK_KHR_external_memory_capabilities
-#endif
-#ifdef VK_KHR_external_memory
-#endif
-#ifdef VK_KHR_external_memory_win32
-#endif
-#ifdef VK_KHR_external_memory_fd
-#endif
-#ifdef VK_KHR_external_semaphore_capabilities
-#endif
-#ifdef VK_KHR_external_semaphore
-#endif
-#ifdef VK_KHR_external_semaphore_win32
-#endif
-#ifdef VK_KHR_external_semaphore_fd
-#endif
-#ifdef VK_KHR_shader_float16_int8
-#endif
-#ifdef VK_KHR_incremental_present
-#endif
-#ifdef VK_KHR_descriptor_update_template
-#endif
-#ifdef VK_KHR_imageless_framebuffer
-#endif
-#ifdef VK_KHR_create_renderpass2
-#endif
-#ifdef VK_KHR_external_fence_capabilities
-#endif
-#ifdef VK_KHR_external_fence
-#endif
-#ifdef VK_KHR_external_fence_fd
-#endif
-#ifdef VK_KHR_maintenance2
-#endif
-#ifdef VK_KHR_dedicated_allocation
-#endif
-#ifdef VK_KHR_storage_buffer_storage_class
-#endif
-#ifdef VK_KHR_get_memory_requirements2
-#endif
-#ifdef VK_KHR_image_format_list
-#endif
-#ifdef VK_KHR_sampler_ycbcr_conversion
-#endif
-#ifdef VK_KHR_bind_memory2
-#endif
-#ifdef VK_KHR_maintenance3
-#endif
-#ifdef VK_KHR_shader_subgroup_extended_types
-#endif
-#ifdef VK_KHR_vulkan_memory_model
-#endif
-#ifdef VK_KHR_shader_terminate_invocation
-#endif
-#ifdef VK_KHR_buffer_device_address
-#endif
-#ifdef VK_KHR_pipeline_executable_properties
-#endif
-#ifdef VK_KHR_shader_integer_dot_product
-#endif
-#ifdef VK_KHR_shader_non_semantic_info
-#endif
-#ifdef VK_KHR_synchronization2
-#endif
-#ifdef VK_KHR_zero_initialize_workgroup_memory
-#endif
-#ifdef VK_KHR_copy_commands2
-#endif
-#ifdef VK_KHR_format_feature_flags2
-#endif
-#ifdef VK_KHR_maintenance4
-#endif
-#ifdef VK_KHR_maintenance5
-#endif
-#ifdef VK_ANDROID_native_buffer
-#endif
-#ifdef VK_EXT_transform_feedback
-#endif
-#ifdef VK_AMD_gpu_shader_half_float
-#endif
-#ifdef VK_EXT_texture_compression_astc_hdr
-#endif
-#ifdef VK_EXT_swapchain_colorspace
-#endif
-#ifdef VK_EXT_queue_family_foreign
-#endif
-#ifdef VK_EXT_debug_utils
-#endif
-#ifdef VK_ANDROID_external_memory_android_hardware_buffer
-#endif
-#ifdef VK_EXT_inline_uniform_block
-#endif
-#ifdef VK_EXT_shader_stencil_export
-#endif
-#ifdef VK_EXT_vertex_attribute_divisor
-#endif
-#ifdef VK_EXT_pipeline_creation_feedback
-#endif
-#ifdef VK_NV_shader_subgroup_partitioned
-#endif
-#ifdef VK_EXT_metal_surface
-#endif
-#ifdef VK_EXT_scalar_block_layout
-#endif
-#ifdef VK_EXT_subgroup_size_control
-#endif
-#ifdef VK_EXT_tooling_info
-#endif
-#ifdef VK_EXT_provoking_vertex
-#endif
-#ifdef VK_EXT_line_rasterization
-#endif
-#ifdef VK_EXT_index_type_uint8
-#endif
-#ifdef VK_EXT_extended_dynamic_state
-#endif
-#ifdef VK_EXT_host_image_copy
-#endif
-#ifdef VK_EXT_swapchain_maintenance1
-#endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-#endif
-#ifdef VK_EXT_texel_buffer_alignment
-#endif
-#ifdef VK_EXT_device_memory_report
-#endif
-#ifdef VK_EXT_custom_border_color
-#endif
-#ifdef VK_EXT_private_data
-#endif
-#ifdef VK_EXT_pipeline_creation_cache_control
-#endif
-#ifdef VK_EXT_graphics_pipeline_library
-#endif
-#ifdef VK_EXT_ycbcr_2plane_444_formats
-#endif
-#ifdef VK_EXT_image_robustness
-#endif
-#ifdef VK_EXT_image_compression_control
-#endif
-#ifdef VK_EXT_4444_formats
-#endif
-#ifdef VK_EXT_primitive_topology_list_restart
-#endif
-#ifdef VK_EXT_extended_dynamic_state2
-#endif
-#ifdef VK_GOOGLE_gfxstream
-#endif
-#ifdef VK_EXT_load_store_op_none
-#endif
-#ifdef VK_EXT_image_compression_control_swapchain
-#endif
-void* goldfish_vulkan_get_proc_address(const char* name);
-void* goldfish_vulkan_get_instance_proc_address(VkInstance instance, const char* name);
-void* goldfish_vulkan_get_device_proc_address(VkDevice device, const char* name);
-
-} // namespace vk
-} // namespace gfxstream
diff --git a/guest/vulkan_enc/vkQueueFlushCommandsGOOGLE_encode_impl.cpp.inl b/guest/vulkan_enc/vkQueueFlushCommandsGOOGLE_encode_impl.cpp.inl
index 8e27e9c..75fb7a8 100644
--- a/guest/vulkan_enc/vkQueueFlushCommandsGOOGLE_encode_impl.cpp.inl
+++ b/guest/vulkan_enc/vkQueueFlushCommandsGOOGLE_encode_impl.cpp.inl
@@ -27,14 +27,11 @@
}
bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
uint32_t packetSize_vkQueueFlushCommandsGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
-healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkQueueFlushCommandsGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueFlushCommandsGOOGLE - local_dataSize);
uint8_t* packetBeginPtr = streamPtr;
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueFlushCommandsGOOGLE = OP_vkQueueFlushCommandsGOOGLE;
uint32_t seqno = ResourceTracker::nextSeqno();
-healthMonitorAnnotation_seqno = std::make_optional(seqno);
memcpy(streamPtr, &opcode_vkQueueFlushCommandsGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &packetSize_vkQueueFlushCommandsGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
@@ -48,12 +45,6 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkDeviceSize*)&local_dataSize, sizeof(VkDeviceSize));
*streamPtrPtr += sizeof(VkDeviceSize);
-if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkQueueFlushCommandsGOOGLE), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
-}
MESA_TRACE_SCOPE("vkQueueFlush large xfer");
stream->flush();
diff --git a/guest/vulkan_enc_unit_tests/Android.bp b/guest/vulkan_enc_unit_tests/Android.bp
deleted file mode 100644
index 225c18b..0000000
--- a/guest/vulkan_enc_unit_tests/Android.bp
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (C) 2023 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package {
- default_team: "trendy_team_android_developer_tools",
- // See: http://go/android-license-faq
- default_applicable_licenses: ["hardware_google_gfxstream_license"],
-}
-
-cc_test {
- name: "CommandBufferStagingStreamTests",
- vendor: true,
- defaults: [
- "libgfxstream_guest_cc_defaults",
- ],
- srcs: [
- "CommandBufferStagingStream_test.cpp",
- ],
- header_libs: [
- "libgfxstream_vulkan_headers",
- "libgfxstream_guest_iostream",
- ],
- shared_libs: [
- "liblog",
- "libcutils",
- ],
- static_libs: [
- "libgmock",
- "libvulkan_enc",
- "libmesa_util_gfxstream",
- ],
-}
diff --git a/guest/vulkan_enc_unit_tests/CommandBufferStagingStream_test.cpp b/guest/vulkan_enc_unit_tests/CommandBufferStagingStream_test.cpp
deleted file mode 100644
index dc18142..0000000
--- a/guest/vulkan_enc_unit_tests/CommandBufferStagingStream_test.cpp
+++ /dev/null
@@ -1,730 +0,0 @@
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-#include <CommandBufferStagingStream.h>
-#include <string.h>
-
-#include <condition_variable>
-#include <mutex>
-#include <string_view>
-#include <thread>
-
-namespace gfxstream {
-namespace vk {
-
-using ::testing::A;
-using ::testing::ElementsAre;
-using ::testing::Eq;
-using ::testing::Ge;
-using ::testing::InSequence;
-using ::testing::IsNull;
-using ::testing::MockFunction;
-using ::testing::NotNull;
-using ::testing::Return;
-
-static constexpr size_t kTestBufferSize = 1048576;
-
-// tests allocBuffer can successfully allocate a buffer of given size
-TEST(CommandBufferStagingStreamTest, AllocateBufferTestUnderMinSize) {
- CommandBufferStagingStream stream;
- uint8_t* buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
- EXPECT_THAT(buffer, NotNull());
-}
-
-// test reallocate buffer remembers previously committed buffers
-TEST(CommandBufferStagingStreamTest, ReallocateBuffer) {
- CommandBufferStagingStream stream;
- uint8_t* buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
- EXPECT_THAT(buffer, NotNull());
-
- // write some data
- const std::string_view commandData{"some command"};
- const size_t dataSize = commandData.size();
- memcpy(buffer, commandData.data(), dataSize);
-
- // commit data
- stream.commitBuffer(dataSize);
-
- // this will result in a reallocation
- buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
- EXPECT_THAT(buffer, NotNull());
-
- // get stream data
- uint8_t* outBuf = nullptr;
- size_t outSize = 0;
- stream.getWritten(&outBuf, &outSize);
-
- std::string_view actualData{reinterpret_cast<char*>(outBuf), outSize};
- EXPECT_THAT(actualData, Eq(commandData));
-}
-
-// tests commitBuffer tracks the portion of the buffer to be committed
-TEST(CommandBufferStagingStreamTest, CommitBuffer) {
- CommandBufferStagingStream stream;
- // allocate buffer
- uint8_t* buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
-
- // write some arbitrary data
- const std::string_view commandData{"some command"};
- const size_t dataSize = commandData.size();
- memcpy(buffer, commandData.data(), dataSize);
-
- // commit
- stream.commitBuffer(dataSize);
-
- // writeBuffer should have the committed portion in CommandBufferStagingStream
- uint8_t* outBuf = nullptr;
- size_t outSize = 0;
- stream.getWritten(&outBuf, &outSize);
-
- std::string_view actualData{reinterpret_cast<char*>(outBuf), outSize};
- EXPECT_THAT(actualData, Eq(commandData));
-}
-
-// tests reset api
-TEST(CommandBufferStagingStreamTest, Reset) {
- CommandBufferStagingStream stream;
- // allocate buffer
- uint8_t* buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
-
- // write some arbitrary data
- const std::string_view commandData{"some command"};
- const size_t dataSize = commandData.size();
- memcpy(buffer, commandData.data(), dataSize);
-
- // commit
- stream.commitBuffer(dataSize);
-
- // reset
- stream.reset();
-
- size_t outSize;
- unsigned char* outBuf;
- // write buffer
- stream.getWritten(&outBuf, &outSize);
-
- // outSize should be 0 after reset
- EXPECT_EQ(outSize, 0) << "no data should be available for a write after a reset";
-}
-
-// tests that multiple alloc calls do not result in reallocations
-TEST(CommandBufferStagingStreamTest, MultipleAllocationCalls) {
- CommandBufferStagingStream stream;
- uint8_t* buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
- EXPECT_THAT(buffer, NotNull());
-
- // another call to allocBuffer should not result in reallocations
- uint8_t* anotherBuffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
- EXPECT_THAT(anotherBuffer, Eq(buffer));
-}
-
-// this test verifies that allocBuffer doesn't cause reallcation if buffer has available space
-TEST(CommandBufferStagingStream, NoReallocationIfBufferIsNotFull) {
- CommandBufferStagingStream stream;
- uint8_t* buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
- EXPECT_THAT(buffer, NotNull());
-
- // commit portion of buffer
- const size_t writeSize = 10;
- stream.commitBuffer(writeSize);
-
- uint8_t* writePtr = static_cast<uint8_t*>(stream.allocBuffer(writeSize));
- EXPECT_THAT(writePtr, buffer + writeSize);
-}
-
-// tests that data written prior to reallocation is still intact
-TEST(CommandBufferStagingStreamTest, ReallocationBoundary) {
- CommandBufferStagingStream stream;
- uint8_t* buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
- EXPECT_THAT(buffer, NotNull());
-
- // split data into two batches
- const std::string firstBatchData(kTestBufferSize, 'a');
-
- // copy first batch of data into stream
- memcpy(buffer, firstBatchData.data(), kTestBufferSize);
-
- // commit first batch of data
- stream.commitBuffer(firstBatchData.size());
-
- // size of first batch of data brings stream buffer to capacity; this will result in a
- // reallocation
- buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
- EXPECT_THAT(buffer, NotNull());
-
- // data written before reallocation should be intact
- unsigned char* outBuf = nullptr;
- size_t outSize = 0;
- stream.getWritten(&outBuf, &outSize);
-
- const std::string_view expectedData{firstBatchData};
- std::string_view actualData{reinterpret_cast<char*>(outBuf), outSize};
- EXPECT_THAT(actualData, Eq(expectedData));
-}
-
-// this test is a death test for unsupported apis
-TEST(CommandBufferStagingStreamDeathTest, UnsupportedAPIs) {
- CommandBufferStagingStream stream;
-
- EXPECT_DEATH(
- {
- void* buffer = nullptr;
- size_t size = 0;
- stream.readFully(buffer, size);
- },
- "")
- << "readFully should not be supported";
-
- EXPECT_DEATH(
- {
- void* buffer = nullptr;
- size_t size = 0;
- stream.read(buffer, &size);
- },
- "")
- << "read should not be supported";
-
- EXPECT_DEATH(
- {
- void* buffer = nullptr;
- size_t size = 0;
- stream.writeFully(buffer, size);
- },
- "")
- << "writeFully should not be supported";
-
- EXPECT_DEATH(
- {
- void* buffer = nullptr;
- size_t size = 0;
- size_t len = 0;
- stream.commitBufferAndReadFully(size, buffer, len);
- },
- "")
- << "commitBufferAndReadFully should not be supported";
-}
-
-using MockAlloc = MockFunction<CommandBufferStagingStream::Memory(size_t)>;
-using MockFree = MockFunction<void(const CommandBufferStagingStream::Memory&)>;
-// default empty implementation of free
-static std::function<void(const CommandBufferStagingStream::Memory&)> EmptyFree =
- [](const CommandBufferStagingStream::Memory&) {};
-// CommandBufferStagingStreamCustomAllocationTest tests behavior of CommandBufferStagingStream
-// when initialized with custom allocator/free function.
-// These tests test the same outcome as CommandBufferStagingStreamTest tests
-
-// tests allocBuffer can successfully allocate a buffer of given size
-TEST(CommandBufferStagingStreamCustomAllocationTest, AllocateBufferTest) {
- // memory source
- std::vector<uint8_t> memorySrc(kTestBufferSize * 2);
-
- CommandBufferStagingStream::Memory memory{
- .deviceMemory = VK_NULL_HANDLE, // not needed for this test
- .ptr = memorySrc.data()};
-
- MockAlloc allocFn;
-
- // alloc function should be called once
- EXPECT_CALL(allocFn, Call(Ge(kTestBufferSize))).Times(1).WillRepeatedly(Return(memory));
-
- // free function should be called once
- MockFree freeFn;
- EXPECT_CALL(freeFn, Call(Eq(memory))).Times(1);
-
- // scope: CommandBufferStagingStream_Creation
- {
- auto allocStdFn = allocFn.AsStdFunction();
- auto freeStdFn = freeFn.AsStdFunction();
- CommandBufferStagingStream stream(allocStdFn, freeStdFn);
- uint8_t* buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
- EXPECT_THAT(buffer, NotNull());
- }
-}
-
-// test allocBuffer returns nullptr if custom allocation fails
-TEST(CommandBufferStagingStreamCustomAllocationTest, AllocateBufferFailure) {
- // memory source for initial allocation
- std::vector<uint8_t> memorySrc(kTestBufferSize * 2);
-
- CommandBufferStagingStream::Memory memory{
- .deviceMemory = VK_NULL_HANDLE, // not needed for this test
- .ptr = nullptr, // to test alloc call failing
- };
-
- MockAlloc allocFn;
-
- // alloc function should be called once
- EXPECT_CALL(allocFn, Call(Ge(kTestBufferSize))).Times(1).WillRepeatedly(Return(memory));
-
- // free function should not be called if allocation fails
- MockFree freeFn;
- EXPECT_CALL(freeFn, Call).Times(0);
-
- // scope: CommandBufferStagingStream_Creation
- {
- auto allocStdFn = allocFn.AsStdFunction();
- auto freeStdFn = freeFn.AsStdFunction();
- CommandBufferStagingStream stream(allocStdFn, freeStdFn);
- void* buffer = stream.allocBuffer(kTestBufferSize);
- EXPECT_THAT(buffer, IsNull());
- }
-}
-
-TEST(CommandBufferStagingStreamCustomAllocationTest, DeviceMemoryPointerIsPassedDuringFree) {
- // memory source
- std::vector<uint8_t> memorySrc(kTestBufferSize * 2);
-
- // device memory for test purposes. The test just needs a pointer
- uint64_t deviceMem = 0;
- VkDeviceMemory deviceMemPtr = (VkDeviceMemory)(&deviceMem);
-
- CommandBufferStagingStream::Memory memory{.deviceMemory = deviceMemPtr,
- .ptr = memorySrc.data()};
-
- MockAlloc allocFn;
-
- // alloc function should be called once
- EXPECT_CALL(allocFn, Call(Ge(kTestBufferSize))).Times(1).WillRepeatedly(Return(memory));
-
- // free function should be called once
- MockFree freeFn;
- EXPECT_CALL(freeFn, Call(Eq(memory))).Times(1);
-
- // scope: CommandBufferStagingStream_Creation
- {
- auto allocStdFn = allocFn.AsStdFunction();
- auto freeStdFn = freeFn.AsStdFunction();
- CommandBufferStagingStream stream(allocStdFn, freeStdFn);
- uint8_t* buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
- EXPECT_THAT(buffer, NotNull());
- }
-}
-
-// test verifies that there are no crashes if alloc/free function reference becomes null
-TEST(CommandBufferStagingStreamCustomAllocationTest, AllocFreeInvalidReference) {
- MockAlloc allocFn;
- // alloc shouldn't be called if reference is invalidated
- EXPECT_CALL(allocFn, Call).Times(0);
-
- MockFree freeFn;
- // free shouldn't be called if reference is invalidated
- EXPECT_CALL(freeFn, Call).Times(0);
-
- auto allocStdFn = allocFn.AsStdFunction();
- auto freeStdFn = freeFn.AsStdFunction();
- // scope: CommandBufferStagingStream_Creation
- {
- CommandBufferStagingStream stream(allocStdFn, freeStdFn);
- // invalidate alloc/free functions
- allocStdFn = nullptr;
- freeStdFn = nullptr;
- stream.allocBuffer(kTestBufferSize);
- uint8_t* buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
- EXPECT_THAT(buffer, IsNull());
- }
-}
-
-// test reallocate buffer remembers previously committed buffers
-TEST(CommandBufferStagingStreamCustomAllocationTest, ReallocateBuffer) {
- // memory source for initial allocation
- std::vector<uint8_t> memorySrc(kTestBufferSize * 2);
- // memory source after reallocation
- std::vector<uint8_t> reallocatedMemorySrc(kTestBufferSize * 3);
-
- CommandBufferStagingStream::Memory memory{
- .deviceMemory = VK_NULL_HANDLE, // not needed for this test
- .ptr = memorySrc.data()};
-
- CommandBufferStagingStream::Memory reallocatedMemory{
- .deviceMemory = VK_NULL_HANDLE, // not needed for this test
- .ptr = reallocatedMemorySrc.data()};
-
- MockAlloc allocFn;
-
- // alloc function should be called twice
- {
- InSequence seq;
-
- // expect initial allocation call with allocation size == kTestBufferSize;
- EXPECT_CALL(allocFn, Call(Ge(kTestBufferSize))).Times(1).WillRepeatedly(Return(memory));
-
- // expect reallocation call with allocation size > kTestBufferSize.
- EXPECT_CALL(allocFn, Call(testing::Ge(kTestBufferSize)))
- .Times(1)
- .WillRepeatedly(Return(reallocatedMemory));
- }
-
- MockFree freeFn;
- {
- InSequence seq;
- // free function should be called when reallocation happens
- EXPECT_CALL(freeFn, Call(Eq(memory))).Times(1);
- // free function should be called when stream goes out of scope
- EXPECT_CALL(freeFn, Call(Eq(reallocatedMemory))).Times(1);
- }
-
- // scope: CommandBufferStagingStream_Creation
- {
- auto allocStdFn = allocFn.AsStdFunction();
- auto freeStdFn = freeFn.AsStdFunction();
- CommandBufferStagingStream stream(allocStdFn, freeStdFn);
- uint8_t* buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
- EXPECT_THAT(buffer, NotNull());
-
- // write some data
- const std::string_view commandData{"some command"};
- const size_t dataSize = commandData.size();
- memcpy(buffer, commandData.data(), dataSize);
-
- // commit data
- stream.commitBuffer(dataSize);
-
- // this will result in a reallocation
- buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
- EXPECT_THAT(buffer, NotNull());
-
- // get stream data
- unsigned char* outBuf = nullptr;
- size_t outSize = 0;
- stream.getWritten(&outBuf, &outSize);
-
- std::string_view actualData{reinterpret_cast<char*>(outBuf), outSize};
- EXPECT_THAT(actualData, Eq(commandData));
- }
-}
-
-// tests commitBuffer tracks the portion of the buffer to be committed
-TEST(CommandBufferStagingStreamCustomAllocationTest, CommitBuffer) {
- // memory source
- std::vector<uint8_t> memorySrc(kTestBufferSize * 2);
-
- CommandBufferStagingStream::Memory memory{
- .deviceMemory = VK_NULL_HANDLE, // not needed for this test
- .ptr = memorySrc.data()};
-
- MockAlloc allocFn;
-
- // alloc function should be called once
- EXPECT_CALL(allocFn, Call(Ge(kTestBufferSize))).Times(1).WillRepeatedly(Return(memory));
- auto allocStdFn = allocFn.AsStdFunction();
- CommandBufferStagingStream stream(allocStdFn, EmptyFree);
- uint8_t* buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
- EXPECT_THAT(buffer, NotNull());
-
- // write some arbitrary data
- const std::string_view commandData{"some command"};
- const size_t dataSize = commandData.size();
- memcpy(buffer, commandData.data(), dataSize);
-
- // commit
- stream.commitBuffer(dataSize);
-
- // writeBuffer should have the committed portion in CommandBufferStagingStream
- uint8_t* outBuf = nullptr;
- size_t outSize = 0;
- stream.getWritten(&outBuf, &outSize);
-
- std::string_view actualData{reinterpret_cast<char*>(outBuf), outSize};
- EXPECT_THAT(actualData, Eq(commandData));
-}
-
-// tests reset api
-TEST(CommandBufferStagingStreamCustomAllocationTest, Reset) {
- // memory source
- std::vector<uint8_t> memorySrc(kTestBufferSize * 2);
-
- CommandBufferStagingStream::Memory memory{
- .deviceMemory = VK_NULL_HANDLE, // not needed for this test
- .ptr = memorySrc.data()};
-
- MockAlloc allocFn;
-
- // alloc function should be called once
- EXPECT_CALL(allocFn, Call(Ge(kTestBufferSize))).Times(1).WillRepeatedly(Return(memory));
- auto allocStdFn = allocFn.AsStdFunction();
- CommandBufferStagingStream stream(allocStdFn, EmptyFree);
- uint8_t* buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
-
- // write some arbitrary data
- const std::string_view commandData{"some command"};
- const size_t dataSize = commandData.size();
- memcpy(buffer, commandData.data(), dataSize);
-
- // commit
- stream.commitBuffer(dataSize);
-
- // reset
- stream.reset();
-
- size_t outSize;
- unsigned char* outBuf;
- // write buffer
- stream.getWritten(&outBuf, &outSize);
-
- // outSize should be 0 after reset
- EXPECT_EQ(outSize, 0) << "no data should be available for a write after a reset";
-}
-
-// tests that multiple alloc calls do not result in reallocations
-TEST(CommandBufferStagingStreamCustomAllocationTest, MultipleAllocationCalls) {
- // memory source
- std::vector<uint8_t> memorySrc(kTestBufferSize * 2);
-
- CommandBufferStagingStream::Memory memory{
- .deviceMemory = VK_NULL_HANDLE, // not needed for this test
- .ptr = memorySrc.data()};
-
- MockAlloc allocFn;
-
- // alloc function should be called once, no reallocation
- EXPECT_CALL(allocFn, Call(Ge(kTestBufferSize))).Times(1).WillRepeatedly(Return(memory));
-
- auto allocStdFn = allocFn.AsStdFunction();
- CommandBufferStagingStream stream(allocStdFn, EmptyFree);
- uint8_t* buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
- EXPECT_THAT(buffer, NotNull());
-
- // another call to allocBuffer should not result in reallocations
- uint8_t* anotherBuffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
- EXPECT_THAT(anotherBuffer, Eq(buffer));
-}
-
-// tests that data written prior to reallocation is still intact
-TEST(CommandBufferStagingStreamCustomAllocationTest, ReallocationBoundary) {
- // memory source
- std::vector<uint8_t> memorySrc(kTestBufferSize * 3);
- CommandBufferStagingStream::Memory memory{
- .deviceMemory = VK_NULL_HANDLE, // not needed for this test
- .ptr = memorySrc.data()};
-
- MockAlloc allocFn;
-
- // alloc function should be called twice
- {
- InSequence seq;
-
- // expect initial allocation call with allocation size >= kTestBufferSize;
- EXPECT_CALL(allocFn, Call(Ge(kTestBufferSize))).Times(1).WillRepeatedly(Return(memory));
-
- // expect reallocation call with allocation size > kTestBufferSize.
- EXPECT_CALL(allocFn, Call(testing::Ge(kTestBufferSize)))
- .Times(1)
- .WillRepeatedly(Return(memory));
- }
-
- // free function should be called once during reallocation,
- // once when stream goes out of scope
- MockFree freeFn;
-
- EXPECT_CALL(freeFn, Call(Eq(memory))).Times(2);
- auto allocStdFn = allocFn.AsStdFunction();
- auto freeStdFn = freeFn.AsStdFunction();
- CommandBufferStagingStream stream(allocStdFn, freeStdFn);
- uint8_t* buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
- EXPECT_THAT(buffer, NotNull());
-
- // split data into two batches
- // size of first batch data should be enough to fill the allocated buffer
- // first data batch size = kTestBufferSize - sync data size
- const std::string firstBatchData(kTestBufferSize - CommandBufferStagingStream::kSyncDataSize,
- 'a');
-
- // copy first batch of data into stream
- memcpy(buffer, firstBatchData.data(), firstBatchData.size());
-
- // commit first batch of data
- stream.commitBuffer(firstBatchData.size());
-
- // size of first batch of data brings stream buffer to capacity; this will result in a
- // reallocation
- buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
- EXPECT_THAT(buffer, NotNull());
-
- // data written before reallocation should be intact
- unsigned char* outBuf = nullptr;
- size_t outSize = 0;
- stream.getWritten(&outBuf, &outSize);
-
- const std::string_view expectedData{firstBatchData};
- std::string_view actualData{reinterpret_cast<char*>(outBuf), outSize};
- EXPECT_THAT(actualData, Eq(expectedData));
-}
-
-// this test verifies that allocBuffer doesn't cause reallcation if buffer has available space
-TEST(CommandBufferStagingStreamCustomAllocationTest, NoReallocationIfBufferIsNotFull) {
- // memory source
- std::vector<uint8_t> memorySrc(kTestBufferSize * 3);
-
- CommandBufferStagingStream::Memory memory{
- .deviceMemory = VK_NULL_HANDLE, // not needed for this test
- .ptr = memorySrc.data()};
-
- MockAlloc allocFn;
- EXPECT_CALL(allocFn, Call(Ge(kTestBufferSize))).Times(1).WillRepeatedly(Return(memory));
-
- auto allocStdFn = allocFn.AsStdFunction();
- CommandBufferStagingStream stream(allocStdFn, EmptyFree);
- uint8_t* buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
- EXPECT_THAT(buffer, NotNull());
-
- // commit portion of buffer
- const size_t writeSize = 10;
- stream.commitBuffer(writeSize);
-
- uint8_t* writePtr = static_cast<uint8_t*>(stream.allocBuffer(writeSize));
- EXPECT_THAT(writePtr, buffer + writeSize);
-}
-
-// this test verifies that CommandBufferStagingStream accounts for metadata in the
-// beginning of its stream buffer
-TEST(CommandBufferStagingStreamCustomAllocationTest, MetadataCheck) {
- // memory source
- std::vector<uint8_t> memorySrc(kTestBufferSize * 2);
- CommandBufferStagingStream::Memory memory{
- .deviceMemory = VK_NULL_HANDLE, // not needed for this test
- .ptr = memorySrc.data()};
-
- // CommandBufferStagingStream allocates metadata when using custom allocators
- static const size_t expectedMetadataSize = 8;
- MockAlloc allocFn;
-
- EXPECT_CALL(allocFn, Call(Ge(kTestBufferSize))).Times(1).WillRepeatedly(Return(memory));
-
- auto allocStdFn = allocFn.AsStdFunction();
- CommandBufferStagingStream stream(allocStdFn, EmptyFree);
- uint8_t* buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
- // data should start after metadata
- EXPECT_THAT(buffer, memorySrc.data() + expectedMetadataSize);
- // metadata should be initialized to read complete
- uint32_t* metadataPtr = reinterpret_cast<uint32_t*>(memorySrc.data());
- EXPECT_THAT(*metadataPtr, CommandBufferStagingStream::kSyncDataReadComplete);
-}
-
-TEST(CommandBufferStagingStreamCustomAllocationTest, MarkFlushing) {
- // memory source for allocation
- std::vector<uint8_t> memorySrc(kTestBufferSize * 2);
- CommandBufferStagingStream::Memory memory{
- .deviceMemory = VK_NULL_HANDLE, // not needed for this test
- .ptr = memorySrc.data()};
- MockAlloc allocFn;
-
- EXPECT_CALL(allocFn, Call(Ge(kTestBufferSize))).Times(1).WillRepeatedly(Return(memory));
-
- auto allocStdFn = allocFn.AsStdFunction();
- CommandBufferStagingStream stream(allocStdFn, EmptyFree);
- uint8_t* buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
-
- // write some data
- const std::string_view commandData{"some command"};
- const size_t dataSize = commandData.size();
- memcpy(buffer, commandData.data(), dataSize);
-
- // commit data
- stream.commitBuffer(dataSize);
-
- // will set metadata of the stream buffer to pending read
- stream.markFlushing();
-
- uint32_t* readPtr = reinterpret_cast<uint32_t*>(memorySrc.data());
- EXPECT_EQ(*readPtr, CommandBufferStagingStream::kSyncDataReadPending);
-}
-
-// this test verifies that realloc waits till consumer of memory has completed read
-TEST(CommandBufferStagingStreamCustomAllocationTest, ReallocNotCalledTillBufferIsRead) {
- // memory source for allocation
- // allocate a big enough buffer to avoid resizes in test
- std::vector<uint8_t> memorySrc(kTestBufferSize * 3);
- CommandBufferStagingStream::Memory memory{
- .deviceMemory = VK_NULL_HANDLE, // not needed for this test
- .ptr = memorySrc.data()};
-
- std::condition_variable memoryFlushedCondition;
- std::mutex mutex;
-
- MockAlloc allocFn;
-
- // mock function to notify read is complete
- // this will be used to set up the expectation that realloc should
- // not be called till read is complete
- MockFunction<void(void)> readCompleteCall;
-
- testing::Expectation readCompleteExpectation = EXPECT_CALL(readCompleteCall, Call).Times(1);
-
- std::thread consumer([&]() {
- std::unique_lock readLock(mutex);
- memoryFlushedCondition.wait(readLock, [&]() {
- // wait till memorySrc is ready for read
- uint32_t* syncData = static_cast<uint32_t*>(memory.ptr);
- return *syncData = CommandBufferStagingStream::kSyncDataReadPending;
- });
-
- readLock.unlock();
-
- __atomic_store_n(memorySrc.data(), CommandBufferStagingStream::kSyncDataReadComplete,
- __ATOMIC_RELEASE);
-
- auto fn = readCompleteCall.AsStdFunction();
- fn();
- });
-
- auto allocStdFn = allocFn.AsStdFunction();
- CommandBufferStagingStream stream(allocStdFn, EmptyFree); // scope for writeLock
- {
- std::lock_guard writeLock(mutex);
-
- EXPECT_CALL(allocFn, Call(Ge(kTestBufferSize))).Times(1).WillRepeatedly(Return(memory));
-
- uint8_t* buffer = static_cast<uint8_t*>(stream.allocBuffer(kTestBufferSize));
-
- // write some data
- const std::string_view commandData{"some command"};
- const size_t dataSize = commandData.size();
- memcpy(buffer, commandData.data(), dataSize);
-
- // commit data
- stream.commitBuffer(dataSize);
-
- // will set metadata of the stream buffer to pending read
- stream.markFlushing();
-
- memoryFlushedCondition.notify_one();
- }
-
- // expecatation call for reallocation call
- EXPECT_CALL(allocFn, Call(testing::Ge(kTestBufferSize)))
- .Times(1)
- .After(readCompleteExpectation)
- .WillRepeatedly(Return(memory));
-
- // realloc will be blocked till buffer read is complete by reader
- (void)stream.allocBuffer(kTestBufferSize);
-
- // wait for read thread to finish
- consumer.join();
-}
-
-// this test verifies that allocBuffer() cannot be called on a stream
-// that is currently being read by the host
-TEST(CommandBufferStagingStreamCustomAllocationTest, AllocBufferFailsIfReadPending) {
- // memory source for allocation
- std::vector<uint8_t> memorySrc(kTestBufferSize * 2);
- CommandBufferStagingStream::Memory memory{
- .deviceMemory = VK_NULL_HANDLE, // not needed for this test
- .ptr = memorySrc.data()};
- MockAlloc allocFn;
-
- EXPECT_CALL(allocFn, Call(Ge(kTestBufferSize))).Times(1).WillRepeatedly(Return(memory));
-
- auto allocStdFn = allocFn.AsStdFunction();
- CommandBufferStagingStream stream(allocStdFn, EmptyFree);
- (void)stream.allocBuffer(kTestBufferSize);
-
- // will set metadata of the stream buffer to pending read
- stream.markFlushing();
-
- EXPECT_DEATH({ (void)stream.allocBuffer(kTestBufferSize); }, "")
- << "allocBuffer() should not be called while previous data is being flushed";
-}
-
-} // namespace vk
-} // namespace gfxstream
diff --git a/host/ColorBuffer.cpp b/host/ColorBuffer.cpp
index 2b68fbf..96ae654 100644
--- a/host/ColorBuffer.cpp
+++ b/host/ColorBuffer.cpp
@@ -226,14 +226,20 @@
if (mColorBufferGl) {
mColorBufferGl->subUpdateFromFrameworkFormat(x, y, width, height, frameworkFormat,
pixelsFormat, pixelsType, pixels, metadata);
+ flushFromGl();
+ return true;
}
#endif
if (mColorBufferVk) {
- return mColorBufferVk->updateFromBytes(x, y, width, height, pixels);
+ bool success = mColorBufferVk->updateFromBytes(x, y, width, height, pixels);
+ if (!success) return success;
+ flushFromVk();
+ return true;
}
- return true;
+ GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "No ColorBuffer impl?";
+ return false;
}
bool ColorBuffer::updateFromBytes(int x, int y, int width, int height, GLenum pixelsFormat,
@@ -242,7 +248,11 @@
#if GFXSTREAM_ENABLE_HOST_GLES
if (mColorBufferGl) {
- return mColorBufferGl->subUpdate(x, y, width, height, pixelsFormat, pixelsType, pixels);
+ bool res = mColorBufferGl->subUpdate(x, y, width, height, pixelsFormat, pixelsType, pixels);
+ if (res) {
+ flushFromGl();
+ }
+ return res;
}
#endif
@@ -319,6 +329,7 @@
// ColorBufferGl is currently considered the "main" backing. If this changes,
// the "main" should be updated from the current contents of the GL backing.
+ mGlTexDirty = true;
return true;
}
@@ -346,7 +357,7 @@
return false;
}
#endif
-
+ mGlTexDirty = false;
return true;
}
@@ -367,7 +378,7 @@
}
}
#endif
-
+ mGlTexDirty = false;
return true;
}
@@ -394,6 +405,10 @@
return true;
}
+ if (!mGlTexDirty) {
+ return true;
+ }
+
#if GFXSTREAM_ENABLE_HOST_GLES
std::size_t contentsSize = 0;
if (!mColorBufferGl->readContents(&contentsSize, nullptr)) {
@@ -413,7 +428,7 @@
return false;
}
#endif
-
+ mGlTexDirty = false;
return true;
}
diff --git a/host/ColorBuffer.h b/host/ColorBuffer.h
index ab99dfa..b625829 100644
--- a/host/ColorBuffer.h
+++ b/host/ColorBuffer.h
@@ -136,6 +136,7 @@
std::unique_ptr<vk::ColorBufferVk> mColorBufferVk;
bool mGlAndVkAreSharingExternalMemory = false;
+ bool mGlTexDirty = false;
};
typedef std::shared_ptr<ColorBuffer> ColorBufferPtr;
diff --git a/host/FrameBuffer.cpp b/host/FrameBuffer.cpp
index 7dafbbc..c958fa9 100644
--- a/host/FrameBuffer.cpp
+++ b/host/FrameBuffer.cpp
@@ -327,7 +327,7 @@
if (fb->m_features.VulkanNativeSwapchain.enabled) {
fb->m_vkInstance = vkEmu->instance;
}
- if (vkEmu->deviceInfo.supportsIdProperties) {
+ if (vkEmu->instanceSupportsPhysicalDeviceIDProperties) {
GL_LOG("Supports id properties, got a vulkan device UUID");
fprintf(stderr, "%s: Supports id properties, got a vulkan device UUID\n", __func__);
memcpy(fb->m_vulkanUUID.data(), vkEmu->deviceInfo.idProps.deviceUUID, VK_UUID_SIZE);
@@ -436,7 +436,7 @@
bool vulkanInteropSupported = true;
// First, if the VkEmulation instance doesn't support ext memory capabilities,
// it won't support uuids.
- if (!vkEmu || !vkEmu->deviceInfo.supportsIdProperties) {
+ if (!vkEmu || !vkEmu->instanceSupportsPhysicalDeviceIDProperties) {
vulkanInteropSupported = false;
}
if (!fb->m_emulationGl) {
diff --git a/host/virtio-gpu-gfxstream-renderer.cpp b/host/virtio-gpu-gfxstream-renderer.cpp
index ae2e3c0..f7c070d 100644
--- a/host/virtio-gpu-gfxstream-renderer.cpp
+++ b/host/virtio-gpu-gfxstream-renderer.cpp
@@ -1701,24 +1701,47 @@
capset->externalSync = 1;
#endif
- const std::vector<uint32_t> kVirglPossibleFormats = {
- VIRGL_FORMAT_B8G8R8X8_UNORM, VIRGL_FORMAT_B8G8R8A8_UNORM,
- VIRGL_FORMAT_R8G8B8X8_UNORM, VIRGL_FORMAT_R8G8B8A8_UNORM,
- VIRGL_FORMAT_B5G6R5_UNORM, VIRGL_FORMAT_R16_UNORM,
- VIRGL_FORMAT_R16G16B16A16_FLOAT, VIRGL_FORMAT_R8_UNORM,
- VIRGL_FORMAT_R8G8_UNORM, VIRGL_FORMAT_NV12,
- VIRGL_FORMAT_P010, VIRGL_FORMAT_YV12,
- VIRGL_FORMAT_R10G10B10A2_UNORM, VIRGL_FORMAT_Z16_UNORM,
- VIRGL_FORMAT_Z24X8_UNORM, VIRGL_FORMAT_Z24_UNORM_S8_UINT,
- VIRGL_FORMAT_Z32_FLOAT, VIRGL_FORMAT_Z32_FLOAT_S8X24_UINT,
- };
-
memset(capset->virglSupportedFormats, 0, sizeof(capset->virglSupportedFormats));
- for (uint32_t possibleFormat : kVirglPossibleFormats) {
- GLenum possibleFormatGl = virgl_format_to_gl(possibleFormat);
+ struct FormatWithName {
+ uint32_t format;
+ const char* name;
+ };
+#define MAKE_FORMAT_AND_NAME(x) \
+ { x, #x }
+ static const FormatWithName kPossibleFormats[] = {
+ MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_B5G6R5_UNORM),
+ MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_B8G8R8A8_UNORM),
+ MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_B8G8R8X8_UNORM),
+ MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_NV12),
+ MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_P010),
+ MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_R10G10B10A2_UNORM),
+ MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_R16_UNORM),
+ MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_R16G16B16A16_FLOAT),
+ MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_R8_UNORM),
+ MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_R8G8_UNORM),
+ MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_R8G8B8A8_UNORM),
+ MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_R8G8B8X8_UNORM),
+ MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_YV12),
+ MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_Z16_UNORM),
+ MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_Z24_UNORM_S8_UINT),
+ MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_Z24X8_UNORM),
+ MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_Z32_FLOAT_S8X24_UINT),
+ MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_Z32_FLOAT),
+ };
+#undef MAKE_FORMAT_AND_NAME
+
+ stream_renderer_info("Format support:");
+ for (std::size_t i = 0; i < std::size(kPossibleFormats); i++) {
+ const FormatWithName& possibleFormat = kPossibleFormats[i];
+
+ GLenum possibleFormatGl = virgl_format_to_gl(possibleFormat.format);
const bool supported = gfxstream::FrameBuffer::getFB()->isFormatSupported(possibleFormatGl);
- set_virgl_format_supported(capset->virglSupportedFormats, possibleFormat, supported);
+
+ stream_renderer_info(" %s: %s", possibleFormat.name,
+ (supported ? "supported" : "unsupported"));
+ set_virgl_format_supported(capset->virglSupportedFormats, possibleFormat.format,
+ supported);
}
break;
}
diff --git a/host/vulkan/VkCommonOperations.cpp b/host/vulkan/VkCommonOperations.cpp
index fb7ec0f..67e2c9d 100644
--- a/host/vulkan/VkCommonOperations.cpp
+++ b/host/vulkan/VkCommonOperations.cpp
@@ -553,6 +553,115 @@
return res;
}
+// Checks if the user enforced a specific GPU, it can be done via index or name.
+// Otherwise try to find the best device with discrete GPU and high vulkan API level.
+// Scoring of the devices is done by some implicit choices based on known driver
+// quality, stability and performance issues of current GPUs.
+// Only one Vulkan device is selected; this makes things simple for now, but we
+// could consider utilizing multiple devices in use cases that make sense.
+int getSelectedGpuIndex(const std::vector<VkEmulation::DeviceSupportInfo>& deviceInfos) {
+ const int physdevCount = deviceInfos.size();
+ if (physdevCount == 1) {
+ return 0;
+ }
+
+ if (!sVkEmulation->instanceSupportsGetPhysicalDeviceProperties2) {
+ // If we don't support physical device ID properties, pick the first physical device
+ WARN("Instance doesn't support '%s', picking the first physical device",
+ VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+ return 0;
+ }
+
+ const char* EnvVarSelectGpu = "ANDROID_EMU_VK_SELECT_GPU";
+ std::string enforcedGpuStr = android::base::getEnvironmentVariable(EnvVarSelectGpu);
+ int enforceGpuIndex = -1;
+ if (enforcedGpuStr.size()) {
+ INFO("%s is set to %s", EnvVarSelectGpu, enforcedGpuStr.c_str());
+
+ if (enforcedGpuStr[0] == '0') {
+ enforceGpuIndex = 0;
+ } else {
+ enforceGpuIndex = (atoi(enforcedGpuStr.c_str()));
+ if (enforceGpuIndex == 0) {
+ // Could not convert to an integer, try searching with device name
+ // Do the comparison case insensitive as vendor names don't have consistency
+ enforceGpuIndex = -1;
+ std::transform(enforcedGpuStr.begin(), enforcedGpuStr.end(), enforcedGpuStr.begin(),
+ [](unsigned char c) { return std::tolower(c); });
+
+ for (int i = 0; i < physdevCount; ++i) {
+ std::string deviceName = std::string(deviceInfos[i].physdevProps.deviceName);
+ std::transform(deviceName.begin(), deviceName.end(), deviceName.begin(),
+ [](unsigned char c) { return std::tolower(c); });
+ INFO("Physical device [%d] = %s", i, deviceName.c_str());
+
+ if (deviceName.find(enforcedGpuStr) != std::string::npos) {
+ enforceGpuIndex = i;
+ }
+ }
+ }
+ }
+
+ if (enforceGpuIndex != -1 && enforceGpuIndex >= 0 && enforceGpuIndex < deviceInfos.size()) {
+ INFO("Selecting GPU (%s) at index %d.",
+ deviceInfos[enforceGpuIndex].physdevProps.deviceName, enforceGpuIndex);
+ } else {
+ WARN("Could not select the GPU with ANDROID_EMU_VK_GPU_SELECT.");
+ enforceGpuIndex = -1;
+ }
+ }
+
+ if (enforceGpuIndex != -1) {
+ return enforceGpuIndex;
+ }
+
+ // If there are multiple devices, and none of them are enforced to use,
+ // score each device and select the best
+ int selectedGpuIndex = 0;
+ auto getDeviceScore = [](const VkEmulation::DeviceSupportInfo& deviceInfo) {
+ uint32_t deviceScore = 0;
+ if (!deviceInfo.hasGraphicsQueueFamily) {
+ // Not supporting graphics, cannot be used.
+ return deviceScore;
+ }
+
+ // Matches the ordering in VkPhysicalDeviceType
+ const uint32_t deviceTypeScoreTable[] = {
+ 100, // VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
+ 1000, // VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
+ 2000, // VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
+ 500, // VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
+ 600, // VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
+ };
+
+ // Prefer discrete GPUs, then integrated and then others..
+ const int deviceType = deviceInfo.physdevProps.deviceType;
+ deviceScore += deviceTypeScoreTable[deviceInfo.physdevProps.deviceType];
+
+ // Prefer higher level of Vulkan API support, restrict version numbers to
+ // common limits to ensure an always increasing scoring change
+ const uint32_t major = VK_API_VERSION_MAJOR(deviceInfo.physdevProps.apiVersion);
+ const uint32_t minor = VK_API_VERSION_MINOR(deviceInfo.physdevProps.apiVersion);
+ const uint32_t patch = VK_API_VERSION_PATCH(deviceInfo.physdevProps.apiVersion);
+ deviceScore += major * 5000 + std::min(minor, 10u) * 500 + std::min(patch, 400u);
+
+ return deviceScore;
+ };
+
+ uint32_t maxScore = 0;
+ for (int i = 0; i < physdevCount; ++i) {
+ const uint32_t score = getDeviceScore(deviceInfos[i]);
+ VERBOSE("Device selection score for '%s' = %d", deviceInfos[i].physdevProps.deviceName,
+ score);
+ if (score > maxScore) {
+ selectedGpuIndex = i;
+ maxScore = score;
+ }
+ }
+
+ return selectedGpuIndex;
+}
+
VkEmulation* createGlobalVkEmulation(VulkanDispatch* vk, gfxstream::host::FeatureSet features) {
// Downstream branches can provide abort logic or otherwise use result without a new macro
#define VK_EMU_INIT_RETURN_OR_ABORT_ON_ERROR(res, ...) \
@@ -577,9 +686,23 @@
sVkEmulation->gvk = vk;
auto gvk = vk;
+ std::vector<const char*> getPhysicalDeviceProperties2InstanceExtNames = {
+ VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
+ };
std::vector<const char*> externalMemoryInstanceExtNames = {
VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME,
- VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
+ };
+
+ std::vector<const char*> externalSemaphoreInstanceExtNames = {
+ VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME,
+ };
+
+ std::vector<const char*> externalFenceInstanceExtNames = {
+ VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME,
+ };
+
+ std::vector<const char*> surfaceInstanceExtNames = {
+ VK_KHR_SURFACE_EXTENSION_NAME,
};
std::vector<const char*> externalMemoryDeviceExtNames = {
@@ -599,18 +722,6 @@
#endif
};
- std::vector<const char*> externalSemaphoreInstanceExtNames = {
- VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME,
- };
-
- std::vector<const char*> externalFenceInstanceExtNames = {
- VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME,
- };
-
- std::vector<const char*> surfaceInstanceExtNames = {
- VK_KHR_SURFACE_EXTENSION_NAME,
- };
-
#if defined(__APPLE__)
std::vector<const char*> moltenVkInstanceExtNames = {
VK_MVK_MACOS_SURFACE_EXTENSION_NAME,
@@ -628,11 +739,13 @@
instanceExts.resize(instanceExtCount);
gvk->vkEnumerateInstanceExtensionProperties(nullptr, &instanceExtCount, instanceExts.data());
- bool externalMemoryCapabilitiesSupported =
+ bool getPhysicalDeviceProperties2Supported =
+ extensionsSupported(instanceExts, getPhysicalDeviceProperties2InstanceExtNames);
+ bool externalMemoryCapabilitiesSupported = getPhysicalDeviceProperties2Supported &&
extensionsSupported(instanceExts, externalMemoryInstanceExtNames);
- bool externalSemaphoreCapabilitiesSupported =
+ bool externalSemaphoreCapabilitiesSupported = getPhysicalDeviceProperties2Supported &&
extensionsSupported(instanceExts, externalSemaphoreInstanceExtNames);
- bool externalFenceCapabilitiesSupported =
+ bool externalFenceCapabilitiesSupported = getPhysicalDeviceProperties2Supported &&
extensionsSupported(instanceExts, externalFenceInstanceExtNames);
bool surfaceSupported = extensionsSupported(instanceExts, surfaceInstanceExtNames);
#if defined(__APPLE__)
@@ -659,12 +772,30 @@
VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
}
- if (externalMemoryCapabilitiesSupported) {
+ if (getPhysicalDeviceProperties2Supported) {
+ for (auto extension : getPhysicalDeviceProperties2InstanceExtNames) {
+ selectedInstanceExtensionNames.emplace(extension);
+ }
+ }
+
+ if (externalSemaphoreCapabilitiesSupported) {
for (auto extension : externalMemoryInstanceExtNames) {
selectedInstanceExtensionNames.emplace(extension);
}
}
+ if (externalFenceCapabilitiesSupported) {
+ for (auto extension : externalSemaphoreInstanceExtNames) {
+ selectedInstanceExtensionNames.emplace(extension);
+ }
+ }
+
+ if (externalMemoryCapabilitiesSupported) {
+ for (auto extension : externalFenceInstanceExtNames) {
+ selectedInstanceExtensionNames.emplace(extension);
+ }
+ }
+
if (surfaceSupported) {
for (auto extension : surfaceInstanceExtNames) {
selectedInstanceExtensionNames.emplace(extension);
@@ -767,6 +898,14 @@
sVkEmulation->vulkanInstanceVersion = appInfo.apiVersion;
+ // https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceIDProperties.html
+ // Provided by VK_VERSION_1_1, or VK_KHR_external_fence_capabilities, VK_KHR_external_memory_capabilities,
+ // VK_KHR_external_semaphore_capabilities
+ sVkEmulation->instanceSupportsPhysicalDeviceIDProperties =
+ externalFenceCapabilitiesSupported || externalMemoryCapabilitiesSupported ||
+ externalSemaphoreCapabilitiesSupported;
+
+ sVkEmulation->instanceSupportsGetPhysicalDeviceProperties2 = getPhysicalDeviceProperties2Supported;
sVkEmulation->instanceSupportsExternalMemoryCapabilities = externalMemoryCapabilitiesSupported;
sVkEmulation->instanceSupportsExternalSemaphoreCapabilities =
externalSemaphoreCapabilitiesSupported;
@@ -776,18 +915,23 @@
sVkEmulation->instanceSupportsMoltenVK = moltenVKSupported;
#endif
- if (sVkEmulation->instanceSupportsExternalMemoryCapabilities) {
+ if (sVkEmulation->instanceSupportsGetPhysicalDeviceProperties2) {
sVkEmulation->getImageFormatProperties2Func = vk_util::getVkInstanceProcAddrWithFallback<
vk_util::vk_fn_info::GetPhysicalDeviceImageFormatProperties2>(
{ivk->vkGetInstanceProcAddr, vk->vkGetInstanceProcAddr}, sVkEmulation->instance);
sVkEmulation->getPhysicalDeviceProperties2Func = vk_util::getVkInstanceProcAddrWithFallback<
vk_util::vk_fn_info::GetPhysicalDeviceProperties2>(
{ivk->vkGetInstanceProcAddr, vk->vkGetInstanceProcAddr}, sVkEmulation->instance);
- }
- sVkEmulation->getPhysicalDeviceFeatures2Func =
- vk_util::getVkInstanceProcAddrWithFallback<vk_util::vk_fn_info::GetPhysicalDeviceFeatures2>(
+ sVkEmulation->getPhysicalDeviceFeatures2Func = vk_util::getVkInstanceProcAddrWithFallback<
+ vk_util::vk_fn_info::GetPhysicalDeviceFeatures2>(
{ivk->vkGetInstanceProcAddr, vk->vkGetInstanceProcAddr}, sVkEmulation->instance);
+ if (!sVkEmulation->getPhysicalDeviceProperties2Func) {
+ ERR("Warning: device claims to support ID properties "
+ "but vkGetPhysicalDeviceProperties2 could not be found");
+ }
+ }
+
#if defined(__APPLE__)
if (sVkEmulation->instanceSupportsMoltenVK) {
// Using metal_objects extension on MacOS when moltenVK is used.
@@ -849,44 +993,37 @@
// External memory export not supported on QNX
deviceInfos[i].supportsExternalMemoryExport = false;
#endif
+ }
- deviceInfos[i].supportsIdProperties =
- sVkEmulation->getPhysicalDeviceProperties2Func != nullptr;
+ if (sVkEmulation->instanceSupportsGetPhysicalDeviceProperties2) {
deviceInfos[i].supportsDriverProperties =
extensionsSupported(deviceExts, {VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME}) ||
(deviceInfos[i].physdevProps.apiVersion >= VK_API_VERSION_1_2);
- deviceInfos[i].supportsExternalMemoryHostProps = extensionsSupported(deviceExts, {VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME});
+ deviceInfos[i].supportsExternalMemoryHostProps =
+ extensionsSupported(deviceExts, {VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME});
- if (!sVkEmulation->getPhysicalDeviceProperties2Func) {
- ERR("Warning: device claims to support ID properties "
- "but vkGetPhysicalDeviceProperties2 could not be found");
- }
- }
- if (sVkEmulation->getPhysicalDeviceProperties2Func) {
- VkPhysicalDeviceExternalMemoryHostPropertiesEXT externalMemoryHostProps = {
- .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT,
- };
VkPhysicalDeviceProperties2 deviceProps = {
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR,
-
};
+ auto devicePropsChain = vk_make_chain_iterator(&deviceProps);
+
VkPhysicalDeviceIDProperties idProps = {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR,
};
- VkPhysicalDeviceDriverPropertiesKHR driverProps = {
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR,
- };
-
- auto devicePropsChain = vk_make_chain_iterator(&deviceProps);
-
- if (deviceInfos[i].supportsIdProperties) {
+ if (sVkEmulation->instanceSupportsPhysicalDeviceIDProperties) {
vk_append_struct(&devicePropsChain, &idProps);
}
+ VkPhysicalDeviceDriverPropertiesKHR driverProps = {
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR,
+ };
if (deviceInfos[i].supportsDriverProperties) {
vk_append_struct(&devicePropsChain, &driverProps);
}
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT externalMemoryHostProps = {
+ .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT,
+ };
if(deviceInfos[i].supportsExternalMemoryHostProps) {
vk_append_struct(&devicePropsChain, &externalMemoryHostProps);
}
@@ -1003,72 +1140,16 @@
}
}
- // Of all the devices enumerated, find the best one. Try to find a device
- // with graphics queue as the highest priority, then ext memory, then
- // compute.
+ // When there are multiple physical devices, find the best one or enable selecting
+ // the one enforced by environment variable setting.
+ int selectedGpuIndex = getSelectedGpuIndex(deviceInfos);
- // Graphics queue is highest priority since without that, we really
- // shouldn't be using the driver. Although, one could make a case for doing
- // some sorts of things if only a compute queue is available (such as for
- // AI), that's not really the priority yet.
-
- // As for external memory, we really should not be running on any driver
- // without external memory support, but we might be able to pull it off, and
- // single Vulkan apps might work via CPU transfer of the rendered frames.
-
- // Compute support is treated as icing on the cake and not relied upon yet
- // for anything critical to emulation. However, we might potentially use it
- // to perform image format conversion on GPUs where that's not natively
- // supported.
-
- // Another implicit choice is to select only one Vulkan device. This makes
- // things simple for now, but we could consider utilizing multiple devices
- // in use cases that make sense, if/when they come up.
-
- std::vector<uint32_t> deviceScores(physdevCount, 0);
- for (uint32_t i = 0; i < physdevCount; ++i) {
- uint32_t deviceScore = 0;
- if (deviceInfos[i].hasGraphicsQueueFamily) deviceScore += 10000;
- if (deviceInfos[i].supportsExternalMemoryImport ||
- deviceInfos[i].supportsExternalMemoryExport)
- deviceScore += 1000;
- if (deviceInfos[i].physdevProps.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU ||
- deviceInfos[i].physdevProps.deviceType == VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU) {
- deviceScore += 100;
- }
- if (deviceInfos[i].physdevProps.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU) {
- deviceScore += 50;
- }
- deviceScores[i] = deviceScore;
- }
-
- uint32_t maxScoringIndex = 0;
- uint32_t maxScore = 0;
-
- // If we don't support physical device ID properties,
- // just pick the first physical device.
- if (!sVkEmulation->instanceSupportsExternalMemoryCapabilities) {
- ERR("Warning: instance doesn't support "
- "external memory capabilities, picking first physical device");
- maxScoringIndex = 0;
- } else {
- for (uint32_t i = 0; i < physdevCount; ++i) {
- if (deviceScores[i] > maxScore) {
- maxScoringIndex = i;
- maxScore = deviceScores[i];
- }
- }
- }
-
- sVkEmulation->physdev = physdevs[maxScoringIndex];
- sVkEmulation->physicalDeviceIndex = maxScoringIndex;
- sVkEmulation->deviceInfo = deviceInfos[maxScoringIndex];
+ sVkEmulation->physdev = physdevs[selectedGpuIndex];
+ sVkEmulation->physicalDeviceIndex = selectedGpuIndex;
+ sVkEmulation->deviceInfo = deviceInfos[selectedGpuIndex];
// Postcondition: sVkEmulation has valid device support info
- // Ask about image format support here.
- // TODO: May have to first ask when selecting physical devices
- // (e.g., choose between Intel or NVIDIA GPU for certain image format
- // support)
+ // Collect image support info of the selected device
sVkEmulation->imageSupportInfo = getBasicImageSupportList();
for (size_t i = 0; i < sVkEmulation->imageSupportInfo.size(); ++i) {
getImageFormatExternalMemorySupportInfo(ivk, sVkEmulation->physdev,
@@ -1091,7 +1172,6 @@
"hasComputeQueueFamily = %d\n"
"supportsExternalMemoryImport = %d\n"
"supportsExternalMemoryExport = %d\n"
- "supportsIdProperties = %d\n"
"supportsDriverProperties = %d\n"
"hasSamplerYcbcrConversionExtension = %d\n"
"supportsSamplerYcbcrConversion = %d\n"
@@ -1100,7 +1180,6 @@
sVkEmulation->deviceInfo.hasComputeQueueFamily,
sVkEmulation->deviceInfo.supportsExternalMemoryImport,
sVkEmulation->deviceInfo.supportsExternalMemoryExport,
- sVkEmulation->deviceInfo.supportsIdProperties,
sVkEmulation->deviceInfo.supportsDriverProperties,
sVkEmulation->deviceInfo.hasSamplerYcbcrConversionExtension,
sVkEmulation->deviceInfo.supportsSamplerYcbcrConversion,
diff --git a/host/vulkan/VkCommonOperations.h b/host/vulkan/VkCommonOperations.h
index 88b4c08..566b863 100644
--- a/host/vulkan/VkCommonOperations.h
+++ b/host/vulkan/VkCommonOperations.h
@@ -143,6 +143,8 @@
VulkanDispatch* ivk = nullptr;
VulkanDispatch* dvk = nullptr;
+ bool instanceSupportsPhysicalDeviceIDProperties = false;
+ bool instanceSupportsGetPhysicalDeviceProperties2 = false;
bool instanceSupportsExternalMemoryCapabilities = false;
bool instanceSupportsExternalSemaphoreCapabilities = false;
bool instanceSupportsExternalFenceCapabilities = false;
@@ -204,7 +206,6 @@
bool supportsExternalMemoryImport = false;
bool supportsExternalMemoryExport = false;
bool supportsDmaBuf = false;
- bool supportsIdProperties = false;
bool supportsDriverProperties = false;
bool supportsExternalMemoryHostProps = false;
bool hasSamplerYcbcrConversionExtension = false;
diff --git a/host/vulkan/VkDecoderGlobalState.cpp b/host/vulkan/VkDecoderGlobalState.cpp
index 4ed1bdd..b056460 100644
--- a/host/vulkan/VkDecoderGlobalState.cpp
+++ b/host/vulkan/VkDecoderGlobalState.cpp
@@ -1155,7 +1155,7 @@
void FilterPhysicalDevicesLocked(VkInstance instance, VulkanDispatch* vk,
std::vector<VkPhysicalDevice>& toFilterPhysicalDevices) {
- if (m_emu->instanceSupportsExternalMemoryCapabilities) {
+ if (m_emu->instanceSupportsGetPhysicalDeviceProperties2) {
PFN_vkGetPhysicalDeviceProperties2KHR getPhysdevProps2Func =
vk_util::getVkInstanceProcAddrWithFallback<
vk_util::vk_fn_info::GetPhysicalDeviceProperties2>(
@@ -1306,7 +1306,7 @@
fprintf(stderr,
"%s: Warning: Trying to use extension struct in "
"VkPhysicalDeviceFeatures2 without having enabled "
- "the extension!!!!11111\n",
+ "the extension!\n",
__func__);
}
*pFeatures = {
@@ -3320,128 +3320,129 @@
const VkWriteDescriptorSet* pDescriptorWrites,
uint32_t descriptorCopyCount,
const VkCopyDescriptorSet* pDescriptorCopies) {
- if (snapshotsEnabled()) {
- for (uint32_t writeIdx = 0; writeIdx < descriptorWriteCount; writeIdx++) {
- const VkWriteDescriptorSet& descriptorWrite = pDescriptorWrites[writeIdx];
- auto ite = mDescriptorSetInfo.find(descriptorWrite.dstSet);
- if (ite == mDescriptorSetInfo.end()) {
- continue;
- }
- DescriptorSetInfo& descriptorSetInfo = ite->second;
- auto& table = descriptorSetInfo.allWrites;
- VkDescriptorType descType = descriptorWrite.descriptorType;
- uint32_t dstBinding = descriptorWrite.dstBinding;
- uint32_t dstArrayElement = descriptorWrite.dstArrayElement;
- uint32_t descriptorCount = descriptorWrite.descriptorCount;
+ for (uint32_t writeIdx = 0; writeIdx < descriptorWriteCount; writeIdx++) {
+ const VkWriteDescriptorSet& descriptorWrite = pDescriptorWrites[writeIdx];
+ auto ite = mDescriptorSetInfo.find(descriptorWrite.dstSet);
+ if (ite == mDescriptorSetInfo.end()) {
+ continue;
+ }
+ DescriptorSetInfo& descriptorSetInfo = ite->second;
+ auto& table = descriptorSetInfo.allWrites;
+ VkDescriptorType descType = descriptorWrite.descriptorType;
+ uint32_t dstBinding = descriptorWrite.dstBinding;
+ uint32_t dstArrayElement = descriptorWrite.dstArrayElement;
+ uint32_t descriptorCount = descriptorWrite.descriptorCount;
- uint32_t arrOffset = dstArrayElement;
+ uint32_t arrOffset = dstArrayElement;
- if (isDescriptorTypeImageInfo(descType)) {
- for (uint32_t writeElemIdx = 0; writeElemIdx < descriptorCount;
- ++writeElemIdx, ++arrOffset) {
- // Descriptor writes wrap to the next binding. See
- // https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSet.html
- if (arrOffset >= table[dstBinding].size()) {
- ++dstBinding;
- arrOffset = 0;
- }
- auto& entry = table[dstBinding][arrOffset];
- entry.imageInfo = descriptorWrite.pImageInfo[writeElemIdx];
- entry.writeType = DescriptorSetInfo::DescriptorWriteType::ImageInfo;
- entry.descriptorType = descType;
- entry.alives.clear();
- if (descriptorTypeContainsImage(descType)) {
- auto* imageViewInfo =
- android::base::find(mImageViewInfo, entry.imageInfo.imageView);
- if (imageViewInfo) {
- entry.alives.push_back(imageViewInfo->alive);
- }
- }
- if (descriptorTypeContainsSampler(descType)) {
- auto* samplerInfo =
- android::base::find(mSamplerInfo, entry.imageInfo.sampler);
- if (samplerInfo) {
- entry.alives.push_back(samplerInfo->alive);
- }
- }
+ if (isDescriptorTypeImageInfo(descType)) {
+ for (uint32_t writeElemIdx = 0; writeElemIdx < descriptorCount;
+ ++writeElemIdx, ++arrOffset) {
+ // Descriptor writes wrap to the next binding. See
+ // https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSet.html
+ if (arrOffset >= table[dstBinding].size()) {
+ ++dstBinding;
+ arrOffset = 0;
}
- } else if (isDescriptorTypeBufferInfo(descType)) {
- for (uint32_t writeElemIdx = 0; writeElemIdx < descriptorCount;
- ++writeElemIdx, ++arrOffset) {
- if (arrOffset >= table[dstBinding].size()) {
- ++dstBinding;
- arrOffset = 0;
- }
- auto& entry = table[dstBinding][arrOffset];
- entry.bufferInfo = descriptorWrite.pBufferInfo[writeElemIdx];
- entry.writeType = DescriptorSetInfo::DescriptorWriteType::BufferInfo;
- entry.descriptorType = descType;
- entry.alives.clear();
- auto* bufferInfo =
- android::base::find(mBufferInfo, entry.bufferInfo.buffer);
- if (bufferInfo) {
- entry.alives.push_back(bufferInfo->alive);
- }
- }
- } else if (isDescriptorTypeBufferView(descType)) {
- for (uint32_t writeElemIdx = 0; writeElemIdx < descriptorCount;
- ++writeElemIdx, ++arrOffset) {
- if (arrOffset >= table[dstBinding].size()) {
- ++dstBinding;
- arrOffset = 0;
- }
- auto& entry = table[dstBinding][arrOffset];
- entry.bufferView = descriptorWrite.pTexelBufferView[writeElemIdx];
- entry.writeType = DescriptorSetInfo::DescriptorWriteType::BufferView;
- entry.descriptorType = descType;
- // TODO: check alive
- ERR("%s: Snapshot for texel buffer view is incomplete.\n", __func__);
- }
- } else if (isDescriptorTypeInlineUniformBlock(descType)) {
- const VkWriteDescriptorSetInlineUniformBlock* descInlineUniformBlock =
- static_cast<const VkWriteDescriptorSetInlineUniformBlock*>(
- descriptorWrite.pNext);
- while (descInlineUniformBlock &&
- descInlineUniformBlock->sType !=
- VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK) {
- descInlineUniformBlock =
- static_cast<const VkWriteDescriptorSetInlineUniformBlock*>(
- descInlineUniformBlock->pNext);
- }
- if (!descInlineUniformBlock) {
- GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
- << __func__ << ": did not find inline uniform block";
- return;
- }
- auto& entry = table[dstBinding][0];
- entry.inlineUniformBlock = *descInlineUniformBlock;
- entry.inlineUniformBlockBuffer.assign(
- static_cast<const uint8_t*>(descInlineUniformBlock->pData),
- static_cast<const uint8_t*>(descInlineUniformBlock->pData) +
- descInlineUniformBlock->dataSize);
- entry.writeType = DescriptorSetInfo::DescriptorWriteType::InlineUniformBlock;
+ auto& entry = table[dstBinding][arrOffset];
+ entry.imageInfo = descriptorWrite.pImageInfo[writeElemIdx];
+ entry.writeType = DescriptorSetInfo::DescriptorWriteType::ImageInfo;
entry.descriptorType = descType;
- entry.dstArrayElement = dstArrayElement;
- } else if (isDescriptorTypeAccelerationStructure(descType)) {
- // TODO
- // Look for pNext inline uniform block or acceleration structure.
- // Append new DescriptorWrite entry that holds the buffer
- ERR("%s: Ignoring Snapshot for emulated write for descriptor type 0x%x\n",
- __func__, descType);
+ entry.alives.clear();
+ entry.boundColorBuffer.reset();
+ if (descriptorTypeContainsImage(descType)) {
+ auto* imageViewInfo =
+ android::base::find(mImageViewInfo, entry.imageInfo.imageView);
+ if (imageViewInfo) {
+ entry.alives.push_back(imageViewInfo->alive);
+ entry.boundColorBuffer = imageViewInfo->boundColorBuffer;
+ }
+ }
+ if (descriptorTypeContainsSampler(descType)) {
+ auto* samplerInfo =
+ android::base::find(mSamplerInfo, entry.imageInfo.sampler);
+ if (samplerInfo) {
+ entry.alives.push_back(samplerInfo->alive);
+ }
+ }
}
+ } else if (isDescriptorTypeBufferInfo(descType)) {
+ for (uint32_t writeElemIdx = 0; writeElemIdx < descriptorCount;
+ ++writeElemIdx, ++arrOffset) {
+ if (arrOffset >= table[dstBinding].size()) {
+ ++dstBinding;
+ arrOffset = 0;
+ }
+ auto& entry = table[dstBinding][arrOffset];
+ entry.bufferInfo = descriptorWrite.pBufferInfo[writeElemIdx];
+ entry.writeType = DescriptorSetInfo::DescriptorWriteType::BufferInfo;
+ entry.descriptorType = descType;
+ entry.alives.clear();
+ auto* bufferInfo = android::base::find(mBufferInfo, entry.bufferInfo.buffer);
+ if (bufferInfo) {
+ entry.alives.push_back(bufferInfo->alive);
+ }
+ }
+ } else if (isDescriptorTypeBufferView(descType)) {
+ for (uint32_t writeElemIdx = 0; writeElemIdx < descriptorCount;
+ ++writeElemIdx, ++arrOffset) {
+ if (arrOffset >= table[dstBinding].size()) {
+ ++dstBinding;
+ arrOffset = 0;
+ }
+ auto& entry = table[dstBinding][arrOffset];
+ entry.bufferView = descriptorWrite.pTexelBufferView[writeElemIdx];
+ entry.writeType = DescriptorSetInfo::DescriptorWriteType::BufferView;
+ entry.descriptorType = descType;
+ // TODO: check alive
+ ERR("%s: Snapshot for texel buffer view is incomplete.\n", __func__);
+ }
+ } else if (isDescriptorTypeInlineUniformBlock(descType)) {
+ const VkWriteDescriptorSetInlineUniformBlock* descInlineUniformBlock =
+ static_cast<const VkWriteDescriptorSetInlineUniformBlock*>(
+ descriptorWrite.pNext);
+ while (descInlineUniformBlock &&
+ descInlineUniformBlock->sType !=
+ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK) {
+ descInlineUniformBlock =
+ static_cast<const VkWriteDescriptorSetInlineUniformBlock*>(
+ descInlineUniformBlock->pNext);
+ }
+ if (!descInlineUniformBlock) {
+ GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+ << __func__ << ": did not find inline uniform block";
+ return;
+ }
+ auto& entry = table[dstBinding][0];
+ entry.inlineUniformBlock = *descInlineUniformBlock;
+ entry.inlineUniformBlockBuffer.assign(
+ static_cast<const uint8_t*>(descInlineUniformBlock->pData),
+ static_cast<const uint8_t*>(descInlineUniformBlock->pData) +
+ descInlineUniformBlock->dataSize);
+ entry.writeType = DescriptorSetInfo::DescriptorWriteType::InlineUniformBlock;
+ entry.descriptorType = descType;
+ entry.dstArrayElement = dstArrayElement;
+ } else if (isDescriptorTypeAccelerationStructure(descType)) {
+ // TODO
+ // Look for pNext inline uniform block or acceleration structure.
+ // Append new DescriptorWrite entry that holds the buffer
+ ERR("%s: Ignoring Snapshot for emulated write for descriptor type 0x%x\n", __func__,
+ descType);
}
- // TODO: bookkeep pDescriptorCopies
- // Our primary use case vkQueueCommitDescriptorSetUpdatesGOOGLE does not use
- // pDescriptorCopies. Thus skip its implementation for now.
- if (descriptorCopyCount) {
- ERR("%s: Snapshot does not support descriptor copy yet\n");
- }
+ }
+ // TODO: bookkeep pDescriptorCopies
+ // Our primary use case vkQueueCommitDescriptorSetUpdatesGOOGLE does not use
+ // pDescriptorCopies. Thus skip its implementation for now.
+ if (descriptorCopyCount && snapshotsEnabled()) {
+ ERR("%s: Snapshot does not support descriptor copy yet\n");
}
bool needEmulateWriteDescriptor = false;
// c++ seems to allow for 0-size array allocation
std::unique_ptr<bool[]> descriptorWritesNeedDeepCopy(new bool[descriptorWriteCount]);
for (uint32_t i = 0; i < descriptorWriteCount; i++) {
const VkWriteDescriptorSet& descriptorWrite = pDescriptorWrites[i];
+ auto descriptorSetInfo =
+ android::base::find(mDescriptorSetInfo, descriptorWrite.dstSet);
descriptorWritesNeedDeepCopy[i] = false;
if (!vk_util::vk_descriptor_type_has_image_view(descriptorWrite.descriptorType)) {
continue;
@@ -3452,14 +3453,6 @@
if (!imgViewInfo) {
continue;
}
- if (imgViewInfo->boundColorBuffer) {
- // TODO(igorc): Move this to vkQueueSubmit time.
- // Likely can be removed after b/323596143
- auto fb = FrameBuffer::getFB();
- if (fb) {
- fb->invalidateColorBufferForVk(*imgViewInfo->boundColorBuffer);
- }
- }
if (descriptorWrite.descriptorType != VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) {
continue;
}
@@ -4330,12 +4323,12 @@
// decompress, could we do it once before calling vkCmdDispatch?
vk->vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE,
cmdBufferInfo->computePipeline);
- if (!cmdBufferInfo->descriptorSets.empty()) {
+ if (!cmdBufferInfo->currentDescriptorSets.empty()) {
vk->vkCmdBindDescriptorSets(
commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, cmdBufferInfo->descriptorLayout,
- cmdBufferInfo->firstSet, cmdBufferInfo->descriptorSets.size(),
- cmdBufferInfo->descriptorSets.data(), cmdBufferInfo->dynamicOffsets.size(),
- cmdBufferInfo->dynamicOffsets.data());
+ cmdBufferInfo->firstSet, cmdBufferInfo->currentDescriptorSets.size(),
+ cmdBufferInfo->currentDescriptorSets.data(),
+ cmdBufferInfo->dynamicOffsets.size(), cmdBufferInfo->dynamicOffsets.data());
}
}
@@ -5614,6 +5607,25 @@
if (!cmdBufferInfo) {
continue;
}
+ for (auto descriptorSet : cmdBufferInfo->allDescriptorSets) {
+ auto descriptorSetInfo =
+ android::base::find(mDescriptorSetInfo, descriptorSet);
+ if (!descriptorSetInfo) {
+ continue;
+ }
+ for (auto& writes : descriptorSetInfo->allWrites) {
+ for (const auto& write : writes) {
+ bool isValid = true;
+ for (const auto& alive : write.alives) {
+ isValid &= !alive.expired();
+ }
+ if (isValid && write.boundColorBuffer.has_value()) {
+ acquiredColorBuffers.insert(write.boundColorBuffer.value());
+ }
+ }
+ }
+ }
+
acquiredColorBuffers.merge(cmdBufferInfo->acquiredColorBuffers);
releasedColorBuffers.merge(cmdBufferInfo->releasedColorBuffers);
for (const auto& ite : cmdBufferInfo->cbLayouts) {
@@ -5843,28 +5855,31 @@
if (!physicalDevice) {
return;
}
- // Cannot forward this call to driver because nVidia linux driver crahses on it.
- switch (pExternalSemaphoreInfo->handleType) {
- case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
- pExternalSemaphoreProperties->exportFromImportedHandleTypes =
- VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
- pExternalSemaphoreProperties->compatibleHandleTypes =
- VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
- pExternalSemaphoreProperties->externalSemaphoreFeatures =
- VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT |
- VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;
- return;
- case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
- pExternalSemaphoreProperties->exportFromImportedHandleTypes =
- VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
- pExternalSemaphoreProperties->compatibleHandleTypes =
- VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
- pExternalSemaphoreProperties->externalSemaphoreFeatures =
- VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT |
- VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;
- return;
- default:
- break;
+
+ if (m_emu->features.VulkanExternalSync.enabled) {
+ // Cannot forward this call to driver because nVidia linux driver crahses on it.
+ switch (pExternalSemaphoreInfo->handleType) {
+ case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
+ pExternalSemaphoreProperties->exportFromImportedHandleTypes =
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
+ pExternalSemaphoreProperties->compatibleHandleTypes =
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
+ pExternalSemaphoreProperties->externalSemaphoreFeatures =
+ VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT |
+ VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;
+ return;
+ case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
+ pExternalSemaphoreProperties->exportFromImportedHandleTypes =
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
+ pExternalSemaphoreProperties->compatibleHandleTypes =
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
+ pExternalSemaphoreProperties->externalSemaphoreFeatures =
+ VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT |
+ VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;
+ return;
+ default:
+ break;
+ }
}
pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0;
@@ -6205,19 +6220,19 @@
vk->vkCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet,
descriptorSetCount, pDescriptorSets, dynamicOffsetCount,
pDynamicOffsets);
- if (pipelineBindPoint == VK_PIPELINE_BIND_POINT_COMPUTE) {
+ if (descriptorSetCount) {
std::lock_guard<std::recursive_mutex> lock(mLock);
auto* cmdBufferInfo = android::base::find(mCmdBufferInfo, commandBuffer);
if (cmdBufferInfo) {
cmdBufferInfo->descriptorLayout = layout;
- if (descriptorSetCount) {
- cmdBufferInfo->firstSet = firstSet;
- cmdBufferInfo->descriptorSets.assign(pDescriptorSets,
- pDescriptorSets + descriptorSetCount);
- cmdBufferInfo->dynamicOffsets.assign(pDynamicOffsets,
- pDynamicOffsets + dynamicOffsetCount);
- }
+ cmdBufferInfo->allDescriptorSets.insert(pDescriptorSets,
+ pDescriptorSets + descriptorSetCount);
+ cmdBufferInfo->firstSet = firstSet;
+ cmdBufferInfo->currentDescriptorSets.assign(pDescriptorSets,
+ pDescriptorSets + descriptorSetCount);
+ cmdBufferInfo->dynamicOffsets.assign(pDynamicOffsets,
+ pDynamicOffsets + dynamicOffsetCount);
}
}
}
@@ -7945,7 +7960,8 @@
VkPipeline computePipeline = VK_NULL_HANDLE;
uint32_t firstSet = 0;
VkPipelineLayout descriptorLayout = VK_NULL_HANDLE;
- std::vector<VkDescriptorSet> descriptorSets;
+ std::vector<VkDescriptorSet> currentDescriptorSets;
+ std::unordered_set<VkDescriptorSet> allDescriptorSets;
std::vector<uint32_t> dynamicOffsets;
std::unordered_set<HandleType> acquiredColorBuffers;
std::unordered_set<HandleType> releasedColorBuffers;
@@ -7959,7 +7975,8 @@
computePipeline = VK_NULL_HANDLE;
firstSet = 0;
descriptorLayout = VK_NULL_HANDLE;
- descriptorSets.clear();
+ currentDescriptorSets.clear();
+ allDescriptorSets.clear();
dynamicOffsets.clear();
acquiredColorBuffers.clear();
releasedColorBuffers.clear();
diff --git a/host/vulkan/VkDecoderInternalStructs.h b/host/vulkan/VkDecoderInternalStructs.h
index f8acb70..4b9575f 100644
--- a/host/vulkan/VkDecoderInternalStructs.h
+++ b/host/vulkan/VkDecoderInternalStructs.h
@@ -366,6 +366,7 @@
std::vector<uint8_t> inlineUniformBlockBuffer;
// Weak pointer(s) to detect if all objects on dependency chain are alive.
std::vector<std::weak_ptr<bool>> alives;
+ std::optional<HandleType> boundColorBuffer;
};
VkDescriptorPool pool;
