Mozilla ํ๋ก์ ํธ์ ์ํด ์ค๋ฆฝ๋์์ง๋ง ํ์ฌ๋ ๋ ๋ฆฝ์ ์ธ ๋น์๋ฆฌ ์กฐ์ง์ธ Rust Foundation์ ํ์์ผ๋ก ๊ฐ๋ฐ๋ Rust 1.59 ๋ฒ์ฉ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ์ถ์๊ฐ ๋ฐํ๋์์ต๋๋ค. ์ด ์ธ์ด๋ ๋ฉ๋ชจ๋ฆฌ ์์ ์ ์ค์ ์ ๋๊ณ ๊ฐ๋น์ง ์์ง๊ธฐ ๋ฐ ๋ฐํ์(๋ฐํ์์ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๊ธฐ๋ณธ ์ด๊ธฐํ ๋ฐ ์ ์ง ๊ด๋ฆฌ๋ก ์ถ์๋จ)์ ์ฌ์ฉ์ ํผํ๋ฉด์ ๋์ ์์ ๋ณ๋ ฌ์ฑ์ ๋ฌ์ฑํ ์ ์๋ ์๋จ์ ์ ๊ณตํฉ๋๋ค.
Rust์ ๋ฉ๋ชจ๋ฆฌ ์ฒ๋ฆฌ ๋ฐฉ๋ฒ์ ํฌ์ธํฐ๋ฅผ ์กฐ์ํ ๋ ๊ฐ๋ฐ์๋ฅผ ์ค๋ฅ๋ก๋ถํฐ ๋ณดํธํ๊ณ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ด ํด์ ๋ ํ ์ก์ธ์ค, null ํฌ์ธํฐ ์ญ์ฐธ์กฐ, ๋ฒํผ ์ค๋ฒ๋ฐ ๋ฑ๊ณผ ๊ฐ์ ์ ์์ค ๋ฉ๋ชจ๋ฆฌ ์ฒ๋ฆฌ๋ก ์ธํด ๋ฐ์ํ๋ ๋ฌธ์ ๋ก๋ถํฐ ๋ณดํธํฉ๋๋ค. ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๋ฐฐํฌ, ๋น๋ ์ ๊ณต ๋ฐ ์ข ์์ฑ ๊ด๋ฆฌ๋ฅผ ์ํด ํ๋ก์ ํธ๋ Cargo ํจํค์ง ๊ด๋ฆฌ์๋ฅผ ๊ฐ๋ฐํฉ๋๋ค. crates.io ์ ์ฅ์๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ํธ์คํ ์ ์ํด ์ง์๋ฉ๋๋ค.
๋ฉ๋ชจ๋ฆฌ ์์ ์ ์ปดํ์ผ ์๊ฐ์ ์ฐธ์กฐ ํ์ธ, ๊ฐ์ฒด ์์ ๊ถ ์ถ์ , ๊ฐ์ฒด ์๋ช (๋ฒ์) ์ถ์ ๋ฐ ์ฝ๋ ์คํ ์ค ๋ฉ๋ชจ๋ฆฌ ์ก์ธ์ค์ ์ ํ์ฑ ํ๊ฐ๋ฅผ ํตํด Rust์์ ์ ๊ณต๋ฉ๋๋ค. Rust๋ ๋ํ ์ ์ ์ค๋ฒํ๋ก์ ๋ํ ๋ณดํธ ๊ธฐ๋ฅ์ ์ ๊ณตํ๊ณ , ์ฌ์ฉํ๊ธฐ ์ ์ ๋ณ์ ๊ฐ์ ํ์ ์ด๊ธฐํ๊ฐ ํ์ํ๋ฉฐ, ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ์ค๋ฅ๋ฅผ ๋ ์ ์ฒ๋ฆฌํ๊ณ , ๊ธฐ๋ณธ์ ์ผ๋ก ๋ถ๋ณ ์ฐธ์กฐ ๋ฐ ๋ณ์ ๊ฐ๋ ์ ์ ์ฉํ๊ณ , ๊ฐ๋ ฅํ ์ ์ ์ ํ ์ง์ ์ ์ ๊ณตํ์ฌ ๋ ผ๋ฆฌ์ ์ค๋ฅ๋ฅผ ์ต์ํํฉ๋๋ค.
์ฃผ์ ํ์ :
- ๋ฎ์ ์์ค์์ ์คํ์ ์ ์ดํด์ผ ํ๊ฑฐ๋ ํน์ํ ๊ธฐ๊ณ ๋ช ๋ น์ด๋ฅผ ์ฌ์ฉํ ์ ์์ด์ผ ํ๋ ์์ฉ ํ๋ก๊ทธ๋จ์์ ์๊ตฌ๋๋ ์ด์ ๋ธ๋ฆฌ ์ธ์ด ์ฝ์ ์ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ด์ ๋ธ๋ฆฌ ์ธ์ํธ๋ "asm!" ๋งคํฌ๋ก๋ฅผ ์ฌ์ฉํ์ฌ ์ถ๊ฐ๋ฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ "global_asm!" Rust์์ ๋ฌธ์์ด ๋์ฒด์ ์ฌ์ฉ๋๋ ๊ฒ๊ณผ ์ ์ฌํ ์ด๋ฆ ์ง์ ๋ ์ง์คํฐ์ ๋ฌธ์์ด ํ์ํ ๊ตฌ๋ฌธ์ ์ฌ์ฉํฉ๋๋ค. ์ปดํ์ผ๋ฌ๋ x86, x86-64, ARM, AArch64 ๋ฐ RISC-V ์ํคํ ์ฒ์ ๋ํ ์ด์ ๋ธ๋ฆฌ ๋ช ๋ น์ด๋ฅผ ์ง์ํฉ๋๋ค. ์ฝ์ ์: std::arch::asm;์ ์ฌ์ฉํ์ญ์์ค. // ์ํํธ๋ฅผ ์ฌ์ฉํ์ฌ x์ 6์ ๊ณฑํ๊ณ ์ถ๊ฐํฉ๋๋ค. let mut x: u64 = 4; unsafe { asm!( "mov {tmp}, {x}", "shl {tmp}, 1", "shl {x}, 2", "{x}, {tmp} ์ถ๊ฐ", x = inout(reg ) x, tmp = out(reg) _, ); } ์ฃผ์ฅ_eq!(x, 4 * 6);
- ์ฌ๋ฌ ํน์ฑ, ์กฐ๊ฐ ๋๋ ๊ตฌ์กฐ๊ฐ ํํ์์ ์ผ์ชฝ์ ์ง์ ๋๋ ๊ตฌ์กฐ ํด์ ๋(๋ณ๋ ฌ) ํ ๋น์ ๋ํ ์ง์์ด ์ถ๊ฐ๋์์ต๋๋ค. ์๋ฅผ ๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค: (a, b, c, d, e); (a, b) = (1, 2); [c, .., d, _] = [1, 2, 3, 4, 5]; ๊ตฌ์กฐ์ฒด { e, .. } = ๊ตฌ์กฐ์ฒด { e: 5, f: 3 }; ์ฃผ์ฅ_eq!([1, 2, 1, 4, 5], [a, b, c, d, e]);
- const ์ ๋ค๋ฆญ์ ๋ํ ๊ธฐ๋ณธ๊ฐ์ ์ง์ ํ ์ ์์ต๋๋ค: struct ArrayStorage { ๋์ฐฉ: [T; N], } ์์ ์ด๋ ์ด์คํ ๋ฆฌ์ง { fn new(a: T, b: T) -> ArrayStorage { ArrayStorage { ๋์ฐฉ: [a, b], } } }
- Cargo ํจํค์ง ๊ด๋ฆฌ์๋ ์ปดํ์ผ๋ฌ์ ์ค๋ฅ๋ก ์ธํด ์ฒ๋ฆฌ๋๋ ์ข ์์ฑ์์ ์ ํจํ์ง ์์ ๊ตฌ์กฐ์ ์ฌ์ฉ์ ๋ํ ๊ฒฝ๊ณ ๋ฅผ ์ ๊ณตํฉ๋๋ค(์: ์ค๋ฅ๋ก ์ธํด ํจํน๋ ๊ตฌ์กฐ์ ํ๋๋ฅผ ์์ ํ ๋ธ๋ก์์ ๋น๋ ค์ค๋ ๊ฒ์ด ํ์ฉ๋จ). ์ด๋ฌํ ๊ตฌ์ฑ์ ํฅํ Rust ๋ฒ์ ์์๋ ๋ ์ด์ ์ง์๋์ง ์์ต๋๋ค.
- Cargo์ Rustc์๋ ๋ณ๋์ ์ ํธ๋ฆฌํฐ๋ฅผ ํธ์ถํ ํ์ ์์ด ๋๋ฒ๊น ๋ฐ์ดํฐ(strip = "debuginfo")์ ๊ธฐํธ(strip = "symbols")๊ฐ ์ ๊ฑฐ๋ ์คํ ํ์ผ์ ์์ฑํ๋ ๊ธฐ๋ฅ์ด ๋ด์ฅ๋์ด ์์ต๋๋ค. ์ ๋ฆฌ ์ค์ ์ Cargo.toml์ "strip" ๋งค๊ฐ๋ณ์๋ฅผ ํตํด ๊ตฌํ๋ฉ๋๋ค: [profile.release] ์คํธ๋ฆฝ = "debuginfo", "symbols"
- ์ฆ๋ถ ์ปดํ์ผ์ ๊ธฐ๋ณธ์ ์ผ๋ก ๋นํ์ฑํ๋์ด ์์ต๋๋ค. ๊ทธ ์ด์ ๋ ์ถฉ๋ ๋ฐ ์ญ์ง๋ ฌํ ์ค๋ฅ๋ฅผ ๋ฐ์์ํค๋ ์ปดํ์ผ๋ฌ ๋ฒ๊ทธ์ ๋ํ ์์ ํด๊ฒฐ ๋ฐฉ๋ฒ์ด๋ผ๊ณ ํฉ๋๋ค. ๋ฒ๊ทธ ์์ ์ ์ด๋ฏธ ์ค๋น๋์์ผ๋ฉฐ ๋ค์ ๋ฆด๋ฆฌ์ค์ ํฌํจ๋ ์์ ์ ๋๋ค. ์ฆ๋ถ ์ปดํ์ผ์ ๋ฐํํ๋ ค๋ฉด ํ๊ฒฝ ๋ณ์ RUSTC_FORCE_INCREMENTAL=1์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
- API์ ์๋ก์ด ๋ถ๋ถ์ด ์์ ํ๋ ํน์ฑ์ ๋ฉ์๋ ๋ฐ ๊ตฌํ์ ํฌํจํ์ฌ ์์ ์ ์ธ ๋ฒ์ฃผ๋ก ์ด๋๋์์ต๋๋ค.
- std::์ค๋ ๋::available_parallelism
- ๊ฒฐ๊ณผ::๋ณต์ฌ๋จ
- ๊ฒฐ๊ณผ::๋ณต์ ๋จ
- ์์น::asm!
- ์์น::global_asm!
- ops::ControlFlow::is_break
- ops::ControlFlow::is_continue
- u8์ฉ TryFrom
- char::TryFromCharError(๋ณต์ , ๋๋ฒ๊ทธ, ํ์, PartialEq, ๋ณต์ฌ, Eq, ์ค๋ฅ)
- ๋ฐ๋ณต::zip
- NonZeroU8::is_power_of_two
- NonZeroU16::is_power_of_two
- NonZeroU32::is_power_of_two
- NonZeroU64::is_power_of_two
- NonZeroU128::is_power_of_two
- ToLowercase ๊ตฌ์กฐ์ ๋ํ DoubleEndedIterator
- ToUppercase ๊ตฌ์กฐ์ ๋ํ DoubleEndedIterator
- TryFrom<&mut [T]> for [T; N]
- Once ๊ตฌ์กฐ์ ๋ํ UnwindSafe
- RefUnwindSafe๋ฅผ ํ ๋ฒ๋ง ์ฌ์ฉํด๋ณด์ธ์.
- aarch8์ฉ ์ปดํ์ผ๋ฌ์ ๋ด์ฅ๋ armv64 ๋ค์จ ์ง์ ํจ์
- ์์ ๋์ ๋ชจ๋ ์ปจํ
์คํธ์์ ์ฌ์ฉํ ๊ฐ๋ฅ์ฑ์ ๊ฒฐ์ ํ๋ "const" ์์ฑ์ ํจ์์์ ์ฌ์ฉ๋ฉ๋๋ค.
- mem::MaybeUninit::as_ptr
- mem::MaybeUninit::assume_init
- mem::MaybeUninit::assume_init_ref
- ffi::CStr::from_bytes_with_nul_unchecked
์ถ์ฒ : opennet.ru