Skip to content

Commit

Permalink
Consolidate duplication of WriteFunctionCall routines
Browse files Browse the repository at this point in the history 
- DRY: break out a shared utility, avoiding code-duplication
  • Loading branch information
@fabian-lunarg
fabian-lunarg committed Feb 5, 2025
1 parent 5ace53b commit ef32975
Show file tree
Hide file tree
Showing 5 changed files with 97 additions and 122 deletions.
67 changes: 7 additions & 60 deletions framework/encode/vulkan_state_writer.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3683,76 +3683,23 @@ void VulkanStateWriter::DestroyTemporaryDeviceObject(format::ApiCallId
WriteDestroyDeviceObject(call_id, device_id, object_id, allocator);
}

// TODO: This is the same code used by CaptureManager to write function call data. It could be moved to a format
// utility.
void VulkanStateWriter::WriteFunctionCall(format::ApiCallId call_id,
util::MemoryOutputStream* parameter_buffer,
util::FileOutputStream* output_stream)
{
assert(parameter_buffer != nullptr);

bool not_compressed = true;
format::CompressedFunctionCallHeader compressed_header = {};
format::FunctionCallHeader uncompressed_header = {};
size_t uncompressed_size = parameter_buffer->GetDataSize();
size_t header_size = 0;
const void* header_pointer = nullptr;
size_t data_size = 0;
const void* data_pointer = nullptr;

if (compressor_ != nullptr)
{
size_t packet_size = 0;
size_t compressed_size =
compressor_->Compress(uncompressed_size, parameter_buffer->GetData(), &compressed_parameter_buffer_, 0);

if ((0 < compressed_size) && (compressed_size < uncompressed_size))
{
data_pointer = reinterpret_cast<const void*>(compressed_parameter_buffer_.data());
data_size = compressed_size;
header_pointer = reinterpret_cast<const void*>(&compressed_header);
header_size = sizeof(format::CompressedFunctionCallHeader);

compressed_header.block_header.type = format::BlockType::kCompressedFunctionCallBlock;
compressed_header.api_call_id = call_id;
compressed_header.thread_id = thread_data_->thread_id_;
compressed_header.uncompressed_size = uncompressed_size;

packet_size += sizeof(compressed_header.api_call_id) + sizeof(compressed_header.uncompressed_size) +
sizeof(compressed_header.thread_id) + compressed_size;

compressed_header.block_header.size = packet_size;
not_compressed = false;
}
}

if (not_compressed)
{
size_t packet_size = 0;
data_pointer = reinterpret_cast<const void*>(parameter_buffer->GetData());
data_size = uncompressed_size;
header_pointer = reinterpret_cast<const void*>(&uncompressed_header);
header_size = sizeof(format::FunctionCallHeader);

uncompressed_header.block_header.type = format::BlockType::kFunctionCallBlock;
uncompressed_header.api_call_id = call_id;
uncompressed_header.thread_id = thread_data_->thread_id_;

packet_size += sizeof(uncompressed_header.api_call_id) + sizeof(uncompressed_header.thread_id) + data_size;

uncompressed_header.block_header.size = packet_size;
}
format::function_call_block_t block = format::CreateFunctionCallBlock(
call_id, thread_data_->thread_id_, parameter_buffer, compressor_, &compressed_parameter_buffer_);

// Write appropriate function call block header and parameter data
if (output_stream != nullptr)
{
output_stream->Write(header_pointer, header_size);
output_stream->Write(data_pointer, data_size);
output_stream->Write(block.header, block.header_size);
output_stream->Write(block.data, block.data_size);
}
else
{
output_stream_->Write(header_pointer, header_size);
output_stream_->Write(data_pointer, data_size);
// if using internal output-stream, increment block-count
output_stream_->Write(block.header, block.header_size);
output_stream_->Write(block.data, block.data_size);
++blocks_written_;
}
}
Expand Down
57 changes: 57 additions & 0 deletions framework/format/format_util.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -106,5 +106,62 @@ std::string GetCompressionTypeName(CompressionType type)
return "";
}

format::function_call_block_t CreateFunctionCallBlock(format::ApiCallId call_id,
format::ThreadId thread_id,
const util::MemoryOutputStream* parameter_buffer,
util::Compressor* compressor,
std::vector<uint8_t>* compressor_scratch_space)
{
GFXRECON_ASSERT(parameter_buffer != nullptr);

function_call_block_t result{};
bool not_compressed = true;
size_t uncompressed_size = parameter_buffer->GetDataSize();

if (compressor != nullptr && compressor_scratch_space != nullptr)
{
size_t packet_size = 0;
size_t compressed_size =
compressor->Compress(uncompressed_size, parameter_buffer->GetData(), compressor_scratch_space, 0);

if ((compressed_size > 0) && (compressed_size < uncompressed_size))
{
auto* compressed_header = reinterpret_cast<format::CompressedFunctionCallHeader*>(result.header);
result.data = reinterpret_cast<const void*>(compressor_scratch_space->data());
result.data_size = compressed_size;
result.header_size = sizeof(format::CompressedFunctionCallHeader);

compressed_header->block_header.type = format::BlockType::kCompressedFunctionCallBlock;
compressed_header->api_call_id = call_id;
compressed_header->thread_id = thread_id;
compressed_header->uncompressed_size = uncompressed_size;

packet_size += sizeof(compressed_header->api_call_id) + sizeof(compressed_header->uncompressed_size) +
sizeof(compressed_header->thread_id) + compressed_size;

compressed_header->block_header.size = packet_size;
not_compressed = false;
}
}

if (not_compressed)
{
auto* uncompressed_header = reinterpret_cast<format::FunctionCallHeader*>(result.header);
result.data = reinterpret_cast<const void*>(parameter_buffer->GetData());
result.data_size = uncompressed_size;
result.header_size = sizeof(format::FunctionCallHeader);

uncompressed_header->block_header.type = format::BlockType::kFunctionCallBlock;
uncompressed_header->api_call_id = call_id;
uncompressed_header->thread_id = thread_id;

size_t packet_size =
sizeof(uncompressed_header->api_call_id) + sizeof(uncompressed_header->thread_id) + result.data_size;

uncompressed_header->block_header.size = packet_size;
}
return result;
}

GFXRECON_END_NAMESPACE(format)
GFXRECON_END_NAMESPACE(gfxrecon)
27 changes: 27 additions & 0 deletions framework/format/format_util.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -27,6 +27,7 @@
#include "format/format.h"
#include "util/compressor.h"
#include "util/defines.h"
#include "util/memory_output_stream.h"

#include <string>

Expand Down Expand Up @@ -95,6 +96,32 @@ util::Compressor* CreateCompressor(CompressionType type);

std::string GetCompressionTypeName(CompressionType type);

//! groups memory regions for header & data of an optionally compressed function-block
struct function_call_block_t
{
char header[std::max(sizeof(format::FunctionCallHeader), sizeof(format::CompressedFunctionCallHeader))]{};
size_t header_size = 0;
const void* data = nullptr;
size_t data_size = 0;
};

/**
* @brief CreateFunctionCallBlock can be used to create an optionally compressed function-call block
* and return pointers to the created header- and data-segments.
*
* @param call_id provided ApiCallId
* @param thread_id provided ThreadId
* @param parameter_buffer a MemoryOutputStream containing parameters
* @param compressor optional compressor, can be nullptr
* @param compressor_scratch_space optional scratch-space to be used during compression, can be nullptr
* @return a struct grouping pointers for header- and data-segments
*/
format::function_call_block_t CreateFunctionCallBlock(format::ApiCallId call_id,
format::ThreadId thread_id,
const util::MemoryOutputStream* parameter_buffer,
util::Compressor* compressor,
std::vector<uint8_t>* compressor_scratch_space);

GFXRECON_END_NAMESPACE(format)
GFXRECON_END_NAMESPACE(gfxrecon)

Expand Down
64 changes: 4 additions & 60 deletions tools/optimize/vulkan_file_optimizer.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -125,74 +125,18 @@ bool VulkanFileOptimizer::ProcessFunctionCall(const format::BlockHeader& block_h
return success;
}

// TODO: This is the same code used by CaptureManager to write function call data. It could be moved to a format
// utility.
void VulkanFileOptimizer::WriteFunctionCall(format::ApiCallId call_id,
format::ThreadId thread_id,
const util::MemoryOutputStream* parameter_buffer)
{
assert(parameter_buffer != nullptr);

bool not_compressed = true;
format::CompressedFunctionCallHeader compressed_header = {};
format::FunctionCallHeader uncompressed_header = {};
size_t uncompressed_size = parameter_buffer->GetDataSize();
size_t header_size = 0;
const void* header_pointer = nullptr;
size_t data_size = 0;
const void* data_pointer = nullptr;

auto compressor = GetCompressor();
auto compressed_parameter_buffer = GetCompressedParameterBuffer();

if (compressor != nullptr)
{
size_t packet_size = 0;
size_t compressed_size =
compressor->Compress(uncompressed_size, parameter_buffer->GetData(), &compressed_parameter_buffer, 0);

if ((0 < compressed_size) && (compressed_size < uncompressed_size))
{
data_pointer = reinterpret_cast<const void*>(compressed_parameter_buffer.data());
data_size = compressed_size;
header_pointer = reinterpret_cast<const void*>(&compressed_header);
header_size = sizeof(format::CompressedFunctionCallHeader);

compressed_header.block_header.type = format::BlockType::kCompressedFunctionCallBlock;
compressed_header.api_call_id = call_id;
compressed_header.thread_id = thread_id;
compressed_header.uncompressed_size = uncompressed_size;

packet_size += sizeof(compressed_header.api_call_id) + sizeof(compressed_header.uncompressed_size) +
sizeof(compressed_header.thread_id) + compressed_size;

compressed_header.block_header.size = packet_size;
not_compressed = false;
}
}

if (not_compressed)
{
size_t packet_size = 0;
data_pointer = reinterpret_cast<const void*>(parameter_buffer->GetData());
data_size = uncompressed_size;
header_pointer = reinterpret_cast<const void*>(&uncompressed_header);
header_size = sizeof(format::FunctionCallHeader);

uncompressed_header.block_header.type = format::BlockType::kFunctionCallBlock;
uncompressed_header.api_call_id = call_id;
uncompressed_header.thread_id = thread_id;

packet_size += sizeof(uncompressed_header.api_call_id) + sizeof(uncompressed_header.thread_id) + data_size;

uncompressed_header.block_header.size = packet_size;
}
format::function_call_block_t block = format::CreateFunctionCallBlock(
call_id, thread_id, parameter_buffer, GetCompressor(), &GetCompressedParameterBuffer());

// Write appropriate function call block header.
WriteBytes(header_pointer, header_size);
WriteBytes(block.header, block.header_size);

// Write parameter data.
WriteBytes(data_pointer, data_size);
WriteBytes(block.data, block.data_size);
}

GFXRECON_END_NAMESPACE(gfxrecon)
4 changes: 2 additions & 2 deletions tools/optimize/vulkan_file_optimizer.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -40,12 +40,12 @@ class VulkanFileOptimizer : public FileOptimizer
std::vector<std::unique_ptr<util::VulkanModifierBase>> modifiers;
};

VulkanFileOptimizer(VulkanOptimizationData* optimization_data) :
explicit VulkanFileOptimizer(VulkanOptimizationData* optimization_data) :
FileOptimizer(optimization_data->unreferenced_ids), optimization_data_(optimization_data)
{}

private:
virtual bool ProcessFunctionCall(const format::BlockHeader& block_header, format::ApiCallId call_id) override;
bool ProcessFunctionCall(const format::BlockHeader& block_header, format::ApiCallId call_id) override;

void WriteFunctionCall(format::ApiCallId call_id,
format::ThreadId thread_id,
Expand Down

0 comments on commit ef32975

Please sign in to comment.