pub fn recover(&mut self) {
        #[cfg(not(any(feature = "no_pthread", windows)))] unsafe {
        crate::sync::init_lock(&mut self.mutex.0, &mut self.mutex.1);
        }

        #[cfg(any(feature = "no_pthread", windows))] {
        self.mutex = 0; }


        #[cfg(feature = "check_allocator_cyclic_links")]
        if !self.verify() {
            eprintln!("not verified before recovery");
        }

        if self.aux_valid {
            #[cfg(debug_assertions)]
            eprintln!("Crashed while the allocator was operating");

            #[cfg(feature = "verbose")] {
                if *crate::utils::VERBOSE {
                    self.aux.foreach(|(off, next)| {
                        let n = Self::buddy(off);
                        println!("aux @({:x}) {:x} -> {:x}", off, n.next, next);
                    });
    
                    self.log64.foreach(|(off, next)| {
                        let n = Self::buddy(off);
                        println!("log @({:x}) {:x} -> {:x}", off, n.next, next);
                    });
    
                    self.drop_log.foreach(|(off, len)| {
                        println!("drop ({:x}; {})", off, len);
                    });
                }
            }

            // continue draining
            self.drain_aux();

            // drop unnecessary allocations
            if !self.drop_log.is_empty() {
                eprintln!("Dropping unnecessary allocations");
                unsafe {
                    let self_mut = self as *mut Self;
                    self.drop_log.drain_atomic(|(off, len)| {
                        (*self_mut).dealloc_impl(off, len, false);
                    }, || {
                        (*self_mut).drain_aux();
                        (*self_mut).discard();
                    });
                }
                self.drop_log.clear();
            }

            #[cfg(debug_assertions)]
            self.check(module_path!());
        } else {
            self.aux.clear();
            self.log64.clear();
            self.drop_log.clear();
        }

        #[cfg(feature = "check_allocator_cyclic_links")]
        if !self.verify() {
            eprintln!("not verified after recovery");
        }
    }
/// Starts the recovery procedure. If the crash happened while draining the
/// auxiliary buffer, it continues draining it and making the remaining
/// changes. It is rational because the [`DropOnFailure`] log was taken
/// before draining the auxiliary buffer. When the draining is finished,
/// the higher-level log reclaims the allocation in the higher level
/// recovery procedure.
/// 
/// [`DropOnFailure`]: ../alloc/trait.MemPool.html#method.drop_on_failure
Starts the recovery procedure. If the crash happened while draining the
auxiliary buffer, it continues draining it and making the remaining
changes. It is rational because the [`DropOnFailure`] log was taken
before draining the auxiliary buffer. When the draining is finished,
the higher-level log reclaims the allocation in the higher level
recovery procedure.


Starts the recovery procedure . If the crash happened while draining the auxiliary buffer it continues draining it and making the remaining changes . It is rational because the [ ` DropOnFailure ` ] log was taken before draining the auxiliary buffer . When the draining is finished the higher - level log reclaims the allocation in the higher level recovery procedure .
pub fn recover(&mut self) {
        #[cfg(not(any(feature = "no_pthread", windows)))] unsafe {
        crate::sync::init_lock(&mut self.mutex.0, &mut self.mutex.1);
        }
        #[cfg(any(feature = "no_pthread", windows))] {
        self.mutex = 0; }
        #[cfg(feature = "check_allocator_cyclic_links")]
        if !self.verify() {
            eprintln!("not verified before recovery");
        }
        if self.aux_valid {
            #[cfg(debug_assertions)]
            eprintln!("Crashed while the allocator was operating");
            #[cfg(feature = "verbose")] {
                if *crate::utils::VERBOSE {
                    self.aux.foreach(|(off, next)| {
                        let n = Self::buddy(off);
                        println!("aux @({:x}) {:x} -> {:x}", off, n.next, next);
                    });
                    self.log64.foreach(|(off, next)| {
                        let n = Self::buddy(off);
                        println!("log @({:x}) {:x} -> {:x}", off, n.next, next);
                    });
                    self.drop_log.foreach(|(off, len)| {
                        println!("drop ({:x}; {})", off, len);
                    });
                }
            }
            // continue draining
            self.drain_aux();
            // drop unnecessary allocations
            if !self.drop_log.is_empty() {
                eprintln!("Dropping unnecessary allocations");
                unsafe {
                    let self_mut = self as *mut Self;
                    self.drop_log.drain_atomic(|(off, len)| {
                        (*self_mut).dealloc_impl(off, len, false);
                    }, || {
                        (*self_mut).drain_aux();
                        (*self_mut).discard();
                    });
                }
                self.drop_log.clear();
            }
            #[cfg(debug_assertions)]
            self.check(module_path!());
        } else {
            self.aux.clear();
            self.log64.clear();
            self.drop_log.clear();
        }
        #[cfg(feature = "check_allocator_cyclic_links")]
        if !self.verify() {
            eprintln!("not verified after recovery");
        }
    }
pub fn recover ( & mut self ) { # [ cfg ( not ( any ( feature " " windows ) ) ) ] unsafe { crate :: sync :: init_lock ( & mut self . mutex . 0 , & mut self . mutex . 1 ) ; } # [ cfg ( any ( feature " " windows ) ) ] { self . mutex = 0 ; } # [ cfg ( feature " " ) ] if ! self . verify ( ) { eprintln ! ( " " ) ; } if self . aux_valid { # [ cfg ( debug_assertions ) ] eprintln ! ( " " ) ; # [ cfg ( feature " " ) ] { if * crate :: utils :: VERBOSE { self . aux . foreach ( | ( off , next ) | { let n = Self :: buddy ( off ) ; println ! ( " " off n next next ) ; } ) ; self . log64 . foreach ( | ( off , next ) | { let n = Self :: buddy ( off ) ; println ! ( " " off n next next ) ; } ) ; self . drop_log . foreach ( | ( off , len ) | { println ! ( " " off len ) ; } ) ; } } // continue draining self . drain_aux ( ) ; // drop unnecessary allocations if ! self . drop_log . is_empty ( ) { eprintln ! ( " " ) ; unsafe { let self_mut = self as * mut Self ; self . drop_log . drain_atomic ( | ( off , len ) | { ( * self_mut ) . dealloc_impl ( off , len , false ) ; } , | | { ( * self_mut ) . drain_aux ( ) ; ( * self_mut ) . discard ( ) ; } ) ; } self . drop_log . clear ( ) ; } # [ cfg ( debug_assertions ) ] self . check ( module_path ! ( ) ) ; } else { self . aux . clear ( ) ; self . log64 . clear ( ) ; self . drop_log . clear ( ) ; } # [ cfg ( feature " " ) ] if ! self . verify ( ) { eprintln ! ( " " ) ; } }
Starts the recovery procedure.
Starts the recovery procedure .
&mut self