ruby_memprofiler_pprof 0.0.1

data/ext/ruby_memprofiler_pprof/compat.c

@@ -0,0 +1,182 @@
+#include <errno.h>
+#include <ruby.h>
+#include <pthread.h>
+#include <stdarg.h>
+#include <stdlib.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
+
+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 = malloc(sz);
+    if (!mem) {
+        MPP_ASSERT_FAIL("failed to allocate memory in ruby_memprofiler_pprof gem");
+    }
+    return mem;
+}
+
+void mpp_free(void *mem) {
+    free(mem);
+}
+
+void *mpp_realloc(void *mem, size_t newsz) {
+    void *newmem = realloc(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/extconf.rb

@@ -0,0 +1,72 @@
+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
+
+# Peek into internal Ruby headers
+require 'debase/ruby_core_source'
+internal_headers = proc {
+  have_header("vm_core.h") and
+    have_header("iseq.h", ["vm_core.h"]) and
+    have_header("version.h")
+}
+
+# Need to actually link pthreads properly
+have_library("pthread") or raise "missing pthread library"
+
+# 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
+])
+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',
+])
+
+# 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")}"
+
+dir_config('ruby')
+extname = "ruby_memprofiler_pprof/ruby_memprofiler_pprof_ext"
+unless Debase::RubyCoreSource.create_makefile_with_core(internal_headers, extname)
+  STDERR.print("Makefile creation failed\n")
+  STDERR.print("*************************************************************\n\n")
+  STDERR.print("  NOTE: If your headers were not found, try passing\n")
+  STDERR.print("        --with-ruby-include=PATH_TO_HEADERS      \n\n")
+  STDERR.print("*************************************************************\n\n")
+  exit(1)
+end

data/ext/ruby_memprofiler_pprof/pprof.upb.c

@@ -0,0 +1,170 @@
+/* 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 <stddef.h>
+#include "upb/msg_internal.h"
+#include "pprof.upb.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"
+