컴퓨터 구조 완전 가이드: ISA부터 GPU 병렬 아키텍처까지

응용 프로그램 (Application)
       ↓
운영체제 (Operating System)
       ↓
ISA (Instruction Set Architecture)  ← 하드웨어/소프트웨어 경계
       ↓
마이크로아키텍처 (Microarchitecture)
       ↓
논리 게이트 (Logic Gates)
       ↓
트랜지스터 (Transistors)

CPU Time = Instruction Count × CPI × Clock Cycle Time
         = Instruction Count × CPI / Clock Rate

Speedup = 1 / ((1 - f) + f/s)

R-형식 (레지스터 연산):
[funct7|rs2|rs1|funct3|rd|opcode]
 7비트  5비트 5비트 3비트 5비트 7비트

I-형식 (즉시값/로드):
[imm[11:0]|rs1|funct3|rd|opcode]
  12비트   5비트 3비트 5비트 7비트

S-형식 (스토어):
[imm[11:5]|rs2|rs1|funct3|imm[4:0]|opcode]

B-형식 (분기):
[imm[12|10:5]|rs2|rs1|funct3|imm[4:1|11]|opcode]

U-형식 (상위 즉시값):
[imm[31:12]|rd|opcode]

J-형식 (JAL):
[imm[20|10:1|11|19:12]|rd|opcode]

# RISC-V 어셈블리 예제
# 기본 산술 연산
add  a0, a0, a1      # a0 = a0 + a1
sub  t0, t1, t2      # t0 = t1 - t2
addi t0, t0, 10      # t0 = t0 + 10 (즉시값)
mul  a0, a1, a2      # a0 = a1 * a2

# 메모리 접근 (Load/Store)
lw   t0, 0(a0)       # t0 = Memory[a0 + 0]   (워드 로드)
lh   t1, 2(a0)       # t1 = Memory[a0 + 2]   (하프워드 로드)
lb   t2, 1(a0)       # t2 = Memory[a0 + 1]   (바이트 로드)
sw   t0, 4(a0)       # Memory[a0 + 4] = t0   (워드 스토어)

# 논리 연산
and  t0, t1, t2      # t0 = t1 & t2
or   t0, t1, t2      # t0 = t1 | t2
xor  t0, t1, t2      # t0 = t1 ^ t2
sll  t0, t1, t2      # t0 = t1 << t2 (논리 왼쪽 시프트)
srl  t0, t1, t2      # t0 = t1 >> t2 (논리 오른쪽 시프트)

# 분기 및 점프
beq  t0, t1, label   # if t0 == t1, jump to label
bne  t0, t1, label   # if t0 != t1, jump to label
blt  t0, t1, label   # if t0 < t1,  jump to label
bge  t0, t1, label   # if t0 >= t1, jump to label
jal  ra, func        # ra = PC+4; jump to func
jalr ra, 0(t0)       # ra = PC+4; jump to t0+0

# RISC-V 레지스터 규약
# x0 (zero): 항상 0
# x1 (ra):   반환 주소 (Return Address)
# x2 (sp):   스택 포인터 (Stack Pointer)
# x10-x17 (a0-a7): 함수 인자/반환값
# x5-x7, x28-x31 (t0-t6): 임시 레지스터
# x8-x9, x18-x27 (s0-s11): 저장 레지스터

// C 코드
int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

# RISC-V 어셈블리 (재귀 팩토리얼)
factorial:
    addi sp, sp, -16     # 스택 프레임 할당
    sw   ra, 12(sp)      # 반환 주소 저장
    sw   a0, 8(sp)       # n 저장

    addi t0, zero, 1
    bgt  a0, t0, recurse # n > 1이면 재귀
    addi a0, zero, 1     # return 1
    j    done

recurse:
    addi a0, a0, -1      # n - 1
    jal  ra, factorial   # 재귀 호출
    lw   t0, 8(sp)       # n 복원
    mul  a0, t0, a0      # n * factorial(n-1)

done:
    lw   ra, 12(sp)      # 반환 주소 복원
    addi sp, sp, 16      # 스택 프레임 해제
    jalr zero, 0(ra)     # 반환

ADD:  결과 = A + B
SUB:  결과 = A + (~B + 1) = A - B  (2의 보수)
AND:  결과 = A AND B
OR:   결과 = A OR B
XOR:  결과 = A XOR B
SLT:  결과 = (A < B) ? 1 : 0  (Set Less Than)
SLL:  결과 = A << B (시프트)

FA0: S0 = A0 XOR B0 XOR Cin;  C1 = (A0 AND B0) OR ...
FA1: S1 = A1 XOR B1 XOR C1;  C2 = ...
...
FAn: Sn = An XOR Bn XOR Cn;  Cout = ...

Gi = Ai AND Bi       (올림 생성)
Pi = Ai XOR Bi       (올림 전파)
Ci+1 = Gi OR (Pi AND Ci)

명령어 흐름 (R-형식 ADD):
1. IF: PC → 명령어 메모리 → 명령어 인출
2. ID: 레지스터 파일에서 rs1, rs2 읽기 + 제어 신호 생성
3. EX: ALU에서 rs1 + rs2 계산
4. MEM: (R-형식은 메모리 접근 없음)
5. WB: ALU 결과를 rd에 기록

단계   약어  역할
------+-----+----------------------------------------
인출   IF   PC로부터 명령어를 메모리에서 가져옴
해독   ID   명령어 해독, 레지스터 읽기, 제어 신호 생성
실행   EX   ALU 연산 수행
메모리 MEM  데이터 메모리 읽기/쓰기
기록   WB   레지스터 파일에 결과 저장

사이클:  1    2    3    4    5    6    7    8
Inst 1: IF   ID   EX  MEM   WB
Inst 2:      IF   ID   EX  MEM   WB
Inst 3:           IF   ID   EX  MEM   WB
Inst 4:                IF   ID   EX  MEM   WB

add t0, t1, t2    # t0 쓰기 (WB: 5사이클)
sub t3, t0, t4    # t0 읽기 (ID: 3사이클) → RAW 해저드!

# 로드-유스 해저드 (1 사이클 스톨 불가피)
lw  t0, 0(a0)      # 메모리에서 로드
add t1, t0, t2     # t0 바로 사용 → MEM→EX 전방전달 불가
# 해결: 컴파일러가 독립 명령어 삽입
lw  t0, 0(a0)
add t3, t4, t5     # 독립 명령어 삽입
add t1, t0, t2     # 이제 t0 준비됨

beq t0, t1, label  # 분기 여부 EX 단계에서 결정
# 그 동안 IF, ID에서 인출된 명령어들은?

Intel Core: 6-way 비순서 실행 (Out-of-Order Execution)
AMD Zen 4:  4-way 디코드 + OoO 실행
ARM Cortex-X4: 5-way 디코드

레지스터 (Register)
  용량: ~1KB  |  속도: 1 사이클  |  비용: 매우 높음

L1 캐시 (On-chip)
  용량: 32-64KB  |  속도: 4-5 사이클  |  비용: 높음

L2 캐시 (On-chip)
  용량: 256KB-1MB  |  속도: 12-15 사이클  |  비용: 중간

L3 캐시 (On-chip, 공유)
  용량: 8-64MB  |  속도: 30-40 사이클  |  비용: 낮음

DRAM (Main Memory)
  용량: 8-256GB  |  속도: 200-300 사이클  |  비용: 매우 낮음

SSD/NVMe
  용량: 1-4TB  |  속도: 10,000+ 사이클  |  비용: 아주 낮음

// 공간적 지역성 최적화 예시
// 나쁜 예: 열 우선 접근 (캐시 미스 빈번)
for (int j = 0; j < N; j++)
    for (int i = 0; i < N; i++)
        sum += A[i][j];  // A[0][0], A[1][0], A[2][0]... (행 건너뜀)

// 좋은 예: 행 우선 접근 (캐시 친화적)
for (int i = 0; i < N; i++)
    for (int j = 0; j < N; j++)
        sum += A[i][j];  // A[0][0], A[0][1], A[0][2]... (연속 메모리)

[태그(20비트) | 인덱스(6비트) | 오프셋(6비트)]

가상 주소 (VA): 프로세스가 사용하는 주소 (0x0000 ~ 0xFFFFFFFF)
물리 주소 (PA): 실제 DRAM의 주소
페이지:         가상/물리 메모리의 고정 크기 블록 (보통 4KB)

가상 주소 [VPN | Page Offset]
              ↓
         페이지 테이블 조회
              ↓
물리 주소 [PFN | Page Offset]

[PML4(9비트) | PDPT(9비트) | PD(9비트) | PT(9비트) | Offset(12비트)]

TLB Hit:  가상 주소 → TLB 조회 → 물리 주소 (1-2 사이클)
TLB Miss: 가상 주소 → 페이지 테이블 워크 → 물리 주소 (100+ 사이클)

PCIe 5.0:   x16 슬롯 = 128 GB/s 양방향
NVMe (PCIe):최대 7 GB/s 순차 읽기 (Gen4)
USB 4.0:    최대 40 Gbps
DDR5-6400:  최대 51.2 GB/s (채널당)

Modified (M): 이 코어만 수정된 최신 복사본 보유
Exclusive (E): 이 코어만 보유, 메모리와 동일
Shared (S):   여러 코어가 읽기 전용 복사본 보유
Invalid (I):  유효하지 않음 (다른 코어가 수정함)

#include <omp.h>
#include <stdio.h>
#include <stdlib.h>

// 병렬 배열 합산
int main() {
    int n = 1000000;
    long long sum = 0;
    int *arr = malloc(n * sizeof(int));

    for (int i = 0; i < n; i++)
        arr[i] = i + 1;

    // reduction으로 안전한 병렬 합산
    #pragma omp parallel for reduction(+:sum) schedule(static)
    for (int i = 0; i < n; i++) {
        sum += arr[i];
    }

    printf("Sum = %lld\n", sum);  // 500000500000

    // 병렬 for + 작업 분배
    #pragma omp parallel
    {
        int tid = omp_get_thread_num();
        int nthreads = omp_get_num_threads();
        printf("Thread %d of %d\n", tid, nthreads);
    }

    free(arr);
    return 0;
}

// 행렬 곱셈 병렬화 (캐시 친화적 + OpenMP)
void matmul(float *A, float *B, float *C, int N) {
    #pragma omp parallel for collapse(2) schedule(dynamic, 64)
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            float sum = 0.0f;
            for (int k = 0; k < N; k++) {
                sum += A[i*N + k] * B[k*N + j];
            }
            C[i*N + j] = sum;
        }
    }
}

소켓 0 (Core 0-15) ←→ Local DRAM (64GB)  [~80ns]
      ↕ QPI/Infinity Fabric
소켓 1 (Core 16-31) ←→ Local DRAM (64GB) [~80ns]

소켓 0에서 소켓 1의 메모리 접근: ~160ns (2배 지연)

워프(Warp): 32개 스레드의 묶음 (NVIDIA)
→ 32개 스레드가 동일한 명령어를 동시에 실행
→ 각 스레드는 서로 다른 데이터에 작용

워프 스케줄러: 지연 발생 시(메모리 접근) 즉시 다른 워프로 전환
→ 수천 개 워프를 빠르게 전환하여 지연을 숨김 (Latency Hiding)

GPU
├── GPC (Graphics Processing Cluster) x 8
│   └── SM (Streaming Multiprocessor) x 7-12
│       ├── CUDA Core x 128 (FP32 연산)
│       ├── Tensor Core x 4 (행렬 연산, AI)
│       ├── RT Core x 1 (레이 트레이싱)
│       ├── Warp Scheduler x 4
│       ├── Register File (256KB)
│       └── Shared Memory / L1 Cache (128-256KB)
└── L2 Cache (공유, 수십 MB)

#include <cuda_runtime.h>
#include <stdio.h>

// GPU 커널: 벡터 덧셈
__global__ void vectorAdd(float *a, float *b, float *c, int n) {
    // 스레드 글로벌 인덱스 계산
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx < n) {
        c[idx] = a[idx] + b[idx];
    }
}

int main() {
    int n = 1 << 20;  // 1M 원소
    size_t size = n * sizeof(float);

    // 호스트(CPU) 메모리
    float *h_a = (float*)malloc(size);
    float *h_b = (float*)malloc(size);
    float *h_c = (float*)malloc(size);

    // 디바이스(GPU) 메모리
    float *d_a, *d_b, *d_c;
    cudaMalloc(&d_a, size);
    cudaMalloc(&d_b, size);
    cudaMalloc(&d_c, size);

    // 호스트 → 디바이스 복사
    cudaMemcpy(d_a, h_a, size, cudaMemcpyHostToDevice);
    cudaMemcpy(d_b, h_b, size, cudaMemcpyHostToDevice);

    // 커널 실행: 블록당 256 스레드
    int threadsPerBlock = 256;
    int blocksPerGrid = (n + threadsPerBlock - 1) / threadsPerBlock;
    vectorAdd<<<blocksPerGrid, threadsPerBlock>>>(d_a, d_b, d_c, n);

    // 디바이스 → 호스트 복사
    cudaMemcpy(h_c, d_c, size, cudaMemcpyDeviceToHost);

    cudaFree(d_a); cudaFree(d_b); cudaFree(d_c);
    free(h_a); free(h_b); free(h_c);
    return 0;
}

// 공유 메모리를 활용한 행렬 곱 최적화
#define TILE_SIZE 16

__global__ void matmulShared(float *A, float *B, float *C, int N) {
    __shared__ float tileA[TILE_SIZE][TILE_SIZE];
    __shared__ float tileB[TILE_SIZE][TILE_SIZE];

    int row = blockIdx.y * TILE_SIZE + threadIdx.y;
    int col = blockIdx.x * TILE_SIZE + threadIdx.x;
    float sum = 0.0f;

    for (int t = 0; t < N / TILE_SIZE; t++) {
        // 타일을 공유 메모리로 로드
        tileA[threadIdx.y][threadIdx.x] = A[row * N + t * TILE_SIZE + threadIdx.x];
        tileB[threadIdx.y][threadIdx.x] = B[(t * TILE_SIZE + threadIdx.y) * N + col];
        __syncthreads();  // 모든 스레드 로드 완료 대기

        for (int k = 0; k < TILE_SIZE; k++)
            sum += tileA[threadIdx.y][k] * tileB[k][threadIdx.x];
        __syncthreads();
    }

    if (row < N && col < N)
        C[row * N + col] = sum;
}

일반 CUDA Core: FP32 MAC 1개/사이클
Tensor Core(4세대): 16x16x16 행렬 곱 = 4096 FP16 MAC/사이클

HBM3E (2024): 9.6 Gbps/핀, 8-스택 = 1.2 TB/s (패키지당)
GDDR6X (RTX 4090): 21 Gbps/핀, 384비트 = 1 TB/s
DDR5-6400: 51.2 GB/s (채널당, CPU 기준)

#include <time.h>
#include <stdio.h>
#include <stdlib.h>

#define N 4096

float A[N][N], B[N][N], C[N][N];

// 비효율적: 열 우선 접근 (캐시 미스 많음)
void matmul_naive() {
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            for (int k = 0; k < N; k++)
                C[i][j] += A[i][k] * B[k][j];  // B[k][j] 접근이 비연속
}

// 효율적: 블록 타일링 (캐시 재사용)
#define BLOCK 64
void matmul_tiled() {
    for (int ii = 0; ii < N; ii += BLOCK)
        for (int jj = 0; jj < N; jj += BLOCK)
            for (int kk = 0; kk < N; kk += BLOCK)
                for (int i = ii; i < ii+BLOCK && i < N; i++)
                    for (int j = jj; j < jj+BLOCK && j < N; j++)
                        for (int k = kk; k < kk+BLOCK && k < N; k++)
                            C[i][j] += A[i][k] * B[k][j];
}

#include <immintrin.h>  // AVX2

// AVX2로 float 8개를 동시에 덧셈
void vector_add_avx2(float *a, float *b, float *c, int n) {
    int i;
    for (i = 0; i <= n - 8; i += 8) {
        __m256 va = _mm256_loadu_ps(&a[i]);   // 8x float 로드
        __m256 vb = _mm256_loadu_ps(&b[i]);
        __m256 vc = _mm256_add_ps(va, vb);    // 8x 동시 덧셈
        _mm256_storeu_ps(&c[i], vc);          // 8x float 저장
    }
    // 나머지 원소 처리
    for (; i < n; i++)
        c[i] = a[i] + b[i];
}