CUDA Intro to Parallel Programming笔记--Lesson 1 The GPU Programming Model

1.  3 traditional ways computes run faster

• Faster clocks
• More work/clock cycle　　
• More processors

2. Parallelism

• A high end Gpu contains over 3,000 arithmatic units,ALUs, that can simultanously run 3,000 arithmetic operations. GPU can have tens of thousands of parallel pieces of work all active at the same time.
• A modern GPU may be runing up to 65,000 concurrent threads. 

3. GPGPU--General purpose Programmability on the Graphics Grocessing Unit.

4.  How Are CPUs Getting Faster?

　   More transistors avaliable for computation.

5. Why don`t we keep increasing clock speed?

　　Runing a billion transistors generate an awful lot of heat,and we can`t keep all these processors cool.

6. What kind of processors are we building

　　A: Why are traditional CPU-like processors not the most energy efficient processors?

　　Q: Traditonal CPU-like processors rise up in flexibility and performance but expensive in terms of power.

　　We might choose to build simpler control structures and instead devote those transistors to supporting more computation to the data path.The way that we`re going to build that data path in the GPU is by building a large number of parallel compute units. Individually, these compute units are small,simple,and power efficient.

7.  Build a power efficient processor

　　Optimizing 

• • Minimizing Latency(execute time)
  • Throughput(tasks completed unit time, stuff/time, jobs/hour)　　

　　　　   Notes:these two goals are not necessarily aligned.　　　　　　　　

8. Latency vs Bandwidth

　　Improved latency often leads to improved througput,and vise versa.But the GP designers are really prioritizing througput.

9. Core GPU design tents

• Lots of simple compute units and trade simple control for more compute
• Explicitly(显示) parallel programming model　　
• Optimize for througput,not latency

10. GPU from the point of view of the developer

　　8 core Intel Ivy Bridge processor,has 8 cores,each core has 8-wide AVX vector operations,each core supports two simultaneously running threads.Multiply those together will get 128-way parallelism.

11. Squaring numbers using CUDA

#include <stdio.h>
__global__ void square(float *d_out,float *d_in){
    int idx = threadIdx.x;
    float f = d_in[idx];
    d_out[idx] = f * f*f;
}

int main(int argc, char **argv){
    const int ArraySize = 96;
    const int ArrayBytes = ArraySize * sizeof(float);

    //Generate the input array on the host
    float h_in[ArraySize]; 
    for(int i=0; i<96; i++){
        h_in[i] = float(i);
    }
    float h_out[ArraySize];

    //Declare GPU memory pointers
    float *d_in;
    float *d_out;

    //Allocate GPU memory
    cudaMalloc((void **) &d_in, ArrayBytes);
    cudaMalloc((void **) &d_out, ArrayBytes);

    //Transfer the array to the GPU
    cudaMemcpy(d_in,h_in,ArrayBytes,cudaMemcpyHostToDevice);

    //Launch the kernel    
    square<<< 1 , ArraySize>>>(d_out,d_in);

    //Copy back the result to the CPU
    cudaMemcpy(h_out,d_out,ArrayBytes,cudaMemcpyDeviceToHost);

    for (int i = 0; i < ArraySize; ++i){
        printf("%f", h_out[i]);
        printf(((i % 4) == 3) ? "\n": "\t");
    }

    cudaFree(d_in);
    cudaFree(d_out);
}