Snap for 6870254 from ab89e17faf95f6180907067b5f79023972ef48c0 to emu-30-releaseemu-30-release

Change-Id: I755de106ceca6e6a18674114aedda5db49f7fc42

34 files changed, 790 insertions, 1279 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/OpenglSystemCommon/address_space_graphics_types.h b/system/OpenglSystemCommon/address_space_graphics_types.h
index 5f0e9b67..753644bf 100644
--- a/system/OpenglSystemCommon/address_space_graphics_types.h
+++ b/system/OpenglSystemCommon/address_space_graphics_types.h
@@ -124,7 +124,7 @@ struct asg_context { // ptrs into RingStorage
 // Helper function that will be common between guest and host:
 // Given ring storage and a write buffer, returns asg_context that
 // is the correct view into it.
-static struct asg_context asg_context_create(
+static inline struct asg_context asg_context_create(
     char* ring_storage,
     char* buffer,
     uint32_t buffer_size) {
diff --git a/system/renderControl_enc/renderControl_client_context.cpp b/system/renderControl_enc/renderControl_client_context.cpp
index ded019b8..5b1f14ee 100644
--- a/system/renderControl_enc/renderControl_client_context.cpp
+++ b/system/renderControl_enc/renderControl_client_context.cpp
@@ -64,6 +64,7 @@ int renderControl_client_context_t::initDispatchByName(void *(*getProc)(const ch
 	rcSetColorBufferVulkanMode2 = (rcSetColorBufferVulkanMode2_client_proc_t) getProc("rcSetColorBufferVulkanMode2", userData);
 	rcMapGpaToBufferHandle = (rcMapGpaToBufferHandle_client_proc_t) getProc("rcMapGpaToBufferHandle", userData);
 	rcCreateBuffer2 = (rcCreateBuffer2_client_proc_t) getProc("rcCreateBuffer2", userData);
+	rcMapGpaToBufferHandle2 = (rcMapGpaToBufferHandle2_client_proc_t) getProc("rcMapGpaToBufferHandle2", userData);
 	return 0;
 }
 
diff --git a/system/renderControl_enc/renderControl_client_context.h b/system/renderControl_enc/renderControl_client_context.h
index 54749dfd..2032a324 100644
--- a/system/renderControl_enc/renderControl_client_context.h
+++ b/system/renderControl_enc/renderControl_client_context.h
@@ -64,6 +64,7 @@ struct renderControl_client_context_t {
 	rcSetColorBufferVulkanMode2_client_proc_t rcSetColorBufferVulkanMode2;
 	rcMapGpaToBufferHandle_client_proc_t rcMapGpaToBufferHandle;
 	rcCreateBuffer2_client_proc_t rcCreateBuffer2;
+	rcMapGpaToBufferHandle2_client_proc_t rcMapGpaToBufferHandle2;
 	virtual ~renderControl_client_context_t() {}
 
 	typedef renderControl_client_context_t *CONTEXT_ACCESSOR_TYPE(void);
diff --git a/system/renderControl_enc/renderControl_client_proc.h b/system/renderControl_enc/renderControl_client_proc.h
index 9f8f39c9..c0b9a7fd 100644
--- a/system/renderControl_enc/renderControl_client_proc.h
+++ b/system/renderControl_enc/renderControl_client_proc.h
@@ -66,6 +66,7 @@ typedef void (renderControl_APIENTRY *rcCloseBuffer_client_proc_t) (void * ctx,
 typedef GLint (renderControl_APIENTRY *rcSetColorBufferVulkanMode2_client_proc_t) (void * ctx, uint32_t, uint32_t, uint32_t);
 typedef int (renderControl_APIENTRY *rcMapGpaToBufferHandle_client_proc_t) (void * ctx, uint32_t, uint64_t);
 typedef uint32_t (renderControl_APIENTRY *rcCreateBuffer2_client_proc_t) (void * ctx, uint64_t, uint32_t);
+typedef int (renderControl_APIENTRY *rcMapGpaToBufferHandle2_client_proc_t) (void * ctx, uint32_t, uint64_t, uint64_t);
 
 
 #endif
diff --git a/system/renderControl_enc/renderControl_enc.cpp b/system/renderControl_enc/renderControl_enc.cpp
index f9994c47..6b2680c2 100644
--- a/system/renderControl_enc/renderControl_enc.cpp
+++ b/system/renderControl_enc/renderControl_enc.cpp
@@ -2145,6 +2145,49 @@ uint32_t rcCreateBuffer2_enc(void *self , uint64_t size, uint32_t memoryProperty
 	return retval;
 }
 
+int rcMapGpaToBufferHandle2_enc(void *self , uint32_t bufferHandle, uint64_t gpa, uint64_t size)
+{
+	AEMU_SCOPED_TRACE("rcMapGpaToBufferHandle2 encode");
+
+	renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
+	IOStream *stream = ctx->m_stream;
+	ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+	bool useChecksum = checksumCalculator->getVersion() > 0;
+
+	 unsigned char *ptr;
+	 unsigned char *buf;
+	 const size_t sizeWithoutChecksum = 8 + 4 + 8 + 8;
+	 const size_t checksumSize = checksumCalculator->checksumByteSize();
+	 const size_t totalSize = sizeWithoutChecksum + checksumSize;
+	buf = stream->alloc(totalSize);
+	ptr = buf;
+	int tmp = OP_rcMapGpaToBufferHandle2;memcpy(ptr, &tmp, 4); ptr += 4;
+	memcpy(ptr, &totalSize, 4);  ptr += 4;
+
+		memcpy(ptr, &bufferHandle, 4); ptr += 4;
+		memcpy(ptr, &gpa, 8); ptr += 8;
+		memcpy(ptr, &size, 8); ptr += 8;
+
+	if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+	if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+	int retval;
+	stream->readback(&retval, 4);
+	if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+	if (useChecksum) {
+		unsigned char *checksumBufPtr = NULL;
+		unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
+		if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
+		stream->readback(checksumBufPtr, checksumSize);
+		if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
+			ALOGE("rcMapGpaToBufferHandle2: GL communication error, please report this issue to b.android.com.\n");
+			abort();
+		}
+	}
+	return retval;
+}
+
 }  // namespace
 
 renderControl_encoder_context_t::renderControl_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator)
@@ -2206,5 +2249,6 @@ renderControl_encoder_context_t::renderControl_encoder_context_t(IOStream *strea
 	this->rcSetColorBufferVulkanMode2 = &rcSetColorBufferVulkanMode2_enc;
 	this->rcMapGpaToBufferHandle = &rcMapGpaToBufferHandle_enc;
 	this->rcCreateBuffer2 = &rcCreateBuffer2_enc;
+	this->rcMapGpaToBufferHandle2 = &rcMapGpaToBufferHandle2_enc;
 }
 
diff --git a/system/renderControl_enc/renderControl_entry.cpp b/system/renderControl_enc/renderControl_entry.cpp
index 2f30f4c6..0ea37d61 100644
--- a/system/renderControl_enc/renderControl_entry.cpp
+++ b/system/renderControl_enc/renderControl_entry.cpp
@@ -59,6 +59,7 @@ extern "C" {
 	GLint rcSetColorBufferVulkanMode2(uint32_t colorBuffer, uint32_t mode, uint32_t memoryProperty);
 	int rcMapGpaToBufferHandle(uint32_t bufferHandle, uint64_t gpa);
 	uint32_t rcCreateBuffer2(uint64_t size, uint32_t memoryProperty);
+	int rcMapGpaToBufferHandle2(uint32_t bufferHandle, uint64_t gpa, uint64_t size);
 };
 
 #ifndef GET_CONTEXT
@@ -391,3 +392,9 @@ uint32_t rcCreateBuffer2(uint64_t size, uint32_t memoryProperty)
 	return ctx->rcCreateBuffer2(ctx, size, memoryProperty);
 }
 
+int rcMapGpaToBufferHandle2(uint32_t bufferHandle, uint64_t gpa, uint64_t size)
+{
+	GET_CONTEXT;
+	return ctx->rcMapGpaToBufferHandle2(ctx, bufferHandle, gpa, size);
+}
+
diff --git a/system/renderControl_enc/renderControl_ftable.h b/system/renderControl_enc/renderControl_ftable.h
index 3cec1d36..247a0bd1 100644
--- a/system/renderControl_enc/renderControl_ftable.h
+++ b/system/renderControl_enc/renderControl_ftable.h
@@ -62,6 +62,7 @@ static const struct _renderControl_funcs_by_name {
 	{"rcSetColorBufferVulkanMode2", (void*)rcSetColorBufferVulkanMode2},
 	{"rcMapGpaToBufferHandle", (void*)rcMapGpaToBufferHandle},
 	{"rcCreateBuffer2", (void*)rcCreateBuffer2},
+	{"rcMapGpaToBufferHandle2", (void*)rcMapGpaToBufferHandle2},
 };
 static const int renderControl_num_funcs = sizeof(renderControl_funcs_by_name) / sizeof(struct _renderControl_funcs_by_name);
 
diff --git a/system/renderControl_enc/renderControl_opcodes.h b/system/renderControl_enc/renderControl_opcodes.h
index a59306d0..16c02141 100644
--- a/system/renderControl_enc/renderControl_opcodes.h
+++ b/system/renderControl_enc/renderControl_opcodes.h
@@ -57,7 +57,8 @@
 #define OP_rcSetColorBufferVulkanMode2 					10051
 #define OP_rcMapGpaToBufferHandle 					10052
 #define OP_rcCreateBuffer2 					10053
-#define OP_last 					10054
+#define OP_rcMapGpaToBufferHandle2 					10054
+#define OP_last 					10055
 
 
 #endif
diff --git a/system/vulkan/func_table.cpp b/system/vulkan/func_table.cpp
index 51913e8e..6a4a1289 100644
--- a/system/vulkan/func_table.cpp
+++ b/system/vulkan/func_table.cpp
@@ -5338,6 +5338,33 @@ static void entry_vkQueueBindSparseAsyncGOOGLE(
     vkEnc->vkQueueBindSparseAsyncGOOGLE(queue, bindInfoCount, pBindInfo, fence);
 }
 #endif
+#ifdef VK_GOOGLE_linear_image_layout
+static void entry_vkGetLinearImageLayoutGOOGLE(
+    VkDevice device,
+    VkFormat format,
+    VkDeviceSize* pOffset,
+    VkDeviceSize* pRowPitchAlignment)
+{
+    AEMU_SCOPED_TRACE("vkGetLinearImageLayoutGOOGLE");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetLinearImageLayoutGOOGLE(device, format, pOffset, pRowPitchAlignment);
+}
+static void dynCheck_entry_vkGetLinearImageLayoutGOOGLE(
+    VkDevice device,
+    VkFormat format,
+    VkDeviceSize* pOffset,
+    VkDeviceSize* pRowPitchAlignment)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_linear_image_layout"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkGetLinearImageLayoutGOOGLE", "VK_GOOGLE_linear_image_layout");
+    }
+    AEMU_SCOPED_TRACE("vkGetLinearImageLayoutGOOGLE");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetLinearImageLayoutGOOGLE(device, format, pOffset, pRowPitchAlignment);
+}
+#endif
 void* goldfish_vulkan_get_proc_address(const char* name){
 #ifdef VK_VERSION_1_0
     if (!strcmp(name, "vkCreateInstance"))
@@ -6813,6 +6840,12 @@ void* goldfish_vulkan_get_proc_address(const char* name){
         return nullptr;
     }
 #endif
+#ifdef VK_GOOGLE_linear_image_layout
+    if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE"))
+    {
+        return nullptr;
+    }
+#endif
     return nullptr;
 }
 void* goldfish_vulkan_get_instance_proc_address(VkInstance instance, const char* name){
@@ -8389,6 +8422,12 @@ void* goldfish_vulkan_get_instance_proc_address(VkInstance instance, const char*
         return hasExt ? (void*)entry_vkQueueBindSparseAsyncGOOGLE : nullptr;
     }
 #endif
+#ifdef VK_GOOGLE_linear_image_layout
+    if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE"))
+    {
+        return (void*)dynCheck_entry_vkGetLinearImageLayoutGOOGLE;
+    }
+#endif
     return nullptr;
 }
 void* goldfish_vulkan_get_device_proc_address(VkDevice device, const char* name){
@@ -10036,6 +10075,13 @@ void* goldfish_vulkan_get_device_proc_address(VkDevice device, const char* name)
         return hasExt ? (void*)entry_vkQueueBindSparseAsyncGOOGLE : nullptr;
     }
 #endif
+#ifdef VK_GOOGLE_linear_image_layout
+    if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE"))
+    {
+        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_linear_image_layout");
+        return hasExt ? (void*)entry_vkGetLinearImageLayoutGOOGLE : nullptr;
+    }
+#endif
     return nullptr;
 }
 
diff --git a/system/vulkan/func_table.h b/system/vulkan/func_table.h
index 9c2e5beb..a3a7f990 100644
--- a/system/vulkan/func_table.h
+++ b/system/vulkan/func_table.h
@@ -294,6 +294,8 @@ namespace goldfish_vk {
 #endif
 #ifdef VK_GOOGLE_async_queue_submit
 #endif
+#ifdef VK_GOOGLE_linear_image_layout
+#endif
 void* goldfish_vulkan_get_proc_address(const char* name);
 void* goldfish_vulkan_get_instance_proc_address(VkInstance instance, const char* name);
 void* goldfish_vulkan_get_device_proc_address(VkDevice device, const char* name);
diff --git a/system/vulkan_enc/ResourceTracker.cpp b/system/vulkan_enc/ResourceTracker.cpp
index ecf5b1f9..b00a5627 100644
--- a/system/vulkan_enc/ResourceTracker.cpp
+++ b/system/vulkan_enc/ResourceTracker.cpp
@@ -52,6 +52,7 @@ void zx_event_create(int, zx_handle_t*) { }
 #include <lib/zx/vmo.h>
 #include <zircon/errors.h>
 #include <zircon/process.h>
+#include <zircon/rights.h>
 #include <zircon/syscalls.h>
 #include <zircon/syscalls/object.h>
 
@@ -275,12 +276,12 @@ public:
     };
 
     struct VkCommandBuffer_Info {
-        VkEncoder** lastUsedEncoderPtr = nullptr;
+        VkEncoder* lastUsedEncoder = nullptr;
         uint32_t sequenceNumber = 0;
     };
 
     struct VkQueue_Info {
-        VkEncoder** lastUsedEncoderPtr = nullptr;
+        VkEncoder* lastUsedEncoder = nullptr;
         uint32_t sequenceNumber = 0;
     };
 
@@ -398,15 +399,10 @@ public:
         auto it = info_VkCommandBuffer.find(commandBuffer);
         if (it == info_VkCommandBuffer.end()) return;
         auto& info = it->second;
-        auto lastUsedEncoder =
-            info.lastUsedEncoderPtr ?
-            *(info.lastUsedEncoderPtr) : nullptr;
-
-        if (lastUsedEncoder) {
-            lastUsedEncoder->decRef();
-            info.lastUsedEncoderPtr = nullptr;
+        if (info.lastUsedEncoder) {
+            info.lastUsedEncoder->decRef();
         }
-
+        info.lastUsedEncoder = nullptr;
         info_VkCommandBuffer.erase(commandBuffer);
     }
 
@@ -416,15 +412,11 @@ public:
         auto it = info_VkQueue.find(queue);
         if (it == info_VkQueue.end()) return;
         auto& info = it->second;
-        auto lastUsedEncoder =
-            info.lastUsedEncoderPtr ?
-            *(info.lastUsedEncoderPtr) : nullptr;
-
-        if (lastUsedEncoder) {
-            lastUsedEncoder->decRef();
-            info.lastUsedEncoderPtr = nullptr;
+        auto lastUsedEncoder = info.lastUsedEncoder;
+        if (info.lastUsedEncoder) {
+            info.lastUsedEncoder->decRef();
         }
-
+        info.lastUsedEncoder = nullptr;
         info_VkQueue.erase(queue);
     }
 
@@ -1740,9 +1732,9 @@ public:
         delete sysmem_collection;
     }
 
-    inline llcpp::fuchsia::sysmem::BufferCollectionConstraints
-    defaultBufferCollectionConstraints(size_t min_size_bytes,
-                                       size_t buffer_count) {
+    inline llcpp::fuchsia::sysmem::BufferCollectionConstraints defaultBufferCollectionConstraints(
+        size_t min_size_bytes,
+        size_t buffer_count) {
         llcpp::fuchsia::sysmem::BufferCollectionConstraints constraints = {};
         constraints.min_buffer_count = buffer_count;
         constraints.has_buffer_memory_constraints = true;
@@ -1753,12 +1745,16 @@ public:
         buffer_constraints.max_size_bytes = 0xffffffff;
         buffer_constraints.physically_contiguous_required = false;
         buffer_constraints.secure_required = false;
-        buffer_constraints.ram_domain_supported = false;
-        buffer_constraints.cpu_domain_supported = false;
+
+        // No restrictions on coherency domain or Heaps.
+        buffer_constraints.ram_domain_supported = true;
+        buffer_constraints.cpu_domain_supported = true;
         buffer_constraints.inaccessible_domain_supported = true;
-        buffer_constraints.heap_permitted_count = 1;
+        buffer_constraints.heap_permitted_count = 2;
         buffer_constraints.heap_permitted[0] =
             llcpp::fuchsia::sysmem::HeapType::GOLDFISH_DEVICE_LOCAL;
+        buffer_constraints.heap_permitted[1] =
+            llcpp::fuchsia::sysmem::HeapType::GOLDFISH_HOST_VISIBLE;
 
         return constraints;
     }
@@ -1808,6 +1804,7 @@ public:
     }
 
     VkResult setBufferCollectionConstraints(
+        VkEncoder* enc, VkDevice device,
         llcpp::fuchsia::sysmem::BufferCollection::SyncClient* collection,
         const VkImageCreateInfo* pImageInfo) {
         if (pImageInfo == nullptr) {
@@ -1815,13 +1812,9 @@ public:
             return VK_ERROR_OUT_OF_DEVICE_MEMORY;
         }
 
-        // TODO(liyl): Currently the size only works for RGBA8 and BGRA8 images.
-        // We should set the size based on its actual format.
         llcpp::fuchsia::sysmem::BufferCollectionConstraints constraints =
             defaultBufferCollectionConstraints(
-                /* min_size_bytes */ pImageInfo->extent.width *
-                    pImageInfo->extent.height * 4,
-                /* buffer_count */ 1u);
+                /* min_size_bytes */ 0, /* buffer_count */ 1u);
 
         constraints.usage.vulkan =
             getBufferCollectionConstraintsVulkanImageUsage(pImageInfo);
@@ -1837,10 +1830,44 @@ 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;
             for (VkFormat format : formats) {
+                // Get row alignment from host GPU.
+                VkDeviceSize offset;
+                VkDeviceSize rowPitchAlignment;
+                enc->vkGetLinearImageLayoutGOOGLE(device, format, &offset, &rowPitchAlignment);
+
+                ALOGD("vkGetLinearImageLayoutGOOGLE: format %d offset %lu rowPitchAlignment = %lu",
+                    (int)format, offset, rowPitchAlignment);
+
                 llcpp::fuchsia::sysmem::ImageFormatConstraints&
                     image_constraints =
                         constraints.image_format_constraints[format_index++];
@@ -1873,15 +1900,16 @@ public:
                 image_constraints.max_coded_width = 0xfffffff;
                 image_constraints.min_coded_height = pImageInfo->extent.height;
                 image_constraints.max_coded_height = 0xffffffff;
-                image_constraints.min_bytes_per_row =
-                        pImageInfo->extent.width * 4;
+                // The min_bytes_per_row can be calculated by sysmem using
+                // |min_coded_width|, |bytes_per_row_divisor| and color format.
+                image_constraints.min_bytes_per_row = 0;
                 image_constraints.max_bytes_per_row = 0xffffffff;
                 image_constraints.max_coded_width_times_coded_height =
                         0xffffffff;
                 image_constraints.layers = 1;
                 image_constraints.coded_width_divisor = 1;
                 image_constraints.coded_height_divisor = 1;
-                image_constraints.bytes_per_row_divisor = 1;
+                image_constraints.bytes_per_row_divisor = rowPitchAlignment;
                 image_constraints.start_offset_divisor = 1;
                 image_constraints.display_width_divisor = 1;
                 image_constraints.display_height_divisor = 1;
@@ -1909,8 +1937,7 @@ public:
 
         llcpp::fuchsia::sysmem::BufferCollectionConstraints constraints =
             defaultBufferCollectionConstraints(
-                /* min_size_bytes */ pBufferConstraintsInfo->pBufferCreateInfo
-                    ->size,
+                /* min_size_bytes */ pBufferConstraintsInfo->pBufferCreateInfo->size,
                 /* buffer_count */ pBufferConstraintsInfo->minCount);
         constraints.usage.vulkan =
             getBufferCollectionConstraintsVulkanBufferUsage(
@@ -1926,12 +1953,13 @@ public:
     }
 
     VkResult on_vkSetBufferCollectionConstraintsFUCHSIA(
-        void*, VkResult, VkDevice,
+        void* context, VkResult, VkDevice device,
         VkBufferCollectionFUCHSIA collection,
         const VkImageCreateInfo* pImageInfo) {
+        VkEncoder* enc = (VkEncoder*)context;
         auto sysmem_collection = reinterpret_cast<
             llcpp::fuchsia::sysmem::BufferCollection::SyncClient*>(collection);
-        return setBufferCollectionConstraints(sysmem_collection, pImageInfo);
+        return setBufferCollectionConstraints(enc, device, sysmem_collection, pImageInfo);
     }
 
     VkResult on_vkSetBufferCollectionBufferConstraintsFUCHSIA(
@@ -1963,9 +1991,16 @@ public:
         llcpp::fuchsia::sysmem::BufferCollectionInfo_2 info =
             std::move(result.Unwrap()->buffer_collection_info);
 
-        if (!info.settings.has_image_format_constraints) {
+        bool is_host_visible = info.settings.buffer_settings.heap ==
+                               llcpp::fuchsia::sysmem::HeapType::GOLDFISH_HOST_VISIBLE;
+        bool is_device_local = info.settings.buffer_settings.heap ==
+                               llcpp::fuchsia::sysmem::HeapType::GOLDFISH_DEVICE_LOCAL;
+        if (!is_host_visible && !is_device_local) {
+            ALOGE("buffer collection uses a non-goldfish heap (type 0x%lu)",
+                static_cast<uint64_t>(info.settings.buffer_settings.heap));
             return VK_ERROR_INITIALIZATION_FAILED;
         }
+
         pProperties->count = info.buffer_count;
 
         AutoLock lock(mLock);
@@ -1981,8 +2016,10 @@ public:
         // Device local memory type supported.
         pProperties->memoryTypeBits = 0;
         for (uint32_t i = 0; i < deviceInfo.memProps.memoryTypeCount; ++i) {
-            if (deviceInfo.memProps.memoryTypes[i].propertyFlags &
-                VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) {
+            if ((is_device_local && (deviceInfo.memProps.memoryTypes[i].propertyFlags &
+                                     VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)) ||
+                (is_host_visible && (deviceInfo.memProps.memoryTypes[i].propertyFlags &
+                                     VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT))) {
                 pProperties->memoryTypeBits |= 1ull << i;
             }
         }
@@ -2469,7 +2506,7 @@ public:
                     std::move(collection_client));
                 if (hasDedicatedImage) {
                     VkResult res = setBufferCollectionConstraints(
-                        &collection, pImageCreateInfo);
+                        enc, device, &collection, pImageCreateInfo);
                     if (res == VK_ERROR_FORMAT_NOT_SUPPORTED) {
                       ALOGE("setBufferCollectionConstraints failed: format %u is not supported",
                             pImageCreateInfo->format);
@@ -2654,12 +2691,44 @@ public:
             abort();
         }
 
+#ifdef VK_USE_PLATFORM_FUCHSIA
         if (vmo_handle != ZX_HANDLE_INVALID) {
-            ALOGE("%s: Host visible export/import allocation "
-                  "of VMO is not supported yet.",
-                  __func__);
-            abort();
+            input_result = enc->vkAllocateMemory(device, &finalAllocInfo, pAllocator, pMemory);
+
+            // Get VMO handle rights, and only use allowed rights to map the
+            // host memory.
+            zx_info_handle_basic handle_info;
+            zx_status_t status = zx_object_get_info(vmo_handle, ZX_INFO_HANDLE_BASIC, &handle_info,
+                                        sizeof(handle_info), nullptr, nullptr);
+            if (status != ZX_OK) {
+                ALOGE("%s: cannot get vmo object info: vmo = %u status: %d.", __func__, vmo_handle,
+                      status);
+                return VK_ERROR_OUT_OF_HOST_MEMORY;
+            }
+
+            zx_vm_option_t vm_permission = 0u;
+            vm_permission |= (handle_info.rights & ZX_RIGHT_READ) ? ZX_VM_PERM_READ : 0;
+            vm_permission |= (handle_info.rights & ZX_RIGHT_WRITE) ? ZX_VM_PERM_WRITE : 0;
+
+            zx_paddr_t addr;
+            status = zx_vmar_map(zx_vmar_root_self(), vm_permission, 0, vmo_handle, 0,
+                finalAllocInfo.allocationSize, &addr);
+            if (status != ZX_OK) {
+                ALOGE("%s: cannot map vmar: status %d.", __func__, status);
+                return VK_ERROR_OUT_OF_HOST_MEMORY;
+            }
+
+            D("host visible alloc (external): "
+              "size 0x%llx host ptr %p mapped size 0x%llx",
+              (unsigned long long)finalAllocInfo.allocationSize, mappedPtr,
+              (unsigned long long)mappedSize);
+            setDeviceMemoryInfo(device, *pMemory,
+                finalAllocInfo.allocationSize, finalAllocInfo.allocationSize,
+                reinterpret_cast<uint8_t*>(addr), finalAllocInfo.memoryTypeIndex,
+                /*ahw=*/nullptr, vmo_handle);
+            return VK_SUCCESS;
         }
+#endif
 
         // Host visible memory, non external
         bool directMappingSupported = usingDirectMapping();
@@ -2755,6 +2824,17 @@ public:
         if (it == info_VkDeviceMemory.end()) return;
         auto& info = it->second;
 
+#ifdef VK_USE_PLATFORM_FUCHSIA
+        if (info.vmoHandle && info.mappedPtr) {
+            zx_status_t status = zx_vmar_unmap(
+                zx_vmar_root_self(), reinterpret_cast<zx_paddr_t>(info.mappedPtr), info.mappedSize);
+            if (status != ZX_OK) {
+                ALOGE("%s: Cannot unmap mappedPtr: status %d", status);
+            }
+            info.mappedPtr = nullptr;
+        }
+#endif
+
         if (!info.directMapped) {
             lock.unlock();
             VkEncoder* enc = (VkEncoder*)context;
@@ -3021,36 +3101,62 @@ public:
             }
 
             if (vmo.is_valid()) {
-              auto format = info.settings.image_format_constraints.pixel_format.type ==
-                                    llcpp::fuchsia::sysmem::PixelFormatType::R8G8B8A8
-                                ? llcpp::fuchsia::hardware::goldfish::ColorBufferFormatType::RGBA
-                                : llcpp::fuchsia::hardware::goldfish::ColorBufferFormatType::BGRA;
-
-              auto createParams =
-                  llcpp::fuchsia::hardware::goldfish::CreateColorBuffer2Params::Builder(
-                      std::make_unique<
-                          llcpp::fuchsia::hardware::goldfish::CreateColorBuffer2Params::Frame>())
-                      .set_width(std::make_unique<uint32_t>(
-                          info.settings.image_format_constraints.min_coded_width))
-                      .set_height(std::make_unique<uint32_t>(
-                          info.settings.image_format_constraints.min_coded_height))
-                      .set_format(
-                          std::make_unique<
-                              llcpp::fuchsia::hardware::goldfish::ColorBufferFormatType>(format))
-                      .set_memory_property(std::make_unique<uint32_t>(
-                          llcpp::fuchsia::hardware::goldfish::MEMORY_PROPERTY_DEVICE_LOCAL))
-                      .build();
-
-              auto result =
-                  mControlDevice->CreateColorBuffer2(std::move(vmo), std::move(createParams));
-              if (!result.ok() || result.Unwrap()->res != ZX_OK) {
-                  if (result.ok() &&
-                      result.Unwrap()->res == ZX_ERR_ALREADY_EXISTS) {
-                      ALOGD("CreateColorBuffer: color buffer already exists");
-                  } else {
-                      ALOGE("CreateColorBuffer failed: %d:%d", result.status(),
-                            GET_STATUS_SAFE(result, res));
-                  }
+                zx::vmo vmo_dup;
+                if (zx_status_t status = vmo.duplicate(ZX_RIGHT_SAME_RIGHTS, &vmo_dup);
+                    status != ZX_OK) {
+                    ALOGE("%s: zx_vmo_duplicate failed: %d", __func__, status);
+                    abort();
+                }
+
+                auto buffer_handle_result = mControlDevice->GetBufferHandle(std::move(vmo_dup));
+                if (!buffer_handle_result.ok()) {
+                    ALOGE("%s: GetBufferHandle FIDL error: %d", __func__,
+                          buffer_handle_result.status());
+                    abort();
+                }
+                if (buffer_handle_result.value().res == ZX_OK) {
+                    // Buffer handle already exists.
+                    // If it is a ColorBuffer, no-op; Otherwise return error.
+                    if (buffer_handle_result.value().type !=
+                        llcpp::fuchsia::hardware::goldfish::BufferHandleType::COLOR_BUFFER) {
+                        ALOGE("%s: BufferHandle %u is not a ColorBuffer", __func__,
+                              buffer_handle_result.value().id);
+                        return VK_ERROR_OUT_OF_HOST_MEMORY;
+                    }
+                } else if (buffer_handle_result.value().res == ZX_ERR_NOT_FOUND) {
+                    // Buffer handle not found. Create ColorBuffer based on buffer settings.
+                    auto format =
+                        info.settings.image_format_constraints.pixel_format.type ==
+                                llcpp::fuchsia::sysmem::PixelFormatType::R8G8B8A8
+                            ? llcpp::fuchsia::hardware::goldfish::ColorBufferFormatType::RGBA
+                            : llcpp::fuchsia::hardware::goldfish::ColorBufferFormatType::BGRA;
+
+                    uint32_t memory_property =
+                        info.settings.buffer_settings.heap ==
+                                llcpp::fuchsia::sysmem::HeapType::GOLDFISH_DEVICE_LOCAL
+                            ? llcpp::fuchsia::hardware::goldfish::MEMORY_PROPERTY_DEVICE_LOCAL
+                            : llcpp::fuchsia::hardware::goldfish::MEMORY_PROPERTY_HOST_VISIBLE;
+
+                    auto createParams =
+                        llcpp::fuchsia::hardware::goldfish::CreateColorBuffer2Params::Builder(
+                            std::make_unique<llcpp::fuchsia::hardware::goldfish::
+                                                 CreateColorBuffer2Params::Frame>())
+                            .set_width(std::make_unique<uint32_t>(
+                                info.settings.image_format_constraints.min_coded_width))
+                            .set_height(std::make_unique<uint32_t>(
+                                info.settings.image_format_constraints.min_coded_height))
+                            .set_format(std::make_unique<
+                                        llcpp::fuchsia::hardware::goldfish::ColorBufferFormatType>(
+                                format))
+                            .set_memory_property(std::make_unique<uint32_t>(memory_property))
+                            .build();
+
+                    auto result =
+                        mControlDevice->CreateColorBuffer2(std::move(vmo), std::move(createParams));
+                    if (!result.ok() || result.Unwrap()->res != ZX_OK) {
+                        ALOGE("CreateColorBuffer failed: %d:%d", result.status(),
+                              GET_STATUS_SAFE(result, res));
+                    }
                 }
             }
             isSysmemBackedMemory = true;
@@ -4828,42 +4934,39 @@ public:
 
         auto& info = it->second;
 
-        if (!info.lastUsedEncoderPtr) {
-            info.lastUsedEncoderPtr = new VkEncoder*;
-            *(info.lastUsedEncoderPtr) = currentEncoder;
-            currentEncoder->incRef();
-        }
-
-        auto lastUsedEncoderPtr = info.lastUsedEncoderPtr;
-
-        auto lastEncoder = *(lastUsedEncoderPtr);
-
-        // We always make lastUsedEncoderPtr track
-        // the current encoder, even if the last encoder
-        // is null. And also, increment the current encoder,
-        // and decrement refcount for the last one.
-        // (Decrement only after we are done)
-        *(lastUsedEncoderPtr) = currentEncoder;
-        if (lastEncoder != currentEncoder) {
-            currentEncoder->incRef();
-        }
+        currentEncoder->incRef();
 
+        auto lastEncoder = info.lastUsedEncoder;
+        info.lastUsedEncoder = currentEncoder;
         if (!lastEncoder) return 0;
-        if (lastEncoder == currentEncoder) return 0;
-
         auto oldSeq = info.sequenceNumber;
+        bool lookupAgain = false;
 
-        lock.unlock();
+        if (lastEncoder != currentEncoder) {
+            info.sequenceNumber += 2;
+            lookupAgain = true;
+            lock.unlock();
 
-        lastEncoder->vkCommandBufferHostSyncGOOGLE(commandBuffer, false, oldSeq + 1);
-        lastEncoder->flush();
+            lastEncoder->vkCommandBufferHostSyncGOOGLE(commandBuffer, false, oldSeq + 1);
+            lastEncoder->flush();
 
-        currentEncoder->vkCommandBufferHostSyncGOOGLE(commandBuffer, true, oldSeq + 2);
+            currentEncoder->vkCommandBufferHostSyncGOOGLE(commandBuffer, true, oldSeq + 2);
 
-        lock.lock();
-        if (lastEncoder->decRef()) { *lastUsedEncoderPtr = nullptr; }
+            lock.lock();
+        }
+
+        if (lastEncoder->decRef()) {
+            if (lookupAgain) {
+                auto it2 = info_VkCommandBuffer.find(commandBuffer);
+                if (it2 == info_VkCommandBuffer.end()) return 0;
+                auto& info2 = it2->second;
+                info2.lastUsedEncoder = nullptr;
+            } else {
+                info.lastUsedEncoder = nullptr;
+            }
+        }
 
-        return 1;
+        return 0;
     }
 
     uint32_t syncEncodersForQueue(VkQueue queue, VkEncoder* currentEncoder) {
@@ -4878,44 +4981,38 @@ public:
 
         auto& info = it->second;
 
-        if (!info.lastUsedEncoderPtr) {
-            info.lastUsedEncoderPtr = new VkEncoder*;
-            *(info.lastUsedEncoderPtr) = currentEncoder;
-            currentEncoder->incRef();
-        }
-
-        auto lastUsedEncoderPtr = info.lastUsedEncoderPtr;
-
-        auto lastEncoder = *(lastUsedEncoderPtr);
-
-        // We always make lastUsedEncoderPtr track
-        // the current encoder, even if the last encoder
-        // is null.
-        *(lastUsedEncoderPtr) = currentEncoder;
-
-        if (lastEncoder != currentEncoder) {
-            currentEncoder->incRef();
-        }
+        currentEncoder->incRef();
 
+        auto lastEncoder = info.lastUsedEncoder;
+        info.lastUsedEncoder = currentEncoder;
         if (!lastEncoder) return 0;
-        if (lastEncoder == currentEncoder) return 0;
-
         auto oldSeq = info.sequenceNumber;
+        bool lookupAgain = false;
 
-        info.sequenceNumber += 2;
-
-        lock.unlock();
+        if (lastEncoder != currentEncoder) {
+            info.sequenceNumber += 2;
+            lookupAgain = true;
+            lock.unlock();
 
-        // at this point the seqno for the old thread is determined
+            lastEncoder->vkQueueHostSyncGOOGLE(queue, false, oldSeq + 1);
+            lastEncoder->flush();
+            currentEncoder->vkQueueHostSyncGOOGLE(queue, true, oldSeq + 2);
 
-        lastEncoder->vkQueueHostSyncGOOGLE(queue, false, oldSeq + 1);
-        lastEncoder->flush();
-        currentEncoder->vkQueueHostSyncGOOGLE(queue, true, oldSeq + 2);
+            lock.lock();
+        }
 
-        lock.lock();
-        if (lastEncoder->decRef()) { *lastUsedEncoderPtr = nullptr; }
+        if (lastEncoder->decRef()) {
+            if (lookupAgain) {
+                auto it2 = info_VkQueue.find(queue);
+                if (it2 == info_VkQueue.end()) return 0;
+                auto& info2 = it2->second;
+                info2.lastUsedEncoder = nullptr;
+            } else {
+                info.lastUsedEncoder = nullptr;
+            }
+        }
 
-        return 1;
+        return 0;
     }
 
     VkResult on_vkBeginCommandBuffer(
diff --git a/system/vulkan_enc/VkEncoder.cpp b/system/vulkan_enc/VkEncoder.cpp
index 0d5e4801..8f16a528 100644
--- a/system/vulkan_enc/VkEncoder.cpp
+++ b/system/vulkan_enc/VkEncoder.cpp
@@ -59,127 +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) {
-        const char* emuVkLogEncodesPropName = "qemu.vk.log";
-        char encodeProp[PROPERTY_VALUE_MAX];
-        if (property_get(emuVkLogEncodesPropName, encodeProp, nullptr) > 0) {
-            m_logEncodes = atoi(encodeProp) > 0;
-        }
-    }
-
-    ~Impl() { }
-
-    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);
-        m_stream.incStreamRef();
-    }
-
-    bool decRef() {
-        m_stream.decStreamRef();
-        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; \
@@ -196,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();
@@ -258,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);
@@ -280,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();
@@ -329,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();
@@ -344,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();
@@ -409,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();
@@ -440,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();
@@ -455,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();
@@ -480,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();
@@ -499,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();
@@ -528,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();
@@ -551,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();
@@ -596,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();
@@ -617,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();
@@ -642,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();
@@ -662,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();
@@ -719,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();
@@ -752,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();
@@ -764,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();
@@ -789,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();
@@ -808,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();
@@ -839,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();
@@ -855,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();
@@ -886,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();
@@ -904,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();
@@ -974,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);
@@ -996,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();
@@ -1046,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();
@@ -1062,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();
@@ -1145,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();
@@ -1178,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();
@@ -1195,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();
@@ -1286,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();
@@ -1319,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();
@@ -1334,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();
@@ -1383,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();
@@ -1416,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();
@@ -1432,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();
@@ -1489,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();
@@ -1522,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();
@@ -1539,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();
@@ -1578,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();
@@ -1598,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();
@@ -1658,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();
@@ -1673,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();
@@ -1696,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();
@@ -1711,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();
@@ -1734,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();
@@ -1752,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();
@@ -1822,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();
@@ -1844,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();
@@ -1898,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();
@@ -1915,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");;
@@ -1926,7 +1736,6 @@ void VkEncoder::vkUnmapMemory(
     VkDevice device,
     VkDeviceMemory memory)
 {
-    AEMU_SCOPED_TRACE("vkUnmapMemory resourceEvent");
     mImpl->resources()->on_vkUnmapMemory(this, device, memory);
 }
 
@@ -1936,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();
@@ -2027,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();
@@ -2044,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();
@@ -2097,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())
@@ -2133,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();
@@ -2167,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();
@@ -2183,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();
@@ -2227,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();
@@ -2245,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();
@@ -2289,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();
@@ -2306,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();
@@ -2339,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();
@@ -2358,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();
@@ -2391,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();
@@ -2411,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();
@@ -2476,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();
@@ -2509,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();
@@ -2527,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();
@@ -2604,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();
@@ -2637,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();
@@ -2651,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();
@@ -2711,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();
@@ -2729,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();
@@ -2799,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();
@@ -2821,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();
@@ -2878,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();
@@ -2893,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();
@@ -2940,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();
@@ -2956,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();
@@ -2987,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();
@@ -3006,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();
@@ -3061,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();
@@ -3079,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();
@@ -3149,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();
@@ -3171,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();
@@ -3228,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();
@@ -3244,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();
@@ -3314,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();
@@ -3336,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();
@@ -3393,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();
@@ -3407,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();
@@ -3438,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();
@@ -3454,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();
@@ -3485,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();
@@ -3501,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();
@@ -3532,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();
@@ -3550,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();
@@ -3620,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();
@@ -3642,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();
@@ -3699,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();
@@ -3719,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();
@@ -3774,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();
@@ -3793,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();
@@ -3863,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();
@@ -3885,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();
@@ -3942,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();
@@ -3958,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();
@@ -4028,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();
@@ -4050,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();
@@ -4107,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();
@@ -4123,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();
@@ -4194,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();
@@ -4216,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();
@@ -4273,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();
@@ -4289,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();
@@ -4335,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();
@@ -4355,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();
@@ -4425,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();
@@ -4447,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();
@@ -4504,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();
@@ -4520,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();
@@ -4590,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();
@@ -4612,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();
@@ -4669,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();
@@ -4685,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();
@@ -4755,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();
@@ -4777,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();
@@ -4834,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();
@@ -4850,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();
@@ -4911,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();
@@ -4934,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();
@@ -4951,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();
@@ -5006,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();
@@ -5026,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();
@@ -5128,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)))
     {
@@ -5138,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();
@@ -5157,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();
@@ -5259,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)))
     {
@@ -5269,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();
@@ -5285,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();
@@ -5342,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();
@@ -5358,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();
@@ -5428,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();
@@ -5450,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();
@@ -5507,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();
@@ -5523,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();
@@ -5593,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();
@@ -5615,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();
@@ -5672,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();
@@ -5688,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();
@@ -5758,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();
@@ -5780,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();
@@ -5837,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();
@@ -5853,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();
@@ -5923,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();
@@ -5945,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();
@@ -6002,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();
@@ -6017,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();
@@ -6052,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();
@@ -6069,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();
@@ -6121,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)
     {
@@ -6131,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();
@@ -6148,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();
@@ -6215,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)
@@ -6238,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();
@@ -6319,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();
@@ -6334,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();
@@ -6404,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();
@@ -6426,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();
@@ -6483,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();
@@ -6499,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();
@@ -6569,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();
@@ -6591,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();
@@ -6648,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();
@@ -6663,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();
@@ -6696,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();
@@ -6716,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();
@@ -6786,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();
@@ -6808,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();
@@ -6865,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();
@@ -6880,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();
@@ -6915,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();
@@ -6932,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();
@@ -6984,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)
     {
@@ -6994,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();
@@ -7011,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();
@@ -7078,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)));
@@ -7095,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();
@@ -7131,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();
@@ -7146,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();
@@ -7169,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();
@@ -7185,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();
@@ -7212,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();
@@ -7229,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();
@@ -7264,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();
@@ -7279,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();
@@ -7335,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();
@@ -7350,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();
@@ -7406,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();
@@ -7419,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();
@@ -7446,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();
@@ -7461,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();
@@ -7496,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();
@@ -7509,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();
@@ -7536,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();
@@ -7550,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();
@@ -7581,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();
@@ -7595,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();
@@ -7626,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();
@@ -7640,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();
@@ -7671,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();
@@ -7685,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();
@@ -7716,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();
@@ -7735,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();
@@ -7810,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();
@@ -7825,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();
@@ -7864,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();
@@ -7880,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();
@@ -7939,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();
@@ -7955,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();
@@ -7994,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();
@@ -8011,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();
@@ -8054,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();
@@ -8070,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();
@@ -8113,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();
@@ -8129,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();
@@ -8172,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();
@@ -8187,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();
@@ -8222,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();
@@ -8236,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();
@@ -8271,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();
@@ -8287,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();
@@ -8355,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();
@@ -8373,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();
@@ -8449,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();
@@ -8468,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();
@@ -8548,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();
@@ -8565,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();
@@ -8637,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();
@@ -8654,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();
@@ -8726,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();
@@ -8742,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();
@@ -8789,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();
@@ -8805,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();
@@ -8848,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();
@@ -8865,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();
@@ -8942,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();
@@ -8959,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();
@@ -9036,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();
@@ -9052,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();
@@ -9133,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();
@@ -9151,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();
@@ -9227,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();
@@ -9241,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();
@@ -9276,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();
@@ -9290,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();
@@ -9325,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();
@@ -9347,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();
@@ -9489,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();
@@ -9510,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();
@@ -9632,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();
@@ -9647,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();
@@ -9686,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();
@@ -9700,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();
@@ -9735,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();
@@ -9750,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();
@@ -9789,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();
@@ -9804,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();
@@ -9843,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();
@@ -9862,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();
@@ -9921,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();
@@ -9938,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();
@@ -9989,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();
@@ -10003,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();
@@ -10043,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();
@@ -10056,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();
@@ -10083,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();
@@ -10095,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();
@@ -10118,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();
@@ -10132,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();
@@ -10179,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();
@@ -10193,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();
@@ -10210,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();
@@ -10228,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();
@@ -10280,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();
@@ -10297,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();
@@ -10349,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();
@@ -10368,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();
@@ -10405,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();
@@ -10419,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();
@@ -10446,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();
@@ -10464,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();
@@ -10511,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();
@@ -10525,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();
@@ -10582,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();
@@ -10615,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();
@@ -10631,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();
@@ -10669,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();
@@ -10688,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();
@@ -10726,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();
@@ -10746,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();
@@ -10816,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();
@@ -10849,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();
@@ -10861,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();
@@ -10886,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();
@@ -10904,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();
@@ -10929,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();
@@ -10949,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();
@@ -10978,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();
@@ -10997,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();
@@ -11035,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();
@@ -11057,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();
@@ -11114,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();
@@ -11147,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();
@@ -11159,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();
@@ -11184,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();
@@ -11205,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();
@@ -11275,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();
@@ -11308,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();
@@ -11321,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();
@@ -11356,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();
@@ -11370,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();
@@ -11414,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();
@@ -11432,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();
@@ -11502,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();
@@ -11524,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();
@@ -11581,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();
@@ -11597,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();
@@ -11667,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);
@@ -11690,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();
@@ -11747,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();
@@ -11763,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();
@@ -11822,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();
@@ -11836,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();
@@ -11875,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();
@@ -11895,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();
@@ -11933,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();
@@ -11952,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();
@@ -11990,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();
@@ -12009,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();
@@ -12047,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();
@@ -12068,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();
@@ -12125,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();
@@ -12141,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();
@@ -12178,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();
@@ -12196,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();
@@ -12229,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();
@@ -12252,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();
@@ -12317,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();
@@ -12350,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();
@@ -12367,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();
@@ -12426,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();
@@ -12449,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();
@@ -12468,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();
@@ -12538,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();
@@ -12560,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();
@@ -12617,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();
@@ -12633,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();
@@ -12706,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();
@@ -12735,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();
@@ -12754,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();
@@ -12807,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();
@@ -12824,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();
@@ -12860,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();
@@ -12876,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();
@@ -12901,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();
@@ -12923,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();
@@ -12968,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();
@@ -12980,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();
@@ -12997,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();
@@ -13062,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();
@@ -13095,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();
@@ -13111,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();
@@ -13149,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();
@@ -13169,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();
@@ -13226,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();
@@ -13259,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();
@@ -13275,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();
@@ -13332,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();
@@ -13365,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();
@@ -13382,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();
@@ -13451,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();
@@ -13480,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();
@@ -13497,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();
@@ -13562,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();
@@ -13595,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();
@@ -13613,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();
@@ -13691,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();
@@ -13714,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();
@@ -13751,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();
@@ -13774,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();
@@ -13844,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();
@@ -13868,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();
@@ -13962,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;
@@ -13970,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();
@@ -13989,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();
@@ -14059,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();
@@ -14080,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();
@@ -14113,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();
@@ -14134,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();
@@ -14204,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();
@@ -14225,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();
@@ -14258,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();
@@ -14279,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();
@@ -14349,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();
@@ -14369,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();
@@ -14398,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();
@@ -14419,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();
@@ -14489,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();
@@ -14509,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();
@@ -14538,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();
@@ -14559,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();
@@ -14629,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();
@@ -14652,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();
@@ -14722,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();
@@ -14741,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();
@@ -14768,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();
@@ -14790,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();
@@ -14815,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();
@@ -14833,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();
@@ -14858,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();
@@ -14878,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();
@@ -14907,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();
@@ -14926,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();
@@ -14964,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();
@@ -14986,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();
@@ -15043,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();
@@ -15076,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();
@@ -15088,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();
@@ -15113,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();
@@ -15134,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();
@@ -15204,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();
@@ -15237,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();
@@ -15254,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();
@@ -15291,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();
@@ -15305,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();
@@ -15332,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();
@@ -15350,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();
@@ -15397,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();
@@ -15415,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();
@@ -15450,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();
@@ -15466,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();
@@ -15523,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();
@@ -15556,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();
@@ -15574,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();
@@ -15613,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();
@@ -15637,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();
@@ -15675,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();
@@ -15694,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();
@@ -15727,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();
@@ -15751,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();
@@ -15789,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();
@@ -15808,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();
@@ -15841,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();
@@ -15867,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();
@@ -15905,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();
@@ -15927,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();
@@ -15963,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();
@@ -15980,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();
@@ -16018,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();
@@ -16037,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();
@@ -16073,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();
@@ -16090,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();
@@ -16128,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();
@@ -16151,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();
@@ -16219,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();
@@ -16235,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();
@@ -16298,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();
@@ -16319,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();
@@ -16389,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);
@@ -16412,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();
@@ -16469,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();
@@ -16485,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();
@@ -16544,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();
@@ -16561,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();
@@ -16631,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();
@@ -16651,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();
@@ -16700,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();
@@ -16714,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();
@@ -16763,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();
@@ -16776,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();
@@ -16812,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();
@@ -16827,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();
@@ -16858,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();
@@ -16877,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();
@@ -16915,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();
@@ -16937,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();
@@ -16973,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();
@@ -16990,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();
@@ -17028,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();
@@ -17047,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();
@@ -17083,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();
@@ -17100,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();
@@ -17138,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();
@@ -17160,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();
@@ -17198,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();
@@ -17221,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();
@@ -17291,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();
@@ -17324,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();
@@ -17344,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();
@@ -17401,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();
@@ -17434,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();
@@ -17450,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();
@@ -17507,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();
@@ -17540,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();
@@ -17557,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();
@@ -17622,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();
@@ -17655,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();
@@ -17671,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();
@@ -17709,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();
@@ -17739,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();
@@ -17777,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();
@@ -17796,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();
@@ -17834,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();
@@ -17854,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();
@@ -17924,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();
@@ -17957,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();
@@ -17975,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();
@@ -18045,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();
@@ -18067,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();
@@ -18124,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();
@@ -18141,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();
@@ -18193,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();
@@ -18210,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();
@@ -18262,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();
@@ -18281,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();
@@ -18319,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();
@@ -18344,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();
@@ -18399,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();
@@ -18417,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();
@@ -18472,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();
@@ -18493,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();
@@ -18526,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();
@@ -18546,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();
@@ -18598,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();
@@ -18617,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();
@@ -18686,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();
@@ -18708,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();
@@ -18778,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();
@@ -18800,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();
@@ -18857,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();
@@ -18877,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();
@@ -18938,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();
@@ -18965,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();
@@ -19001,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();
@@ -19017,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();
@@ -19053,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();
@@ -19069,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();
@@ -19105,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();
@@ -19117,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();
@@ -19140,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();
@@ -19153,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();
@@ -19189,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();
@@ -19213,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();
@@ -19268,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();
@@ -19286,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();
@@ -19341,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();
@@ -19368,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();
@@ -19437,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();
@@ -19460,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();
@@ -19487,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();
@@ -19536,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();
@@ -19563,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();
@@ -19601,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();
@@ -19626,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();
@@ -19696,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();
@@ -19721,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();
@@ -19757,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();
@@ -19769,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();
@@ -19792,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();
@@ -19807,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();
@@ -19843,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();
@@ -19856,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();
@@ -19892,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();
@@ -19907,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();
@@ -19977,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();
@@ -19999,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();
@@ -20056,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();
@@ -20072,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();
@@ -20142,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();
@@ -20164,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();
@@ -20221,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();
@@ -20238,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();
@@ -20286,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();
@@ -20305,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();
@@ -20356,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();
@@ -20373,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();
@@ -20400,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)
     {
@@ -20411,7 +19459,6 @@ void VkEncoder::vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
     {
         transform_fromhost_VkDeviceGeneratedCommandsLimitsNVX(mImpl->resources(), (VkDeviceGeneratedCommandsLimitsNVX*)(pLimits));
     }
-    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX returnUnmarshal");
     pool->freeAll();
     countingStream->clearPool();
     stream->clearPool();
@@ -20427,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();
@@ -20483,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();
@@ -20498,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();
@@ -20529,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();
@@ -20548,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();
@@ -20581,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();
@@ -20600,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();
@@ -20637,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();
@@ -20660,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();
@@ -20693,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();
@@ -20717,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();
@@ -20761,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();
@@ -20779,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();
@@ -20849,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();
@@ -20871,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();
@@ -20949,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();
@@ -20970,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();
@@ -21007,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();
@@ -21027,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();
@@ -21060,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();
@@ -21083,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();
@@ -21148,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();
@@ -21181,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();
@@ -21210,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();
@@ -21266,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();
@@ -21287,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();
@@ -21359,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();
@@ -21376,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();
@@ -21446,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();
@@ -21469,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();
@@ -21539,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();
@@ -21564,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();
@@ -21600,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();
@@ -21616,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();
@@ -21652,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();
@@ -21668,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();
@@ -21704,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();
@@ -21716,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();
@@ -21739,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();
@@ -21752,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();
@@ -21788,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();
@@ -21801,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();
@@ -21837,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();
@@ -21849,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();
@@ -21872,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();
@@ -21885,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();
@@ -21921,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();
@@ -21936,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();
@@ -22006,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();
@@ -22028,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();
@@ -22085,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();
@@ -22101,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();
@@ -22145,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();
@@ -22161,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();
@@ -22194,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();
@@ -22216,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();
@@ -22254,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();
@@ -22283,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();
@@ -22319,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();
@@ -22333,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();
@@ -22362,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();
@@ -22394,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();
@@ -22464,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();
@@ -22486,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();
@@ -22543,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();
@@ -22559,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();
@@ -22614,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();
@@ -22632,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();
@@ -22693,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();
@@ -22716,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();
@@ -22741,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();
@@ -22790,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();
@@ -22816,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();
@@ -22859,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();
@@ -22880,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();
@@ -22923,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();
@@ -22937,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();
@@ -22994,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();
@@ -23027,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();
@@ -23042,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();
@@ -23089,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();
@@ -23101,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);
@@ -23120,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();
@@ -23155,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();
@@ -23172,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();
@@ -23207,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();
@@ -23235,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();
@@ -23452,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();
@@ -23467,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();
@@ -23503,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();
@@ -23515,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();
@@ -23538,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();
@@ -23552,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();
@@ -23579,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();
@@ -23593,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();
@@ -23624,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();
@@ -23642,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();
@@ -23715,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);
@@ -23726,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();
@@ -23744,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();
@@ -23816,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);
@@ -23827,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();
@@ -23847,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();
@@ -23921,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();
@@ -23955,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();
@@ -23973,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();
@@ -24027,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);
@@ -24047,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();
@@ -24078,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();
@@ -24093,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();
@@ -24153,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();
@@ -24166,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();
@@ -24189,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();
@@ -24205,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();
@@ -24265,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();
@@ -24275,5 +23160,52 @@ void VkEncoder::vkQueueBindSparseAsyncGOOGLE(
 }
 
 #endif
+#ifdef VK_GOOGLE_linear_image_layout
+void VkEncoder::vkGetLinearImageLayoutGOOGLE(
+    VkDevice device,
+    VkFormat format,
+    VkDeviceSize* pOffset,
+    VkDeviceSize* pRowPitchAlignment)
+{
+    EncoderAutoLock encoderLock(this);
+    mImpl->log("start vkGetLinearImageLayoutGOOGLE");
+    auto stream = mImpl->stream();
+    auto countingStream = mImpl->countingStream();
+    auto resources = mImpl->resources();
+    auto pool = mImpl->pool();
+    stream->setHandleMapping(resources->unwrapMapping());
+    VkDevice local_device;
+    VkFormat local_format;
+    local_device = device;
+    local_format = format;
+    countingStream->rewind();
+    {
+        uint64_t cgen_var_1565;
+        countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1565, 1);
+        countingStream->write((uint64_t*)&cgen_var_1565, 1 * 8);
+        countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
+        countingStream->write((VkDeviceSize*)pOffset, sizeof(VkDeviceSize));
+        countingStream->write((VkDeviceSize*)pRowPitchAlignment, sizeof(VkDeviceSize));
+    }
+    uint32_t packetSize_vkGetLinearImageLayoutGOOGLE = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+    countingStream->rewind();
+    uint32_t opcode_vkGetLinearImageLayoutGOOGLE = OP_vkGetLinearImageLayoutGOOGLE;
+    stream->write(&opcode_vkGetLinearImageLayoutGOOGLE, sizeof(uint32_t));
+    stream->write(&packetSize_vkGetLinearImageLayoutGOOGLE, sizeof(uint32_t));
+    uint64_t cgen_var_1566;
+    stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1566, 1);
+    stream->write((uint64_t*)&cgen_var_1566, 1 * 8);
+    stream->write((VkFormat*)&local_format, sizeof(VkFormat));
+    stream->write((VkDeviceSize*)pOffset, sizeof(VkDeviceSize));
+    stream->write((VkDeviceSize*)pRowPitchAlignment, sizeof(VkDeviceSize));
+    stream->read((VkDeviceSize*)pOffset, sizeof(VkDeviceSize));
+    stream->read((VkDeviceSize*)pRowPitchAlignment, sizeof(VkDeviceSize));
+    pool->freeAll();
+    countingStream->clearPool();
+    stream->clearPool();
+    mImpl->log("finish vkGetLinearImageLayoutGOOGLE");;
+}
+
+#endif
 
 } // namespace goldfish_vk
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 d9860e6a..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,
@@ -1838,9 +1836,13 @@ public:
         const VkBindSparseInfo* pBindInfo,
         VkFence fence);
 #endif
-
-    void incRef();
-    bool decRef();
+#ifdef VK_GOOGLE_linear_image_layout
+    void vkGetLinearImageLayoutGOOGLE(
+    VkDevice device,
+        VkFormat format,
+        VkDeviceSize* pOffset,
+        VkDeviceSize* pRowPitchAlignment);
+#endif
 
 private:
     class Impl;
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();
diff --git a/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp b/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
index 4f59d219..512554f8 100644
--- a/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
@@ -6426,6 +6426,8 @@ void deepcopy_VkImportPhysicalAddressGOOGLE(
 #endif
 #ifdef VK_GOOGLE_async_queue_submit
 #endif
+#ifdef VK_GOOGLE_linear_image_layout
+#endif
 void deepcopy_extension_struct(
     Pool* pool,
     const void* structExtension,
diff --git a/system/vulkan_enc/goldfish_vk_deepcopy_guest.h b/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
index 243240a4..8cca9b1c 100644
--- a/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
+++ b/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
@@ -2046,5 +2046,7 @@ void deepcopy_VkImportPhysicalAddressGOOGLE(
 #endif
 #ifdef VK_GOOGLE_async_queue_submit
 #endif
+#ifdef VK_GOOGLE_linear_image_layout
+#endif
 
 } // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp b/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
index 1bc69fa1..ee84c212 100644
--- a/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
@@ -292,6 +292,8 @@ namespace goldfish_vk {
 #endif
 #ifdef VK_GOOGLE_async_queue_submit
 #endif
+#ifdef VK_GOOGLE_linear_image_layout
+#endif
 uint32_t goldfish_vk_struct_type(
     const void* structExtension)
 {
diff --git a/system/vulkan_enc/goldfish_vk_extension_structs_guest.h b/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
index 9d91cdc4..e549de9a 100644
--- a/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
+++ b/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
@@ -313,5 +313,7 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(
 #endif
 #ifdef VK_GOOGLE_async_queue_submit
 #endif
+#ifdef VK_GOOGLE_linear_image_layout
+#endif
 
 } // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp b/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
index 2e22fb0c..ff9a0697 100644
--- a/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
@@ -4782,6 +4782,8 @@ void handlemap_VkImportPhysicalAddressGOOGLE(
 #endif
 #ifdef VK_GOOGLE_async_queue_submit
 #endif
+#ifdef VK_GOOGLE_linear_image_layout
+#endif
 void handlemap_extension_struct(
     VulkanHandleMapping* handlemap,
     void* structExtension_out)
diff --git a/system/vulkan_enc/goldfish_vk_handlemap_guest.h b/system/vulkan_enc/goldfish_vk_handlemap_guest.h
index 79eeaf66..88fca6c6 100644
--- a/system/vulkan_enc/goldfish_vk_handlemap_guest.h
+++ b/system/vulkan_enc/goldfish_vk_handlemap_guest.h
@@ -1697,5 +1697,7 @@ void handlemap_VkImportPhysicalAddressGOOGLE(
 #endif
 #ifdef VK_GOOGLE_async_queue_submit
 #endif
+#ifdef VK_GOOGLE_linear_image_layout
+#endif
 
 } // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
index f857a2a8..15fa96f9 100644
--- a/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
@@ -10370,6 +10370,8 @@ void unmarshal_VkImportPhysicalAddressGOOGLE(
 #endif
 #ifdef VK_GOOGLE_async_queue_submit
 #endif
+#ifdef VK_GOOGLE_linear_image_layout
+#endif
 void marshal_extension_struct(
     VulkanStreamGuest* vkStream,
     const void* structExtension)
@@ -13241,6 +13243,12 @@ const char* api_opcode_to_string(
             return "OP_vkQueueBindSparseAsyncGOOGLE";
         }
 #endif
+#ifdef VK_GOOGLE_linear_image_layout
+        case OP_vkGetLinearImageLayoutGOOGLE:
+        {
+            return "OP_vkGetLinearImageLayoutGOOGLE";
+        }
+#endif
         default:
         {
             return "OP_UNKNOWN_API_CALL";
diff --git a/system/vulkan_enc/goldfish_vk_marshaling_guest.h b/system/vulkan_enc/goldfish_vk_marshaling_guest.h
index df07272c..d8cb1b0b 100644
--- a/system/vulkan_enc/goldfish_vk_marshaling_guest.h
+++ b/system/vulkan_enc/goldfish_vk_marshaling_guest.h
@@ -3424,6 +3424,9 @@ void unmarshal_VkImportPhysicalAddressGOOGLE(
 #define OP_vkQueueWaitIdleAsyncGOOGLE 20331
 #define OP_vkQueueBindSparseAsyncGOOGLE 20332
 #endif
+#ifdef VK_GOOGLE_linear_image_layout
+#define OP_vkGetLinearImageLayoutGOOGLE 20333
+#endif
 const char* api_opcode_to_string(
     const uint32_t opcode);
 
diff --git a/system/vulkan_enc/goldfish_vk_private_defs.h b/system/vulkan_enc/goldfish_vk_private_defs.h
index b295eda6..b844cdde 100644
--- a/system/vulkan_enc/goldfish_vk_private_defs.h
+++ b/system/vulkan_enc/goldfish_vk_private_defs.h
@@ -625,6 +625,10 @@ typedef void (VKAPI_PTR *PFN_vkQueueWaitIdleAsyncGOOGLE)(VkQueue queue);
 typedef void (VKAPI_PTR *PFN_vkQueueBindSparseAsyncGOOGLE)(
     VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
 
+#define VK_GOOGLE_linear_image_layout 1
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetLinearImageLayoutGOOGLE)(VkDevice device, VkFormat format, VkDeviceSize* pOffset, VkDeviceSize* pRowPitchAlignment);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/system/vulkan_enc/goldfish_vk_transform_guest.cpp b/system/vulkan_enc/goldfish_vk_transform_guest.cpp
index 6fc3e46c..b829c49f 100644
--- a/system/vulkan_enc/goldfish_vk_transform_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_transform_guest.cpp
@@ -9003,6 +9003,8 @@ void transform_fromhost_VkImportPhysicalAddressGOOGLE(
 #endif
 #ifdef VK_GOOGLE_async_queue_submit
 #endif
+#ifdef VK_GOOGLE_linear_image_layout
+#endif
 void transform_tohost_extension_struct(
     ResourceTracker* resourceTracker,
     void* structExtension_out)
diff --git a/system/vulkan_enc/goldfish_vk_transform_guest.h b/system/vulkan_enc/goldfish_vk_transform_guest.h
index b9699583..b29e205f 100644
--- a/system/vulkan_enc/goldfish_vk_transform_guest.h
+++ b/system/vulkan_enc/goldfish_vk_transform_guest.h
@@ -3093,5 +3093,7 @@ void transform_fromhost_VkImportPhysicalAddressGOOGLE(
 #endif
 #ifdef VK_GOOGLE_async_queue_submit
 #endif
+#ifdef VK_GOOGLE_linear_image_layout
+#endif
 
 } // namespace goldfish_vk