Snap for 6859336 from ab89e17faf95f6180907067b5f79023972ef48c0 to simpleperf-releasesimpleperf-release

Change-Id: I9265d7d736e1cfdacecac590cbd661c0172d8adf

13 files changed, 396 insertions, 1149 deletions

diff --git a/shared/OpenglCodecCommon/GLClientState.cpp b/shared/OpenglCodecCommon/GLClientState.cpp
index 039b7632..67758316 100644
--- a/shared/OpenglCodecCommon/GLClientState.cpp
+++ b/shared/OpenglCodecCommon/GLClientState.cpp
@@ -2406,6 +2406,13 @@ void GLClientState::validateUniform(bool isFloat, bool isUnsigned, GLint columns
     }
 }
 
+bool GLClientState::isAttribIndexUsedByProgram(int index) {
+    auto info = currentAttribValidationInfo.get_const(index);
+    if (!info) return false;
+    if (!info->validInProgram) return false;
+    return true;
+}
+
 void GLClientState::addFreshFramebuffer(GLuint name) {
     FboProps props;
     props.name = name;
diff --git a/shared/OpenglCodecCommon/GLClientState.h b/shared/OpenglCodecCommon/GLClientState.h
index c98190c8..6beeb962 100644
--- a/shared/OpenglCodecCommon/GLClientState.h
+++ b/shared/OpenglCodecCommon/GLClientState.h
@@ -541,12 +541,14 @@ public:
     int getMaxColorAttachments() const;
     int getMaxDrawBuffers() const;
 
-    // Uniform validation info
+    // Uniform/attribute validation info
     UniformValidationInfo currentUniformValidationInfo;
-    // TODO: Program uniform validation info
+    AttribValidationInfo currentAttribValidationInfo;;
 
     // Uniform validation api
     void validateUniform(bool isFloat, bool isUnsigned, GLint columns, GLint rows, GLint location, GLsizei count, GLenum* err);
+    // Attrib validation
+    bool isAttribIndexUsedByProgram(int attribIndex);
 
 private:
     void init();
diff --git a/shared/OpenglCodecCommon/GLSharedGroup.cpp b/shared/OpenglCodecCommon/GLSharedGroup.cpp
index 848dfdbb..e2ed36cb 100755
--- a/shared/OpenglCodecCommon/GLSharedGroup.cpp
+++ b/shared/OpenglCodecCommon/GLSharedGroup.cpp
@@ -40,6 +40,7 @@ ProgramData::ProgramData() : m_numIndexes(0),
                              m_numAttributes(0),
                              m_initialized(false) {
     m_Indexes = NULL;
+    m_attribIndexes = NULL;
     m_refcount = 1;
     m_linkStatus = 0;
     m_activeUniformBlockCount = 0;
@@ -52,8 +53,10 @@ void ProgramData::initProgramData(GLuint numIndexes, GLuint numAttributes) {
     m_numAttributes = numAttributes;
 
     delete [] m_Indexes;
+    delete [] m_attribIndexes;
 
     m_Indexes = new IndexInfo[numIndexes];
+    m_attribIndexes = new AttribInfo[m_numAttributes];
 }
 
 bool ProgramData::isInitialized() {
@@ -63,6 +66,7 @@ bool ProgramData::isInitialized() {
 ProgramData::~ProgramData() {
 
     delete [] m_Indexes;
+    delete [] m_attribIndexes;
 
     m_Indexes = NULL;
 }
@@ -80,6 +84,16 @@ void ProgramData::setIndexInfo(
     m_Indexes[index].samplerValue = 0;
 }
 
+void ProgramData::setAttribInfo(
+    GLuint index, GLint attribLoc, GLint size, GLenum type) {
+
+    if (index >= m_numAttributes) return;
+
+    m_attribIndexes[index].attribLoc = attribLoc;
+    m_attribIndexes[index].size = size;
+    m_attribIndexes[index].type = type;
+}
+
 void ProgramData::setIndexFlags(GLuint index, GLuint flags) {
 
     if (index >= m_numIndexes) return;
@@ -228,6 +242,27 @@ UniformValidationInfo ProgramData::compileValidationInfo(bool* error) const {
     return res;
 }
 
+AttribValidationInfo ProgramData::compileAttribValidationInfo(bool* error) const {
+    AttribValidationInfo res;
+    if (!m_attribIndexes) {
+        *error = true;
+        return res;
+    }
+
+    for (GLuint i = 0; i < m_numAttributes; ++i) {
+        if (m_attribIndexes[i].attribLoc < 0) continue;
+
+        AttribIndexInfo info = {
+            .validInProgram = true,
+        };
+
+        for (GLuint j = 0; j < getAttributeCountOfType(m_attribIndexes[i].type) * m_attribIndexes[i].size ; ++j) {
+            res.add(m_attribIndexes[i].attribLoc + j, info);
+        }
+    }
+
+    return res;
+}
 /***** GLSharedGroup ****/
 
 GLSharedGroup::GLSharedGroup() { }
@@ -521,6 +556,19 @@ void GLSharedGroup::setProgramIndexInfo(
     }
 }
 
+void GLSharedGroup::setProgramAttribInfo(
+    GLuint program, GLuint index, GLint attribLoc,
+    GLint size, GLenum type, const char* name) {
+
+    android::AutoMutex _lock(m_lock);
+
+    ProgramData* pData = getProgramDataLocked(program);
+
+    if (pData) {
+        pData->setAttribInfo(index,attribLoc,size,type);
+    }
+}
+
 GLenum GLSharedGroup::getProgramUniformType(GLuint program, GLint location) {
 
     android::AutoMutex _lock(m_lock);
@@ -801,6 +849,20 @@ UniformValidationInfo GLSharedGroup::getUniformValidationInfo(GLuint program) {
     return pData->compileValidationInfo(&error);
 }
 
+AttribValidationInfo GLSharedGroup::getAttribValidationInfo(GLuint program) {
+    AttribValidationInfo res;
+
+    android::AutoMutex _lock(m_lock);
+
+    ProgramData* pData =
+        getProgramDataLocked(program);
+
+    if (!pData) return res;
+
+    bool error; (void)error;
+    return pData->compileAttribValidationInfo(&error);
+}
+
 void GLSharedGroup::setProgramLinkStatus(GLuint program, GLint linkStatus) {
     android::AutoMutex _lock(m_lock);
     ProgramData* pData =
diff --git a/shared/OpenglCodecCommon/GLSharedGroup.h b/shared/OpenglCodecCommon/GLSharedGroup.h
index b423951b..807a0065 100755
--- a/shared/OpenglCodecCommon/GLSharedGroup.h
+++ b/shared/OpenglCodecCommon/GLSharedGroup.h
@@ -76,9 +76,16 @@ private:
         GLint samplerValue; // only set for sampler uniforms
     } IndexInfo;
 
+    typedef struct _AttribInfo {
+        GLint attribLoc;
+        GLint size;
+        GLenum type;
+    } AttribInfo;
+
     GLuint m_numIndexes;
     GLuint m_numAttributes;
     IndexInfo* m_Indexes;
+    AttribInfo* m_attribIndexes;
     bool m_initialized;
 
     std::vector<GLuint> m_shaders;
@@ -100,6 +107,7 @@ public:
     bool isInitialized();
     virtual ~ProgramData();
     void setIndexInfo(GLuint index, GLint base, GLint size, GLenum type);
+    void setAttribInfo(GLuint index, GLint base, GLint size, GLenum type);
     void setIndexFlags(GLuint index, GLuint flags);
     GLuint getIndexForLocation(GLint location);
     GLenum getTypeForLocation(GLint location);
@@ -120,6 +128,7 @@ public:
     }
 
     UniformValidationInfo compileValidationInfo(bool* error) const;
+    AttribValidationInfo compileAttribValidationInfo(bool* error) const;
     void setLinkStatus(GLint status) { m_linkStatus = status; }
     GLint getLinkStatus() { return m_linkStatus; }
 
@@ -210,6 +219,7 @@ public:
     void    deleteProgramData(GLuint program);
     void    deleteProgramDataLocked(GLuint program);
     void    setProgramIndexInfo(GLuint program, GLuint index, GLint base, GLint size, GLenum type, const char* name);
+    void    setProgramAttribInfo(GLuint program, GLuint index, GLint attribLoc, GLint size, GLenum type, const char* name);
     GLenum  getProgramUniformType(GLuint program, GLint location);
     GLint   getNextSamplerUniform(GLuint program, GLint index, GLint* val, GLenum* target) const;
     bool    setSamplerUniform(GLuint program, GLint appLoc, GLint val, GLenum* target);
@@ -233,6 +243,7 @@ public:
 
     // Validation info
     UniformValidationInfo getUniformValidationInfo(GLuint program);
+    AttribValidationInfo getAttribValidationInfo(GLuint program);
 
     void setProgramLinkStatus(GLuint program, GLint linkStatus);
     GLint getProgramLinkStatus(GLuint program);
diff --git a/shared/OpenglCodecCommon/StateTrackingSupport.h b/shared/OpenglCodecCommon/StateTrackingSupport.h
index c6715c4e..b742c131 100644
--- a/shared/OpenglCodecCommon/StateTrackingSupport.h
+++ b/shared/OpenglCodecCommon/StateTrackingSupport.h
@@ -74,7 +74,8 @@ private:
     Storage mStorage;
 };
 
-// A structure for fast validation of uniform uploads and other uniform related api calls.
+// Structures for fast validation of uniforms/attribs.
+
 struct UniformLocationInfo {
     bool valid = false;
     uint32_t columns;
@@ -86,7 +87,12 @@ struct UniformLocationInfo {
     bool isBool;
 };
 
+struct AttribIndexInfo {
+    bool validInProgram = false;
+};
+
 using UniformValidationInfo = android::base::HybridComponentManager<1000, uint32_t, UniformLocationInfo>;
+using AttribValidationInfo = android::base::HybridComponentManager<16, uint32_t, AttribIndexInfo>;
 
 using LastQueryTargetInfo = android::base::HybridComponentManager<1000, uint32_t, uint32_t>;
 
diff --git a/shared/OpenglCodecCommon/glUtils.cpp b/shared/OpenglCodecCommon/glUtils.cpp
index de621393..a6b0b7c8 100644
--- a/shared/OpenglCodecCommon/glUtils.cpp
+++ b/shared/OpenglCodecCommon/glUtils.cpp
@@ -287,6 +287,100 @@ uint32_t getRowsOfType(GLenum type) {
     }
 }
 
+uint32_t getAttributeCountOfType(GLenum type) {
+    switch (type) {
+    case GL_BYTE:
+    case GL_UNSIGNED_BYTE:
+    case GL_SHORT:
+    case GL_UNSIGNED_SHORT:
+    case GL_HALF_FLOAT:
+    case GL_HALF_FLOAT_OES:
+    case GL_IMAGE_2D:
+    case GL_IMAGE_3D:
+    case GL_UNSIGNED_INT:
+    case GL_INT:
+    case GL_FLOAT:
+    case GL_FIXED:
+    case GL_BOOL:
+        return 1;
+#ifdef GL_DOUBLE
+    case GL_DOUBLE:
+    case GL_DOUBLE_VEC2:
+    case GL_DOUBLE_VEC3:
+    case GL_DOUBLE_VEC4:
+        return 1;
+    case GL_DOUBLE_MAT2:
+    case GL_DOUBLE_MAT2x3:
+    case GL_DOUBLE_MAT2x4:
+        return 4;
+    case GL_DOUBLE_MAT3:
+    case GL_DOUBLE_MAT3x2:
+    case GL_DOUBLE_MAT3x4:
+        return 6;
+    case GL_DOUBLE_MAT4:
+    case GL_DOUBLE_MAT4x2:
+    case GL_DOUBLE_MAT4x3:
+        return 8;
+#endif
+    case GL_FLOAT_VEC2:
+    case GL_INT_VEC2:
+    case GL_UNSIGNED_INT_VEC2:
+    case GL_BOOL_VEC2:
+    case GL_INT_VEC3:
+    case GL_UNSIGNED_INT_VEC3:
+    case GL_BOOL_VEC3:
+    case GL_FLOAT_VEC3:
+    case GL_FLOAT_VEC4:
+    case GL_BOOL_VEC4:
+    case GL_INT_VEC4:
+    case GL_UNSIGNED_INT_VEC4:
+        return 1;
+    case GL_FLOAT_MAT2:
+    case GL_FLOAT_MAT2x3:
+    case GL_FLOAT_MAT2x4:
+        return 2;
+    case GL_FLOAT_MAT3:
+    case GL_FLOAT_MAT3x2:
+    case GL_FLOAT_MAT3x4:
+        return 3;
+    case GL_FLOAT_MAT4:
+    case GL_FLOAT_MAT4x2:
+    case GL_FLOAT_MAT4x3:
+        return 4;
+    case GL_SAMPLER_2D:
+    case GL_SAMPLER_3D:
+    case GL_SAMPLER_CUBE:
+    case GL_SAMPLER_2D_SHADOW:
+    case GL_SAMPLER_2D_ARRAY:
+    case GL_SAMPLER_2D_ARRAY_SHADOW:
+    case GL_SAMPLER_2D_MULTISAMPLE:
+    case GL_SAMPLER_CUBE_SHADOW:
+    case GL_INT_SAMPLER_2D:
+    case GL_INT_SAMPLER_3D:
+    case GL_INT_SAMPLER_CUBE:
+    case GL_INT_SAMPLER_2D_ARRAY:
+    case GL_INT_SAMPLER_2D_MULTISAMPLE:
+    case GL_UNSIGNED_INT_SAMPLER_2D:
+    case GL_UNSIGNED_INT_SAMPLER_3D:
+    case GL_UNSIGNED_INT_SAMPLER_CUBE:
+    case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
+    case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
+    case GL_IMAGE_CUBE:
+    case GL_IMAGE_2D_ARRAY:
+    case GL_INT_IMAGE_2D:
+    case GL_INT_IMAGE_3D:
+    case GL_INT_IMAGE_CUBE:
+    case GL_INT_IMAGE_2D_ARRAY:
+    case GL_UNSIGNED_INT_IMAGE_2D:
+    case GL_UNSIGNED_INT_IMAGE_3D:
+    case GL_UNSIGNED_INT_IMAGE_CUBE:
+    case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:
+    case GL_UNSIGNED_INT_ATOMIC_COUNTER:
+    default:
+        return 1;
+    }
+}
+
 size_t glSizeof(GLenum type)
 {
     size_t retval = 0;
diff --git a/shared/OpenglCodecCommon/glUtils.h b/shared/OpenglCodecCommon/glUtils.h
index 489ac188..09081c2f 100644
--- a/shared/OpenglCodecCommon/glUtils.h
+++ b/shared/OpenglCodecCommon/glUtils.h
@@ -63,6 +63,7 @@ typedef enum {
     bool isBoolType(GLenum type);
     uint32_t getColumnsOfType(GLenum type);
     uint32_t getRowsOfType(GLenum type);
+    uint32_t getAttributeCountOfType(GLenum type);
     size_t glSizeof(GLenum type);
     size_t glUtilsParamSize(GLenum param);
     void   glUtilsPackPointerData(unsigned char *dst, unsigned char *str,
diff --git a/system/GLESv2_enc/GL2Encoder.cpp b/system/GLESv2_enc/GL2Encoder.cpp
index 919fdef1..cca18a98 100755
--- a/system/GLESv2_enc/GL2Encoder.cpp
+++ b/system/GLESv2_enc/GL2Encoder.cpp
@@ -1319,20 +1319,24 @@ void GL2Encoder::sendVertexAttributes(GLint first, GLsizei count, bool hasClient
                 }
                 if (state.elementSize == 0) {
                     // The vertex attribute array is uninitialized. Abandon it.
-                    ALOGE("a vertex attribute array is uninitialized. Skipping corresponding vertex attribute.");
                     this->m_glDisableVertexAttribArray_enc(this, i);
                     continue;
                 }
                 m_glEnableVertexAttribArray_enc(this, i);
 
                 if (datalen && (!offset || !((unsigned char*)offset + firstIndex))) {
-                    ALOGD("%s: bad offset / len!!!!!", __FUNCTION__);
                     continue;
                 }
+
+                unsigned char* data = (unsigned char*)offset + firstIndex;
+                if (!m_state->isAttribIndexUsedByProgram(i)) {
+                    continue;
+                }
+
                 if (state.isInt) {
-                    this->glVertexAttribIPointerDataAEMU(this, i, state.size, state.type, stride, (unsigned char *)offset + firstIndex, datalen);
+                    this->glVertexAttribIPointerDataAEMU(this, i, state.size, state.type, stride, data, datalen);
                 } else {
-                    this->glVertexAttribPointerData(this, i, state.size, state.type, state.normalized, stride, (unsigned char *)offset + firstIndex, datalen);
+                    this->glVertexAttribPointerData(this, i, state.size, state.type, state.normalized, stride, data, datalen);
                 }
             } else {
                 const BufferData* buf = m_shared->getBufferData(bufferObject);
@@ -1347,20 +1351,24 @@ void GL2Encoder::sendVertexAttributes(GLint first, GLsizei count, bool hasClient
                 if (buf && firstIndex >= 0 && firstIndex + bufLen <= buf->m_size) {
                     if (hasClientArrays) {
                         m_glEnableVertexAttribArray_enc(this, i);
-                        if (state.isInt) {
-                            this->glVertexAttribIPointerOffsetAEMU(this, i, state.size, state.type, stride, offset + firstIndex);
-                        } else {
-                            this->glVertexAttribPointerOffset(this, i, state.size, state.type, state.normalized, stride, offset + firstIndex);
+                        if (firstIndex) {
+                            if (state.isInt) {
+                                this->glVertexAttribIPointerOffsetAEMU(this, i, state.size, state.type, stride, offset + firstIndex);
+                            } else {
+                                this->glVertexAttribPointerOffset(this, i, state.size, state.type, state.normalized, stride, offset + firstIndex);
+                            }
                         }
                     }
                 } else {
-                    ALOGE("a vertex attribute index out of boundary is detected. Skipping corresponding vertex attribute. buf=%p", buf);
-                    if (buf) {
-                        ALOGE("Out of bounds vertex attribute info: "
-                                "clientArray? %d attribute %d vbo %u allocedBufferSize %u bufferDataSpecified? %d wantedStart %u wantedEnd %u",
-                                hasClientArrays, i, bufferObject, (unsigned int)buf->m_size, buf != NULL, firstIndex, firstIndex + bufLen);
+                    if (m_state->isAttribIndexUsedByProgram(i)) {
+                        ALOGE("a vertex attribute index out of boundary is detected. Skipping corresponding vertex attribute. buf=%p", buf);
+                        if (buf) {
+                            ALOGE("Out of bounds vertex attribute info: "
+                                    "clientArray? %d attribute %d vbo %u allocedBufferSize %u bufferDataSpecified? %d wantedStart %u wantedEnd %u",
+                                    hasClientArrays, i, bufferObject, (unsigned int)buf->m_size, buf != NULL, firstIndex, firstIndex + bufLen);
+                        }
+                        m_glDisableVertexAttribArray_enc(this, i);
                     }
-                    m_glDisableVertexAttribArray_enc(this, i);
                 }
             }
         } else {
@@ -1909,11 +1917,14 @@ void GL2Encoder::s_glLinkProgram(void * self, GLuint program)
 
     //get the length of the longest uniform name
     GLint maxLength=0;
+    GLint maxAttribLength=0;
     ctx->m_glGetProgramiv_enc(self, program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxLength);
+    ctx->m_glGetProgramiv_enc(self, program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &maxAttribLength);
 
     GLint size;
     GLenum type;
-    GLchar *name = new GLchar[maxLength+1];
+    size_t bufLen = maxLength > maxAttribLength ? maxLength : maxAttribLength;
+    GLchar *name = new GLchar[bufLen + 1];
     GLint location;
     //for each active uniform, get its size and starting location.
     for (GLint i=0 ; i<numUniforms ; ++i)
@@ -1923,6 +1934,12 @@ void GL2Encoder::s_glLinkProgram(void * self, GLuint program)
         ctx->m_shared->setProgramIndexInfo(program, i, location, size, type, name);
     }
 
+    for (GLint i = 0; i < numAttributes; ++i) {
+        ctx->m_glGetActiveAttrib_enc(self, program, i, maxAttribLength,  NULL, &size, &type, name);
+        location = ctx->m_glGetAttribLocation_enc(self, program, name);
+        ctx->m_shared->setProgramAttribInfo(program, i, location, size, type, name);
+    }
+
     if (ctx->majorVersion() > 2) {
         GLint numBlocks;
         ctx->m_glGetProgramiv_enc(ctx, program, GL_ACTIVE_UNIFORM_BLOCKS, &numBlocks);
@@ -2219,6 +2236,7 @@ void GL2Encoder::s_glUseProgram(void *self, GLuint program)
 
     if (program) {
         ctx->m_state->currentUniformValidationInfo = ctx->m_shared->getUniformValidationInfo(program);
+        ctx->m_state->currentAttribValidationInfo = ctx->m_shared->getAttribValidationInfo(program);
     }
 }
 
@@ -5321,7 +5339,7 @@ void GL2Encoder::s_glActiveShaderProgram(void* self, GLuint pipeline, GLuint pro
     }
 }
 
-GLuint GL2Encoder::s_glCreateShaderProgramv(void* self, GLenum type, GLsizei count, const char** strings) {
+GLuint GL2Encoder::s_glCreateShaderProgramv(void* self, GLenum shaderType, GLsizei count, const char** strings) {
 
     GLint* length = NULL;
     GL2Encoder* ctx = (GL2Encoder*)self;
@@ -5342,7 +5360,7 @@ GLuint GL2Encoder::s_glCreateShaderProgramv(void* self, GLenum type, GLsizei cou
         return -1;
     }
 
-    GLuint res = ctx->glCreateShaderProgramvAEMU(ctx, type, count, str, len + 1);
+    GLuint res = ctx->glCreateShaderProgramvAEMU(ctx, shaderType, count, str, len + 1);
     delete [] str;
 
     // Phase 2: do glLinkProgram-related initialization for locationWorkARound
@@ -5363,14 +5381,23 @@ GLuint GL2Encoder::s_glCreateShaderProgramv(void* self, GLenum type, GLsizei cou
     ctx->m_shared->initShaderProgramData(res, numUniforms, numAttributes);
 
     GLint maxLength=0;
+    GLint maxAttribLength=0;
     ctx->m_glGetProgramiv_enc(self, res, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxLength);
+    ctx->m_glGetProgramiv_enc(self, res, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &maxAttribLength);
 
-    GLint size; GLenum uniformType; GLchar* name = new GLchar[maxLength + 1];
+    size_t bufLen = maxLength > maxAttribLength ? maxLength : maxAttribLength;
+    GLint size; GLenum type; GLchar *name = new GLchar[bufLen + 1];
 
     for (GLint i = 0; i < numUniforms; ++i) {
-        ctx->m_glGetActiveUniform_enc(self, res, i, maxLength, NULL, &size, &uniformType, name);
+        ctx->m_glGetActiveUniform_enc(self, res, i, maxLength, NULL, &size, &type, name);
         GLint location = ctx->m_glGetUniformLocation_enc(self, res, name);
-        ctx->m_shared->setShaderProgramIndexInfo(res, i, location, size, uniformType, name);
+        ctx->m_shared->setShaderProgramIndexInfo(res, i, location, size, type, name);
+    }
+
+    for (GLint i = 0; i < numAttributes; ++i) {
+        ctx->m_glGetActiveAttrib_enc(self, res, i, maxAttribLength,  NULL, &size, &type, name);
+        GLint location = ctx->m_glGetAttribLocation_enc(self, res, name);
+        ctx->m_shared->setProgramAttribInfo(res, i, location, size, type, name);
     }
 
     GLint numBlocks;
@@ -5636,6 +5663,11 @@ void GL2Encoder::s_glUseProgramStages(void *self, GLuint pipeline, GLbitfield st
 
     // Otherwise, update host texture 2D bindings.
     ctx->updateHostTexture2DBindingsFromProgramData(program);
+
+    if (program) {
+        ctx->m_state->currentUniformValidationInfo = ctx->m_shared->getUniformValidationInfo(program);
+        ctx->m_state->currentAttribValidationInfo = ctx->m_shared->getAttribValidationInfo(program);
+    }
 }
 
 void GL2Encoder::s_glBindProgramPipeline(void* self, GLuint pipeline)
@@ -6208,6 +6240,7 @@ void GL2Encoder::s_glBindAttribLocation(void *self , GLuint program, GLuint inde
     SET_ERROR_IF(index > maxVertexAttribs, GL_INVALID_VALUE);
     SET_ERROR_IF(name && !strncmp("gl_", name, 3), GL_INVALID_OPERATION);
 
+    fprintf(stderr, "%s: bind attrib %u name %s\n", __func__, index, name);
     ctx->m_glBindAttribLocation_enc(ctx, program, index, name);
 }
 
diff --git a/system/vulkan_enc/ResourceTracker.cpp b/system/vulkan_enc/ResourceTracker.cpp
index c20e394f..b00a5627 100644
--- a/system/vulkan_enc/ResourceTracker.cpp
+++ b/system/vulkan_enc/ResourceTracker.cpp
@@ -1830,6 +1830,32 @@ public:
                         VK_FORMAT_B8G8R8A8_UNORM,
                         VK_FORMAT_R8G8B8A8_UNORM,
                 };
+            } else {
+                // If image format is predefined, check on host if the format,
+                // tiling and usage is supported.
+                AutoLock lock(mLock);
+                auto deviceIt = info_VkDevice.find(device);
+                if (deviceIt == info_VkDevice.end()) {
+                    return VK_ERROR_INITIALIZATION_FAILED;
+                }
+                auto& deviceInfo = deviceIt->second;
+
+                VkImageFormatProperties format_properties;
+                auto result = enc->vkGetPhysicalDeviceImageFormatProperties(
+                    deviceInfo.physdev, pImageInfo->format, pImageInfo->imageType,
+                    pImageInfo->tiling, pImageInfo->usage, pImageInfo->flags, &format_properties);
+                if (result != VK_SUCCESS) {
+                    ALOGE(
+                        "%s: Image format (%u) type (%u) tiling (%u) "
+                        "usage (%u) flags (%u) not supported by physical "
+                        "device",
+                        __func__, static_cast<uint32_t>(pImageInfo->format),
+                        static_cast<uint32_t>(pImageInfo->imageType),
+                        static_cast<uint32_t>(pImageInfo->tiling),
+                        static_cast<uint32_t>(pImageInfo->usage),
+                        static_cast<uint32_t>(pImageInfo->flags));
+                    return VK_ERROR_FORMAT_NOT_SUPPORTED;
+                }
             }
             constraints.image_format_constraints_count = formats.size();
             uint32_t format_index = 0;
diff --git a/system/vulkan_enc/VkEncoder.cpp b/system/vulkan_enc/VkEncoder.cpp
index 189f0dab..8f16a528 100644
--- a/system/vulkan_enc/VkEncoder.cpp
+++ b/system/vulkan_enc/VkEncoder.cpp
@@ -59,128 +59,7 @@ using android::base::guest::AutoLock;
 using android::base::guest::Lock;
 using android::base::Pool;
 
-class VkEncoder::Impl {
-public:
-    Impl(IOStream* stream) : m_stream(stream), m_logEncodes(false) {
-        m_stream.incStreamRef();
-        const char* emuVkLogEncodesPropName = "qemu.vk.log";
-        char encodeProp[PROPERTY_VALUE_MAX];
-        if (property_get(emuVkLogEncodesPropName, encodeProp, nullptr) > 0) {
-            m_logEncodes = atoi(encodeProp) > 0;
-        }
-    }
-
-    ~Impl() {
-        m_stream.decStreamRef();
-    }
-
-    VulkanCountingStream* countingStream() { return &m_countingStream; }
-    VulkanStreamGuest* stream() { return &m_stream; }
-    Pool* pool() { return &m_pool; }
-    ResourceTracker* resources() { return ResourceTracker::get(); }
-    Validation* validation() { return &m_validation; }
-
-    void log(const char* text) {
-        if (!m_logEncodes) return;
-        ALOGD("encoder log: %s", text);
-    }
-
-    void flush() {
-        lock();
-        m_stream.flush();
-        unlock();
-    }
-
-    // can be recursive
-    void lock() {
-        if (this == sAcquiredEncoderThreadLocal) {
-            ++sAcquiredEncoderThreadLockLevels;
-            return; // recursive
-        }
-        while (mLock.test_and_set(std::memory_order_acquire));
-        sAcquiredEncoderThreadLocal = this;
-        sAcquiredEncoderThreadLockLevels = 1;
-    }
-
-    void unlock() {
-        if (this != sAcquiredEncoderThreadLocal) {
-            // error, trying to unlock without having locked first
-            return;
-        }
-
-        --sAcquiredEncoderThreadLockLevels;
-        if (0 == sAcquiredEncoderThreadLockLevels) {
-            mLock.clear(std::memory_order_release);
-            sAcquiredEncoderThreadLocal = nullptr;
-        }
-    }
-
-    void incRef() {
-        __atomic_add_fetch(&m_refCount, 1, __ATOMIC_SEQ_CST);
-    }
-
-    bool decRef() {
-        if (0 == __atomic_sub_fetch(&m_refCount, 1, __ATOMIC_SEQ_CST)) {
-            return true;
-        }
-        return false;
-    }
-
-private:
-    VulkanCountingStream m_countingStream;
-    VulkanStreamGuest m_stream;
-    Pool m_pool { 8, 4096, 64 };
-
-    Validation m_validation;
-    bool m_logEncodes;
-    std::atomic_flag mLock = ATOMIC_FLAG_INIT;
-    static thread_local Impl* sAcquiredEncoderThreadLocal;
-    static thread_local uint32_t sAcquiredEncoderThreadLockLevels;
-    uint32_t m_refCount = 1;
-};
-
-VkEncoder::~VkEncoder() { }
-
-// static
-thread_local VkEncoder::Impl* VkEncoder::Impl::sAcquiredEncoderThreadLocal = nullptr;
-thread_local uint32_t VkEncoder::Impl::sAcquiredEncoderThreadLockLevels = 0;
-
-struct EncoderAutoLock {
-    EncoderAutoLock(VkEncoder* enc) : mEnc(enc) {
-        mEnc->lock();
-    }
-    ~EncoderAutoLock() {
-        mEnc->unlock();
-    }
-    VkEncoder* mEnc;
-};
-
-VkEncoder::VkEncoder(IOStream *stream) :
-    mImpl(new VkEncoder::Impl(stream)) { }
-
-void VkEncoder::flush() {
-    mImpl->flush();
-}
-
-void VkEncoder::lock() {
-    mImpl->lock();
-}
-
-void VkEncoder::unlock() {
-    mImpl->unlock();
-}
-
-void VkEncoder::incRef() {
-    mImpl->incRef();
-}
-
-bool VkEncoder::decRef() {
-    if (mImpl->decRef()) {
-        delete this;
-        return true;
-    }
-    return false;
-}
+#include "VkEncoder.cpp.inl"
 
 #define VALIDATE_RET(retType, success, validate) \
     retType goldfish_vk_validateResult = validate; \
@@ -197,7 +76,6 @@ VkResult VkEncoder::vkCreateInstance(
     VkInstance* pInstance)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateInstance encode");
     mImpl->log("start vkCreateInstance");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -259,13 +137,11 @@ VkResult VkEncoder::vkCreateInstance(
     stream->handleMapping()->mapHandles_VkInstance_u64(pInstance, &cgen_var_3, 1);
     stream->write((uint64_t*)&cgen_var_3, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateInstance readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_4;
     stream->read((uint64_t*)&cgen_var_4, 8);
     stream->handleMapping()->mapHandles_u64_VkInstance(&cgen_var_4, (VkInstance*)pInstance, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateInstance returnUnmarshal");
     VkResult vkCreateInstance_VkResult_return = (VkResult)0;
     stream->read(&vkCreateInstance_VkResult_return, sizeof(VkResult));
     mImpl->resources()->on_vkCreateInstance(this, vkCreateInstance_VkResult_return, pCreateInfo, pAllocator, pInstance);
@@ -281,7 +157,6 @@ void VkEncoder::vkDestroyInstance(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyInstance encode");
     mImpl->log("start vkDestroyInstance");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -330,8 +205,6 @@ void VkEncoder::vkDestroyInstance(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyInstance readParams");
-    AEMU_SCOPED_TRACE("vkDestroyInstance returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkInstance((VkInstance*)&instance);
     pool->freeAll();
     countingStream->clearPool();
@@ -345,7 +218,6 @@ VkResult VkEncoder::vkEnumeratePhysicalDevices(
     VkPhysicalDevice* pPhysicalDevices)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkEnumeratePhysicalDevices encode");
     mImpl->log("start vkEnumeratePhysicalDevices");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -410,7 +282,6 @@ VkResult VkEncoder::vkEnumeratePhysicalDevices(
         }
     }
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkEnumeratePhysicalDevices readParams");
     // WARNING PTR CHECK
     uint32_t* check_pPhysicalDeviceCount;
     check_pPhysicalDeviceCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -441,7 +312,6 @@ VkResult VkEncoder::vkEnumeratePhysicalDevices(
         }
     }
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkEnumeratePhysicalDevices returnUnmarshal");
     VkResult vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0;
     stream->read(&vkEnumeratePhysicalDevices_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -456,7 +326,6 @@ void VkEncoder::vkGetPhysicalDeviceFeatures(
     VkPhysicalDeviceFeatures* pFeatures)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures encode");
     mImpl->log("start vkGetPhysicalDeviceFeatures");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -481,13 +350,11 @@ void VkEncoder::vkGetPhysicalDeviceFeatures(
     stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_21, 1);
     stream->write((uint64_t*)&cgen_var_21, 1 * 8);
     marshal_VkPhysicalDeviceFeatures(stream, (VkPhysicalDeviceFeatures*)(pFeatures));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures readParams");
     unmarshal_VkPhysicalDeviceFeatures(stream, (VkPhysicalDeviceFeatures*)(pFeatures));
     if (pFeatures)
     {
         transform_fromhost_VkPhysicalDeviceFeatures(mImpl->resources(), (VkPhysicalDeviceFeatures*)(pFeatures));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -500,7 +367,6 @@ void VkEncoder::vkGetPhysicalDeviceFormatProperties(
     VkFormatProperties* pFormatProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties encode");
     mImpl->log("start vkGetPhysicalDeviceFormatProperties");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -529,13 +395,11 @@ void VkEncoder::vkGetPhysicalDeviceFormatProperties(
     stream->write((uint64_t*)&cgen_var_23, 1 * 8);
     stream->write((VkFormat*)&local_format, sizeof(VkFormat));
     marshal_VkFormatProperties(stream, (VkFormatProperties*)(pFormatProperties));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties readParams");
     unmarshal_VkFormatProperties(stream, (VkFormatProperties*)(pFormatProperties));
     if (pFormatProperties)
     {
         transform_fromhost_VkFormatProperties(mImpl->resources(), (VkFormatProperties*)(pFormatProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -552,7 +416,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties(
     VkImageFormatProperties* pImageFormatProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties encode");
     mImpl->log("start vkGetPhysicalDeviceImageFormatProperties");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -597,13 +460,11 @@ VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties(
     stream->write((VkImageUsageFlags*)&local_usage, sizeof(VkImageUsageFlags));
     stream->write((VkImageCreateFlags*)&local_flags, sizeof(VkImageCreateFlags));
     marshal_VkImageFormatProperties(stream, (VkImageFormatProperties*)(pImageFormatProperties));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties readParams");
     unmarshal_VkImageFormatProperties(stream, (VkImageFormatProperties*)(pImageFormatProperties));
     if (pImageFormatProperties)
     {
         transform_fromhost_VkImageFormatProperties(mImpl->resources(), (VkImageFormatProperties*)(pImageFormatProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties returnUnmarshal");
     VkResult vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceImageFormatProperties_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -618,7 +479,6 @@ void VkEncoder::vkGetPhysicalDeviceProperties(
     VkPhysicalDeviceProperties* pProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties encode");
     mImpl->log("start vkGetPhysicalDeviceProperties");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -643,13 +503,11 @@ void VkEncoder::vkGetPhysicalDeviceProperties(
     stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_27, 1);
     stream->write((uint64_t*)&cgen_var_27, 1 * 8);
     marshal_VkPhysicalDeviceProperties(stream, (VkPhysicalDeviceProperties*)(pProperties));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties readParams");
     unmarshal_VkPhysicalDeviceProperties(stream, (VkPhysicalDeviceProperties*)(pProperties));
     if (pProperties)
     {
         transform_fromhost_VkPhysicalDeviceProperties(mImpl->resources(), (VkPhysicalDeviceProperties*)(pProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties returnUnmarshal");
     mImpl->resources()->on_vkGetPhysicalDeviceProperties(this, physicalDevice, pProperties);
     pool->freeAll();
     countingStream->clearPool();
@@ -663,7 +521,6 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties(
     VkQueueFamilyProperties* pQueueFamilyProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties encode");
     mImpl->log("start vkGetPhysicalDeviceQueueFamilyProperties");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -720,7 +577,6 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties(
             marshal_VkQueueFamilyProperties(stream, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties readParams");
     // WARNING PTR CHECK
     uint32_t* check_pQueueFamilyPropertyCount;
     check_pQueueFamilyPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -753,7 +609,6 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties(
             transform_fromhost_VkQueueFamilyProperties(mImpl->resources(), (VkQueueFamilyProperties*)(pQueueFamilyProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -765,7 +620,6 @@ void VkEncoder::vkGetPhysicalDeviceMemoryProperties(
     VkPhysicalDeviceMemoryProperties* pMemoryProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties encode");
     mImpl->log("start vkGetPhysicalDeviceMemoryProperties");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -790,13 +644,11 @@ void VkEncoder::vkGetPhysicalDeviceMemoryProperties(
     stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_37, 1);
     stream->write((uint64_t*)&cgen_var_37, 1 * 8);
     marshal_VkPhysicalDeviceMemoryProperties(stream, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties readParams");
     unmarshal_VkPhysicalDeviceMemoryProperties(stream, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties));
     if (pMemoryProperties)
     {
         transform_fromhost_VkPhysicalDeviceMemoryProperties(mImpl->resources(), (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties returnUnmarshal");
     mImpl->resources()->on_vkGetPhysicalDeviceMemoryProperties(this, physicalDevice, pMemoryProperties);
     pool->freeAll();
     countingStream->clearPool();
@@ -809,7 +661,6 @@ PFN_vkVoidFunction VkEncoder::vkGetInstanceProcAddr(
     const char* pName)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetInstanceProcAddr encode");
     mImpl->log("start vkGetInstanceProcAddr");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -840,8 +691,6 @@ PFN_vkVoidFunction VkEncoder::vkGetInstanceProcAddr(
     stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_39, 1);
     stream->write((uint64_t*)&cgen_var_39, 1 * 8);
     stream->putString(local_pName);
-    AEMU_SCOPED_TRACE("vkGetInstanceProcAddr readParams");
-    AEMU_SCOPED_TRACE("vkGetInstanceProcAddr returnUnmarshal");
     PFN_vkVoidFunction vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
     stream->read(&vkGetInstanceProcAddr_PFN_vkVoidFunction_return, sizeof(PFN_vkVoidFunction));
     pool->freeAll();
@@ -856,7 +705,6 @@ PFN_vkVoidFunction VkEncoder::vkGetDeviceProcAddr(
     const char* pName)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetDeviceProcAddr encode");
     mImpl->log("start vkGetDeviceProcAddr");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -887,8 +735,6 @@ PFN_vkVoidFunction VkEncoder::vkGetDeviceProcAddr(
     stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_41, 1);
     stream->write((uint64_t*)&cgen_var_41, 1 * 8);
     stream->putString(local_pName);
-    AEMU_SCOPED_TRACE("vkGetDeviceProcAddr readParams");
-    AEMU_SCOPED_TRACE("vkGetDeviceProcAddr returnUnmarshal");
     PFN_vkVoidFunction vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
     stream->read(&vkGetDeviceProcAddr_PFN_vkVoidFunction_return, sizeof(PFN_vkVoidFunction));
     pool->freeAll();
@@ -905,7 +751,6 @@ VkResult VkEncoder::vkCreateDevice(
     VkDevice* pDevice)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateDevice encode");
     mImpl->log("start vkCreateDevice");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -975,13 +820,11 @@ VkResult VkEncoder::vkCreateDevice(
     stream->handleMapping()->mapHandles_VkDevice_u64(pDevice, &cgen_var_47, 1);
     stream->write((uint64_t*)&cgen_var_47, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateDevice readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_48;
     stream->read((uint64_t*)&cgen_var_48, 8);
     stream->handleMapping()->mapHandles_u64_VkDevice(&cgen_var_48, (VkDevice*)pDevice, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateDevice returnUnmarshal");
     VkResult vkCreateDevice_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDevice_VkResult_return, sizeof(VkResult));
     mImpl->resources()->on_vkCreateDevice(this, vkCreateDevice_VkResult_return, physicalDevice, pCreateInfo, pAllocator, pDevice);
@@ -997,7 +840,6 @@ void VkEncoder::vkDestroyDevice(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyDevice encode");
     mImpl->log("start vkDestroyDevice");
     mImpl->resources()->on_vkDestroyDevice_pre(this, device, pAllocator);
     auto stream = mImpl->stream();
@@ -1047,8 +889,6 @@ void VkEncoder::vkDestroyDevice(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyDevice readParams");
-    AEMU_SCOPED_TRACE("vkDestroyDevice returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkDevice((VkDevice*)&device);
     stream->flush();
     pool->freeAll();
@@ -1063,7 +903,6 @@ VkResult VkEncoder::vkEnumerateInstanceExtensionProperties(
     VkExtensionProperties* pProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkEnumerateInstanceExtensionProperties encode");
     mImpl->log("start vkEnumerateInstanceExtensionProperties");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -1146,7 +985,6 @@ VkResult VkEncoder::vkEnumerateInstanceExtensionProperties(
             marshal_VkExtensionProperties(stream, (VkExtensionProperties*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkEnumerateInstanceExtensionProperties readParams");
     // WARNING PTR CHECK
     uint32_t* check_pPropertyCount;
     check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -1179,7 +1017,6 @@ VkResult VkEncoder::vkEnumerateInstanceExtensionProperties(
             transform_fromhost_VkExtensionProperties(mImpl->resources(), (VkExtensionProperties*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkEnumerateInstanceExtensionProperties returnUnmarshal");
     VkResult vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0;
     stream->read(&vkEnumerateInstanceExtensionProperties_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -1196,7 +1033,6 @@ VkResult VkEncoder::vkEnumerateDeviceExtensionProperties(
     VkExtensionProperties* pProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkEnumerateDeviceExtensionProperties encode");
     mImpl->log("start vkEnumerateDeviceExtensionProperties");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -1287,7 +1123,6 @@ VkResult VkEncoder::vkEnumerateDeviceExtensionProperties(
             marshal_VkExtensionProperties(stream, (VkExtensionProperties*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkEnumerateDeviceExtensionProperties readParams");
     // WARNING PTR CHECK
     uint32_t* check_pPropertyCount;
     check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -1320,7 +1155,6 @@ VkResult VkEncoder::vkEnumerateDeviceExtensionProperties(
             transform_fromhost_VkExtensionProperties(mImpl->resources(), (VkExtensionProperties*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkEnumerateDeviceExtensionProperties returnUnmarshal");
     VkResult vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
     stream->read(&vkEnumerateDeviceExtensionProperties_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -1335,7 +1169,6 @@ VkResult VkEncoder::vkEnumerateInstanceLayerProperties(
     VkLayerProperties* pProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkEnumerateInstanceLayerProperties encode");
     mImpl->log("start vkEnumerateInstanceLayerProperties");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -1384,7 +1217,6 @@ VkResult VkEncoder::vkEnumerateInstanceLayerProperties(
             marshal_VkLayerProperties(stream, (VkLayerProperties*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkEnumerateInstanceLayerProperties readParams");
     // WARNING PTR CHECK
     uint32_t* check_pPropertyCount;
     check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -1417,7 +1249,6 @@ VkResult VkEncoder::vkEnumerateInstanceLayerProperties(
             transform_fromhost_VkLayerProperties(mImpl->resources(), (VkLayerProperties*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkEnumerateInstanceLayerProperties returnUnmarshal");
     VkResult vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
     stream->read(&vkEnumerateInstanceLayerProperties_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -1433,7 +1264,6 @@ VkResult VkEncoder::vkEnumerateDeviceLayerProperties(
     VkLayerProperties* pProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkEnumerateDeviceLayerProperties encode");
     mImpl->log("start vkEnumerateDeviceLayerProperties");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -1490,7 +1320,6 @@ VkResult VkEncoder::vkEnumerateDeviceLayerProperties(
             marshal_VkLayerProperties(stream, (VkLayerProperties*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkEnumerateDeviceLayerProperties readParams");
     // WARNING PTR CHECK
     uint32_t* check_pPropertyCount;
     check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -1523,7 +1352,6 @@ VkResult VkEncoder::vkEnumerateDeviceLayerProperties(
             transform_fromhost_VkLayerProperties(mImpl->resources(), (VkLayerProperties*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkEnumerateDeviceLayerProperties returnUnmarshal");
     VkResult vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
     stream->read(&vkEnumerateDeviceLayerProperties_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -1540,7 +1368,6 @@ void VkEncoder::vkGetDeviceQueue(
     VkQueue* pQueue)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetDeviceQueue encode");
     mImpl->log("start vkGetDeviceQueue");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -1579,13 +1406,11 @@ void VkEncoder::vkGetDeviceQueue(
     stream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_88, 1);
     stream->write((uint64_t*)&cgen_var_88, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkGetDeviceQueue readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_89;
     stream->read((uint64_t*)&cgen_var_89, 8);
     stream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_89, (VkQueue*)pQueue, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkGetDeviceQueue returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -1599,7 +1424,6 @@ VkResult VkEncoder::vkQueueSubmit(
     VkFence fence)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkQueueSubmit encode");
     mImpl->log("start vkQueueSubmit");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -1659,8 +1483,6 @@ VkResult VkEncoder::vkQueueSubmit(
     uint64_t cgen_var_93;
     stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_93, 1);
     stream->write((uint64_t*)&cgen_var_93, 1 * 8);
-    AEMU_SCOPED_TRACE("vkQueueSubmit readParams");
-    AEMU_SCOPED_TRACE("vkQueueSubmit returnUnmarshal");
     VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
     stream->read(&vkQueueSubmit_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -1674,7 +1496,6 @@ VkResult VkEncoder::vkQueueWaitIdle(
     VkQueue queue)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkQueueWaitIdle encode");
     mImpl->log("start vkQueueWaitIdle");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -1697,8 +1518,6 @@ VkResult VkEncoder::vkQueueWaitIdle(
     uint64_t cgen_var_95;
     stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_95, 1);
     stream->write((uint64_t*)&cgen_var_95, 1 * 8);
-    AEMU_SCOPED_TRACE("vkQueueWaitIdle readParams");
-    AEMU_SCOPED_TRACE("vkQueueWaitIdle returnUnmarshal");
     VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
     stream->read(&vkQueueWaitIdle_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -1712,7 +1531,6 @@ VkResult VkEncoder::vkDeviceWaitIdle(
     VkDevice device)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDeviceWaitIdle encode");
     mImpl->log("start vkDeviceWaitIdle");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -1735,8 +1553,6 @@ VkResult VkEncoder::vkDeviceWaitIdle(
     uint64_t cgen_var_97;
     stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_97, 1);
     stream->write((uint64_t*)&cgen_var_97, 1 * 8);
-    AEMU_SCOPED_TRACE("vkDeviceWaitIdle readParams");
-    AEMU_SCOPED_TRACE("vkDeviceWaitIdle returnUnmarshal");
     VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
     stream->read(&vkDeviceWaitIdle_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -1753,7 +1569,6 @@ VkResult VkEncoder::vkAllocateMemory(
     VkDeviceMemory* pMemory)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkAllocateMemory encode");
     mImpl->log("start vkAllocateMemory");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -1823,13 +1638,11 @@ VkResult VkEncoder::vkAllocateMemory(
     stream->handleMapping()->mapHandles_VkDeviceMemory_u64(pMemory, &cgen_var_103, 1);
     stream->write((uint64_t*)&cgen_var_103, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkAllocateMemory readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_104;
     stream->read((uint64_t*)&cgen_var_104, 8);
     stream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_104, (VkDeviceMemory*)pMemory, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkAllocateMemory returnUnmarshal");
     VkResult vkAllocateMemory_VkResult_return = (VkResult)0;
     stream->read(&vkAllocateMemory_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -1845,7 +1658,6 @@ void VkEncoder::vkFreeMemory(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkFreeMemory encode");
     mImpl->log("start vkFreeMemory");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -1899,8 +1711,6 @@ void VkEncoder::vkFreeMemory(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkFreeMemory readParams");
-    AEMU_SCOPED_TRACE("vkFreeMemory returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkDeviceMemory((VkDeviceMemory*)&memory);
     pool->freeAll();
     countingStream->clearPool();
@@ -1916,7 +1726,6 @@ VkResult VkEncoder::vkMapMemory(
     VkMemoryMapFlags flags,
     void** ppData)
 {
-    AEMU_SCOPED_TRACE("vkMapMemory resourceEvent");
     VkResult vkMapMemory_VkResult_return = (VkResult)0;
     vkMapMemory_VkResult_return = mImpl->resources()->on_vkMapMemory(this, VK_SUCCESS, device, memory, offset, size, flags, ppData);
     mImpl->log("finish vkMapMemory");;
@@ -1927,7 +1736,6 @@ void VkEncoder::vkUnmapMemory(
     VkDevice device,
     VkDeviceMemory memory)
 {
-    AEMU_SCOPED_TRACE("vkUnmapMemory resourceEvent");
     mImpl->resources()->on_vkUnmapMemory(this, device, memory);
 }
 
@@ -1937,7 +1745,6 @@ VkResult VkEncoder::vkFlushMappedMemoryRanges(
     const VkMappedMemoryRange* pMemoryRanges)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkFlushMappedMemoryRanges encode");
     mImpl->log("start vkFlushMappedMemoryRanges");
     VALIDATE_RET(VkResult, VK_SUCCESS, mImpl->validation()->on_vkFlushMappedMemoryRanges(this, VK_SUCCESS, device, memoryRangeCount, pMemoryRanges));
     auto stream = mImpl->stream();
@@ -2028,8 +1835,6 @@ VkResult VkEncoder::vkFlushMappedMemoryRanges(
             stream->write(targetRange, actualSize);
         }
     }
-    AEMU_SCOPED_TRACE("vkFlushMappedMemoryRanges readParams");
-    AEMU_SCOPED_TRACE("vkFlushMappedMemoryRanges returnUnmarshal");
     VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
     stream->read(&vkFlushMappedMemoryRanges_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -2045,7 +1850,6 @@ VkResult VkEncoder::vkInvalidateMappedMemoryRanges(
     const VkMappedMemoryRange* pMemoryRanges)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkInvalidateMappedMemoryRanges encode");
     mImpl->log("start vkInvalidateMappedMemoryRanges");
     VALIDATE_RET(VkResult, VK_SUCCESS, mImpl->validation()->on_vkInvalidateMappedMemoryRanges(this, VK_SUCCESS, device, memoryRangeCount, pMemoryRanges));
     auto stream = mImpl->stream();
@@ -2098,8 +1902,6 @@ VkResult VkEncoder::vkInvalidateMappedMemoryRanges(
     {
         marshal_VkMappedMemoryRange(stream, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
     }
-    AEMU_SCOPED_TRACE("vkInvalidateMappedMemoryRanges readParams");
-    AEMU_SCOPED_TRACE("vkInvalidateMappedMemoryRanges returnUnmarshal");
     VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
     stream->read(&vkInvalidateMappedMemoryRanges_VkResult_return, sizeof(VkResult));
     if (!resources->usingDirectMapping())
@@ -2134,7 +1936,6 @@ void VkEncoder::vkGetDeviceMemoryCommitment(
     VkDeviceSize* pCommittedMemoryInBytes)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment encode");
     mImpl->log("start vkGetDeviceMemoryCommitment");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -2168,9 +1969,7 @@ void VkEncoder::vkGetDeviceMemoryCommitment(
     stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_118, 1);
     stream->write((uint64_t*)&cgen_var_118, 1 * 8);
     stream->write((VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize));
-    AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment readParams");
     stream->read((VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize));
-    AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -2184,7 +1983,6 @@ VkResult VkEncoder::vkBindBufferMemory(
     VkDeviceSize memoryOffset)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkBindBufferMemory encode");
     mImpl->log("start vkBindBufferMemory");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -2228,8 +2026,6 @@ VkResult VkEncoder::vkBindBufferMemory(
     stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_124, 1);
     stream->write((uint64_t*)&cgen_var_124, 1 * 8);
     stream->write((VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize));
-    AEMU_SCOPED_TRACE("vkBindBufferMemory readParams");
-    AEMU_SCOPED_TRACE("vkBindBufferMemory returnUnmarshal");
     VkResult vkBindBufferMemory_VkResult_return = (VkResult)0;
     stream->read(&vkBindBufferMemory_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -2246,7 +2042,6 @@ VkResult VkEncoder::vkBindImageMemory(
     VkDeviceSize memoryOffset)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkBindImageMemory encode");
     mImpl->log("start vkBindImageMemory");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -2290,8 +2085,6 @@ VkResult VkEncoder::vkBindImageMemory(
     stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_130, 1);
     stream->write((uint64_t*)&cgen_var_130, 1 * 8);
     stream->write((VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize));
-    AEMU_SCOPED_TRACE("vkBindImageMemory readParams");
-    AEMU_SCOPED_TRACE("vkBindImageMemory returnUnmarshal");
     VkResult vkBindImageMemory_VkResult_return = (VkResult)0;
     stream->read(&vkBindImageMemory_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -2307,7 +2100,6 @@ void VkEncoder::vkGetBufferMemoryRequirements(
     VkMemoryRequirements* pMemoryRequirements)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements encode");
     mImpl->log("start vkGetBufferMemoryRequirements");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -2340,13 +2132,11 @@ void VkEncoder::vkGetBufferMemoryRequirements(
     stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_134, 1);
     stream->write((uint64_t*)&cgen_var_134, 1 * 8);
     marshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
-    AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements readParams");
     unmarshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
     if (pMemoryRequirements)
     {
         transform_fromhost_VkMemoryRequirements(mImpl->resources(), (VkMemoryRequirements*)(pMemoryRequirements));
     }
-    AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -2359,7 +2149,6 @@ void VkEncoder::vkGetImageMemoryRequirements(
     VkMemoryRequirements* pMemoryRequirements)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements encode");
     mImpl->log("start vkGetImageMemoryRequirements");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -2392,13 +2181,11 @@ void VkEncoder::vkGetImageMemoryRequirements(
     stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_138, 1);
     stream->write((uint64_t*)&cgen_var_138, 1 * 8);
     marshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
-    AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements readParams");
     unmarshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
     if (pMemoryRequirements)
     {
         transform_fromhost_VkMemoryRequirements(mImpl->resources(), (VkMemoryRequirements*)(pMemoryRequirements));
     }
-    AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -2412,7 +2199,6 @@ void VkEncoder::vkGetImageSparseMemoryRequirements(
     VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements encode");
     mImpl->log("start vkGetImageSparseMemoryRequirements");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -2477,7 +2263,6 @@ void VkEncoder::vkGetImageSparseMemoryRequirements(
             marshal_VkSparseImageMemoryRequirements(stream, (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements readParams");
     // WARNING PTR CHECK
     uint32_t* check_pSparseMemoryRequirementCount;
     check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -2510,7 +2295,6 @@ void VkEncoder::vkGetImageSparseMemoryRequirements(
             transform_fromhost_VkSparseImageMemoryRequirements(mImpl->resources(), (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -2528,7 +2312,6 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties(
     VkSparseImageFormatProperties* pProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties encode");
     mImpl->log("start vkGetPhysicalDeviceSparseImageFormatProperties");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -2605,7 +2388,6 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties(
             marshal_VkSparseImageFormatProperties(stream, (VkSparseImageFormatProperties*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties readParams");
     // WARNING PTR CHECK
     uint32_t* check_pPropertyCount;
     check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -2638,7 +2420,6 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties(
             transform_fromhost_VkSparseImageFormatProperties(mImpl->resources(), (VkSparseImageFormatProperties*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -2652,7 +2433,6 @@ VkResult VkEncoder::vkQueueBindSparse(
     VkFence fence)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkQueueBindSparse encode");
     mImpl->log("start vkQueueBindSparse");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -2712,8 +2492,6 @@ VkResult VkEncoder::vkQueueBindSparse(
     uint64_t cgen_var_160;
     stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_160, 1);
     stream->write((uint64_t*)&cgen_var_160, 1 * 8);
-    AEMU_SCOPED_TRACE("vkQueueBindSparse readParams");
-    AEMU_SCOPED_TRACE("vkQueueBindSparse returnUnmarshal");
     VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
     stream->read(&vkQueueBindSparse_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -2730,7 +2508,6 @@ VkResult VkEncoder::vkCreateFence(
     VkFence* pFence)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateFence encode");
     mImpl->log("start vkCreateFence");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -2800,13 +2577,11 @@ VkResult VkEncoder::vkCreateFence(
     stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_166, 1);
     stream->write((uint64_t*)&cgen_var_166, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateFence readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_167;
     stream->read((uint64_t*)&cgen_var_167, 8);
     stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_167, (VkFence*)pFence, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateFence returnUnmarshal");
     VkResult vkCreateFence_VkResult_return = (VkResult)0;
     stream->read(&vkCreateFence_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -2822,7 +2597,6 @@ void VkEncoder::vkDestroyFence(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyFence encode");
     mImpl->log("start vkDestroyFence");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -2879,8 +2653,6 @@ void VkEncoder::vkDestroyFence(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyFence readParams");
-    AEMU_SCOPED_TRACE("vkDestroyFence returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkFence((VkFence*)&fence);
     pool->freeAll();
     countingStream->clearPool();
@@ -2894,7 +2666,6 @@ VkResult VkEncoder::vkResetFences(
     const VkFence* pFences)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkResetFences encode");
     mImpl->log("start vkResetFences");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -2941,8 +2712,6 @@ VkResult VkEncoder::vkResetFences(
         stream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_177, ((fenceCount)));
         stream->write((uint64_t*)cgen_var_177, ((fenceCount)) * 8);
     }
-    AEMU_SCOPED_TRACE("vkResetFences readParams");
-    AEMU_SCOPED_TRACE("vkResetFences returnUnmarshal");
     VkResult vkResetFences_VkResult_return = (VkResult)0;
     stream->read(&vkResetFences_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -2957,7 +2726,6 @@ VkResult VkEncoder::vkGetFenceStatus(
     VkFence fence)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetFenceStatus encode");
     mImpl->log("start vkGetFenceStatus");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -2988,8 +2756,6 @@ VkResult VkEncoder::vkGetFenceStatus(
     uint64_t cgen_var_181;
     stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_181, 1);
     stream->write((uint64_t*)&cgen_var_181, 1 * 8);
-    AEMU_SCOPED_TRACE("vkGetFenceStatus readParams");
-    AEMU_SCOPED_TRACE("vkGetFenceStatus returnUnmarshal");
     VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
     stream->read(&vkGetFenceStatus_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -3007,7 +2773,6 @@ VkResult VkEncoder::vkWaitForFences(
     uint64_t timeout)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkWaitForFences encode");
     mImpl->log("start vkWaitForFences");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -3062,8 +2827,6 @@ VkResult VkEncoder::vkWaitForFences(
     }
     stream->write((VkBool32*)&local_waitAll, sizeof(VkBool32));
     stream->write((uint64_t*)&local_timeout, sizeof(uint64_t));
-    AEMU_SCOPED_TRACE("vkWaitForFences readParams");
-    AEMU_SCOPED_TRACE("vkWaitForFences returnUnmarshal");
     VkResult vkWaitForFences_VkResult_return = (VkResult)0;
     stream->read(&vkWaitForFences_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -3080,7 +2843,6 @@ VkResult VkEncoder::vkCreateSemaphore(
     VkSemaphore* pSemaphore)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateSemaphore encode");
     mImpl->log("start vkCreateSemaphore");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -3150,13 +2912,11 @@ VkResult VkEncoder::vkCreateSemaphore(
     stream->handleMapping()->mapHandles_VkSemaphore_u64(pSemaphore, &cgen_var_191, 1);
     stream->write((uint64_t*)&cgen_var_191, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateSemaphore readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_192;
     stream->read((uint64_t*)&cgen_var_192, 8);
     stream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_192, (VkSemaphore*)pSemaphore, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateSemaphore returnUnmarshal");
     VkResult vkCreateSemaphore_VkResult_return = (VkResult)0;
     stream->read(&vkCreateSemaphore_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -3172,7 +2932,6 @@ void VkEncoder::vkDestroySemaphore(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroySemaphore encode");
     mImpl->log("start vkDestroySemaphore");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -3229,8 +2988,6 @@ void VkEncoder::vkDestroySemaphore(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroySemaphore readParams");
-    AEMU_SCOPED_TRACE("vkDestroySemaphore returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkSemaphore((VkSemaphore*)&semaphore);
     pool->freeAll();
     countingStream->clearPool();
@@ -3245,7 +3002,6 @@ VkResult VkEncoder::vkCreateEvent(
     VkEvent* pEvent)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateEvent encode");
     mImpl->log("start vkCreateEvent");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -3315,13 +3071,11 @@ VkResult VkEncoder::vkCreateEvent(
     stream->handleMapping()->mapHandles_VkEvent_u64(pEvent, &cgen_var_204, 1);
     stream->write((uint64_t*)&cgen_var_204, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateEvent readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_205;
     stream->read((uint64_t*)&cgen_var_205, 8);
     stream->handleMapping()->mapHandles_u64_VkEvent(&cgen_var_205, (VkEvent*)pEvent, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateEvent returnUnmarshal");
     VkResult vkCreateEvent_VkResult_return = (VkResult)0;
     stream->read(&vkCreateEvent_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -3337,7 +3091,6 @@ void VkEncoder::vkDestroyEvent(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyEvent encode");
     mImpl->log("start vkDestroyEvent");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -3394,8 +3147,6 @@ void VkEncoder::vkDestroyEvent(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyEvent readParams");
-    AEMU_SCOPED_TRACE("vkDestroyEvent returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkEvent((VkEvent*)&event);
     pool->freeAll();
     countingStream->clearPool();
@@ -3408,7 +3159,6 @@ VkResult VkEncoder::vkGetEventStatus(
     VkEvent event)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetEventStatus encode");
     mImpl->log("start vkGetEventStatus");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -3439,8 +3189,6 @@ VkResult VkEncoder::vkGetEventStatus(
     uint64_t cgen_var_215;
     stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_215, 1);
     stream->write((uint64_t*)&cgen_var_215, 1 * 8);
-    AEMU_SCOPED_TRACE("vkGetEventStatus readParams");
-    AEMU_SCOPED_TRACE("vkGetEventStatus returnUnmarshal");
     VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
     stream->read(&vkGetEventStatus_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -3455,7 +3203,6 @@ VkResult VkEncoder::vkSetEvent(
     VkEvent event)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkSetEvent encode");
     mImpl->log("start vkSetEvent");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -3486,8 +3233,6 @@ VkResult VkEncoder::vkSetEvent(
     uint64_t cgen_var_219;
     stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_219, 1);
     stream->write((uint64_t*)&cgen_var_219, 1 * 8);
-    AEMU_SCOPED_TRACE("vkSetEvent readParams");
-    AEMU_SCOPED_TRACE("vkSetEvent returnUnmarshal");
     VkResult vkSetEvent_VkResult_return = (VkResult)0;
     stream->read(&vkSetEvent_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -3502,7 +3247,6 @@ VkResult VkEncoder::vkResetEvent(
     VkEvent event)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkResetEvent encode");
     mImpl->log("start vkResetEvent");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -3533,8 +3277,6 @@ VkResult VkEncoder::vkResetEvent(
     uint64_t cgen_var_223;
     stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_223, 1);
     stream->write((uint64_t*)&cgen_var_223, 1 * 8);
-    AEMU_SCOPED_TRACE("vkResetEvent readParams");
-    AEMU_SCOPED_TRACE("vkResetEvent returnUnmarshal");
     VkResult vkResetEvent_VkResult_return = (VkResult)0;
     stream->read(&vkResetEvent_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -3551,7 +3293,6 @@ VkResult VkEncoder::vkCreateQueryPool(
     VkQueryPool* pQueryPool)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateQueryPool encode");
     mImpl->log("start vkCreateQueryPool");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -3621,13 +3362,11 @@ VkResult VkEncoder::vkCreateQueryPool(
     stream->handleMapping()->mapHandles_VkQueryPool_u64(pQueryPool, &cgen_var_229, 1);
     stream->write((uint64_t*)&cgen_var_229, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateQueryPool readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_230;
     stream->read((uint64_t*)&cgen_var_230, 8);
     stream->handleMapping()->mapHandles_u64_VkQueryPool(&cgen_var_230, (VkQueryPool*)pQueryPool, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateQueryPool returnUnmarshal");
     VkResult vkCreateQueryPool_VkResult_return = (VkResult)0;
     stream->read(&vkCreateQueryPool_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -3643,7 +3382,6 @@ void VkEncoder::vkDestroyQueryPool(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyQueryPool encode");
     mImpl->log("start vkDestroyQueryPool");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -3700,8 +3438,6 @@ void VkEncoder::vkDestroyQueryPool(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyQueryPool readParams");
-    AEMU_SCOPED_TRACE("vkDestroyQueryPool returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkQueryPool((VkQueryPool*)&queryPool);
     pool->freeAll();
     countingStream->clearPool();
@@ -3720,7 +3456,6 @@ VkResult VkEncoder::vkGetQueryPoolResults(
     VkQueryResultFlags flags)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetQueryPoolResults encode");
     mImpl->log("start vkGetQueryPoolResults");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -3775,9 +3510,7 @@ VkResult VkEncoder::vkGetQueryPoolResults(
     stream->write((void*)pData, ((dataSize)) * sizeof(uint8_t));
     stream->write((VkDeviceSize*)&local_stride, sizeof(VkDeviceSize));
     stream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
-    AEMU_SCOPED_TRACE("vkGetQueryPoolResults readParams");
     stream->read((void*)pData, ((dataSize)) * sizeof(uint8_t));
-    AEMU_SCOPED_TRACE("vkGetQueryPoolResults returnUnmarshal");
     VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0;
     stream->read(&vkGetQueryPoolResults_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -3794,7 +3527,6 @@ VkResult VkEncoder::vkCreateBuffer(
     VkBuffer* pBuffer)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateBuffer encode");
     mImpl->log("start vkCreateBuffer");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -3864,13 +3596,11 @@ VkResult VkEncoder::vkCreateBuffer(
     stream->handleMapping()->mapHandles_VkBuffer_u64(pBuffer, &cgen_var_248, 1);
     stream->write((uint64_t*)&cgen_var_248, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateBuffer readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_249;
     stream->read((uint64_t*)&cgen_var_249, 8);
     stream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_249, (VkBuffer*)pBuffer, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateBuffer returnUnmarshal");
     VkResult vkCreateBuffer_VkResult_return = (VkResult)0;
     stream->read(&vkCreateBuffer_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -3886,7 +3616,6 @@ void VkEncoder::vkDestroyBuffer(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyBuffer encode");
     mImpl->log("start vkDestroyBuffer");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -3943,8 +3672,6 @@ void VkEncoder::vkDestroyBuffer(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyBuffer readParams");
-    AEMU_SCOPED_TRACE("vkDestroyBuffer returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkBuffer((VkBuffer*)&buffer);
     pool->freeAll();
     countingStream->clearPool();
@@ -3959,7 +3686,6 @@ VkResult VkEncoder::vkCreateBufferView(
     VkBufferView* pView)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateBufferView encode");
     mImpl->log("start vkCreateBufferView");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -4029,13 +3755,11 @@ VkResult VkEncoder::vkCreateBufferView(
     stream->handleMapping()->mapHandles_VkBufferView_u64(pView, &cgen_var_261, 1);
     stream->write((uint64_t*)&cgen_var_261, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateBufferView readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_262;
     stream->read((uint64_t*)&cgen_var_262, 8);
     stream->handleMapping()->mapHandles_u64_VkBufferView(&cgen_var_262, (VkBufferView*)pView, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateBufferView returnUnmarshal");
     VkResult vkCreateBufferView_VkResult_return = (VkResult)0;
     stream->read(&vkCreateBufferView_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -4051,7 +3775,6 @@ void VkEncoder::vkDestroyBufferView(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyBufferView encode");
     mImpl->log("start vkDestroyBufferView");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -4108,8 +3831,6 @@ void VkEncoder::vkDestroyBufferView(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyBufferView readParams");
-    AEMU_SCOPED_TRACE("vkDestroyBufferView returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkBufferView((VkBufferView*)&bufferView);
     pool->freeAll();
     countingStream->clearPool();
@@ -4124,7 +3845,6 @@ VkResult VkEncoder::vkCreateImage(
     VkImage* pImage)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateImage encode");
     mImpl->log("start vkCreateImage");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -4195,13 +3915,11 @@ VkResult VkEncoder::vkCreateImage(
     stream->handleMapping()->mapHandles_VkImage_u64(pImage, &cgen_var_274, 1);
     stream->write((uint64_t*)&cgen_var_274, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateImage readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_275;
     stream->read((uint64_t*)&cgen_var_275, 8);
     stream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_275, (VkImage*)pImage, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateImage returnUnmarshal");
     VkResult vkCreateImage_VkResult_return = (VkResult)0;
     stream->read(&vkCreateImage_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -4217,7 +3935,6 @@ void VkEncoder::vkDestroyImage(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyImage encode");
     mImpl->log("start vkDestroyImage");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -4274,8 +3991,6 @@ void VkEncoder::vkDestroyImage(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyImage readParams");
-    AEMU_SCOPED_TRACE("vkDestroyImage returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkImage((VkImage*)&image);
     pool->freeAll();
     countingStream->clearPool();
@@ -4290,7 +4005,6 @@ void VkEncoder::vkGetImageSubresourceLayout(
     VkSubresourceLayout* pLayout)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout encode");
     mImpl->log("start vkGetImageSubresourceLayout");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -4336,13 +4050,11 @@ void VkEncoder::vkGetImageSubresourceLayout(
     stream->write((uint64_t*)&cgen_var_285, 1 * 8);
     marshal_VkImageSubresource(stream, (VkImageSubresource*)(local_pSubresource));
     marshal_VkSubresourceLayout(stream, (VkSubresourceLayout*)(pLayout));
-    AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout readParams");
     unmarshal_VkSubresourceLayout(stream, (VkSubresourceLayout*)(pLayout));
     if (pLayout)
     {
         transform_fromhost_VkSubresourceLayout(mImpl->resources(), (VkSubresourceLayout*)(pLayout));
     }
-    AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -4356,7 +4068,6 @@ VkResult VkEncoder::vkCreateImageView(
     VkImageView* pView)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateImageView encode");
     mImpl->log("start vkCreateImageView");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -4426,13 +4137,11 @@ VkResult VkEncoder::vkCreateImageView(
     stream->handleMapping()->mapHandles_VkImageView_u64(pView, &cgen_var_291, 1);
     stream->write((uint64_t*)&cgen_var_291, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateImageView readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_292;
     stream->read((uint64_t*)&cgen_var_292, 8);
     stream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_292, (VkImageView*)pView, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateImageView returnUnmarshal");
     VkResult vkCreateImageView_VkResult_return = (VkResult)0;
     stream->read(&vkCreateImageView_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -4448,7 +4157,6 @@ void VkEncoder::vkDestroyImageView(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyImageView encode");
     mImpl->log("start vkDestroyImageView");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -4505,8 +4213,6 @@ void VkEncoder::vkDestroyImageView(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyImageView readParams");
-    AEMU_SCOPED_TRACE("vkDestroyImageView returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkImageView((VkImageView*)&imageView);
     pool->freeAll();
     countingStream->clearPool();
@@ -4521,7 +4227,6 @@ VkResult VkEncoder::vkCreateShaderModule(
     VkShaderModule* pShaderModule)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateShaderModule encode");
     mImpl->log("start vkCreateShaderModule");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -4591,13 +4296,11 @@ VkResult VkEncoder::vkCreateShaderModule(
     stream->handleMapping()->mapHandles_VkShaderModule_u64(pShaderModule, &cgen_var_304, 1);
     stream->write((uint64_t*)&cgen_var_304, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateShaderModule readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_305;
     stream->read((uint64_t*)&cgen_var_305, 8);
     stream->handleMapping()->mapHandles_u64_VkShaderModule(&cgen_var_305, (VkShaderModule*)pShaderModule, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateShaderModule returnUnmarshal");
     VkResult vkCreateShaderModule_VkResult_return = (VkResult)0;
     stream->read(&vkCreateShaderModule_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -4613,7 +4316,6 @@ void VkEncoder::vkDestroyShaderModule(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyShaderModule encode");
     mImpl->log("start vkDestroyShaderModule");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -4670,8 +4372,6 @@ void VkEncoder::vkDestroyShaderModule(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyShaderModule readParams");
-    AEMU_SCOPED_TRACE("vkDestroyShaderModule returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkShaderModule((VkShaderModule*)&shaderModule);
     pool->freeAll();
     countingStream->clearPool();
@@ -4686,7 +4386,6 @@ VkResult VkEncoder::vkCreatePipelineCache(
     VkPipelineCache* pPipelineCache)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreatePipelineCache encode");
     mImpl->log("start vkCreatePipelineCache");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -4756,13 +4455,11 @@ VkResult VkEncoder::vkCreatePipelineCache(
     stream->handleMapping()->mapHandles_VkPipelineCache_u64(pPipelineCache, &cgen_var_317, 1);
     stream->write((uint64_t*)&cgen_var_317, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreatePipelineCache readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_318;
     stream->read((uint64_t*)&cgen_var_318, 8);
     stream->handleMapping()->mapHandles_u64_VkPipelineCache(&cgen_var_318, (VkPipelineCache*)pPipelineCache, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreatePipelineCache returnUnmarshal");
     VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0;
     stream->read(&vkCreatePipelineCache_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -4778,7 +4475,6 @@ void VkEncoder::vkDestroyPipelineCache(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyPipelineCache encode");
     mImpl->log("start vkDestroyPipelineCache");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -4835,8 +4531,6 @@ void VkEncoder::vkDestroyPipelineCache(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyPipelineCache readParams");
-    AEMU_SCOPED_TRACE("vkDestroyPipelineCache returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkPipelineCache((VkPipelineCache*)&pipelineCache);
     pool->freeAll();
     countingStream->clearPool();
@@ -4851,7 +4545,6 @@ VkResult VkEncoder::vkGetPipelineCacheData(
     void* pData)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPipelineCacheData encode");
     mImpl->log("start vkGetPipelineCacheData");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -4912,7 +4605,6 @@ VkResult VkEncoder::vkGetPipelineCacheData(
     {
         stream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
     }
-    AEMU_SCOPED_TRACE("vkGetPipelineCacheData readParams");
     // WARNING PTR CHECK
     size_t* check_pDataSize;
     check_pDataSize = (size_t*)(uintptr_t)stream->getBe64();
@@ -4935,7 +4627,6 @@ VkResult VkEncoder::vkGetPipelineCacheData(
         }
         stream->read((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
     }
-    AEMU_SCOPED_TRACE("vkGetPipelineCacheData returnUnmarshal");
     VkResult vkGetPipelineCacheData_VkResult_return = (VkResult)0;
     stream->read(&vkGetPipelineCacheData_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -4952,7 +4643,6 @@ VkResult VkEncoder::vkMergePipelineCaches(
     const VkPipelineCache* pSrcCaches)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkMergePipelineCaches encode");
     mImpl->log("start vkMergePipelineCaches");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -5007,8 +4697,6 @@ VkResult VkEncoder::vkMergePipelineCaches(
         stream->handleMapping()->mapHandles_VkPipelineCache_u64(local_pSrcCaches, cgen_var_343, ((srcCacheCount)));
         stream->write((uint64_t*)cgen_var_343, ((srcCacheCount)) * 8);
     }
-    AEMU_SCOPED_TRACE("vkMergePipelineCaches readParams");
-    AEMU_SCOPED_TRACE("vkMergePipelineCaches returnUnmarshal");
     VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0;
     stream->read(&vkMergePipelineCaches_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -5027,7 +4715,6 @@ VkResult VkEncoder::vkCreateGraphicsPipelines(
     VkPipeline* pPipelines)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateGraphicsPipelines encode");
     mImpl->log("start vkCreateGraphicsPipelines");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -5129,7 +4816,6 @@ VkResult VkEncoder::vkCreateGraphicsPipelines(
         stream->write((uint64_t*)cgen_var_351, ((createInfoCount)) * 8);
     }
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateGraphicsPipelines readParams");
     stream->setHandleMapping(resources->createMapping());
     if (((createInfoCount)))
     {
@@ -5139,7 +4825,6 @@ VkResult VkEncoder::vkCreateGraphicsPipelines(
         stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_352, (VkPipeline*)pPipelines, ((createInfoCount)));
     }
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateGraphicsPipelines returnUnmarshal");
     VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
     stream->read(&vkCreateGraphicsPipelines_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -5158,7 +4843,6 @@ VkResult VkEncoder::vkCreateComputePipelines(
     VkPipeline* pPipelines)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateComputePipelines encode");
     mImpl->log("start vkCreateComputePipelines");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -5260,7 +4944,6 @@ VkResult VkEncoder::vkCreateComputePipelines(
         stream->write((uint64_t*)cgen_var_360, ((createInfoCount)) * 8);
     }
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateComputePipelines readParams");
     stream->setHandleMapping(resources->createMapping());
     if (((createInfoCount)))
     {
@@ -5270,7 +4953,6 @@ VkResult VkEncoder::vkCreateComputePipelines(
         stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_361, (VkPipeline*)pPipelines, ((createInfoCount)));
     }
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateComputePipelines returnUnmarshal");
     VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0;
     stream->read(&vkCreateComputePipelines_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -5286,7 +4968,6 @@ void VkEncoder::vkDestroyPipeline(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyPipeline encode");
     mImpl->log("start vkDestroyPipeline");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -5343,8 +5024,6 @@ void VkEncoder::vkDestroyPipeline(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyPipeline readParams");
-    AEMU_SCOPED_TRACE("vkDestroyPipeline returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkPipeline((VkPipeline*)&pipeline);
     pool->freeAll();
     countingStream->clearPool();
@@ -5359,7 +5038,6 @@ VkResult VkEncoder::vkCreatePipelineLayout(
     VkPipelineLayout* pPipelineLayout)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreatePipelineLayout encode");
     mImpl->log("start vkCreatePipelineLayout");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -5429,13 +5107,11 @@ VkResult VkEncoder::vkCreatePipelineLayout(
     stream->handleMapping()->mapHandles_VkPipelineLayout_u64(pPipelineLayout, &cgen_var_373, 1);
     stream->write((uint64_t*)&cgen_var_373, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreatePipelineLayout readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_374;
     stream->read((uint64_t*)&cgen_var_374, 8);
     stream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_374, (VkPipelineLayout*)pPipelineLayout, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreatePipelineLayout returnUnmarshal");
     VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0;
     stream->read(&vkCreatePipelineLayout_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -5451,7 +5127,6 @@ void VkEncoder::vkDestroyPipelineLayout(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyPipelineLayout encode");
     mImpl->log("start vkDestroyPipelineLayout");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -5508,8 +5183,6 @@ void VkEncoder::vkDestroyPipelineLayout(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyPipelineLayout readParams");
-    AEMU_SCOPED_TRACE("vkDestroyPipelineLayout returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkPipelineLayout((VkPipelineLayout*)&pipelineLayout);
     pool->freeAll();
     countingStream->clearPool();
@@ -5524,7 +5197,6 @@ VkResult VkEncoder::vkCreateSampler(
     VkSampler* pSampler)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateSampler encode");
     mImpl->log("start vkCreateSampler");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -5594,13 +5266,11 @@ VkResult VkEncoder::vkCreateSampler(
     stream->handleMapping()->mapHandles_VkSampler_u64(pSampler, &cgen_var_386, 1);
     stream->write((uint64_t*)&cgen_var_386, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateSampler readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_387;
     stream->read((uint64_t*)&cgen_var_387, 8);
     stream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_387, (VkSampler*)pSampler, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateSampler returnUnmarshal");
     VkResult vkCreateSampler_VkResult_return = (VkResult)0;
     stream->read(&vkCreateSampler_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -5616,7 +5286,6 @@ void VkEncoder::vkDestroySampler(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroySampler encode");
     mImpl->log("start vkDestroySampler");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -5673,8 +5342,6 @@ void VkEncoder::vkDestroySampler(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroySampler readParams");
-    AEMU_SCOPED_TRACE("vkDestroySampler returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkSampler((VkSampler*)&sampler);
     pool->freeAll();
     countingStream->clearPool();
@@ -5689,7 +5356,6 @@ VkResult VkEncoder::vkCreateDescriptorSetLayout(
     VkDescriptorSetLayout* pSetLayout)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout encode");
     mImpl->log("start vkCreateDescriptorSetLayout");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -5759,13 +5425,11 @@ VkResult VkEncoder::vkCreateDescriptorSetLayout(
     stream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(pSetLayout, &cgen_var_399, 1);
     stream->write((uint64_t*)&cgen_var_399, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_400;
     stream->read((uint64_t*)&cgen_var_400, 8);
     stream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(&cgen_var_400, (VkDescriptorSetLayout*)pSetLayout, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout returnUnmarshal");
     VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDescriptorSetLayout_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -5781,7 +5445,6 @@ void VkEncoder::vkDestroyDescriptorSetLayout(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyDescriptorSetLayout encode");
     mImpl->log("start vkDestroyDescriptorSetLayout");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -5838,8 +5501,6 @@ void VkEncoder::vkDestroyDescriptorSetLayout(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyDescriptorSetLayout readParams");
-    AEMU_SCOPED_TRACE("vkDestroyDescriptorSetLayout returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)&descriptorSetLayout);
     pool->freeAll();
     countingStream->clearPool();
@@ -5854,7 +5515,6 @@ VkResult VkEncoder::vkCreateDescriptorPool(
     VkDescriptorPool* pDescriptorPool)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateDescriptorPool encode");
     mImpl->log("start vkCreateDescriptorPool");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -5924,13 +5584,11 @@ VkResult VkEncoder::vkCreateDescriptorPool(
     stream->handleMapping()->mapHandles_VkDescriptorPool_u64(pDescriptorPool, &cgen_var_412, 1);
     stream->write((uint64_t*)&cgen_var_412, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateDescriptorPool readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_413;
     stream->read((uint64_t*)&cgen_var_413, 8);
     stream->handleMapping()->mapHandles_u64_VkDescriptorPool(&cgen_var_413, (VkDescriptorPool*)pDescriptorPool, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateDescriptorPool returnUnmarshal");
     VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDescriptorPool_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -5946,7 +5604,6 @@ void VkEncoder::vkDestroyDescriptorPool(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyDescriptorPool encode");
     mImpl->log("start vkDestroyDescriptorPool");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -6003,8 +5660,6 @@ void VkEncoder::vkDestroyDescriptorPool(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyDescriptorPool readParams");
-    AEMU_SCOPED_TRACE("vkDestroyDescriptorPool returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkDescriptorPool((VkDescriptorPool*)&descriptorPool);
     pool->freeAll();
     countingStream->clearPool();
@@ -6018,7 +5673,6 @@ VkResult VkEncoder::vkResetDescriptorPool(
     VkDescriptorPoolResetFlags flags)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkResetDescriptorPool encode");
     mImpl->log("start vkResetDescriptorPool");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -6053,8 +5707,6 @@ VkResult VkEncoder::vkResetDescriptorPool(
     stream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_423, 1);
     stream->write((uint64_t*)&cgen_var_423, 1 * 8);
     stream->write((VkDescriptorPoolResetFlags*)&local_flags, sizeof(VkDescriptorPoolResetFlags));
-    AEMU_SCOPED_TRACE("vkResetDescriptorPool readParams");
-    AEMU_SCOPED_TRACE("vkResetDescriptorPool returnUnmarshal");
     VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0;
     stream->read(&vkResetDescriptorPool_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -6070,7 +5722,6 @@ VkResult VkEncoder::vkAllocateDescriptorSets(
     VkDescriptorSet* pDescriptorSets)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkAllocateDescriptorSets encode");
     mImpl->log("start vkAllocateDescriptorSets");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -6122,7 +5773,6 @@ VkResult VkEncoder::vkAllocateDescriptorSets(
         stream->write((uint64_t*)cgen_var_427, pAllocateInfo->descriptorSetCount * 8);
     }
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkAllocateDescriptorSets readParams");
     stream->setHandleMapping(resources->createMapping());
     if (pAllocateInfo->descriptorSetCount)
     {
@@ -6132,7 +5782,6 @@ VkResult VkEncoder::vkAllocateDescriptorSets(
         stream->handleMapping()->mapHandles_u64_VkDescriptorSet(cgen_var_428, (VkDescriptorSet*)pDescriptorSets, pAllocateInfo->descriptorSetCount);
     }
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkAllocateDescriptorSets returnUnmarshal");
     VkResult vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
     stream->read(&vkAllocateDescriptorSets_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -6149,7 +5798,6 @@ VkResult VkEncoder::vkFreeDescriptorSets(
     const VkDescriptorSet* pDescriptorSets)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkFreeDescriptorSets encode");
     mImpl->log("start vkFreeDescriptorSets");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -6216,8 +5864,6 @@ VkResult VkEncoder::vkFreeDescriptorSets(
             stream->write((uint64_t*)cgen_var_436, ((descriptorSetCount)) * 8);
         }
     }
-    AEMU_SCOPED_TRACE("vkFreeDescriptorSets readParams");
-    AEMU_SCOPED_TRACE("vkFreeDescriptorSets returnUnmarshal");
     VkResult vkFreeDescriptorSets_VkResult_return = (VkResult)0;
     stream->read(&vkFreeDescriptorSets_VkResult_return, sizeof(VkResult));
     if (pDescriptorSets)
@@ -6239,7 +5885,6 @@ void VkEncoder::vkUpdateDescriptorSets(
     const VkCopyDescriptorSet* pDescriptorCopies)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkUpdateDescriptorSets encode");
     mImpl->log("start vkUpdateDescriptorSets");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -6320,8 +5965,6 @@ void VkEncoder::vkUpdateDescriptorSets(
     {
         marshal_VkCopyDescriptorSet(stream, (VkCopyDescriptorSet*)(local_pDescriptorCopies + i));
     }
-    AEMU_SCOPED_TRACE("vkUpdateDescriptorSets readParams");
-    AEMU_SCOPED_TRACE("vkUpdateDescriptorSets returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -6335,7 +5978,6 @@ VkResult VkEncoder::vkCreateFramebuffer(
     VkFramebuffer* pFramebuffer)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateFramebuffer encode");
     mImpl->log("start vkCreateFramebuffer");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -6405,13 +6047,11 @@ VkResult VkEncoder::vkCreateFramebuffer(
     stream->handleMapping()->mapHandles_VkFramebuffer_u64(pFramebuffer, &cgen_var_444, 1);
     stream->write((uint64_t*)&cgen_var_444, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateFramebuffer readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_445;
     stream->read((uint64_t*)&cgen_var_445, 8);
     stream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_445, (VkFramebuffer*)pFramebuffer, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateFramebuffer returnUnmarshal");
     VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0;
     stream->read(&vkCreateFramebuffer_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -6427,7 +6067,6 @@ void VkEncoder::vkDestroyFramebuffer(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyFramebuffer encode");
     mImpl->log("start vkDestroyFramebuffer");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -6484,8 +6123,6 @@ void VkEncoder::vkDestroyFramebuffer(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyFramebuffer readParams");
-    AEMU_SCOPED_TRACE("vkDestroyFramebuffer returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkFramebuffer((VkFramebuffer*)&framebuffer);
     pool->freeAll();
     countingStream->clearPool();
@@ -6500,7 +6137,6 @@ VkResult VkEncoder::vkCreateRenderPass(
     VkRenderPass* pRenderPass)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateRenderPass encode");
     mImpl->log("start vkCreateRenderPass");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -6570,13 +6206,11 @@ VkResult VkEncoder::vkCreateRenderPass(
     stream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_457, 1);
     stream->write((uint64_t*)&cgen_var_457, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateRenderPass readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_458;
     stream->read((uint64_t*)&cgen_var_458, 8);
     stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_458, (VkRenderPass*)pRenderPass, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateRenderPass returnUnmarshal");
     VkResult vkCreateRenderPass_VkResult_return = (VkResult)0;
     stream->read(&vkCreateRenderPass_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -6592,7 +6226,6 @@ void VkEncoder::vkDestroyRenderPass(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyRenderPass encode");
     mImpl->log("start vkDestroyRenderPass");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -6649,8 +6282,6 @@ void VkEncoder::vkDestroyRenderPass(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyRenderPass readParams");
-    AEMU_SCOPED_TRACE("vkDestroyRenderPass returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkRenderPass((VkRenderPass*)&renderPass);
     pool->freeAll();
     countingStream->clearPool();
@@ -6664,7 +6295,6 @@ void VkEncoder::vkGetRenderAreaGranularity(
     VkExtent2D* pGranularity)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetRenderAreaGranularity encode");
     mImpl->log("start vkGetRenderAreaGranularity");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -6697,13 +6327,11 @@ void VkEncoder::vkGetRenderAreaGranularity(
     stream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_468, 1);
     stream->write((uint64_t*)&cgen_var_468, 1 * 8);
     marshal_VkExtent2D(stream, (VkExtent2D*)(pGranularity));
-    AEMU_SCOPED_TRACE("vkGetRenderAreaGranularity readParams");
     unmarshal_VkExtent2D(stream, (VkExtent2D*)(pGranularity));
     if (pGranularity)
     {
         transform_fromhost_VkExtent2D(mImpl->resources(), (VkExtent2D*)(pGranularity));
     }
-    AEMU_SCOPED_TRACE("vkGetRenderAreaGranularity returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -6717,7 +6345,6 @@ VkResult VkEncoder::vkCreateCommandPool(
     VkCommandPool* pCommandPool)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateCommandPool encode");
     mImpl->log("start vkCreateCommandPool");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -6787,13 +6414,11 @@ VkResult VkEncoder::vkCreateCommandPool(
     stream->handleMapping()->mapHandles_VkCommandPool_u64(pCommandPool, &cgen_var_474, 1);
     stream->write((uint64_t*)&cgen_var_474, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateCommandPool readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_475;
     stream->read((uint64_t*)&cgen_var_475, 8);
     stream->handleMapping()->mapHandles_u64_VkCommandPool(&cgen_var_475, (VkCommandPool*)pCommandPool, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateCommandPool returnUnmarshal");
     VkResult vkCreateCommandPool_VkResult_return = (VkResult)0;
     stream->read(&vkCreateCommandPool_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -6809,7 +6434,6 @@ void VkEncoder::vkDestroyCommandPool(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyCommandPool encode");
     mImpl->log("start vkDestroyCommandPool");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -6866,8 +6490,6 @@ void VkEncoder::vkDestroyCommandPool(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyCommandPool readParams");
-    AEMU_SCOPED_TRACE("vkDestroyCommandPool returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkCommandPool((VkCommandPool*)&commandPool);
     pool->freeAll();
     countingStream->clearPool();
@@ -6881,7 +6503,6 @@ VkResult VkEncoder::vkResetCommandPool(
     VkCommandPoolResetFlags flags)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkResetCommandPool encode");
     mImpl->log("start vkResetCommandPool");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -6916,8 +6537,6 @@ VkResult VkEncoder::vkResetCommandPool(
     stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_485, 1);
     stream->write((uint64_t*)&cgen_var_485, 1 * 8);
     stream->write((VkCommandPoolResetFlags*)&local_flags, sizeof(VkCommandPoolResetFlags));
-    AEMU_SCOPED_TRACE("vkResetCommandPool readParams");
-    AEMU_SCOPED_TRACE("vkResetCommandPool returnUnmarshal");
     VkResult vkResetCommandPool_VkResult_return = (VkResult)0;
     stream->read(&vkResetCommandPool_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -6933,7 +6552,6 @@ VkResult VkEncoder::vkAllocateCommandBuffers(
     VkCommandBuffer* pCommandBuffers)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkAllocateCommandBuffers encode");
     mImpl->log("start vkAllocateCommandBuffers");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -6985,7 +6603,6 @@ VkResult VkEncoder::vkAllocateCommandBuffers(
         stream->write((uint64_t*)cgen_var_489, pAllocateInfo->commandBufferCount * 8);
     }
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkAllocateCommandBuffers readParams");
     stream->setHandleMapping(resources->createMapping());
     if (pAllocateInfo->commandBufferCount)
     {
@@ -6995,7 +6612,6 @@ VkResult VkEncoder::vkAllocateCommandBuffers(
         stream->handleMapping()->mapHandles_u64_VkCommandBuffer(cgen_var_490, (VkCommandBuffer*)pCommandBuffers, pAllocateInfo->commandBufferCount);
     }
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkAllocateCommandBuffers returnUnmarshal");
     VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
     stream->read(&vkAllocateCommandBuffers_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -7012,7 +6628,6 @@ void VkEncoder::vkFreeCommandBuffers(
     const VkCommandBuffer* pCommandBuffers)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkFreeCommandBuffers encode");
     mImpl->log("start vkFreeCommandBuffers");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -7079,8 +6694,6 @@ void VkEncoder::vkFreeCommandBuffers(
             stream->write((uint64_t*)cgen_var_498, ((commandBufferCount)) * 8);
         }
     }
-    AEMU_SCOPED_TRACE("vkFreeCommandBuffers readParams");
-    AEMU_SCOPED_TRACE("vkFreeCommandBuffers returnUnmarshal");
     if (pCommandBuffers)
     {
         resources->destroyMapping()->mapHandles_VkCommandBuffer((VkCommandBuffer*)pCommandBuffers, ((commandBufferCount)));
@@ -7096,7 +6709,6 @@ VkResult VkEncoder::vkBeginCommandBuffer(
     const VkCommandBufferBeginInfo* pBeginInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkBeginCommandBuffer encode");
     mImpl->log("start vkBeginCommandBuffer");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -7132,8 +6744,6 @@ VkResult VkEncoder::vkBeginCommandBuffer(
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_500, 1);
     stream->write((uint64_t*)&cgen_var_500, 1 * 8);
     marshal_VkCommandBufferBeginInfo(stream, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
-    AEMU_SCOPED_TRACE("vkBeginCommandBuffer readParams");
-    AEMU_SCOPED_TRACE("vkBeginCommandBuffer returnUnmarshal");
     VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
     stream->read(&vkBeginCommandBuffer_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -7147,7 +6757,6 @@ VkResult VkEncoder::vkEndCommandBuffer(
     VkCommandBuffer commandBuffer)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkEndCommandBuffer encode");
     mImpl->log("start vkEndCommandBuffer");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -7170,8 +6779,6 @@ VkResult VkEncoder::vkEndCommandBuffer(
     uint64_t cgen_var_502;
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_502, 1);
     stream->write((uint64_t*)&cgen_var_502, 1 * 8);
-    AEMU_SCOPED_TRACE("vkEndCommandBuffer readParams");
-    AEMU_SCOPED_TRACE("vkEndCommandBuffer returnUnmarshal");
     VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
     stream->read(&vkEndCommandBuffer_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -7186,7 +6793,6 @@ VkResult VkEncoder::vkResetCommandBuffer(
     VkCommandBufferResetFlags flags)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkResetCommandBuffer encode");
     mImpl->log("start vkResetCommandBuffer");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -7213,8 +6819,6 @@ VkResult VkEncoder::vkResetCommandBuffer(
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_504, 1);
     stream->write((uint64_t*)&cgen_var_504, 1 * 8);
     stream->write((VkCommandBufferResetFlags*)&local_flags, sizeof(VkCommandBufferResetFlags));
-    AEMU_SCOPED_TRACE("vkResetCommandBuffer readParams");
-    AEMU_SCOPED_TRACE("vkResetCommandBuffer returnUnmarshal");
     VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
     stream->read(&vkResetCommandBuffer_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -7230,7 +6834,6 @@ void VkEncoder::vkCmdBindPipeline(
     VkPipeline pipeline)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdBindPipeline encode");
     mImpl->log("start vkCmdBindPipeline");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -7265,8 +6868,6 @@ void VkEncoder::vkCmdBindPipeline(
     uint64_t cgen_var_508;
     stream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_508, 1);
     stream->write((uint64_t*)&cgen_var_508, 1 * 8);
-    AEMU_SCOPED_TRACE("vkCmdBindPipeline readParams");
-    AEMU_SCOPED_TRACE("vkCmdBindPipeline returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -7280,7 +6881,6 @@ void VkEncoder::vkCmdSetViewport(
     const VkViewport* pViewports)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdSetViewport encode");
     mImpl->log("start vkCmdSetViewport");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -7336,8 +6936,6 @@ void VkEncoder::vkCmdSetViewport(
     {
         marshal_VkViewport(stream, (VkViewport*)(local_pViewports + i));
     }
-    AEMU_SCOPED_TRACE("vkCmdSetViewport readParams");
-    AEMU_SCOPED_TRACE("vkCmdSetViewport returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -7351,7 +6949,6 @@ void VkEncoder::vkCmdSetScissor(
     const VkRect2D* pScissors)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdSetScissor encode");
     mImpl->log("start vkCmdSetScissor");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -7407,8 +7004,6 @@ void VkEncoder::vkCmdSetScissor(
     {
         marshal_VkRect2D(stream, (VkRect2D*)(local_pScissors + i));
     }
-    AEMU_SCOPED_TRACE("vkCmdSetScissor readParams");
-    AEMU_SCOPED_TRACE("vkCmdSetScissor returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -7420,7 +7015,6 @@ void VkEncoder::vkCmdSetLineWidth(
     float lineWidth)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdSetLineWidth encode");
     mImpl->log("start vkCmdSetLineWidth");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -7447,8 +7041,6 @@ void VkEncoder::vkCmdSetLineWidth(
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_514, 1);
     stream->write((uint64_t*)&cgen_var_514, 1 * 8);
     stream->write((float*)&local_lineWidth, sizeof(float));
-    AEMU_SCOPED_TRACE("vkCmdSetLineWidth readParams");
-    AEMU_SCOPED_TRACE("vkCmdSetLineWidth returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -7462,7 +7054,6 @@ void VkEncoder::vkCmdSetDepthBias(
     float depthBiasSlopeFactor)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdSetDepthBias encode");
     mImpl->log("start vkCmdSetDepthBias");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -7497,8 +7088,6 @@ void VkEncoder::vkCmdSetDepthBias(
     stream->write((float*)&local_depthBiasConstantFactor, sizeof(float));
     stream->write((float*)&local_depthBiasClamp, sizeof(float));
     stream->write((float*)&local_depthBiasSlopeFactor, sizeof(float));
-    AEMU_SCOPED_TRACE("vkCmdSetDepthBias readParams");
-    AEMU_SCOPED_TRACE("vkCmdSetDepthBias returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -7510,7 +7099,6 @@ void VkEncoder::vkCmdSetBlendConstants(
     const float blendConstants[4])
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdSetBlendConstants encode");
     mImpl->log("start vkCmdSetBlendConstants");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -7537,8 +7125,6 @@ void VkEncoder::vkCmdSetBlendConstants(
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_518, 1);
     stream->write((uint64_t*)&cgen_var_518, 1 * 8);
     stream->write((float*)local_blendConstants, 4 * sizeof(float));
-    AEMU_SCOPED_TRACE("vkCmdSetBlendConstants readParams");
-    AEMU_SCOPED_TRACE("vkCmdSetBlendConstants returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -7551,7 +7137,6 @@ void VkEncoder::vkCmdSetDepthBounds(
     float maxDepthBounds)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdSetDepthBounds encode");
     mImpl->log("start vkCmdSetDepthBounds");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -7582,8 +7167,6 @@ void VkEncoder::vkCmdSetDepthBounds(
     stream->write((uint64_t*)&cgen_var_520, 1 * 8);
     stream->write((float*)&local_minDepthBounds, sizeof(float));
     stream->write((float*)&local_maxDepthBounds, sizeof(float));
-    AEMU_SCOPED_TRACE("vkCmdSetDepthBounds readParams");
-    AEMU_SCOPED_TRACE("vkCmdSetDepthBounds returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -7596,7 +7179,6 @@ void VkEncoder::vkCmdSetStencilCompareMask(
     uint32_t compareMask)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask encode");
     mImpl->log("start vkCmdSetStencilCompareMask");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -7627,8 +7209,6 @@ void VkEncoder::vkCmdSetStencilCompareMask(
     stream->write((uint64_t*)&cgen_var_522, 1 * 8);
     stream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
     stream->write((uint32_t*)&local_compareMask, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask readParams");
-    AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -7641,7 +7221,6 @@ void VkEncoder::vkCmdSetStencilWriteMask(
     uint32_t writeMask)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask encode");
     mImpl->log("start vkCmdSetStencilWriteMask");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -7672,8 +7251,6 @@ void VkEncoder::vkCmdSetStencilWriteMask(
     stream->write((uint64_t*)&cgen_var_524, 1 * 8);
     stream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
     stream->write((uint32_t*)&local_writeMask, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask readParams");
-    AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -7686,7 +7263,6 @@ void VkEncoder::vkCmdSetStencilReference(
     uint32_t reference)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdSetStencilReference encode");
     mImpl->log("start vkCmdSetStencilReference");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -7717,8 +7293,6 @@ void VkEncoder::vkCmdSetStencilReference(
     stream->write((uint64_t*)&cgen_var_526, 1 * 8);
     stream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
     stream->write((uint32_t*)&local_reference, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdSetStencilReference readParams");
-    AEMU_SCOPED_TRACE("vkCmdSetStencilReference returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -7736,7 +7310,6 @@ void VkEncoder::vkCmdBindDescriptorSets(
     const uint32_t* pDynamicOffsets)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdBindDescriptorSets encode");
     mImpl->log("start vkCmdBindDescriptorSets");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -7811,8 +7384,6 @@ void VkEncoder::vkCmdBindDescriptorSets(
     }
     stream->write((uint32_t*)&local_dynamicOffsetCount, sizeof(uint32_t));
     stream->write((uint32_t*)local_pDynamicOffsets, ((dynamicOffsetCount)) * sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdBindDescriptorSets readParams");
-    AEMU_SCOPED_TRACE("vkCmdBindDescriptorSets returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -7826,7 +7397,6 @@ void VkEncoder::vkCmdBindIndexBuffer(
     VkIndexType indexType)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer encode");
     mImpl->log("start vkCmdBindIndexBuffer");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -7865,8 +7435,6 @@ void VkEncoder::vkCmdBindIndexBuffer(
     stream->write((uint64_t*)&cgen_var_536, 1 * 8);
     stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
     stream->write((VkIndexType*)&local_indexType, sizeof(VkIndexType));
-    AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer readParams");
-    AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -7881,7 +7449,6 @@ void VkEncoder::vkCmdBindVertexBuffers(
     const VkDeviceSize* pOffsets)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers encode");
     mImpl->log("start vkCmdBindVertexBuffers");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -7940,8 +7507,6 @@ void VkEncoder::vkCmdBindVertexBuffers(
         stream->write((uint64_t*)cgen_var_540, ((bindingCount)) * 8);
     }
     stream->write((VkDeviceSize*)local_pOffsets, ((bindingCount)) * sizeof(VkDeviceSize));
-    AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers readParams");
-    AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -7956,7 +7521,6 @@ void VkEncoder::vkCmdDraw(
     uint32_t firstInstance)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdDraw encode");
     mImpl->log("start vkCmdDraw");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -7995,8 +7559,6 @@ void VkEncoder::vkCmdDraw(
     stream->write((uint32_t*)&local_instanceCount, sizeof(uint32_t));
     stream->write((uint32_t*)&local_firstVertex, sizeof(uint32_t));
     stream->write((uint32_t*)&local_firstInstance, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdDraw readParams");
-    AEMU_SCOPED_TRACE("vkCmdDraw returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -8012,7 +7574,6 @@ void VkEncoder::vkCmdDrawIndexed(
     uint32_t firstInstance)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdDrawIndexed encode");
     mImpl->log("start vkCmdDrawIndexed");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -8055,8 +7616,6 @@ void VkEncoder::vkCmdDrawIndexed(
     stream->write((uint32_t*)&local_firstIndex, sizeof(uint32_t));
     stream->write((int32_t*)&local_vertexOffset, sizeof(int32_t));
     stream->write((uint32_t*)&local_firstInstance, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdDrawIndexed readParams");
-    AEMU_SCOPED_TRACE("vkCmdDrawIndexed returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -8071,7 +7630,6 @@ void VkEncoder::vkCmdDrawIndirect(
     uint32_t stride)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdDrawIndirect encode");
     mImpl->log("start vkCmdDrawIndirect");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -8114,8 +7672,6 @@ void VkEncoder::vkCmdDrawIndirect(
     stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
     stream->write((uint32_t*)&local_drawCount, sizeof(uint32_t));
     stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdDrawIndirect readParams");
-    AEMU_SCOPED_TRACE("vkCmdDrawIndirect returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -8130,7 +7686,6 @@ void VkEncoder::vkCmdDrawIndexedIndirect(
     uint32_t stride)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect encode");
     mImpl->log("start vkCmdDrawIndexedIndirect");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -8173,8 +7728,6 @@ void VkEncoder::vkCmdDrawIndexedIndirect(
     stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
     stream->write((uint32_t*)&local_drawCount, sizeof(uint32_t));
     stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect readParams");
-    AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -8188,7 +7741,6 @@ void VkEncoder::vkCmdDispatch(
     uint32_t groupCountZ)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdDispatch encode");
     mImpl->log("start vkCmdDispatch");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -8223,8 +7775,6 @@ void VkEncoder::vkCmdDispatch(
     stream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t));
     stream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t));
     stream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdDispatch readParams");
-    AEMU_SCOPED_TRACE("vkCmdDispatch returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -8237,7 +7787,6 @@ void VkEncoder::vkCmdDispatchIndirect(
     VkDeviceSize offset)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdDispatchIndirect encode");
     mImpl->log("start vkCmdDispatchIndirect");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -8272,8 +7821,6 @@ void VkEncoder::vkCmdDispatchIndirect(
     stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_558, 1);
     stream->write((uint64_t*)&cgen_var_558, 1 * 8);
     stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
-    AEMU_SCOPED_TRACE("vkCmdDispatchIndirect readParams");
-    AEMU_SCOPED_TRACE("vkCmdDispatchIndirect returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -8288,7 +7835,6 @@ void VkEncoder::vkCmdCopyBuffer(
     const VkBufferCopy* pRegions)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdCopyBuffer encode");
     mImpl->log("start vkCmdCopyBuffer");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -8356,8 +7902,6 @@ void VkEncoder::vkCmdCopyBuffer(
     {
         marshal_VkBufferCopy(stream, (VkBufferCopy*)(local_pRegions + i));
     }
-    AEMU_SCOPED_TRACE("vkCmdCopyBuffer readParams");
-    AEMU_SCOPED_TRACE("vkCmdCopyBuffer returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -8374,7 +7918,6 @@ void VkEncoder::vkCmdCopyImage(
     const VkImageCopy* pRegions)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdCopyImage encode");
     mImpl->log("start vkCmdCopyImage");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -8450,8 +7993,6 @@ void VkEncoder::vkCmdCopyImage(
     {
         marshal_VkImageCopy(stream, (VkImageCopy*)(local_pRegions + i));
     }
-    AEMU_SCOPED_TRACE("vkCmdCopyImage readParams");
-    AEMU_SCOPED_TRACE("vkCmdCopyImage returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -8469,7 +8010,6 @@ void VkEncoder::vkCmdBlitImage(
     VkFilter filter)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdBlitImage encode");
     mImpl->log("start vkCmdBlitImage");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -8549,8 +8089,6 @@ void VkEncoder::vkCmdBlitImage(
         marshal_VkImageBlit(stream, (VkImageBlit*)(local_pRegions + i));
     }
     stream->write((VkFilter*)&local_filter, sizeof(VkFilter));
-    AEMU_SCOPED_TRACE("vkCmdBlitImage readParams");
-    AEMU_SCOPED_TRACE("vkCmdBlitImage returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -8566,7 +8104,6 @@ void VkEncoder::vkCmdCopyBufferToImage(
     const VkBufferImageCopy* pRegions)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage encode");
     mImpl->log("start vkCmdCopyBufferToImage");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -8638,8 +8175,6 @@ void VkEncoder::vkCmdCopyBufferToImage(
     {
         marshal_VkBufferImageCopy(stream, (VkBufferImageCopy*)(local_pRegions + i));
     }
-    AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage readParams");
-    AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -8655,7 +8190,6 @@ void VkEncoder::vkCmdCopyImageToBuffer(
     const VkBufferImageCopy* pRegions)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer encode");
     mImpl->log("start vkCmdCopyImageToBuffer");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -8727,8 +8261,6 @@ void VkEncoder::vkCmdCopyImageToBuffer(
     {
         marshal_VkBufferImageCopy(stream, (VkBufferImageCopy*)(local_pRegions + i));
     }
-    AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer readParams");
-    AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -8743,7 +8275,6 @@ void VkEncoder::vkCmdUpdateBuffer(
     const void* pData)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdUpdateBuffer encode");
     mImpl->log("start vkCmdUpdateBuffer");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -8790,8 +8321,6 @@ void VkEncoder::vkCmdUpdateBuffer(
     stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
     stream->write((VkDeviceSize*)&local_dataSize, sizeof(VkDeviceSize));
     stream->write((void*)local_pData, ((dataSize)) * sizeof(uint8_t));
-    AEMU_SCOPED_TRACE("vkCmdUpdateBuffer readParams");
-    AEMU_SCOPED_TRACE("vkCmdUpdateBuffer returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -8806,7 +8335,6 @@ void VkEncoder::vkCmdFillBuffer(
     uint32_t data)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdFillBuffer encode");
     mImpl->log("start vkCmdFillBuffer");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -8849,8 +8377,6 @@ void VkEncoder::vkCmdFillBuffer(
     stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
     stream->write((VkDeviceSize*)&local_size, sizeof(VkDeviceSize));
     stream->write((uint32_t*)&local_data, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdFillBuffer readParams");
-    AEMU_SCOPED_TRACE("vkCmdFillBuffer returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -8866,7 +8392,6 @@ void VkEncoder::vkCmdClearColorImage(
     const VkImageSubresourceRange* pRanges)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdClearColorImage encode");
     mImpl->log("start vkCmdClearColorImage");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -8943,8 +8468,6 @@ void VkEncoder::vkCmdClearColorImage(
     {
         marshal_VkImageSubresourceRange(stream, (VkImageSubresourceRange*)(local_pRanges + i));
     }
-    AEMU_SCOPED_TRACE("vkCmdClearColorImage readParams");
-    AEMU_SCOPED_TRACE("vkCmdClearColorImage returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -8960,7 +8483,6 @@ void VkEncoder::vkCmdClearDepthStencilImage(
     const VkImageSubresourceRange* pRanges)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage encode");
     mImpl->log("start vkCmdClearDepthStencilImage");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -9037,8 +8559,6 @@ void VkEncoder::vkCmdClearDepthStencilImage(
     {
         marshal_VkImageSubresourceRange(stream, (VkImageSubresourceRange*)(local_pRanges + i));
     }
-    AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage readParams");
-    AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -9053,7 +8573,6 @@ void VkEncoder::vkCmdClearAttachments(
     const VkClearRect* pRects)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdClearAttachments encode");
     mImpl->log("start vkCmdClearAttachments");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -9134,8 +8653,6 @@ void VkEncoder::vkCmdClearAttachments(
     {
         marshal_VkClearRect(stream, (VkClearRect*)(local_pRects + i));
     }
-    AEMU_SCOPED_TRACE("vkCmdClearAttachments readParams");
-    AEMU_SCOPED_TRACE("vkCmdClearAttachments returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -9152,7 +8669,6 @@ void VkEncoder::vkCmdResolveImage(
     const VkImageResolve* pRegions)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdResolveImage encode");
     mImpl->log("start vkCmdResolveImage");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -9228,8 +8744,6 @@ void VkEncoder::vkCmdResolveImage(
     {
         marshal_VkImageResolve(stream, (VkImageResolve*)(local_pRegions + i));
     }
-    AEMU_SCOPED_TRACE("vkCmdResolveImage readParams");
-    AEMU_SCOPED_TRACE("vkCmdResolveImage returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -9242,7 +8756,6 @@ void VkEncoder::vkCmdSetEvent(
     VkPipelineStageFlags stageMask)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdSetEvent encode");
     mImpl->log("start vkCmdSetEvent");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -9277,8 +8790,6 @@ void VkEncoder::vkCmdSetEvent(
     stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_616, 1);
     stream->write((uint64_t*)&cgen_var_616, 1 * 8);
     stream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
-    AEMU_SCOPED_TRACE("vkCmdSetEvent readParams");
-    AEMU_SCOPED_TRACE("vkCmdSetEvent returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -9291,7 +8802,6 @@ void VkEncoder::vkCmdResetEvent(
     VkPipelineStageFlags stageMask)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdResetEvent encode");
     mImpl->log("start vkCmdResetEvent");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -9326,8 +8836,6 @@ void VkEncoder::vkCmdResetEvent(
     stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_620, 1);
     stream->write((uint64_t*)&cgen_var_620, 1 * 8);
     stream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
-    AEMU_SCOPED_TRACE("vkCmdResetEvent readParams");
-    AEMU_SCOPED_TRACE("vkCmdResetEvent returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -9348,7 +8856,6 @@ void VkEncoder::vkCmdWaitEvents(
     const VkImageMemoryBarrier* pImageMemoryBarriers)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdWaitEvents encode");
     mImpl->log("start vkCmdWaitEvents");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -9490,8 +8997,6 @@ void VkEncoder::vkCmdWaitEvents(
     {
         marshal_VkImageMemoryBarrier(stream, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
     }
-    AEMU_SCOPED_TRACE("vkCmdWaitEvents readParams");
-    AEMU_SCOPED_TRACE("vkCmdWaitEvents returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -9511,7 +9016,6 @@ void VkEncoder::vkCmdPipelineBarrier(
     const VkImageMemoryBarrier* pImageMemoryBarriers)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdPipelineBarrier encode");
     mImpl->log("start vkCmdPipelineBarrier");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -9633,8 +9137,6 @@ void VkEncoder::vkCmdPipelineBarrier(
     {
         marshal_VkImageMemoryBarrier(stream, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
     }
-    AEMU_SCOPED_TRACE("vkCmdPipelineBarrier readParams");
-    AEMU_SCOPED_TRACE("vkCmdPipelineBarrier returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -9648,7 +9150,6 @@ void VkEncoder::vkCmdBeginQuery(
     VkQueryControlFlags flags)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdBeginQuery encode");
     mImpl->log("start vkCmdBeginQuery");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -9687,8 +9188,6 @@ void VkEncoder::vkCmdBeginQuery(
     stream->write((uint64_t*)&cgen_var_630, 1 * 8);
     stream->write((uint32_t*)&local_query, sizeof(uint32_t));
     stream->write((VkQueryControlFlags*)&local_flags, sizeof(VkQueryControlFlags));
-    AEMU_SCOPED_TRACE("vkCmdBeginQuery readParams");
-    AEMU_SCOPED_TRACE("vkCmdBeginQuery returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -9701,7 +9200,6 @@ void VkEncoder::vkCmdEndQuery(
     uint32_t query)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdEndQuery encode");
     mImpl->log("start vkCmdEndQuery");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -9736,8 +9234,6 @@ void VkEncoder::vkCmdEndQuery(
     stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_634, 1);
     stream->write((uint64_t*)&cgen_var_634, 1 * 8);
     stream->write((uint32_t*)&local_query, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdEndQuery readParams");
-    AEMU_SCOPED_TRACE("vkCmdEndQuery returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -9751,7 +9247,6 @@ void VkEncoder::vkCmdResetQueryPool(
     uint32_t queryCount)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdResetQueryPool encode");
     mImpl->log("start vkCmdResetQueryPool");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -9790,8 +9285,6 @@ void VkEncoder::vkCmdResetQueryPool(
     stream->write((uint64_t*)&cgen_var_638, 1 * 8);
     stream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
     stream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdResetQueryPool readParams");
-    AEMU_SCOPED_TRACE("vkCmdResetQueryPool returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -9805,7 +9298,6 @@ void VkEncoder::vkCmdWriteTimestamp(
     uint32_t query)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdWriteTimestamp encode");
     mImpl->log("start vkCmdWriteTimestamp");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -9844,8 +9336,6 @@ void VkEncoder::vkCmdWriteTimestamp(
     stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_642, 1);
     stream->write((uint64_t*)&cgen_var_642, 1 * 8);
     stream->write((uint32_t*)&local_query, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdWriteTimestamp readParams");
-    AEMU_SCOPED_TRACE("vkCmdWriteTimestamp returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -9863,7 +9353,6 @@ void VkEncoder::vkCmdCopyQueryPoolResults(
     VkQueryResultFlags flags)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdCopyQueryPoolResults encode");
     mImpl->log("start vkCmdCopyQueryPoolResults");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -9922,8 +9411,6 @@ void VkEncoder::vkCmdCopyQueryPoolResults(
     stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
     stream->write((VkDeviceSize*)&local_stride, sizeof(VkDeviceSize));
     stream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
-    AEMU_SCOPED_TRACE("vkCmdCopyQueryPoolResults readParams");
-    AEMU_SCOPED_TRACE("vkCmdCopyQueryPoolResults returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -9939,7 +9426,6 @@ void VkEncoder::vkCmdPushConstants(
     const void* pValues)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdPushConstants encode");
     mImpl->log("start vkCmdPushConstants");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -9990,8 +9476,6 @@ void VkEncoder::vkCmdPushConstants(
     stream->write((uint32_t*)&local_offset, sizeof(uint32_t));
     stream->write((uint32_t*)&local_size, sizeof(uint32_t));
     stream->write((void*)local_pValues, ((size)) * sizeof(uint8_t));
-    AEMU_SCOPED_TRACE("vkCmdPushConstants readParams");
-    AEMU_SCOPED_TRACE("vkCmdPushConstants returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -10004,7 +9488,6 @@ void VkEncoder::vkCmdBeginRenderPass(
     VkSubpassContents contents)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdBeginRenderPass encode");
     mImpl->log("start vkCmdBeginRenderPass");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -10044,8 +9527,6 @@ void VkEncoder::vkCmdBeginRenderPass(
     stream->write((uint64_t*)&cgen_var_654, 1 * 8);
     marshal_VkRenderPassBeginInfo(stream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
     stream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
-    AEMU_SCOPED_TRACE("vkCmdBeginRenderPass readParams");
-    AEMU_SCOPED_TRACE("vkCmdBeginRenderPass returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -10057,7 +9538,6 @@ void VkEncoder::vkCmdNextSubpass(
     VkSubpassContents contents)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdNextSubpass encode");
     mImpl->log("start vkCmdNextSubpass");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -10084,8 +9564,6 @@ void VkEncoder::vkCmdNextSubpass(
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_656, 1);
     stream->write((uint64_t*)&cgen_var_656, 1 * 8);
     stream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
-    AEMU_SCOPED_TRACE("vkCmdNextSubpass readParams");
-    AEMU_SCOPED_TRACE("vkCmdNextSubpass returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -10096,7 +9574,6 @@ void VkEncoder::vkCmdEndRenderPass(
     VkCommandBuffer commandBuffer)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdEndRenderPass encode");
     mImpl->log("start vkCmdEndRenderPass");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -10119,8 +9596,6 @@ void VkEncoder::vkCmdEndRenderPass(
     uint64_t cgen_var_658;
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_658, 1);
     stream->write((uint64_t*)&cgen_var_658, 1 * 8);
-    AEMU_SCOPED_TRACE("vkCmdEndRenderPass readParams");
-    AEMU_SCOPED_TRACE("vkCmdEndRenderPass returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -10133,7 +9608,6 @@ void VkEncoder::vkCmdExecuteCommands(
     const VkCommandBuffer* pCommandBuffers)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdExecuteCommands encode");
     mImpl->log("start vkCmdExecuteCommands");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -10180,8 +9654,6 @@ void VkEncoder::vkCmdExecuteCommands(
         stream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_662, ((commandBufferCount)));
         stream->write((uint64_t*)cgen_var_662, ((commandBufferCount)) * 8);
     }
-    AEMU_SCOPED_TRACE("vkCmdExecuteCommands readParams");
-    AEMU_SCOPED_TRACE("vkCmdExecuteCommands returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -10194,7 +9666,6 @@ VkResult VkEncoder::vkEnumerateInstanceVersion(
     uint32_t* pApiVersion)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkEnumerateInstanceVersion encode");
     mImpl->log("start vkEnumerateInstanceVersion");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -10211,9 +9682,7 @@ VkResult VkEncoder::vkEnumerateInstanceVersion(
     stream->write(&opcode_vkEnumerateInstanceVersion, sizeof(uint32_t));
     stream->write(&packetSize_vkEnumerateInstanceVersion, sizeof(uint32_t));
     stream->write((uint32_t*)pApiVersion, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkEnumerateInstanceVersion readParams");
     stream->read((uint32_t*)pApiVersion, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkEnumerateInstanceVersion returnUnmarshal");
     VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
     stream->read(&vkEnumerateInstanceVersion_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -10229,7 +9698,6 @@ VkResult VkEncoder::vkBindBufferMemory2(
     const VkBindBufferMemoryInfo* pBindInfos)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkBindBufferMemory2 encode");
     mImpl->log("start vkBindBufferMemory2");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -10281,8 +9749,6 @@ VkResult VkEncoder::vkBindBufferMemory2(
     {
         marshal_VkBindBufferMemoryInfo(stream, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
     }
-    AEMU_SCOPED_TRACE("vkBindBufferMemory2 readParams");
-    AEMU_SCOPED_TRACE("vkBindBufferMemory2 returnUnmarshal");
     VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
     stream->read(&vkBindBufferMemory2_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -10298,7 +9764,6 @@ VkResult VkEncoder::vkBindImageMemory2(
     const VkBindImageMemoryInfo* pBindInfos)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkBindImageMemory2 encode");
     mImpl->log("start vkBindImageMemory2");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -10350,8 +9815,6 @@ VkResult VkEncoder::vkBindImageMemory2(
     {
         marshal_VkBindImageMemoryInfo(stream, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
     }
-    AEMU_SCOPED_TRACE("vkBindImageMemory2 readParams");
-    AEMU_SCOPED_TRACE("vkBindImageMemory2 returnUnmarshal");
     VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
     stream->read(&vkBindImageMemory2_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -10369,7 +9832,6 @@ void VkEncoder::vkGetDeviceGroupPeerMemoryFeatures(
     VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures encode");
     mImpl->log("start vkGetDeviceGroupPeerMemoryFeatures");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -10406,9 +9868,7 @@ void VkEncoder::vkGetDeviceGroupPeerMemoryFeatures(
     stream->write((uint32_t*)&local_localDeviceIndex, sizeof(uint32_t));
     stream->write((uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t));
     stream->write((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
-    AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures readParams");
     stream->read((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
-    AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -10420,7 +9880,6 @@ void VkEncoder::vkCmdSetDeviceMask(
     uint32_t deviceMask)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdSetDeviceMask encode");
     mImpl->log("start vkCmdSetDeviceMask");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -10447,8 +9906,6 @@ void VkEncoder::vkCmdSetDeviceMask(
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_670, 1);
     stream->write((uint64_t*)&cgen_var_670, 1 * 8);
     stream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdSetDeviceMask readParams");
-    AEMU_SCOPED_TRACE("vkCmdSetDeviceMask returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -10465,7 +9922,6 @@ void VkEncoder::vkCmdDispatchBase(
     uint32_t groupCountZ)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdDispatchBase encode");
     mImpl->log("start vkCmdDispatchBase");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -10512,8 +9968,6 @@ void VkEncoder::vkCmdDispatchBase(
     stream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t));
     stream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t));
     stream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdDispatchBase readParams");
-    AEMU_SCOPED_TRACE("vkCmdDispatchBase returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -10526,7 +9980,6 @@ VkResult VkEncoder::vkEnumeratePhysicalDeviceGroups(
     VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroups encode");
     mImpl->log("start vkEnumeratePhysicalDeviceGroups");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -10583,7 +10036,6 @@ VkResult VkEncoder::vkEnumeratePhysicalDeviceGroups(
             marshal_VkPhysicalDeviceGroupProperties(stream, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroups readParams");
     // WARNING PTR CHECK
     uint32_t* check_pPhysicalDeviceGroupCount;
     check_pPhysicalDeviceGroupCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -10616,7 +10068,6 @@ VkResult VkEncoder::vkEnumeratePhysicalDeviceGroups(
             transform_fromhost_VkPhysicalDeviceGroupProperties(mImpl->resources(), (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroups returnUnmarshal");
     VkResult vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
     stream->read(&vkEnumeratePhysicalDeviceGroups_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -10632,7 +10083,6 @@ void VkEncoder::vkGetImageMemoryRequirements2(
     VkMemoryRequirements2* pMemoryRequirements)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2 encode");
     mImpl->log("start vkGetImageMemoryRequirements2");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -10670,13 +10120,11 @@ void VkEncoder::vkGetImageMemoryRequirements2(
     stream->write((uint64_t*)&cgen_var_682, 1 * 8);
     marshal_VkImageMemoryRequirementsInfo2(stream, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
     marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
-    AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2 readParams");
     unmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
     if (pMemoryRequirements)
     {
         transform_fromhost_VkMemoryRequirements2(mImpl->resources(), (VkMemoryRequirements2*)(pMemoryRequirements));
     }
-    AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2 returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -10689,7 +10137,6 @@ void VkEncoder::vkGetBufferMemoryRequirements2(
     VkMemoryRequirements2* pMemoryRequirements)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2 encode");
     mImpl->log("start vkGetBufferMemoryRequirements2");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -10727,13 +10174,11 @@ void VkEncoder::vkGetBufferMemoryRequirements2(
     stream->write((uint64_t*)&cgen_var_684, 1 * 8);
     marshal_VkBufferMemoryRequirementsInfo2(stream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
     marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
-    AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2 readParams");
     unmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
     if (pMemoryRequirements)
     {
         transform_fromhost_VkMemoryRequirements2(mImpl->resources(), (VkMemoryRequirements2*)(pMemoryRequirements));
     }
-    AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2 returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -10747,7 +10192,6 @@ void VkEncoder::vkGetImageSparseMemoryRequirements2(
     VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2 encode");
     mImpl->log("start vkGetImageSparseMemoryRequirements2");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -10817,7 +10261,6 @@ void VkEncoder::vkGetImageSparseMemoryRequirements2(
             marshal_VkSparseImageMemoryRequirements2(stream, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2 readParams");
     // WARNING PTR CHECK
     uint32_t* check_pSparseMemoryRequirementCount;
     check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -10850,7 +10293,6 @@ void VkEncoder::vkGetImageSparseMemoryRequirements2(
             transform_fromhost_VkSparseImageMemoryRequirements2(mImpl->resources(), (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2 returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -10862,7 +10304,6 @@ void VkEncoder::vkGetPhysicalDeviceFeatures2(
     VkPhysicalDeviceFeatures2* pFeatures)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2 encode");
     mImpl->log("start vkGetPhysicalDeviceFeatures2");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -10887,13 +10328,11 @@ void VkEncoder::vkGetPhysicalDeviceFeatures2(
     stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_694, 1);
     stream->write((uint64_t*)&cgen_var_694, 1 * 8);
     marshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2 readParams");
     unmarshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures));
     if (pFeatures)
     {
         transform_fromhost_VkPhysicalDeviceFeatures2(mImpl->resources(), (VkPhysicalDeviceFeatures2*)(pFeatures));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2 returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -10905,7 +10344,6 @@ void VkEncoder::vkGetPhysicalDeviceProperties2(
     VkPhysicalDeviceProperties2* pProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2 encode");
     mImpl->log("start vkGetPhysicalDeviceProperties2");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -10930,13 +10368,11 @@ void VkEncoder::vkGetPhysicalDeviceProperties2(
     stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_696, 1);
     stream->write((uint64_t*)&cgen_var_696, 1 * 8);
     marshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2 readParams");
     unmarshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties));
     if (pProperties)
     {
         transform_fromhost_VkPhysicalDeviceProperties2(mImpl->resources(), (VkPhysicalDeviceProperties2*)(pProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2 returnUnmarshal");
     mImpl->resources()->on_vkGetPhysicalDeviceProperties2(this, physicalDevice, pProperties);
     pool->freeAll();
     countingStream->clearPool();
@@ -10950,7 +10386,6 @@ void VkEncoder::vkGetPhysicalDeviceFormatProperties2(
     VkFormatProperties2* pFormatProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2 encode");
     mImpl->log("start vkGetPhysicalDeviceFormatProperties2");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -10979,13 +10414,11 @@ void VkEncoder::vkGetPhysicalDeviceFormatProperties2(
     stream->write((uint64_t*)&cgen_var_698, 1 * 8);
     stream->write((VkFormat*)&local_format, sizeof(VkFormat));
     marshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2 readParams");
     unmarshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties));
     if (pFormatProperties)
     {
         transform_fromhost_VkFormatProperties2(mImpl->resources(), (VkFormatProperties2*)(pFormatProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2 returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -10998,7 +10431,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties2(
     VkImageFormatProperties2* pImageFormatProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2 encode");
     mImpl->log("start vkGetPhysicalDeviceImageFormatProperties2");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -11036,13 +10468,11 @@ VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties2(
     stream->write((uint64_t*)&cgen_var_700, 1 * 8);
     marshal_VkPhysicalDeviceImageFormatInfo2(stream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
     marshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2 readParams");
     unmarshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties));
     if (pImageFormatProperties)
     {
         transform_fromhost_VkImageFormatProperties2(mImpl->resources(), (VkImageFormatProperties2*)(pImageFormatProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2 returnUnmarshal");
     VkResult vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceImageFormatProperties2_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -11058,7 +10488,6 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2(
     VkQueueFamilyProperties2* pQueueFamilyProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2 encode");
     mImpl->log("start vkGetPhysicalDeviceQueueFamilyProperties2");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -11115,7 +10544,6 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2(
             marshal_VkQueueFamilyProperties2(stream, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2 readParams");
     // WARNING PTR CHECK
     uint32_t* check_pQueueFamilyPropertyCount;
     check_pQueueFamilyPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -11148,7 +10576,6 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2(
             transform_fromhost_VkQueueFamilyProperties2(mImpl->resources(), (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2 returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -11160,7 +10587,6 @@ void VkEncoder::vkGetPhysicalDeviceMemoryProperties2(
     VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2 encode");
     mImpl->log("start vkGetPhysicalDeviceMemoryProperties2");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -11185,13 +10611,11 @@ void VkEncoder::vkGetPhysicalDeviceMemoryProperties2(
     stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_710, 1);
     stream->write((uint64_t*)&cgen_var_710, 1 * 8);
     marshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2 readParams");
     unmarshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
     if (pMemoryProperties)
     {
         transform_fromhost_VkPhysicalDeviceMemoryProperties2(mImpl->resources(), (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2 returnUnmarshal");
     mImpl->resources()->on_vkGetPhysicalDeviceMemoryProperties2(this, physicalDevice, pMemoryProperties);
     pool->freeAll();
     countingStream->clearPool();
@@ -11206,7 +10630,6 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2(
     VkSparseImageFormatProperties2* pProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2 encode");
     mImpl->log("start vkGetPhysicalDeviceSparseImageFormatProperties2");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -11276,7 +10699,6 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2(
             marshal_VkSparseImageFormatProperties2(stream, (VkSparseImageFormatProperties2*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2 readParams");
     // WARNING PTR CHECK
     uint32_t* check_pPropertyCount;
     check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -11309,7 +10731,6 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2(
             transform_fromhost_VkSparseImageFormatProperties2(mImpl->resources(), (VkSparseImageFormatProperties2*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2 returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -11322,7 +10743,6 @@ void VkEncoder::vkTrimCommandPool(
     VkCommandPoolTrimFlags flags)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkTrimCommandPool encode");
     mImpl->log("start vkTrimCommandPool");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -11357,8 +10777,6 @@ void VkEncoder::vkTrimCommandPool(
     stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_722, 1);
     stream->write((uint64_t*)&cgen_var_722, 1 * 8);
     stream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
-    AEMU_SCOPED_TRACE("vkTrimCommandPool readParams");
-    AEMU_SCOPED_TRACE("vkTrimCommandPool returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -11371,7 +10789,6 @@ void VkEncoder::vkGetDeviceQueue2(
     VkQueue* pQueue)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetDeviceQueue2 encode");
     mImpl->log("start vkGetDeviceQueue2");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -11415,11 +10832,9 @@ void VkEncoder::vkGetDeviceQueue2(
     stream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_726, 1);
     stream->write((uint64_t*)&cgen_var_726, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkGetDeviceQueue2 readParams");
     uint64_t cgen_var_727;
     stream->read((uint64_t*)&cgen_var_727, 8);
     stream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_727, (VkQueue*)pQueue, 1);
-    AEMU_SCOPED_TRACE("vkGetDeviceQueue2 returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -11433,7 +10848,6 @@ VkResult VkEncoder::vkCreateSamplerYcbcrConversion(
     VkSamplerYcbcrConversion* pYcbcrConversion)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion encode");
     mImpl->log("start vkCreateSamplerYcbcrConversion");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -11503,13 +10917,11 @@ VkResult VkEncoder::vkCreateSamplerYcbcrConversion(
     stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_733, 1);
     stream->write((uint64_t*)&cgen_var_733, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_734;
     stream->read((uint64_t*)&cgen_var_734, 8);
     stream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_734, (VkSamplerYcbcrConversion*)pYcbcrConversion, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion returnUnmarshal");
     VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
     stream->read(&vkCreateSamplerYcbcrConversion_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -11525,7 +10937,6 @@ void VkEncoder::vkDestroySamplerYcbcrConversion(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion encode");
     mImpl->log("start vkDestroySamplerYcbcrConversion");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -11582,8 +10993,6 @@ void VkEncoder::vkDestroySamplerYcbcrConversion(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion readParams");
-    AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkSamplerYcbcrConversion((VkSamplerYcbcrConversion*)&ycbcrConversion);
     pool->freeAll();
     countingStream->clearPool();
@@ -11598,7 +11007,6 @@ VkResult VkEncoder::vkCreateDescriptorUpdateTemplate(
     VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate encode");
     mImpl->log("start vkCreateDescriptorUpdateTemplate");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -11668,13 +11076,11 @@ VkResult VkEncoder::vkCreateDescriptorUpdateTemplate(
     stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_746, 1);
     stream->write((uint64_t*)&cgen_var_746, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_747;
     stream->read((uint64_t*)&cgen_var_747, 8);
     stream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(&cgen_var_747, (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate returnUnmarshal");
     VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDescriptorUpdateTemplate_VkResult_return, sizeof(VkResult));
     mImpl->resources()->on_vkCreateDescriptorUpdateTemplate(this, vkCreateDescriptorUpdateTemplate_VkResult_return, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
@@ -11691,7 +11097,6 @@ void VkEncoder::vkDestroyDescriptorUpdateTemplate(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate encode");
     mImpl->log("start vkDestroyDescriptorUpdateTemplate");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -11748,8 +11153,6 @@ void VkEncoder::vkDestroyDescriptorUpdateTemplate(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate readParams");
-    AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkDescriptorUpdateTemplate((VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate);
     pool->freeAll();
     countingStream->clearPool();
@@ -11764,7 +11167,6 @@ void VkEncoder::vkUpdateDescriptorSetWithTemplate(
     const void* pData)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate encode");
     mImpl->log("start vkUpdateDescriptorSetWithTemplate");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -11823,8 +11225,6 @@ void VkEncoder::vkUpdateDescriptorSetWithTemplate(
     {
         stream->write((void*)local_pData, sizeof(uint8_t));
     }
-    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate readParams");
-    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -11837,7 +11237,6 @@ void VkEncoder::vkGetPhysicalDeviceExternalBufferProperties(
     VkExternalBufferProperties* pExternalBufferProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferProperties encode");
     mImpl->log("start vkGetPhysicalDeviceExternalBufferProperties");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -11876,14 +11275,12 @@ void VkEncoder::vkGetPhysicalDeviceExternalBufferProperties(
     stream->write((uint64_t*)&cgen_var_763, 1 * 8);
     marshal_VkPhysicalDeviceExternalBufferInfo(stream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
     marshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferProperties readParams");
     unmarshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties));
     if (pExternalBufferProperties)
     {
         mImpl->resources()->transformImpl_VkExternalBufferProperties_fromhost(pExternalBufferProperties, 1);
         transform_fromhost_VkExternalBufferProperties(mImpl->resources(), (VkExternalBufferProperties*)(pExternalBufferProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferProperties returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -11896,7 +11293,6 @@ void VkEncoder::vkGetPhysicalDeviceExternalFenceProperties(
     VkExternalFenceProperties* pExternalFenceProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFenceProperties encode");
     mImpl->log("start vkGetPhysicalDeviceExternalFenceProperties");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -11934,13 +11330,11 @@ void VkEncoder::vkGetPhysicalDeviceExternalFenceProperties(
     stream->write((uint64_t*)&cgen_var_765, 1 * 8);
     marshal_VkPhysicalDeviceExternalFenceInfo(stream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
     marshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFenceProperties readParams");
     unmarshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties));
     if (pExternalFenceProperties)
     {
         transform_fromhost_VkExternalFenceProperties(mImpl->resources(), (VkExternalFenceProperties*)(pExternalFenceProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFenceProperties returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -11953,7 +11347,6 @@ void VkEncoder::vkGetPhysicalDeviceExternalSemaphoreProperties(
     VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphoreProperties encode");
     mImpl->log("start vkGetPhysicalDeviceExternalSemaphoreProperties");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -11991,13 +11384,11 @@ void VkEncoder::vkGetPhysicalDeviceExternalSemaphoreProperties(
     stream->write((uint64_t*)&cgen_var_767, 1 * 8);
     marshal_VkPhysicalDeviceExternalSemaphoreInfo(stream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
     marshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphoreProperties readParams");
     unmarshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
     if (pExternalSemaphoreProperties)
     {
         transform_fromhost_VkExternalSemaphoreProperties(mImpl->resources(), (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphoreProperties returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -12010,7 +11401,6 @@ void VkEncoder::vkGetDescriptorSetLayoutSupport(
     VkDescriptorSetLayoutSupport* pSupport)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport encode");
     mImpl->log("start vkGetDescriptorSetLayoutSupport");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -12048,13 +11438,11 @@ void VkEncoder::vkGetDescriptorSetLayoutSupport(
     stream->write((uint64_t*)&cgen_var_769, 1 * 8);
     marshal_VkDescriptorSetLayoutCreateInfo(stream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
     marshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport));
-    AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport readParams");
     unmarshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport));
     if (pSupport)
     {
         transform_fromhost_VkDescriptorSetLayoutSupport(mImpl->resources(), (VkDescriptorSetLayoutSupport*)(pSupport));
     }
-    AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -12069,7 +11457,6 @@ void VkEncoder::vkDestroySurfaceKHR(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroySurfaceKHR encode");
     mImpl->log("start vkDestroySurfaceKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -12126,8 +11513,6 @@ void VkEncoder::vkDestroySurfaceKHR(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroySurfaceKHR readParams");
-    AEMU_SCOPED_TRACE("vkDestroySurfaceKHR returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkSurfaceKHR((VkSurfaceKHR*)&surface);
     pool->freeAll();
     countingStream->clearPool();
@@ -12142,7 +11527,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceSupportKHR(
     VkBool32* pSupported)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceSupportKHR encode");
     mImpl->log("start vkGetPhysicalDeviceSurfaceSupportKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -12179,9 +11563,7 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceSupportKHR(
     stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_779, 1);
     stream->write((uint64_t*)&cgen_var_779, 1 * 8);
     stream->write((VkBool32*)pSupported, sizeof(VkBool32));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceSupportKHR readParams");
     stream->read((VkBool32*)pSupported, sizeof(VkBool32));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceSupportKHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -12197,7 +11579,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
     VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilitiesKHR encode");
     mImpl->log("start vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -12230,13 +11611,11 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
     stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_783, 1);
     stream->write((uint64_t*)&cgen_var_783, 1 * 8);
     marshal_VkSurfaceCapabilitiesKHR(stream, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilitiesKHR readParams");
     unmarshal_VkSurfaceCapabilitiesKHR(stream, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities));
     if (pSurfaceCapabilities)
     {
         transform_fromhost_VkSurfaceCapabilitiesKHR(mImpl->resources(), (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilitiesKHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -12253,7 +11632,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormatsKHR(
     VkSurfaceFormatKHR* pSurfaceFormats)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormatsKHR encode");
     mImpl->log("start vkGetPhysicalDeviceSurfaceFormatsKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -12318,7 +11696,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormatsKHR(
             marshal_VkSurfaceFormatKHR(stream, (VkSurfaceFormatKHR*)(pSurfaceFormats + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormatsKHR readParams");
     // WARNING PTR CHECK
     uint32_t* check_pSurfaceFormatCount;
     check_pSurfaceFormatCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -12351,7 +11728,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormatsKHR(
             transform_fromhost_VkSurfaceFormatKHR(mImpl->resources(), (VkSurfaceFormatKHR*)(pSurfaceFormats + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormatsKHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -12368,7 +11744,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfacePresentModesKHR(
     VkPresentModeKHR* pPresentModes)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfacePresentModesKHR encode");
     mImpl->log("start vkGetPhysicalDeviceSurfacePresentModesKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -12427,7 +11802,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfacePresentModesKHR(
     {
         stream->write((VkPresentModeKHR*)pPresentModes, (*(pPresentModeCount)) * sizeof(VkPresentModeKHR));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfacePresentModesKHR readParams");
     // WARNING PTR CHECK
     uint32_t* check_pPresentModeCount;
     check_pPresentModeCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -12450,7 +11824,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfacePresentModesKHR(
         }
         stream->read((VkPresentModeKHR*)pPresentModes, (*(pPresentModeCount)) * sizeof(VkPresentModeKHR));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfacePresentModesKHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -12469,7 +11842,6 @@ VkResult VkEncoder::vkCreateSwapchainKHR(
     VkSwapchainKHR* pSwapchain)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateSwapchainKHR encode");
     mImpl->log("start vkCreateSwapchainKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -12539,13 +11911,11 @@ VkResult VkEncoder::vkCreateSwapchainKHR(
     stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchain, &cgen_var_809, 1);
     stream->write((uint64_t*)&cgen_var_809, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateSwapchainKHR readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_810;
     stream->read((uint64_t*)&cgen_var_810, 8);
     stream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_810, (VkSwapchainKHR*)pSwapchain, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateSwapchainKHR returnUnmarshal");
     VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateSwapchainKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -12561,7 +11931,6 @@ void VkEncoder::vkDestroySwapchainKHR(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroySwapchainKHR encode");
     mImpl->log("start vkDestroySwapchainKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -12618,8 +11987,6 @@ void VkEncoder::vkDestroySwapchainKHR(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroySwapchainKHR readParams");
-    AEMU_SCOPED_TRACE("vkDestroySwapchainKHR returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&swapchain);
     pool->freeAll();
     countingStream->clearPool();
@@ -12634,7 +12001,6 @@ VkResult VkEncoder::vkGetSwapchainImagesKHR(
     VkImage* pSwapchainImages)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetSwapchainImagesKHR encode");
     mImpl->log("start vkGetSwapchainImagesKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -12707,7 +12073,6 @@ VkResult VkEncoder::vkGetSwapchainImagesKHR(
         }
     }
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkGetSwapchainImagesKHR readParams");
     // WARNING PTR CHECK
     uint32_t* check_pSwapchainImageCount;
     check_pSwapchainImageCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -12736,7 +12101,6 @@ VkResult VkEncoder::vkGetSwapchainImagesKHR(
             stream->handleMapping()->mapHandles_u64_VkImage(cgen_var_829, (VkImage*)pSwapchainImages, (*(pSwapchainImageCount)));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetSwapchainImagesKHR returnUnmarshal");
     VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetSwapchainImagesKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -12755,7 +12119,6 @@ VkResult VkEncoder::vkAcquireNextImageKHR(
     uint32_t* pImageIndex)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkAcquireNextImageKHR encode");
     mImpl->log("start vkAcquireNextImageKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -12808,9 +12171,7 @@ VkResult VkEncoder::vkAcquireNextImageKHR(
     stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_837, 1);
     stream->write((uint64_t*)&cgen_var_837, 1 * 8);
     stream->write((uint32_t*)pImageIndex, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkAcquireNextImageKHR readParams");
     stream->read((uint32_t*)pImageIndex, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkAcquireNextImageKHR returnUnmarshal");
     VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
     stream->read(&vkAcquireNextImageKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -12825,7 +12186,6 @@ VkResult VkEncoder::vkQueuePresentKHR(
     const VkPresentInfoKHR* pPresentInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkQueuePresentKHR encode");
     mImpl->log("start vkQueuePresentKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -12861,8 +12221,6 @@ VkResult VkEncoder::vkQueuePresentKHR(
     stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_839, 1);
     stream->write((uint64_t*)&cgen_var_839, 1 * 8);
     marshal_VkPresentInfoKHR(stream, (VkPresentInfoKHR*)(local_pPresentInfo));
-    AEMU_SCOPED_TRACE("vkQueuePresentKHR readParams");
-    AEMU_SCOPED_TRACE("vkQueuePresentKHR returnUnmarshal");
     VkResult vkQueuePresentKHR_VkResult_return = (VkResult)0;
     stream->read(&vkQueuePresentKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -12877,7 +12235,6 @@ VkResult VkEncoder::vkGetDeviceGroupPresentCapabilitiesKHR(
     VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetDeviceGroupPresentCapabilitiesKHR encode");
     mImpl->log("start vkGetDeviceGroupPresentCapabilitiesKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -12902,13 +12259,11 @@ VkResult VkEncoder::vkGetDeviceGroupPresentCapabilitiesKHR(
     stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_841, 1);
     stream->write((uint64_t*)&cgen_var_841, 1 * 8);
     marshal_VkDeviceGroupPresentCapabilitiesKHR(stream, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
-    AEMU_SCOPED_TRACE("vkGetDeviceGroupPresentCapabilitiesKHR readParams");
     unmarshal_VkDeviceGroupPresentCapabilitiesKHR(stream, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
     if (pDeviceGroupPresentCapabilities)
     {
         transform_fromhost_VkDeviceGroupPresentCapabilitiesKHR(mImpl->resources(), (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
     }
-    AEMU_SCOPED_TRACE("vkGetDeviceGroupPresentCapabilitiesKHR returnUnmarshal");
     VkResult vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -12924,7 +12279,6 @@ VkResult VkEncoder::vkGetDeviceGroupSurfacePresentModesKHR(
     VkDeviceGroupPresentModeFlagsKHR* pModes)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetDeviceGroupSurfacePresentModesKHR encode");
     mImpl->log("start vkGetDeviceGroupSurfacePresentModesKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -12969,7 +12323,6 @@ VkResult VkEncoder::vkGetDeviceGroupSurfacePresentModesKHR(
     {
         stream->write((VkDeviceGroupPresentModeFlagsKHR*)pModes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
     }
-    AEMU_SCOPED_TRACE("vkGetDeviceGroupSurfacePresentModesKHR readParams");
     // WARNING PTR CHECK
     VkDeviceGroupPresentModeFlagsKHR* check_pModes;
     check_pModes = (VkDeviceGroupPresentModeFlagsKHR*)(uintptr_t)stream->getBe64();
@@ -12981,7 +12334,6 @@ VkResult VkEncoder::vkGetDeviceGroupSurfacePresentModesKHR(
         }
         stream->read((VkDeviceGroupPresentModeFlagsKHR*)pModes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
     }
-    AEMU_SCOPED_TRACE("vkGetDeviceGroupSurfacePresentModesKHR returnUnmarshal");
     VkResult vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -12998,7 +12350,6 @@ VkResult VkEncoder::vkGetPhysicalDevicePresentRectanglesKHR(
     VkRect2D* pRects)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDevicePresentRectanglesKHR encode");
     mImpl->log("start vkGetPhysicalDevicePresentRectanglesKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -13063,7 +12414,6 @@ VkResult VkEncoder::vkGetPhysicalDevicePresentRectanglesKHR(
             marshal_VkRect2D(stream, (VkRect2D*)(pRects + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDevicePresentRectanglesKHR readParams");
     // WARNING PTR CHECK
     uint32_t* check_pRectCount;
     check_pRectCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -13096,7 +12446,6 @@ VkResult VkEncoder::vkGetPhysicalDevicePresentRectanglesKHR(
             transform_fromhost_VkRect2D(mImpl->resources(), (VkRect2D*)(pRects + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDevicePresentRectanglesKHR returnUnmarshal");
     VkResult vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -13112,7 +12461,6 @@ VkResult VkEncoder::vkAcquireNextImage2KHR(
     uint32_t* pImageIndex)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkAcquireNextImage2KHR encode");
     mImpl->log("start vkAcquireNextImage2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -13150,9 +12498,7 @@ VkResult VkEncoder::vkAcquireNextImage2KHR(
     stream->write((uint64_t*)&cgen_var_860, 1 * 8);
     marshal_VkAcquireNextImageInfoKHR(stream, (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo));
     stream->write((uint32_t*)pImageIndex, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkAcquireNextImage2KHR readParams");
     stream->read((uint32_t*)pImageIndex, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkAcquireNextImage2KHR returnUnmarshal");
     VkResult vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkAcquireNextImage2KHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -13170,7 +12516,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPropertiesKHR(
     VkDisplayPropertiesKHR* pProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPropertiesKHR encode");
     mImpl->log("start vkGetPhysicalDeviceDisplayPropertiesKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -13227,7 +12572,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPropertiesKHR(
             marshal_VkDisplayPropertiesKHR(stream, (VkDisplayPropertiesKHR*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPropertiesKHR readParams");
     // WARNING PTR CHECK
     uint32_t* check_pPropertyCount;
     check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -13260,7 +12604,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPropertiesKHR(
             transform_fromhost_VkDisplayPropertiesKHR(mImpl->resources(), (VkDisplayPropertiesKHR*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPropertiesKHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -13276,7 +12619,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
     VkDisplayPlanePropertiesKHR* pProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlanePropertiesKHR encode");
     mImpl->log("start vkGetPhysicalDeviceDisplayPlanePropertiesKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -13333,7 +12675,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
             marshal_VkDisplayPlanePropertiesKHR(stream, (VkDisplayPlanePropertiesKHR*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlanePropertiesKHR readParams");
     // WARNING PTR CHECK
     uint32_t* check_pPropertyCount;
     check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -13366,7 +12707,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
             transform_fromhost_VkDisplayPlanePropertiesKHR(mImpl->resources(), (VkDisplayPlanePropertiesKHR*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlanePropertiesKHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -13383,7 +12723,6 @@ VkResult VkEncoder::vkGetDisplayPlaneSupportedDisplaysKHR(
     VkDisplayKHR* pDisplays)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetDisplayPlaneSupportedDisplaysKHR encode");
     mImpl->log("start vkGetDisplayPlaneSupportedDisplaysKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -13452,7 +12791,6 @@ VkResult VkEncoder::vkGetDisplayPlaneSupportedDisplaysKHR(
         }
     }
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkGetDisplayPlaneSupportedDisplaysKHR readParams");
     // WARNING PTR CHECK
     uint32_t* check_pDisplayCount;
     check_pDisplayCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -13481,7 +12819,6 @@ VkResult VkEncoder::vkGetDisplayPlaneSupportedDisplaysKHR(
             stream->handleMapping()->mapHandles_u64_VkDisplayKHR(cgen_var_887, (VkDisplayKHR*)pDisplays, (*(pDisplayCount)));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetDisplayPlaneSupportedDisplaysKHR returnUnmarshal");
     VkResult vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -13498,7 +12835,6 @@ VkResult VkEncoder::vkGetDisplayModePropertiesKHR(
     VkDisplayModePropertiesKHR* pProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetDisplayModePropertiesKHR encode");
     mImpl->log("start vkGetDisplayModePropertiesKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -13563,7 +12899,6 @@ VkResult VkEncoder::vkGetDisplayModePropertiesKHR(
             marshal_VkDisplayModePropertiesKHR(stream, (VkDisplayModePropertiesKHR*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetDisplayModePropertiesKHR readParams");
     // WARNING PTR CHECK
     uint32_t* check_pPropertyCount;
     check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -13596,7 +12931,6 @@ VkResult VkEncoder::vkGetDisplayModePropertiesKHR(
             transform_fromhost_VkDisplayModePropertiesKHR(mImpl->resources(), (VkDisplayModePropertiesKHR*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetDisplayModePropertiesKHR returnUnmarshal");
     VkResult vkGetDisplayModePropertiesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetDisplayModePropertiesKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -13614,7 +12948,6 @@ VkResult VkEncoder::vkCreateDisplayModeKHR(
     VkDisplayModeKHR* pMode)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateDisplayModeKHR encode");
     mImpl->log("start vkCreateDisplayModeKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -13692,13 +13025,11 @@ VkResult VkEncoder::vkCreateDisplayModeKHR(
     stream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(pMode, &cgen_var_905, 1);
     stream->write((uint64_t*)&cgen_var_905, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateDisplayModeKHR readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_906;
     stream->read((uint64_t*)&cgen_var_906, 8);
     stream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_906, (VkDisplayModeKHR*)pMode, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateDisplayModeKHR returnUnmarshal");
     VkResult vkCreateDisplayModeKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDisplayModeKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -13715,7 +13046,6 @@ VkResult VkEncoder::vkGetDisplayPlaneCapabilitiesKHR(
     VkDisplayPlaneCapabilitiesKHR* pCapabilities)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilitiesKHR encode");
     mImpl->log("start vkGetDisplayPlaneCapabilitiesKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -13752,13 +13082,11 @@ VkResult VkEncoder::vkGetDisplayPlaneCapabilitiesKHR(
     stream->write((uint64_t*)&cgen_var_910, 1 * 8);
     stream->write((uint32_t*)&local_planeIndex, sizeof(uint32_t));
     marshal_VkDisplayPlaneCapabilitiesKHR(stream, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities));
-    AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilitiesKHR readParams");
     unmarshal_VkDisplayPlaneCapabilitiesKHR(stream, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities));
     if (pCapabilities)
     {
         transform_fromhost_VkDisplayPlaneCapabilitiesKHR(mImpl->resources(), (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities));
     }
-    AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilitiesKHR returnUnmarshal");
     VkResult vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetDisplayPlaneCapabilitiesKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -13775,7 +13103,6 @@ VkResult VkEncoder::vkCreateDisplayPlaneSurfaceKHR(
     VkSurfaceKHR* pSurface)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateDisplayPlaneSurfaceKHR encode");
     mImpl->log("start vkCreateDisplayPlaneSurfaceKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -13845,11 +13172,9 @@ VkResult VkEncoder::vkCreateDisplayPlaneSurfaceKHR(
     stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_916, 1);
     stream->write((uint64_t*)&cgen_var_916, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateDisplayPlaneSurfaceKHR readParams");
     uint64_t cgen_var_917;
     stream->read((uint64_t*)&cgen_var_917, 8);
     stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_917, (VkSurfaceKHR*)pSurface, 1);
-    AEMU_SCOPED_TRACE("vkCreateDisplayPlaneSurfaceKHR returnUnmarshal");
     VkResult vkCreateDisplayPlaneSurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDisplayPlaneSurfaceKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -13869,7 +13194,6 @@ VkResult VkEncoder::vkCreateSharedSwapchainsKHR(
     VkSwapchainKHR* pSwapchains)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateSharedSwapchainsKHR encode");
     mImpl->log("start vkCreateSharedSwapchainsKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -13963,7 +13287,6 @@ VkResult VkEncoder::vkCreateSharedSwapchainsKHR(
         stream->write((uint64_t*)cgen_var_923, ((swapchainCount)) * 8);
     }
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateSharedSwapchainsKHR readParams");
     if (((swapchainCount)))
     {
         uint64_t* cgen_var_924;
@@ -13971,7 +13294,6 @@ VkResult VkEncoder::vkCreateSharedSwapchainsKHR(
         stream->read((uint64_t*)cgen_var_924, ((swapchainCount)) * 8);
         stream->handleMapping()->mapHandles_u64_VkSwapchainKHR(cgen_var_924, (VkSwapchainKHR*)pSwapchains, ((swapchainCount)));
     }
-    AEMU_SCOPED_TRACE("vkCreateSharedSwapchainsKHR returnUnmarshal");
     VkResult vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateSharedSwapchainsKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -13990,7 +13312,6 @@ VkResult VkEncoder::vkCreateXlibSurfaceKHR(
     VkSurfaceKHR* pSurface)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateXlibSurfaceKHR encode");
     mImpl->log("start vkCreateXlibSurfaceKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -14060,11 +13381,9 @@ VkResult VkEncoder::vkCreateXlibSurfaceKHR(
     stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_930, 1);
     stream->write((uint64_t*)&cgen_var_930, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateXlibSurfaceKHR readParams");
     uint64_t cgen_var_931;
     stream->read((uint64_t*)&cgen_var_931, 8);
     stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_931, (VkSurfaceKHR*)pSurface, 1);
-    AEMU_SCOPED_TRACE("vkCreateXlibSurfaceKHR returnUnmarshal");
     VkResult vkCreateXlibSurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateXlibSurfaceKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -14081,7 +13400,6 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceXlibPresentationSupportKHR(
     VisualID visualID)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXlibPresentationSupportKHR encode");
     mImpl->log("start vkGetPhysicalDeviceXlibPresentationSupportKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -14114,9 +13432,7 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceXlibPresentationSupportKHR(
     stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
     stream->write((Display*)dpy, sizeof(Display));
     stream->write((VisualID*)&local_visualID, sizeof(VisualID));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXlibPresentationSupportKHR readParams");
     stream->read((Display*)dpy, sizeof(Display));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXlibPresentationSupportKHR returnUnmarshal");
     VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = (VkBool32)0;
     stream->read(&vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
     pool->freeAll();
@@ -14135,7 +13451,6 @@ VkResult VkEncoder::vkCreateXcbSurfaceKHR(
     VkSurfaceKHR* pSurface)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateXcbSurfaceKHR encode");
     mImpl->log("start vkCreateXcbSurfaceKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -14205,11 +13520,9 @@ VkResult VkEncoder::vkCreateXcbSurfaceKHR(
     stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_939, 1);
     stream->write((uint64_t*)&cgen_var_939, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateXcbSurfaceKHR readParams");
     uint64_t cgen_var_940;
     stream->read((uint64_t*)&cgen_var_940, 8);
     stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_940, (VkSurfaceKHR*)pSurface, 1);
-    AEMU_SCOPED_TRACE("vkCreateXcbSurfaceKHR returnUnmarshal");
     VkResult vkCreateXcbSurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateXcbSurfaceKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -14226,7 +13539,6 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceXcbPresentationSupportKHR(
     xcb_visualid_t visual_id)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXcbPresentationSupportKHR encode");
     mImpl->log("start vkGetPhysicalDeviceXcbPresentationSupportKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -14259,9 +13571,7 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceXcbPresentationSupportKHR(
     stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
     stream->write((xcb_connection_t*)connection, sizeof(xcb_connection_t));
     stream->write((xcb_visualid_t*)&local_visual_id, sizeof(xcb_visualid_t));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXcbPresentationSupportKHR readParams");
     stream->read((xcb_connection_t*)connection, sizeof(xcb_connection_t));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXcbPresentationSupportKHR returnUnmarshal");
     VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = (VkBool32)0;
     stream->read(&vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
     pool->freeAll();
@@ -14280,7 +13590,6 @@ VkResult VkEncoder::vkCreateWaylandSurfaceKHR(
     VkSurfaceKHR* pSurface)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateWaylandSurfaceKHR encode");
     mImpl->log("start vkCreateWaylandSurfaceKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -14350,11 +13659,9 @@ VkResult VkEncoder::vkCreateWaylandSurfaceKHR(
     stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_948, 1);
     stream->write((uint64_t*)&cgen_var_948, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateWaylandSurfaceKHR readParams");
     uint64_t cgen_var_949;
     stream->read((uint64_t*)&cgen_var_949, 8);
     stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_949, (VkSurfaceKHR*)pSurface, 1);
-    AEMU_SCOPED_TRACE("vkCreateWaylandSurfaceKHR returnUnmarshal");
     VkResult vkCreateWaylandSurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateWaylandSurfaceKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -14370,7 +13677,6 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceWaylandPresentationSupportKHR(
     wl_display* display)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWaylandPresentationSupportKHR encode");
     mImpl->log("start vkGetPhysicalDeviceWaylandPresentationSupportKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -14399,9 +13705,7 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceWaylandPresentationSupportKHR(
     stream->write((uint64_t*)&cgen_var_951, 1 * 8);
     stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
     stream->write((wl_display*)display, sizeof(wl_display));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWaylandPresentationSupportKHR readParams");
     stream->read((wl_display*)display, sizeof(wl_display));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWaylandPresentationSupportKHR returnUnmarshal");
     VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return = (VkBool32)0;
     stream->read(&vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
     pool->freeAll();
@@ -14420,7 +13724,6 @@ VkResult VkEncoder::vkCreateMirSurfaceKHR(
     VkSurfaceKHR* pSurface)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateMirSurfaceKHR encode");
     mImpl->log("start vkCreateMirSurfaceKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -14490,11 +13793,9 @@ VkResult VkEncoder::vkCreateMirSurfaceKHR(
     stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_957, 1);
     stream->write((uint64_t*)&cgen_var_957, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateMirSurfaceKHR readParams");
     uint64_t cgen_var_958;
     stream->read((uint64_t*)&cgen_var_958, 8);
     stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_958, (VkSurfaceKHR*)pSurface, 1);
-    AEMU_SCOPED_TRACE("vkCreateMirSurfaceKHR returnUnmarshal");
     VkResult vkCreateMirSurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateMirSurfaceKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -14510,7 +13811,6 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceMirPresentationSupportKHR(
     MirConnection* connection)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMirPresentationSupportKHR encode");
     mImpl->log("start vkGetPhysicalDeviceMirPresentationSupportKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -14539,9 +13839,7 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceMirPresentationSupportKHR(
     stream->write((uint64_t*)&cgen_var_960, 1 * 8);
     stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
     stream->write((MirConnection*)connection, sizeof(MirConnection));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMirPresentationSupportKHR readParams");
     stream->read((MirConnection*)connection, sizeof(MirConnection));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMirPresentationSupportKHR returnUnmarshal");
     VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return = (VkBool32)0;
     stream->read(&vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
     pool->freeAll();
@@ -14560,7 +13858,6 @@ VkResult VkEncoder::vkCreateAndroidSurfaceKHR(
     VkSurfaceKHR* pSurface)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateAndroidSurfaceKHR encode");
     mImpl->log("start vkCreateAndroidSurfaceKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -14630,11 +13927,9 @@ VkResult VkEncoder::vkCreateAndroidSurfaceKHR(
     stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_966, 1);
     stream->write((uint64_t*)&cgen_var_966, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateAndroidSurfaceKHR readParams");
     uint64_t cgen_var_967;
     stream->read((uint64_t*)&cgen_var_967, 8);
     stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_967, (VkSurfaceKHR*)pSurface, 1);
-    AEMU_SCOPED_TRACE("vkCreateAndroidSurfaceKHR returnUnmarshal");
     VkResult vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateAndroidSurfaceKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -14653,7 +13948,6 @@ VkResult VkEncoder::vkCreateWin32SurfaceKHR(
     VkSurfaceKHR* pSurface)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateWin32SurfaceKHR encode");
     mImpl->log("start vkCreateWin32SurfaceKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -14723,11 +14017,9 @@ VkResult VkEncoder::vkCreateWin32SurfaceKHR(
     stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_973, 1);
     stream->write((uint64_t*)&cgen_var_973, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateWin32SurfaceKHR readParams");
     uint64_t cgen_var_974;
     stream->read((uint64_t*)&cgen_var_974, 8);
     stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_974, (VkSurfaceKHR*)pSurface, 1);
-    AEMU_SCOPED_TRACE("vkCreateWin32SurfaceKHR returnUnmarshal");
     VkResult vkCreateWin32SurfaceKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateWin32SurfaceKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -14742,7 +14034,6 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceWin32PresentationSupportKHR(
     uint32_t queueFamilyIndex)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWin32PresentationSupportKHR encode");
     mImpl->log("start vkGetPhysicalDeviceWin32PresentationSupportKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -14769,8 +14060,6 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceWin32PresentationSupportKHR(
     stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_976, 1);
     stream->write((uint64_t*)&cgen_var_976, 1 * 8);
     stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWin32PresentationSupportKHR readParams");
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWin32PresentationSupportKHR returnUnmarshal");
     VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = (VkBool32)0;
     stream->read(&vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
     pool->freeAll();
@@ -14791,7 +14080,6 @@ void VkEncoder::vkGetPhysicalDeviceFeatures2KHR(
     VkPhysicalDeviceFeatures2* pFeatures)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceFeatures2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -14816,13 +14104,11 @@ void VkEncoder::vkGetPhysicalDeviceFeatures2KHR(
     stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_978, 1);
     stream->write((uint64_t*)&cgen_var_978, 1 * 8);
     marshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2KHR readParams");
     unmarshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures));
     if (pFeatures)
     {
         transform_fromhost_VkPhysicalDeviceFeatures2(mImpl->resources(), (VkPhysicalDeviceFeatures2*)(pFeatures));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2KHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -14834,7 +14120,6 @@ void VkEncoder::vkGetPhysicalDeviceProperties2KHR(
     VkPhysicalDeviceProperties2* pProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceProperties2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -14859,13 +14144,11 @@ void VkEncoder::vkGetPhysicalDeviceProperties2KHR(
     stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_980, 1);
     stream->write((uint64_t*)&cgen_var_980, 1 * 8);
     marshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2KHR readParams");
     unmarshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties));
     if (pProperties)
     {
         transform_fromhost_VkPhysicalDeviceProperties2(mImpl->resources(), (VkPhysicalDeviceProperties2*)(pProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2KHR returnUnmarshal");
     mImpl->resources()->on_vkGetPhysicalDeviceProperties2KHR(this, physicalDevice, pProperties);
     pool->freeAll();
     countingStream->clearPool();
@@ -14879,7 +14162,6 @@ void VkEncoder::vkGetPhysicalDeviceFormatProperties2KHR(
     VkFormatProperties2* pFormatProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceFormatProperties2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -14908,13 +14190,11 @@ void VkEncoder::vkGetPhysicalDeviceFormatProperties2KHR(
     stream->write((uint64_t*)&cgen_var_982, 1 * 8);
     stream->write((VkFormat*)&local_format, sizeof(VkFormat));
     marshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2KHR readParams");
     unmarshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties));
     if (pFormatProperties)
     {
         transform_fromhost_VkFormatProperties2(mImpl->resources(), (VkFormatProperties2*)(pFormatProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2KHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -14927,7 +14207,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties2KHR(
     VkImageFormatProperties2* pImageFormatProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceImageFormatProperties2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -14965,13 +14244,11 @@ VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties2KHR(
     stream->write((uint64_t*)&cgen_var_984, 1 * 8);
     marshal_VkPhysicalDeviceImageFormatInfo2(stream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
     marshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2KHR readParams");
     unmarshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties));
     if (pImageFormatProperties)
     {
         transform_fromhost_VkImageFormatProperties2(mImpl->resources(), (VkImageFormatProperties2*)(pImageFormatProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2KHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -14987,7 +14264,6 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2KHR(
     VkQueueFamilyProperties2* pQueueFamilyProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceQueueFamilyProperties2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -15044,7 +14320,6 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2KHR(
             marshal_VkQueueFamilyProperties2(stream, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2KHR readParams");
     // WARNING PTR CHECK
     uint32_t* check_pQueueFamilyPropertyCount;
     check_pQueueFamilyPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -15077,7 +14352,6 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2KHR(
             transform_fromhost_VkQueueFamilyProperties2(mImpl->resources(), (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2KHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -15089,7 +14363,6 @@ void VkEncoder::vkGetPhysicalDeviceMemoryProperties2KHR(
     VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceMemoryProperties2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -15114,13 +14387,11 @@ void VkEncoder::vkGetPhysicalDeviceMemoryProperties2KHR(
     stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_994, 1);
     stream->write((uint64_t*)&cgen_var_994, 1 * 8);
     marshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2KHR readParams");
     unmarshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
     if (pMemoryProperties)
     {
         transform_fromhost_VkPhysicalDeviceMemoryProperties2(mImpl->resources(), (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2KHR returnUnmarshal");
     mImpl->resources()->on_vkGetPhysicalDeviceMemoryProperties2KHR(this, physicalDevice, pMemoryProperties);
     pool->freeAll();
     countingStream->clearPool();
@@ -15135,7 +14406,6 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
     VkSparseImageFormatProperties2* pProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -15205,7 +14475,6 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
             marshal_VkSparseImageFormatProperties2(stream, (VkSparseImageFormatProperties2*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2KHR readParams");
     // WARNING PTR CHECK
     uint32_t* check_pPropertyCount;
     check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -15238,7 +14507,6 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
             transform_fromhost_VkSparseImageFormatProperties2(mImpl->resources(), (VkSparseImageFormatProperties2*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2KHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -15255,7 +14523,6 @@ void VkEncoder::vkGetDeviceGroupPeerMemoryFeaturesKHR(
     VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeaturesKHR encode");
     mImpl->log("start vkGetDeviceGroupPeerMemoryFeaturesKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -15292,9 +14559,7 @@ void VkEncoder::vkGetDeviceGroupPeerMemoryFeaturesKHR(
     stream->write((uint32_t*)&local_localDeviceIndex, sizeof(uint32_t));
     stream->write((uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t));
     stream->write((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
-    AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeaturesKHR readParams");
     stream->read((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
-    AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeaturesKHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -15306,7 +14571,6 @@ void VkEncoder::vkCmdSetDeviceMaskKHR(
     uint32_t deviceMask)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdSetDeviceMaskKHR encode");
     mImpl->log("start vkCmdSetDeviceMaskKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -15333,8 +14597,6 @@ void VkEncoder::vkCmdSetDeviceMaskKHR(
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1006, 1);
     stream->write((uint64_t*)&cgen_var_1006, 1 * 8);
     stream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdSetDeviceMaskKHR readParams");
-    AEMU_SCOPED_TRACE("vkCmdSetDeviceMaskKHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -15351,7 +14613,6 @@ void VkEncoder::vkCmdDispatchBaseKHR(
     uint32_t groupCountZ)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdDispatchBaseKHR encode");
     mImpl->log("start vkCmdDispatchBaseKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -15398,8 +14659,6 @@ void VkEncoder::vkCmdDispatchBaseKHR(
     stream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t));
     stream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t));
     stream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdDispatchBaseKHR readParams");
-    AEMU_SCOPED_TRACE("vkCmdDispatchBaseKHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -15416,7 +14675,6 @@ void VkEncoder::vkTrimCommandPoolKHR(
     VkCommandPoolTrimFlags flags)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR encode");
     mImpl->log("start vkTrimCommandPoolKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -15451,8 +14709,6 @@ void VkEncoder::vkTrimCommandPoolKHR(
     stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_1012, 1);
     stream->write((uint64_t*)&cgen_var_1012, 1 * 8);
     stream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
-    AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR readParams");
-    AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -15467,7 +14723,6 @@ VkResult VkEncoder::vkEnumeratePhysicalDeviceGroupsKHR(
     VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroupsKHR encode");
     mImpl->log("start vkEnumeratePhysicalDeviceGroupsKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -15524,7 +14779,6 @@ VkResult VkEncoder::vkEnumeratePhysicalDeviceGroupsKHR(
             marshal_VkPhysicalDeviceGroupProperties(stream, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroupsKHR readParams");
     // WARNING PTR CHECK
     uint32_t* check_pPhysicalDeviceGroupCount;
     check_pPhysicalDeviceGroupCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -15557,7 +14811,6 @@ VkResult VkEncoder::vkEnumeratePhysicalDeviceGroupsKHR(
             transform_fromhost_VkPhysicalDeviceGroupProperties(mImpl->resources(), (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroupsKHR returnUnmarshal");
     VkResult vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return = (VkResult)0;
     stream->read(&vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -15575,7 +14828,6 @@ void VkEncoder::vkGetPhysicalDeviceExternalBufferPropertiesKHR(
     VkExternalBufferProperties* pExternalBufferProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferPropertiesKHR encode");
     mImpl->log("start vkGetPhysicalDeviceExternalBufferPropertiesKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -15614,14 +14866,12 @@ void VkEncoder::vkGetPhysicalDeviceExternalBufferPropertiesKHR(
     stream->write((uint64_t*)&cgen_var_1022, 1 * 8);
     marshal_VkPhysicalDeviceExternalBufferInfo(stream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
     marshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferPropertiesKHR readParams");
     unmarshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties));
     if (pExternalBufferProperties)
     {
         mImpl->resources()->transformImpl_VkExternalBufferProperties_fromhost(pExternalBufferProperties, 1);
         transform_fromhost_VkExternalBufferProperties(mImpl->resources(), (VkExternalBufferProperties*)(pExternalBufferProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferPropertiesKHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -15638,7 +14888,6 @@ VkResult VkEncoder::vkGetMemoryWin32HandleKHR(
     HANDLE* pHandle)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleKHR encode");
     mImpl->log("start vkGetMemoryWin32HandleKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -15676,9 +14925,7 @@ VkResult VkEncoder::vkGetMemoryWin32HandleKHR(
     stream->write((uint64_t*)&cgen_var_1024, 1 * 8);
     marshal_VkMemoryGetWin32HandleInfoKHR(stream, (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
     stream->write((HANDLE*)pHandle, sizeof(HANDLE));
-    AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleKHR readParams");
     stream->read((HANDLE*)pHandle, sizeof(HANDLE));
-    AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleKHR returnUnmarshal");
     VkResult vkGetMemoryWin32HandleKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetMemoryWin32HandleKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -15695,7 +14942,6 @@ VkResult VkEncoder::vkGetMemoryWin32HandlePropertiesKHR(
     VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetMemoryWin32HandlePropertiesKHR encode");
     mImpl->log("start vkGetMemoryWin32HandlePropertiesKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -15728,13 +14974,11 @@ VkResult VkEncoder::vkGetMemoryWin32HandlePropertiesKHR(
     stream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
     stream->write((HANDLE*)&local_handle, sizeof(HANDLE));
     marshal_VkMemoryWin32HandlePropertiesKHR(stream, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties));
-    AEMU_SCOPED_TRACE("vkGetMemoryWin32HandlePropertiesKHR readParams");
     unmarshal_VkMemoryWin32HandlePropertiesKHR(stream, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties));
     if (pMemoryWin32HandleProperties)
     {
         transform_fromhost_VkMemoryWin32HandlePropertiesKHR(mImpl->resources(), (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetMemoryWin32HandlePropertiesKHR returnUnmarshal");
     VkResult vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetMemoryWin32HandlePropertiesKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -15752,7 +14996,6 @@ VkResult VkEncoder::vkGetMemoryFdKHR(
     int* pFd)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetMemoryFdKHR encode");
     mImpl->log("start vkGetMemoryFdKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -15790,9 +15033,7 @@ VkResult VkEncoder::vkGetMemoryFdKHR(
     stream->write((uint64_t*)&cgen_var_1028, 1 * 8);
     marshal_VkMemoryGetFdInfoKHR(stream, (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo));
     stream->write((int*)pFd, sizeof(int));
-    AEMU_SCOPED_TRACE("vkGetMemoryFdKHR readParams");
     stream->read((int*)pFd, sizeof(int));
-    AEMU_SCOPED_TRACE("vkGetMemoryFdKHR returnUnmarshal");
     VkResult vkGetMemoryFdKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetMemoryFdKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -15809,7 +15050,6 @@ VkResult VkEncoder::vkGetMemoryFdPropertiesKHR(
     VkMemoryFdPropertiesKHR* pMemoryFdProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetMemoryFdPropertiesKHR encode");
     mImpl->log("start vkGetMemoryFdPropertiesKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -15842,13 +15082,11 @@ VkResult VkEncoder::vkGetMemoryFdPropertiesKHR(
     stream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
     stream->write((int*)&local_fd, sizeof(int));
     marshal_VkMemoryFdPropertiesKHR(stream, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties));
-    AEMU_SCOPED_TRACE("vkGetMemoryFdPropertiesKHR readParams");
     unmarshal_VkMemoryFdPropertiesKHR(stream, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties));
     if (pMemoryFdProperties)
     {
         transform_fromhost_VkMemoryFdPropertiesKHR(mImpl->resources(), (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetMemoryFdPropertiesKHR returnUnmarshal");
     VkResult vkGetMemoryFdPropertiesKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetMemoryFdPropertiesKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -15868,7 +15106,6 @@ void VkEncoder::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
     VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR encode");
     mImpl->log("start vkGetPhysicalDeviceExternalSemaphorePropertiesKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -15906,13 +15143,11 @@ void VkEncoder::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
     stream->write((uint64_t*)&cgen_var_1032, 1 * 8);
     marshal_VkPhysicalDeviceExternalSemaphoreInfo(stream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
     marshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR readParams");
     unmarshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
     if (pExternalSemaphoreProperties)
     {
         transform_fromhost_VkExternalSemaphoreProperties(mImpl->resources(), (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -15928,7 +15163,6 @@ VkResult VkEncoder::vkImportSemaphoreWin32HandleKHR(
     const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkImportSemaphoreWin32HandleKHR encode");
     mImpl->log("start vkImportSemaphoreWin32HandleKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -15964,8 +15198,6 @@ VkResult VkEncoder::vkImportSemaphoreWin32HandleKHR(
     stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1034, 1);
     stream->write((uint64_t*)&cgen_var_1034, 1 * 8);
     marshal_VkImportSemaphoreWin32HandleInfoKHR(stream, (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo));
-    AEMU_SCOPED_TRACE("vkImportSemaphoreWin32HandleKHR readParams");
-    AEMU_SCOPED_TRACE("vkImportSemaphoreWin32HandleKHR returnUnmarshal");
     VkResult vkImportSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
     stream->read(&vkImportSemaphoreWin32HandleKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -15981,7 +15213,6 @@ VkResult VkEncoder::vkGetSemaphoreWin32HandleKHR(
     HANDLE* pHandle)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetSemaphoreWin32HandleKHR encode");
     mImpl->log("start vkGetSemaphoreWin32HandleKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -16019,9 +15250,7 @@ VkResult VkEncoder::vkGetSemaphoreWin32HandleKHR(
     stream->write((uint64_t*)&cgen_var_1036, 1 * 8);
     marshal_VkSemaphoreGetWin32HandleInfoKHR(stream, (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
     stream->write((HANDLE*)pHandle, sizeof(HANDLE));
-    AEMU_SCOPED_TRACE("vkGetSemaphoreWin32HandleKHR readParams");
     stream->read((HANDLE*)pHandle, sizeof(HANDLE));
-    AEMU_SCOPED_TRACE("vkGetSemaphoreWin32HandleKHR returnUnmarshal");
     VkResult vkGetSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetSemaphoreWin32HandleKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -16038,7 +15267,6 @@ VkResult VkEncoder::vkImportSemaphoreFdKHR(
     const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR encode");
     mImpl->log("start vkImportSemaphoreFdKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -16074,8 +15302,6 @@ VkResult VkEncoder::vkImportSemaphoreFdKHR(
     stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1038, 1);
     stream->write((uint64_t*)&cgen_var_1038, 1 * 8);
     marshal_VkImportSemaphoreFdInfoKHR(stream, (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo));
-    AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR readParams");
-    AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR returnUnmarshal");
     VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
     stream->read(&vkImportSemaphoreFdKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -16091,7 +15317,6 @@ VkResult VkEncoder::vkGetSemaphoreFdKHR(
     int* pFd)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR encode");
     mImpl->log("start vkGetSemaphoreFdKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -16129,9 +15354,7 @@ VkResult VkEncoder::vkGetSemaphoreFdKHR(
     stream->write((uint64_t*)&cgen_var_1040, 1 * 8);
     marshal_VkSemaphoreGetFdInfoKHR(stream, (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo));
     stream->write((int*)pFd, sizeof(int));
-    AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR readParams");
     stream->read((int*)pFd, sizeof(int));
-    AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR returnUnmarshal");
     VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetSemaphoreFdKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -16152,7 +15375,6 @@ void VkEncoder::vkCmdPushDescriptorSetKHR(
     const VkWriteDescriptorSet* pDescriptorWrites)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetKHR encode");
     mImpl->log("start vkCmdPushDescriptorSetKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -16220,8 +15442,6 @@ void VkEncoder::vkCmdPushDescriptorSetKHR(
     {
         marshal_VkWriteDescriptorSet(stream, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
     }
-    AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetKHR readParams");
-    AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetKHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -16236,7 +15456,6 @@ void VkEncoder::vkCmdPushDescriptorSetWithTemplateKHR(
     const void* pData)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetWithTemplateKHR encode");
     mImpl->log("start vkCmdPushDescriptorSetWithTemplateKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -16299,8 +15518,6 @@ void VkEncoder::vkCmdPushDescriptorSetWithTemplateKHR(
     {
         stream->write((void*)local_pData, sizeof(uint8_t));
     }
-    AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetWithTemplateKHR readParams");
-    AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetWithTemplateKHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -16320,7 +15537,6 @@ VkResult VkEncoder::vkCreateDescriptorUpdateTemplateKHR(
     VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR encode");
     mImpl->log("start vkCreateDescriptorUpdateTemplateKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -16390,13 +15606,11 @@ VkResult VkEncoder::vkCreateDescriptorUpdateTemplateKHR(
     stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_1058, 1);
     stream->write((uint64_t*)&cgen_var_1058, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_1059;
     stream->read((uint64_t*)&cgen_var_1059, 8);
     stream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(&cgen_var_1059, (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR returnUnmarshal");
     VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDescriptorUpdateTemplateKHR_VkResult_return, sizeof(VkResult));
     mImpl->resources()->on_vkCreateDescriptorUpdateTemplateKHR(this, vkCreateDescriptorUpdateTemplateKHR_VkResult_return, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
@@ -16413,7 +15627,6 @@ void VkEncoder::vkDestroyDescriptorUpdateTemplateKHR(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR encode");
     mImpl->log("start vkDestroyDescriptorUpdateTemplateKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -16470,8 +15683,6 @@ void VkEncoder::vkDestroyDescriptorUpdateTemplateKHR(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR readParams");
-    AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkDescriptorUpdateTemplate((VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate);
     pool->freeAll();
     countingStream->clearPool();
@@ -16486,7 +15697,6 @@ void VkEncoder::vkUpdateDescriptorSetWithTemplateKHR(
     const void* pData)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR encode");
     mImpl->log("start vkUpdateDescriptorSetWithTemplateKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -16545,8 +15755,6 @@ void VkEncoder::vkUpdateDescriptorSetWithTemplateKHR(
     {
         stream->write((void*)local_pData, sizeof(uint8_t));
     }
-    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR readParams");
-    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -16562,7 +15770,6 @@ VkResult VkEncoder::vkCreateRenderPass2KHR(
     VkRenderPass* pRenderPass)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR encode");
     mImpl->log("start vkCreateRenderPass2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -16632,11 +15839,9 @@ VkResult VkEncoder::vkCreateRenderPass2KHR(
     stream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_1079, 1);
     stream->write((uint64_t*)&cgen_var_1079, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR readParams");
     uint64_t cgen_var_1080;
     stream->read((uint64_t*)&cgen_var_1080, 8);
     stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_1080, (VkRenderPass*)pRenderPass, 1);
-    AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR returnUnmarshal");
     VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateRenderPass2KHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -16652,7 +15857,6 @@ void VkEncoder::vkCmdBeginRenderPass2KHR(
     const VkSubpassBeginInfoKHR* pSubpassBeginInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR encode");
     mImpl->log("start vkCmdBeginRenderPass2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -16701,8 +15905,6 @@ void VkEncoder::vkCmdBeginRenderPass2KHR(
     stream->write((uint64_t*)&cgen_var_1082, 1 * 8);
     marshal_VkRenderPassBeginInfo(stream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
     marshal_VkSubpassBeginInfoKHR(stream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
-    AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR readParams");
-    AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -16715,7 +15917,6 @@ void VkEncoder::vkCmdNextSubpass2KHR(
     const VkSubpassEndInfoKHR* pSubpassEndInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR encode");
     mImpl->log("start vkCmdNextSubpass2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -16764,8 +15965,6 @@ void VkEncoder::vkCmdNextSubpass2KHR(
     stream->write((uint64_t*)&cgen_var_1084, 1 * 8);
     marshal_VkSubpassBeginInfoKHR(stream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
     marshal_VkSubpassEndInfoKHR(stream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
-    AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR readParams");
-    AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -16777,7 +15976,6 @@ void VkEncoder::vkCmdEndRenderPass2KHR(
     const VkSubpassEndInfoKHR* pSubpassEndInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR encode");
     mImpl->log("start vkCmdEndRenderPass2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -16813,8 +16011,6 @@ void VkEncoder::vkCmdEndRenderPass2KHR(
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1086, 1);
     stream->write((uint64_t*)&cgen_var_1086, 1 * 8);
     marshal_VkSubpassEndInfoKHR(stream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
-    AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR readParams");
-    AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -16828,7 +16024,6 @@ VkResult VkEncoder::vkGetSwapchainStatusKHR(
     VkSwapchainKHR swapchain)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetSwapchainStatusKHR encode");
     mImpl->log("start vkGetSwapchainStatusKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -16859,8 +16054,6 @@ VkResult VkEncoder::vkGetSwapchainStatusKHR(
     uint64_t cgen_var_1090;
     stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1090, 1);
     stream->write((uint64_t*)&cgen_var_1090, 1 * 8);
-    AEMU_SCOPED_TRACE("vkGetSwapchainStatusKHR readParams");
-    AEMU_SCOPED_TRACE("vkGetSwapchainStatusKHR returnUnmarshal");
     VkResult vkGetSwapchainStatusKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetSwapchainStatusKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -16878,7 +16071,6 @@ void VkEncoder::vkGetPhysicalDeviceExternalFencePropertiesKHR(
     VkExternalFenceProperties* pExternalFenceProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFencePropertiesKHR encode");
     mImpl->log("start vkGetPhysicalDeviceExternalFencePropertiesKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -16916,13 +16108,11 @@ void VkEncoder::vkGetPhysicalDeviceExternalFencePropertiesKHR(
     stream->write((uint64_t*)&cgen_var_1092, 1 * 8);
     marshal_VkPhysicalDeviceExternalFenceInfo(stream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
     marshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFencePropertiesKHR readParams");
     unmarshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties));
     if (pExternalFenceProperties)
     {
         transform_fromhost_VkExternalFenceProperties(mImpl->resources(), (VkExternalFenceProperties*)(pExternalFenceProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFencePropertiesKHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -16938,7 +16128,6 @@ VkResult VkEncoder::vkImportFenceWin32HandleKHR(
     const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkImportFenceWin32HandleKHR encode");
     mImpl->log("start vkImportFenceWin32HandleKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -16974,8 +16163,6 @@ VkResult VkEncoder::vkImportFenceWin32HandleKHR(
     stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1094, 1);
     stream->write((uint64_t*)&cgen_var_1094, 1 * 8);
     marshal_VkImportFenceWin32HandleInfoKHR(stream, (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo));
-    AEMU_SCOPED_TRACE("vkImportFenceWin32HandleKHR readParams");
-    AEMU_SCOPED_TRACE("vkImportFenceWin32HandleKHR returnUnmarshal");
     VkResult vkImportFenceWin32HandleKHR_VkResult_return = (VkResult)0;
     stream->read(&vkImportFenceWin32HandleKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -16991,7 +16178,6 @@ VkResult VkEncoder::vkGetFenceWin32HandleKHR(
     HANDLE* pHandle)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetFenceWin32HandleKHR encode");
     mImpl->log("start vkGetFenceWin32HandleKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -17029,9 +16215,7 @@ VkResult VkEncoder::vkGetFenceWin32HandleKHR(
     stream->write((uint64_t*)&cgen_var_1096, 1 * 8);
     marshal_VkFenceGetWin32HandleInfoKHR(stream, (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
     stream->write((HANDLE*)pHandle, sizeof(HANDLE));
-    AEMU_SCOPED_TRACE("vkGetFenceWin32HandleKHR readParams");
     stream->read((HANDLE*)pHandle, sizeof(HANDLE));
-    AEMU_SCOPED_TRACE("vkGetFenceWin32HandleKHR returnUnmarshal");
     VkResult vkGetFenceWin32HandleKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetFenceWin32HandleKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -17048,7 +16232,6 @@ VkResult VkEncoder::vkImportFenceFdKHR(
     const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkImportFenceFdKHR encode");
     mImpl->log("start vkImportFenceFdKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -17084,8 +16267,6 @@ VkResult VkEncoder::vkImportFenceFdKHR(
     stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1098, 1);
     stream->write((uint64_t*)&cgen_var_1098, 1 * 8);
     marshal_VkImportFenceFdInfoKHR(stream, (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo));
-    AEMU_SCOPED_TRACE("vkImportFenceFdKHR readParams");
-    AEMU_SCOPED_TRACE("vkImportFenceFdKHR returnUnmarshal");
     VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
     stream->read(&vkImportFenceFdKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -17101,7 +16282,6 @@ VkResult VkEncoder::vkGetFenceFdKHR(
     int* pFd)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetFenceFdKHR encode");
     mImpl->log("start vkGetFenceFdKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -17139,9 +16319,7 @@ VkResult VkEncoder::vkGetFenceFdKHR(
     stream->write((uint64_t*)&cgen_var_1100, 1 * 8);
     marshal_VkFenceGetFdInfoKHR(stream, (VkFenceGetFdInfoKHR*)(local_pGetFdInfo));
     stream->write((int*)pFd, sizeof(int));
-    AEMU_SCOPED_TRACE("vkGetFenceFdKHR readParams");
     stream->read((int*)pFd, sizeof(int));
-    AEMU_SCOPED_TRACE("vkGetFenceFdKHR returnUnmarshal");
     VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetFenceFdKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -17161,7 +16339,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilities2KHR(
     VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceSurfaceCapabilities2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -17199,13 +16376,11 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilities2KHR(
     stream->write((uint64_t*)&cgen_var_1102, 1 * 8);
     marshal_VkPhysicalDeviceSurfaceInfo2KHR(stream, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
     marshal_VkSurfaceCapabilities2KHR(stream, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2KHR readParams");
     unmarshal_VkSurfaceCapabilities2KHR(stream, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities));
     if (pSurfaceCapabilities)
     {
         transform_fromhost_VkSurfaceCapabilities2KHR(mImpl->resources(), (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2KHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -17222,7 +16397,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormats2KHR(
     VkSurfaceFormat2KHR* pSurfaceFormats)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormats2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceSurfaceFormats2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -17292,7 +16466,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormats2KHR(
             marshal_VkSurfaceFormat2KHR(stream, (VkSurfaceFormat2KHR*)(pSurfaceFormats + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormats2KHR readParams");
     // WARNING PTR CHECK
     uint32_t* check_pSurfaceFormatCount;
     check_pSurfaceFormatCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -17325,7 +16498,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormats2KHR(
             transform_fromhost_VkSurfaceFormat2KHR(mImpl->resources(), (VkSurfaceFormat2KHR*)(pSurfaceFormats + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormats2KHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -17345,7 +16517,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayProperties2KHR(
     VkDisplayProperties2KHR* pProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayProperties2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceDisplayProperties2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -17402,7 +16573,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayProperties2KHR(
             marshal_VkDisplayProperties2KHR(stream, (VkDisplayProperties2KHR*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayProperties2KHR readParams");
     // WARNING PTR CHECK
     uint32_t* check_pPropertyCount;
     check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -17435,7 +16605,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayProperties2KHR(
             transform_fromhost_VkDisplayProperties2KHR(mImpl->resources(), (VkDisplayProperties2KHR*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayProperties2KHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -17451,7 +16620,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
     VkDisplayPlaneProperties2KHR* pProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlaneProperties2KHR encode");
     mImpl->log("start vkGetPhysicalDeviceDisplayPlaneProperties2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -17508,7 +16676,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
             marshal_VkDisplayPlaneProperties2KHR(stream, (VkDisplayPlaneProperties2KHR*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlaneProperties2KHR readParams");
     // WARNING PTR CHECK
     uint32_t* check_pPropertyCount;
     check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -17541,7 +16708,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
             transform_fromhost_VkDisplayPlaneProperties2KHR(mImpl->resources(), (VkDisplayPlaneProperties2KHR*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlaneProperties2KHR returnUnmarshal");
     VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -17558,7 +16724,6 @@ VkResult VkEncoder::vkGetDisplayModeProperties2KHR(
     VkDisplayModeProperties2KHR* pProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetDisplayModeProperties2KHR encode");
     mImpl->log("start vkGetDisplayModeProperties2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -17623,7 +16788,6 @@ VkResult VkEncoder::vkGetDisplayModeProperties2KHR(
             marshal_VkDisplayModeProperties2KHR(stream, (VkDisplayModeProperties2KHR*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetDisplayModeProperties2KHR readParams");
     // WARNING PTR CHECK
     uint32_t* check_pPropertyCount;
     check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -17656,7 +16820,6 @@ VkResult VkEncoder::vkGetDisplayModeProperties2KHR(
             transform_fromhost_VkDisplayModeProperties2KHR(mImpl->resources(), (VkDisplayModeProperties2KHR*)(pProperties + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetDisplayModeProperties2KHR returnUnmarshal");
     VkResult vkGetDisplayModeProperties2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetDisplayModeProperties2KHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -17672,7 +16835,6 @@ VkResult VkEncoder::vkGetDisplayPlaneCapabilities2KHR(
     VkDisplayPlaneCapabilities2KHR* pCapabilities)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilities2KHR encode");
     mImpl->log("start vkGetDisplayPlaneCapabilities2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -17710,13 +16872,11 @@ VkResult VkEncoder::vkGetDisplayPlaneCapabilities2KHR(
     stream->write((uint64_t*)&cgen_var_1138, 1 * 8);
     marshal_VkDisplayPlaneInfo2KHR(stream, (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo));
     marshal_VkDisplayPlaneCapabilities2KHR(stream, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities));
-    AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilities2KHR readParams");
     unmarshal_VkDisplayPlaneCapabilities2KHR(stream, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities));
     if (pCapabilities)
     {
         transform_fromhost_VkDisplayPlaneCapabilities2KHR(mImpl->resources(), (VkDisplayPlaneCapabilities2KHR*)(pCapabilities));
     }
-    AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilities2KHR returnUnmarshal");
     VkResult vkGetDisplayPlaneCapabilities2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkGetDisplayPlaneCapabilities2KHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -17740,7 +16900,6 @@ void VkEncoder::vkGetImageMemoryRequirements2KHR(
     VkMemoryRequirements2* pMemoryRequirements)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR encode");
     mImpl->log("start vkGetImageMemoryRequirements2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -17778,13 +16937,11 @@ void VkEncoder::vkGetImageMemoryRequirements2KHR(
     stream->write((uint64_t*)&cgen_var_1140, 1 * 8);
     marshal_VkImageMemoryRequirementsInfo2(stream, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
     marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
-    AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR readParams");
     unmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
     if (pMemoryRequirements)
     {
         transform_fromhost_VkMemoryRequirements2(mImpl->resources(), (VkMemoryRequirements2*)(pMemoryRequirements));
     }
-    AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -17797,7 +16954,6 @@ void VkEncoder::vkGetBufferMemoryRequirements2KHR(
     VkMemoryRequirements2* pMemoryRequirements)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR encode");
     mImpl->log("start vkGetBufferMemoryRequirements2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -17835,13 +16991,11 @@ void VkEncoder::vkGetBufferMemoryRequirements2KHR(
     stream->write((uint64_t*)&cgen_var_1142, 1 * 8);
     marshal_VkBufferMemoryRequirementsInfo2(stream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
     marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
-    AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR readParams");
     unmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
     if (pMemoryRequirements)
     {
         transform_fromhost_VkMemoryRequirements2(mImpl->resources(), (VkMemoryRequirements2*)(pMemoryRequirements));
     }
-    AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -17855,7 +17009,6 @@ void VkEncoder::vkGetImageSparseMemoryRequirements2KHR(
     VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR encode");
     mImpl->log("start vkGetImageSparseMemoryRequirements2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -17925,7 +17078,6 @@ void VkEncoder::vkGetImageSparseMemoryRequirements2KHR(
             marshal_VkSparseImageMemoryRequirements2(stream, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR readParams");
     // WARNING PTR CHECK
     uint32_t* check_pSparseMemoryRequirementCount;
     check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -17958,7 +17110,6 @@ void VkEncoder::vkGetImageSparseMemoryRequirements2KHR(
             transform_fromhost_VkSparseImageMemoryRequirements2(mImpl->resources(), (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -17976,7 +17127,6 @@ VkResult VkEncoder::vkCreateSamplerYcbcrConversionKHR(
     VkSamplerYcbcrConversion* pYcbcrConversion)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR encode");
     mImpl->log("start vkCreateSamplerYcbcrConversionKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -18046,13 +17196,11 @@ VkResult VkEncoder::vkCreateSamplerYcbcrConversionKHR(
     stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_1156, 1);
     stream->write((uint64_t*)&cgen_var_1156, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_1157;
     stream->read((uint64_t*)&cgen_var_1157, 8);
     stream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_1157, (VkSamplerYcbcrConversion*)pYcbcrConversion, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR returnUnmarshal");
     VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
     stream->read(&vkCreateSamplerYcbcrConversionKHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -18068,7 +17216,6 @@ void VkEncoder::vkDestroySamplerYcbcrConversionKHR(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR encode");
     mImpl->log("start vkDestroySamplerYcbcrConversionKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -18125,8 +17272,6 @@ void VkEncoder::vkDestroySamplerYcbcrConversionKHR(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR readParams");
-    AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkSamplerYcbcrConversion((VkSamplerYcbcrConversion*)&ycbcrConversion);
     pool->freeAll();
     countingStream->clearPool();
@@ -18142,7 +17287,6 @@ VkResult VkEncoder::vkBindBufferMemory2KHR(
     const VkBindBufferMemoryInfo* pBindInfos)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR encode");
     mImpl->log("start vkBindBufferMemory2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -18194,8 +17338,6 @@ VkResult VkEncoder::vkBindBufferMemory2KHR(
     {
         marshal_VkBindBufferMemoryInfo(stream, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
     }
-    AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR readParams");
-    AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR returnUnmarshal");
     VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkBindBufferMemory2KHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -18211,7 +17353,6 @@ VkResult VkEncoder::vkBindImageMemory2KHR(
     const VkBindImageMemoryInfo* pBindInfos)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkBindImageMemory2KHR encode");
     mImpl->log("start vkBindImageMemory2KHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -18263,8 +17404,6 @@ VkResult VkEncoder::vkBindImageMemory2KHR(
     {
         marshal_VkBindImageMemoryInfo(stream, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
     }
-    AEMU_SCOPED_TRACE("vkBindImageMemory2KHR readParams");
-    AEMU_SCOPED_TRACE("vkBindImageMemory2KHR returnUnmarshal");
     VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
     stream->read(&vkBindImageMemory2KHR_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -18282,7 +17421,6 @@ void VkEncoder::vkGetDescriptorSetLayoutSupportKHR(
     VkDescriptorSetLayoutSupport* pSupport)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR encode");
     mImpl->log("start vkGetDescriptorSetLayoutSupportKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -18320,13 +17458,11 @@ void VkEncoder::vkGetDescriptorSetLayoutSupportKHR(
     stream->write((uint64_t*)&cgen_var_1169, 1 * 8);
     marshal_VkDescriptorSetLayoutCreateInfo(stream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
     marshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport));
-    AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR readParams");
     unmarshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport));
     if (pSupport)
     {
         transform_fromhost_VkDescriptorSetLayoutSupport(mImpl->resources(), (VkDescriptorSetLayoutSupport*)(pSupport));
     }
-    AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -18345,7 +17481,6 @@ void VkEncoder::vkCmdDrawIndirectCountKHR(
     uint32_t stride)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountKHR encode");
     mImpl->log("start vkCmdDrawIndirectCountKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -18400,8 +17535,6 @@ void VkEncoder::vkCmdDrawIndirectCountKHR(
     stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
     stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
     stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountKHR readParams");
-    AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountKHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -18418,7 +17551,6 @@ void VkEncoder::vkCmdDrawIndexedIndirectCountKHR(
     uint32_t stride)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountKHR encode");
     mImpl->log("start vkCmdDrawIndexedIndirectCountKHR");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -18473,8 +17605,6 @@ void VkEncoder::vkCmdDrawIndexedIndirectCountKHR(
     stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
     stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
     stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountKHR readParams");
-    AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountKHR returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -18494,7 +17624,6 @@ VkResult VkEncoder::vkGetSwapchainGrallocUsageANDROID(
     int* grallocUsage)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID encode");
     mImpl->log("start vkGetSwapchainGrallocUsageANDROID");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -18527,9 +17656,7 @@ VkResult VkEncoder::vkGetSwapchainGrallocUsageANDROID(
     stream->write((VkFormat*)&local_format, sizeof(VkFormat));
     stream->write((VkImageUsageFlags*)&local_imageUsage, sizeof(VkImageUsageFlags));
     stream->write((int*)grallocUsage, sizeof(int));
-    AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID readParams");
     stream->read((int*)grallocUsage, sizeof(int));
-    AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID returnUnmarshal");
     VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
     stream->read(&vkGetSwapchainGrallocUsageANDROID_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -18547,7 +17674,6 @@ VkResult VkEncoder::vkAcquireImageANDROID(
     VkFence fence)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkAcquireImageANDROID encode");
     mImpl->log("start vkAcquireImageANDROID");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -18599,8 +17725,6 @@ VkResult VkEncoder::vkAcquireImageANDROID(
     uint64_t cgen_var_1191;
     stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1191, 1);
     stream->write((uint64_t*)&cgen_var_1191, 1 * 8);
-    AEMU_SCOPED_TRACE("vkAcquireImageANDROID readParams");
-    AEMU_SCOPED_TRACE("vkAcquireImageANDROID returnUnmarshal");
     VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
     stream->read(&vkAcquireImageANDROID_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -18618,7 +17742,6 @@ VkResult VkEncoder::vkQueueSignalReleaseImageANDROID(
     int* pNativeFenceFd)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROID encode");
     mImpl->log("start vkQueueSignalReleaseImageANDROID");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -18687,9 +17810,7 @@ VkResult VkEncoder::vkQueueSignalReleaseImageANDROID(
     stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1199, 1);
     stream->write((uint64_t*)&cgen_var_1199, 1 * 8);
     stream->write((int*)pNativeFenceFd, sizeof(int));
-    AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROID readParams");
     stream->read((int*)pNativeFenceFd, sizeof(int));
-    AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROID returnUnmarshal");
     VkResult vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0;
     stream->read(&vkQueueSignalReleaseImageANDROID_VkResult_return, sizeof(VkResult));
     stream->flush();
@@ -18709,7 +17830,6 @@ VkResult VkEncoder::vkCreateDebugReportCallbackEXT(
     VkDebugReportCallbackEXT* pCallback)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateDebugReportCallbackEXT encode");
     mImpl->log("start vkCreateDebugReportCallbackEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -18779,13 +17899,11 @@ VkResult VkEncoder::vkCreateDebugReportCallbackEXT(
     stream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(pCallback, &cgen_var_1205, 1);
     stream->write((uint64_t*)&cgen_var_1205, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateDebugReportCallbackEXT readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_1206;
     stream->read((uint64_t*)&cgen_var_1206, 8);
     stream->handleMapping()->mapHandles_u64_VkDebugReportCallbackEXT(&cgen_var_1206, (VkDebugReportCallbackEXT*)pCallback, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateDebugReportCallbackEXT returnUnmarshal");
     VkResult vkCreateDebugReportCallbackEXT_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDebugReportCallbackEXT_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -18801,7 +17919,6 @@ void VkEncoder::vkDestroyDebugReportCallbackEXT(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyDebugReportCallbackEXT encode");
     mImpl->log("start vkDestroyDebugReportCallbackEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -18858,8 +17975,6 @@ void VkEncoder::vkDestroyDebugReportCallbackEXT(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyDebugReportCallbackEXT readParams");
-    AEMU_SCOPED_TRACE("vkDestroyDebugReportCallbackEXT returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkDebugReportCallbackEXT((VkDebugReportCallbackEXT*)&callback);
     pool->freeAll();
     countingStream->clearPool();
@@ -18878,7 +17993,6 @@ void VkEncoder::vkDebugReportMessageEXT(
     const char* pMessage)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDebugReportMessageEXT encode");
     mImpl->log("start vkDebugReportMessageEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -18939,8 +18053,6 @@ void VkEncoder::vkDebugReportMessageEXT(
     stream->write((int32_t*)&local_messageCode, sizeof(int32_t));
     stream->putString(local_pLayerPrefix);
     stream->putString(local_pMessage);
-    AEMU_SCOPED_TRACE("vkDebugReportMessageEXT readParams");
-    AEMU_SCOPED_TRACE("vkDebugReportMessageEXT returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -18966,7 +18078,6 @@ VkResult VkEncoder::vkDebugMarkerSetObjectTagEXT(
     const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectTagEXT encode");
     mImpl->log("start vkDebugMarkerSetObjectTagEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -19002,8 +18113,6 @@ VkResult VkEncoder::vkDebugMarkerSetObjectTagEXT(
     stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1218, 1);
     stream->write((uint64_t*)&cgen_var_1218, 1 * 8);
     marshal_VkDebugMarkerObjectTagInfoEXT(stream, (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo));
-    AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectTagEXT readParams");
-    AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectTagEXT returnUnmarshal");
     VkResult vkDebugMarkerSetObjectTagEXT_VkResult_return = (VkResult)0;
     stream->read(&vkDebugMarkerSetObjectTagEXT_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -19018,7 +18127,6 @@ VkResult VkEncoder::vkDebugMarkerSetObjectNameEXT(
     const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectNameEXT encode");
     mImpl->log("start vkDebugMarkerSetObjectNameEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -19054,8 +18162,6 @@ VkResult VkEncoder::vkDebugMarkerSetObjectNameEXT(
     stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1220, 1);
     stream->write((uint64_t*)&cgen_var_1220, 1 * 8);
     marshal_VkDebugMarkerObjectNameInfoEXT(stream, (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo));
-    AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectNameEXT readParams");
-    AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectNameEXT returnUnmarshal");
     VkResult vkDebugMarkerSetObjectNameEXT_VkResult_return = (VkResult)0;
     stream->read(&vkDebugMarkerSetObjectNameEXT_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -19070,7 +18176,6 @@ void VkEncoder::vkCmdDebugMarkerBeginEXT(
     const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdDebugMarkerBeginEXT encode");
     mImpl->log("start vkCmdDebugMarkerBeginEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -19106,8 +18211,6 @@ void VkEncoder::vkCmdDebugMarkerBeginEXT(
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1222, 1);
     stream->write((uint64_t*)&cgen_var_1222, 1 * 8);
     marshal_VkDebugMarkerMarkerInfoEXT(stream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
-    AEMU_SCOPED_TRACE("vkCmdDebugMarkerBeginEXT readParams");
-    AEMU_SCOPED_TRACE("vkCmdDebugMarkerBeginEXT returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -19118,7 +18221,6 @@ void VkEncoder::vkCmdDebugMarkerEndEXT(
     VkCommandBuffer commandBuffer)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdDebugMarkerEndEXT encode");
     mImpl->log("start vkCmdDebugMarkerEndEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -19141,8 +18243,6 @@ void VkEncoder::vkCmdDebugMarkerEndEXT(
     uint64_t cgen_var_1224;
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1224, 1);
     stream->write((uint64_t*)&cgen_var_1224, 1 * 8);
-    AEMU_SCOPED_TRACE("vkCmdDebugMarkerEndEXT readParams");
-    AEMU_SCOPED_TRACE("vkCmdDebugMarkerEndEXT returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -19154,7 +18254,6 @@ void VkEncoder::vkCmdDebugMarkerInsertEXT(
     const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdDebugMarkerInsertEXT encode");
     mImpl->log("start vkCmdDebugMarkerInsertEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -19190,8 +18289,6 @@ void VkEncoder::vkCmdDebugMarkerInsertEXT(
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1226, 1);
     stream->write((uint64_t*)&cgen_var_1226, 1 * 8);
     marshal_VkDebugMarkerMarkerInfoEXT(stream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
-    AEMU_SCOPED_TRACE("vkCmdDebugMarkerInsertEXT readParams");
-    AEMU_SCOPED_TRACE("vkCmdDebugMarkerInsertEXT returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -19214,7 +18311,6 @@ void VkEncoder::vkCmdDrawIndirectCountAMD(
     uint32_t stride)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountAMD encode");
     mImpl->log("start vkCmdDrawIndirectCountAMD");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -19269,8 +18365,6 @@ void VkEncoder::vkCmdDrawIndirectCountAMD(
     stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
     stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
     stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountAMD readParams");
-    AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountAMD returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -19287,7 +18381,6 @@ void VkEncoder::vkCmdDrawIndexedIndirectCountAMD(
     uint32_t stride)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountAMD encode");
     mImpl->log("start vkCmdDrawIndexedIndirectCountAMD");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -19342,8 +18435,6 @@ void VkEncoder::vkCmdDrawIndexedIndirectCountAMD(
     stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
     stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
     stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountAMD readParams");
-    AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountAMD returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -19369,7 +18460,6 @@ VkResult VkEncoder::vkGetShaderInfoAMD(
     void* pInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetShaderInfoAMD encode");
     mImpl->log("start vkGetShaderInfoAMD");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -19438,7 +18528,6 @@ VkResult VkEncoder::vkGetShaderInfoAMD(
     {
         stream->write((void*)pInfo, (*(pInfoSize)) * sizeof(uint8_t));
     }
-    AEMU_SCOPED_TRACE("vkGetShaderInfoAMD readParams");
     // WARNING PTR CHECK
     size_t* check_pInfoSize;
     check_pInfoSize = (size_t*)(uintptr_t)stream->getBe64();
@@ -19461,7 +18550,6 @@ VkResult VkEncoder::vkGetShaderInfoAMD(
         }
         stream->read((void*)pInfo, (*(pInfoSize)) * sizeof(uint8_t));
     }
-    AEMU_SCOPED_TRACE("vkGetShaderInfoAMD returnUnmarshal");
     VkResult vkGetShaderInfoAMD_VkResult_return = (VkResult)0;
     stream->read(&vkGetShaderInfoAMD_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -19488,7 +18576,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
     VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalImageFormatPropertiesNV encode");
     mImpl->log("start vkGetPhysicalDeviceExternalImageFormatPropertiesNV");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -19537,13 +18624,11 @@ VkResult VkEncoder::vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
     stream->write((VkImageCreateFlags*)&local_flags, sizeof(VkImageCreateFlags));
     stream->write((VkExternalMemoryHandleTypeFlagsNV*)&local_externalHandleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
     marshal_VkExternalImageFormatPropertiesNV(stream, (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalImageFormatPropertiesNV readParams");
     unmarshal_VkExternalImageFormatPropertiesNV(stream, (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties));
     if (pExternalImageFormatProperties)
     {
         transform_fromhost_VkExternalImageFormatPropertiesNV(mImpl->resources(), (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalImageFormatPropertiesNV returnUnmarshal");
     VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -19564,7 +18649,6 @@ VkResult VkEncoder::vkGetMemoryWin32HandleNV(
     HANDLE* pHandle)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleNV encode");
     mImpl->log("start vkGetMemoryWin32HandleNV");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -19602,9 +18686,7 @@ VkResult VkEncoder::vkGetMemoryWin32HandleNV(
     stream->write((uint64_t*)&cgen_var_1257, 1 * 8);
     stream->write((VkExternalMemoryHandleTypeFlagsNV*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
     stream->write((HANDLE*)pHandle, sizeof(HANDLE));
-    AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleNV readParams");
     stream->read((HANDLE*)pHandle, sizeof(HANDLE));
-    AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleNV returnUnmarshal");
     VkResult vkGetMemoryWin32HandleNV_VkResult_return = (VkResult)0;
     stream->read(&vkGetMemoryWin32HandleNV_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -19627,7 +18709,6 @@ VkResult VkEncoder::vkCreateViSurfaceNN(
     VkSurfaceKHR* pSurface)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateViSurfaceNN encode");
     mImpl->log("start vkCreateViSurfaceNN");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -19697,11 +18778,9 @@ VkResult VkEncoder::vkCreateViSurfaceNN(
     stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1263, 1);
     stream->write((uint64_t*)&cgen_var_1263, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateViSurfaceNN readParams");
     uint64_t cgen_var_1264;
     stream->read((uint64_t*)&cgen_var_1264, 8);
     stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1264, (VkSurfaceKHR*)pSurface, 1);
-    AEMU_SCOPED_TRACE("vkCreateViSurfaceNN returnUnmarshal");
     VkResult vkCreateViSurfaceNN_VkResult_return = (VkResult)0;
     stream->read(&vkCreateViSurfaceNN_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -19722,7 +18801,6 @@ void VkEncoder::vkCmdBeginConditionalRenderingEXT(
     const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdBeginConditionalRenderingEXT encode");
     mImpl->log("start vkCmdBeginConditionalRenderingEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -19758,8 +18836,6 @@ void VkEncoder::vkCmdBeginConditionalRenderingEXT(
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1266, 1);
     stream->write((uint64_t*)&cgen_var_1266, 1 * 8);
     marshal_VkConditionalRenderingBeginInfoEXT(stream, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin));
-    AEMU_SCOPED_TRACE("vkCmdBeginConditionalRenderingEXT readParams");
-    AEMU_SCOPED_TRACE("vkCmdBeginConditionalRenderingEXT returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -19770,7 +18846,6 @@ void VkEncoder::vkCmdEndConditionalRenderingEXT(
     VkCommandBuffer commandBuffer)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdEndConditionalRenderingEXT encode");
     mImpl->log("start vkCmdEndConditionalRenderingEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -19793,8 +18868,6 @@ void VkEncoder::vkCmdEndConditionalRenderingEXT(
     uint64_t cgen_var_1268;
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1268, 1);
     stream->write((uint64_t*)&cgen_var_1268, 1 * 8);
-    AEMU_SCOPED_TRACE("vkCmdEndConditionalRenderingEXT readParams");
-    AEMU_SCOPED_TRACE("vkCmdEndConditionalRenderingEXT returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -19808,7 +18881,6 @@ void VkEncoder::vkCmdProcessCommandsNVX(
     const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdProcessCommandsNVX encode");
     mImpl->log("start vkCmdProcessCommandsNVX");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -19844,8 +18916,6 @@ void VkEncoder::vkCmdProcessCommandsNVX(
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1270, 1);
     stream->write((uint64_t*)&cgen_var_1270, 1 * 8);
     marshal_VkCmdProcessCommandsInfoNVX(stream, (VkCmdProcessCommandsInfoNVX*)(local_pProcessCommandsInfo));
-    AEMU_SCOPED_TRACE("vkCmdProcessCommandsNVX readParams");
-    AEMU_SCOPED_TRACE("vkCmdProcessCommandsNVX returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -19857,7 +18927,6 @@ void VkEncoder::vkCmdReserveSpaceForCommandsNVX(
     const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdReserveSpaceForCommandsNVX encode");
     mImpl->log("start vkCmdReserveSpaceForCommandsNVX");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -19893,8 +18962,6 @@ void VkEncoder::vkCmdReserveSpaceForCommandsNVX(
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1272, 1);
     stream->write((uint64_t*)&cgen_var_1272, 1 * 8);
     marshal_VkCmdReserveSpaceForCommandsInfoNVX(stream, (VkCmdReserveSpaceForCommandsInfoNVX*)(local_pReserveSpaceInfo));
-    AEMU_SCOPED_TRACE("vkCmdReserveSpaceForCommandsNVX readParams");
-    AEMU_SCOPED_TRACE("vkCmdReserveSpaceForCommandsNVX returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -19908,7 +18975,6 @@ VkResult VkEncoder::vkCreateIndirectCommandsLayoutNVX(
     VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateIndirectCommandsLayoutNVX encode");
     mImpl->log("start vkCreateIndirectCommandsLayoutNVX");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -19978,13 +19044,11 @@ VkResult VkEncoder::vkCreateIndirectCommandsLayoutNVX(
     stream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(pIndirectCommandsLayout, &cgen_var_1278, 1);
     stream->write((uint64_t*)&cgen_var_1278, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateIndirectCommandsLayoutNVX readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_1279;
     stream->read((uint64_t*)&cgen_var_1279, 8);
     stream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_1279, (VkIndirectCommandsLayoutNVX*)pIndirectCommandsLayout, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateIndirectCommandsLayoutNVX returnUnmarshal");
     VkResult vkCreateIndirectCommandsLayoutNVX_VkResult_return = (VkResult)0;
     stream->read(&vkCreateIndirectCommandsLayoutNVX_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -20000,7 +19064,6 @@ void VkEncoder::vkDestroyIndirectCommandsLayoutNVX(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyIndirectCommandsLayoutNVX encode");
     mImpl->log("start vkDestroyIndirectCommandsLayoutNVX");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -20057,8 +19120,6 @@ void VkEncoder::vkDestroyIndirectCommandsLayoutNVX(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyIndirectCommandsLayoutNVX readParams");
-    AEMU_SCOPED_TRACE("vkDestroyIndirectCommandsLayoutNVX returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkIndirectCommandsLayoutNVX((VkIndirectCommandsLayoutNVX*)&indirectCommandsLayout);
     pool->freeAll();
     countingStream->clearPool();
@@ -20073,7 +19134,6 @@ VkResult VkEncoder::vkCreateObjectTableNVX(
     VkObjectTableNVX* pObjectTable)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateObjectTableNVX encode");
     mImpl->log("start vkCreateObjectTableNVX");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -20143,13 +19203,11 @@ VkResult VkEncoder::vkCreateObjectTableNVX(
     stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(pObjectTable, &cgen_var_1291, 1);
     stream->write((uint64_t*)&cgen_var_1291, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateObjectTableNVX readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_1292;
     stream->read((uint64_t*)&cgen_var_1292, 8);
     stream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_1292, (VkObjectTableNVX*)pObjectTable, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateObjectTableNVX returnUnmarshal");
     VkResult vkCreateObjectTableNVX_VkResult_return = (VkResult)0;
     stream->read(&vkCreateObjectTableNVX_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -20165,7 +19223,6 @@ void VkEncoder::vkDestroyObjectTableNVX(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyObjectTableNVX encode");
     mImpl->log("start vkDestroyObjectTableNVX");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -20222,8 +19279,6 @@ void VkEncoder::vkDestroyObjectTableNVX(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyObjectTableNVX readParams");
-    AEMU_SCOPED_TRACE("vkDestroyObjectTableNVX returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkObjectTableNVX((VkObjectTableNVX*)&objectTable);
     pool->freeAll();
     countingStream->clearPool();
@@ -20239,7 +19294,6 @@ VkResult VkEncoder::vkRegisterObjectsNVX(
     const uint32_t* pObjectIndices)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkRegisterObjectsNVX encode");
     mImpl->log("start vkRegisterObjectsNVX");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -20287,8 +19341,6 @@ VkResult VkEncoder::vkRegisterObjectsNVX(
     stream->write((uint32_t*)&local_objectCount, sizeof(uint32_t));
     (void)local_ppObjectTableEntries;
     stream->write((uint32_t*)local_pObjectIndices, ((objectCount)) * sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkRegisterObjectsNVX readParams");
-    AEMU_SCOPED_TRACE("vkRegisterObjectsNVX returnUnmarshal");
     VkResult vkRegisterObjectsNVX_VkResult_return = (VkResult)0;
     stream->read(&vkRegisterObjectsNVX_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -20306,7 +19358,6 @@ VkResult VkEncoder::vkUnregisterObjectsNVX(
     const uint32_t* pObjectIndices)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkUnregisterObjectsNVX encode");
     mImpl->log("start vkUnregisterObjectsNVX");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -20357,8 +19408,6 @@ VkResult VkEncoder::vkUnregisterObjectsNVX(
     stream->write((uint32_t*)&local_objectCount, sizeof(uint32_t));
     stream->write((VkObjectEntryTypeNVX*)local_pObjectEntryTypes, ((objectCount)) * sizeof(VkObjectEntryTypeNVX));
     stream->write((uint32_t*)local_pObjectIndices, ((objectCount)) * sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkUnregisterObjectsNVX readParams");
-    AEMU_SCOPED_TRACE("vkUnregisterObjectsNVX returnUnmarshal");
     VkResult vkUnregisterObjectsNVX_VkResult_return = (VkResult)0;
     stream->read(&vkUnregisterObjectsNVX_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -20374,7 +19423,6 @@ void VkEncoder::vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
     VkDeviceGeneratedCommandsLimitsNVX* pLimits)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX encode");
     mImpl->log("start vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -20401,7 +19449,6 @@ void VkEncoder::vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
     stream->write((uint64_t*)&cgen_var_1308, 1 * 8);
     marshal_VkDeviceGeneratedCommandsFeaturesNVX(stream, (VkDeviceGeneratedCommandsFeaturesNVX*)(pFeatures));
     marshal_VkDeviceGeneratedCommandsLimitsNVX(stream, (VkDeviceGeneratedCommandsLimitsNVX*)(pLimits));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX readParams");
     unmarshal_VkDeviceGeneratedCommandsFeaturesNVX(stream, (VkDeviceGeneratedCommandsFeaturesNVX*)(pFeatures));
     if (pFeatures)
     {
@@ -20412,7 +19459,6 @@ void VkEncoder::vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
     {
         transform_fromhost_VkDeviceGeneratedCommandsLimitsNVX(mImpl->resources(), (VkDeviceGeneratedCommandsLimitsNVX*)(pLimits));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -20428,7 +19474,6 @@ void VkEncoder::vkCmdSetViewportWScalingNV(
     const VkViewportWScalingNV* pViewportWScalings)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdSetViewportWScalingNV encode");
     mImpl->log("start vkCmdSetViewportWScalingNV");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -20484,8 +19529,6 @@ void VkEncoder::vkCmdSetViewportWScalingNV(
     {
         marshal_VkViewportWScalingNV(stream, (VkViewportWScalingNV*)(local_pViewportWScalings + i));
     }
-    AEMU_SCOPED_TRACE("vkCmdSetViewportWScalingNV readParams");
-    AEMU_SCOPED_TRACE("vkCmdSetViewportWScalingNV returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -20499,7 +19542,6 @@ VkResult VkEncoder::vkReleaseDisplayEXT(
     VkDisplayKHR display)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkReleaseDisplayEXT encode");
     mImpl->log("start vkReleaseDisplayEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -20530,8 +19572,6 @@ VkResult VkEncoder::vkReleaseDisplayEXT(
     uint64_t cgen_var_1314;
     stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1314, 1);
     stream->write((uint64_t*)&cgen_var_1314, 1 * 8);
-    AEMU_SCOPED_TRACE("vkReleaseDisplayEXT readParams");
-    AEMU_SCOPED_TRACE("vkReleaseDisplayEXT returnUnmarshal");
     VkResult vkReleaseDisplayEXT_VkResult_return = (VkResult)0;
     stream->read(&vkReleaseDisplayEXT_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -20549,7 +19589,6 @@ VkResult VkEncoder::vkAcquireXlibDisplayEXT(
     VkDisplayKHR display)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkAcquireXlibDisplayEXT encode");
     mImpl->log("start vkAcquireXlibDisplayEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -20582,9 +19621,7 @@ VkResult VkEncoder::vkAcquireXlibDisplayEXT(
     uint64_t cgen_var_1318;
     stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1318, 1);
     stream->write((uint64_t*)&cgen_var_1318, 1 * 8);
-    AEMU_SCOPED_TRACE("vkAcquireXlibDisplayEXT readParams");
     stream->read((Display*)dpy, sizeof(Display));
-    AEMU_SCOPED_TRACE("vkAcquireXlibDisplayEXT returnUnmarshal");
     VkResult vkAcquireXlibDisplayEXT_VkResult_return = (VkResult)0;
     stream->read(&vkAcquireXlibDisplayEXT_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -20601,7 +19638,6 @@ VkResult VkEncoder::vkGetRandROutputDisplayEXT(
     VkDisplayKHR* pDisplay)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetRandROutputDisplayEXT encode");
     mImpl->log("start vkGetRandROutputDisplayEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -20638,12 +19674,10 @@ VkResult VkEncoder::vkGetRandROutputDisplayEXT(
     stream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplay, &cgen_var_1322, 1);
     stream->write((uint64_t*)&cgen_var_1322, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkGetRandROutputDisplayEXT readParams");
     stream->read((Display*)dpy, sizeof(Display));
     uint64_t cgen_var_1323;
     stream->read((uint64_t*)&cgen_var_1323, 8);
     stream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_1323, (VkDisplayKHR*)pDisplay, 1);
-    AEMU_SCOPED_TRACE("vkGetRandROutputDisplayEXT returnUnmarshal");
     VkResult vkGetRandROutputDisplayEXT_VkResult_return = (VkResult)0;
     stream->read(&vkGetRandROutputDisplayEXT_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -20661,7 +19695,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilities2EXT(
     VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2EXT encode");
     mImpl->log("start vkGetPhysicalDeviceSurfaceCapabilities2EXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -20694,13 +19727,11 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilities2EXT(
     stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_1327, 1);
     stream->write((uint64_t*)&cgen_var_1327, 1 * 8);
     marshal_VkSurfaceCapabilities2EXT(stream, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2EXT readParams");
     unmarshal_VkSurfaceCapabilities2EXT(stream, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities));
     if (pSurfaceCapabilities)
     {
         transform_fromhost_VkSurfaceCapabilities2EXT(mImpl->resources(), (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2EXT returnUnmarshal");
     VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return = (VkResult)0;
     stream->read(&vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -20718,7 +19749,6 @@ VkResult VkEncoder::vkDisplayPowerControlEXT(
     const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDisplayPowerControlEXT encode");
     mImpl->log("start vkDisplayPowerControlEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -20762,8 +19792,6 @@ VkResult VkEncoder::vkDisplayPowerControlEXT(
     stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1331, 1);
     stream->write((uint64_t*)&cgen_var_1331, 1 * 8);
     marshal_VkDisplayPowerInfoEXT(stream, (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo));
-    AEMU_SCOPED_TRACE("vkDisplayPowerControlEXT readParams");
-    AEMU_SCOPED_TRACE("vkDisplayPowerControlEXT returnUnmarshal");
     VkResult vkDisplayPowerControlEXT_VkResult_return = (VkResult)0;
     stream->read(&vkDisplayPowerControlEXT_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -20780,7 +19808,6 @@ VkResult VkEncoder::vkRegisterDeviceEventEXT(
     VkFence* pFence)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkRegisterDeviceEventEXT encode");
     mImpl->log("start vkRegisterDeviceEventEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -20850,11 +19877,9 @@ VkResult VkEncoder::vkRegisterDeviceEventEXT(
     stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1337, 1);
     stream->write((uint64_t*)&cgen_var_1337, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkRegisterDeviceEventEXT readParams");
     uint64_t cgen_var_1338;
     stream->read((uint64_t*)&cgen_var_1338, 8);
     stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_1338, (VkFence*)pFence, 1);
-    AEMU_SCOPED_TRACE("vkRegisterDeviceEventEXT returnUnmarshal");
     VkResult vkRegisterDeviceEventEXT_VkResult_return = (VkResult)0;
     stream->read(&vkRegisterDeviceEventEXT_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -20872,7 +19897,6 @@ VkResult VkEncoder::vkRegisterDisplayEventEXT(
     VkFence* pFence)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkRegisterDisplayEventEXT encode");
     mImpl->log("start vkRegisterDisplayEventEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -20950,11 +19974,9 @@ VkResult VkEncoder::vkRegisterDisplayEventEXT(
     stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1346, 1);
     stream->write((uint64_t*)&cgen_var_1346, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkRegisterDisplayEventEXT readParams");
     uint64_t cgen_var_1347;
     stream->read((uint64_t*)&cgen_var_1347, 8);
     stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_1347, (VkFence*)pFence, 1);
-    AEMU_SCOPED_TRACE("vkRegisterDisplayEventEXT returnUnmarshal");
     VkResult vkRegisterDisplayEventEXT_VkResult_return = (VkResult)0;
     stream->read(&vkRegisterDisplayEventEXT_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -20971,7 +19993,6 @@ VkResult VkEncoder::vkGetSwapchainCounterEXT(
     uint64_t* pCounterValue)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetSwapchainCounterEXT encode");
     mImpl->log("start vkGetSwapchainCounterEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -21008,9 +20029,7 @@ VkResult VkEncoder::vkGetSwapchainCounterEXT(
     stream->write((uint64_t*)&cgen_var_1351, 1 * 8);
     stream->write((VkSurfaceCounterFlagBitsEXT*)&local_counter, sizeof(VkSurfaceCounterFlagBitsEXT));
     stream->write((uint64_t*)pCounterValue, sizeof(uint64_t));
-    AEMU_SCOPED_TRACE("vkGetSwapchainCounterEXT readParams");
     stream->read((uint64_t*)pCounterValue, sizeof(uint64_t));
-    AEMU_SCOPED_TRACE("vkGetSwapchainCounterEXT returnUnmarshal");
     VkResult vkGetSwapchainCounterEXT_VkResult_return = (VkResult)0;
     stream->read(&vkGetSwapchainCounterEXT_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -21028,7 +20047,6 @@ VkResult VkEncoder::vkGetRefreshCycleDurationGOOGLE(
     VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetRefreshCycleDurationGOOGLE encode");
     mImpl->log("start vkGetRefreshCycleDurationGOOGLE");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -21061,13 +20079,11 @@ VkResult VkEncoder::vkGetRefreshCycleDurationGOOGLE(
     stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1355, 1);
     stream->write((uint64_t*)&cgen_var_1355, 1 * 8);
     marshal_VkRefreshCycleDurationGOOGLE(stream, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties));
-    AEMU_SCOPED_TRACE("vkGetRefreshCycleDurationGOOGLE readParams");
     unmarshal_VkRefreshCycleDurationGOOGLE(stream, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties));
     if (pDisplayTimingProperties)
     {
         transform_fromhost_VkRefreshCycleDurationGOOGLE(mImpl->resources(), (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetRefreshCycleDurationGOOGLE returnUnmarshal");
     VkResult vkGetRefreshCycleDurationGOOGLE_VkResult_return = (VkResult)0;
     stream->read(&vkGetRefreshCycleDurationGOOGLE_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -21084,7 +20100,6 @@ VkResult VkEncoder::vkGetPastPresentationTimingGOOGLE(
     VkPastPresentationTimingGOOGLE* pPresentationTimings)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPastPresentationTimingGOOGLE encode");
     mImpl->log("start vkGetPastPresentationTimingGOOGLE");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -21149,7 +20164,6 @@ VkResult VkEncoder::vkGetPastPresentationTimingGOOGLE(
             marshal_VkPastPresentationTimingGOOGLE(stream, (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPastPresentationTimingGOOGLE readParams");
     // WARNING PTR CHECK
     uint32_t* check_pPresentationTimingCount;
     check_pPresentationTimingCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -21182,7 +20196,6 @@ VkResult VkEncoder::vkGetPastPresentationTimingGOOGLE(
             transform_fromhost_VkPastPresentationTimingGOOGLE(mImpl->resources(), (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetPastPresentationTimingGOOGLE returnUnmarshal");
     VkResult vkGetPastPresentationTimingGOOGLE_VkResult_return = (VkResult)0;
     stream->read(&vkGetPastPresentationTimingGOOGLE_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -21211,7 +20224,6 @@ void VkEncoder::vkCmdSetDiscardRectangleEXT(
     const VkRect2D* pDiscardRectangles)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdSetDiscardRectangleEXT encode");
     mImpl->log("start vkCmdSetDiscardRectangleEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -21267,8 +20279,6 @@ void VkEncoder::vkCmdSetDiscardRectangleEXT(
     {
         marshal_VkRect2D(stream, (VkRect2D*)(local_pDiscardRectangles + i));
     }
-    AEMU_SCOPED_TRACE("vkCmdSetDiscardRectangleEXT readParams");
-    AEMU_SCOPED_TRACE("vkCmdSetDiscardRectangleEXT returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -21288,7 +20298,6 @@ void VkEncoder::vkSetHdrMetadataEXT(
     const VkHdrMetadataEXT* pMetadata)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkSetHdrMetadataEXT encode");
     mImpl->log("start vkSetHdrMetadataEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -21360,8 +20369,6 @@ void VkEncoder::vkSetHdrMetadataEXT(
     {
         marshal_VkHdrMetadataEXT(stream, (VkHdrMetadataEXT*)(local_pMetadata + i));
     }
-    AEMU_SCOPED_TRACE("vkSetHdrMetadataEXT readParams");
-    AEMU_SCOPED_TRACE("vkSetHdrMetadataEXT returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -21377,7 +20384,6 @@ VkResult VkEncoder::vkCreateIOSSurfaceMVK(
     VkSurfaceKHR* pSurface)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateIOSSurfaceMVK encode");
     mImpl->log("start vkCreateIOSSurfaceMVK");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -21447,11 +20453,9 @@ VkResult VkEncoder::vkCreateIOSSurfaceMVK(
     stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1377, 1);
     stream->write((uint64_t*)&cgen_var_1377, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateIOSSurfaceMVK readParams");
     uint64_t cgen_var_1378;
     stream->read((uint64_t*)&cgen_var_1378, 8);
     stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1378, (VkSurfaceKHR*)pSurface, 1);
-    AEMU_SCOPED_TRACE("vkCreateIOSSurfaceMVK returnUnmarshal");
     VkResult vkCreateIOSSurfaceMVK_VkResult_return = (VkResult)0;
     stream->read(&vkCreateIOSSurfaceMVK_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -21470,7 +20474,6 @@ VkResult VkEncoder::vkCreateMacOSSurfaceMVK(
     VkSurfaceKHR* pSurface)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateMacOSSurfaceMVK encode");
     mImpl->log("start vkCreateMacOSSurfaceMVK");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -21540,11 +20543,9 @@ VkResult VkEncoder::vkCreateMacOSSurfaceMVK(
     stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1384, 1);
     stream->write((uint64_t*)&cgen_var_1384, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateMacOSSurfaceMVK readParams");
     uint64_t cgen_var_1385;
     stream->read((uint64_t*)&cgen_var_1385, 8);
     stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1385, (VkSurfaceKHR*)pSurface, 1);
-    AEMU_SCOPED_TRACE("vkCreateMacOSSurfaceMVK returnUnmarshal");
     VkResult vkCreateMacOSSurfaceMVK_VkResult_return = (VkResult)0;
     stream->read(&vkCreateMacOSSurfaceMVK_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -21565,7 +20566,6 @@ VkResult VkEncoder::vkSetDebugUtilsObjectNameEXT(
     const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectNameEXT encode");
     mImpl->log("start vkSetDebugUtilsObjectNameEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -21601,8 +20601,6 @@ VkResult VkEncoder::vkSetDebugUtilsObjectNameEXT(
     stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1387, 1);
     stream->write((uint64_t*)&cgen_var_1387, 1 * 8);
     marshal_VkDebugUtilsObjectNameInfoEXT(stream, (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo));
-    AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectNameEXT readParams");
-    AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectNameEXT returnUnmarshal");
     VkResult vkSetDebugUtilsObjectNameEXT_VkResult_return = (VkResult)0;
     stream->read(&vkSetDebugUtilsObjectNameEXT_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -21617,7 +20615,6 @@ VkResult VkEncoder::vkSetDebugUtilsObjectTagEXT(
     const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectTagEXT encode");
     mImpl->log("start vkSetDebugUtilsObjectTagEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -21653,8 +20650,6 @@ VkResult VkEncoder::vkSetDebugUtilsObjectTagEXT(
     stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1389, 1);
     stream->write((uint64_t*)&cgen_var_1389, 1 * 8);
     marshal_VkDebugUtilsObjectTagInfoEXT(stream, (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo));
-    AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectTagEXT readParams");
-    AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectTagEXT returnUnmarshal");
     VkResult vkSetDebugUtilsObjectTagEXT_VkResult_return = (VkResult)0;
     stream->read(&vkSetDebugUtilsObjectTagEXT_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -21669,7 +20664,6 @@ void VkEncoder::vkQueueBeginDebugUtilsLabelEXT(
     const VkDebugUtilsLabelEXT* pLabelInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkQueueBeginDebugUtilsLabelEXT encode");
     mImpl->log("start vkQueueBeginDebugUtilsLabelEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -21705,8 +20699,6 @@ void VkEncoder::vkQueueBeginDebugUtilsLabelEXT(
     stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1391, 1);
     stream->write((uint64_t*)&cgen_var_1391, 1 * 8);
     marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
-    AEMU_SCOPED_TRACE("vkQueueBeginDebugUtilsLabelEXT readParams");
-    AEMU_SCOPED_TRACE("vkQueueBeginDebugUtilsLabelEXT returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -21717,7 +20709,6 @@ void VkEncoder::vkQueueEndDebugUtilsLabelEXT(
     VkQueue queue)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkQueueEndDebugUtilsLabelEXT encode");
     mImpl->log("start vkQueueEndDebugUtilsLabelEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -21740,8 +20731,6 @@ void VkEncoder::vkQueueEndDebugUtilsLabelEXT(
     uint64_t cgen_var_1393;
     stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1393, 1);
     stream->write((uint64_t*)&cgen_var_1393, 1 * 8);
-    AEMU_SCOPED_TRACE("vkQueueEndDebugUtilsLabelEXT readParams");
-    AEMU_SCOPED_TRACE("vkQueueEndDebugUtilsLabelEXT returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -21753,7 +20742,6 @@ void VkEncoder::vkQueueInsertDebugUtilsLabelEXT(
     const VkDebugUtilsLabelEXT* pLabelInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkQueueInsertDebugUtilsLabelEXT encode");
     mImpl->log("start vkQueueInsertDebugUtilsLabelEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -21789,8 +20777,6 @@ void VkEncoder::vkQueueInsertDebugUtilsLabelEXT(
     stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1395, 1);
     stream->write((uint64_t*)&cgen_var_1395, 1 * 8);
     marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
-    AEMU_SCOPED_TRACE("vkQueueInsertDebugUtilsLabelEXT readParams");
-    AEMU_SCOPED_TRACE("vkQueueInsertDebugUtilsLabelEXT returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -21802,7 +20788,6 @@ void VkEncoder::vkCmdBeginDebugUtilsLabelEXT(
     const VkDebugUtilsLabelEXT* pLabelInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdBeginDebugUtilsLabelEXT encode");
     mImpl->log("start vkCmdBeginDebugUtilsLabelEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -21838,8 +20823,6 @@ void VkEncoder::vkCmdBeginDebugUtilsLabelEXT(
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1397, 1);
     stream->write((uint64_t*)&cgen_var_1397, 1 * 8);
     marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
-    AEMU_SCOPED_TRACE("vkCmdBeginDebugUtilsLabelEXT readParams");
-    AEMU_SCOPED_TRACE("vkCmdBeginDebugUtilsLabelEXT returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -21850,7 +20833,6 @@ void VkEncoder::vkCmdEndDebugUtilsLabelEXT(
     VkCommandBuffer commandBuffer)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdEndDebugUtilsLabelEXT encode");
     mImpl->log("start vkCmdEndDebugUtilsLabelEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -21873,8 +20855,6 @@ void VkEncoder::vkCmdEndDebugUtilsLabelEXT(
     uint64_t cgen_var_1399;
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1399, 1);
     stream->write((uint64_t*)&cgen_var_1399, 1 * 8);
-    AEMU_SCOPED_TRACE("vkCmdEndDebugUtilsLabelEXT readParams");
-    AEMU_SCOPED_TRACE("vkCmdEndDebugUtilsLabelEXT returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -21886,7 +20866,6 @@ void VkEncoder::vkCmdInsertDebugUtilsLabelEXT(
     const VkDebugUtilsLabelEXT* pLabelInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdInsertDebugUtilsLabelEXT encode");
     mImpl->log("start vkCmdInsertDebugUtilsLabelEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -21922,8 +20901,6 @@ void VkEncoder::vkCmdInsertDebugUtilsLabelEXT(
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1401, 1);
     stream->write((uint64_t*)&cgen_var_1401, 1 * 8);
     marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
-    AEMU_SCOPED_TRACE("vkCmdInsertDebugUtilsLabelEXT readParams");
-    AEMU_SCOPED_TRACE("vkCmdInsertDebugUtilsLabelEXT returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -21937,7 +20914,6 @@ VkResult VkEncoder::vkCreateDebugUtilsMessengerEXT(
     VkDebugUtilsMessengerEXT* pMessenger)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateDebugUtilsMessengerEXT encode");
     mImpl->log("start vkCreateDebugUtilsMessengerEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -22007,13 +20983,11 @@ VkResult VkEncoder::vkCreateDebugUtilsMessengerEXT(
     stream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(pMessenger, &cgen_var_1407, 1);
     stream->write((uint64_t*)&cgen_var_1407, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateDebugUtilsMessengerEXT readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_1408;
     stream->read((uint64_t*)&cgen_var_1408, 8);
     stream->handleMapping()->mapHandles_u64_VkDebugUtilsMessengerEXT(&cgen_var_1408, (VkDebugUtilsMessengerEXT*)pMessenger, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateDebugUtilsMessengerEXT returnUnmarshal");
     VkResult vkCreateDebugUtilsMessengerEXT_VkResult_return = (VkResult)0;
     stream->read(&vkCreateDebugUtilsMessengerEXT_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -22029,7 +21003,6 @@ void VkEncoder::vkDestroyDebugUtilsMessengerEXT(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyDebugUtilsMessengerEXT encode");
     mImpl->log("start vkDestroyDebugUtilsMessengerEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -22086,8 +21059,6 @@ void VkEncoder::vkDestroyDebugUtilsMessengerEXT(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyDebugUtilsMessengerEXT readParams");
-    AEMU_SCOPED_TRACE("vkDestroyDebugUtilsMessengerEXT returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkDebugUtilsMessengerEXT((VkDebugUtilsMessengerEXT*)&messenger);
     pool->freeAll();
     countingStream->clearPool();
@@ -22102,7 +21073,6 @@ void VkEncoder::vkSubmitDebugUtilsMessageEXT(
     const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkSubmitDebugUtilsMessageEXT encode");
     mImpl->log("start vkSubmitDebugUtilsMessageEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -22146,8 +21116,6 @@ void VkEncoder::vkSubmitDebugUtilsMessageEXT(
     stream->write((VkDebugUtilsMessageSeverityFlagBitsEXT*)&local_messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT));
     stream->write((VkDebugUtilsMessageTypeFlagsEXT*)&local_messageTypes, sizeof(VkDebugUtilsMessageTypeFlagsEXT));
     marshal_VkDebugUtilsMessengerCallbackDataEXT(stream, (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData));
-    AEMU_SCOPED_TRACE("vkSubmitDebugUtilsMessageEXT readParams");
-    AEMU_SCOPED_TRACE("vkSubmitDebugUtilsMessageEXT returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -22162,7 +21130,6 @@ VkResult VkEncoder::vkGetAndroidHardwareBufferPropertiesANDROID(
     VkAndroidHardwareBufferPropertiesANDROID* pProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID encode");
     mImpl->log("start vkGetAndroidHardwareBufferPropertiesANDROID");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -22195,13 +21162,11 @@ VkResult VkEncoder::vkGetAndroidHardwareBufferPropertiesANDROID(
     stream->write((uint64_t*)&cgen_var_1418, 1 * 8);
     stream->write((AHardwareBuffer*)local_buffer, sizeof(AHardwareBuffer));
     marshal_VkAndroidHardwareBufferPropertiesANDROID(stream, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties));
-    AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID readParams");
     unmarshal_VkAndroidHardwareBufferPropertiesANDROID(stream, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties));
     if (pProperties)
     {
         transform_fromhost_VkAndroidHardwareBufferPropertiesANDROID(mImpl->resources(), (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID returnUnmarshal");
     VkResult vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
     stream->read(&vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -22217,7 +21182,6 @@ VkResult VkEncoder::vkGetMemoryAndroidHardwareBufferANDROID(
     AHardwareBuffer** pBuffer)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID encode");
     mImpl->log("start vkGetMemoryAndroidHardwareBufferANDROID");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -22255,9 +21219,7 @@ VkResult VkEncoder::vkGetMemoryAndroidHardwareBufferANDROID(
     stream->write((uint64_t*)&cgen_var_1420, 1 * 8);
     marshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(stream, (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo));
     stream->write((AHardwareBuffer**)pBuffer, sizeof(AHardwareBuffer*));
-    AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID readParams");
     stream->read((AHardwareBuffer**)pBuffer, sizeof(AHardwareBuffer*));
-    AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID returnUnmarshal");
     VkResult vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
     stream->read(&vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -22284,7 +21246,6 @@ void VkEncoder::vkCmdSetSampleLocationsEXT(
     const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdSetSampleLocationsEXT encode");
     mImpl->log("start vkCmdSetSampleLocationsEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -22320,8 +21281,6 @@ void VkEncoder::vkCmdSetSampleLocationsEXT(
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1422, 1);
     stream->write((uint64_t*)&cgen_var_1422, 1 * 8);
     marshal_VkSampleLocationsInfoEXT(stream, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo));
-    AEMU_SCOPED_TRACE("vkCmdSetSampleLocationsEXT readParams");
-    AEMU_SCOPED_TRACE("vkCmdSetSampleLocationsEXT returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -22334,7 +21293,6 @@ void VkEncoder::vkGetPhysicalDeviceMultisamplePropertiesEXT(
     VkMultisamplePropertiesEXT* pMultisampleProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMultisamplePropertiesEXT encode");
     mImpl->log("start vkGetPhysicalDeviceMultisamplePropertiesEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -22363,13 +21321,11 @@ void VkEncoder::vkGetPhysicalDeviceMultisamplePropertiesEXT(
     stream->write((uint64_t*)&cgen_var_1424, 1 * 8);
     stream->write((VkSampleCountFlagBits*)&local_samples, sizeof(VkSampleCountFlagBits));
     marshal_VkMultisamplePropertiesEXT(stream, (VkMultisamplePropertiesEXT*)(pMultisampleProperties));
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMultisamplePropertiesEXT readParams");
     unmarshal_VkMultisamplePropertiesEXT(stream, (VkMultisamplePropertiesEXT*)(pMultisampleProperties));
     if (pMultisampleProperties)
     {
         transform_fromhost_VkMultisamplePropertiesEXT(mImpl->resources(), (VkMultisamplePropertiesEXT*)(pMultisampleProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMultisamplePropertiesEXT returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -22395,7 +21351,6 @@ VkResult VkEncoder::vkCreateValidationCacheEXT(
     VkValidationCacheEXT* pValidationCache)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateValidationCacheEXT encode");
     mImpl->log("start vkCreateValidationCacheEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -22465,13 +21420,11 @@ VkResult VkEncoder::vkCreateValidationCacheEXT(
     stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(pValidationCache, &cgen_var_1430, 1);
     stream->write((uint64_t*)&cgen_var_1430, 8);
     stream->setHandleMapping(resources->unwrapMapping());
-    AEMU_SCOPED_TRACE("vkCreateValidationCacheEXT readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_1431;
     stream->read((uint64_t*)&cgen_var_1431, 8);
     stream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(&cgen_var_1431, (VkValidationCacheEXT*)pValidationCache, 1);
     stream->unsetHandleMapping();
-    AEMU_SCOPED_TRACE("vkCreateValidationCacheEXT returnUnmarshal");
     VkResult vkCreateValidationCacheEXT_VkResult_return = (VkResult)0;
     stream->read(&vkCreateValidationCacheEXT_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -22487,7 +21440,6 @@ void VkEncoder::vkDestroyValidationCacheEXT(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkDestroyValidationCacheEXT encode");
     mImpl->log("start vkDestroyValidationCacheEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -22544,8 +21496,6 @@ void VkEncoder::vkDestroyValidationCacheEXT(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkDestroyValidationCacheEXT readParams");
-    AEMU_SCOPED_TRACE("vkDestroyValidationCacheEXT returnUnmarshal");
     resources->destroyMapping()->mapHandles_VkValidationCacheEXT((VkValidationCacheEXT*)&validationCache);
     pool->freeAll();
     countingStream->clearPool();
@@ -22560,7 +21510,6 @@ VkResult VkEncoder::vkMergeValidationCachesEXT(
     const VkValidationCacheEXT* pSrcCaches)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkMergeValidationCachesEXT encode");
     mImpl->log("start vkMergeValidationCachesEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -22615,8 +21564,6 @@ VkResult VkEncoder::vkMergeValidationCachesEXT(
         stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(local_pSrcCaches, cgen_var_1443, ((srcCacheCount)));
         stream->write((uint64_t*)cgen_var_1443, ((srcCacheCount)) * 8);
     }
-    AEMU_SCOPED_TRACE("vkMergeValidationCachesEXT readParams");
-    AEMU_SCOPED_TRACE("vkMergeValidationCachesEXT returnUnmarshal");
     VkResult vkMergeValidationCachesEXT_VkResult_return = (VkResult)0;
     stream->read(&vkMergeValidationCachesEXT_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -22633,7 +21580,6 @@ VkResult VkEncoder::vkGetValidationCacheDataEXT(
     void* pData)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetValidationCacheDataEXT encode");
     mImpl->log("start vkGetValidationCacheDataEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -22694,7 +21640,6 @@ VkResult VkEncoder::vkGetValidationCacheDataEXT(
     {
         stream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
     }
-    AEMU_SCOPED_TRACE("vkGetValidationCacheDataEXT readParams");
     // WARNING PTR CHECK
     size_t* check_pDataSize;
     check_pDataSize = (size_t*)(uintptr_t)stream->getBe64();
@@ -22717,7 +21662,6 @@ VkResult VkEncoder::vkGetValidationCacheDataEXT(
         }
         stream->read((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
     }
-    AEMU_SCOPED_TRACE("vkGetValidationCacheDataEXT returnUnmarshal");
     VkResult vkGetValidationCacheDataEXT_VkResult_return = (VkResult)0;
     stream->read(&vkGetValidationCacheDataEXT_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -22742,7 +21686,6 @@ VkResult VkEncoder::vkGetMemoryHostPointerPropertiesEXT(
     VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetMemoryHostPointerPropertiesEXT encode");
     mImpl->log("start vkGetMemoryHostPointerPropertiesEXT");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -22791,13 +21734,11 @@ VkResult VkEncoder::vkGetMemoryHostPointerPropertiesEXT(
         stream->write((void*)local_pHostPointer, sizeof(uint8_t));
     }
     marshal_VkMemoryHostPointerPropertiesEXT(stream, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties));
-    AEMU_SCOPED_TRACE("vkGetMemoryHostPointerPropertiesEXT readParams");
     unmarshal_VkMemoryHostPointerPropertiesEXT(stream, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties));
     if (pMemoryHostPointerProperties)
     {
         transform_fromhost_VkMemoryHostPointerPropertiesEXT(mImpl->resources(), (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties));
     }
-    AEMU_SCOPED_TRACE("vkGetMemoryHostPointerPropertiesEXT returnUnmarshal");
     VkResult vkGetMemoryHostPointerPropertiesEXT_VkResult_return = (VkResult)0;
     stream->read(&vkGetMemoryHostPointerPropertiesEXT_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -22817,7 +21758,6 @@ void VkEncoder::vkCmdWriteBufferMarkerAMD(
     uint32_t marker)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdWriteBufferMarkerAMD encode");
     mImpl->log("start vkCmdWriteBufferMarkerAMD");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -22860,8 +21800,6 @@ void VkEncoder::vkCmdWriteBufferMarkerAMD(
     stream->write((uint64_t*)&cgen_var_1464, 1 * 8);
     stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
     stream->write((uint32_t*)&local_marker, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCmdWriteBufferMarkerAMD readParams");
-    AEMU_SCOPED_TRACE("vkCmdWriteBufferMarkerAMD returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -22881,7 +21819,6 @@ void VkEncoder::vkCmdSetCheckpointNV(
     const void* pCheckpointMarker)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCmdSetCheckpointNV encode");
     mImpl->log("start vkCmdSetCheckpointNV");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -22924,8 +21861,6 @@ void VkEncoder::vkCmdSetCheckpointNV(
     {
         stream->write((void*)local_pCheckpointMarker, sizeof(uint8_t));
     }
-    AEMU_SCOPED_TRACE("vkCmdSetCheckpointNV readParams");
-    AEMU_SCOPED_TRACE("vkCmdSetCheckpointNV returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -22938,7 +21873,6 @@ void VkEncoder::vkGetQueueCheckpointDataNV(
     VkCheckpointDataNV* pCheckpointData)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetQueueCheckpointDataNV encode");
     mImpl->log("start vkGetQueueCheckpointDataNV");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -22995,7 +21929,6 @@ void VkEncoder::vkGetQueueCheckpointDataNV(
             marshal_VkCheckpointDataNV(stream, (VkCheckpointDataNV*)(pCheckpointData + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetQueueCheckpointDataNV readParams");
     // WARNING PTR CHECK
     uint32_t* check_pCheckpointDataCount;
     check_pCheckpointDataCount = (uint32_t*)(uintptr_t)stream->getBe64();
@@ -23028,7 +21961,6 @@ void VkEncoder::vkGetQueueCheckpointDataNV(
             transform_fromhost_VkCheckpointDataNV(mImpl->resources(), (VkCheckpointDataNV*)(pCheckpointData + i));
         }
     }
-    AEMU_SCOPED_TRACE("vkGetQueueCheckpointDataNV returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -23043,7 +21975,6 @@ VkResult VkEncoder::vkMapMemoryIntoAddressSpaceGOOGLE(
     uint64_t* pAddress)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE encode");
     mImpl->log("start vkMapMemoryIntoAddressSpaceGOOGLE");
     mImpl->resources()->on_vkMapMemoryIntoAddressSpaceGOOGLE_pre(this, VK_SUCCESS, device, memory, pAddress);
     auto stream = mImpl->stream();
@@ -23090,7 +22021,6 @@ VkResult VkEncoder::vkMapMemoryIntoAddressSpaceGOOGLE(
     {
         stream->write((uint64_t*)pAddress, sizeof(uint64_t));
     }
-    AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE readParams");
     // WARNING PTR CHECK
     uint64_t* check_pAddress;
     check_pAddress = (uint64_t*)(uintptr_t)stream->getBe64();
@@ -23102,7 +22032,6 @@ VkResult VkEncoder::vkMapMemoryIntoAddressSpaceGOOGLE(
         }
         stream->read((uint64_t*)pAddress, sizeof(uint64_t));
     }
-    AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE returnUnmarshal");
     VkResult vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = (VkResult)0;
     stream->read(&vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return, sizeof(VkResult));
     mImpl->resources()->on_vkMapMemoryIntoAddressSpaceGOOGLE(this, vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return, device, memory, pAddress);
@@ -23121,7 +22050,6 @@ VkResult VkEncoder::vkRegisterImageColorBufferGOOGLE(
     uint32_t colorBuffer)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkRegisterImageColorBufferGOOGLE encode");
     mImpl->log("start vkRegisterImageColorBufferGOOGLE");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -23156,8 +22084,6 @@ VkResult VkEncoder::vkRegisterImageColorBufferGOOGLE(
     stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1487, 1);
     stream->write((uint64_t*)&cgen_var_1487, 1 * 8);
     stream->write((uint32_t*)&local_colorBuffer, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkRegisterImageColorBufferGOOGLE readParams");
-    AEMU_SCOPED_TRACE("vkRegisterImageColorBufferGOOGLE returnUnmarshal");
     VkResult vkRegisterImageColorBufferGOOGLE_VkResult_return = (VkResult)0;
     stream->read(&vkRegisterImageColorBufferGOOGLE_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -23173,7 +22099,6 @@ VkResult VkEncoder::vkRegisterBufferColorBufferGOOGLE(
     uint32_t colorBuffer)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkRegisterBufferColorBufferGOOGLE encode");
     mImpl->log("start vkRegisterBufferColorBufferGOOGLE");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -23208,8 +22133,6 @@ VkResult VkEncoder::vkRegisterBufferColorBufferGOOGLE(
     stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1491, 1);
     stream->write((uint64_t*)&cgen_var_1491, 1 * 8);
     stream->write((uint32_t*)&local_colorBuffer, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkRegisterBufferColorBufferGOOGLE readParams");
-    AEMU_SCOPED_TRACE("vkRegisterBufferColorBufferGOOGLE returnUnmarshal");
     VkResult vkRegisterBufferColorBufferGOOGLE_VkResult_return = (VkResult)0;
     stream->read(&vkRegisterBufferColorBufferGOOGLE_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -23236,7 +22159,6 @@ void VkEncoder::vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
     const VkBufferView* pBufferViews)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE encode");
     mImpl->log("start vkUpdateDescriptorSetWithTemplateSizedGOOGLE");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -23453,8 +22375,6 @@ void VkEncoder::vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
             stream->write((uint64_t*)cgen_var_1511, ((bufferViewCount)) * 8);
         }
     }
-    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE readParams");
-    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -23468,7 +22388,6 @@ void VkEncoder::vkBeginCommandBufferAsyncGOOGLE(
     const VkCommandBufferBeginInfo* pBeginInfo)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE encode");
     mImpl->log("start vkBeginCommandBufferAsyncGOOGLE");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -23504,8 +22423,6 @@ void VkEncoder::vkBeginCommandBufferAsyncGOOGLE(
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1513, 1);
     stream->write((uint64_t*)&cgen_var_1513, 1 * 8);
     marshal_VkCommandBufferBeginInfo(stream, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
-    AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE readParams");
-    AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -23516,7 +22433,6 @@ void VkEncoder::vkEndCommandBufferAsyncGOOGLE(
     VkCommandBuffer commandBuffer)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE encode");
     mImpl->log("start vkEndCommandBufferAsyncGOOGLE");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -23539,8 +22455,6 @@ void VkEncoder::vkEndCommandBufferAsyncGOOGLE(
     uint64_t cgen_var_1515;
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1515, 1);
     stream->write((uint64_t*)&cgen_var_1515, 1 * 8);
-    AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE readParams");
-    AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE returnUnmarshal");
     stream->flush();
     pool->freeAll();
     countingStream->clearPool();
@@ -23553,7 +22467,6 @@ void VkEncoder::vkResetCommandBufferAsyncGOOGLE(
     VkCommandBufferResetFlags flags)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE encode");
     mImpl->log("start vkResetCommandBufferAsyncGOOGLE");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -23580,8 +22493,6 @@ void VkEncoder::vkResetCommandBufferAsyncGOOGLE(
     stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1517, 1);
     stream->write((uint64_t*)&cgen_var_1517, 1 * 8);
     stream->write((VkCommandBufferResetFlags*)&local_flags, sizeof(VkCommandBufferResetFlags));
-    AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE readParams");
-    AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -23594,7 +22505,6 @@ void VkEncoder::vkCommandBufferHostSyncGOOGLE(
     uint32_t sequenceNumber)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCommandBufferHostSyncGOOGLE encode");
     mImpl->log("start vkCommandBufferHostSyncGOOGLE");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -23625,8 +22535,6 @@ void VkEncoder::vkCommandBufferHostSyncGOOGLE(
     stream->write((uint64_t*)&cgen_var_1519, 1 * 8);
     stream->write((uint32_t*)&local_needHostSync, sizeof(uint32_t));
     stream->write((uint32_t*)&local_sequenceNumber, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkCommandBufferHostSyncGOOGLE readParams");
-    AEMU_SCOPED_TRACE("vkCommandBufferHostSyncGOOGLE returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -23643,7 +22551,6 @@ VkResult VkEncoder::vkCreateImageWithRequirementsGOOGLE(
     VkMemoryRequirements* pMemoryRequirements)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE encode");
     mImpl->log("start vkCreateImageWithRequirementsGOOGLE");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -23716,7 +22623,6 @@ VkResult VkEncoder::vkCreateImageWithRequirementsGOOGLE(
     stream->write((uint64_t*)&cgen_var_1525, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     marshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
-    AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_1526;
     stream->read((uint64_t*)&cgen_var_1526, 8);
@@ -23727,7 +22633,6 @@ VkResult VkEncoder::vkCreateImageWithRequirementsGOOGLE(
     {
         transform_fromhost_VkMemoryRequirements(mImpl->resources(), (VkMemoryRequirements*)(pMemoryRequirements));
     }
-    AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE returnUnmarshal");
     VkResult vkCreateImageWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
     stream->read(&vkCreateImageWithRequirementsGOOGLE_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -23745,7 +22650,6 @@ VkResult VkEncoder::vkCreateBufferWithRequirementsGOOGLE(
     VkMemoryRequirements* pMemoryRequirements)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE encode");
     mImpl->log("start vkCreateBufferWithRequirementsGOOGLE");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -23817,7 +22721,6 @@ VkResult VkEncoder::vkCreateBufferWithRequirementsGOOGLE(
     stream->write((uint64_t*)&cgen_var_1532, 8);
     stream->setHandleMapping(resources->unwrapMapping());
     marshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
-    AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE readParams");
     stream->setHandleMapping(resources->createMapping());
     uint64_t cgen_var_1533;
     stream->read((uint64_t*)&cgen_var_1533, 8);
@@ -23828,7 +22731,6 @@ VkResult VkEncoder::vkCreateBufferWithRequirementsGOOGLE(
     {
         transform_fromhost_VkMemoryRequirements(mImpl->resources(), (VkMemoryRequirements*)(pMemoryRequirements));
     }
-    AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE returnUnmarshal");
     VkResult vkCreateBufferWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
     stream->read(&vkCreateBufferWithRequirementsGOOGLE_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -23848,7 +22750,6 @@ VkResult VkEncoder::vkGetMemoryHostAddressInfoGOOGLE(
     uint64_t* pHostmemId)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetMemoryHostAddressInfoGOOGLE encode");
     mImpl->log("start vkGetMemoryHostAddressInfoGOOGLE");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -23922,7 +22823,6 @@ VkResult VkEncoder::vkGetMemoryHostAddressInfoGOOGLE(
     {
         stream->write((uint64_t*)pHostmemId, sizeof(uint64_t));
     }
-    AEMU_SCOPED_TRACE("vkGetMemoryHostAddressInfoGOOGLE readParams");
     // WARNING PTR CHECK
     uint64_t* check_pAddress;
     check_pAddress = (uint64_t*)(uintptr_t)stream->getBe64();
@@ -23956,7 +22856,6 @@ VkResult VkEncoder::vkGetMemoryHostAddressInfoGOOGLE(
         }
         stream->read((uint64_t*)pHostmemId, sizeof(uint64_t));
     }
-    AEMU_SCOPED_TRACE("vkGetMemoryHostAddressInfoGOOGLE returnUnmarshal");
     VkResult vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = (VkResult)0;
     stream->read(&vkGetMemoryHostAddressInfoGOOGLE_VkResult_return, sizeof(VkResult));
     pool->freeAll();
@@ -23974,7 +22873,6 @@ VkResult VkEncoder::vkFreeMemorySyncGOOGLE(
     const VkAllocationCallbacks* pAllocator)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkFreeMemorySyncGOOGLE encode");
     mImpl->log("start vkFreeMemorySyncGOOGLE");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -24028,8 +22926,6 @@ VkResult VkEncoder::vkFreeMemorySyncGOOGLE(
     {
         marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
     }
-    AEMU_SCOPED_TRACE("vkFreeMemorySyncGOOGLE readParams");
-    AEMU_SCOPED_TRACE("vkFreeMemorySyncGOOGLE returnUnmarshal");
     VkResult vkFreeMemorySyncGOOGLE_VkResult_return = (VkResult)0;
     stream->read(&vkFreeMemorySyncGOOGLE_VkResult_return, sizeof(VkResult));
     resources->destroyMapping()->mapHandles_VkDeviceMemory((VkDeviceMemory*)&memory);
@@ -24048,7 +22944,6 @@ void VkEncoder::vkQueueHostSyncGOOGLE(
     uint32_t sequenceNumber)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkQueueHostSyncGOOGLE encode");
     mImpl->log("start vkQueueHostSyncGOOGLE");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -24079,8 +22974,6 @@ void VkEncoder::vkQueueHostSyncGOOGLE(
     stream->write((uint64_t*)&cgen_var_1554, 1 * 8);
     stream->write((uint32_t*)&local_needHostSync, sizeof(uint32_t));
     stream->write((uint32_t*)&local_sequenceNumber, sizeof(uint32_t));
-    AEMU_SCOPED_TRACE("vkQueueHostSyncGOOGLE readParams");
-    AEMU_SCOPED_TRACE("vkQueueHostSyncGOOGLE returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -24094,7 +22987,6 @@ void VkEncoder::vkQueueSubmitAsyncGOOGLE(
     VkFence fence)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkQueueSubmitAsyncGOOGLE encode");
     mImpl->log("start vkQueueSubmitAsyncGOOGLE");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -24154,8 +23046,6 @@ void VkEncoder::vkQueueSubmitAsyncGOOGLE(
     uint64_t cgen_var_1558;
     stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1558, 1);
     stream->write((uint64_t*)&cgen_var_1558, 1 * 8);
-    AEMU_SCOPED_TRACE("vkQueueSubmitAsyncGOOGLE readParams");
-    AEMU_SCOPED_TRACE("vkQueueSubmitAsyncGOOGLE returnUnmarshal");
     stream->flush();
     pool->freeAll();
     countingStream->clearPool();
@@ -24167,7 +23057,6 @@ void VkEncoder::vkQueueWaitIdleAsyncGOOGLE(
     VkQueue queue)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkQueueWaitIdleAsyncGOOGLE encode");
     mImpl->log("start vkQueueWaitIdleAsyncGOOGLE");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -24190,8 +23079,6 @@ void VkEncoder::vkQueueWaitIdleAsyncGOOGLE(
     uint64_t cgen_var_1560;
     stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1560, 1);
     stream->write((uint64_t*)&cgen_var_1560, 1 * 8);
-    AEMU_SCOPED_TRACE("vkQueueWaitIdleAsyncGOOGLE readParams");
-    AEMU_SCOPED_TRACE("vkQueueWaitIdleAsyncGOOGLE returnUnmarshal");
     stream->flush();
     pool->freeAll();
     countingStream->clearPool();
@@ -24206,7 +23093,6 @@ void VkEncoder::vkQueueBindSparseAsyncGOOGLE(
     VkFence fence)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkQueueBindSparseAsyncGOOGLE encode");
     mImpl->log("start vkQueueBindSparseAsyncGOOGLE");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -24266,8 +23152,6 @@ void VkEncoder::vkQueueBindSparseAsyncGOOGLE(
     uint64_t cgen_var_1564;
     stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1564, 1);
     stream->write((uint64_t*)&cgen_var_1564, 1 * 8);
-    AEMU_SCOPED_TRACE("vkQueueBindSparseAsyncGOOGLE readParams");
-    AEMU_SCOPED_TRACE("vkQueueBindSparseAsyncGOOGLE returnUnmarshal");
     stream->flush();
     pool->freeAll();
     countingStream->clearPool();
@@ -24284,7 +23168,6 @@ void VkEncoder::vkGetLinearImageLayoutGOOGLE(
     VkDeviceSize* pRowPitchAlignment)
 {
     EncoderAutoLock encoderLock(this);
-    AEMU_SCOPED_TRACE("vkGetLinearImageLayoutGOOGLE encode");
     mImpl->log("start vkGetLinearImageLayoutGOOGLE");
     auto stream = mImpl->stream();
     auto countingStream = mImpl->countingStream();
@@ -24315,10 +23198,8 @@ void VkEncoder::vkGetLinearImageLayoutGOOGLE(
     stream->write((VkFormat*)&local_format, sizeof(VkFormat));
     stream->write((VkDeviceSize*)pOffset, sizeof(VkDeviceSize));
     stream->write((VkDeviceSize*)pRowPitchAlignment, sizeof(VkDeviceSize));
-    AEMU_SCOPED_TRACE("vkGetLinearImageLayoutGOOGLE readParams");
     stream->read((VkDeviceSize*)pOffset, sizeof(VkDeviceSize));
     stream->read((VkDeviceSize*)pRowPitchAlignment, sizeof(VkDeviceSize));
-    AEMU_SCOPED_TRACE("vkGetLinearImageLayoutGOOGLE returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
diff --git a/system/vulkan_enc/VkEncoder.cpp.inl b/system/vulkan_enc/VkEncoder.cpp.inl
new file mode 100644
index 00000000..5e1c5f39
--- /dev/null
+++ b/system/vulkan_enc/VkEncoder.cpp.inl
@@ -0,0 +1,124 @@
+
+class VkEncoder::Impl {
+public:
+    Impl(IOStream* stream) : m_stream(stream), m_logEncodes(false) {
+        m_stream.incStreamRef();
+        const char* emuVkLogEncodesPropName = "qemu.vk.log";
+        char encodeProp[PROPERTY_VALUE_MAX];
+        if (property_get(emuVkLogEncodesPropName, encodeProp, nullptr) > 0) {
+            m_logEncodes = atoi(encodeProp) > 0;
+        }
+    }
+
+    ~Impl() {
+        m_stream.decStreamRef();
+    }
+
+    VulkanCountingStream* countingStream() { return &m_countingStream; }
+    VulkanStreamGuest* stream() { return &m_stream; }
+    Pool* pool() { return &m_pool; }
+    ResourceTracker* resources() { return ResourceTracker::get(); }
+    Validation* validation() { return &m_validation; }
+
+    void log(const char* text) {
+        if (!m_logEncodes) return;
+        ALOGD("encoder log: %s", text);
+    }
+
+    void flush() {
+        lock();
+        m_stream.flush();
+        unlock();
+    }
+
+    // can be recursive
+    void lock() {
+        if (this == sAcquiredEncoderThreadLocal) {
+            ++sAcquiredEncoderThreadLockLevels;
+            return; // recursive
+        }
+        while (mLock.test_and_set(std::memory_order_acquire));
+        sAcquiredEncoderThreadLocal = this;
+        sAcquiredEncoderThreadLockLevels = 1;
+    }
+
+    void unlock() {
+        if (this != sAcquiredEncoderThreadLocal) {
+            // error, trying to unlock without having locked first
+            return;
+        }
+
+        --sAcquiredEncoderThreadLockLevels;
+        if (0 == sAcquiredEncoderThreadLockLevels) {
+            mLock.clear(std::memory_order_release);
+            sAcquiredEncoderThreadLocal = nullptr;
+        }
+    }
+
+    void incRef() {
+        __atomic_add_fetch(&m_refCount, 1, __ATOMIC_SEQ_CST);
+    }
+
+    bool decRef() {
+        if (0 == __atomic_sub_fetch(&m_refCount, 1, __ATOMIC_SEQ_CST)) {
+            return true;
+        }
+        return false;
+    }
+
+private:
+    VulkanCountingStream m_countingStream;
+    VulkanStreamGuest m_stream;
+    Pool m_pool { 8, 4096, 64 };
+
+    Validation m_validation;
+    bool m_logEncodes;
+    std::atomic_flag mLock = ATOMIC_FLAG_INIT;
+    static thread_local Impl* sAcquiredEncoderThreadLocal;
+    static thread_local uint32_t sAcquiredEncoderThreadLockLevels;
+    uint32_t m_refCount = 1;
+};
+
+VkEncoder::~VkEncoder() { }
+
+// static
+thread_local VkEncoder::Impl* VkEncoder::Impl::sAcquiredEncoderThreadLocal = nullptr;
+thread_local uint32_t VkEncoder::Impl::sAcquiredEncoderThreadLockLevels = 0;
+
+struct EncoderAutoLock {
+    EncoderAutoLock(VkEncoder* enc) : mEnc(enc) {
+        mEnc->lock();
+    }
+    ~EncoderAutoLock() {
+        mEnc->unlock();
+    }
+    VkEncoder* mEnc;
+};
+
+VkEncoder::VkEncoder(IOStream *stream) :
+    mImpl(new VkEncoder::Impl(stream)) { }
+
+void VkEncoder::flush() {
+    mImpl->flush();
+}
+
+void VkEncoder::lock() {
+    mImpl->lock();
+}
+
+void VkEncoder::unlock() {
+    mImpl->unlock();
+}
+
+void VkEncoder::incRef() {
+    mImpl->incRef();
+}
+
+bool VkEncoder::decRef() {
+    if (mImpl->decRef()) {
+        delete this;
+        return true;
+    }
+    return false;
+}
+
diff --git a/system/vulkan_enc/VkEncoder.h b/system/vulkan_enc/VkEncoder.h
index 572efee6..d2638238 100644
--- a/system/vulkan_enc/VkEncoder.h
+++ b/system/vulkan_enc/VkEncoder.h
@@ -40,9 +40,7 @@ public:
     VkEncoder(IOStream* stream);
     ~VkEncoder();
 
-    void flush();
-    void lock();
-    void unlock();
+#include "VkEncoder.h.inl"
 #ifdef VK_VERSION_1_0
     VkResult vkCreateInstance(
     const VkInstanceCreateInfo* pCreateInfo,
@@ -1846,9 +1844,6 @@ public:
         VkDeviceSize* pRowPitchAlignment);
 #endif
 
-    void incRef();
-    bool decRef();
-
 private:
     class Impl;
     std::unique_ptr<Impl> mImpl;
diff --git a/system/vulkan_enc/VkEncoder.h.inl b/system/vulkan_enc/VkEncoder.h.inl
new file mode 100644
index 00000000..d4155966
--- /dev/null
+++ b/system/vulkan_enc/VkEncoder.h.inl
@@ -0,0 +1,5 @@
+    void flush();
+    void lock();
+    void unlock();
+    void incRef();
+    bool decRef();