๐ restrict ํฌ์ธํฐ์ ์ธ๊ณ๋ก ๋ ๋๋ ์ ๋๋ ์ฌํ! ๐

์๋ ํ์ธ์, ์ฌ๋ฌ๋ถ! ์ค๋์ C ์ธ์ด์ ์จ๊ฒจ์ง ๋ณด๋ฌผ ์ค ํ๋์ธ 'restrict ํฌ์ธํฐ'์ ๋ํด ์์๋ณผ ๊ฑฐ์์. ์ด ์ฃผ์ ๊ฐ ์ข ์ด๋ ต๊ฒ ๋๊ปด์ง ์๋ ์๊ฒ ์ง๋ง, ๊ฑฑ์ ๋ง์ธ์! ์ฐ๋ฆฌ ํจ๊ป ์ฌ๋ฏธ์๊ฒ ํํํด๋ณผ ๊ฑฐ๋๊น์. ๐
ํน์ 'restrict'๋ผ๋ ๋จ์ด๋ฅผ ๋ค์ด๋ณธ ์ ์๋์? ํ๋ก๊ทธ๋๋ฐ ์ธ๊ณ์์๋ ์ด ๋จ์ด๊ฐ ํน๋ณํ ์๋ฏธ๋ฅผ ๊ฐ์ง๊ณ ์๋ต๋๋ค. ๋ง์น ์ฌ๋ฅ๋ท์์ ๋ค์ํ ์ฌ๋ฅ์ ๊ฑฐ๋ํ๋ฏ์ด, C ์ธ์ด์์๋ 'restrict' ํค์๋๋ก ํฌ์ธํฐ์ ํน๋ณํ ๋ฅ๋ ฅ์ ๊ฑฐ๋(?)ํ๋ค๊ณ ๋ณผ ์ ์์ฃ . ใ ใ ใ
๐ ์์ญ๋ฌ์ญ ํฌ์ธํฐ, ์ด์ ๋ ์ ๋๋ก ์์๋ณด์!
ํฌ์ธํฐ๊ฐ ๋ญ์ง ์์ง ์ ๋ชจ๋ฅด๊ฒ ๋ค๊ตฌ์? ๊ฑฑ์ ๋ง์ธ์! ์ฐ๋ฆฌ ํจ๊ป ์ฐจ๊ทผ์ฐจ๊ทผ ์์๊ฐ ๊ฑฐ์์. restrict ํฌ์ธํฐ๋ฅผ ์ดํดํ๋ฉด, ์ฌ๋ฌ๋ถ์ ์ฝ๋ฉ ์ค๋ ฅ์ ์ฌ๋ฅ๋ท์์ ์ธ๊ธฐ ๋ง์ ์ฌ๋ฅ์ฒ๋ผ ๋น๋ ๊ฑฐ์์! ๐
๐ค restrict ํฌ์ธํฐ๊ฐ ๋ญ๊ธธ๋?
์, ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก restrict ํฌ์ธํฐ์ ๋ํด ์์๋ณผ ์๊ฐ์ด์์! ๐
restrict ํค์๋๋ C99 ํ์ค์์ ๋์ ๋ ํน๋ณํ ๋ ์์ด์์. ์ด ํค์๋๋ฅผ ์ฌ์ฉํ๋ฉด ์ปดํ์ผ๋ฌ์๊ฒ "์ผ, ์ด ํฌ์ธํฐ ์ข ํน๋ณ ๊ด๋ฆฌ ํด์ค!"๋ผ๊ณ ๋งํ๋ ๊ฑฐ์ฃ . ใ ใ ใ
restrict ํฌ์ธํฐ์ ํต์ฌ์ ๋ฐ๋ก ์ต์ ํ์ ์์ด์. ์ปดํ์ผ๋ฌ์๊ฒ "์ด ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ๋ฉ๋ชจ๋ฆฌ๋ ๋ค๋ฅธ ํฌ์ธํฐ๋ ๊ฒน์น์ง ์์ ๊ฑฐ์ผ!"๋ผ๊ณ ์ฝ์ํ๋ ๊ฑฐ์ฃ . ์ด๋ ๊ฒ ํ๋ฉด ์ปดํ์ผ๋ฌ๊ฐ ๋ ํจ์จ์ ์ธ ์ฝ๋๋ฅผ ๋ง๋ค ์ ์๊ฒ ๋ผ์.
๐จ ์ฃผ์! restrict๋ ์ฝ์์ด์์!
restrict๋ฅผ ์ฌ์ฉํ ๋๋ ์ ๋ง๋ก ๊ทธ ํฌ์ธํฐ๋ง์ด ํด๋น ๋ฉ๋ชจ๋ฆฌ์ ์ ๊ทผํ๋ค๋ ๊ฑธ ๋ณด์ฅํด์ผ ํด์. ๋ง์ฝ ์ด ์ฝ์์ ์ด๊ธฐ๋ฉด... ์, ํ๋ก๊ทธ๋จ์ด ์ด์ํ๊ฒ ๋์ํ ์ ์์ด์. ๋ง์น ์ฌ๋ฅ๋ท์์ ์ฝ์์ ์ด๊ธฐ๋ฉด ์ ๋ขฐ๋ฅผ ์๋ ๊ฒ์ฒ๋ผ์! ๐ฑ
๊ทธ๋ผ ์ด์ restrict ํฌ์ธํฐ๋ฅผ ์ด๋ป๊ฒ ์ ์ธํ๊ณ ์ฌ์ฉํ๋์ง ์ดํด๋ณผ๊น์?
int * restrict ptr = (int *)malloc(sizeof(int));
์ด๋ ๊ฒ ์ ์ธํ๋ฉด ptr์ด๋ผ๋ ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ๋ฉ๋ชจ๋ฆฌ๋ ์ค์ง ptr์ ํตํด์๋ง ์ ๊ทผํ ๊ฑฐ๋ผ๊ณ ์ปดํ์ผ๋ฌ์๊ฒ ์๋ ค์ฃผ๋ ๊ฑฐ์์. ๋ฉ์ง์ฃ ? ๐
์ด ๊ทธ๋ฆผ์ ๋ณด๋ฉด restrict ํฌ์ธํฐ๊ฐ ์ด๋ป๊ฒ ๋์ํ๋์ง ๋ ์ ์ดํดํ ์ ์์ ๊ฑฐ์์. ptr์ด๋ผ๋ restrict ํฌ์ธํฐ๊ฐ ํน์ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ๋ ์ ์ ์ผ๋ก ๊ฐ๋ฆฌํค๊ณ ์์ฃ ? ์ด๊ฒ ๋ฐ๋ก restrict์ ํต์ฌ์ด์์!
์, ์ด์ restrict ํฌ์ธํฐ์ ๊ธฐ๋ณธ ๊ฐ๋ ์ ์์์ผ๋, ๋ ๊น์ด ๋ค์ด๊ฐ๋ณผ๊น์? ๐โโ๏ธ
๐ restrict ํฌ์ธํฐ์ ์ฅ์
restrict ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ๋ฉด ์ด๋ค ์ข์ ์ ์ด ์์๊น์? ํ๋ฒ ์์ธํ ์ดํด๋ณผ๊ฒ์!
- ์ฑ๋ฅ ํฅ์ ๐: restrict ํค์๋๋ฅผ ์ฌ์ฉํ๋ฉด ์ปดํ์ผ๋ฌ๊ฐ ๋ ํจ์จ์ ์ธ ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ด์. ํฌ์ธํฐ ๊ฐ์ ๋ณ์นญ(aliasing) ๋ฌธ์ ๋ฅผ ์ค์ผ ์ ์๊ธฐ ๋๋ฌธ์ด์ฃ .
- ์ต์ ํ์ ๊ธฐํ ๐ฏ: ์ปดํ์ผ๋ฌ์๊ฒ ๋ ๋ง์ ์ต์ ํ ๊ธฐํ๋ฅผ ์ ๊ณตํด์. ํนํ ๋ฃจํ์์ ๋ง์ด ์ฌ์ฉ๋๋ ํฌ์ธํฐ์ restrict๋ฅผ ์ฌ์ฉํ๋ฉด ํจ๊ณผ๊ฐ ํฌ๋ต๋๋ค.
- ๋ช ํํ ์๋ ์ ๋ฌ ๐ข: ์ฝ๋๋ฅผ ์ฝ๋ ๋ค๋ฅธ ๊ฐ๋ฐ์๋ค์๊ฒ "์ด ํฌ์ธํฐ๋ ๋ ์ ์ ์ผ๋ก ์ฌ์ฉ๋ ๊ฑฐ์ผ!"๋ผ๊ณ ๋ช ํํ๊ฒ ์๋ ค์ค ์ ์์ด์.
- ๋ฒ๊ทธ ์๋ฐฉ ๐: restrict ๊ท์น์ ์งํค๋ฉด์ ์ฝ๋ฉํ๋ฉด, ํฌ์ธํฐ ๊ด๋ จ ๋ฒ๊ทธ๋ฅผ ๋ฏธ๋ฆฌ ๋ฐฉ์งํ ์ ์์ด์.
๐ก ์ฌ๋ฅ๋ท ํ!
ํ๋ก๊ทธ๋๋ฐ ์ค๋ ฅ์ ํฅ์์ํค๋ ๊ฒ๋ ์ผ์ข ์ ์ฌ๋ฅ์ด์์. restrict ํฌ์ธํฐ๋ฅผ ๋ง์คํฐํ๋ฉด, ์ฌ๋ฌ๋ถ์ C ํ๋ก๊ทธ๋๋ฐ ์ฌ๋ฅ์ ์ฌ๋ฅ๋ท์์ ์ธ๊ธฐ ๋ง์ ์ฌ๋ฅ์ด ๋ ๊ฑฐ์์! ๐
๊ทธ๋ผ ์ด์ restrict ํฌ์ธํฐ๋ฅผ ์ค์ ๋ก ์ด๋ป๊ฒ ์ฌ์ฉํ๋์ง ์์ ๋ฅผ ํตํด ์ดํด๋ณผ๊น์?
void vector_add(int n, float * restrict a,
float * restrict b,
float * restrict result) {
for (int i = 0; i < n; i++) {
result[i] = a[i] + b[i];
}
}
์ด ์์ ์์ a, b, result ์ธ ํฌ์ธํฐ ๋ชจ๋์ restrict๋ฅผ ์ฌ์ฉํ์ด์. ์ด๋ ๊ฒ ํ๋ฉด ์ปดํ์ผ๋ฌ๋ ์ด ์ธ ํฌ์ธํฐ๊ฐ ์๋ก ๊ฒน์น์ง ์๋๋ค๊ณ ๊ฐ์ ํ๊ณ ์ต์ ํ๋ฅผ ์ํํ ์ ์์ด์.
๋ง์ฝ restrict๋ฅผ ์ฌ์ฉํ์ง ์์๋ค๋ฉด, ์ปดํ์ผ๋ฌ๋ a, b, result๊ฐ ์๋ก ๊ฒน์น ์ ์๋ค๊ณ ๊ฐ์ ํ๊ณ , ๋งค ๋ฃจํ๋ง๋ค ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ค์ ์ฝ์ด์ผ ํ ์๋ ์์ด์. ํ์ง๋ง restrict๋ฅผ ์ฌ์ฉํ๋ฉด ์ด๋ฐ ๊ฑฑ์ ์์ด ๋ ํจ์จ์ ์ธ ์ฝ๋๋ฅผ ์์ฑํ ์ ์๋ต๋๋ค!
์ด ๊ทธ๋ฆผ์ restrict ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ์ ๋์ ์ต์ ํ ํจ๊ณผ๋ฅผ ๋ณด์ฌ์ค์. a[], b[], result[] ๋ฐฐ์ด์ด ์๋ก ๋ ๋ฆฝ์ ์ผ๋ก ์กด์ฌํ๊ณ , ์ปดํ์ผ๋ฌ๊ฐ ์ด๋ฅผ ์ธ์ํด์ ๋ ํจ์จ์ ์ธ ์ ๊ทผ ๋ฐฉ์์ ์ฌ์ฉํ ์ ์๋ค๋ ๊ฑธ ๋ํ๋ด๊ณ ์์ฃ .
ํ์ง๋ง ์ฃผ์ํด์ผ ํ ์ ์ด ์์ด์! restrict ํค์๋๋ ๋ง ๊ทธ๋๋ก '์ ํ'์ ์๋ฏธํด์. ์ด ์ ํ์ ์งํค์ง ์์ผ๋ฉด ์์์น ๋ชปํ ๊ฒฐ๊ณผ๊ฐ ๋ฐ์ํ ์ ์๋ต๋๋ค. ๋ง์น ์ฌ๋ฅ๋ท์์ ์ฝ์์ ์ด๊ธฐ๋ฉด ์ ์ข์ ๊ฒฐ๊ณผ๊ฐ ์๊ธฐ๋ ๊ฒ์ฒ๋ผ์! ๐
๋ค์ ์น์ ์์๋ restrict ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ ๋ ์ฃผ์ํด์ผ ํ ์ ๋ค์ ๋ํด ์์ธํ ์์๋ณผ๊ฒ์. ์ค๋น๋์ จ๋์? ๊ณ ๊ณ ! ๐
โ ๏ธ restrict ํฌ์ธํฐ ์ฌ์ฉ ์ ์ฃผ์์ฌํญ
์, ์ด์ restrict ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ ๋ ์กฐ์ฌํด์ผ ํ ์ ๋ค์ ๋ํด ์์๋ณผ ๊ฑฐ์์. ๋ง์น ์ฌ๋ฅ๋ท์์ ๊ฑฐ๋ํ ๋ ์ฃผ์์ฌํญ์ ์ ์ฝ์ด์ผ ํ๋ ๊ฒ์ฒ๋ผ, ํ๋ก๊ทธ๋๋ฐ์์๋ ์ด๋ฐ ์ฃผ์์ฌํญ๋ค์ ์ ์์๋๋ ๊ฒ ์ค์ํด์!
๐จ restrict ํฌ์ธํฐ์ ํจ์ ๋ค
- ์ค๋ณต ์ ๊ทผ ๊ธ์ง
- ํจ์ ๋ด์์๋ง ์ ํจ
- ์ปดํ์ผ๋ฌ์ ์ต์ ํ ์์กด์ฑ
- ๋ค๋ฅธ ํฌ์ธํฐ์์ ๊ด๊ณ
1. ์ค๋ณต ์ ๊ทผ์ ์ ๋ ๊ธ์ง! ๐ซ
restrict ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ๋ฉ๋ชจ๋ฆฌ์ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ผ๋ก ์ ๊ทผํ๋ฉด ์ ๋ผ์. ์ด๊ฑด ์ ๋ง ์ค์ํด์! ์๋ฅผ ๋ค์ด๋ณผ๊ฒ์:
void bad_function(int * restrict p, int * restrict q) {
*p = 1;
*q = 2;
printf("%d %d\n", *p, *q); // ์ํํ ์ฝ๋!
}
int main() {
int x = 0;
bad_function(&x, &x); // ์ด๋ฌ๋ฉด ์ ๋ผ์!
return 0;
}
์ด ์ฝ๋์์ p์ q๋ restrict ํฌ์ธํฐ๋ก ์ ์ธ๋์์ง๋ง, ์ค์ ๋ก๋ ๊ฐ์ ๋ณ์ x๋ฅผ ๊ฐ๋ฆฌํค๊ณ ์์ด์. ์ด๋ ๊ฒ ํ๋ฉด undefined behavior๊ฐ ๋ฐ์ํ ์ ์์ด์. ๋ง์น ์ฌ๋ฅ๋ท์์ ํ ์ฌ๋์ด ๋ ๊ฐ์ ๊ณ์ ์ผ๋ก ์์ ๊ณผ ๊ฑฐ๋ํ๋ ๊ฒ์ฒ๋ผ ์ด์ํ ์ํฉ์ด ๋๋ ๊ฑฐ์ฃ ! ใ ใ ใ
2. ํจ์ ์์์๋ง ์ ํจํด์! ๐
restrict ํค์๋์ ํจ๊ณผ๋ ํด๋น ํจ์ ๋ด์์๋ง ์ ํจํด์. ํจ์๋ฅผ ๋ฒ์ด๋๋ฉด ๊ทธ ํจ๊ณผ๊ฐ ์ฌ๋ผ์ง๋ค๊ณ ๋ณด๋ฉด ๋ผ์. ์๋ฅผ ๋ค์ด๋ณผ๊ฒ์:
void func1(int * restrict p) {
// ์ฌ๊ธฐ์๋ p๊ฐ restrict ํฌ์ธํฐ๋ก ๋์ํด์
}
void func2(int *p) {
// ์ฌ๊ธฐ์๋ p๊ฐ ์ผ๋ฐ ํฌ์ธํฐ์์
func1(p); // func1 ์์์๋ง p๊ฐ restrict ํฌ์ธํฐ๋ก ์ทจ๊ธ๋ผ์
}
func2์์ p๋ฅผ func1์ ์ ๋ฌํ ๋, func1 ์์์๋ง p๊ฐ restrict ํฌ์ธํฐ๋ก ์ทจ๊ธ๋๋ค๋ ์ ์ ๊ธฐ์ตํ์ธ์!
3. ์ปดํ์ผ๋ฌ๋ง๋ค ๋ค๋ฅผ ์ ์์ด์! ๐ฅ๏ธ
restrict ํค์๋์ ํจ๊ณผ๋ ์ปดํ์ผ๋ฌ์ ์ต์ ํ ๋ฅ๋ ฅ์ ๋ฐ๋ผ ๋ฌ๋ผ์ง ์ ์์ด์. ์ด๋ค ์ปดํ์ผ๋ฌ๋ restrict๋ฅผ ๋ฌด์ํ ์๋ ์๊ณ , ์ด๋ค ์ปดํ์ผ๋ฌ๋ ์์ฒญ๋ ์ต์ ํ๋ฅผ ํด์ค ์๋ ์์ฃ . ๋ง์น ์ฌ๋ฅ๋ท์์ ๊ฐ์ ์ฌ๋ฅ์ด๋ผ๋ ํ๋งค์์ ๋ฐ๋ผ ํ์ง์ด ๋ค๋ฅผ ์ ์๋ ๊ฒ์ฒ๋ผ์!
๐ก ์ปดํ์ผ๋ฌ ์ต์ ํ ํ
restrict ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ ๋๋ ํญ์ ์ปดํ์ผ๋ฌ์ ์ต์ ํ ์ต์ ์ ํ์ธํด๋ณด์ธ์. ์๋ฅผ ๋ค์ด, GCC์์๋ -O2๋ -O3 ์ต์ ์ ์ฌ์ฉํ๋ฉด restrict์ ํจ๊ณผ๋ฅผ ๋ ์ ๋ณผ ์ ์์ด์!
4. ๋ค๋ฅธ ํฌ์ธํฐ์์ ๊ด๊ณ๋ฅผ ์กฐ์ฌํ์ธ์! ๐ค
restrict ํฌ์ธํฐ์ ์ผ๋ฐ ํฌ์ธํฐ๋ฅผ ํจ๊ป ์ฌ์ฉํ ๋๋ ํนํ ์ฃผ์ํด์ผ ํด์. ์๋ฅผ ๋ค์ด๋ณผ๊ฒ์:
void tricky_function(int * restrict p, int *q) {
*p = 10;
*q = 20; // q๊ฐ p์ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฐ๋ฆฌํฌ ์ ์์ด์!
printf("%d\n", *p); // 10์ผ๊น์, 20์ผ๊น์?
}
์ด ๊ฒฝ์ฐ, q๊ฐ p์ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฐ๋ฆฌํฌ ์ ์๊ธฐ ๋๋ฌธ์ ์์์น ๋ชปํ ๊ฒฐ๊ณผ๊ฐ ๋์ฌ ์ ์์ด์. restrict๋ p์๋ง ์ ์ฉ๋์๊ธฐ ๋๋ฌธ์ q์ ๋์์ ์ ํ๋์ง ์์์. ์ด๋ฐ ์ํฉ์ ์กฐ์ฌํด์ผ ํด์!
์ด ๊ทธ๋ฆผ์ restrict ํฌ์ธํฐ p์ ์ผ๋ฐ ํฌ์ธํฐ q๊ฐ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฐ๋ฆฌํฌ ์ ์๋ ์ํฉ์ ๋ณด์ฌ์ค์. p๋ restrict๋ก ์ ์ธ๋์ด ๋ ์ ์ ์ ๊ทผ์ ๊ธฐ๋ํ์ง๋ง, q๋ ๊ทธ๋ ์ง ์์ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ์ ์ ๊ทผํ ์ ์์ด์. ์ด๋ฐ ์ํฉ์์ ์์์น ๋ชปํ ๊ฒฐ๊ณผ๊ฐ ๋ฐ์ํ ์ ์๋ต๋๋ค!
์, ์ด์ restrict ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ ๋ ์ฃผ์ํด์ผ ํ ์ ๋ค์ ์์์ด์. ์ด๋ฐ ์ ๋ค์ ์ ๊ธฐ์ตํ๊ณ ์์ผ๋ฉด, ์ฌ๋ฌ๋ถ์ ์ฝ๋๋ ๋์ฑ ์์ ํ๊ณ ํจ์จ์ ์ด ๋ ๊ฑฐ์์! ๋ง์น ์ฌ๋ฅ๋ท์์ ์์ ํ๊ฒ ๊ฑฐ๋ํ๋ ๊ฒ์ฒ๋ผ ๋ง์ด์ฃ . ๐
๋ค์ ์น์ ์์๋ restrict ํฌ์ธํฐ์ ์ค์ ์ฌ์ฉ ์ฌ๋ก์ ์ฑ๋ฅ ํฅ์ ํจ๊ณผ์ ๋ํด ๋ ์์ธํ ์์๋ณผ๊ฒ์. ์ค๋น๋์ จ๋์? ๊ณ ๊ณ ! ๐
๐ restrict ํฌ์ธํฐ์ ์ค์ ํ์ฉ๊ณผ ์ฑ๋ฅ ํฅ์
์, ์ด์ restrict ํฌ์ธํฐ๋ฅผ ์ค์ ๋ก ์ด๋ป๊ฒ ํ์ฉํ๊ณ , ์ด๋ค ์ฑ๋ฅ ํฅ์์ ์ป์ ์ ์๋์ง ์์๋ณผ ๊ฑฐ์์. ๋ง์น ์ฌ๋ฅ๋ท์์ ์๋ก์ด ๊ธฐ์ ์ ๋ฐฐ์ ์์ ์ ์ฌ๋ฅ์ ์ ๊ทธ๋ ์ด๋ํ๋ ๊ฒ์ฒ๋ผ, ์ฐ๋ฆฌ๋ restrict ํฌ์ธํฐ๋ก ์ฝ๋ฉ ์ค๋ ฅ์ ์ ๊ทธ๋ ์ด๋ํด๋ณผ๊น์? ๐
1. ๋ฒกํฐ ์ฐ์ฐ์์์ ํ์ฉ ๐
๋ฒกํฐ ์ฐ์ฐ์ restrict ํฌ์ธํฐ์ ์ฅ์ ์ ์ ๋ณด์ฌ์ฃผ๋ ๋ํ์ ์ธ ์์์์. ์๋ ์ฝ๋๋ฅผ ๋ณผ๊น์?
void vector_add(int n, float * restrict a,
float * restrict b,
float * restrict result) {
for (int i = 0; i < n; i++) {
result[i] = a[i] + b[i];
}
}
์ด ํจ์์์ a, b, result ๋ชจ๋ restrict ํฌ์ธํฐ๋ก ์ ์ธ๋์์ด์. ์ด๋ ๊ฒ ํ๋ฉด ์ปดํ์ผ๋ฌ๋ ์ธ ๋ฐฐ์ด์ด ์๋ก ๊ฒน์น์ง ์๋๋ค๊ณ ๊ฐ์ ํ๊ณ ์ต์ ํ๋ฅผ ์ํํ ์ ์์ด์.
๐ก ์ฑ๋ฅ ํฅ์์ ๋น๋ฐ
restrict๋ฅผ ์ฌ์ฉํ๋ฉด ์ปดํ์ผ๋ฌ๊ฐ ๋ฃจํ ์ธ๋กค๋ง(loop unrolling)์ด๋ ๋ฒกํฐํ(vectorization) ๊ฐ์ ๊ณ ๊ธ ์ต์ ํ ๊ธฐ๋ฒ์ ๋ ํจ๊ณผ์ ์ผ๋ก ์ ์ฉํ ์ ์์ด์. ์ด๋ ํนํ SIMD(Single Instruction, Multiple Data) ๋ช ๋ น์ด๋ฅผ ์ง์ํ๋ ํ๋ ํ๋ก์ธ์์์ ํฐ ์ฑ๋ฅ ํฅ์์ ๊ฐ์ ธ์ฌ ์ ์๋ต๋๋ค!
2. ๋ฉ๋ชจ๋ฆฌ ๋ณต์ฌ ํจ์ ์ต์ ํ ๐พ
๋ฉ๋ชจ๋ฆฌ ๋ณต์ฌ ํจ์๋ restrict ํฌ์ธํฐ์ ๋ ๋ค๋ฅธ ์ข์ ํ์ฉ ์์์์. ํ์ค C ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ memcpy ํจ์๋ฅผ ์ดํด๋ณผ๊น์?
void *memcpy(void * restrict dest, const void * restrict src, size_t n) {
char *d = dest;
const char *s = src;
for (size_t i = 0; i < n; i++) {
d[i] = s[i];
}
return dest;
}
์ฌ๊ธฐ์ dest์ src๋ฅผ restrict ํฌ์ธํฐ๋ก ์ ์ธํจ์ผ๋ก์จ, ์ปดํ์ผ๋ฌ๋ ๋ ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ด ๊ฒน์น์ง ์๋๋ค๊ณ ๊ฐ์ ํ ์ ์์ด์. ์ด๋ฅผ ํตํด ๋ ํจ์จ์ ์ธ ๋ณต์ฌ ์ฐ์ฐ์ ์ํํ ์ ์์ฃ .
์ด ๊ทธ๋ฆผ์ restrict ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ ๋ฉ๋ชจ๋ฆฌ ๋ณต์ฌ์ ์ต์ ํ๋ฅผ ๋ณด์ฌ์ค์. src์ dest๊ฐ ์๋ก ๊ฒน์น์ง ์๋๋ค๊ณ ๊ฐ์ ํ๊ธฐ ๋๋ฌธ์, ์ปดํ์ผ๋ฌ๋ ๋ ํจ์จ์ ์ธ ๋ณต์ฌ ์ฐ์ฐ์ ์ํํ ์ ์์ด์.
3. ํ๋ ฌ ์ฐ์ฐ์์์ ํ์ฉ ๐ข
ํ๋ ฌ ์ฐ์ฐ์ restrict ํฌ์ธํฐ์ ์ฅ์ ์ ๊ทน๋ํํ ์ ์๋ ๋ ๋ค๋ฅธ ์์ญ์ด์์. ์๋ฅผ ๋ค์ด, ํ๋ ฌ ๊ณฑ์ ํจ์๋ฅผ ๋ณผ๊น์?
void matrix_multiply(int n, float * restrict A, float * restrict B, float * restrict C) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
float sum = 0;
for (int k = 0; k < n; k++) {
sum += A[i*n + k] * B[k*n + j];
}
C[i*n + j] = sum;
}
}
}
์ด ํจ์์์ A, B, C๋ฅผ ๋ชจ๋ restrict ํฌ์ธํฐ๋ก ์ ์ธํ์ด์. ์ด๋ ๊ฒ ํ๋ฉด ์ปดํ์ผ๋ฌ๋ ์ธ ํ๋ ฌ์ด ์๋ก ๊ฒน์น์ง ์๋๋ค๊ณ ๊ฐ์ ํ๊ณ , ๋ ํจ์จ์ ์ธ ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ด์.
๐ ์ฑ๋ฅ ํฅ์์ ์ค์ ํจ๊ณผ
์ค์ ๋ก ์ด๋ฐ ํ๋ ฌ ์ฐ์ฐ์์ restrict ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ๋ฉด, ๊ฒฝ์ฐ์ ๋ฐ๋ผ 10-20% ์ ๋์ ์ฑ๋ฅ ํฅ์์ ๋ณผ ์ ์๋ค๋ ์ฐ๊ตฌ ๊ฒฐ๊ณผ๊ฐ ์์ด์. ๋ง์น ์ฌ๋ฅ๋ท์์ ์๋ก์ด ๊ธฐ์ ์ ์ตํ ๋ ๋์ ํ๊ฐ๋ฅผ ๋ฐ๋ ๊ฒ์ฒ๋ผ, ์ฐ๋ฆฌ ์ฝ๋๋ ๋ ๋์ 'ํ๊ฐ'(์ฑ๋ฅ)๋ฅผ ๋ฐ์ ์ ์๋ ๊ฑฐ์ฃ ! ๐
4. ๋ฉํฐ์ค๋ ๋ฉ ํ๊ฒฝ์์์ ํ์ฉ ๐งต
๋ฉํฐ์ค๋ ๋ฉ ํ๊ฒฝ์์๋ restrict ํฌ์ธํฐ๋ ์ ์ฉํ๊ฒ ์ฌ์ฉ๋ ์ ์์ด์. ์๋ฅผ ๋ค์ด, ๋ณ๋ ฌ ์ฒ๋ฆฌ๋ฅผ ํ๋ ํจ์๋ฅผ ๋ณผ๊น์?
void parallel_process(int n, float * restrict input, float * restrict output) {
#pragma omp parallel for
for (int i = 0; i < n; i++) {
output[i] = complex_calculation(input[i]);
}
}
์ด ํจ์์์ input๊ณผ output์ restrict ํฌ์ธํฐ๋ก ์ ์ธํจ์ผ๋ก์จ, ์ปดํ์ผ๋ฌ๋ ๋ ๋ฐฐ์ด์ด ๊ฒน์น์ง ์๋๋ค๊ณ ๊ฐ์ ํ๊ณ ๋ ํจ์จ์ ์ธ ๋ณ๋ ฌ ์ฒ๋ฆฌ ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ด์.
์ด ๊ทธ๋ฆผ์ restrict ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ ๋ณ๋ ฌ ์ฒ๋ฆฌ์ ์ต์ ํ๋ฅผ ๋ณด์ฌ์ค์. ๊ฐ ์ค๋ ๋๊ฐ ๊ฒน์น์ง ์๋ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ์ ๊ทผํ๋ค๊ณ ๊ฐ์ ํ๊ธฐ ๋๋ฌธ์, ๋ ํจ์จ์ ์ธ ๋ณ๋ ฌ ์ฒ๋ฆฌ๊ฐ ๊ฐ๋ฅํด์ ธ์.
restrict ํฌ์ธํฐ์ ์ค์ ์ฑ๋ฅ ํฅ์ ํจ๊ณผ๋ ์ํฉ์ ๋ฐ๋ผ ๋ค๋ฅผ ์ ์์ด์. ๋๋ก๋ ํฐ ์ฐจ์ด๊ฐ ์์ ์๋ ์๊ณ , ๋๋ก๋ ์๋นํ ์ฑ๋ฅ ํฅ์์ ๋ณผ ์ ์์ฃ . ํ์ง๋ง ์ค์ํ ๊ฑด, restrict๋ฅผ ์ฌ์ฉํจ์ผ๋ก์จ ์ฐ๋ฆฌ๊ฐ ์ปดํ์ผ๋ฌ์๊ฒ ๋ ๋ง์ ์ ๋ณด๋ฅผ ์ ๊ณตํ๊ณ , ์ต์ ํ์ ๊ธฐํ๋ฅผ ์ค๋ค๋ ๊ฑฐ์์.
๐ restrict ํฌ์ธํฐ ๋ง์คํฐ ํ!
restrict ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ ๋๋ ํญ์ ์ฑ๋ฅ ํ ์คํธ๋ฅผ ํด๋ณด์ธ์. ๋๋ก๋ ์์์น ๋ชปํ ๊ณณ์์ ํฐ ์ฑ๋ฅ ํฅ์์ ๋ฐ๊ฒฌํ ์ ์์ด์. ๋ง์น ์ฌ๋ฅ๋ท์์ ์๋ก์ด ์ฌ๋ฅ์ ๋ฐ๊ฒฌํ๋ ๊ฒ์ฒ๋ผ ๋ง์ด์ฃ ! ๐
์, ์ด์ restrict ํฌ์ธํฐ์ ์ค์ ํ์ฉ๊ณผ ์ฑ๋ฅ ํฅ์์ ๋ํด ์์๋ดค์ด์. ์ด๋ฐ ์ง์์ ํ์ฉํ๋ฉด, ์ฌ๋ฌ๋ถ์ C ํ๋ก๊ทธ๋๋ฐ ์ค๋ ฅ์ ํ์ธต ๋ ์ ๊ทธ๋ ์ด๋๋ ๊ฑฐ์์! ๋ง์ง๋ง์ผ๋ก, restrict ํฌ์ธํฐ ์ฌ์ฉ์ ์ฅ๋จ์ ์ ์ ๋ฆฌํด๋ณผ๊น์?
restrict ํฌ์ธํฐ ์ฌ์ฉ์ ์ฅ๋จ์ โ๏ธ
- ์ฅ์ ๐
- ์ปดํ์ผ๋ฌ ์ต์ ํ ํฅ์
- ์ฑ๋ฅ ๊ฐ์ ๊ฐ๋ฅ์ฑ
- ์ฝ๋์ ์๋๋ฅผ ๋ช ํํ ์ ๋ฌ
- ๋จ์ ๐
- ์๋ชป ์ฌ์ฉ ์ ์์ธก ๋ถ๊ฐ๋ฅํ ๊ฒฐ๊ณผ
- ๋๋ฒ๊น ์ด ์ด๋ ค์ธ ์ ์์
- ๋ชจ๋ ์ปดํ์ผ๋ฌ๊ฐ ๋์ผํ๊ฒ ์ง์ํ์ง ์์
restrict ํฌ์ธํฐ๋ ๊ฐ๋ ฅํ ๋๊ตฌ์ง๋ง, ์๋ ์ ๊ฒ๊ณผ ๊ฐ์์. ์ ์ฌ์ฉํ๋ฉด ํฐ ์ด์ ์ ์ป์ ์ ์์ง๋ง, ์๋ชป ์ฌ์ฉํ๋ฉด ์คํ๋ ค ๋ฌธ์ ๊ฐ ๋ ์ ์์ฃ . ๋ง์น ์ฌ๋ฅ๋ท์์ ์์ ์ ์ฌ๋ฅ์ ์ ํ์ฉํ๋ฉด ํฐ ์ฑ๊ณผ๋ฅผ ์ป์ง๋ง, ์๋ชป ์ฌ์ฉํ๋ฉด ๋ฌธ์ ๊ฐ ์๊ธธ ์ ์๋ ๊ฒ์ฒ๋ผ์.
์ฌ๋ฌ๋ถ, ์ด์ restrict ํฌ์ธํฐ์ ๋ชจ๋ ๊ฒ์ ์๊ฒ ๋์์ด์! ์ด ์ง์์ ํ์ฉํด์ ๋ ํจ์จ์ ์ด๊ณ ์ต์ ํ๋ C ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์ธ์. ์ฌ๋ฌ๋ถ์ ์ฝ๋ฉ ์ค๋ ฅ์ด ์ฌ๋ฅ๋ท์ ์ธ๊ธฐ ์ฌ๋ฅ์ฒ๋ผ ๋น๋๊ธธ ๋ฐ๋๊ฒ์! ํ์ดํ ! ๐ช๐
- ์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์ฌ๋ฅ๋ท์ ์ต์ AI ๊ธฐ์ ๊ณผ ๋ฒ๋ฅ ์ ๊ธฐ๋ฐํ์ฌ ์์ฌ์ ์ง์ ์ฌ์ฐ๊ถ์ ์ ๊ทน์ ์ผ๋ก ๋ณดํธํ๋ฉฐ,
๋ฌด๋จ ์ฌ์ฉ ๋ฐ ์นจํด ํ์์ ๋ํด ๋ฒ์ ๋์์ ํ ๊ถ๋ฆฌ๋ฅผ ๋ณด์ ํฉ๋๋ค.
ยฉ 2025 ์ฌ๋ฅ๋ท | All rights reserved.
๋๊ธ 0๊ฐ