ruby-prof 1.7.1 → 1.7.2

data/ext/ruby_prof/rp_stack.c

@@ -1,212 +1,212 @@
-/* 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_stack.h"
-
-#define INITIAL_STACK_SIZE 16
-
-// Creates a stack of prof_frame_t to keep track of timings for active methods.
-prof_stack_t* prof_stack_create(void)
-{
-    prof_stack_t* stack = ALLOC(prof_stack_t);
-    stack->start = ZALLOC_N(prof_frame_t, INITIAL_STACK_SIZE);
-    stack->ptr = stack->start;
-    stack->end = stack->start + INITIAL_STACK_SIZE;
-
-    return stack;
-}
-
-void prof_stack_free(prof_stack_t* stack)
-{
-    xfree(stack->start);
-    xfree(stack);
-}
-
-prof_frame_t* prof_stack_parent(prof_stack_t* stack)
-{
-    if (stack->ptr == stack->start || stack->ptr - 1 == stack->start)
-        return NULL;
-    else
-        return stack->ptr - 2;
-}
-
-prof_frame_t* prof_stack_last(prof_stack_t* stack)
-{
-    if (stack->ptr == stack->start)
-        return NULL;
-    else
-        return stack->ptr - 1;
-}
-
-void prof_stack_verify_size(prof_stack_t* stack)
-{
-    // Is there space on the stack?  If not, double its size.
-    if (stack->ptr == stack->end)
-    {
-        size_t len = stack->ptr - stack->start;
-        size_t new_capacity = (stack->end - stack->start) * 2;
-        REALLOC_N(stack->start, prof_frame_t, new_capacity);
-
-        /* Memory just got moved, reset pointers */
-        stack->ptr = stack->start + len;
-        stack->end = stack->start + new_capacity;
-    }
-}
-
-prof_frame_t* prof_stack_push(prof_stack_t* stack)
-{
-    prof_stack_verify_size(stack);
-
-    prof_frame_t* result = stack->ptr;
-    stack->ptr++;
-    return result;
-}
-
-prof_frame_t* prof_stack_pop(prof_stack_t* stack)
-{
-    prof_frame_t* result = prof_stack_last(stack);
-    if (result)
-        stack->ptr--;
-
-    return result;
-}
-
-// ----------------  Frame Methods  ----------------------------
-void prof_frame_pause(prof_frame_t* frame, double current_measurement)
-{
-    if (frame && prof_frame_is_unpaused(frame))
-        frame->pause_time = current_measurement;
-}
-
-void prof_frame_unpause(prof_frame_t* frame, double current_measurement)
-{
-    if (prof_frame_is_paused(frame))
-    {
-        frame->dead_time += (current_measurement - frame->pause_time);
-        frame->pause_time = -1;
-    }
-}
-
-prof_frame_t* prof_frame_current(prof_stack_t* stack)
-{
-    return prof_stack_last(stack);
-}
-
-prof_frame_t* prof_frame_push(prof_stack_t* stack, prof_call_tree_t* call_tree, double measurement, bool paused)
-{
-    prof_frame_t* result = prof_stack_push(stack);
-    prof_frame_t* parent_frame = prof_stack_parent(stack);
-
-    result->call_tree = call_tree;
-
-    result->start_time = measurement;
-    result->pause_time = -1; // init as not paused.
-    result->switch_time = 0;
-    result->wait_time = 0;
-    result->child_time = 0;
-    result->dead_time = 0;
-    result->source_file = Qnil;
-    result->source_line = 0;
-
-    call_tree->measurement->called++;
-    call_tree->visits++;
-
-    if (call_tree->method->visits > 0)
-    {
-        call_tree->method->recursive = true;
-    }
-    call_tree->method->measurement->called++;
-    call_tree->method->visits++;
-
-    // Unpause the parent frame, if it exists.
-    // If currently paused then:
-    //   1) The child frame will begin paused.
-    //   2) The parent will inherit the child's dead time.
-    if (parent_frame)
-        prof_frame_unpause(parent_frame, measurement);
-
-    if (paused)
-    {
-        prof_frame_pause(result, measurement);
-    }
-
-    // Return the result
-    return result;
-}
-
-prof_frame_t* prof_frame_unshift(prof_stack_t* stack, prof_call_tree_t* parent_call_tree, prof_call_tree_t* call_tree, double measurement)
-{
-    if (prof_stack_last(stack))
-        rb_raise(rb_eRuntimeError, "Stack unshift can only be called with an empty stack");
-
-    parent_call_tree->measurement->total_time = call_tree->measurement->total_time;
-    parent_call_tree->measurement->self_time = 0;
-    parent_call_tree->measurement->wait_time = call_tree->measurement->wait_time;
-
-    parent_call_tree->method->measurement->total_time += call_tree->measurement->total_time;
-    parent_call_tree->method->measurement->wait_time += call_tree->measurement->wait_time;
-
-    return prof_frame_push(stack, parent_call_tree, measurement, false);
-}
-
-prof_frame_t* prof_frame_pop(prof_stack_t* stack, double measurement)
-{
-    prof_frame_t* frame = prof_stack_pop(stack);
-
-    if (!frame)
-        return NULL;
-
-    /* Calculate the total time this method took */
-    prof_frame_unpause(frame, measurement);
-
-    double total_time = measurement - frame->start_time - frame->dead_time;
-    double self_time = total_time - frame->child_time - frame->wait_time;
-
-    /* Update information about the current method */
-    prof_call_tree_t* call_tree = frame->call_tree;
-
-    // Update method measurement
-    call_tree->method->measurement->self_time += self_time;
-    call_tree->method->measurement->wait_time += frame->wait_time;
-    if (call_tree->method->visits == 1)
-        call_tree->method->measurement->total_time += total_time;
-
-    call_tree->method->visits--;
-
-    // Update method measurement
-    call_tree->measurement->self_time += self_time;
-    call_tree->measurement->wait_time += frame->wait_time;
-    if (call_tree->visits == 1)
-        call_tree->measurement->total_time += total_time;
-
-    call_tree->visits--;
-
-    prof_frame_t* parent_frame = prof_stack_last(stack);
-    if (parent_frame)
-    {
-        parent_frame->child_time += total_time;
-        parent_frame->dead_time += frame->dead_time;
-    }
-
-    frame->source_file = Qnil;
-
-    return frame;
-}
-
-prof_method_t* prof_find_method(prof_stack_t* stack, VALUE source_file, int source_line)
-{
-    prof_frame_t* frame = prof_stack_last(stack);
-    while (frame >= stack->start)
-    {
-        if (!frame->call_tree)
-            return NULL;
-
-        if (rb_str_equal(source_file, frame->call_tree->method->source_file) &&
-            source_line >= frame->call_tree->method->source_line)
-        {
-            return frame->call_tree->method;
-        }
-        frame--;
-    }
-    return NULL;
-}
+/* 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_stack.h"
+
+#define INITIAL_STACK_SIZE 16
+
+// Creates a stack of prof_frame_t to keep track of timings for active methods.
+prof_stack_t* prof_stack_create(void)
+{
+    prof_stack_t* stack = ALLOC(prof_stack_t);
+    stack->start = ZALLOC_N(prof_frame_t, INITIAL_STACK_SIZE);
+    stack->ptr = stack->start;
+    stack->end = stack->start + INITIAL_STACK_SIZE;
+
+    return stack;
+}
+
+void prof_stack_free(prof_stack_t* stack)
+{
+    xfree(stack->start);
+    xfree(stack);
+}
+
+prof_frame_t* prof_stack_parent(prof_stack_t* stack)
+{
+    if (stack->ptr == stack->start || stack->ptr - 1 == stack->start)
+        return NULL;
+    else
+        return stack->ptr - 2;
+}
+
+prof_frame_t* prof_stack_last(prof_stack_t* stack)
+{
+    if (stack->ptr == stack->start)
+        return NULL;
+    else
+        return stack->ptr - 1;
+}
+
+void prof_stack_verify_size(prof_stack_t* stack)
+{
+    // Is there space on the stack?  If not, double its size.
+    if (stack->ptr == stack->end)
+    {
+        size_t len = stack->ptr - stack->start;
+        size_t new_capacity = (stack->end - stack->start) * 2;
+        REALLOC_N(stack->start, prof_frame_t, new_capacity);
+
+        /* Memory just got moved, reset pointers */
+        stack->ptr = stack->start + len;
+        stack->end = stack->start + new_capacity;
+    }
+}
+
+prof_frame_t* prof_stack_push(prof_stack_t* stack)
+{
+    prof_stack_verify_size(stack);
+
+    prof_frame_t* result = stack->ptr;
+    stack->ptr++;
+    return result;
+}
+
+prof_frame_t* prof_stack_pop(prof_stack_t* stack)
+{
+    prof_frame_t* result = prof_stack_last(stack);
+    if (result)
+        stack->ptr--;
+
+    return result;
+}
+
+// ----------------  Frame Methods  ----------------------------
+void prof_frame_pause(prof_frame_t* frame, double current_measurement)
+{
+    if (frame && prof_frame_is_unpaused(frame))
+        frame->pause_time = current_measurement;
+}
+
+void prof_frame_unpause(prof_frame_t* frame, double current_measurement)
+{
+    if (prof_frame_is_paused(frame))
+    {
+        frame->dead_time += (current_measurement - frame->pause_time);
+        frame->pause_time = -1;
+    }
+}
+
+prof_frame_t* prof_frame_current(prof_stack_t* stack)
+{
+    return prof_stack_last(stack);
+}
+
+prof_frame_t* prof_frame_push(prof_stack_t* stack, prof_call_tree_t* call_tree, double measurement, bool paused)
+{
+    prof_frame_t* result = prof_stack_push(stack);
+    prof_frame_t* parent_frame = prof_stack_parent(stack);
+
+    result->call_tree = call_tree;
+
+    result->start_time = measurement;
+    result->pause_time = -1; // init as not paused.
+    result->switch_time = 0;
+    result->wait_time = 0;
+    result->child_time = 0;
+    result->dead_time = 0;
+    result->source_file = Qnil;
+    result->source_line = 0;
+
+    call_tree->measurement->called++;
+    call_tree->visits++;
+
+    if (call_tree->method->visits > 0)
+    {
+        call_tree->method->recursive = true;
+    }
+    call_tree->method->measurement->called++;
+    call_tree->method->visits++;
+
+    // Unpause the parent frame, if it exists.
+    // If currently paused then:
+    //   1) The child frame will begin paused.
+    //   2) The parent will inherit the child's dead time.
+    if (parent_frame)
+        prof_frame_unpause(parent_frame, measurement);
+
+    if (paused)
+    {
+        prof_frame_pause(result, measurement);
+    }
+
+    // Return the result
+    return result;
+}
+
+prof_frame_t* prof_frame_unshift(prof_stack_t* stack, prof_call_tree_t* parent_call_tree, prof_call_tree_t* call_tree, double measurement)
+{
+    if (prof_stack_last(stack))
+        rb_raise(rb_eRuntimeError, "Stack unshift can only be called with an empty stack");
+
+    parent_call_tree->measurement->total_time = call_tree->measurement->total_time;
+    parent_call_tree->measurement->self_time = 0;
+    parent_call_tree->measurement->wait_time = call_tree->measurement->wait_time;
+
+    parent_call_tree->method->measurement->total_time += call_tree->measurement->total_time;
+    parent_call_tree->method->measurement->wait_time += call_tree->measurement->wait_time;
+
+    return prof_frame_push(stack, parent_call_tree, measurement, false);
+}
+
+prof_frame_t* prof_frame_pop(prof_stack_t* stack, double measurement)
+{
+    prof_frame_t* frame = prof_stack_pop(stack);
+
+    if (!frame)
+        return NULL;
+
+    /* Calculate the total time this method took */
+    prof_frame_unpause(frame, measurement);
+
+    double total_time = measurement - frame->start_time - frame->dead_time;
+    double self_time = total_time - frame->child_time - frame->wait_time;
+
+    /* Update information about the current method */
+    prof_call_tree_t* call_tree = frame->call_tree;
+
+    // Update method measurement
+    call_tree->method->measurement->self_time += self_time;
+    call_tree->method->measurement->wait_time += frame->wait_time;
+    if (call_tree->method->visits == 1)
+        call_tree->method->measurement->total_time += total_time;
+
+    call_tree->method->visits--;
+
+    // Update method measurement
+    call_tree->measurement->self_time += self_time;
+    call_tree->measurement->wait_time += frame->wait_time;
+    if (call_tree->visits == 1)
+        call_tree->measurement->total_time += total_time;
+
+    call_tree->visits--;
+
+    prof_frame_t* parent_frame = prof_stack_last(stack);
+    if (parent_frame)
+    {
+        parent_frame->child_time += total_time;
+        parent_frame->dead_time += frame->dead_time;
+    }
+
+    frame->source_file = Qnil;
+
+    return frame;
+}
+
+prof_method_t* prof_find_method(prof_stack_t* stack, VALUE source_file, int source_line)
+{
+    prof_frame_t* frame = prof_stack_last(stack);
+    while (frame >= stack->start)
+    {
+        if (!frame->call_tree)
+            return NULL;
+
+        if (rb_str_equal(source_file, frame->call_tree->method->source_file) &&
+            source_line >= frame->call_tree->method->source_line)
+        {
+            return frame->call_tree->method;
+        }
+        frame--;
+    }
+    return NULL;
+}

data/ext/ruby_prof/ruby_prof.c

@@ -1,50 +1,50 @@
-/* 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 */
-
-   /* ruby-prof tracks the time spent executing every method in ruby programming.
-      The main players are:
-
-        profile_t         - This represents 1 profile.
-        thread_data_t     - Stores data about a single thread.
-        prof_stack_t      - The method call stack in a particular thread
-        prof_method_t     - Profiling information about each method
-        prof_call_tree_t  - Keeps track a method's callers and callees.
-
-     The final result is an instance of a profile object which has a hash table of
-     thread_data_t, keyed on the thread id.  Each thread in turn has a hash table
-     of prof_method_t, keyed on the method id.  A hash table is used for quick
-     look up when doing a profile.  However, it is exposed to Ruby as an array.
-
-     Each prof_method_t has two hash tables, parent and children, of prof_call_tree_t.
-     These objects keep track of a method's callers (who called the method) and its
-     callees (who the method called).  These are keyed the method id, but once again,
-     are exposed to Ruby as arrays.  Each prof_call_into_t maintains a pointer to the
-     caller or callee method, thereby making it easy to navigate through the call
-     hierarchy in ruby - which is very helpful for creating call graphs.
-   */
-
-#include "ruby_prof.h"
-
-#include "rp_allocation.h"
-#include "rp_measurement.h"
-#include "rp_method.h"
-#include "rp_call_tree.h"
-#include "rp_call_trees.h"
-#include "rp_profile.h"
-#include "rp_stack.h"
-#include "rp_thread.h"
-
-VALUE mProf;
-
-void Init_ruby_prof(void)
-{
-    mProf = rb_define_module("RubyProf");
-
-    rp_init_allocation();
-    rp_init_call_tree();
-    rp_init_call_trees();
-    rp_init_measure();
-    rp_init_method_info();
-    rp_init_profile();
-    rp_init_thread();
-}
+/* 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 */
+
+   /* ruby-prof tracks the time spent executing every method in ruby programming.
+      The main players are:
+
+        profile_t         - This represents 1 profile.
+        thread_data_t     - Stores data about a single thread.
+        prof_stack_t      - The method call stack in a particular thread
+        prof_method_t     - Profiling information about each method
+        prof_call_tree_t  - Keeps track a method's callers and callees.
+
+     The final result is an instance of a profile object which has a hash table of
+     thread_data_t, keyed on the thread id.  Each thread in turn has a hash table
+     of prof_method_t, keyed on the method id.  A hash table is used for quick
+     look up when doing a profile.  However, it is exposed to Ruby as an array.
+
+     Each prof_method_t has two hash tables, parent and children, of prof_call_tree_t.
+     These objects keep track of a method's callers (who called the method) and its
+     callees (who the method called).  These are keyed the method id, but once again,
+     are exposed to Ruby as arrays.  Each prof_call_into_t maintains a pointer to the
+     caller or callee method, thereby making it easy to navigate through the call
+     hierarchy in ruby - which is very helpful for creating call graphs.
+   */
+
+#include "ruby_prof.h"
+
+#include "rp_allocation.h"
+#include "rp_measurement.h"
+#include "rp_method.h"
+#include "rp_call_tree.h"
+#include "rp_call_trees.h"
+#include "rp_profile.h"
+#include "rp_stack.h"
+#include "rp_thread.h"
+
+VALUE mProf;
+
+void Init_ruby_prof(void)
+{
+    mProf = rb_define_module("RubyProf");
+
+    rp_init_allocation();
+    rp_init_call_tree();
+    rp_init_call_trees();
+    rp_init_measure();
+    rp_init_method_info();
+    rp_init_profile();
+    rp_init_thread();
+}

data/ext/ruby_prof/ruby_prof.h

@@ -4,11 +4,12 @@
 #ifndef __RUBY_PROF_H__
 #define __RUBY_PROF_H__
 
-#include <ruby.h>
-#include <ruby/debug.h>
 #include <stdio.h>
 #include <stdbool.h>
 
+#include <ruby.h>
+#include <ruby/debug.h>
+
 #ifndef rb_st_lookup
 #define rb_st_foreach st_foreach
 #define rb_st_free_table st_free_table

data/ext/ruby_prof/vc/ruby_prof.vcxproj

@@ -104,14 +104,14 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
-      <AdditionalIncludeDirectories>C:\msys64\usr\local\ruby-3.3.0-vc\include\ruby-3.3.0\x64-mswin64_140;C:\msys64\usr\local\ruby-3.3.0-vc\include\ruby-3.3.0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>C:\msys64\usr\local\ruby-3.4.3-mswin\include\ruby-3.4.0\x64-mswin64_140;C:\msys64\usr\local\ruby-3.4.3-mswin\include\ruby-3.4.0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <WarningLevel>Level3</WarningLevel>
     </ClCompile>
     <Link>
-      <AdditionalLibraryDirectories>C:\msys64\usr\local\ruby-3.3.0-vc\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>x64-vcruntime140-ruby330.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>C:\msys64\usr\local\ruby-3.4.3-mswin\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>x64-vcruntime140-ruby340.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <ModuleDefinitionFile>ruby_prof.def</ModuleDefinitionFile>
       <SubSystem>Console</SubSystem>
     </Link>