pf2 0.8.0 → 1.0.0.alpha1

data/ext/pf2/src/ruby_init.rs

@@ -1,40 +0,0 @@
-#![deny(unsafe_op_in_unsafe_fn)]
-
-use rb_sys::*;
-
-use crate::session::ruby_object::SessionRubyObject;
-use crate::util::*;
-
-#[allow(non_snake_case)]
-#[no_mangle]
-extern "C" fn Init_pf2() {
-    #[cfg(feature = "debug")]
-    {
-        env_logger::builder().format_timestamp(None).format_module_path(false).init();
-    }
-
-    unsafe {
-        let rb_mPf2: VALUE = rb_define_module(cstr!("Pf2"));
-
-        let rb_mPf2_Session = rb_define_class_under(rb_mPf2, cstr!("Session"), rb_cObject);
-        rb_define_alloc_func(rb_mPf2_Session, Some(SessionRubyObject::rb_alloc));
-        rb_define_method(
-            rb_mPf2_Session,
-            cstr!("initialize"),
-            Some(to_ruby_cfunc_with_args(SessionRubyObject::rb_initialize)),
-            -1,
-        );
-        rb_define_method(
-            rb_mPf2_Session,
-            cstr!("start"),
-            Some(to_ruby_cfunc_with_no_args(SessionRubyObject::rb_start)),
-            0,
-        );
-        rb_define_method(
-            rb_mPf2_Session,
-            cstr!("stop"),
-            Some(to_ruby_cfunc_with_no_args(SessionRubyObject::rb_stop)),
-            0,
-        );
-    }
-}

data/ext/pf2/src/ruby_internal_apis.rs

@@ -1,77 +0,0 @@
-#![allow(non_snake_case)]
-#![allow(non_camel_case_types)]
-
-use libc::{clockid_t, pthread_t};
-use rb_sys::{rb_check_typeddata, rb_data_type_struct, RTypedData, VALUE};
-use std::ffi::{c_char, c_int, c_void};
-use std::mem::MaybeUninit;
-
-#[cfg(target_os = "linux")]
-use libc::pthread_getcpuclockid;
-
-#[cfg(not(target_os = "linux"))]
-pub unsafe fn pthread_getcpuclockid(thread: pthread_t, clk_id: *mut clockid_t) -> c_int {
-    unimplemented!()
-}
-
-// Types and structs from Ruby 3.4.0.
-#[repr(C)]
-pub struct rb_callable_method_entry_struct {
-    /* same fields with rb_method_entry_t */
-    pub flags: VALUE,
-    _padding_defined_class: VALUE,
-    pub def: *mut rb_method_definition_struct,
-    // ...
-}
-
-#[repr(C)]
-pub struct rb_method_definition_struct {
-    pub type_: c_int,
-    _padding: [c_char; 4],
-    pub cfunc: rb_method_cfunc_struct,
-    // ...
-}
-
-#[repr(C)]
-pub struct rb_method_cfunc_struct {
-    pub func: *mut c_void,
-    // ...
-}
-
-type rb_nativethread_id_t = libc::pthread_t;
-
-#[repr(C)]
-struct rb_native_thread {
-    _padding_serial: [c_char; 4], // rb_atomic_t
-    _padding_vm: *mut c_int,      // struct rb_vm_struct
-    thread_id: rb_nativethread_id_t,
-    // ...
-}
-
-#[repr(C)]
-struct rb_thread_struct {
-    _padding_lt_node: [c_char; 16], // struct ccan_list_node
-    _padding_self: VALUE,
-    _padding_ractor: *mut c_int, // rb_ractor_t
-    _padding_vm: *mut c_int,     // rb_vm_t
-    nt: *mut rb_native_thread,
-    // ...
-}
-type rb_thread_t = rb_thread_struct;
-
-/// Reimplementation of the internal RTYPEDDATA_TYPE macro.
-unsafe fn RTYPEDDATA_TYPE(obj: VALUE) -> *const rb_data_type_struct {
-    let typed: *mut RTypedData = obj as *mut RTypedData;
-    (*typed).type_
-}
-
-unsafe fn rb_thread_ptr(thread: VALUE) -> *mut rb_thread_t {
-    unsafe { rb_check_typeddata(thread, RTYPEDDATA_TYPE(thread)) as *mut rb_thread_t }
-}
-
-pub unsafe fn rb_thread_getcpuclockid(thread: VALUE) -> clockid_t {
-    let mut cid: clockid_t = MaybeUninit::zeroed().assume_init();
-    let pthread_id: pthread_t = (*(*rb_thread_ptr(thread)).nt).thread_id;
-    pthread_getcpuclockid(pthread_id, &mut cid as *mut clockid_t);
-    cid
-}

data/ext/pf2/src/sample.rs

@@ -1,67 +0,0 @@
-use std::time::Instant;
-
-use rb_sys::*;
-
-use crate::backtrace::{Backtrace, BacktraceState};
-
-const MAX_STACK_DEPTH: usize = 500;
-const MAX_C_STACK_DEPTH: usize = 1000;
-
-#[derive(Debug, PartialEq)]
-pub struct Sample {
-    pub ruby_thread: VALUE,
-    pub timestamp: Instant,
-    pub line_count: i32,
-    pub frames: [VALUE; MAX_STACK_DEPTH],
-    pub linenos: [i32; MAX_STACK_DEPTH],
-    /// First element represents the backtrace depth.
-    pub c_backtrace_pcs: [usize; MAX_C_STACK_DEPTH + 1],
-}
-
-impl Sample {
-    // Nearly async-signal-safe
-    // (rb_profile_thread_frames isn't defined as a-s-s)
-    pub fn capture(ruby_thread: VALUE, backtrace_state: &BacktraceState) -> Self {
-        let mut c_backtrace_pcs = [0; MAX_C_STACK_DEPTH + 1];
-
-        Backtrace::backtrace_simple(
-            backtrace_state,
-            0,
-            |pc: usize| -> i32 {
-                if c_backtrace_pcs[0] >= MAX_C_STACK_DEPTH {
-                    return 1;
-                }
-                c_backtrace_pcs[0] += 1;
-                c_backtrace_pcs[c_backtrace_pcs[0]] = pc;
-                0
-            },
-            Some(Backtrace::backtrace_error_callback),
-        );
-
-        let mut sample = Sample {
-            ruby_thread,
-            timestamp: Instant::now(),
-            line_count: 0,
-            frames: [0; MAX_STACK_DEPTH],
-            linenos: [0; MAX_STACK_DEPTH],
-            c_backtrace_pcs,
-        };
-        unsafe {
-            sample.line_count = rb_profile_thread_frames(
-                ruby_thread,
-                0,
-                2000,
-                sample.frames.as_mut_ptr(),
-                sample.linenos.as_mut_ptr(),
-            );
-        };
-        sample
-    }
-
-    pub unsafe fn dmark(&self) {
-        rb_gc_mark(self.ruby_thread);
-        for frame in self.frames.iter() {
-            rb_gc_mark(*frame);
-        }
-    }
-}

data/ext/pf2/src/scheduler.rs

@@ -1,10 +0,0 @@
-use rb_sys::{size_t, VALUE};
-
-pub trait Scheduler {
-    fn start(&self) -> VALUE;
-    fn stop(&self) -> VALUE;
-    fn on_new_thread(&self, thread: VALUE);
-    fn dmark(&self);
-    fn dfree(&self);
-    fn dsize(&self) -> size_t;
-}

data/ext/pf2/src/serialization/profile.rs

@@ -1,48 +0,0 @@
-#[derive(Clone, Deserialize, Serialize)]
-pub struct Profile {
-    pub samples: Vec<Sample>,
-    pub locations: Vec<Location>,
-    pub functions: Vec<Function>,
-    pub start_timestamp_ns: u128,
-    pub duration_ns: u128,
-}
-
-pub type LocationIndex = usize;
-pub type FunctionIndex = usize;
-
-/// Sample
-#[derive(Clone, Serialize, Deserialize)]
-pub struct Sample {
-    /// The stack leading to this sample.
-    /// The leaf node will be stored at `stack[0]`.
-    pub stack: Vec<LocationIndex>,
-    pub native_stack: Vec<LocationIndex>,
-    pub ruby_thread_id: Option<u64>,
-    pub elapsed_ns: u64,
-}
-
-/// Location represents a location (line) in the source code when a sample was captured.
-#[derive(Clone, PartialEq, Serialize, Deserialize)]
-pub struct Location {
-    pub function_index: FunctionIndex,
-    pub lineno: i32,
-    pub address: Option<usize>,
-}
-
-/// Function represents a Ruby method or a C function in the profile.
-#[derive(Clone, PartialEq, Serialize, Deserialize)]
-pub struct Function {
-    pub implementation: FunctionImplementation,
-    pub name: Option<String>, // unique key
-    pub filename: Option<String>,
-    /// The first line number in the method/function definition.
-    /// For the actual location (line) which was hit during sample capture, refer to `Location.lineno`.
-    pub start_lineno: Option<i32>,
-    pub start_address: Option<usize>,
-}
-
-#[derive(Clone, PartialEq, Serialize, Deserialize)]
-pub enum FunctionImplementation {
-    Ruby,
-    Native,
-}

data/ext/pf2/src/serialization/serializer.rs

@@ -1,329 +0,0 @@
-use std::ffi::{c_char, CStr, CString};
-
-use rb_sys::*;
-
-use super::profile::{
-    Function, FunctionImplementation, FunctionIndex, Location, LocationIndex, Profile, Sample,
-};
-use crate::backtrace::Backtrace;
-use crate::util::{cstr, RTEST};
-
-pub struct ProfileSerializer2 {
-    profile: Profile,
-}
-
-impl ProfileSerializer2 {
-    pub fn new() -> ProfileSerializer2 {
-        ProfileSerializer2 {
-            profile: Profile {
-                start_timestamp_ns: 0,
-                duration_ns: 0,
-                samples: vec![],
-                locations: vec![],
-                functions: vec![],
-            },
-        }
-    }
-
-    pub fn serialize(&mut self, source: &crate::profile::Profile) {
-        // Fill in meta fields
-        self.profile.start_timestamp_ns =
-            source.start_timestamp.duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
-        self.profile.duration_ns =
-            source.end_instant.unwrap().duration_since(source.start_instant).as_nanos();
-
-        // Create a Sample for each sample collected
-        for sample in source.samples.iter() {
-            // Iterate over the Ruby stack
-            let mut stack: Vec<LocationIndex> = vec![];
-            let ruby_stack_depth = sample.line_count;
-            for i in 0..ruby_stack_depth {
-                let frame: VALUE = sample.frames[i as usize];
-                let lineno: i32 = sample.linenos[i as usize];
-                let function = Self::extract_function_from_ruby_frame(frame);
-
-                let function_index = self.function_index_for(function);
-                let location_index = self.location_index_for(function_index, lineno);
-                stack.push(location_index);
-            }
-
-            // Iterate over the native stack
-            let mut native_stack: Vec<LocationIndex> = vec![];
-            let native_stack_depth = sample.c_backtrace_pcs[0];
-            for i in 1..(native_stack_depth - 1) {
-                let pc = sample.c_backtrace_pcs[i];
-                let function = Self::extract_function_from_native_pc(pc, source);
-
-                let function_index = self.function_index_for(function);
-                let location_index = self.location_index_for(function_index, 0);
-                native_stack.push(location_index);
-            }
-
-            self.profile.samples.push(Sample {
-                stack,
-                native_stack,
-                ruby_thread_id: Some(sample.ruby_thread),
-                elapsed_ns: sample.timestamp.duration_since(source.start_instant).as_nanos() as u64,
-            });
-        }
-    }
-
-    /// Returns the index of the function in `functions`.
-    /// Calling this method will modify `self.profile` in place.
-    fn function_index_for(&mut self, function: Function) -> FunctionIndex {
-        match self.profile.functions.iter_mut().position(|f| *f == function) {
-            Some(index) => index,
-            None => {
-                self.profile.functions.push(function);
-                self.profile.functions.len() - 1
-            }
-        }
-    }
-
-    /// Returns the index of the location in `locations`.
-    /// Calling this method will modify `self.profile` in place.
-    fn location_index_for(&mut self, function_index: FunctionIndex, lineno: i32) -> LocationIndex {
-        // Build a Location based on (1) the Function and (2) the actual line hit during sampling.
-        let location = Location { function_index, lineno, address: None };
-        match self.profile.locations.iter_mut().position(|l| *l == location) {
-            Some(index) => index,
-            None => {
-                self.profile.locations.push(location);
-                self.profile.locations.len() - 1
-            }
-        }
-    }
-
-    /// Build a Function from a Ruby frame.
-    fn extract_function_from_ruby_frame(frame: VALUE) -> Function {
-        unsafe {
-            let mut frame_full_label: VALUE = rb_profile_frame_full_label(frame);
-            let frame_full_label: Option<String> = if RTEST(frame_full_label) {
-                Some(
-                    CStr::from_ptr(rb_string_value_cstr(&mut frame_full_label))
-                        .to_str()
-                        .unwrap()
-                        .to_owned(),
-                )
-            } else {
-                None
-            };
-
-            let mut frame_path: VALUE = rb_profile_frame_path(frame);
-            let frame_path: Option<String> = if RTEST(frame_path) {
-                Some(
-                    CStr::from_ptr(rb_string_value_cstr(&mut frame_path))
-                        .to_str()
-                        .unwrap()
-                        .to_owned(),
-                )
-            } else {
-                None
-            };
-
-            let frame_first_lineno: VALUE = rb_profile_frame_first_lineno(frame);
-            let frame_first_lineno: Option<i32> = if RTEST(frame_first_lineno) {
-                Some(rb_num2int(frame_first_lineno).try_into().unwrap())
-            } else {
-                None
-            };
-
-            let start_address = Self::get_underlying_c_function_address(frame);
-
-            Function {
-                implementation: FunctionImplementation::Ruby,
-                name: frame_full_label,
-                filename: frame_path,
-                start_lineno: frame_first_lineno,
-                start_address,
-            }
-        }
-    }
-
-    fn get_underlying_c_function_address(frame: VALUE) -> Option<usize> {
-        unsafe {
-            let cme = frame as *mut crate::ruby_internal_apis::rb_callable_method_entry_struct;
-            let cme = &*cme; // *mut to reference
-
-            if (*(cme.def)).type_ == 1 {
-                // The cme is a Cfunc
-                Some((*(cme.def)).cfunc.func as usize)
-            } else {
-                // The cme is an ISeq (Ruby code) or some other type
-                None
-            }
-        }
-    }
-
-    /// Build a Function from a PC (program counter) obtained by libbacktrace.
-    fn extract_function_from_native_pc(pc: usize, source: &crate::profile::Profile) -> Function {
-        // Obtain the function name and address using libbacktrace
-        let mut function: Option<Function> = None;
-        Backtrace::backtrace_syminfo(
-            &source.backtrace_state,
-            pc,
-            |_pc: usize, symname: *const c_char, symval: usize, _symsize: usize| unsafe {
-                function = Some(Function {
-                    implementation: FunctionImplementation::Native,
-                    name: if symname.is_null() {
-                        None
-                    } else {
-                        Some(CStr::from_ptr(symname).to_str().unwrap().to_owned())
-                    },
-                    filename: None,
-                    start_lineno: None,
-                    start_address: Some(symval),
-                });
-            },
-            Some(Backtrace::backtrace_error_callback),
-        );
-        function.unwrap()
-    }
-
-    pub fn to_ruby_hash(&self) -> VALUE {
-        unsafe {
-            let hash: VALUE = rb_hash_new();
-
-            // profile[:start_timestamp_ns]
-            rb_hash_aset(
-                hash,
-                rb_id2sym(rb_intern(cstr!("start_timestamp_ns"))),
-                rb_int2inum(self.profile.start_timestamp_ns as isize),
-            );
-            // profile[:duration_ns]
-            rb_hash_aset(
-                hash,
-                rb_id2sym(rb_intern(cstr!("duration_ns"))),
-                rb_int2inum(self.profile.duration_ns as isize),
-            );
-
-            // profile[:samples]
-            let samples: VALUE = rb_ary_new();
-            for sample in self.profile.samples.iter() {
-                // sample[:stack]
-                let stack: VALUE = rb_ary_new();
-                for &location_index in sample.stack.iter() {
-                    rb_ary_push(stack, rb_int2inum(location_index as isize));
-                }
-                // sample[:native_stack]
-                let native_stack: VALUE = rb_ary_new();
-                for &location_index in sample.native_stack.iter() {
-                    rb_ary_push(native_stack, rb_int2inum(location_index as isize));
-                }
-                // sample[:ruby_thread_id]
-                let ruby_thread_id = if let Some(ruby_thread_id) = sample.ruby_thread_id {
-                    rb_int2inum(ruby_thread_id as isize)
-                } else {
-                    Qnil as VALUE
-                };
-                // sample[:elapsed_ns]
-                let elapsed_ns = rb_ull2inum(sample.elapsed_ns);
-
-                let sample_hash: VALUE = rb_hash_new();
-                rb_hash_aset(sample_hash, rb_id2sym(rb_intern(cstr!("stack"))), stack);
-                rb_hash_aset(
-                    sample_hash,
-                    rb_id2sym(rb_intern(cstr!("native_stack"))),
-                    native_stack,
-                );
-                rb_hash_aset(
-                    sample_hash,
-                    rb_id2sym(rb_intern(cstr!("ruby_thread_id"))),
-                    ruby_thread_id,
-                );
-                rb_hash_aset(sample_hash, rb_id2sym(rb_intern(cstr!("elapsed_ns"))), elapsed_ns);
-
-                rb_ary_push(samples, sample_hash);
-            }
-            rb_hash_aset(hash, rb_id2sym(rb_intern(cstr!("samples"))), samples);
-
-            // profile[:locations]
-            let locations = rb_ary_new();
-            for location in self.profile.locations.iter() {
-                let location_hash: VALUE = rb_hash_new();
-                // location[:function_index]
-                rb_hash_aset(
-                    location_hash,
-                    rb_id2sym(rb_intern(cstr!("function_index"))),
-                    rb_int2inum(location.function_index as isize),
-                );
-                // location[:lineno]
-                rb_hash_aset(
-                    location_hash,
-                    rb_id2sym(rb_intern(cstr!("lineno"))),
-                    rb_int2inum(location.lineno as isize),
-                );
-                // location[:address]
-                rb_hash_aset(
-                    location_hash,
-                    rb_id2sym(rb_intern(cstr!("address"))),
-                    if let Some(address) = location.address {
-                        rb_int2inum(address as isize)
-                    } else {
-                        Qnil as VALUE
-                    },
-                );
-                rb_ary_push(locations, location_hash);
-            }
-            rb_hash_aset(hash, rb_id2sym(rb_intern(cstr!("locations"))), locations);
-
-            // profile[:functions]
-            let functions = rb_ary_new();
-            for function in self.profile.functions.iter() {
-                let function_hash: VALUE = rb_hash_new();
-                // function[:implementation]
-                rb_hash_aset(
-                    function_hash,
-                    rb_id2sym(rb_intern(cstr!("implementation"))),
-                    match function.implementation {
-                        FunctionImplementation::Ruby => rb_id2sym(rb_intern(cstr!("ruby"))),
-                        FunctionImplementation::Native => rb_id2sym(rb_intern(cstr!("native"))),
-                    },
-                );
-
-                // function[:name]
-                let name: VALUE = match &function.name {
-                    Some(name) => {
-                        let cstring = CString::new(name.as_str()).unwrap();
-                        rb_str_new_cstr(cstring.as_ptr())
-                    }
-                    None => Qnil as VALUE,
-                };
-                rb_hash_aset(function_hash, rb_id2sym(rb_intern(cstr!("name"))), name);
-                // function[:filename]
-                let filename: VALUE = match &function.filename {
-                    Some(filename) => {
-                        let cstring = CString::new(filename.as_str()).unwrap();
-                        rb_str_new_cstr(cstring.as_ptr())
-                    }
-                    None => Qnil as VALUE,
-                };
-                rb_hash_aset(function_hash, rb_id2sym(rb_intern(cstr!("filename"))), filename);
-                // function[:start_lineno]
-                rb_hash_aset(
-                    function_hash,
-                    rb_id2sym(rb_intern(cstr!("start_lineno"))),
-                    if let Some(start_lineno) = function.start_lineno {
-                        rb_int2inum(start_lineno as isize)
-                    } else {
-                        Qnil as VALUE
-                    },
-                );
-                // function[:start_address]
-                rb_hash_aset(
-                    function_hash,
-                    rb_id2sym(rb_intern(cstr!("start_address"))),
-                    if let Some(start_address) = function.start_address {
-                        rb_int2inum(start_address as isize)
-                    } else {
-                        Qnil as VALUE
-                    },
-                );
-                rb_ary_push(functions, function_hash);
-            }
-            rb_hash_aset(hash, rb_id2sym(rb_intern(cstr!("functions"))), functions);
-
-            hash
-        }
-    }
-}

data/ext/pf2/src/serialization.rs

@@ -1,2 +0,0 @@
-pub mod profile;
-pub mod serializer;

data/ext/pf2/src/session/configuration.rs

@@ -1,114 +0,0 @@
-use std::collections::HashSet;
-use std::str::FromStr;
-use std::time::Duration;
-
-use rb_sys::*;
-
-use crate::util::cstr;
-
-#[cfg(target_os = "linux")]
-pub const DEFAULT_SCHEDULER: Scheduler = Scheduler::Signal;
-#[cfg(target_os = "linux")]
-pub const DEFAULT_TIME_MODE: TimeMode = TimeMode::CpuTime;
-#[cfg(not(target_os = "linux"))]
-pub const DEFAULT_SCHEDULER: Scheduler = Scheduler::TimerThread;
-#[cfg(not(target_os = "linux"))]
-pub const DEFAULT_TIME_MODE: TimeMode = TimeMode::WallTime;
-
-pub const DEFAULT_INTERVAL: Duration = Duration::from_millis(9);
-
-#[derive(Clone, Debug)]
-pub struct Configuration {
-    pub scheduler: Scheduler,
-    pub interval: Duration,
-    pub time_mode: TimeMode,
-    pub target_ruby_threads: Threads,
-    pub use_experimental_serializer: bool,
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum Scheduler {
-    Signal,
-    TimerThread,
-}
-
-impl FromStr for Scheduler {
-    type Err = ();
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "signal" => Ok(Self::Signal),
-            "timer_thread" => Ok(Self::TimerThread),
-            _ => Err(()),
-        }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum TimeMode {
-    CpuTime,
-    WallTime,
-}
-
-impl FromStr for TimeMode {
-    type Err = ();
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "cpu" => Ok(Self::CpuTime),
-            "wall" => Ok(Self::WallTime),
-            _ => Err(()),
-        }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum Threads {
-    All,
-    Targeted(HashSet<VALUE>),
-}
-
-impl Configuration {
-    pub fn validate(&self) -> Result<(), String> {
-        if self.scheduler == Scheduler::TimerThread && self.time_mode == TimeMode::CpuTime {
-            return Err("TimerThread scheduler does not support `time_mode: :cpu`.".to_owned());
-        }
-        if self.scheduler == Scheduler::TimerThread && self.target_ruby_threads == Threads::All {
-            return Err(concat!(
-                "TimerThread scheduler does not support `threads: :all` at the moment. ",
-                "Consider using `threads: Thread.list` for watching all threads at profiler start."
-            )
-            .to_owned());
-        }
-
-        Ok(())
-    }
-
-    pub fn to_rb_hash(&self) -> VALUE {
-        let hash: VALUE = unsafe { rb_hash_new() };
-        unsafe {
-            rb_hash_aset(
-                hash,
-                rb_id2sym(rb_intern(cstr!("scheduler"))),
-                rb_id2sym(rb_intern(match self.scheduler {
-                    Scheduler::Signal => cstr!("signal"),
-                    Scheduler::TimerThread => cstr!("timer_thread"),
-                })),
-            );
-            rb_hash_aset(
-                hash,
-                rb_id2sym(rb_intern(cstr!("interval_ms"))),
-                rb_int2inum(self.interval.as_millis().try_into().unwrap()),
-            );
-            rb_hash_aset(
-                hash,
-                rb_id2sym(rb_intern(cstr!("time_mode"))),
-                rb_id2sym(rb_intern(match self.time_mode {
-                    TimeMode::CpuTime => cstr!("cpu"),
-                    TimeMode::WallTime => cstr!("wall"),
-                })),
-            );
-        }
-        hash
-    }
-}