[WebGPU] Add delegate header parser

Parses the VH00/VK00 FlatBuffer envelope from the Vulkan
partitioner to extract the serialized graph payload.

Author: digantdesai

backends/webgpu/runtime/WebGPUDelegateHeader.cpp

@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <executorch/backends/webgpu/runtime/WebGPUDelegateHeader.h>
+
+#include <cstring>
+
+#include <executorch/runtime/core/error.h>
+#include <executorch/runtime/core/result.h>
+
+namespace executorch {
+namespace backends {
+namespace webgpu {
+
+using executorch::runtime::Error;
+using executorch::runtime::Result;
+
+namespace {
+
+struct ByteSlice {
+  size_t offset;
+  size_t size;
+};
+
+constexpr size_t kExpectedSize = 30;
+constexpr char kExpectedMagic[4] = {'V', 'H', '0', '0'};
+
+constexpr ByteSlice kMagic = {4, 4};
+constexpr ByteSlice kHeaderSize = {8, 2};
+constexpr ByteSlice kFlatbufferOffset = {10, 4};
+constexpr ByteSlice kFlatbufferSize = {14, 4};
+constexpr ByteSlice kBytesOffset = {18, 4};
+constexpr ByteSlice kBytesSize = {22, 8};
+
+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);
+}
+
+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);
+}
+
+uint32_t getUInt16LE(const uint8_t* data) {
+  return (uint32_t)data[0] | ((uint32_t)data[1] << 8);
+}
+
+} // namespace
+
+bool WebGPUDelegateHeader::is_valid() const {
+  if (header_size < kExpectedSize) {
+    return false;
+  }
+  if (flatbuffer_offset < header_size) {
+    return false;
+  }
+  if (flatbuffer_size == 0) {
+    return false;
+  }
+  if (bytes_offset < flatbuffer_offset + flatbuffer_size) {
+    return false;
+  }
+  return true;
+}
+
+Result<WebGPUDelegateHeader> WebGPUDelegateHeader::parse(const void* data) {
+  const uint8_t* header_data = (const uint8_t*)data;
+
+  const uint8_t* magic_start = header_data + kMagic.offset;
+  if (std::memcmp(magic_start, kExpectedMagic, kMagic.size) != 0) {
+    return Error::NotFound;
+  }
+
+  WebGPUDelegateHeader header = WebGPUDelegateHeader{
+      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()) {
+    return Error::InvalidArgument;
+  }
+
+  return header;
+}
+
+} // namespace webgpu
+} // namespace backends
+} // namespace executorch

backends/webgpu/runtime/WebGPUDelegateHeader.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <executorch/runtime/core/result.h>
+
+namespace executorch {
+namespace backends {
+namespace webgpu {
+
+struct WebGPUDelegateHeader {
+  bool is_valid() const;
+
+  static executorch::runtime::Result<WebGPUDelegateHeader> parse(
+      const void* data);
+
+  uint32_t header_size;
+  uint32_t flatbuffer_offset;
+  uint32_t flatbuffer_size;
+  uint32_t bytes_offset;
+  uint64_t bytes_size;
+};
+
+} // namespace webgpu
+} // namespace backends
+} // namespace executorch