pytorch · junpi3 · May 8, 2024 · May 8, 2024
diff --git a/backends/vulkan/runtime/VulkanBackend.cpp b/backends/vulkan/runtime/VulkanBackend.cpp
@@ -48,7 +48,7 @@ using BytesVector =
     const flatbuffers::Vector<flatbuffers::Offset<vkgraph::VkBytes>>*;
 using UIntVector = const flatbuffers::Vector<uint32_t>*;
 
-const uint8_t* getConstantDataPtr(
+const uint8_t* get_constant_data_ptr(
     VkGraphPtr flatbuffer_graph,
     const int32_t buffer_idx,
     const uint8_t* constant_data) {
@@ -111,19 +111,19 @@ GraphConfig get_graph_config(ArrayRef<CompileSpec>& compile_specs) {
     const size_t value_size = spec.value.nbytes;
     if (strcmp(spec.key, "storage_type_override") == 0) {
       ET_CHECK_MSG(value_size == sizeof(int32_t), "Unexpected value size!");
-      int value_as_int = static_cast<int>(GetUInt32LE(value_data));
+      int value_as_int = static_cast<int>(getUInt32LE(value_data));
       api::StorageType storage_type =
           static_cast<api::StorageType>(value_as_int);
 
-      config.setStorageTypeOverride(storage_type);
+      config.set_storage_type_override(storage_type);
     }
     if (strcmp(spec.key, "memory_layout_override") == 0) {
       ET_CHECK_MSG(value_size == sizeof(uint32_t), "Unexpected value size!");
-      uint32_t value_as_int = GetUInt32LE(value_data);
+      uint32_t value_as_int = getUInt32LE(value_data);
       api::GPUMemoryLayout memory_layout =
           static_cast<api::GPUMemoryLayout>(value_as_int);
 
-      config.setMemoryLayoutOverride(memory_layout);
+      config.set_memory_layout_override(memory_layout);
     }
   }
   return config;
@@ -181,7 +181,7 @@ class GraphBuilder {
 
     ValueRef ref;
     if (tensor_fb->constant_id() >= 0) {
-      const uint8_t* tensor_data = getConstantDataPtr(
+      const uint8_t* tensor_data = get_constant_data_ptr(
           flatbuffer_, tensor_fb->constant_id(), constant_data_);
 
       ref = compute_graph_->add_tensorref(dims_vector, dtype, tensor_data);
@@ -399,7 +399,7 @@ class VulkanBackend final : public PyTorchBackendInterface {
   __ET_NODISCARD Error
   compileModel(const void* buffer_pointer, ComputeGraph* compute_graph) const {
     Result<VulkanDelegateHeader> header =
-        VulkanDelegateHeader::Parse(buffer_pointer);
+        VulkanDelegateHeader::parse(buffer_pointer);
 
     const uint8_t* flatbuffer_data = nullptr;
     const uint8_t* constant_data = nullptr;

diff --git a/backends/vulkan/runtime/VulkanDelegateHeader.cpp b/backends/vulkan/runtime/VulkanDelegateHeader.cpp
@@ -39,21 +39,21 @@ constexpr ByteSlice kBytesSize = {22, 8};
 } // namespace
 
 /// Interprets the 8 bytes at `data` as a little-endian uint64_t.
-uint64_t GetUInt64LE(const uint8_t* data) {
+uint64_t getUInt64LE(const uint8_t* data) {
   return (uint64_t)data[0] | ((uint64_t)data[1] << 8) |
       ((uint64_t)data[2] << 16) | ((uint64_t)data[3] << 24) |
       ((uint64_t)data[4] << 32) | ((uint64_t)data[5] << 40) |
       ((uint64_t)data[6] << 48) | ((uint64_t)data[7] << 56);
 }
 
 /// Interprets the 4 bytes at `data` as a little-endian uint32_t.
-uint32_t GetUInt32LE(const uint8_t* data) {
+uint32_t getUInt32LE(const uint8_t* data) {
   return (uint32_t)data[0] | ((uint32_t)data[1] << 8) |
       ((uint32_t)data[2] << 16) | ((uint32_t)data[3] << 24);
 }
 
 /// Interprets the 2 bytes at `data` as a little-endian uint32_t.
-uint32_t GetUInt16LE(const uint8_t* data) {
+uint32_t getUInt16LE(const uint8_t* data) {
   return (uint32_t)data[0] | ((uint32_t)data[1] << 8);
 }
 
@@ -77,7 +77,7 @@ bool VulkanDelegateHeader::is_valid() const {
   return true;
 }
 
-Result<VulkanDelegateHeader> VulkanDelegateHeader::Parse(const void* data) {
+Result<VulkanDelegateHeader> VulkanDelegateHeader::parse(const void* data) {
   const uint8_t* header_data = (const uint8_t*)data;
 
   const uint8_t* magic_start = header_data + kMagic.offset;
@@ -86,11 +86,11 @@ Result<VulkanDelegateHeader> VulkanDelegateHeader::Parse(const void* data) {
   }
 
   VulkanDelegateHeader header = VulkanDelegateHeader{
-      GetUInt16LE(header_data + kHeaderSize.offset),
-      GetUInt32LE(header_data + kFlatbufferOffset.offset),
-      GetUInt32LE(header_data + kFlatbufferSize.offset),
-      GetUInt32LE(header_data + kBytesOffset.offset),
-      GetUInt64LE(header_data + kBytesSize.offset),
+      getUInt16LE(header_data + kHeaderSize.offset),
+      getUInt32LE(header_data + kFlatbufferOffset.offset),
+      getUInt32LE(header_data + kFlatbufferSize.offset),
+      getUInt32LE(header_data + kBytesOffset.offset),
+      getUInt64LE(header_data + kBytesSize.offset),
   };
 
   if (!header.is_valid()) {

diff --git a/backends/vulkan/runtime/VulkanDelegateHeader.h b/backends/vulkan/runtime/VulkanDelegateHeader.h
@@ -15,14 +15,14 @@ namespace executor {
 namespace vulkan {
 
 // Byte decoding utilities
-uint64_t GetUInt64LE(const uint8_t* data);
-uint32_t GetUInt32LE(const uint8_t* data);
-uint32_t GetUInt16LE(const uint8_t* data);
+uint64_t getUInt64LE(const uint8_t* data);
+uint32_t getUInt32LE(const uint8_t* data);
+uint32_t getUInt16LE(const uint8_t* data);
 
 struct VulkanDelegateHeader {
   bool is_valid() const;
 
-  static Result<VulkanDelegateHeader> Parse(const void* data);
+  static Result<VulkanDelegateHeader> parse(const void* data);
 
   uint32_t header_size;
   uint32_t flatbuffer_offset;

diff --git a/backends/vulkan/runtime/api/Command.cpp b/backends/vulkan/runtime/api/Command.cpp
@@ -392,7 +392,7 @@ CommandPool::CommandPool(
   VK_CHECK(vkCreateCommandPool(device_, &create_info, nullptr, &pool_));
 
   // Pre-allocate some command buffers
-  allocate_new_batch(config_.cmdPoolInitialSize);
+  allocate_new_batch(config_.cmd_pool_initial_size);
 }
 
 CommandPool::~CommandPool() {
@@ -406,7 +406,7 @@ CommandBuffer CommandPool::get_new_cmd(bool reusable) {
   std::lock_guard<std::mutex> lock(mutex_);
 
   // No-ops if there are command buffers available
-  allocate_new_batch(config_.cmdPoolBatchSize);
+  allocate_new_batch(config_.cmd_pool_batch_size);
 
   VkCommandBuffer handle = buffers_[in_use_];
 

diff --git a/backends/vulkan/runtime/api/Command.h b/backends/vulkan/runtime/api/Command.h
@@ -130,8 +130,8 @@ class CommandBuffer final {
 };
 
 struct CommandPoolConfig final {
-  uint32_t cmdPoolInitialSize;
-  uint32_t cmdPoolBatchSize;
+  uint32_t cmd_pool_initial_size;
+  uint32_t cmd_pool_batch_size;
 };
 
 class CommandPool final {

diff --git a/backends/vulkan/runtime/api/Context.cpp b/backends/vulkan/runtime/api/Context.cpp
@@ -30,12 +30,12 @@ Context::Context(size_t adapter_i, const ContextConfig& config)
       device_(adapter_p_->device_handle()),
       queue_(adapter_p_->request_queue()),
       // Resource pools
-      command_pool_(device_, queue_.family_index, config_.cmdPoolConfig),
-      descriptor_pool_(device_, config_.descriptorPoolConfig),
+      command_pool_(device_, queue_.family_index, config_.cmd_pool_config),
+      descriptor_pool_(device_, config_.descriptor_pool_config),
       fences_(device_),
 // Diagnostics
 #ifdef USE_VULKAN_GPU_DIAGNOSTICS
-      querypool_(config_.queryPoolConfig, adapter_p_),
+      querypool_(config_.query_pool_config, adapter_p_),
 #endif /* USE_VULKAN_GPU_DIAGNOSTICS */
       // Command buffer submission
       cmd_mutex_{},
@@ -143,7 +143,7 @@ bool available() {
 Context* context() {
   static const std::unique_ptr<Context> context([]() -> Context* {
     try {
-      const uint32_t submit_frequency = 16u;
+      const uint32_t cmd_submit_frequency = 16u;
 
       const CommandPoolConfig cmd_config{
           32u, // cmdPoolInitialSize
@@ -165,10 +165,10 @@ Context* context() {
       };
 
       const ContextConfig config{
-          submit_frequency, // cmdSubmitFrequency
-          cmd_config, // cmdPoolConfig
-          descriptor_pool_config, // descriptorPoolConfig
-          query_pool_config, // queryPoolConfig
+          cmd_submit_frequency,
+          cmd_config,
+          descriptor_pool_config,
+          query_pool_config,
       };
 
       return new Context(runtime()->default_adapter_i(), config);

diff --git a/backends/vulkan/runtime/api/Context.h b/backends/vulkan/runtime/api/Context.h
@@ -26,10 +26,10 @@ namespace vkcompute {
 namespace api {
 
 struct ContextConfig final {
-  uint32_t cmdSubmitFrequency;
-  CommandPoolConfig cmdPoolConfig;
-  DescriptorPoolConfig descriptorPoolConfig;
-  QueryPoolConfig queryPoolConfig;
+  uint32_t cmd_submit_frequency;
+  CommandPoolConfig cmd_pool_config;
+  DescriptorPoolConfig descriptor_pool_config;
+  QueryPoolConfig query_pool_config;
 };
 
 //
@@ -485,7 +485,7 @@ inline bool Context::submit_copy(
 
   submit_count_++;
   if (fence_handle != VK_NULL_HANDLE ||
-      submit_count_ >= config_.cmdSubmitFrequency) {
+      submit_count_ >= config_.cmd_submit_frequency) {
     submit_cmd_to_gpu(fence_handle);
     return true;
   }
@@ -568,7 +568,7 @@ inline bool Context::submit_compute_job(
 
   submit_count_++;
   if (fence_handle != VK_NULL_HANDLE ||
-      submit_count_ >= config_.cmdSubmitFrequency) {
+      submit_count_ >= config_.cmd_submit_frequency) {
     submit_cmd_to_gpu(fence_handle);
     return true;
   }

diff --git a/backends/vulkan/runtime/api/Descriptor.cpp b/backends/vulkan/runtime/api/Descriptor.cpp
@@ -235,7 +235,7 @@ DescriptorPool::DescriptorPool(
       config_(config),
       mutex_{},
       piles_{} {
-  if (config.descriptorPoolMaxSets > 0) {
+  if (config.descriptor_pool_max_sets > 0) {
     init(config);
   }
 }
@@ -257,27 +257,27 @@ void DescriptorPool::init(const DescriptorPoolConfig& config) {
   std::vector<VkDescriptorPoolSize> type_sizes{
       {
           VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-          config_.descriptorUniformBufferCount,
+          config_.descriptor_uniform_buffer_count,
       },
       {
           VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-          config_.descriptorStorageBufferCount,
+          config_.descriptor_storage_buffer_count,
       },
       {
           VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
-          config_.descriptorCombinedSamplerCount,
+          config_.descriptor_combined_sampler_count,
       },
       {
           VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
-          config_.descriptorStorageBufferCount,
+          config_.descriptor_storage_buffer_count,
       },
   };
 
   const VkDescriptorPoolCreateInfo create_info{
       VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, // sType
       nullptr, // pNext
       0u, // flags
-      config_.descriptorPoolMaxSets, // maxSets
+      config_.descriptor_pool_max_sets, // maxSets
       static_cast<uint32_t>(type_sizes.size()), // poolSizeCounts
       type_sizes.data(), // pPoolSizes
   };
@@ -297,7 +297,7 @@ DescriptorSet DescriptorPool::get_descriptor_set(
              .insert({
                  set_layout,
                  DescriptorSetPile(
-                     config_.descriptorPileSizes, set_layout, device_, pool_),
+                     config_.descriptor_pile_sizes, set_layout, device_, pool_),
              })
              .first;
   }

diff --git a/backends/vulkan/runtime/api/Descriptor.h b/backends/vulkan/runtime/api/Descriptor.h
@@ -107,14 +107,14 @@ class DescriptorSetPile final {
 
 struct DescriptorPoolConfig final {
   // Overall Pool capacity
-  uint32_t descriptorPoolMaxSets;
+  uint32_t descriptor_pool_max_sets;
   // DescriptorCounts by type
-  uint32_t descriptorUniformBufferCount;
-  uint32_t descriptorStorageBufferCount;
-  uint32_t descriptorCombinedSamplerCount;
-  uint32_t descriptorStorageImageCount;
+  uint32_t descriptor_uniform_buffer_count;
+  uint32_t descriptor_storage_buffer_count;
+  uint32_t descriptor_combined_sampler_count;
+  uint32_t descriptor_storage_image_count;
   // Pile size for pre-allocating descriptor sets
-  uint32_t descriptorPileSizes;
+  uint32_t descriptor_pile_sizes;
 };
 
 class DescriptorPool final {

diff --git a/backends/vulkan/runtime/api/QueryPool.cpp b/backends/vulkan/runtime/api/QueryPool.cpp
@@ -42,13 +42,13 @@ QueryPool::QueryPool(const QueryPoolConfig& config, const Adapter* adapter_p)
       nullptr, // pNext
       0u, // flags
       VK_QUERY_TYPE_TIMESTAMP, // queryType
-      config_.maxQueryCount, // queryCount
+      config_.max_query_count, // queryCount
       0u, // pipelineStatistics
   };
 
   VK_CHECK(vkCreateQueryPool(device_, &info, nullptr, &querypool_));
 
-  shader_log().reserve(config_.initialReserveSize);
+  shader_log().reserve(config_.initial_reserve_size);
 
   VK_CHECK_COND(adapter_p, "Valid GPU device must be created for QueryPool");
   ns_per_tick_ = std::lround(adapter_p->timestamp_period());
@@ -79,16 +79,16 @@ void QueryPool::reset(const CommandBuffer& cmd) {
   previous_shader_count_ += shader_log().size();
   in_use_ = 0u;
   shader_logs_.emplace_back();
-  shader_log().reserve(config_.initialReserveSize);
+  shader_log().reserve(config_.initial_reserve_size);
   results_pending_ = false;
 }
 
 size_t QueryPool::write_timestamp(const CommandBuffer& cmd) {
   VK_CHECK_COND(
-      in_use_ < config_.maxQueryCount,
+      in_use_ < config_.max_query_count,
       "Vulkan QueryPool: Exceeded the maximum number of queries "
       "allowed by the queryPool (",
-      config_.maxQueryCount,
+      config_.max_query_count,
       ")!");
 
   cmd.write_timestamp(querypool_, in_use_);

diff --git a/backends/vulkan/runtime/api/QueryPool.h b/backends/vulkan/runtime/api/QueryPool.h
@@ -22,8 +22,8 @@ namespace vkcompute {
 namespace api {
 
 struct QueryPoolConfig final {
-  uint32_t maxQueryCount;
-  uint32_t initialReserveSize;
+  uint32_t max_query_count;
+  uint32_t initial_reserve_size;
 };
 
 struct ShaderDuration final {