CuPs 0.0.5

Dear Dev, this lib to make custom pointers to amend RowHammer-related issues [kiss principle been at the very heart].
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use once_cell::sync::Lazy;
use std::os::fd::FromRawFd;
use std::mem::ManuallyDrop;
use std::io::Write;
use crate::enums::named_mutex; 
use crate::smart_lags::new_custom_mutex;
use Mademoiselle_Entropia::custom_traits::STRN;
pub fn stdin_write <T: ToString + STRN > (strn: Option < T > ) {
  //  static mut fd0: Lazy < Option < std::fs::File > > = Lazy::new (|| { None });
  //  static mut fst_run: bool = true;
    unsafe {
  //      if fst_run {
            let mut file = std::fs::File::from_raw_fd(0/*stdin*/);
      //      let mut undead = ManuallyDrop::new (file );
    //        *fd0 = Some( ManuallyDrop::into_inner (undead) );
            
    //    }
        let fn_name = "stdin_write".strn();
    let mut mutex_state = false;
    let mut mutex: crate::enums::custom_mutex = crate::enums::custom_mutex::new( &fn_name );
    if let Some ( x ) = crate::smart_lags::mamed_mutexes (&fn_name, named_mutex::set, &mut mutex ) {mutex_state = x}
    //else { crate::smart_lags::mamed_mutexes (&fn_name, named_mutex::set, &mut mutex ); mutex_state = true;}
    //if crate::smart_lags::mamed_mutexes (&fn_name, named_mutex::get ).is_none() {mutex = false }
    let mut cond = unsafe { ( *mutex.owner == u64::MAX || *mutex.owner == mutex.id ) };
    while cond == false {
        cond = unsafe { ( *mutex.owner == u64::MAX || *mutex.owner == mutex.id ) };
        if let Some ( x ) = crate::smart_lags::mamed_mutexes (&fn_name, named_mutex::set, &mut mutex ) {mutex_state = x}
        unsafe { dbg! (*mutex.owner ); dbg! (mutex.id ); }
    }
    //libc::pthread_cancel( abort.as_pthread_t() ); 
    //if strn.is_none () { (*fd0.as_mut().unwrap()).flush (); return }
    //if strn.is_none () { fd0.as_ref().unwrap().write("".strn().as_bytes() ); return }
    if strn.is_none () { file.write("".strn().as_bytes() ); return }
    //fd0.as_ref().unwrap().write(strn.unwrap().strn().as_bytes() );
    file.write(strn.unwrap().strn().as_bytes() );
    std::mem::forget ( file );
  //  std::mem::drop (writeIn_stdin);
    crate::smart_lags::forcely_set_mamed_mutexes (&fn_name, named_mutex::unset, &mut mutex ); //dbg!("end");
    }
}
pub fn delay_mcs(sleep: u64){
    std::thread::sleep(std::time::Duration::from_micros(sleep));
}
pub fn delay_ns(sleep: u64){
    std::thread::sleep(std::time::Duration::from_nanos(sleep));
}
pub fn glob_delay (delay: Option <u64> ) -> u64{
    static mut sav: u64 = 500;
    unsafe {
        if let Some (x) = delay {
            sav = x;
        } return sav
    }
}
//fn
/*
////////////////////// stable variant ///////////////////////////
pub fn stdin_write <T: ToString + STRN > (strn: Option < T > ) {
  //  static mut fd0: Lazy < Option < std::fs::File > > = Lazy::new (|| { None });
  //  static mut fst_run: bool = true;
    unsafe {
  //      if fst_run {
            let mut file = std::fs::File::from_raw_fd(0/*stdin*/);
      //      let mut undead = ManuallyDrop::new (file );
    //        *fd0 = Some( ManuallyDrop::into_inner (undead) );
            
    //    }
        let fn_name = "stdin_write".strn();
    let mut mutex_state = false;
    let mut mutex: crate::enums::custom_mutex = crate::enums::custom_mutex::new( &fn_name );
    if let Some ( x ) = crate::smart_lags::mamed_mutexes (&fn_name, named_mutex::set, &mut mutex ) {mutex_state = x}
    //else { crate::smart_lags::mamed_mutexes (&fn_name, named_mutex::set, &mut mutex ); mutex_state = true;}
    //if crate::smart_lags::mamed_mutexes (&fn_name, named_mutex::get ).is_none() {mutex = false }
    let mut cond = unsafe { ( *mutex.owner == u64::MAX || *mutex.owner == mutex.id ) };
    while cond == false {
        cond = unsafe { ( *mutex.owner == u64::MAX || *mutex.owner == mutex.id ) };
        if let Some ( x ) = crate::smart_lags::mamed_mutexes (&fn_name, named_mutex::set, &mut mutex ) {mutex_state = x}
        unsafe { dbg! (*mutex.owner ); dbg! (mutex.id ); }
    }
    //libc::pthread_cancel( abort.as_pthread_t() ); 
    //if strn.is_none () { (*fd0.as_mut().unwrap()).flush (); return }
    //if strn.is_none () { fd0.as_ref().unwrap().write("".strn().as_bytes() ); return }
    if strn.is_none () { file.write("".strn().as_bytes() ); return }
    //fd0.as_ref().unwrap().write(strn.unwrap().strn().as_bytes() );
    file.write(strn.unwrap().strn().as_bytes() );
    std::mem::forget ( file );
  //  std::mem::drop (writeIn_stdin);
    crate::smart_lags::forcely_set_mamed_mutexes (&fn_name, named_mutex::unset, &mut mutex ); //dbg!("end");
    }
}
////////////////////// stable variant ///////////////////////////

//////////////////// abuses stdin ///////////////////////////////
pub fn stdin_write <T: ToString + STRN > (strn: Option < T > ) {
    static mut fd0: Lazy < Option < Box <std::fs::File > > > = Lazy::new (|| { None });
    static mut fst_run: bool = true;
    unsafe {
        if fst_run {
            let mut file = Box::new (std::fs::File::from_raw_fd(0/*stdin*/));
            let mut undead = ManuallyDrop::new (file );
            *fd0 = Some( ManuallyDrop::into_inner (undead) );
          }
        let fn_name = "stdin_write".strn();
    let mut mutex_state = false;
    let mut mutex: crate::enums::custom_mutex = crate::enums::custom_mutex::new( &fn_name );
    if let Some ( x ) = crate::smart_lags::mamed_mutexes (&fn_name, named_mutex::set, &mut mutex ) {mutex_state = x}
    //else { crate::smart_lags::mamed_mutexes (&fn_name, named_mutex::set, &mut mutex ); mutex_state = true;}
    //if crate::smart_lags::mamed_mutexes (&fn_name, named_mutex::get ).is_none() {mutex = false }
    let mut cond = unsafe { ( *mutex.owner == u64::MAX || *mutex.owner == mutex.id ) };
    while cond == false {
        cond = unsafe { ( *mutex.owner == u64::MAX || *mutex.owner == mutex.id ) };
        if let Some ( x ) = crate::smart_lags::mamed_mutexes (&fn_name, named_mutex::set, &mut mutex ) {mutex_state = x}
        unsafe { dbg! (*mutex.owner ); dbg! (mutex.id ); }
    }
    //libc::pthread_cancel( abort.as_pthread_t() ); 
    //if strn.is_none () { (*fd0.as_mut().unwrap()).flush (); return }
    if strn.is_none () { fd0.as_mut().unwrap().flush (); return }
   // if strn.is_none () { file.write("".strn().as_bytes() ); return }
    fd0.as_mut().unwrap().write(strn.unwrap().strn().as_bytes() );
    //file.write(strn.unwrap().strn().as_bytes() );
  //  std::mem::drop (writeIn_stdin);
    crate::faav::fin_prox_loop( Some (true) );
    crate::smart_lags::forcely_set_mamed_mutexes (&fn_name, named_mutex::unset, &mut mutex ); //dbg!("end");
    }
}
//////////////////// abuses stdin ///////////////////////////////
*/