ruby-prof 0.13.1 → 1.4.2

data/ext/ruby_prof/rp_call_trees.h

@@ -0,0 +1,28 @@
+/* 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 */
+
+#ifndef __RP_CALL_TREES_H__
+#define __RP_CALL_TREES_H__
+
+#include "ruby_prof.h"
+#include "rp_call_tree.h"
+
+   /* Array of call_tree objects */
+typedef struct prof_call_trees_t
+{
+    prof_call_tree_t** start;
+    prof_call_tree_t** end;
+    prof_call_tree_t** ptr;
+
+    VALUE object;
+} prof_call_trees_t;
+
+
+void rp_init_call_trees();
+prof_call_trees_t* prof_call_trees_create();
+void prof_call_trees_free(prof_call_trees_t* call_trees);
+prof_call_trees_t* prof_get_call_trees(VALUE self);
+void prof_add_call_tree(prof_call_trees_t* call_trees, prof_call_tree_t* call_tree);
+VALUE prof_call_trees_wrap(prof_call_trees_t* call_trees);
+
+#endif //__RP_CALL_TREES_H__

data/ext/ruby_prof/rp_measure_allocations.c

@@ -1,65 +1,50 @@
-/* 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 "ruby_prof.h"
-
-static VALUE cMeasureAllocations;
-
-#if defined(HAVE_RB_OS_ALLOCATED_OBJECTS)
-  unsigned LONG_LONG rb_os_allocated_objects();
-#endif
-
-#if defined(HAVE_RB_GC_MALLOC_ALLOCATIONS)
-  unsigned LONG_LONG rb_gc_malloc_allocations();
-#endif
-
-static double
-measure_allocations()
-{
-#if defined(HAVE_RB_OS_ALLOCATED_OBJECTS)
-#define MEASURE_ALLOCATIONS_ENABLED Qtrue
-    return rb_os_allocated_objects();
-
-#elif defined(HAVE_RB_GC_MALLOC_ALLOCATIONS)
-#define MEASURE_ALLOCATIONS_ENABLED Qtrue
-    return rb_gc_malloc_allocations();
-
-#else
-#define MEASURE_ALLOCATIONS_ENABLED Qfalse
-    return 0;
-#endif
-}
-
-
-prof_measurer_t* prof_measurer_allocations()
-{
-  prof_measurer_t* measure = ALLOC(prof_measurer_t);
-  measure->measure = measure_allocations;
-  return measure;
-}
-
-/* call-seq:
-     measure -> int
-
-Returns the number of Ruby object allocations. */
-
-static VALUE
-prof_measure_allocations(VALUE self)
-{
-#if defined(HAVE_LONG_LONG)
-    return ULL2NUM(measure_allocations());
-#else
-    return ULONG2NUM(measure_allocations());
-#endif
-}
-
-void rp_init_measure_allocations()
-{
-    rb_define_const(mProf, "ALLOCATIONS", INT2NUM(MEASURE_ALLOCATIONS));
-    rb_define_const(mProf, "ALLOCATIONS_ENABLED", MEASURE_ALLOCATIONS_ENABLED);
-
-    cMeasureAllocations = rb_define_class_under(mMeasure, "Allocations", rb_cObject);
-    rb_define_singleton_method(cMeasureAllocations, "measure", prof_measure_allocations, 0);    
-}
+/* 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_via_gc_stats(rb_trace_arg_t* trace_arg)
+{
+    return (double)rb_gc_stat(total_allocated_objects_key);
+}
+
+static double measure_allocations_via_tracing(rb_trace_arg_t* trace_arg)
+{
+    static double result = 0;
+
+    if (trace_arg)
+    {
+        rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
+        if (event == RUBY_INTERNAL_EVENT_NEWOBJ)
+            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->multiplier = 1;
+    measure->track_allocations = track_allocations;
+
+    if (track_allocations)
+        measure->measure = measure_allocations_via_tracing;
+    else
+        measure->measure = measure_allocations_via_gc_stats;
+
+    return measure;
+}
+
+void rp_init_measure_allocations()
+{
+    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_memory.c

@@ -1,73 +1,42 @@
-/* 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 "ruby_prof.h"
-
-static VALUE cMeasureMemory;
-
-
-#if defined(HAVE_RB_GC_ALLOCATED_SIZE)
-  VALUE rb_gc_allocated_size();
-#endif
-
-#if defined(HAVE_RB_GC_MALLOC_ALLOCATED_SIZE)
-  size_t rb_gc_malloc_allocated_size();
-#endif
-
-#if defined(HAVE_RB_HEAP_TOTAL_MEM)
-  //FIXME: did not find the patch to check prototype, assuming it to return size_t
-  size_t rb_heap_total_mem();
-#endif
-
-static double
-measure_memory()
-{
-#if defined(HAVE_RB_GC_ALLOCATED_SIZE)
-#define MEASURE_MEMORY_ENABLED Qtrue
-#if defined(HAVE_LONG_LONG)
-    return NUM2LL(rb_gc_allocated_size()) / 1024.0;
-#else
-    return NUM2ULONG(rb_gc_allocated_size()) / 1024.0;
-#endif
-
-#elif defined(HAVE_RB_GC_MALLOC_ALLOCATED_SIZE)
-#define MEASURE_MEMORY_ENABLED Qtrue
-    return rb_gc_malloc_allocated_size() / 1024.0;
-
-#elif defined(HAVE_RB_HEAP_TOTAL_MEM)
-#define MEASURE_MEMORY_ENABLED Qtrue
-    return rb_heap_total_mem() / 1024.0;
-
-#else
-#define MEASURE_MEMORY_ENABLED Qfalse
-    return 0;
-#endif
-}
-
-prof_measurer_t* prof_measurer_memory()
-{
-  prof_measurer_t* measure = ALLOC(prof_measurer_t);
-  measure->measure = measure_memory;
-  return measure;
-}
-
-/* call-seq:
-   measure_process_time -> float
-
-Returns the process time.*/
-static VALUE
-prof_measure_memory(VALUE self)
-{
-    return rb_float_new(measure_memory());
-}
-
-void rp_init_measure_memory()
-{
-    rb_define_const(mProf, "MEMORY", INT2NUM(MEASURE_MEMORY));
-    rb_define_const(mProf, "MEMORY_ENABLED", MEASURE_MEMORY_ENABLED);
-
-    cMeasureMemory = rb_define_class_under(mMeasure, "Memory", rb_cObject);
-    rb_define_singleton_method(cMeasureMemory, "measure", prof_measure_memory, 0);
-}
+/* 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 cMeasureMemory;
+
+static double
+measure_memory_via_tracing(rb_trace_arg_t* trace_arg)
+{
+    static double result = 0;
+
+    if (trace_arg)
+    {
+        rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
+        if (event == RUBY_INTERNAL_EVENT_NEWOBJ)
+        {
+            VALUE object = rb_tracearg_object(trace_arg);
+            result += rb_obj_memsize_of(object);
+        }
+    }
+    return result;
+}
+
+prof_measurer_t* prof_measurer_memory(bool track_allocations)
+{
+  prof_measurer_t* measure = ALLOC(prof_measurer_t);
+  measure->mode = MEASURE_MEMORY;
+  measure->measure = measure_memory_via_tracing;
+  measure->multiplier = 1;
+  measure->track_allocations = true;
+  return measure;
+}
+
+void rp_init_measure_memory()
+{
+    rb_define_const(mProf, "MEMORY", INT2NUM(MEASURE_MEMORY));
+
+    cMeasureMemory = rb_define_class_under(mMeasure, "Allocations", rb_cObject);
+}

data/ext/ruby_prof/rp_measure_process_time.c

@@ -1,71 +1,65 @@
-/* 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 */
-
-#include "ruby_prof.h"
-#include <time.h>
-
-static VALUE cMeasureProcessTime;
-
-static double
-measure_process_time()
-{
-#if defined(__linux__)
-    struct timespec clock;
-    clock_gettime(CLOCK_PROCESS_CPUTIME_ID , &clock);
-    return clock.tv_sec + (clock.tv_nsec/1000000000.0);
-#elif defined(_win32)
-	FILETIME createTime;
-	FILETIME exitTime;
-	FILETIME sysTime;
-	FILETIME cpuTime;
-
-	ULARGE_INTEGER sysTimeInt;
-	ULARGE_INTEGER cpuTimeInt;
-	ULONGLONG totalTime;
-
-	GetProcessTimes(GetCurrentProcess(), &createTime, &exitTime, &sysTime, &cpuTime); 
-
-	/* Doing this based on MSFT's recommendation in the FILETIME structure documentation at
-	  http://msdn.microsoft.com/en-us/library/ms724284%28VS.85%29.aspx*/
-
-	sysTimeInt.LowPart = sysTime.dwLowDateTime;
-	sysTimeInt.HighPart = sysTime.dwHighDateTime;
-	cpuTimeInt.LowPart = cpuTime.dwLowDateTime;
-	cpuTimeInt.HighPart = cpuTime.dwHighDateTime;
-
-	totalTime = sysTimeInt.QuadPart + cpuTimeInt.QuadPart;
-
-	// Times are in 100-nanosecond time units.  So instead of 10-9 use 10-7
-	return totalTime / 10000000.0;
-#else
-    return ((double)clock()) / CLOCKS_PER_SEC;
-#endif
-}
-
-/* call-seq:
-   measure_process_time -> float
-
-Returns the process time.*/
-static VALUE
-prof_measure_process_time(VALUE self)
-{
-    return rb_float_new(measure_process_time());
-}
-
-prof_measurer_t* prof_measurer_process_time()
-{
-  prof_measurer_t* measure = ALLOC(prof_measurer_t);
-  measure->measure = measure_process_time;
-  return measure;
-}
-
-
-void rp_init_measure_process_time()
-{
-    rb_define_const(mProf, "CLOCKS_PER_SEC", INT2NUM(CLOCKS_PER_SEC));
-    rb_define_const(mProf, "PROCESS_TIME", INT2NUM(MEASURE_PROCESS_TIME));
-	rb_define_const(mProf, "PROCESS_TIME_ENABLED", Qtrue);
-
-    cMeasureProcessTime = rb_define_class_under(mMeasure, "ProcessTime", rb_cObject);
-    rb_define_singleton_method(cMeasureProcessTime, "measure", prof_measure_process_time, 0);
-}
+/* 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  sysTime;
+    FILETIME  userTime;
+
+    ULARGE_INTEGER sysTimeInt;
+    ULARGE_INTEGER userTimeInt;
+
+    GetProcessTimes(GetCurrentProcess(), &createTime, &exitTime, &sysTime, &userTime);
+
+    sysTimeInt.LowPart = sysTime.dwLowDateTime;
+    sysTimeInt.HighPart = sysTime.dwHighDateTime;
+    userTimeInt.LowPart = userTime.dwLowDateTime;
+    userTimeInt.HighPart = userTime.dwHighDateTime;
+
+    return (double)(sysTimeInt.QuadPart + userTimeInt.QuadPart);
+#elif !defined(CLOCK_PROCESS_CPUTIME_ID)
+    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()
+{
+    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,42 +1,64 @@
-/* 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 "ruby_prof.h"
-
-static VALUE cMeasureWallTime;
-
-static double
-measure_wall_time()
-{
-    struct timeval tv;
-    gettimeofday(&tv, NULL);
-    return tv.tv_sec + (tv.tv_usec/1000000.0);
-}
-
-prof_measurer_t* prof_measurer_wall_time()
-{
-  prof_measurer_t* measure = ALLOC(prof_measurer_t);
-  measure->measure = measure_wall_time;
-  return measure;
-}
-
-/* Document-method: prof_measure_wall_time
-   call-seq:
-     measure_wall_time -> float
-
-Returns the wall time.*/
-static VALUE
-prof_measure_wall_time(VALUE self)
-{
-    return rb_float_new(measure_wall_time());
-}
-
-void rp_init_measure_wall_time()
-{
-    rb_define_const(mProf, "WALL_TIME", INT2NUM(MEASURE_WALL_TIME));
-    rb_define_const(mProf, "WALL_TIME_ENABLED", Qtrue);
-
-    cMeasureWallTime = rb_define_class_under(mMeasure, "WallTime", rb_cObject);
-    rb_define_singleton_method(cMeasureWallTime, "measure", prof_measure_wall_time, 0);
-}
+/* 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()
+{
+    rb_define_const(mProf, "WALL_TIME", INT2NUM(MEASURE_WALL_TIME));
+
+    cMeasureWallTime = rb_define_class_under(mMeasure, "WallTime", rb_cObject);
+}