Rust의 uninitialized와 forget

uninitialized

러스트는 객체의 초기화, 혹은 객체를 참조하기 전에 객체를 생성하는 것을 강제한다. 그렇게 해야 초보자가 하기 쉬운 쓰레기값을 가진 객체를 사용하는 실수를 방지하기 위해서이다.

하지만 항상 그렇게 하는 것은 피곤할 수 있고, 초기화를 안해도 되는 객체 또한 있기 마련이다. 이를 위해서 Rust에서는 uninitialized함수를 제공한다.

fn main() {
    let num = unsafe{std::mem::uninitialized::<i32>()};
    println!("{}",num);
}

unitialized는 Rust 메모리 안전 관리 수칙에서 벗어나는 행위이기 때문에 '너 정말 이게 안전하지 않은 지 아니?라는 확인용인 unsafe구문 내에서만 사용할 수 있다. 이 코드를 실행하면 num의 값이 쓰레기 값인 걸 확인할 수 있다.

    Finished dev [unoptimized + debuginfo] target(s) in 0.41s
     Running `target\debug\tes.exe`
0x00000086
PS C:\Users\qwead\Documents\tes> cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.00s
     Running `target\debug\tes.exe`
0x00000098
PS C:\Users\qwead\Documents\tes> cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.00s
     Running `target\debug\tes.exe`
0x000000f4
PS C:\Users\qwead\Documents\tes> cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.00s
     Running `target\debug\tes.exe`
0x0000008b

forget

uninitialized가 객체를 생성할 때 Rust 메모리 관리 규칙을 벗어나는 방법을 제공한다면 forget은 객체를 삭제할 때 Rust 메모리 관리 규칙에서 벗어나는 방법을 제공한다.

Rust의 메모리 관리 규칙은 스코프가 끝날 때 그 스코프가 소유한 객체도 메모리를 해제한다. 이때 일반적인 객체가 아닌 파일IO관련 객체 혹은 동적메모리를 사용하는 객체의 경우 객체가 죽을 때 객체의 drop메소드가 호출되어 객체 자신이 정리할 시간을 제공한다.

하지만 forget은 drop메소드를 호출하지 않고 객체를 해제한다.

fn main() {
    {
        let mut s = Vec::<u128>::new();
        for _ in 0..std::u16::MAX as u32 * 16{
            s.push(0u128);
        }
        let mut n = String::new();
        println!("press any key");
        std::io::stdin().read_line(&mut n);
    }
    let mut n = String::new();
    println!("press any key");
    std::io::stdin().read_line(&mut n);
}

메모리를 정상적으로 확인하는 것을 볼 수 있다. 하지만 코드 중간에 forget함수를 삽입하여 drop메소드를 안 호출하고 객체를 제거하면

fn main() {
    {
        let mut s = Vec::<u128>::new();
        for _ in 0..std::u16::MAX as u32 * 16{
            s.push(0u128);
        }
        let mut n = String::new();
        println!("press any key");
        std::io::stdin().read_line(&mut n);
        std::mem::forget(s);
    }
    let mut n = String::new();
    println!("press any key");
    std::io::stdin().read_line(&mut n);
}

보다시피 메모리가 줄어 들지 않는 것을 확인할 수 있다.

이것들을 어떻게 사용할까?

여러군데 사용할 수 있는데 대표적으로는 합병정렬에서 사용할 수 있다.

fn sub_merge_sort<T>(source: *mut[T], memory:*mut[T])where T:PartialEq + PartialOrd{
	let s:&mut[T] = unsafe{ std::mem::transmute::<_, &mut[T]>(source) };
    let m:&mut[T] = unsafe{ std::mem::transmute::<_, &mut[T]>(memory) };
    if s.len() > 1{
        let len = s.len();
        let (s1,s2,m1,m2);
        unsafe{ 
            s1 = std::mem::transmute::<_, &mut[T]>(&mut s[0..len/2]);
            s2 = std::mem::transmute::<_, &mut[T]>(&mut s[len/2..len]);
            m1 = std::mem::transmute::<_, *mut[T]>(&m[0..len/2]);
            m2 = std::mem::transmute::<_, *mut[T]>(&m[len/2..len]);
        }
        sub_merge_sort(s1, m1);
        sub_merge_sort(s2, m2);
        let mem:&mut[T] =  unsafe{ std::mem::transmute::<_, &mut[T]>(memory) };
        let mut s1_it = s1.iter_mut();
        let mut s2_it = s2.iter_mut();
        let mut mem_it = mem.iter_mut();
        let mut sv1= s1_it.next();
        let mut sv2= s2_it.next();
        loop{
            let m = match mem_it.next(){
                Some(v)=>v,
                None=>break
            };
			
            let switch =
			match (&sv1,&sv2){
                (&None,& Some(_))=>2,
                (&Some(_),& None)=>1,
                (&Some(ref v1),&Some(ref v2))if v1 > v2=>2,
				(&Some(ref v1),&Some(ref v2))if v1 <= v2=>1,
                _=>{break;}
            };
			
			match switch{
				2=>{
					//let sv = &mut sv2;
					let v = sv2.unwrap();
					std::mem::swap(m,v);
					sv2 = s2_it.next()
				},
				1=>{
					let v = sv1.unwrap();
					std::mem::swap(m,v);
					sv1 = s1_it.next()
				}
				_=>{}
			}
        }

        let mut mi = m.iter_mut();
        let mut si = s.iter_mut();
        while let Some(sv) = si.next(){
            let mv = mi.next().unwrap();
			std::mem::swap(sv,mv);
        }
    }
}
fn merge_sort<T>(source:&mut[T])where T:PartialEq + PartialOrd{
	let mut tempMemory:Vec<T> = Vec::with_capacity(source.len());
	for _ in 0..source.len(){
		unsafe{tempMemory.push(std::mem::uninitialized());}
	}
	sub_merge_sort(source as *mut[T], tempMemory.as_mut_slice() as *mut[T]);
	for it in tempMemory{
		std::mem::forget(it);
	}
}