#include <stdio.h>

#include <math.h>

#define real float

#define P 2

#define M 2

#define D 2

real u[3][3];

real v[3][3];

void printWeight(){

    for(int i=1;i<3;i++){

        for(int j=0;j<3;j++){

            printf("%f %f

",u[j][i],v[j][i]);

        }

    }

}

int main(){

    bool go= true;

    //training set

    real x[D+2];

    real t[3];

    t[1] = -1;    t[2] = 1;

    real z_sum[P+1]; real z[P+1];

    real o_sum[M+1]; real o[M+1];

    //initialize u, v

    u[0][1] = 0.3;

    u[1][1] = 0.4;

    u[2][1] = 0.2;

    u[0][2] = -0.1;

    u[1][2] = -0.5;

    u[2][2] = 0.1;

    v[0][1] = 0.1;

    v[1][1] = -0.2;

    v[2][1] = 0.4;

    v[0][2] = 0.2;

    v[1][2] = 0.3;

    v[2][2] = -0.1;

    //bias

    x[0] = 1.0;

    z[0] = 1.0;

    //printWeight();

x[1] = 0.7; x[2] = 0.2;

    //do{

    //for(per sample x){

    //set x, t

    z_sum[0] = 0;z_sum[1] = 0;z_sum[2] = 0;

    for(int j=1;j<=P;j++){

        for(int i=0;i<=D;i++){

            z_sum[j] += x[i]*u[i][j];

        }

        //z[j] = exp(z_sum[j])/(1 + exp(z_sum[j])); //sigmoid

        z[j] = 2/(1 + exp(-z_sum[j]))-1; //sigmoid

    }

    o_sum[0] = 0;o_sum[1] = 0;o_sum[2] = 0;

    for(int k=1;k<=M;k++){

        for(int j=0;j<=P;j++){

            o_sum[k] += z[j]*v[j][k];

        }

        o[k] = 2/(1 + exp(-o_sum[k]))-1; //sigmoid

    }

    printf("FF finished o[1] : %f o[2] : %f

",o[1],o[2]);

    //delta v

    //delta u

    //}

    //}while(go);

}

//Ref : https://youtu.be/Ed_h2km0liI

#include <stdio.h>

#define SIZE 1024

//1. parallelize this function

//3. modify function call as gpu

__global__ void VectorAdd(int *a, int *b, int *c, int n){

    int i = threadIdx.x;

    //for( i=0;i<n;i++){

    //    c[i] = a[i] + b[i];

    //}

    if(i < n)

        c[i] = a[i] + b[i];

}

//2. allocate memory on GPU memory

//2.1) Data copied from CPU to GPu

//2.2) Launch VectorAdd kernel on the GPU

//2.3) Resulting data copied from GPU to CPU

int main(){

    int *a, *b, *c, i;

    int *d_a, *d_b, *d_c; // device

    a = (int*)malloc(sizeof(int)*SIZE);

    b = (int*)malloc(sizeof(int)*SIZE);

    c = (int*)malloc(sizeof(int)*SIZE);

    //gpu side memory

    cudaMalloc(&d_a, SIZE*sizeof(int));

    cudaMalloc(&d_b, SIZE*sizeof(int));

    cudaMalloc(&d_c, SIZE*sizeof(int));

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

            a[i] = i;

            b[i] = i;

            c[i] = 0;

    }

    cudaMemcpy(d_a,a,SIZE*sizeof(int),cudaMemcpyHostToDevice); // => 2.1

    cudaMemcpy(d_b,b,SIZE*sizeof(int),cudaMemcpyHostToDevice); // => 2.1

    cudaMemcpy(d_c,c,SIZE*sizeof(int),cudaMemcpyHostToDevice); // => 2.1

    VectorAdd<<<1, SIZE>>>(d_a, d_b, d_c, SIZE);//1 block, SIZE threads => 2.2

    cudaMemcpy(c,d_c,SIZE*sizeof(int),cudaMemcpyDeviceToHost); // => 2.3

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

        printf("c[%d] = %d

",i,c[i]);

    }

    free(a);

    free(b);

    free(c);

    cudaFree(d_a);

    cudaFree(d_b);

    cudaFree(d_c);

    return 0;

}

1) 완전탐색 재귀함수로 문제해결

2) Parameters caching

* 위 방식은 Parameter 의 구간, 개수를 어떻게 든 줄여 제한 메모리에 넣으면 된다.

cons1. 메모리 제한내 다 들어오지 않을 수도 있고 겹치지 않으면 속도도 줄지 않는다.

cons2. sum 같은 중간에 알아야하는 것을 계속 기억해야한다.

음;;