fiber-profiler 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2bbdd5d629b193bb2c9fe87a9935abda45b21339bc9fa8e9a177a3cb08c6ca4
-  data.tar.gz: c38ff2d79d1dcc2cef0745923da73c0e1bfda612623d1592fffbeb708d6ff97f
+  metadata.gz: 7eff364d5f9fc0850ed71072242195873f790518f3f10b784329fe31dafcbf6f
+  data.tar.gz: ad7c9544f0d14fa2b2085d91d9211c7bcb42dc26e0840ca19bf7c064c5067cba
 SHA512:
-  metadata.gz: a23c926af43a1db2f2cf71b269bbb63d0bff602ca17b40ced3da152dd317d084c2f41f47c42ba7194a7be67df6be8d17de54a829808a82173bb3dc83303b14bd
-  data.tar.gz: afd379c5f799fda50fa7229f4512ff01297e9f7f66a32d0eaab575a77c3b66d9b7cc1d13627609193983173b725b8851bf9240ab8096881bc764b66ba83b9a73
+  metadata.gz: '069d76a3551bd65c3cf877e371f00c5dd57c3b0bb8c1d937f7187a291adca561b85628ed46b28b3ad2325e6e37e1da1ec4480cb7f4ef4e180b91c55ffd6fcea6'
+  data.tar.gz: d44f0981b66d6fc382005e13e2900b1c56cc879993d6dd0c141293b1b5ed6223e81e3201ce2e345cfa4e663b8e1b42ce3bacea53b7abff9db901470fc897d0df

data/ext/fiber/profiler/capture.c

@@ -14,6 +14,7 @@
 
 enum {
 	DEBUG_SKIPPED = 0,
+	DEBUG_FILTERED = 0,
 };
 
 int Fiber_Profiler_capture_p = 0;
@@ -25,9 +26,11 @@ VALUE Fiber_Profiler_Capture = Qnil;
 
 struct Fiber_Profiler_Capture_Call {
 	struct timespec enter_time;
-	struct timespec exit_time;
+	double duration;
 	
-	size_t nesting;
+	int nesting;
+	size_t children;
+	size_t filtered;
 	
 	rb_event_flag_t event_flag;
 	ID id;
@@ -65,43 +68,61 @@ struct Fiber_Profiler_Capture;
 typedef void(*Fiber_Profiler_Stream_Print)(struct Fiber_Profiler_Capture*, FILE* restrict);
 
 struct Fiber_Profiler_Capture {
-	// Configuration:
+	// The threshold in seconds, which determines when a fiber is considered to have stalled the event loop.
 	double stall_threshold;
+	
+	// Whether or not to track calls.
 	int track_calls;
+	
+	// The sample rate of the profiler, as a fraction of 1.0, which controls how often the profiler will sample between fiber context switches.
 	double sample_rate;
 	
-	// Calls that are shorter than this filter threshold will be ignored:
+	// Calls that are shorter than this filter threshold will be ignored.
 	double filter_threshold;
 	
-	// Output handling:
+	// The output object to write to.
 	VALUE output;
+	
+	// The stream print function to use.
 	Fiber_Profiler_Stream_Print print;
+	
+	// The stream buffer used for printing.
 	struct Fiber_Profiler_Stream stream;
 	
-	// Whether or not the profiler is currently running:
+	// Whether or not the profiler is currently running.
 	int running;
+	
+	// The thread being profiled.
 	VALUE thread;
 	
-	// Whether or not to capture call data:
+	// Whether or not to capture call data.
 	int capture;
 	
+	// The number of stalls encountered.
 	size_t stalls;
 	
-	// From this point on, the state of any profile in progress:
+	// The start time of the profile.
 	struct timespec start_time;
+	
+	// The stop time of the profile.
 	struct timespec stop_time;
 	
-	// The depth of the call stack:
-	size_t nesting;
+	// The depth of the call stack (can be negative).
+	int nesting;
+	
+	// The minimum nesting level encountered during the profiling session.
+	int nesting_minimum;
 	
-	// The current call frame:
+	// The current call frame.
 	struct Fiber_Profiler_Capture_Call *current;
 	
+	// The call recorded during the profiling session.
 	struct Fiber_Profiler_Deque calls;
 };
 
 void Fiber_Profiler_Capture_reset(struct Fiber_Profiler_Capture *profiler) {
 	profiler->nesting = 0;
+	profiler->nesting_minimum = 0;
 	profiler->current = NULL;
 	Fiber_Profiler_Deque_truncate(&profiler->calls);
 }
@@ -111,10 +132,11 @@ void Fiber_Profiler_Capture_Call_initialize(void *element) {
 	
 	call->enter_time.tv_sec = 0;
 	call->enter_time.tv_nsec = 0;
-	call->exit_time.tv_sec = 0;
-	call->exit_time.tv_nsec = 0;
+	call->duration = 0;
 	
 	call->nesting = 0;
+	call->children = 0;
+	call->filtered = 0;
 	
 	call->event_flag = 0;
 	call->id = 0;
@@ -224,18 +246,21 @@ VALUE Fiber_Profiler_Capture_allocate(VALUE klass) {
 	profiler->capture = 0;
 	profiler->stalls = 0;
 	profiler->nesting = 0;
+	profiler->nesting_minimum = 0;
 	profiler->current = NULL;
 	
 	profiler->stall_threshold = Fiber_Profiler_Capture_stall_threshold;
 	profiler->track_calls = Fiber_Profiler_Capture_track_calls;
 	profiler->sample_rate = Fiber_Profiler_Capture_sample_rate;
 	
-	// Filter calls that are less than 1% of the stall threshold:
-	profiler->filter_threshold = profiler->stall_threshold * 0.01;
+	// Filter calls that are less than 10% of the stall threshold:
+	profiler->filter_threshold = profiler->stall_threshold * 0.1;
 	
 	profiler->calls.element_initialize = (void (*)(void*))Fiber_Profiler_Capture_Call_initialize;
 	profiler->calls.element_free = (void (*)(void*))Fiber_Profiler_Capture_Call_free;
+	
 	Fiber_Profiler_Deque_initialize(&profiler->calls, sizeof(struct Fiber_Profiler_Capture_Call));
+	Fiber_Profiler_Deque_reserve_default(&profiler->calls);
 	
 	return TypedData_Wrap_Struct(klass, &Fiber_Profiler_Capture_Type, profiler);
 }
@@ -302,20 +327,24 @@ const char *event_flag_name(rb_event_flag_t event_flag) {
 		case RUBY_INTERNAL_EVENT_GC_START: return "gc-start";
 		case RUBY_INTERNAL_EVENT_GC_END_MARK: return "gc-end-mark";
 		case RUBY_INTERNAL_EVENT_GC_END_SWEEP: return "gc-end-sweep";
+		case RUBY_EVENT_LINE: return "line";
 		default: return "unknown";
 	}
 }
 
-static struct Fiber_Profiler_Capture_Call* profiler_event_record_call(struct Fiber_Profiler_Capture *profiler, rb_event_flag_t event_flag, ID id, VALUE klass) {
+static struct Fiber_Profiler_Capture_Call* Fiber_Profiler_Capture_Call_new(struct Fiber_Profiler_Capture *profiler, rb_event_flag_t event_flag, ID id, VALUE klass) {
 	struct Fiber_Profiler_Capture_Call *call = Fiber_Profiler_Deque_push(&profiler->calls);
 	
 	call->event_flag = event_flag;
 
 	call->parent = profiler->current;
+	if (call->parent) {
+		call->parent->children += 1;
+	}
+	
 	profiler->current = call;
-
+	
 	call->nesting = profiler->nesting;
-	profiler->nesting += 1;
 
 	if (id) {
 		call->id = id;
@@ -333,6 +362,43 @@ static struct Fiber_Profiler_Capture_Call* profiler_event_record_call(struct Fib
 	return call;
 }
 
+// Finish the call by calculating the duration and filtering it if necessary.
+int Fiber_Profiler_Capture_Call_finish(struct Fiber_Profiler_Capture *profiler, struct Fiber_Profiler_Capture_Call *call) {
+	// Don't filter calls if we're not running:
+	if (DEBUG_FILTERED) return 0;
+	
+	if (call->duration < profiler->filter_threshold) {
+		// We can only remove calls from the end of the deque, otherwise they might be referenced by other calls:
+		if (call == Fiber_Profiler_Deque_last(&profiler->calls)) {
+			if (profiler->current == call) {
+				profiler->current = call->parent;
+			}
+			
+			if (call->parent) {
+				call->parent->children -= 1;
+				call->parent->filtered += 1;
+				call->parent = NULL;
+			}
+			
+			Fiber_Profiler_Deque_pop(&profiler->calls);
+			
+			return 1;
+		}
+	}
+	
+	return 0;
+}
+
+static const double Fiber_Profiler_Capture_Call_EXPENSIVE_THRESHOLD = 0.2;
+
+int Fiber_Profiler_Capture_Call_expensive_p(struct Fiber_Profiler_Capture_Call *call, double total_duration) {
+	if (call->duration > total_duration * Fiber_Profiler_Capture_Call_EXPENSIVE_THRESHOLD) {
+		return 1;
+	}
+	
+	return 0;
+}
+
 static void Fiber_Profiler_Capture_callback(rb_event_flag_t event_flag, VALUE data, VALUE self, ID id, VALUE klass) {
 	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(data);
 	
@@ -340,7 +406,10 @@ static void Fiber_Profiler_Capture_callback(rb_event_flag_t event_flag, VALUE da
 	if (!profiler->capture) return;
 	
 	if (event_flag_call_p(event_flag)) {
-		struct Fiber_Profiler_Capture_Call *call = profiler_event_record_call(profiler, event_flag, id, klass);
+		struct Fiber_Profiler_Capture_Call *call = Fiber_Profiler_Capture_Call_new(profiler, event_flag, id, klass);
+		
+		profiler->nesting += 1;
+		
 		Fiber_Profiler_Time_current(&call->enter_time);
 	}
 	
@@ -350,7 +419,7 @@ static void Fiber_Profiler_Capture_callback(rb_event_flag_t event_flag, VALUE da
 		// We may encounter returns without a preceeding call. This isn't an error, but we should pretend like the call started at the beginning of the profiling session:
 		if (call == NULL) {
 			struct Fiber_Profiler_Capture_Call *last_call = Fiber_Profiler_Deque_last(&profiler->calls);
-			call = profiler_event_record_call(profiler, event_flag, id, klass);
+			call = Fiber_Profiler_Capture_Call_new(profiler, event_flag, id, klass);
 			
 			if (last_call) {
 				call->enter_time = last_call->enter_time;
@@ -359,19 +428,32 @@ static void Fiber_Profiler_Capture_callback(rb_event_flag_t event_flag, VALUE da
 			}
 		}
 		
-		Fiber_Profiler_Time_current(&call->exit_time);
+		call->duration = Fiber_Profiler_Time_delta_current(&call->enter_time);
 		
 		profiler->current = call->parent;
 		
 		// We may encounter returns without a preceeding call.
-		if (profiler->nesting > 0)
-			profiler->nesting -= 1;
+		profiler->nesting -= 1;
 		
-		// If the call was < 1% of the stall threshold, we can ignore it:
-		double duration = Fiber_Profiler_Time_delta(&call->enter_time, &call->exit_time);
-		if (duration < profiler->filter_threshold) {
-			Fiber_Profiler_Deque_pop(&profiler->calls);
+		// We need to keep track of how deep the call stack goes:
+		if (profiler->nesting < profiler->nesting_minimum) {
+			profiler->nesting_minimum = profiler->nesting;
 		}
+		
+		Fiber_Profiler_Capture_Call_finish(profiler, call);
+	}
+	
+	else {
+		struct Fiber_Profiler_Capture_Call *last_call = Fiber_Profiler_Deque_last(&profiler->calls);
+		struct Fiber_Profiler_Capture_Call *call = Fiber_Profiler_Capture_Call_new(profiler, event_flag, id, klass);
+		
+		if (last_call) {
+			call->enter_time = last_call->enter_time;
+		} else {
+			call->enter_time = profiler->start_time;
+		}
+		
+		call->duration = Fiber_Profiler_Time_delta_current(&call->enter_time);
 	}
 }
 
@@ -395,9 +477,11 @@ void Fiber_Profiler_Capture_resume(VALUE self) {
 	rb_event_flag_t event_flags = 0;
 	
 	if (profiler->track_calls) {
+		// event_flags |= RUBY_EVENT_LINE;
+		
 		event_flags |= RUBY_EVENT_CALL | RUBY_EVENT_RETURN;
 		event_flags |= RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN;
-		// event_flags |= RUBY_EVENT_B_CALL | RUBY_EVENT_B_RETURN;
+		event_flags |= RUBY_EVENT_B_CALL | RUBY_EVENT_B_RETURN;
 	}
 	
 	// CRuby will raise an exception if you try to add "INTERNAL_EVENT" hooks at the same time as other hooks, so we do it in two calls:
@@ -445,23 +529,21 @@ VALUE Fiber_Profiler_Capture_stop(VALUE self) {
 	return self;
 }
 
-static inline float Fiber_Profiler_Capture_duration(struct Fiber_Profiler_Capture *profiler) {
-	struct timespec duration;
-	
-	Fiber_Profiler_Time_current(&profiler->stop_time);
-	Fiber_Profiler_Time_elapsed(&profiler->start_time, &profiler->stop_time, &duration);
-	
-	return Fiber_Profiler_Time_duration(&duration);
-}
-
 void Fiber_Profiler_Capture_finish(struct Fiber_Profiler_Capture *profiler) {
 	profiler->capture = 0;
 	
+	struct timespec stop_time;
+	Fiber_Profiler_Time_current(&stop_time);
+	
 	struct Fiber_Profiler_Capture_Call *current = profiler->current;
 	while (current) {
-		Fiber_Profiler_Time_current(&current->exit_time);
+		struct Fiber_Profiler_Capture_Call *parent = current->parent;
+		
+		current->duration = Fiber_Profiler_Time_delta(&current->enter_time, &stop_time);
+		
+		Fiber_Profiler_Capture_Call_finish(profiler, current);
 		
-		current = current->parent;
+		current = parent;
 	}
 }
 
@@ -483,7 +565,8 @@ int Fiber_Profiler_Capture_sample(struct Fiber_Profiler_Capture *profiler) {
 void Fiber_Profiler_Capture_fiber_switch(VALUE self)
 {
 	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(self);
-	float duration = Fiber_Profiler_Capture_duration(profiler);
+	Fiber_Profiler_Time_current(&profiler->stop_time);
+	double duration = Fiber_Profiler_Time_delta(&profiler->start_time, &profiler->stop_time);
 	
 	if (profiler->capture) {
 		Fiber_Profiler_Capture_pause(self);
@@ -506,57 +589,92 @@ void Fiber_Profiler_Capture_fiber_switch(VALUE self)
 	}
 }
 
-static const float Fiber_Profiler_Capture_PRINT_MINIMUM_PROPORTION = 0.01;
+// When sampling a fiber, we may encounter returns without a preceeding call. This isn't an error, and we should correctly visualize the call stack. We track both the relative nesting (which can be negative) and the minimum nesting level encountered during the profiling session, and use that to determine the absolute nesting level of each call when printing the call stack.
+static size_t Fiber_Profiler_Capture_absolute_nesting(struct Fiber_Profiler_Capture *profiler, struct Fiber_Profiler_Capture_Call *call) {
+	return call->nesting - profiler->nesting_minimum;
+}
+
+// If a call is within this threshold of the parent call, it will be skipped when printing the call stack - it's considered inconsequential to the performance of the parent call.
+static const double Fiber_Profiler_Capture_SKIP_THRESHOLD = 0.98;
 
 void Fiber_Profiler_Capture_print_tty(struct Fiber_Profiler_Capture *profiler, FILE *restrict stream) {
-	struct timespec total_duration = {};
-	Fiber_Profiler_Time_elapsed(&profiler->start_time, &profiler->stop_time, &total_duration);
+	double total_duration = Fiber_Profiler_Time_delta(&profiler->start_time, &profiler->stop_time);
 	
-	fprintf(stderr, "Fiber stalled for %.3f seconds\n", Fiber_Profiler_Time_duration(&total_duration));
+	fprintf(stderr, "## Fiber stalled for %.3f seconds ##\n", total_duration);
 	
 	size_t skipped = 0;
 	
 	Fiber_Profiler_Deque_each(&profiler->calls, struct Fiber_Profiler_Capture_Call, call) {
-		struct timespec duration = {};
-		Fiber_Profiler_Time_elapsed(&call->enter_time, &call->exit_time, &duration);
+		if (call->children) {
+			if (call->parent && call->parent->children == 1) {
+				if (call->duration > call->parent->duration * Fiber_Profiler_Capture_SKIP_THRESHOLD) {
+					if (!DEBUG_SKIPPED) {
+						// We remove the nesting level as we're skipping this call - and we use this to track the nesting of child calls which MAY be printed:
+						call->nesting = call->parent->nesting;
+						skipped += 1;
+						continue;
+					} else {
+						fprintf(stream, "\e[34m");
+					}
+				}
+			}
+		}
 		
-		// Skip calls that are too short to be meaningful:
-		if (Fiber_Profiler_Time_proportion(&duration, &total_duration) < Fiber_Profiler_Capture_PRINT_MINIMUM_PROPORTION) {
+		if (call->parent) {
+			call->nesting = call->parent->nesting + 1;
+		}
+		
+		if (skipped) {
+			fprintf(stream, "\e[2m");
 			
-			if (!DEBUG_SKIPPED) {
-				skipped += 1;
-				continue;
-			} else {
-				fprintf(stream, "\e[2m");
+			size_t nesting = Fiber_Profiler_Capture_absolute_nesting(profiler, call);
+			for (size_t i = 0; i < nesting; i += 1) {
+				fputc('\t', stream);
 			}
+			
+			fprintf(stream, "... skipped %zu nested calls ...\e[0m\n", skipped);
+			
+			skipped = 0;
+			call->nesting += 1;
 		}
 		
-		for (size_t i = 0; i < call->nesting; i += 1) {
+		size_t nesting = Fiber_Profiler_Capture_absolute_nesting(profiler, call);
+		for (size_t i = 0; i < nesting; i += 1) {
 			fputc('\t', stream);
 		}
 		
+		if (Fiber_Profiler_Capture_Call_expensive_p(call, total_duration)) {
+			fprintf(stream, "\e[31m");
+		}
+		
 		VALUE class_inspect = rb_inspect(call->klass);
 		const char *name = rb_id2name(call->id);
 		
-		fprintf(stream, "%s:%d in %s '%s#%s' (" Fiber_Profiler_TIME_PRINTF_TIMESPEC "s)\n", call->path, call->line, event_flag_name(call->event_flag), RSTRING_PTR(class_inspect), name, Fiber_Profiler_TIME_PRINTF_TIMESPEC_ARGUMENTS(duration));
+		struct timespec offset;
+		Fiber_Profiler_Time_elapsed(&profiler->start_time, &call->enter_time, &offset);
+		
+		fprintf(stream, "%s:%d in %s '%s#%s' (%0.4fs, T+" Fiber_Profiler_TIME_PRINTF_TIMESPEC ")\n", call->path, call->line, event_flag_name(call->event_flag), RSTRING_PTR(class_inspect), name, call->duration, Fiber_Profiler_TIME_PRINTF_TIMESPEC_ARGUMENTS(offset));
 		
-		if (DEBUG_SKIPPED) {
-			fprintf(stream, "\e[0m");
+		fprintf(stream, "\e[0m");
+		
+		if (call->filtered) {
+			fprintf(stream, "\e[2m");
+			
+			for (size_t i = 0; i < nesting + 1; i += 1) {
+				fputc('\t', stream);
+			}
+			
+			fprintf(stream, "... filtered %zu direct calls ...\e[0m\n", call->filtered);
 		}
 	}
-	
-	if (skipped > 0) {
-		fprintf(stream, "Skipped %zu calls that were too short to be meaningful.\n", skipped);
-	}
 }
 
 void Fiber_Profiler_Capture_print_json(struct Fiber_Profiler_Capture *profiler, FILE *restrict stream) {
-	struct timespec total_duration = {};
-	Fiber_Profiler_Time_elapsed(&profiler->start_time, &profiler->stop_time, &total_duration);
+	double total_duration = Fiber_Profiler_Time_delta(&profiler->start_time, &profiler->stop_time);
 	
 	fputc('{', stream);
 	
-	fprintf(stream, "\"duration\":" Fiber_Profiler_TIME_PRINTF_TIMESPEC, Fiber_Profiler_TIME_PRINTF_TIMESPEC_ARGUMENTS(total_duration));
+	fprintf(stream, "\"duration\":%0.6f", total_duration);
 	
 	size_t skipped = 0;
 	
@@ -564,20 +682,32 @@ void Fiber_Profiler_Capture_print_json(struct Fiber_Profiler_Capture *profiler,
 	int first = 1;
 	
 	Fiber_Profiler_Deque_each(&profiler->calls, struct Fiber_Profiler_Capture_Call, call) {
-		struct timespec duration = {};
-		Fiber_Profiler_Time_elapsed(&call->enter_time, &call->exit_time, &duration);
+		if (call->children) {
+			if (call->parent && call->parent->children == 1) {
+				if (call->duration > call->parent->duration * Fiber_Profiler_Capture_SKIP_THRESHOLD) {
+					// We remove the nesting level as we're skipping this call - and we use this to track the nesting of child calls which MAY be printed:
+					call->nesting = call->parent->nesting;
+					skipped += 1;
+					continue;
+				}
+			}
+		}
 		
-		// Skip calls that are too short to be meaningful:
-		if (Fiber_Profiler_Time_proportion(&duration, &total_duration) < Fiber_Profiler_Capture_PRINT_MINIMUM_PROPORTION) {
-			skipped += 1;
-			continue;
+		if (call->parent) {
+			call->nesting = call->parent->nesting + 1;
 		}
 		
 		VALUE class_inspect = rb_inspect(call->klass);
 		const char *name = rb_id2name(call->id);
 		
-		fprintf(stream, "%s{\"path\":\"%s\",\"line\":%d,\"class\":\"%s\",\"method\":\"%s\",\"duration\":" Fiber_Profiler_TIME_PRINTF_TIMESPEC ",\"nesting\":%zu}", first ? "" : ",", call->path, call->line, RSTRING_PTR(class_inspect), name, Fiber_Profiler_TIME_PRINTF_TIMESPEC_ARGUMENTS(duration), call->nesting);
+		size_t nesting = Fiber_Profiler_Capture_absolute_nesting(profiler, call);
+		
+		struct timespec offset;
+		Fiber_Profiler_Time_elapsed(&profiler->start_time, &call->enter_time, &offset);
+		
+		fprintf(stream, "%s{\"path\":\"%s\",\"line\":%d,\"class\":\"%s\",\"method\":\"%s\",\"duration\":%0.6f,\"offset\":" Fiber_Profiler_TIME_PRINTF_TIMESPEC ",\"nesting\":%zu,\"skipped\":%zu,\"filtered\":%zu}", first ? "" : ",", call->path, call->line, RSTRING_PTR(class_inspect), name, call->duration, Fiber_Profiler_TIME_PRINTF_TIMESPEC_ARGUMENTS(offset), nesting, skipped, call->filtered);
 		
+		skipped = 0;
 		first = 0;
 	}
 	

data/ext/fiber/profiler/deque.h

@@ -11,7 +11,7 @@ enum {
 #ifdef RUBY_DEBUG
 	Fiber_Profiler_Deque_DEBUG = 1,
 #else
-	Fiber_Profiler_Deque_DEBUG = 0,
+	Fiber_Profiler_Deque_DEBUG = 1,
 #endif
 };
 
@@ -172,6 +172,53 @@ inline static size_t Fiber_Profiler_Deque_default_capacity(struct Fiber_Profiler
 	return (target_size - sizeof(struct Fiber_Profiler_Deque_Page)) / deque->element_size;
 }
 
+static inline void Fiber_Profiler_Deque_reserve(struct Fiber_Profiler_Deque *deque, size_t capacity)
+{
+	struct Fiber_Profiler_Deque_Page *page = deque->head;
+	
+	// Walk over all the pages and see if we have enough capacity:
+	while (page) {
+		size_t available = page->capacity - page->size;
+		
+		if (available > capacity) {
+			return;
+		}
+		
+		capacity -= available;
+		
+		if (page->tail) {
+			page = page->tail;
+		} else {
+			break;
+		}
+	}
+	
+	// We need to allocate a new page:
+	size_t minimum_capacity = Fiber_Profiler_Deque_default_capacity(deque);
+	if (capacity < minimum_capacity) {
+		capacity = minimum_capacity;
+	}
+	
+	struct Fiber_Profiler_Deque_Page *reserved_page = Fiber_Profiler_Deque_Page_allocate(deque->element_size, capacity);
+	if (reserved_page == NULL) {
+		return;
+	}
+	
+	if (page) {
+		page->tail = reserved_page;
+		reserved_page->head = page;
+	} else {
+		deque->head = deque->tail = reserved_page;
+	}
+	
+	if (Fiber_Profiler_Deque_DEBUG) Fiber_Profiler_Deque_debug(deque, __FUNCTION__);
+}
+
+static inline void Fiber_Profiler_Deque_reserve_default(struct Fiber_Profiler_Deque *deque)
+{
+	Fiber_Profiler_Deque_reserve(deque, Fiber_Profiler_Deque_default_capacity(deque));
+}
+
 void *Fiber_Profiler_Deque_push(struct Fiber_Profiler_Deque *deque)
 {
 	struct Fiber_Profiler_Deque_Page *page = deque->tail;

data/ext/fiber/profiler/time.c

@@ -13,23 +13,3 @@ void Fiber_Profiler_Time_elapsed(const struct timespec* start, const struct time
 		duration->tv_nsec = stop->tv_nsec - start->tv_nsec;
 	}
 }
-
-double Fiber_Profiler_Time_duration(const struct timespec *duration)
-{
-	return duration->tv_sec + duration->tv_nsec / 1000000000.0;
-}
-
-void Fiber_Profiler_Time_current(struct timespec *time) {
-	clock_gettime(CLOCK_MONOTONIC, time);
-}
-
-double Fiber_Profiler_Time_proportion(const struct timespec *duration, const struct timespec *total_duration) {
-	return Fiber_Profiler_Time_duration(duration) / Fiber_Profiler_Time_duration(total_duration);
-}
-
-double Fiber_Profiler_Time_delta(const struct timespec *start, const struct timespec *stop) {
-	struct timespec duration;
-	Fiber_Profiler_Time_elapsed(start, stop, &duration);
-	
-	return Fiber_Profiler_Time_duration(&duration);
-}

data/ext/fiber/profiler/time.h

@@ -7,11 +7,34 @@
 #include <time.h>
 
 void Fiber_Profiler_Time_elapsed(const struct timespec* start, const struct timespec* stop, struct timespec *duration);
-double Fiber_Profiler_Time_duration(const struct timespec *duration);
-void Fiber_Profiler_Time_current(struct timespec *time);
 
-double Fiber_Profiler_Time_delta(const struct timespec *start, const struct timespec *stop);
-double Fiber_Profiler_Time_proportion(const struct timespec *duration, const struct timespec *total_duration);
+static inline double Fiber_Profiler_Time_duration(const struct timespec *duration)
+{
+	return duration->tv_sec + duration->tv_nsec / 1000000000.0;
+}
+
+static inline double Fiber_Profiler_Time_proportion(const struct timespec *duration, const struct timespec *total_duration)
+{
+	return Fiber_Profiler_Time_duration(duration) / Fiber_Profiler_Time_duration(total_duration);
+}
+
+static inline void Fiber_Profiler_Time_current(struct timespec *time)
+{
+	clock_gettime(CLOCK_MONOTONIC, time);
+}
+
+static inline double Fiber_Profiler_Time_delta(const struct timespec *start, const struct timespec *stop)
+{
+	return stop->tv_sec - start->tv_sec + (stop->tv_nsec - start->tv_nsec) / 1e9;
+}
+
+static inline double Fiber_Profiler_Time_delta_current(const struct timespec *start)
+{
+	struct timespec stop;
+	Fiber_Profiler_Time_current(&stop);
+	
+	return Fiber_Profiler_Time_delta(start, &stop);
+}
 
 #define Fiber_Profiler_TIME_PRINTF_TIMESPEC "%.3g"
 #define Fiber_Profiler_TIME_PRINTF_TIMESPEC_ARGUMENTS(ts) ((double)(ts).tv_sec + (ts).tv_nsec / 1e9)

data/lib/fiber/profiler/version.rb

@@ -7,6 +7,6 @@
 class Fiber
 	# @namespace
 	module Profiler
-		VERSION = "0.1.3"
+		VERSION = "0.1.5"
 	end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fiber-profiler
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.5
 platform: ruby
 authors:
 - Samuel Williams