HLS 최적화 기법 — Pipeline·Unroll·Partition·Dataflow

1
II=1: 매 cycle 새 input 1개 받음 → throughput = clock
2
II=4: 4 cycle마다 input 1개   → throughput = clock / 4

1
for (int i = 0; i < N; i++) {
2
#pragma HLS PIPELINE II=1
3
    out[i] = process(in[i]);
4
}

1
void filter(float in[N], float out[N]) {
2
#pragma HLS PIPELINE II=1
3
    static float prev = 0;
4
    for (int i = 0; i < N; i++) {
5
        out[i] = 0.5f * (in[i] + prev);
6
        prev = in[i];
7
    }
8
}

1
for (int j = 0; j < 4; j++) {
2
#pragma HLS UNROLL
3
    sum += tap[j] * x[i-j];
4
}

1
for (int j = 0; j < 8; j++) {
2
#pragma HLS UNROLL factor=2
3
    /* 2 단계씩 펼침 */
4
}

1
float coef[8];
2
#pragma HLS ARRAY_PARTITION variable=coef complete dim=1
3

4
float buf[32];
5
#pragma HLS ARRAY_PARTITION variable=buf cyclic factor=4 dim=1
6

7
for (int i = 0; i < N; i++) {
8
#pragma HLS PIPELINE II=1
9
    float sum = 0;
10
    for (int j = 0; j < 8; j++) {
11
#pragma HLS UNROLL
12
        sum += coef[j] * buf[(i+j) & 31];   /* 8개 동시 read */
13
    }
14
    out[i] = sum;
15
}

1
void top(stream<pixel> &in, stream<pixel> &out) {
2
#pragma HLS DATAFLOW
3
    stream<pixel> s1, s2;
4
    color_convert(in, s1);
5
    blur(s1, s2);
6
    edge_detect(s2, out);
7
}

1
void accel(int *in, int *out, int n) {
2
#pragma HLS INTERFACE m_axi      port=in  offset=slave bundle=g0
3
#pragma HLS INTERFACE m_axi      port=out offset=slave bundle=g1
4
#pragma HLS INTERFACE s_axilite  port=n   bundle=ctrl
5
#pragma HLS INTERFACE s_axilite  port=return bundle=ctrl
6
    /* ... */
7
}

1
void fir_naive(float in[N], float out[N]) {
2
    static float buf[8];
3
    for (int i = 0; i < N; i++) {
4
        for (int j = 7; j > 0; j--) buf[j] = buf[j-1];
5
        buf[0] = in[i];
6

7
        float sum = 0;
8
        for (int j = 0; j < 8; j++) sum += COEF[j] * buf[j];
9
        out[i] = sum;
10
    }
11
}

1
void fir_fast(float in[N], float out[N]) {
2
#pragma HLS INTERFACE m_axi port=in  offset=slave bundle=g0
3
#pragma HLS INTERFACE m_axi port=out offset=slave bundle=g1
4

5
    static float buf[8];
6
#pragma HLS ARRAY_PARTITION variable=buf complete dim=1
7

8
    static const float coef[8] = {0.1f, 0.2f, 0.3f, 0.4f, 0.4f, 0.3f, 0.2f, 0.1f};
9
#pragma HLS ARRAY_PARTITION variable=coef complete dim=1
10

11
    for (int i = 0; i < N; i++) {
12
#pragma HLS PIPELINE II=1
13
        for (int j = 7; j > 0; j--) {
14
#pragma HLS UNROLL
15
            buf[j] = buf[j-1];
16
        }
17
        buf[0] = in[i];
18

19
        float sum = 0;
20
        for (int j = 0; j < 8; j++) {
21
#pragma HLS UNROLL
22
            sum += coef[j] * buf[j];
23
        }
24
        out[i] = sum;
25
    }
26
}

1
void sobel(stream<uchar_t> &in, stream<uchar_t> &out, int H, int W) {
2
#pragma HLS INTERFACE axis port=in
3
#pragma HLS INTERFACE axis port=out
4
#pragma HLS PIPELINE II=1
5

6
    static uchar_t line[2][MAX_W];   // 2 line buffer
7
#pragma HLS ARRAY_PARTITION variable=line dim=1
8

9
    uchar_t win[3][3];
10
#pragma HLS ARRAY_PARTITION variable=win complete dim=0
11

12
    for (int y = 0; y < H; y++) {
13
        for (int x = 0; x < W; x++) {
14
#pragma HLS PIPELINE II=1
15
            uchar_t p = in.read();
16

17
            // 3x3 sliding window
18
            for (int j = 0; j < 3; j++)
19
#pragma HLS UNROLL
20
                for (int i = 0; i < 2; i++)
21
#pragma HLS UNROLL
22
                    win[j][i] = win[j][i+1];
23
            win[0][2] = line[0][x];
24
            win[1][2] = line[1][x];
25
            win[2][2] = p;
26

27
            line[0][x] = line[1][x];
28
            line[1][x] = p;
29

30
            // Sobel
31
            int gx = -win[0][0] + win[0][2] - 2*win[1][0] + 2*win[1][2]
32
                     - win[2][0] + win[2][2];
33
            int gy = -win[0][0] - 2*win[0][1] - win[0][2]
34
                     + win[2][0] + 2*win[2][1] + win[2][2];
35
            int mag = (gx < 0 ? -gx : gx) + (gy < 0 ? -gy : gy);
36

37
            out.write(mag > 255 ? 255 : mag);
38
        }
39
    }
40
}

1
Latency:    8302 cycles (1080×768)
2
Interval:   8294 cycles
3
II:         1
4
Resource:
5
  BRAM:     2  (line buffer)
6
  DSP:      8  (Sobel multipliers)
7
  LUT:      850
8
  FF:       1200

1
void rgb_to_gray(stream<rgb_t> &in, stream<uchar_t> &gray, int N) {
2
    for (int i = 0; i < N; i++) {
3
#pragma HLS PIPELINE II=1
4
        rgb_t p = in.read();
5
        gray.write((p.r * 77 + p.g * 150 + p.b * 29) >> 8);
6
    }
7
}
8

9
void blur(stream<uchar_t> &in, stream<uchar_t> &out, int H, int W) { /* ... */ }
10
void edge(stream<uchar_t> &in, stream<uchar_t> &out, int H, int W) { /* ... */ }
11

12
void pipeline(stream<rgb_t> &in, stream<uchar_t> &out, int H, int W) {
13
#pragma HLS DATAFLOW
14
    stream<uchar_t, 1024> s1, s2;
15
    rgb_to_gray(in,  s1, H*W);
16
    blur(s1, s2, H, W);
17
    edge(s2, out, H, W);
18
}

1
for (int i = 0; i < N; i++) {
2
#pragma HLS PIPELINE II=1
3
    sum = sum + arr[i];     /* sum 이전 결과 의존 → II > 1 가능 */
4
}

1
float acc[4] = {0};
2
for (int i = 0; i < N; i++) {
3
#pragma HLS PIPELINE II=1
4
    acc[i & 3] += arr[i];    /* 4 independent acc */
5
}
6
sum = acc[0] + acc[1] + acc[2] + acc[3];

1
int arr[8];
2
#pragma HLS ARRAY_PARTITION variable=arr complete
3

4
for (int i = 0; i < 8; i++)
5
    sum += arr[i];   /* 그래도 sequential — UNROLL 같이 필요 */

1
void f1() { arr[0] = 5; }
2
void f2() { x = arr[0]; }
3
DATAFLOW { f1(); f2(); }   /* arr 통한 share 안 됨 */

1
stream<int, 2> s;   /* depth 2 — backpressure 자주 */

1
#pragma HLS ARRAY_PARTITION variable=big_arr[1024] complete

1
out = sin(x);  /* float sin → 수십 cycle */