ruby-prof 1.7.1 → 2.0.0

data/ext/ruby_prof/rp_measure_allocations.c

@@ -1,47 +1,47 @@
-/* Copyright (C) 2005-2013 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
-   Please see the LICENSE file for copyright and distribution information */
-
-/* :nodoc: */
-
-#include "rp_measurement.h"
-
-static VALUE cMeasureAllocations;
-VALUE total_allocated_objects_key;
-
-static double measure_allocations(rb_trace_arg_t* trace_arg)
-{
-    static double result = 0;
-
-    if (trace_arg)
-    {
-        // Only process creation of new objects
-        rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
-        if (event == RUBY_INTERNAL_EVENT_NEWOBJ) {
-            // Don't count allocations of internal IMemo objects
-            VALUE object = rb_tracearg_object(trace_arg);
-            if (BUILTIN_TYPE(object) != T_IMEMO)
-                result++;
-        }
-    }
-    return result;
-}
-
-prof_measurer_t* prof_measurer_allocations(bool track_allocations)
-{
-    prof_measurer_t* measure = ALLOC(prof_measurer_t);
-    measure->mode = MEASURE_ALLOCATIONS;
-    measure->measure = measure_allocations;
-    measure->multiplier = 1;
-    // Need to track allocations to get RUBY_INTERNAL_EVENT_NEWOBJ event
-    measure->track_allocations = track_allocations;
-
-    return measure;
-}
-
-void rp_init_measure_allocations(void)
-{
-    total_allocated_objects_key = ID2SYM(rb_intern("total_allocated_objects"));
-    rb_define_const(mProf, "ALLOCATIONS", INT2NUM(MEASURE_ALLOCATIONS));
-
-    cMeasureAllocations = rb_define_class_under(mMeasure, "Allocations", rb_cObject);
-}
+/* Copyright (C) 2005-2013 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+/* :nodoc: */
+
+#include "rp_measurement.h"
+
+static VALUE cMeasureAllocations;
+VALUE total_allocated_objects_key;
+
+static double measure_allocations(rb_trace_arg_t* trace_arg)
+{
+    static double result = 0;
+
+    if (trace_arg)
+    {
+        // Only process creation of new objects
+        rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
+        if (event == RUBY_INTERNAL_EVENT_NEWOBJ) {
+            // Don't count allocations of internal IMemo objects
+            VALUE object = rb_tracearg_object(trace_arg);
+            if (BUILTIN_TYPE(object) != T_IMEMO)
+                result++;
+        }
+    }
+    return result;
+}
+
+prof_measurer_t* prof_measurer_allocations(bool track_allocations)
+{
+    prof_measurer_t* measure = ALLOC(prof_measurer_t);
+    measure->mode = MEASURE_ALLOCATIONS;
+    measure->measure = measure_allocations;
+    measure->multiplier = 1;
+    // Need to track allocations to get RUBY_INTERNAL_EVENT_NEWOBJ event
+    measure->track_allocations = true;
+
+    return measure;
+}
+
+void rp_init_measure_allocations(void)
+{
+    total_allocated_objects_key = ID2SYM(rb_intern("total_allocated_objects"));
+    rb_define_const(mProf, "ALLOCATIONS", INT2NUM(MEASURE_ALLOCATIONS));
+
+    cMeasureAllocations = rb_define_class_under(mMeasure, "Allocations", rb_cObject);
+}

data/ext/ruby_prof/rp_measure_process_time.c

@@ -1,66 +1,64 @@
-/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
-   Please see the LICENSE file for copyright and distribution information */
-
-#include "rp_measurement.h"
-#include <time.h>
-
-static VALUE cMeasureProcessTime;
-
-static double measure_process_time(rb_trace_arg_t* trace_arg)
-{
-#if defined(_WIN32)
-    FILETIME  createTime;
-    FILETIME  exitTime;
-    FILETIME  kernelTime;
-    FILETIME  userTime;
-
-    ULARGE_INTEGER kernelTimeInt;
-    ULARGE_INTEGER userTimeInt;
-
-    GetProcessTimes(GetCurrentProcess(), &createTime, &exitTime, &kernelTime, &userTime);
-
-    kernelTimeInt.LowPart = kernelTime.dwLowDateTime;
-    kernelTimeInt.HighPart = kernelTime.dwHighDateTime;
-    userTimeInt.LowPart = userTime.dwLowDateTime;
-    userTimeInt.HighPart = userTime.dwHighDateTime;
-
-    return (double)(kernelTimeInt.QuadPart + userTimeInt.QuadPart);
-#elif !defined(CLOCK_PROCESS_CPUTIME_ID)
-    #include <sys/resource.h>
-    struct rusage usage;
-    getrusage(RUSAGE_SELF, &usage);
-    return usage.ru_stime.tv_sec + usage.ru_utime.tv_sec + ((usage.ru_stime.tv_usec + usage.ru_utime.tv_usec) / 1000000.0);
-#else
-    struct timespec clock;
-    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &clock);
-    return clock.tv_sec + (clock.tv_nsec / 1000000000.0);
-#endif
-}
-
-static double multiplier_process_time(void)
-{
-#if defined(_WIN32)
-    // Times are in 100-nanosecond time units.  So instead of 10-9 use 10-7
-    return 1.0 / 10000000.0;
-#else
-    return 1.0;
-#endif
-}
-
-prof_measurer_t* prof_measurer_process_time(bool track_allocations)
-{
-    prof_measurer_t* measure = ALLOC(prof_measurer_t);
-    measure->mode = MEASURE_PROCESS_TIME;
-    measure->measure = measure_process_time;
-    measure->multiplier = multiplier_process_time();
-    measure->track_allocations = track_allocations;
-    return measure;
-}
-
-void rp_init_measure_process_time(void)
-{
-    rb_define_const(mProf, "CLOCKS_PER_SEC", INT2NUM(CLOCKS_PER_SEC));
-    rb_define_const(mProf, "PROCESS_TIME", INT2NUM(MEASURE_PROCESS_TIME));
-
-    cMeasureProcessTime = rb_define_class_under(mMeasure, "ProcessTime", rb_cObject);
-}
+/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#include "rp_measurement.h"
+
+#if !defined(_WIN32)
+#include <time.h>
+#endif
+
+static VALUE cMeasureProcessTime;
+
+static double measure_process_time(rb_trace_arg_t* trace_arg)
+{
+#if defined(_WIN32)
+    FILETIME  createTime;
+    FILETIME  exitTime;
+    FILETIME  kernelTime;
+    FILETIME  userTime;
+
+    ULARGE_INTEGER kernelTimeInt;
+    ULARGE_INTEGER userTimeInt;
+
+    GetProcessTimes(GetCurrentProcess(), &createTime, &exitTime, &kernelTime, &userTime);
+
+    kernelTimeInt.LowPart = kernelTime.dwLowDateTime;
+    kernelTimeInt.HighPart = kernelTime.dwHighDateTime;
+    userTimeInt.LowPart = userTime.dwLowDateTime;
+    userTimeInt.HighPart = userTime.dwHighDateTime;
+
+    return (double)(kernelTimeInt.QuadPart + userTimeInt.QuadPart);
+#else
+    struct timespec clock;
+    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &clock);
+    return clock.tv_sec + (clock.tv_nsec / 1000000000.0);
+#endif
+}
+
+static double multiplier_process_time(void)
+{
+#if defined(_WIN32)
+    // Times are in 100-nanosecond time units.  So instead of 10-9 use 10-7
+    return 1.0 / 10000000.0;
+#else
+    return 1.0;
+#endif
+}
+
+prof_measurer_t* prof_measurer_process_time(bool track_allocations)
+{
+    prof_measurer_t* measure = ALLOC(prof_measurer_t);
+    measure->mode = MEASURE_PROCESS_TIME;
+    measure->measure = measure_process_time;
+    measure->multiplier = multiplier_process_time();
+    measure->track_allocations = track_allocations;
+    return measure;
+}
+
+void rp_init_measure_process_time(void)
+{
+    rb_define_const(mProf, "CLOCKS_PER_SEC", INT2NUM(CLOCKS_PER_SEC));
+    rb_define_const(mProf, "PROCESS_TIME", INT2NUM(MEASURE_PROCESS_TIME));
+
+    cMeasureProcessTime = rb_define_class_under(mMeasure, "ProcessTime", rb_cObject);
+}

data/ext/ruby_prof/rp_measure_wall_time.c

@@ -1,64 +1,52 @@
-/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
-   Please see the LICENSE file for copyright and distribution information */
-
-   /* :nodoc: */
-#include "rp_measurement.h"
-
-#if defined(__APPLE__)
-#include <mach/mach_time.h>
-#elif !defined(_WIN32)
-#include <time.h>
-#endif
-
-static VALUE cMeasureWallTime;
-
-static double measure_wall_time(rb_trace_arg_t* trace_arg)
-{
-#if defined(_WIN32)
-    LARGE_INTEGER time;
-    QueryPerformanceCounter(&time);
-    return (double)time.QuadPart;
-#elif defined(__APPLE__)
-    return mach_absolute_time();// * (uint64_t)mach_timebase.numer / (uint64_t)mach_timebase.denom;
-#elif defined(__linux__)
-    struct timespec tv;
-    clock_gettime(CLOCK_MONOTONIC, &tv);
-    return tv.tv_sec + (tv.tv_nsec / 1000000000.0);
-#else
-    struct timeval tv;
-    gettimeofday(&tv, NULL);
-    return tv.tv_sec + (tv.tv_usec / 1000000.0);
-#endif
-}
-
-static double multiplier_wall_time(void)
-{
-#if defined(_WIN32)
-    LARGE_INTEGER frequency;
-    QueryPerformanceFrequency(&frequency);
-    return 1.0 / frequency.QuadPart;
-#elif defined(__APPLE__)
-    mach_timebase_info_data_t mach_timebase;
-    mach_timebase_info(&mach_timebase);
-    return (uint64_t)mach_timebase.numer / (uint64_t)mach_timebase.denom / 1000000000.0;
-#else
-    return 1.0;
-#endif
-}
-
-prof_measurer_t* prof_measurer_wall_time(bool track_allocations)
-{
-    prof_measurer_t* measure = ALLOC(prof_measurer_t);
-    measure->mode = MEASURE_WALL_TIME;
-    measure->measure = measure_wall_time;
-    measure->multiplier = multiplier_wall_time();
-    measure->track_allocations = track_allocations;
-    return measure;
-}
-
-void rp_init_measure_wall_time(void)
-{
-    rb_define_const(mProf, "WALL_TIME", INT2NUM(MEASURE_WALL_TIME));
-
-    cMeasureWallTime = rb_define_class_under(mMeasure, "WallTime", rb_cObject);
-}
+/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+   /* :nodoc: */
+#include "rp_measurement.h"
+
+#if !defined(_WIN32)
+#include <time.h>
+#endif
+
+static VALUE cMeasureWallTime;
+
+static double measure_wall_time(rb_trace_arg_t* trace_arg)
+{
+#if defined(_WIN32)
+    LARGE_INTEGER time;
+    QueryPerformanceCounter(&time);
+    return (double)time.QuadPart;
+#else
+    struct timespec tv;
+    clock_gettime(CLOCK_MONOTONIC, &tv);
+    return tv.tv_sec + (tv.tv_nsec / 1000000000.0);
+#endif
+}
+
+static double multiplier_wall_time(void)
+{
+#if defined(_WIN32)
+    LARGE_INTEGER frequency;
+    QueryPerformanceFrequency(&frequency);
+    return 1.0 / frequency.QuadPart;
+#else
+    return 1.0;
+#endif
+}
+
+prof_measurer_t* prof_measurer_wall_time(bool track_allocations)
+{
+    prof_measurer_t* measure = ALLOC(prof_measurer_t);
+    measure->mode = MEASURE_WALL_TIME;
+    measure->measure = measure_wall_time;
+    measure->multiplier = multiplier_wall_time();
+    measure->track_allocations = track_allocations;
+    return measure;
+}
+
+void rp_init_measure_wall_time(void)
+{
+    rb_define_const(mProf, "WALL_TIME", INT2NUM(MEASURE_WALL_TIME));
+
+    cMeasureWallTime = rb_define_class_under(mMeasure, "WallTime", rb_cObject);
+}

data/ext/ruby_prof/rp_measurement.c

@@ -7,12 +7,10 @@ VALUE mMeasure;
 VALUE cRpMeasurement;
 
 prof_measurer_t* prof_measurer_allocations(bool track_allocations);
-prof_measurer_t* prof_measurer_memory(bool track_allocations);
 prof_measurer_t* prof_measurer_process_time(bool track_allocations);
 prof_measurer_t* prof_measurer_wall_time(bool track_allocations);
 
 void rp_init_measure_allocations(void);
-void rp_init_measure_memory(void);
 void rp_init_measure_process_time(void);
 void rp_init_measure_wall_time(void);
 
@@ -26,8 +24,6 @@ prof_measurer_t* prof_measurer_create(prof_measure_mode_t measure, bool track_al
         return prof_measurer_process_time(track_allocations);
     case MEASURE_ALLOCATIONS:
         return prof_measurer_allocations(track_allocations);
-    case MEASURE_MEMORY:
-        return prof_measurer_memory(track_allocations);
     default:
         rb_raise(rb_eArgError, "Unknown measure mode: %d", measure);
     }
@@ -342,7 +338,6 @@ void rp_init_measure(void)
     rp_init_measure_wall_time();
     rp_init_measure_process_time();
     rp_init_measure_allocations();
-    rp_init_measure_memory();
 
     cRpMeasurement = rb_define_class_under(mProf, "Measurement", rb_cObject);
     rb_define_alloc_func(cRpMeasurement, prof_measurement_allocate);

data/ext/ruby_prof/rp_measurement.h

@@ -1,53 +1,49 @@
-/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
-   Please see the LICENSE file for copyright and distribution information */
-
-#ifndef __rp_measurementMENT_H__
-#define __rp_measurementMENT_H__
-
-#include "ruby_prof.h"
-
-extern VALUE mMeasure;
-
-typedef double (*get_measurement)(rb_trace_arg_t* trace_arg);
-
-typedef enum
-{
-    MEASURE_WALL_TIME,
-    MEASURE_PROCESS_TIME,
-    MEASURE_ALLOCATIONS,
-    MEASURE_MEMORY
-} prof_measure_mode_t;
-
-typedef struct prof_measurer_t
-{
-    get_measurement measure;
-    prof_measure_mode_t mode;
-    double multiplier;
-    bool track_allocations;
-} prof_measurer_t;
-
-/* Callers and callee information for a method. */
-typedef struct prof_measurement_t
-{
-    prof_owner_t owner;
-    double total_time;
-    double self_time;
-    double wait_time;
-    int called;
-    VALUE object;
-} prof_measurement_t;
-
-prof_measurer_t* prof_measurer_create(prof_measure_mode_t measure, bool track_allocations);
-double prof_measure(prof_measurer_t* measurer, rb_trace_arg_t* trace_arg);
-
-prof_measurement_t* prof_measurement_create(void);
-prof_measurement_t* prof_measurement_copy(prof_measurement_t* other);
-void prof_measurement_free(prof_measurement_t* measurement);
-VALUE prof_measurement_wrap(prof_measurement_t* measurement);
-prof_measurement_t* prof_get_measurement(VALUE self);
-void prof_measurement_mark(void* data);
-void prof_measurement_merge_internal(prof_measurement_t* destination, prof_measurement_t* other);
-
-void rp_init_measure(void);
-
-#endif //__rp_measurementMENT_H__
+/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#pragma once
+
+#include "ruby_prof.h"
+
+extern VALUE mMeasure;
+
+typedef double (*get_measurement)(rb_trace_arg_t* trace_arg);
+
+typedef enum
+{
+    MEASURE_WALL_TIME,
+    MEASURE_PROCESS_TIME,
+    MEASURE_ALLOCATIONS
+} prof_measure_mode_t;
+
+typedef struct prof_measurer_t
+{
+    get_measurement measure;
+    prof_measure_mode_t mode;
+    double multiplier;
+    bool track_allocations;
+} prof_measurer_t;
+
+/* Callers and callee information for a method. */
+typedef struct prof_measurement_t
+{
+    prof_owner_t owner;
+    double total_time;
+    double self_time;
+    double wait_time;
+    int called;
+    VALUE object;
+} prof_measurement_t;
+
+prof_measurer_t* prof_measurer_create(prof_measure_mode_t measure, bool track_allocations);
+double prof_measure(prof_measurer_t* measurer, rb_trace_arg_t* trace_arg);
+
+prof_measurement_t* prof_measurement_create(void);
+prof_measurement_t* prof_measurement_copy(prof_measurement_t* other);
+void prof_measurement_free(prof_measurement_t* measurement);
+VALUE prof_measurement_wrap(prof_measurement_t* measurement);
+prof_measurement_t* prof_get_measurement(VALUE self);
+void prof_measurement_mark(void* data);
+void prof_measurement_merge_internal(prof_measurement_t* destination, prof_measurement_t* other);
+
+void rp_init_measure(void);