ruby_memprofiler_pprof 0.0.3 → 0.0.4

data/ext/ruby_memprofiler_pprof_ext/compat.c

@@ -0,0 +1,184 @@
+#include <errno.h>
+#include <pthread.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include <ruby.h>
+
+#include "ruby_memprofiler_pprof.h"
+
+#if defined(HAVE_ARC4RANDOM)
+uint32_t mpp_rand() { return arc4random(); }
+void mpp_rand_init() {}
+#elif defined(HAVE_MRAND48_R) && defined(HAVE_GETENTROPY)
+// Why? Why does glibc make it so darn difficult to just get random numbers in a way
+// that isn't racy across different threads and doesn't depend on global state?
+#include <sys/random.h>
+
+static pthread_mutex_t mpp_rand_lock;
+static struct drand48_data mpp_rand_buffer;
+
+uint32_t mpp_rand() {
+  pthread_mutex_lock(&mpp_rand_lock);
+  long int result;
+  int ret = mrand48_r(&mpp_rand_buffer, &result);
+  if (ret < 0) {
+    rb_bug("mrand48_r returned -1?");
+  }
+  pthread_mutex_unlock(&mpp_rand_lock);
+  return (uint32_t)result;
+}
+
+void mpp_rand_init() {
+  pthread_mutex_init(&mpp_rand_lock, NULL);
+  memset(&mpp_rand_buffer, 0, sizeof(struct drand48_data));
+  unsigned short int seedbuf[3];
+  int ret;
+  ret = getentropy(seedbuf, sizeof(seedbuf));
+  if (ret == -1) {
+    rb_bug("getentropy returned -1?");
+  }
+  ret = seed48_r(seedbuf, &mpp_rand_buffer);
+  if (ret < 0) {
+    rb_bug("seed48_r returned -1?");
+  }
+}
+#else
+#error "No suitable RNG implementation"
+#endif
+
+struct timespec mpp_gettime_monotonic() {
+  struct timespec tv;
+  clock_gettime(CLOCK_MONOTONIC, &tv);
+  return tv;
+}
+
+int64_t mpp_time_delta_nsec(struct timespec t1, struct timespec t2) {
+  return (t2.tv_sec - t1.tv_sec) * 1000000000 + (t2.tv_nsec - t1.tv_nsec);
+}
+
+void *mpp_xcalloc(size_t sz) {
+  void *mem = mpp_xmalloc(sz);
+  memset(mem, 0, sz);
+  return mem;
+}
+
+void *mpp_xmalloc(size_t sz) {
+  void *mem = ruby_xmalloc(sz);
+  if (!mem) {
+    MPP_ASSERT_FAIL("failed to allocate memory in ruby_memprofiler_pprof gem");
+  }
+  return mem;
+}
+
+void mpp_free(void *mem) { ruby_xfree(mem); }
+
+void *mpp_realloc(void *mem, size_t newsz) {
+  void *newmem = ruby_xrealloc(mem, newsz);
+  if (!newmem) {
+    MPP_ASSERT_FAIL("failed to allocate memory in ruby_memprofiler_pprof gem");
+  }
+  return newmem;
+}
+
+void mpp_pthread_mutex_lock(pthread_mutex_t *m) {
+  if (pthread_mutex_lock(m) != 0) {
+    MPP_ASSERT_FAIL("failed to lock mutex in ruby_memprofiler_pprof gem");
+  }
+}
+
+void mpp_pthread_mutex_unlock(pthread_mutex_t *m) {
+  if (pthread_mutex_unlock(m) != 0) {
+    MPP_ASSERT_FAIL("failed to unlock mutex in ruby_memprofiler_pprof gem");
+  }
+}
+
+int mpp_pthread_mutex_trylock(pthread_mutex_t *m) {
+  int r = pthread_mutex_trylock(m);
+  if (r != 0 && r != EBUSY) {
+    MPP_ASSERT_FAIL("failed to trylock mutex in ruby_memprofiler_pprof gem");
+  }
+  return r;
+}
+
+void mpp_pthread_mutex_init(pthread_mutex_t *m, const pthread_mutexattr_t *attr) {
+  if (pthread_mutex_init(m, attr) != 0) {
+    MPP_ASSERT_FAIL("failed to init mutex in ruby_memprofiler_pprof gem");
+  }
+}
+
+void mpp_pthread_mutex_destroy(pthread_mutex_t *m) {
+  if (pthread_mutex_destroy(m) != 0) {
+    MPP_ASSERT_FAIL("failed to destroy mutex in ruby_memprofiler_pprof gem");
+  }
+}
+
+void mpp_pthread_mutexattr_init(pthread_mutexattr_t *a) {
+  if (pthread_mutexattr_init(a) != 0) {
+    MPP_ASSERT_FAIL("failed to init pthread_mutexattr in ruby_memprofiler_pprof gem");
+  }
+}
+
+void mpp_pthread_mutexattr_destroy(pthread_mutexattr_t *a) {
+  if (pthread_mutexattr_destroy(a) != 0) {
+    MPP_ASSERT_FAIL("failed to destroy pthread_mutexattr in ruby_memprofiler_pprof gem");
+  }
+}
+
+void mpp_pthread_mutexattr_settype(pthread_mutexattr_t *a, int type) {
+  if (pthread_mutexattr_settype(a, type) != 0) {
+    MPP_ASSERT_FAIL("failed to set type on pthread_mutexattr in ruby_memprofiler_pprof gem");
+  }
+}
+
+void mpp_pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void)) {
+  if (pthread_atfork(prepare, parent, child) != 0) {
+    MPP_ASSERT_FAIL("pthread_atfork failed in ruby_memprofiler_pprof gem");
+  }
+}
+
+__attribute__((noreturn)) void mpp_assert_fail(const char *msg, const char *assertion, const char *file,
+                                               const char *line, const char *fn) {
+  char final_msg_buf[1024];
+  int32_t final_msg_ix = 0;
+  int32_t final_msg_remaining = sizeof(final_msg_buf) - 2; // -1 for null terminator, -1 for trailing newline.
+
+#define FINAL_MSG_BUF_APPEND(str)                                                                                      \
+  do {                                                                                                                 \
+    int32_t seg_len = (int32_t)strlen(str);                                                                            \
+    int32_t copy_n = (seg_len > final_msg_remaining) ? final_msg_remaining : seg_len;                                  \
+    memcpy(final_msg_buf + final_msg_ix, str, copy_n);                                                                 \
+    final_msg_ix += seg_len;                                                                                           \
+    final_msg_remaining -= seg_len;                                                                                    \
+  } while (0)
+
+  FINAL_MSG_BUF_APPEND("assertion failure in ruby_memprofiler_pprof gem: ");
+  FINAL_MSG_BUF_APPEND(msg);
+  FINAL_MSG_BUF_APPEND(" (");
+  FINAL_MSG_BUF_APPEND(assertion);
+  FINAL_MSG_BUF_APPEND("; at ");
+  FINAL_MSG_BUF_APPEND(file);
+  FINAL_MSG_BUF_APPEND(":");
+  FINAL_MSG_BUF_APPEND(line);
+  FINAL_MSG_BUF_APPEND(" ");
+  FINAL_MSG_BUF_APPEND(fn);
+  FINAL_MSG_BUF_APPEND(")");
+
+  // We're guaranteed to have left enough space for this because we started final_msg_remaining off
+  // with sizeof(buf) - 2.
+  final_msg_remaining += 2;
+  FINAL_MSG_BUF_APPEND("\n\0");
+
+  __attribute__((unused)) size_t r = write(STDERR_FILENO, final_msg_buf, final_msg_ix + 1);
+  abort();
+}
+
+void mpp_log_debug(const char *pattern, ...) {
+  va_list args;
+  va_start(args, pattern);
+  fprintf(stderr, "ruby_memprofiler_pprof gem: ");
+  vfprintf(stderr, pattern, args);
+  fprintf(stderr, "\n");
+  va_end(args);
+}

data/ext/ruby_memprofiler_pprof_ext/compile_commands.json

@@ -0,0 +1 @@
+ext/ruby_memprofiler_pprof_ext/Users/ktsanaktsidis/Code/zendesk/ruby_memprofiler_pprof/tmp/arm64-dar

data/ext/ruby_memprofiler_pprof_ext/extconf.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "mkmf"
+
+# Support GC.compact on Ruby >=- 2.7
+have_func("rb_gc_mark_movable", ["ruby.h"])
+# Handle Ractors
+have_func("rb_ext_ractor_safe", ["ruby.h"])
+
+# Find a random number generator API that doesn't have global state.
+has_arc4random = have_func("arc4random", ["stdlib.h"])
+has_mrand48_r = have_func("mrand48_r", ["stdlib.h"])
+has_getentropy = have_func("getentropy", ["sys/random.h"])
+if !has_arc4random && !(has_mrand48_r && has_getentropy)
+  abort "Need either arc4random (BSD) or mrand48_r/getentropy (GNU)"
+end
+
+# Need zlib
+has_zlib_headers = have_header("zlib.h")
+has_zlib_lib = have_library("z")
+raise "Zlib headers & library are required!" unless has_zlib_headers && has_zlib_lib
+
+# Need to actually link pthreads properly
+have_library("pthread") or raise "missing pthread library"
+have_func("clock_gettime", ["time.h"]) or raise "missing clock_gettime"
+
+ruby_version = Gem::Version.new RUBY_VERSION
+
+# Ruby >= 3.1 has deprecated/no-opp'd rb_gc_force_recycle, which is good for us, because
+# objects freed with that method do not get the freeobj tracepoint called on them.
+if Gem::Requirement.new("< 3.1").satisfied_by?(ruby_version)
+  $defs << "-DHAVE_WORKING_RB_GC_FORCE_RECYCLE"
+end
+
+if Gem::Requirement.new("~> 2.6.0").satisfied_by?(ruby_version)
+  $VPATH << "$(srcdir)/ruby_private/ruby26"
+  $INCFLAGS << " -I#{File.join($srcdir, "ruby_private/ruby26")}"
+elsif Gem::Requirement.new("~> 2.7.0").satisfied_by?(ruby_version)
+  $VPATH << "$(srcdir)/ruby_private/ruby27"
+  $INCFLAGS << " -I#{File.join($srcdir, "ruby_private/ruby27")}"
+elsif Gem::Requirement.new("~> 3.0.0").satisfied_by?(ruby_version)
+  $VPATH << "$(srcdir)/ruby_private/ruby30"
+  $INCFLAGS << " -I#{File.join($srcdir, "ruby_private/ruby30")}"
+elsif Gem::Requirement.new("~> 3.1.0").satisfied_by?(ruby_version)
+  $VPATH << "$(srcdir)/ruby_private/ruby31"
+  $INCFLAGS << " -I#{File.join($srcdir, "ruby_private/ruby31")}"
+else
+  raise "Not compatible with Ruby #{ruby_version}"
+end
+
+# Ask the ruby interpreter at runtime if these features are enabled or not
+# The values detected this way will be used if they are not present in
+# the mjit header.
+gc_opt_keys = %w[
+  GC_DEBUG
+  USE_RGENGC
+  RGENGC_DEBUG
+  RGENGC_CHECK_MODE
+  RGENGC_PROFILE
+  RGENGC_ESTIMATE_OLDMALLOC
+  GC_PROFILE_MORE_DETAIL
+  GC_ENABLE_LAZY_SWEEP
+  CALC_EXACT_MALLOC_SIZE
+  MALLOC_ALLOCATED_SIZE
+  MALLOC_ALLOCATED_SIZE_CHECK
+  GC_PROFILE_DETAIL_MEMORY
+]
+gc_opt_keys.each do |key|
+  $defs << if GC::OPTS.include?(key)
+    "-D#{key}=1"
+  else
+    "-D#{key}=0"
+  end
+end
+
+# When including the mjit header, it needs to come _before_ ruby.h otherwise
+# the C compiler will spew out multiple definition errors. So we pass a block
+# to the various have_* methods to strip that out (just the first one).
+STRIP_RUBY_INCLUDE = proc do |src|
+  src.sub(/#\s*include\s+["<]ruby\.h[">]/, "")
+end
+
+# Record where to find the mjit header
+RUBY_MJIT_HEADER = "rb_mjit_min_header-#{RUBY_VERSION}.h"
+$defs << "-DRUBY_MJIT_HEADER=\\\"#{RUBY_MJIT_HEADER}\\\""
+have_header(RUBY_MJIT_HEADER, &STRIP_RUBY_INCLUDE) or raise "mjit header #{RUBY_MJIT_HEADER} not found"
+
+# Whether or not we have variable-sized slots in Ruby 3.1+
+checking_for checking_message("variable sized heap slots") do
+  variable_slots_src = <<~CLANG
+    #include <#{RUBY_MJIT_HEADER}>
+    #include <ruby.h>
+    #include <ruby/re.h>
+    #include "gc_private.h"
+  
+    int s = (char *)&((struct heap_page *)0)->slot_size - (char *)0;
+    int main(int argc, char **argv) {
+      return !!argv[argc];  
+    }
+  CLANG
+  if try_compile(variable_slots_src, &STRIP_RUBY_INCLUDE)
+    $defs << "-DHAVE_VARIABLE_SLOT_SIZE"
+    true
+  else
+    false
+  end
+end
+
+if have_macro("GET_RACTOR", [RUBY_MJIT_HEADER], &STRIP_RUBY_INCLUDE)
+  $defs << "-DHAVE_GET_RACTOR"
+end
+
+# Set our cflags up _only after_ we have run all the existence checks above; otherwise
+# stuff like -Werror can break the test programs.
+append_cflags([
+  "-g", # Compile with debug info
+  "-D_GNU_SOURCE", "-std=gnu11", # Use GNU C extensions (e.g. we use this for atomics)
+  "-fvisibility=hidden", # Make sure our upb symbols don't clobber any others from other exts
+  "-fno-optimize-sibling-calls"
+])
+append_cflags(["-Wall", "-Wextra"]) # Enable all the warnings
+# These diagnostics are not very interesting at all, just disable them.
+append_cflags([
+  "-Wno-unused-parameter",
+  "-Wno-declaration-after-statement",
+  "-Wno-suggest-attribute=noreturn",
+  "-Wno-suggest-attribute=format"
+])
+
+# Compile the upb objects into our extension as well.
+$srcs = Dir.glob(File.join($srcdir, "*.c"))
+$srcs += [
+  "upb/decode.c",
+  "upb/encode.c",
+  "upb/msg.c",
+  "upb/table.c",
+  "upb/upb.c",
+  "third_party/utf8_range/naive.c",
+  "third_party/utf8_range/range2-neon.c",
+  "third_party/utf8_range/range2-sse.c"
+].map { |f| File.join($srcdir, "vendor/upb", f) }
+$VPATH << "$(srcdir)/vendor/upb/upb"
+$VPATH << "$(srcdir)/vendor/upb/third_party/utf8_range"
+$INCFLAGS << " -I#{File.join($srcdir, "vendor/upb")}"
+
+# Include the vendored Backtracie header too
+$INCFLAGS << " -I#{File.join($srcdir, 'vendor/backtracie')}"
+
+dir_config("ruby")
+
+create_header
+create_makefile "ruby_memprofiler_pprof_ext"

data/ext/ruby_memprofiler_pprof_ext/pprof.upb.c

@@ -0,0 +1,199 @@
+/* This file was generated by upbc (the upb compiler) from the input
+ * file:
+ *
+ *     pprof.proto
+ *
+ * Do not edit -- your changes will be discarded when the file is
+ * regenerated. */
+
+#include "pprof.upb.h"
+#include "upb/msg_internal.h"
+#include <stddef.h>
+
+#include "upb/port_def.inc"
+
+static const upb_MiniTable_Sub perftools_profiles_Profile_submsgs[6] = {
+    {.submsg = &perftools_profiles_ValueType_msginit}, {.submsg = &perftools_profiles_Sample_msginit},
+    {.submsg = &perftools_profiles_Mapping_msginit},   {.submsg = &perftools_profiles_Location_msginit},
+    {.submsg = &perftools_profiles_Function_msginit},  {.submsg = &perftools_profiles_ValueType_msginit},
+};
+
+static const upb_MiniTable_Field perftools_profiles_Profile__fields[14] = {
+    {1, UPB_SIZE(4, 8), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+    {2, UPB_SIZE(8, 16), UPB_SIZE(0, 0), 1, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+    {3, UPB_SIZE(12, 24), UPB_SIZE(0, 0), 2, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+    {4, UPB_SIZE(16, 32), UPB_SIZE(0, 0), 3, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+    {5, UPB_SIZE(20, 40), UPB_SIZE(0, 0), 4, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+    {6, UPB_SIZE(24, 48), UPB_SIZE(0, 0), kUpb_NoSub, 9,
+     kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+    {7, UPB_SIZE(40, 72), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {8, UPB_SIZE(48, 80), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {9, UPB_SIZE(56, 88), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {10, UPB_SIZE(64, 96), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {11, UPB_SIZE(28, 56), UPB_SIZE(1, 1), 5, 11,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+    {12, UPB_SIZE(72, 104), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {13, UPB_SIZE(32, 64), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Array | kUpb_LabelFlags_IsPacked | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+    {14, UPB_SIZE(80, 112), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable perftools_profiles_Profile_msginit = {
+    &perftools_profiles_Profile_submsgs[0],
+    &perftools_profiles_Profile__fields[0],
+    UPB_SIZE(88, 120),
+    14,
+    kUpb_ExtMode_NonExtendable,
+    14,
+    255,
+    0,
+};
+
+static const upb_MiniTable_Field perftools_profiles_ValueType__fields[2] = {
+    {1, UPB_SIZE(0, 0), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {2, UPB_SIZE(8, 8), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable perftools_profiles_ValueType_msginit = {
+    NULL, &perftools_profiles_ValueType__fields[0], UPB_SIZE(16, 24), 2, kUpb_ExtMode_NonExtendable, 2, 255, 0,
+};
+
+static const upb_MiniTable_Sub perftools_profiles_Sample_submsgs[1] = {
+    {.submsg = &perftools_profiles_Label_msginit},
+};
+
+static const upb_MiniTable_Field perftools_profiles_Sample__fields[3] = {
+    {1, UPB_SIZE(0, 0), UPB_SIZE(0, 0), kUpb_NoSub, 4,
+     kUpb_FieldMode_Array | kUpb_LabelFlags_IsPacked | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+    {2, UPB_SIZE(4, 8), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Array | kUpb_LabelFlags_IsPacked | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+    {3, UPB_SIZE(8, 16), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable perftools_profiles_Sample_msginit = {
+    &perftools_profiles_Sample_submsgs[0],
+    &perftools_profiles_Sample__fields[0],
+    UPB_SIZE(12, 24),
+    3,
+    kUpb_ExtMode_NonExtendable,
+    3,
+    255,
+    0,
+};
+
+static const upb_MiniTable_Field perftools_profiles_Label__fields[4] = {
+    {1, UPB_SIZE(0, 0), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {2, UPB_SIZE(8, 8), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {3, UPB_SIZE(16, 16), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {4, UPB_SIZE(24, 24), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable perftools_profiles_Label_msginit = {
+    NULL, &perftools_profiles_Label__fields[0], UPB_SIZE(32, 40), 4, kUpb_ExtMode_NonExtendable, 4, 255, 0,
+};
+
+static const upb_MiniTable_Field perftools_profiles_Mapping__fields[10] = {
+    {1, UPB_SIZE(8, 8), UPB_SIZE(0, 0), kUpb_NoSub, 4,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {2, UPB_SIZE(16, 16), UPB_SIZE(0, 0), kUpb_NoSub, 4,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {3, UPB_SIZE(24, 24), UPB_SIZE(0, 0), kUpb_NoSub, 4,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {4, UPB_SIZE(32, 32), UPB_SIZE(0, 0), kUpb_NoSub, 4,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {5, UPB_SIZE(40, 40), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {6, UPB_SIZE(48, 48), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {7, UPB_SIZE(0, 0), UPB_SIZE(0, 0), kUpb_NoSub, 8,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+    {8, UPB_SIZE(1, 1), UPB_SIZE(0, 0), kUpb_NoSub, 8,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+    {9, UPB_SIZE(2, 2), UPB_SIZE(0, 0), kUpb_NoSub, 8,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+    {10, UPB_SIZE(3, 3), UPB_SIZE(0, 0), kUpb_NoSub, 8,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable perftools_profiles_Mapping_msginit = {
+    NULL, &perftools_profiles_Mapping__fields[0], UPB_SIZE(56, 56), 10, kUpb_ExtMode_NonExtendable, 10, 255, 0,
+};
+
+static const upb_MiniTable_Sub perftools_profiles_Location_submsgs[1] = {
+    {.submsg = &perftools_profiles_Line_msginit},
+};
+
+static const upb_MiniTable_Field perftools_profiles_Location__fields[5] = {
+    {1, UPB_SIZE(8, 16), UPB_SIZE(0, 0), kUpb_NoSub, 4,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {2, UPB_SIZE(16, 24), UPB_SIZE(0, 0), kUpb_NoSub, 4,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {3, UPB_SIZE(24, 32), UPB_SIZE(0, 0), kUpb_NoSub, 4,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {4, UPB_SIZE(4, 8), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+    {5, UPB_SIZE(0, 0), UPB_SIZE(0, 0), kUpb_NoSub, 8,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable perftools_profiles_Location_msginit = {
+    &perftools_profiles_Location_submsgs[0],
+    &perftools_profiles_Location__fields[0],
+    UPB_SIZE(32, 40),
+    5,
+    kUpb_ExtMode_NonExtendable,
+    5,
+    255,
+    0,
+};
+
+static const upb_MiniTable_Field perftools_profiles_Line__fields[2] = {
+    {1, UPB_SIZE(0, 0), UPB_SIZE(0, 0), kUpb_NoSub, 4,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {2, UPB_SIZE(8, 8), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable perftools_profiles_Line_msginit = {
+    NULL, &perftools_profiles_Line__fields[0], UPB_SIZE(16, 24), 2, kUpb_ExtMode_NonExtendable, 2, 255, 0,
+};
+
+static const upb_MiniTable_Field perftools_profiles_Function__fields[5] = {
+    {1, UPB_SIZE(0, 0), UPB_SIZE(0, 0), kUpb_NoSub, 4,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {2, UPB_SIZE(8, 8), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {3, UPB_SIZE(16, 16), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {4, UPB_SIZE(24, 24), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+    {5, UPB_SIZE(32, 32), UPB_SIZE(0, 0), kUpb_NoSub, 3,
+     kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable perftools_profiles_Function_msginit = {
+    NULL, &perftools_profiles_Function__fields[0], UPB_SIZE(40, 40), 5, kUpb_ExtMode_NonExtendable, 5, 255, 0,
+};
+
+static const upb_MiniTable *messages_layout[8] = {
+    &perftools_profiles_Profile_msginit, &perftools_profiles_ValueType_msginit, &perftools_profiles_Sample_msginit,
+    &perftools_profiles_Label_msginit,   &perftools_profiles_Mapping_msginit,   &perftools_profiles_Location_msginit,
+    &perftools_profiles_Line_msginit,    &perftools_profiles_Function_msginit,
+};
+
+const upb_MiniTable_File pprof_proto_upb_file_layout = {
+    messages_layout, NULL, NULL, 8, 0, 0,
+};
+
+#include "upb/port_undef.inc"