C++ AMP

#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <iostream>
#include <ctime>
#include <cmath>
#include <GL\freeglut.h>
#include <omp.h>
#include <string>

const int N = 1024;
int button = 2;
bool cuda_sw = false;
float *CU_POSR, *CU_POSX, *CU_POSY, *CU_POSR_X, *CU_POSR_Y;

//for FPS
float fps;
int frames = 0;
float time_f;
float timebase = 0;
char text[5 + 10] = "FPS: ";
char res[5 + 10] = "FPS: ";
char buff[10];

float POSX[N];
float POSY[N];
float POSR[N + N];
float AX_M[N];
float AY_M[N];


void initialization()
{
    glClearColor(0, 0, 0, 1);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(-1000, 1000, -1000, 1000);
}


void display()
{
    glClear(GL_COLOR_BUFFER_BIT);
    glPushMatrix();
    glBegin(GL_POINTS);

    for (int draw = 0; draw < N; draw++) {
        glColor3f(1, 1, 1);
        glVertex2f(POSX[draw] += POSR[draw], POSY[draw] += POSR[draw + N]);
    }

    glEnd();

    glPopMatrix();
    glutSwapBuffers();

    frames++;
    time_f = glutGet(GLUT_ELAPSED_TIME);
    if (time_f - timebase >= 1000)
    {
        fps = frames*1000.0 / (time_f - timebase);
        timebase = time_f;
        frames = 0;
        strcpy(text, res);
        glutSetWindowTitle(strcat(text, itoa(fps, buff, 10)));
    }
}


void OMP_Math()
{
    float den;
#pragma omp parallel for private(den, AX_M, AY_M)
    for (int first = 0; first < N; first++) {
        AX_M[first] = 0; AY_M[first] = 0;
        for (int next = 0; next < N; next++) {
            if ((first != next) && ((POSX[next] != POSX[first]) || (POSY[next] != POSY[first]))) {
                den = 100000 * sqrt((POSX[next] - POSX[first])*(POSX[next] - POSX[first]) + (POSY[next] - POSY[first])*(POSY[next] - POSY[first]));
                AX_M[first] += (POSX[next] - POSX[first]) / den;
                AY_M[first] += (POSY[next] - POSY[first]) / den;
            }
        }
        POSR[first] += AX_M[first];
        POSR[first + N] += AY_M[first];
    }
}


__global__ void addKernel(float *POSX, float *POSY, float *POSR_X, float *POSR_Y, float *POSR)
{
    int first = threadIdx.x;
    float  den;
    POSR_X[first] = 0; POSR_Y[first] = 0;
    for (int next = 0; next < N; next++) {
        if ((first != next) && ((POSX[next] != POSX[first]) || (POSY[next] != POSY[first]))) {
            den = 100000 * sqrt((POSX[next] - POSX[first])*(POSX[next] - POSX[first]) + (POSY[next] - POSY[first])*(POSY[next] - POSY[first]));
            POSR_X[first] += (POSX[next] - POSX[first]) / den;
            POSR_Y[first] += (POSY[next] - POSY[first]) / den;
        }
    }
    POSR[first] += POSR_X[first];
    POSR[first + N] += POSR_Y[first];
}

void GPU_Math()
{
    cudaMalloc((void**)&CU_POSX, N * sizeof(int));
    cudaMalloc((void**)&CU_POSY, N * sizeof(int));
    cudaMalloc((void**)&CU_POSR_X, N * sizeof(int));
    cudaMalloc((void**)&CU_POSR_Y, N * sizeof(int));
    cudaMalloc((void**)&CU_POSR, 2 * N * sizeof(int));

    cudaMemcpy(CU_POSX, POSX, N * sizeof(int), cudaMemcpyKind::cudaMemcpyHostToDevice);
    cudaMemcpy(CU_POSY, POSY, N * sizeof(int), cudaMemcpyKind::cudaMemcpyHostToDevice);
    cudaMemcpy(CU_POSR_X, AX_M, N * sizeof(int), cudaMemcpyKind::cudaMemcpyHostToDevice);
    cudaMemcpy(CU_POSR_Y, AY_M, N * sizeof(int), cudaMemcpyKind::cudaMemcpyHostToDevice);
    cudaMemcpy(CU_POSR, POSR, 2 * N * sizeof(int), cudaMemcpyKind::cudaMemcpyHostToDevice);

    addKernel <<< 1, N >> >(CU_POSX, CU_POSY, CU_POSR_X, CU_POSR_Y, CU_POSR);

    cudaMemcpy(AX_M, CU_POSR_X, N * sizeof(int), cudaMemcpyKind::cudaMemcpyDeviceToHost);
    cudaMemcpy(AY_M, CU_POSR_Y, N * sizeof(int), cudaMemcpyKind::cudaMemcpyDeviceToHost);
    cudaMemcpy(POSX, CU_POSX, N * sizeof(int), cudaMemcpyKind::cudaMemcpyDeviceToHost);
    cudaMemcpy(POSY, CU_POSY, N * sizeof(int), cudaMemcpyKind::cudaMemcpyDeviceToHost);
    cudaMemcpy(POSR, CU_POSR, 2 * N * sizeof(int), cudaMemcpyKind::cudaMemcpyDeviceToHost);

    cudaFree(CU_POSX);
    cudaFree(CU_POSY);
    cudaFree(CU_POSR_X);
    cudaFree(CU_POSR_Y);
    cudaFree(CU_POSR);
}

void Timer(int)
{
    if (button == 1)
        GPU_Math();

    else
        OMP_Math();

    display();
    glutTimerFunc(0, Timer, 0);
}


void characters()
{
    for (int i = 0; i < N; i++) {
        POSX[i] = rand() % 1000 - 500;
        POSY[i] = rand() % 1000 - 500;

        for (int j = 0; j < i; j++) {
            if ((i != j) && (POSX[i] == POSX[j]) && (POSY[i] == POSY[j]))
                i--;
        }
    }
}


void keyboard(unsigned char key, int x, int y)
{
    switch (key)
    {
    case '1': button = 1;
        break;
    case '2': button = 2;
        break;
    }
}


int main(int argc, char **argv)
{
    srand(time(0));
    setlocale(LC_ALL, "russian");

    characters();

    std::cout << "[1] -- Select GPU\n";
    std::cout << "[2] -- Select CPU\n";

    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
    glutInitWindowPosition(100, 100);
    glutInitWindowSize(1000, 1000);
    glutCreateWindow("");
    glutDisplayFunc(display);

    glutTimerFunc(0, Timer, 0);
    glutKeyboardFunc(keyboard);
    initialization();
    glutMainLoop();

    return 0;
}