디지털 신호처리 시스템 기말고사 (2009년 봄학기)

담당교수 성원용                        시험시간 2009년 5월 27일 10시30분~11시50분

각 큰 문제당 20점, 총 120점

1. 다음의 4가지 computer architecture가 있다.  아래에서 각 설명된 특징에 해당하는 아키텍쳐를 A ~ D에서 고르시오.  여러 개가 해당될 수도 있는데, 가장 관련이 깊은 것으로 고르는데, 각 4개의 질문 그룹당 A, B, C, D 답이 하나씩 있도록 답을 하시오.

A: Superscalar CPU architecture

B: Shared-memory multi-core processor

C: (partitioned data-path) SIMD processor

D: Interconnection based multiprocessor

1.1) Fine grain parallel processing with control (instruction)-level parallelism (    )

1.2)  Coarse grain parallel processing with fork-join model  (    )

1.3) Fine grain parallel processing with data-level parallelism  (    )

1.4) Coarse grain parallel processing with data-level parallelism  (    )

2.1) OpenMP programming interface (    )

2.2) MPI (    )

2.3) Vectorizing compiler (    )

2.4) Instruction scheduler (    )

3.1) Use ILP (instruction-level parallel processing) (    )

3.2) Use TLP (thread-level parallel processing)  (    )

3.3) Use process-level parallel processing  (    )

3.4) Use data-level parallelism (vector processing)  (    )

4.1) Hardware is not well scalable (designing a hardware that support a large parallelism is very difficult)  (    )

4.2) Hardware is very well scalable  (    )

4.3) Extra hardware cost is very small  (    )

4.4) Pentium quad-core CPU

5.1) Parallelize only the inner most 'for' loop  (    )

5.2) Parallelize the outer loop, if possible  (    )

5.3) SPMD (Single Program Multiple Data) programming  (    )

5.4) This architecture can use the existing programs without recompilation (    )

2.  Foster's parallel program development methodology에 의하면 다음의 네 단계로 되어있다.  각각의 단계를 설명하시오.  각 단계에서의 check list를 설명하는 것이 필요하고, 이를 Global Sum (N개의 element의 합을 구함)을 구하는 문제를 예로 들어서 설명하시오.

Partitioning -> Communication -> Agglomeration -> Mapping

3.  a) 아래는 OpenMP로 프로그램을 이용하여 Pi (원주율)를 구하는 프로그램이다.  이 프로그램에서 틀린 부분을 두군데 고르고, 이 때문에 발생할 수 있는 문제를 설명하시오.

16	h = 1.0 / (double) n;

17	sum = 0.0;

18	#pragma omp for private(i,sum) shared(h)

19	for (i = 1; i <= n; i++)

20	{

21	x = h * ((double)i-0.5);

22	sum += (4.0 / (1.0 + x*x));

23	}

24	pi = h * sum;

B) 다음의 프로그램을 OpenMP로 효율성이 높게 병렬화 하시오.  N, M are quite large numbers. 필요하면 코드도 바꾸도, 어떤 스케쥴링이 좋을지도 의논하시오.

....initialize ...

for (i =0; i < N; i++) {

for (j =0; j < M; j++)

y[i,j] = acoef* y[i-1, j] + x[i,j];

}

4. 어떤 프로그램을 MPI로 병렬화시키려고 한다.  이 프로그램은 다음과 같이 두 부분으로 되어있다.

serial part: number of computations  106

parallel part - number of computations for each CPU:  N2/P

memory space needed for each CPU: N2/P

number of communication with P processors  N log2 P

Computation 1회 대 communication 1회의 비용의 비는 1 대 100으로 가정을 한다.

A) 이 프로그램의 speed-up을 P (the number of processors), N (data size)의 함수로 나타내시오.  Single processor speed-up: 100%.  그리고 N=10,000, P = 4일 때의 speed-up을 보이시오.

B) Iso-efficiency를 유지하기 위한 P와 processor memory size의 관계를 나타내시오. 그리고 여기에서 이 프로그램은 Iso-efficiency의 관점에서 scalable한지 판단하시오.

5. 아래는 Matrix multiplication을 보여주고 있다.

A) 11번 라인의 shared memory access에서 bank conflict가 있는지 판단하시오.

B) TILE_WIDTH를 두배로 늘리면 이 프로그램의 성능이 어떻게 될지 의논하시오. 즉 이 때는 하나의 thread가 네개의 출력 point를 계산하는 식이 될 것이다.

__global__ void MatrixMulKernel(float* Md, float* Nd, float* Pd, int Width)

{

1.  __shared__float Mds[TILE_WIDTH][TILE_WIDTH];

2.  __shared__float Nds[TILE_WIDTH][TILE_WIDTH];

3.  int bx = blockIdx.x  int by = blockIdx.y

4.  int tx = threadIdx.x int ty = threadIdx.y

// Identify the row and column of the Pd element to work on

5.  int Row = by * TILE_WIDTH + ty

6.  int Col = bx * TILE_WIDTH + tx

7.   float Pvalue = 0;

// Loop over the Md and Nd tiles required to compute the Pd element

8.   for (int m = 0; m < Width/TILE_WIDTH; ++m) {

// Coolaborative loading of Md and Nd tiles into shared memory

9.	Mds[ty][tx] = Md[Row*Width + (m*TILE_WIDTH + tx)];

Nds[ty][tx] = Nd[Col + (m*TILE_WIDTH + ty)*Width];

__syncthreads();

11.   for (int k = 0; k < TILE_WIDTH; ++k)

Pvalue += Mds[ty][k] * Nds[k][tx];

Synchthreads();

}

13.   Pd[Row*Width+Col] = Pvalue

}

6. 다음 A, B 두개의 문제 중 A 또는 B 하나만을 골라서 답을 하시오.

A) 입력 데이타 x[0]~x[N/2-1]을 이용하여 N-point DFT를 수행하고자 한다.  즉 x[N/2] ~ x[N-1]의 데이타는 0이다.  얻어지는 값은 X[0]~X[N-1]이다.  그리고 입력 데이타는 전부 real 값을 가진다.  이 때 계산량을 줄이도록 계산과정을 보이고, 몇번의 실수(real) 또는 복소수(complex) 계산(승산과 가산)이 필요한지 보이시오.  힌트: 입력 데이타가 실수(real), 입력 데이타의 절반이 0이라는 사실을 이용하도록 한다.  계산회수 산출 시에 대충 큰 수에 집중해서 답을 내면 된다.

B. A floating-point version C program of a second order IIR digital filter is shown at the end of this exam sheet.  This program needs to be changed to an integer version.  The estimated range of the variables are as follows.

R (x) = 0.99, R (d1) = 3.9, R (t1) = 7.9, R(y1) = 1.9

(a) Draw a flow graph for this digital filter.  The variable name and coefficients need to be shown with the range or the coefficients values in a floating-point format.

(b) Determine the IWL for all the internal variables and coefficients.

(c) Convert the coefficients' value into an integer format.  And design an integer version of the flow graph.

(d) Develop an integer version of C program.

***  Second order IIR filter program for this question ***

float a1[3] = { 1, 0.355407, 1.0 };

float b1[2] = { 1.66664, -0.75504 };

float d1[2];

void iir4(float *x, float *y)

{

float x1, y1, t1, t2;

x1 =  *x;

t1 = x1 + b1[0]*d1[0] + b1[1]*d1[1];

y1 = a1[0]*t1 + a1[1]*d1[0] + a1[2]*d1[1];

d1[1] = d1[0];

d1[0] = t1;

*y = y1;

}

답:

1. abcd, bdca, abdc, adcb, cbda

3. A)

Two bugs: x has to be "private," sum should be a reduction variable.

B)  i 에 대해서 dependency가 있다.   statitic scheduling이 적당.

#pragma omp parallel for private (i)

for (j =0; j < M; j++) {

for (i =0; i < N; i++)

y[i,j] = acoef* y[i-1, j] + x[i,j];

}

4. A)

Speed-up = 100%* (106 + N2)/ (106 + N2/P + 100*N*logP)

N=10,000, P =4라면  Speed-up = 361%

B)

Iso-efficiency 조건   N2 >= C N logP -> N >= C log P

Processor memory size = N2/P = (C log P)2/P

분모보다 분자가 작으므로 매우 scalable하다.

5. A) Mds access시에는 동일한 element를 access하는 것이기 때문에 broadcast로 처리가 된다.

한편 NDs access시에는 다른 thread들이 순서대로 인접한 bank들을 access하기 때문에 bank conflict가 없다.

B) Tile size를 키우면 장점은 한번 global memory에서 shared memroy로 가져온 것을 더 많이 계산하는데 쓰므로 (compute density가 높아진다), 효율이 높다.  즉 타일사이즈가 2배 일때 한 번에 메모리를 4배로 가져오는데 계산은 8배이다.  따라서 compute density는 8/4 = 2배로 된다.  단점은 shared memory의 크기가 더 늘고, 따라서 병렬도가 제한이 된다.

6.

A.  먼저 x[N/2]~x[N-1] 의 값이 0인 것을 이용하면

X[k] = FFTN {x[n]}

= Sum(n=0, N-1) x[n]*e(-j2pi*n*k/N)

= Sum(n=0, N/2-1) x[n]*e(-j2pi*n*k/2/(N/2))

= XN/2[k]

sum (n=0, n=N/2 -1) x[n]*e-j2pi*nk/2/(N/2)

= sum (n=0, N/4 -1) x[2n] e-j2pi*n2k/(N/4) + {sum (n=0, N/4 -1) x[2n] e-j2pi*n2k/(N/4)} e -j2pi*k/(N/2)

위를 실수 허수 부에 대한 FFT의 성질을 이용하여 계산하면

N/4 FFT + 2*N/4 add/sub

=0.5* N/4 log(N/4) complex mult + N/4 log(N/4) complex add + N/2 real add

-------------

F{Re x[n]} = F {0.5x[n] + 0.5 x*[n]}   * complex conjugate

= 1/2 {XN[k] + X*N[-k]} = XN[k]

-> XN[k] = XN*[-k]  complex symmetry

B. 이 문제는 약간 이상,  t와 d의 range가 다를 수가 없다.  왜냐하면 z-1로 연결이 되었기 때문이다.

아무튼 문제에 충실하게 풀면

IWL (x1) = 0, IWL(y1)=1, IWL(a1)=1, IWL(b1) = 1, IWL(d1)=2, IWL(t1)=3

coefficient a의 경우 값이 1이면, IWL=0로는 확실히 나타낼 수 없다 (0.999999밖에 안됨).

a1[0]: 1*2**(31-1) = 230

a1[1] = 0.355407*230

a1[2] = a1[0]

b1[0] = 1.66664*2**(31-1) = 1.66664*230

b1[1] = -0.75504*230

t1 = x1>>sh1 + b1[0]*d1[0]>>sh2 + b1[1]*d1[1]>>sh2;

sh1 = 3 - 0 = 3

sh2 = 3 - (1+2 + 1) = -1   참고: Mulh 함수를 사용할 경우 multiplication후 저절로 1 bit right shift되므로 integer wordlength가 1 증가한다.

y1 = a1[0]*t1>>sh3 + a1[1]*d1[0]>>sh4 + a1[2]*d1[1]>>sh4;

sh3 = IWL(y1) - IWL(a1)-IWL(t1)-1 = 1 - 1 - 3 -1 = -4   즉 4bit left shift

sh4 는 마찬가지로 하면 -3

d1[0] = t1;  -> d1[0] = t1 <<1;