하드웨어 비종속적 Semantic Lowering 체계로의 확장

1. 연구 목표의 일반화

현재 작업에서는 하나의 수학적 연산을 CUDA로 구현하고, 그것이 PTX와 SASS로 lowering되었을 때 연산의 수학적 성질이 어떤 명령과 데이터 흐름으로 나타나는지를 관찰하고 있다.

예를 들어 ReLU는 수학적으로 다음과 같이 정의된다.

ReLU(x) = max(0, x)

CUDA 소스에서는 비교와 선택으로 작성될 수 있다.

y = x > 0.0f ? x : 0.0f;

하지만 실제 SASS에서는 다음과 같은 형태로 나타날 수 있다.

FMNMX.FTZ R7, RZ, R2, !PT

이 결과를 단순히 “ReLU가 FMNMX 명령으로 변환되었다”고만 해석하는 것은 충분하지 않다.

여기서 더 중요한 것은 다음과 같은 의미 구조다.

입력값 x
+
경계값 0
+
두 값 중 큰 값을 선택
+
부동소수점 FTZ 처리

즉, FMNMX는 ReLU 그 자체라기보다, ReLU의 수학적 의미가 특정 NVIDIA GPU에서 실현된 한 가지 방식이다.

따라서 현재 작업을 다음과 같이 일반화할 수 있다.

수학적 의미와 성질
    ↓
기계가 실행할 수 있는 의미 구조
    ↓
특정 하드웨어에 적합한 구현
    ↓
실제 기계 명령

연구의 최종 목표는 특정 SASS 명령을 분석하는 데 있지 않다.

더 근본적인 목표는 다음과 같다.

수학적 연산의 의미가
기계 실행에 가까운 구조로 어떻게 변환되는가

그리고 그 구조를 이용하여 다음 작업을 수행하는 것이다.

• 의미적으로 같은 표현을 판별한다.
• 수학적 불변성을 유지하면서 연산을 변환한다.
• 중복 연산을 제거한다.
• 연산 순서를 재배치한다.
• 여러 연산을 융합한다.
• 불필요한 중간 메모리 저장을 제거한다.
• 대상 하드웨어에 가장 적합한 구현을 선택한다.
• 변환 전후의 의미 보존 여부를 검증한다.

---

2. SASS의 위치 재정의

현재는 SASS를 연산이 도달하는 최종 lowering 표현으로 관찰하고 있다.

하지만 연구를 일반화하려면 SASS를 최종 목적이 아니라 하나의 구체적인 관찰 지점으로 보아야 한다.

전체 구조는 다음과 같이 정리할 수 있다.

수학적 정의
    ↓
의미적 연산 표현
    ↓
기계 근접 의미 표현
    ↓
메모리와 병렬 실행 표현
    ↓
하드웨어별 명령 선택
    ↓
PTX, SASS, CPU ISA, NPU 명령

이 관점에서 SASS는 다음과 같은 의미를 가진다.

추상적인 계산 의미가
특정 NVIDIA GPU에서 실현된 결과

따라서 SASS에서 발견한 opcode 자체를 일반화하는 것이 아니라, opcode 뒤에 존재하는 공통 실행 구조를 추출해야 한다.

ReLU의 경우 SASS 수준에서는 다음과 같이 보인다.

FMNMX.FTZ R7, RZ, R2, !PT

이를 특정 ISA와 무관한 형태로 바꾸면 다음과 같다.

result = maximum(input, zero)

한 단계 더 수학적으로 해석하면 다음과 같다.

입력을 비음수 공간으로 사영한다.

즉, 하나의 연산을 세 가지 수준에서 표현할 수 있다.

수학적 의미:
    비음수 공간으로의 사영

기계 근접 의미:
    maximum(x, 0)

특정 하드웨어 구현:
    FMNMX.FTZ

이러한 분리가 일반화의 핵심이다.

---

3. 필요한 중간 계층

고수준 수학 표현과 실제 ISA 사이에는 하나의 중간 의미 계층이 필요하다.

이를 임시로 다음과 같이 부를 수 있다.

Semantic Lowering IR

또는

Machine-Near Semantic IR

이 표현은 두 가지 조건을 만족해야 한다.

첫째, 특정 하드웨어의 opcode에 종속되지 않아야 한다.

둘째, 실제 기계에서 구현할 수 있을 정도로 충분히 구체적이어야 한다.

예를 들어 ReLU를 다음처럼 표현할 수 있다.

%y = maximum %x, 0

이 표현은 NVIDIA의 FMNMX, CPU의 vector max, compare-select 조합 등으로 모두 변환될 수 있다.

하지만 수학적 의미를 더 직접적으로 보존하려면 다음과 같은 표현도 생각할 수 있다.

%y = project_to_nonnegative %x

두 표현은 서로 다른 추상화 수준을 가진다.

project_to_nonnegative(x)
    ↓ 의미 정규화
maximum(x, 0)
    ↓ 하드웨어별 lowering
FMNMX / VMAX / CMP+SELECT / activation unit

따라서 하나의 IR만 사용하는 것보다 적어도 두 계층으로 나누는 것이 적절하다.

의미 중심 표현

project_to_nonnegative(x)
normalize_probability(x)
reduce_sum(x)
select_by_sign(x)

이 계층은 연산의 수학적 목적을 보존한다.

기계 근접 표현

maximum(x, 0)
compare(x, 0)
select(predicate, a, b)
add(a, b)
multiply(a, b)
reduce_add(values)

이 계층은 실제 하드웨어 명령으로 옮기기 쉬운 primitive를 사용한다.

---

4. 하드웨어 비종속성의 정확한 의미

완전히 하드웨어와 무관하면서 동시에 기계어에 가까운 표현을 만드는 것은 사실상 불가능하다.

기계 실행에는 필연적으로 다음 요소가 포함되기 때문이다.

• 유한한 데이터 타입
• 레지스터 또는 저장 공간
• 메모리 계층
• 병렬 실행 단위
• 동기화 범위
• 벡터 폭
• 연산 지연 시간
• 데이터 이동 비용

따라서 목표는 하드웨어를 완전히 제거하는 것이 아니다.

더 적절한 방향은 다음과 같다.

공통 실행 의미
+
하드웨어별 제약과 비용 모델

예를 들어 다음 의미는 하드웨어에 종속되지 않는다.

maximum(x, 0)

하지만 이를 구현하는 방식은 하드웨어마다 다를 수 있다.

하드웨어 A:
    maximum 명령 1개

하드웨어 B:
    compare + select

하드웨어 C:
    predicate + conditional move

하드웨어 D:
    전용 activation unit

하드웨어 E:
    branch 기반 구현

이 모든 표현은 같은 의미를 구현할 수 있다.

따라서 연구 체계에서는 다음 두 문제를 분리해야 한다.

어떤 표현들이 의미적으로 가능한가

그중 어떤 표현이 대상 하드웨어에서 가장 저렴한가

---

5. 전체 표현 계층

5.1 수학적 의미 계층

가장 높은 계층에서는 연산을 함수와 수학적 성질로 정의한다.

ReLU의 정의는 다음과 같다.

f(x) = max(0, x)

ReLU가 가진 주요 성질은 다음과 같다.

출력 범위:
    f(x) >= 0

멱등성:
    f(f(x)) = f(x)

단조성:
    x <= y 이면 f(x) <= f(y)

양의 동차성:
    alpha >= 0 이면
    f(alpha * x) = alpha * f(x)

비가역성:
    서로 다른 음수 입력이 모두 0으로 합쳐진다.

고정점:
    x >= 0인 모든 값에 대해 f(x) = x

이 계층에서는 실제 명령어보다 연산이 어떤 상태 변환을 수행하는지를 정의한다.

---

5.2 의미 정규화 계층

동일한 연산은 소스 코드에서 여러 형태로 작성될 수 있다.

y = x > 0 ? x : 0;

y = max(x, 0);

if (x > 0)
    y = x;
else
    y = 0;

이 표현들은 문법적으로 다르지만 공통 의미 표현으로 정규화될 수 있다.

maximum(x, 0)

이 계층의 목적은 소스 코드의 문법적 차이를 제거하는 것이다.

즉, “어떻게 작성했는가”보다 “무엇을 계산하는가”를 남긴다.

---

5.3 기계 근접 의미 계층

정규화된 연산은 실제 기계에서 구현 가능한 primitive로 표현된다.

예를 들면 다음과 같다.

add
subtract
multiply
fused_multiply_add
compare
select
minimum
maximum
absolute
convert
load
store
broadcast
permute
reduce
synchronize

이 계층은 특정 ISA 이름을 사용하지 않는다.

하지만 연산의 계산 구조는 충분히 구체적으로 드러난다.

예를 들어 ReLU에는 다음과 같은 후보 표현들이 존재할 수 있다.

maximum(x, 0)

p = compare_greater(x, 0)
y = select(p, x, 0)

sign = extract_sign(x)
mask = create_mask(sign)
y = bit_select(mask, 0, x)

이들은 구현 방식은 다르지만 같은 의미를 가질 수 있다.

---

5.4 메모리와 병렬 실행 계층

연산 의미만으로는 실제 실행 구조를 충분히 설명할 수 없다.

다음과 같은 정보도 필요하다.

값을 어디에서 읽는가
값을 어디에 저장하는가
값을 다른 실행 단위와 공유하는가
중간 결과를 실제 메모리에 기록하는가
레지스터에 유지하는가
동기화가 필요한가

이 계층에서는 특정 GPU의 global memory, shared memory 같은 명칭을 바로 사용하기보다 일반적인 속성을 사용할 수 있다.

예를 들면 다음과 같다.

storage scope:
    private
    subgroup-shared
    workgroup-shared
    device-global

visibility:
    local
    subgroup
    workgroup
    device

operation:
    load
    store
    broadcast
    exchange
    barrier
    atomic update

이후 대상 하드웨어가 이를 실제 메모리 구조에 매핑한다.

예를 들어 workgroup-shared는 어떤 GPU에서는 shared memory가 될 수 있고, 다른 가속기에서는 local scratchpad가 될 수 있다.

---

5.5 하드웨어별 실현 계층

마지막 단계에서 공통 실행 표현이 실제 ISA와 하드웨어 자원에 매핑된다.

이 단계에서 결정되는 것은 다음과 같다.

• 실제 opcode
• 레지스터 할당
• 실제 메모리 공간
• vector width
• thread 또는 lane mapping
• instruction scheduling
• synchronization 명령
• 근사 명령 사용 여부
• fused instruction 사용 여부

예를 들어 다음 공통 표현이 있다고 하자.

maximum(x, 0)

하드웨어별 결과는 다음처럼 달라질 수 있다.

NVIDIA GPU:
    FMNMX

x86 SIMD:
    VMAXPS

단순 스칼라 CPU:
    CMP + CMOV

NPU:
    activation mode = ReLU

---

6. 연산에 수학적 성질을 부착하기

각 연산을 단순히 이름으로만 표현하지 않고, 연산이 가진 성질을 함께 기록할 수 있다.

ReLU에 대해 다음과 같은 속성을 부착할 수 있다.

operation: ReLU

output_range:
    [0, +infinity)

monotone:
    true

idempotent:
    true

positive_homogeneous:
    true

injective:
    false

elementwise:
    true

piecewise_linear:
    true

lipschitz_constant:
    1

fixed_point_set:
    [0, +infinity)

이러한 성질의 집합을 연산의 의미적 fingerprint라고 볼 수 있다.

Semantic Fingerprint
=
연산의 정의
+
출력 범위
+
불변성
+
대수적 성질
+
정보 보존 특성

이 fingerprint는 최적화 규칙을 적용하는 근거로 사용할 수 있다.

---

7. 수학적 성질에 기반한 최적화

7.1 멱등성 기반 중복 제거

어떤 연산 f가 다음 성질을 가진다고 하자.

f(f(x)) = f(x)

그러면 다음 변환이 가능하다.

f(f(x))
    ->
f(x)

ReLU의 경우 다음과 같다.

ReLU(ReLU(x))
    ->
ReLU(x)

이 최적화는 연산 이름을 직접 검사해서 수행할 수도 있지만, 더 일반적으로는 idempotent = true라는 성질을 이용할 수 있다.

---

7.2 출력 범위 기반 제거

어떤 연산 g의 출력이 항상 비음수라고 하자.

g(x) >= 0

그렇다면 다음 연산은 불필요하다.

ReLU(g(x))

왜냐하면 ReLU는 비음수 입력에 대해 항등 함수이기 때문이다.

y >= 0 이면 ReLU(y) = y

따라서 다음 변환이 가능하다.

ReLU(g(x))
    ->
g(x)

이것은 단순한 패턴 매칭보다 더 강력하다.

앞선 연산의 출력 범위를 추론해야 하기 때문이다.

---

7.3 동차성 기반 재배치

ReLU는 양의 스케일에 대해 다음 성질을 가진다.

alpha >= 0일 때

ReLU(alpha * x)
=
alpha * ReLU(x)

따라서 다음 두 표현은 실수 수학에서 동등하다.

ReLU(alpha * x)

alpha * ReLU(x)

이를 이용하면 scaling과 activation의 순서를 변경할 수 있다.

하지만 실제 FP32에서는 다음을 추가로 확인해야 한다.

• overflow가 발생하는가
• underflow가 발생하는가
• FTZ 동작이 같은가
• rounding 순서가 달라지는가
• NaN 처리가 같은가
• signed zero가 보존되는가

즉, 수학적 동등성만으로 최적화를 확정해서는 안 된다.

---

7.4 고정점 집합을 이용한 제거

ReLU의 고정점 집합은 비음수 전체다.

x >= 0이면 ReLU(x) = x

어떤 분석을 통해 특정 값이 이미 고정점 집합 안에 있다는 사실을 증명하면 ReLU를 제거할 수 있다.

known_nonnegative(x)
    ->
ReLU(x) = x

이와 같은 방식은 clamp, normalization, projection 연산에도 일반화할 수 있다.

---

7.5 연산 융합

다음과 같은 연산이 있다고 하자.

t = a * b + c
y = ReLU(t)

이를 별도의 중간 저장 없이 하나의 실행 구조로 합칠 수 있다.

y = fused_bias_activation(a * b, c)

또는 행렬곱 epilogue 안에 ReLU를 포함할 수 있다.

이때 보존해야 하는 것은 단순히 최종 결과만이 아니다.

다음도 함께 고려해야 한다.

• FMA 사용으로 rounding이 달라지는가
• 중간값이 메모리에 materialize되지 않아도 되는가
• alias 관계가 존재하는가
• backward에서 필요한 중간값은 무엇인가
• activation mask를 다시 계산할 수 있는가

---

8. 불변성을 유지하는 변환

모든 최적화는 다음 세 요소로 표현할 수 있다.

변환 규칙
+
적용 조건
+
보존해야 할 불변성

예를 들어 멱등성 기반 변환은 다음과 같다.

규칙:
    f(f(x)) -> f(x)

조건:
    f가 멱등적이다.

보존 불변성:
    모든 유효한 입력 x에 대해
    변환 전후 출력이 같다.

형식적으로는 다음과 같다.

for all x:

eval_before(x) = eval_after(x)

하지만 실제 컴파일러에서는 “같다”의 의미를 더 세분화해야 한다.

---

9. 의미 보존 수준

9.1 비트 단위 동일성

변환 전후의 출력 비트 패턴이 완전히 같다.

가장 강한 의미 보존이다.

부동소수점 연산 순서를 바꾸면 쉽게 깨질 수 있다.

---

9.2 IEEE 부동소수점 의미 보존

다음 요소를 포함한 동등성이다.

• rounding mode
• NaN
• infinity
• signed zero
• exception behavior
• subnormal

비트 단위 동일성과 거의 비슷하게 엄격하지만, 변환 정책에 따라 일부 차이를 허용할 수 있다.

---

9.3 허용 오차 기반 보존

abs(result_after - result_before) <= epsilon

또는

relative_error <= epsilon

근사 exp, reciprocal, softmax, normalization 최적화 등에 사용할 수 있다.

---

9.4 응용 수준 의미 보존

딥러닝에서는 다음과 같은 기준도 가능하다.

• 모델 정확도 저하가 허용 범위 이내다.
• 출력 분포 차이가 허용 범위 이내다.
• 최종 argmax가 유지된다.
• 학습 수렴 특성이 유지된다.

그러나 이는 일반적인 컴파일러 의미 보존보다 약한 기준이므로 별도의 optimization mode로 분리해야 한다.

---

10. 보존해야 하는 불변성의 종류

10.1 함수 의미

f_before(x) = f_after(x)

---

10.2 출력 범위

예를 들어 softmax라면 다음을 유지해야 한다.

각 출력은 0 이상이다.
전체 출력의 합은 1이다.

즉,

p[i] >= 0
sum(p[i]) = 1

---

10.3 순서 관계

단조성을 유지해야 하는 경우 다음 관계가 보존되어야 한다.

x1 <= x2 이면
f(x1) <= f(x2)

---

10.4 대칭성

입력 순서를 바꿨을 때 출력도 동일한 방식으로 바뀌는 equivariance나, 출력이 바뀌지 않는 invariance를 유지해야 한다.

---

10.5 메모리 의미

다음을 보존해야 한다.

• read와 write 순서
• alias 관계
• visibility
• synchronization
• race freedom
• 원자성

수학적으로 같은 식이라도 메모리 부작용이 다르면 같은 프로그램이라고 볼 수 없다.

---

10.6 정보 보존과 소실 구조

어떤 연산이 원래 비가역적이라면 최적화 후에도 동일한 정보 소실 구조가 유지되어야 한다.

반대로 원래 가역적인 연산을 비가역적인 근사로 바꾸었다면 의미가 약화된 것이다.

---

11. 의미와 비용의 분리

두 표현이 의미적으로 같다고 해서 성능도 같은 것은 아니다.

따라서 의미 체계와 비용 체계를 분리해야 한다.

의미 체계

Semantics(A) = Semantics(B)

A와 B가 같은 계산을 수행하는지 판별한다.

비용 체계

Cost_target(A)
Cost_target(B)

대상 하드웨어에서 어느 표현이 더 저렴한지 평가한다.

비용에는 다음이 포함될 수 있다.

• 명령 수
• latency
• throughput
• register pressure
• memory traffic
• synchronization cost
• occupancy 영향
• vector utilization
• branch divergence
• instruction pipeline 사용량

최종 선택은 다음 형태가 된다.

의미적으로 가능한 표현들을 생성한다.
    ↓
대상 하드웨어의 비용을 계산한다.
    ↓
가장 낮은 비용의 표현을 선택한다.

형식적으로 표현하면 다음과 같다.

best_expression
=
argmin Cost_target(expression)

단, 후보 표현은 모두 요구되는 의미 불변성을 만족해야 한다.

---

12. 동등한 표현 집합

하나의 연산에는 여러 동등한 표현이 존재할 수 있다.

ReLU의 예는 다음과 같다.

max(x, 0)

select(x > 0, x, 0)

clamp(x, 0, +infinity)

(x + abs(x)) * 0.5

실수 수학에서는 이들이 같은 함수를 표현할 수 있다.

따라서 하나의 동등성 집합으로 관리할 수 있다.

ReLU equivalence class:

    max(x, 0)
    select(x > 0, x, 0)
    clamp(x, 0, +infinity)
    (x + abs(x)) * 0.5

이후 대상 하드웨어에 따라 적합한 표현을 선택한다.

하지만 부동소수점 환경에서는 이 표현들이 완전히 같지 않을 수 있다.

예를 들어 다음 표현은 overflow 가능성이 있다.

(x + abs(x)) * 0.5

x가 매우 큰 양수라면 x + abs(x)가 먼저 overflow할 수 있다.

반면 다음 표현은 같은 문제가 없을 수 있다.

max(x, 0)

따라서 동등성 집합에는 다음이 함께 기록되어야 한다.

수학적 동등성
부동소수점 동등성
적용 조건
오차 범위
특수값 처리

---

13. 메모리 lowering의 일반화

현재 SASS 분석에서는 다음 구조를 관찰한다.

LDG
    ↓
register computation
    ↓
STG

이를 특정 GPU와 무관한 형태로 일반화하면 다음과 같다.

입력 텐서 원소 읽기
    ↓
로컬 계산
    ↓
결과 원소 쓰기

더 복잡한 연산에서는 다음과 같은 흐름이 나타날 수 있다.

전역 저장 공간에서 읽기
    ↓
작업 그룹 공유 공간으로 이동
    ↓
로컬 계산
    ↓
실행 단위 간 값 교환
    ↓
부분 결과 결합
    ↓
최종 저장

이를 일반화하려면 각 값에 다음 속성을 부착할 수 있다.

lifetime
access pattern
reuse count
alias set
scope
mutability
layout
alignment
materialization requirement

그 후 대상 하드웨어에 따라 저장 위치를 결정한다.

register
local scratchpad
shared memory
cache
global memory

이 관점에서 메모리 최적화의 핵심 질문은 다음과 같다.

수학적 계산 그래프가 요구하는 정보 흐름을
어떤 저장과 이동 구조로 실현할 것인가

---

14. ReLU를 통한 전체 과정

ReLU를 다음의 의미 표현에서 시작한다.

project_to_nonnegative(x)

이를 기계 근접 표현으로 정규화한다.

maximum(x, 0)

가능한 구현 후보를 만든다.

후보 1:
    maximum(x, 0)

후보 2:
    p = compare_greater(x, 0)
    y = select(p, x, 0)

후보 3:
    sign = extract_sign(x)
    mask = create_mask(sign)
    y = bit_select(mask, 0, x)

후보 4:
    activation_unit(ReLU, x)

각 후보에 대해 의미 조건을 검사한다.

일반 입력에서 같은가
NaN 처리 방식이 같은가
-0 처리 방식이 같은가
subnormal 처리 방식이 같은가

이후 target별 비용을 평가한다.

NVIDIA GPU:
    FMNMX가 가장 적절할 가능성

SIMD CPU:
    vector maximum이 적절할 가능성

단순 CPU:
    compare + conditional move 가능

NPU:
    전용 activation mode 가능

따라서 ReLU의 본질은 FMNMX가 아니다.

ReLU의 본질은 다음 의미다.

입력을 비음수 영역으로 보낸다.
비음수 입력은 유지한다.
음수 입력은 경계값 0으로 합친다.

FMNMX는 이 의미의 특정 하드웨어 구현이다.

---

15. 연구 결과물의 구조

이 연구를 체계화하면 다음과 같은 결과물을 만들 수 있다.

15.1 Mathematical Semantics Library

각 연산의 수학적 정의와 성질을 기록한다.

예:

operation
domain
codomain
output range
monotonicity
idempotence
homogeneity
invertibility
symmetry
fixed points
Lipschitz bound
information loss

---

15.2 Semantic Lowering Pattern Library

수학적 구조가 어떤 기계 근접 구조로 변환될 수 있는지를 기록한다.

예:

비음수 사영
    ->
maximum(x, 0)

조각별 함수
    ->
compare + select
    또는
specialized min/max instruction

reduction
    ->
local combine
    +
cross-lane combine
    +
final aggregate

normalization
    ->
statistic extraction
    +
centering/scaling
    +
output reconstruction

---

15.3 Verified Rewrite Library

수학적 성질에 기반한 변환 규칙을 기록한다.

예:

ReLU(ReLU(x))
    ->
ReLU(x)

clamp(clamp(x, a, b), a, b)
    ->
clamp(x, a, b)

ReLU(x)
    ->
x

조건:
    x >= 0이 증명됨

각 규칙에는 다음이 포함되어야 한다.

• 적용 조건
• 보존되는 의미 수준
• 부동소수점 예외
• target 독립 여부
• 허용 오차

---

15.4 Target Mapping Library

공통 primitive를 실제 하드웨어 구현에 대응시킨다.

예:

maximum
    -> FMNMX
    -> VMAXPS
    -> CMP + SELECT
    -> activation unit

subgroup reduction
    -> warp shuffle tree
    -> SIMD horizontal add
    -> local scratchpad reduction

---

15.5 Target Cost Model

하드웨어별 비용을 기록한다.

instruction latency
instruction throughput
register pressure
memory traffic
synchronization cost
occupancy impact
vector utilization
special execution unit usage

---

16. 현재 연구에서 다음 단계

현재 ReLU와 같은 연산별 SASS 관찰은 의미 패턴을 추출하기 위한 기초 데이터가 된다.

다음 단계는 각 연산에 대해 세 표현을 함께 기록하는 것이다.

첫 번째: 수학적 의미

예:

ReLU:
    비음수 공간으로의 사영

두 번째: 기계 근접 의미 패턴

boundary = 0
result = maximum(input, boundary)

세 번째: 실제 target 구현

PTX:
    max.ftz.f32

SASS:
    FMNMX.FTZ

이렇게 기록하면 SASS 분석이 특정 하드웨어에 갇히지 않는다.

다른 하드웨어를 분석할 때도 동일한 의미 패턴과 비교할 수 있다.

같은 의미가
어떤 하드웨어에서는 하나의 opcode로 나타나는가

어떤 하드웨어에서는 compare-select로 나타나는가

어떤 하드웨어에서는 전용 unit으로 나타나는가

---

17. 최종 목표

이 연구의 최종 형태는 다음과 같은 시스템으로 볼 수 있다.

입력:
    연산의 수학적 의미
    입력 범위
    데이터 타입
    수치 의미
    메모리 의미
    보존해야 할 불변성

처리:
    가능한 의미 보존 변환 생성
    동등한 실행 표현 탐색
    target별 비용 평가
    최적 표현 선택

출력:
    의미와 불변성을 만족하는
    target 최적화된 lowering

전체 과정을 한 줄로 표현하면 다음과 같다.

수학적 의미를 보존하면서
여러 실행 가능한 표현을 생성하고,
대상 하드웨어에서 가장 적절한 표현을 선택한다.

이때 최적화의 기준은 단순히 명령 수가 아니다.

다음을 함께 고려해야 한다.

계산량
데이터 이동
레지스터 사용량
동기화
병렬성
수치 안정성
의미 보존 수준

---

18. 결론

현재 수행 중인 SASS 분석은 충분히 더 일반적인 연구로 확장할 수 있다.

다만 일반화의 대상은 FMNMX, FFMA, MUFU와 같은 opcode 자체가 아니다.

그 뒤에 존재하는 의미 구조를 추출해야 한다.

예를 들면 다음과 같다.

경계로의 사영
값 선택
상태 합류
조건부 정보 전달
정보 소실
reduction
broadcast
data movement
synchronization
finite-precision transformation

SASS는 이러한 구조가 특정 NVIDIA GPU에서 어떤 명령으로 실현되는지를 보여주는 하나의 사례다.

따라서 전체 연구는 다음 세 요소로 분리할 수 있다.

수학적 의미
+
기계 근접 실행 구조
+
하드웨어별 비용과 제약

수학적 의미와 불변성은 하드웨어 비종속적으로 정의한다.

실행 구조는 특정 ISA에 종속되지 않은 primitive로 표현한다.

실제 opcode, 메모리 공간, vector width, scheduling은 target별 lowering에서 결정한다.

최종적으로 이 연구의 목표는 다음과 같이 정리할 수 있다.

수학적 성질을 이용하여
의미적으로 가능한 lowering을 생성하고,

불변성을 유지하는 변환만 허용하며,

대상 하드웨어에서 가장 효율적인 구현을 선택하는
하드웨어 매개형 최적화 체계를 구축한다.

즉, 현재의 SASS 관찰은 최종 목적이 아니라 출발점이다.

SASS를 통해 연산의 수학적 의미가 실제 실행 구조로 바뀌는 방식을 관찰하고, 그 관찰에서 하드웨어에 종속되지 않는 공통 의미 패턴을 추출한다.

그 패턴을 기반으로 이후에는 단순히 lowering 결과를 해석하는 수준을 넘어 다음 단계로 발전할 수 있다.

새로운 lowering 후보 생성
의미 보존 검증
불변성 기반 최적화
target별 구현 선택