ruby_memprofiler_pprof 0.0.3 → 0.0.4

data/ext/ruby_memprofiler_pprof/compat.c

@@ -1,182 +0,0 @@
-#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

@@ -1,72 +0,0 @@
-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

@@ -1,170 +0,0 @@
-/* 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"
-