pf2 0.9.0 → 0.10.0

data/ext/pf2/src/session.rs

@@ -1,248 +0,0 @@
-pub mod configuration;
-mod new_thread_watcher;
-pub mod ruby_object;
-
-use std::collections::HashSet;
-use std::ffi::{c_int, CStr, CString};
-use std::str::FromStr as _;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, RwLock};
-use std::thread;
-use std::time::Duration;
-
-use rb_sys::*;
-
-use self::configuration::Configuration;
-use self::new_thread_watcher::NewThreadWatcher;
-use crate::profile::Profile;
-use crate::scheduler::Scheduler;
-#[cfg(target_os = "linux")]
-use crate::signal_scheduler::SignalScheduler;
-#[cfg(not(target_os = "linux"))]
-use crate::signal_scheduler_unsupported_platform::SignalScheduler;
-use crate::timer_thread_scheduler::TimerThreadScheduler;
-use crate::util::*;
-
-pub struct Session {
-    pub configuration: Configuration,
-    pub scheduler: Arc<dyn Scheduler>,
-    pub profile: Arc<RwLock<Profile>>,
-    pub running: Arc<AtomicBool>,
-    pub new_thread_watcher: Option<NewThreadWatcher>,
-}
-
-impl Session {
-    pub fn new_from_rb_initialize(argc: c_int, argv: *const VALUE, rbself: VALUE) -> Self {
-        // Parse arguments
-        let kwargs: VALUE = Qnil.into();
-        unsafe {
-            rb_scan_args(argc, argv, cstr!(":"), &kwargs);
-        };
-        let mut kwargs_values: [VALUE; 5] = [Qnil.into(); 5];
-        unsafe {
-            rb_get_kwargs(
-                kwargs,
-                [
-                    rb_intern(cstr!("interval_ms")),
-                    rb_intern(cstr!("threads")),
-                    rb_intern(cstr!("time_mode")),
-                    rb_intern(cstr!("scheduler")),
-                    rb_intern(cstr!("use_experimental_serializer")),
-                ]
-                .as_mut_ptr(),
-                0,
-                5,
-                kwargs_values.as_mut_ptr(),
-            );
-        };
-
-        let interval = Self::parse_option_interval_ms(kwargs_values[0]);
-        let threads = Self::parse_option_threads(kwargs_values[1]);
-        let time_mode = Self::parse_option_time_mode(kwargs_values[2]);
-        let scheduler = Self::parse_option_scheduler(kwargs_values[3]);
-        let use_experimental_serializer =
-            Self::parse_option_use_experimental_serializer(kwargs_values[4]);
-
-        let configuration = Configuration {
-            scheduler,
-            interval,
-            target_ruby_threads: threads.clone(),
-            time_mode,
-            use_experimental_serializer,
-        };
-
-        match configuration.validate() {
-            Ok(_) => {}
-            Err(msg) => unsafe {
-                rb_raise(rb_eArgError, CString::new(msg).unwrap().as_c_str().as_ptr());
-            },
-        };
-
-        // Store configuration as a Ruby Hash for convenience
-        unsafe {
-            rb_iv_set(rbself, cstr!("@configuration"), configuration.to_rb_hash());
-        }
-
-        // Create a new Profile
-        let profile = Arc::new(RwLock::new(Profile::new()));
-
-        // Initialize the specified Scheduler
-        let scheduler: Arc<dyn Scheduler> = match configuration.scheduler {
-            configuration::Scheduler::Signal => {
-                Arc::new(SignalScheduler::new(&configuration, Arc::clone(&profile)))
-            }
-            configuration::Scheduler::TimerThread => {
-                Arc::new(TimerThreadScheduler::new(&configuration, Arc::clone(&profile)))
-            }
-        };
-
-        let running = Arc::new(AtomicBool::new(false));
-
-        let new_thread_watcher = match threads {
-            configuration::Threads::All => {
-                let scheduler = Arc::clone(&scheduler);
-                let running = Arc::clone(&running);
-                Some(NewThreadWatcher::watch(move |thread: VALUE| {
-                    if running.load(Ordering::Relaxed) {
-                        log::debug!("New Ruby thread detected: {:?}", thread);
-                        scheduler.on_new_thread(thread);
-                    }
-                }))
-            }
-            configuration::Threads::Targeted(_) => None,
-        };
-
-        Session { configuration, scheduler, profile, running, new_thread_watcher }
-    }
-
-    fn parse_option_interval_ms(value: VALUE) -> Duration {
-        if value == Qundef as VALUE {
-            // Return default
-            return configuration::DEFAULT_INTERVAL;
-        }
-
-        let interval_ms = unsafe { rb_num2long(value) };
-        Duration::from_millis(interval_ms.try_into().unwrap_or_else(|_| {
-            eprintln!(
-                "[Pf2] Warning: Specified interval ({}) is not valid. Using default value (9ms).",
-                interval_ms
-            );
-            9
-        }))
-    }
-
-    fn parse_option_threads(value: VALUE) -> configuration::Threads {
-        if (value == Qundef as VALUE)
-            || (value == Qnil as VALUE)
-            || (value == unsafe { rb_id2sym(rb_intern(cstr!("all"))) })
-        {
-            return configuration::Threads::All;
-        }
-
-        let mut set: HashSet<VALUE> = HashSet::new();
-        unsafe {
-            for i in 0..RARRAY_LEN(value) {
-                set.insert(rb_ary_entry(value, i));
-            }
-        }
-        configuration::Threads::Targeted(set)
-    }
-
-    fn parse_option_time_mode(value: VALUE) -> configuration::TimeMode {
-        if value == Qundef as VALUE {
-            // Return default
-            return configuration::DEFAULT_TIME_MODE;
-        }
-
-        let specified_mode = unsafe {
-            let mut str = rb_funcall(value, rb_intern(cstr!("to_s")), 0);
-            let ptr = rb_string_value_ptr(&mut str);
-            CStr::from_ptr(ptr).to_str().unwrap()
-        };
-        configuration::TimeMode::from_str(specified_mode).unwrap_or_else(|_| {
-            // Raise an ArgumentError if the mode is invalid
-            unsafe {
-                rb_raise(
-                    rb_eArgError,
-                    cstr!("Invalid time mode. Valid values are 'cpu' and 'wall'."),
-                )
-            }
-        })
-    }
-
-    fn parse_option_scheduler(value: VALUE) -> configuration::Scheduler {
-        if value == Qundef as VALUE {
-            // Return default
-            return configuration::DEFAULT_SCHEDULER;
-        }
-
-        let specified_scheduler = unsafe {
-            let mut str = rb_funcall(value, rb_intern(cstr!("to_s")), 0);
-            let ptr = rb_string_value_ptr(&mut str);
-            CStr::from_ptr(ptr).to_str().unwrap()
-        };
-        let scheduler =
-            configuration::Scheduler::from_str(specified_scheduler).unwrap_or_else(|_| {
-                // Raise an ArgumentError if the mode is invalid
-                unsafe {
-                    rb_raise(
-                        rb_eArgError,
-                        cstr!("Invalid scheduler. Valid values are ':signal' and ':timer_thread'."),
-                    )
-                }
-            });
-
-        // Raise an ArgumentError if the scheduler is not supported on the current platform
-        if !cfg!(target_os = "linux") && scheduler == configuration::Scheduler::Signal {
-            unsafe {
-                rb_raise(rb_eArgError, cstr!("Signal scheduler is not supported on this platform."))
-            }
-        }
-        scheduler
-    }
-
-    fn parse_option_use_experimental_serializer(value: VALUE) -> bool {
-        if value == Qundef as VALUE {
-            return false;
-        }
-        RTEST(value)
-    }
-
-    pub fn start(&mut self) -> VALUE {
-        self.running.store(true, Ordering::Relaxed);
-        self.start_profile_buffer_flusher_thread();
-        self.scheduler.start()
-    }
-
-    fn start_profile_buffer_flusher_thread(&self) {
-        let profile = Arc::clone(&self.profile);
-        let running = Arc::clone(&self.running);
-        log::debug!("flusher: Starting");
-        thread::spawn(move || loop {
-            if !running.load(Ordering::Relaxed) {
-                log::debug!("flusher: Exiting");
-                break;
-            }
-
-            log::trace!("flusher: Flushing temporary sample buffer");
-            match profile.try_write() {
-                Ok(mut profile) => {
-                    profile.flush_temporary_sample_buffer();
-                }
-                Err(_) => {
-                    log::debug!("flusher: Failed to acquire profile lock");
-                }
-            }
-            thread::sleep(Duration::from_millis(500));
-        });
-    }
-
-    pub fn stop(&mut self) -> VALUE {
-        self.running.store(false, Ordering::Relaxed);
-        self.scheduler.stop()
-    }
-
-    pub fn dmark(&self) {
-        self.scheduler.dmark()
-    }
-}

data/ext/pf2/src/siginfo_t.c

@@ -1,5 +0,0 @@
-#include <signal.h>
-
-void *extract_si_value_sival_ptr(siginfo_t *siginfo) {
-  return siginfo->si_value.sival_ptr;
-}

data/ext/pf2/src/signal_scheduler.rs

@@ -1,201 +0,0 @@
-#![deny(unsafe_op_in_unsafe_fn)]
-
-use crate::profile::Profile;
-use crate::profile_serializer::ProfileSerializer;
-use crate::ruby_internal_apis::rb_thread_getcpuclockid;
-use crate::sample::Sample;
-use crate::scheduler::Scheduler;
-use crate::serialization::serializer::ProfileSerializer2;
-use crate::session::configuration::{self, Configuration};
-
-use core::panic;
-use std::ffi::{c_int, c_void, CString};
-use std::mem::ManuallyDrop;
-use std::sync::{Arc, RwLock};
-use std::{mem, ptr::null_mut};
-
-use rb_sys::*;
-
-use crate::util::*;
-
-#[derive(Debug)]
-pub struct SignalScheduler {
-    configuration: Configuration,
-    profile: Arc<RwLock<Profile>>,
-}
-
-pub struct SignalHandlerArgs {
-    profile: Arc<RwLock<Profile>>,
-    context_ruby_thread: VALUE,
-}
-
-impl Scheduler for SignalScheduler {
-    fn start(&self) -> VALUE {
-        self.install_signal_handler();
-
-        if let configuration::Threads::Targeted(threads) = &self.configuration.target_ruby_threads {
-            for ruby_thread in threads.iter() {
-                self.install_timer_to_ruby_thread(*ruby_thread);
-            }
-        }
-
-        Qtrue.into()
-    }
-
-    fn stop(&self) -> VALUE {
-        // Finalize
-        match self.profile.try_write() {
-            Ok(mut profile) => {
-                profile.flush_temporary_sample_buffer();
-                profile.end_instant = Some(std::time::Instant::now());
-            }
-            Err(_) => {
-                println!("[pf2 ERROR] stop: Failed to acquire profile lock.");
-                return Qfalse.into();
-            }
-        }
-
-        let profile = self.profile.try_read().unwrap();
-        log::debug!("Number of samples: {}", profile.samples.len());
-
-        if self.configuration.use_experimental_serializer {
-            let mut ser = ProfileSerializer2::new();
-            ser.serialize(&profile);
-            ser.to_ruby_hash()
-        } else {
-            let serialized = ProfileSerializer::serialize(&profile);
-            let string = CString::new(serialized).unwrap();
-            unsafe { rb_str_new_cstr(string.as_ptr()) }
-        }
-    }
-
-    fn on_new_thread(&self, thread: VALUE) {
-        self.install_timer_to_ruby_thread(thread);
-    }
-
-    fn dmark(&self) {
-        match self.profile.read() {
-            Ok(profile) => unsafe {
-                profile.dmark();
-            },
-            Err(_) => {
-                panic!("[pf2 FATAL] dmark: Failed to acquire profile lock.");
-            }
-        }
-    }
-
-    fn dfree(&self) {
-        // No-op
-    }
-
-    fn dsize(&self) -> size_t {
-        // FIXME: Report something better
-        mem::size_of::<Self>() as size_t
-    }
-}
-
-impl SignalScheduler {
-    pub fn new(configuration: &Configuration, profile: Arc<RwLock<Profile>>) -> Self {
-        Self { configuration: configuration.clone(), profile }
-    }
-
-    // Install signal handler for profiling events to the current process.
-    fn install_signal_handler(&self) {
-        let mut sa: libc::sigaction = unsafe { mem::zeroed() };
-        sa.sa_sigaction = Self::signal_handler as usize;
-        sa.sa_flags = libc::SA_SIGINFO | libc::SA_RESTART;
-        let err = unsafe { libc::sigaction(libc::SIGALRM, &sa, null_mut()) };
-        if err != 0 {
-            panic!("sigaction failed: {}", err);
-        }
-        log::debug!("Signal handler installed");
-    }
-
-    // Respond to the signal and collect a sample.
-    // This function is called when a timer fires.
-    //
-    // Expected to be async-signal-safe, but the current implementation is not.
-    extern "C" fn signal_handler(
-        _sig: c_int,
-        info: *mut libc::siginfo_t,
-        _ucontext: *mut libc::ucontext_t,
-    ) {
-        let args = unsafe {
-            let ptr = extract_si_value_sival_ptr(info) as *mut SignalHandlerArgs;
-            ManuallyDrop::new(Box::from_raw(ptr))
-        };
-
-        let mut profile = match args.profile.try_write() {
-            Ok(profile) => profile,
-            Err(_) => {
-                // FIXME: Do we want to properly collect GC samples? I don't know yet.
-                log::trace!("Failed to acquire profile lock (garbage collection possibly in progress). Dropping sample.");
-                return;
-            }
-        };
-
-        let sample = Sample::capture(args.context_ruby_thread, &profile.backtrace_state); // NOT async-signal-safe
-        if profile.temporary_sample_buffer.push(sample).is_err() {
-            log::debug!("Temporary sample buffer full. Dropping sample.");
-        }
-    }
-
-    fn install_timer_to_ruby_thread(&self, ruby_thread: VALUE) {
-        // NOTE: This Box never gets dropped
-        let signal_handler_args = Box::new(SignalHandlerArgs {
-            profile: Arc::clone(&self.profile),
-            context_ruby_thread: ruby_thread,
-        });
-
-        // rb_funcall deadlocks when called within a THREAD_EVENT_STARTED hook
-        let kernel_thread_id: i32 = i32::try_from(unsafe {
-            rb_num2int(rb_funcall(
-                ruby_thread,
-                rb_intern(cstr!("native_thread_id")), // kernel thread ID
-                0,
-            ))
-        })
-        .unwrap();
-
-        // Create a signal event
-        let mut sigevent: libc::sigevent = unsafe { mem::zeroed() };
-        // Note: SIGEV_THREAD_ID is Linux-specific. In other platforms, we would need to
-        // "trampoline" the signal as any pthread can receive the signal.
-        sigevent.sigev_notify = libc::SIGEV_THREAD_ID;
-        sigevent.sigev_notify_thread_id = kernel_thread_id;
-        sigevent.sigev_signo = libc::SIGALRM;
-        // Pass required args to the signal handler
-        sigevent.sigev_value.sival_ptr = Box::into_raw(signal_handler_args) as *mut c_void;
-
-        // Create and configure timer to fire every _interval_ ms of CPU time
-        let mut timer: libc::timer_t = unsafe { mem::zeroed() };
-        let clockid = match self.configuration.time_mode {
-            configuration::TimeMode::CpuTime => unsafe { rb_thread_getcpuclockid(ruby_thread) },
-            configuration::TimeMode::WallTime => libc::CLOCK_MONOTONIC,
-        };
-        let err = unsafe { libc::timer_create(clockid, &mut sigevent, &mut timer) };
-        if err != 0 {
-            panic!("timer_create failed: {}", err);
-        }
-        let itimerspec = Self::duration_to_itimerspec(&self.configuration.interval);
-        let err = unsafe { libc::timer_settime(timer, 0, &itimerspec, null_mut()) };
-        if err != 0 {
-            panic!("timer_settime failed: {}", err);
-        }
-
-        log::debug!("timer registered for thread {}", ruby_thread);
-    }
-
-    fn duration_to_itimerspec(duration: &std::time::Duration) -> libc::itimerspec {
-        let nanos = duration.as_nanos();
-        let seconds_part: i64 = (nanos / 1_000_000_000).try_into().unwrap();
-        let nanos_part: i64 = (nanos % 1_000_000_000).try_into().unwrap();
-
-        let mut its: libc::itimerspec = unsafe { mem::zeroed() };
-        its.it_interval.tv_sec = seconds_part;
-        its.it_interval.tv_nsec = nanos_part;
-        its.it_value.tv_sec = seconds_part;
-        its.it_value.tv_nsec = nanos_part;
-        its
-    }
-}

data/ext/pf2/src/signal_scheduler_unsupported_platform.rs

@@ -1,39 +0,0 @@
-use std::sync::{Arc, RwLock};
-
-use crate::profile::Profile;
-use crate::scheduler::Scheduler;
-use crate::session::configuration::Configuration;
-
-pub struct SignalScheduler {}
-
-impl Scheduler for SignalScheduler {
-    fn start(&self) -> rb_sys::VALUE {
-        unimplemented!()
-    }
-
-    fn stop(&self) -> rb_sys::VALUE {
-        unimplemented!()
-    }
-
-    fn on_new_thread(&self, thread: rb_sys::VALUE) {
-        unimplemented!()
-    }
-
-    fn dmark(&self) {
-        unimplemented!()
-    }
-
-    fn dfree(&self) {
-        unimplemented!()
-    }
-
-    fn dsize(&self) -> rb_sys::size_t {
-        unimplemented!()
-    }
-}
-
-impl SignalScheduler {
-    pub fn new(configuration: &Configuration, profile: Arc<RwLock<Profile>>) -> Self {
-        unimplemented!()
-    }
-}

data/ext/pf2/src/timer_thread_scheduler.rs

@@ -1,179 +0,0 @@
-#![deny(unsafe_op_in_unsafe_fn)]
-
-use std::ffi::{c_void, CString};
-use std::mem::ManuallyDrop;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, RwLock};
-use std::thread;
-
-use rb_sys::*;
-
-use crate::profile::Profile;
-use crate::profile_serializer::ProfileSerializer;
-use crate::sample::Sample;
-use crate::scheduler::Scheduler;
-use crate::serialization::serializer::ProfileSerializer2;
-use crate::session::configuration::{self, Configuration};
-use crate::util::*;
-
-#[derive(Clone, Debug)]
-pub struct TimerThreadScheduler {
-    configuration: Arc<Configuration>,
-    profile: Arc<RwLock<Profile>>,
-    stop_requested: Arc<AtomicBool>,
-}
-
-#[derive(Debug)]
-struct PostponedJobArgs {
-    configuration: Arc<Configuration>,
-    profile: Arc<RwLock<Profile>>,
-}
-
-impl Scheduler for TimerThreadScheduler {
-    fn start(&self) -> VALUE {
-        // Register the Postponed Job which does the actual work of collecting samples
-        let postponed_job_args: Box<PostponedJobArgs> = Box::new(PostponedJobArgs {
-            configuration: Arc::clone(&self.configuration),
-            profile: Arc::clone(&self.profile),
-        });
-        let postponed_job_handle: rb_postponed_job_handle_t = unsafe {
-            rb_postponed_job_preregister(
-                0,
-                Some(Self::postponed_job),
-                Box::into_raw(postponed_job_args) as *mut c_void, // FIXME: leak
-            )
-        };
-
-        // Start a timer thread that periodically triggers postponed jobs based on configuration
-        let configuration = Arc::clone(&self.configuration);
-        let stop_requested = Arc::clone(&self.stop_requested);
-        thread::spawn(move || {
-            Self::thread_main_loop(configuration, stop_requested, postponed_job_handle)
-        });
-
-        Qtrue.into()
-    }
-
-    fn stop(&self) -> VALUE {
-        // Stop the collector thread
-        self.stop_requested.store(true, Ordering::Relaxed);
-
-        // Finalize
-        match self.profile.try_write() {
-            Ok(mut profile) => {
-                profile.flush_temporary_sample_buffer();
-                profile.end_instant = Some(std::time::Instant::now());
-            }
-            Err(_) => {
-                println!("[pf2 ERROR] stop: Failed to acquire profile lock.");
-                return Qfalse.into();
-            }
-        }
-
-        let profile = self.profile.try_read().unwrap();
-        log::debug!("Number of samples: {}", profile.samples.len());
-
-        if self.configuration.use_experimental_serializer {
-            let mut ser = ProfileSerializer2::new();
-            ser.serialize(&profile);
-            ser.to_ruby_hash()
-        } else {
-            let serialized = ProfileSerializer::serialize(&profile);
-            let string = CString::new(serialized).unwrap();
-            unsafe { rb_str_new_cstr(string.as_ptr()) }
-        }
-    }
-
-    fn on_new_thread(&self, _thread: VALUE) {
-        todo!();
-    }
-
-    fn dmark(&self) {
-        match self.profile.read() {
-            Ok(profile) => unsafe {
-                profile.dmark();
-            },
-            Err(_) => {
-                panic!("[pf2 FATAL] dmark: Failed to acquire profile lock.");
-            }
-        }
-    }
-
-    fn dfree(&self) {
-        // No-op
-    }
-
-    fn dsize(&self) -> size_t {
-        // FIXME: Report something better
-        std::mem::size_of::<TimerThreadScheduler>() as size_t
-    }
-}
-
-impl TimerThreadScheduler {
-    pub fn new(configuration: &Configuration, profile: Arc<RwLock<Profile>>) -> Self {
-        Self {
-            configuration: Arc::new(configuration.clone()),
-            profile,
-            stop_requested: Arc::new(AtomicBool::new(false)),
-        }
-
-        // cstr!("TimerThreadScheduler only supports :wall mode."),
-    }
-
-    fn thread_main_loop(
-        configuration: Arc<Configuration>,
-        stop_requested: Arc<AtomicBool>,
-        postponed_job_handle: rb_postponed_job_handle_t,
-    ) {
-        loop {
-            if stop_requested.fetch_and(true, Ordering::Relaxed) {
-                break;
-            }
-            unsafe {
-                log::trace!("Triggering postponed job");
-                rb_postponed_job_trigger(postponed_job_handle);
-            }
-
-            thread::sleep(configuration.interval);
-        }
-    }
-
-    unsafe extern "C" fn postponed_job(ptr: *mut c_void) {
-        unsafe {
-            rb_gc_disable();
-        }
-        let args = unsafe { ManuallyDrop::new(Box::from_raw(ptr as *mut PostponedJobArgs)) };
-
-        let mut profile = match args.profile.try_write() {
-            Ok(profile) => profile,
-            Err(_) => {
-                // FIXME: Do we want to properly collect GC samples? I don't know yet.
-                log::trace!("Failed to acquire profile lock (garbage collection possibly in progress). Dropping sample.");
-                return;
-            }
-        };
-
-        // Collect stack information from specified Ruby Threads
-        match &args.configuration.target_ruby_threads {
-            configuration::Threads::All => todo!(),
-            configuration::Threads::Targeted(threads) => {
-                for ruby_thread in threads.iter() {
-                    // Check if the thread is still alive
-                    if unsafe { rb_funcall(*ruby_thread, rb_intern(cstr!("status")), 0) }
-                        == Qfalse as u64
-                    {
-                        continue;
-                    }
-
-                    let sample = Sample::capture(*ruby_thread, &profile.backtrace_state);
-                    if profile.temporary_sample_buffer.push(sample).is_err() {
-                        log::debug!("Temporary sample buffer full. Dropping sample.");
-                    }
-                }
-            }
-        }
-        unsafe {
-            rb_gc_enable();
-        }
-    }
-}

data/ext/pf2/src/util.rs

@@ -1,31 +0,0 @@
-use core::mem::transmute;
-use rb_sys::*;
-use std::{ffi::c_void, u128};
-
-// Convert str literal to C string literal
-macro_rules! cstr {
-    ($s:expr) => {
-        concat!($s, "\0").as_ptr() as *const std::ffi::c_char
-    };
-}
-pub(crate) use cstr;
-
-pub type RubyCFunc = unsafe extern "C" fn() -> VALUE;
-
-// TODO: rewrite as macro
-pub fn to_ruby_cfunc_with_no_args<T>(f: unsafe extern "C" fn(T) -> VALUE) -> RubyCFunc {
-    unsafe { transmute::<unsafe extern "C" fn(T) -> VALUE, RubyCFunc>(f) }
-}
-pub fn to_ruby_cfunc_with_args<T, U, V>(f: unsafe extern "C" fn(T, U, V) -> VALUE) -> RubyCFunc {
-    unsafe { transmute::<unsafe extern "C" fn(T, U, V) -> VALUE, RubyCFunc>(f) }
-}
-
-#[allow(non_snake_case)]
-pub fn RTEST(v: VALUE) -> bool {
-    v != Qfalse as VALUE && v != Qnil as VALUE
-}
-
-extern "C" {
-    pub fn extract_si_value_sival_ptr(info: *mut libc::siginfo_t) -> *mut c_void;
-    pub fn rb_ull2num(n: u128) -> VALUE;
-}