Hoit Studio

#include "GPU_MLP.cuh"

using namespace std; 

__global__ void kernel(int **d_ptr, int width){

    d_ptr[threadIdx.y][threadIdx.x] = 3;

}

__global__ void SetDeviceMem(int *src, int **ptr, int width){

    ptr[threadIdx.x] = src + width * threadIdx.x;

}

GPU_MLP::GPU_MLP(int width, int height){

    nSize = sizeof(int) * width * height;

    _width = width;

    _height = height;

    d_test = NULL;

    d_ptr = NULL;

    h_test = NULL;

    h_ptr = NULL;

    HostMemAlloc();

    DeviceMemAlloc();

    cudaMemcpy(d_test, h_test, nSize, cudaMemcpyHostToDevice);

}

void GPU_MLP::HostMemAlloc(){

    h_test = new int[_width * _height];

    h_ptr = new int*[_height]; 

    for(int i = 0; i < _height; ++i)

        h_ptr[i] = h_test + _width * i;

    memset(h_test, 0, nSize);

}

void GPU_MLP::DeviceMemAlloc(){

    cudaMalloc<int>(&d_test, nSize);

    cudaMalloc<int*>(&d_ptr, sizeof(int*) * _height);

    SetDeviceMem<<<1, _height>>>(d_test, d_ptr, _width);

}

void GPU_MLP::Fuction(int value){

    dim3 block(_width, _height);

    kernel<<<1, block>>>(d_ptr, _width);

    cudaMemcpy(h_test, d_test, nSize, cudaMemcpyDeviceToHost);

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

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

            cout << h_ptr[i][j] << " ";

        }

        cout << endl;

    }

}

GPU_MLP::~GPU_MLP(){

    delete[] h_test;

    delete[] h_ptr;

    cudaFree(d_test);

    cudaFree(d_ptr);

    cudaDeviceReset();

}

CUDA 파일이름.cuh

#include <iostream>

#include <cuda_runtime.h>

#include <device_launch_parameters.h>

__global__ void kernel(int **d_ptr, int width);

__global__ void SetDeviceMem(int *src, int **ptr, int width);

class GPU_MLP{

public:

    int *d_test;

    int **d_ptr;

    int *h_test;

    int **h_ptr;

    int _width;

    int _height;

    size_t nSize;

    GPU_MLP(int width, int height);

    void HostMemAlloc();

    void DeviceMemAlloc();

    void Fuction(int value);

    ~GPU_MLP();

};

main.cpp
#include <iostream>

#include <opencv2\opencv.hpp>

#include "GPU_MLP.cuh"

#include <Windows.h>

using namespace std;

using namespace cv;

int main(int argv, char **argc){

    GPU_MLP test(10, 10);

    test.Fuction(3);

    system("pause");

    return 0;

}

/*****************************************************************************
*  ------------------------------- dlist.h --------------------------------  *
*****************************************************************************/
#ifndef DLIST_H
#define DLIST_H
#include <stdlib.h>
/*****************************************************************************
*  Define a structure for doubly-linked list elements.                       *
*****************************************************************************/
typedef struct DListElmt_ {
 void               *data;
 struct DListElmt_  *prev;
 struct DListElmt_  *next;
} DListElmt;
/*****************************************************************************
*  Define a structure for doubly-linked lists.                               *
*****************************************************************************/
typedef struct DList_ {
 int                size;
 int                (*match)(const void *key1, const void *key2);
 void               (*destroy)(void *data);
 DListElmt          *head;
 DListElmt          *tail;
} DList;
/*****************************************************************************
*  --------------------------- Public Interface ---------------------------  *
*****************************************************************************/
void dlist_init(DList *list, void (*destroy)(void *data));
void dlist_destroy(DList *list);
int dlist_ins_next(DList *list, DListElmt *element, const void *data);
int dlist_ins_prev(DList *list, DListElmt *element, const void *data);
int dlist_remove(DList *list, DListElmt *element, void **data);
#define dlist_size(list) ((list)->size)
#define dlist_head(list) ((list)->head)
#define dlist_tail(list) ((list)->tail)
#define dlist_is_head(element) ((element)->prev == NULL ? 1 : 0)
#define dlist_is_tail(element) ((element)->next == NULL ? 1 : 0)
#define dlist_data(element) ((element)->data)
#define dlist_next(element) ((element)->next)
#define dlist_prev(element) ((element)->prev)
#endif

#include

 <iostream>

using namespace std;

class Parent

{

        int x;

public:

        virtual void foo() { cout <<" Parent::foo" << endl;}

};

class Child : public Parent

{

        int y;

public:

        virtual void foo() { cout << "child::foo"<< endl; }  

        // 가상함수는inline 될수없다. inline : 컴파일시수행.  가상함수: 실행시간수행

};

int main()

{

        Parent p;

        cout << sizeof(p) << endl;   // p 는4바이트가아니고8바이트(가상함수테이블포인터추가)

        Child c;

        cout<< sizeof(c) << endl;   // x,y까지8바이트+ 가상함수테이블포인터4바이트= 12바이트

        Parent* pc = &c;

        pc->foo();    

      // (*pc)[0]()의기계어코드를만들어낸다.이게 포인트다. 이름을 보지 않고 배열의 인덱스로 함수를 

      // 찾아간다. 이걸 기억해두고 아래 문제를 생각한다. 결국 이 코드는

      // 가상함수테이블의첫번째공간으로..어디로 갈지 실행시간에(vptr을 보고) 결정된다

}

class A

{

        int x;

public:

        virtual void foo() { cout << "A::foo" << endl; }

};

class B       // A와상속관계가아님

{

        int y;

public:

        virtual void goo() { cout << "B::goo" << endl; }

};

int main()

{

        A a;

        B* p = (B*)&a;

        p->goo();   // 둘다가상함수가아니라면B:goo() 가실행된다.

}

// foo와goo 가둘다가상함수라면foo()가호출.

// (코드에서타입은B* 이지만&a가대입되어a의주소를가진다.따라서가상함수테이블도A의그것으로가진다.

// 런타임시간에p->goo 는B의goo 가있는줄알고가상함수테이블을따라가서(첫번째로간다) 그곳을참조하는데가보니까

//  A::foo 가있어서호출해버린다-_-.. 배열인덱스처럼따라간다.)

// foo 가 가상이고 goo가 가상이 아니라면 goo()가호출. A는 vptr이 있지만 B는 vptr이 없다. 그래서 A를 대입해도 B는 테이블을 안만든다. 그래서 그냥 goo로..

// goo 가 가상이 아니고 goo가 가상이라면 에러.(쓰레기값을참조한다) A 함수에는 vptr이 없다고!

class A

{

public:

        virtual void foo() { cout << "A::foo" << endl; }

};

class B : public A

{

public :

        virtual void foo() { cout << " B:: foo " << endl; }

};

void hoo(A* p, A& r, A o)

{

        p->foo();     // B::foo

        r.foo();      // B::foo

        o.foo();  // 값으로전달받는다. A::foo

}

int main()

{

        B b;

        hoo(&b,b,b);

}

클래스에 가상 함수가 포함되면 클래스 멤버에 vptr이라는 포인터가 추가된다. 코드에는 나타나지 않고 디버그중에 조사식으로 확

인할 수 있다. vptr은 해당 클래스의 가상함수 테이블의 주소를 가지고 있다. 해당 클래스의 virtual 선언에 따라 클래스가 실행해야

할 가상함수의 함수포인터가 배열을 이루고 있음을 확인할 수 있다. 이것을 가상 함수 테이블이라 한다.