#include <string.h>
#include <dcmf.h>
#include <dcmf_globalcollectives.h>
#include <cuda.h>
DCMF_Protocol_t barrier_prot, control0_prot, control1_prot,
put_prot, reduce_prot;
void cb_decr(void *data) {
unsigned *val = (unsigned*)data;
(*val)--;
}
void cb_recv(void *data, const DCMF_Control_t *info, unsigned) {
memcpy((DCMF_Memregion_t*)data, info, sizeof(DCMF_Memregion_t));
}
void barrier() {
DCMF_CriticalSection_enter(0);
volatile unsigned active = 1;
DCMF_Callback_t cb = { cb_decr, (void *) &active };
DCMF_Request_t req;
DCMF_GlobalBarrier(&barrier_prot, &req, cb);
while (active)
DCMF_Messager_advance();
DCMF_CriticalSection_exit(0);
}
// kernel
__global__ void sub1(float* fx, float* fy, float* fe) {
#define BLOCK (512)
int t = threadIdx.x; // builtin
int b = blockIdx.x; // builtin
float e;
__shared__ float se[BLOCK];
__shared__ float sx[BLOCK];
__shared__ float sy[BLOCK+2];
// copy from device to processor memory
sx[t] = fx[BLOCK*b+t];
sy[t] = fy[BLOCK*b+t];
if (t<2)
sy[t+BLOCK] = fy[BLOCK*b+t+BLOCK];
__syncthreads();
// do computation
sx[t] += ( sy[t+2] + sy[t] )*.5;
e = sy[t+1] * sy[t+1];
// copy to device memory
fx[BLOCK*b+t] = sx[t];
// reduction
se[t] = e;
__syncthreads();
if (t<256) {
se[t] += se[t+256];
__syncthreads();
}
if (t<128) {
se[t] += se[t+128];
__syncthreads();
}
if (t<64) {
se[t] += se[t+64];
__syncthreads();
}
if (t<32) { // warp size
se[t] += se[t+32];
se[t] += se[t+16];
se[t] += se[t+8];
se[t] += se[t+4];
se[t] += se[t+2];
se[t] += se[t+1];
}
if (t==0)
fe[b] = se[0];
}
int main(int argc, char *argv[]) {
int n = ...;
DCMF_Messager_initialize();
{ // init barrier, put, reduce
DCMF_GlobalBarrier_Configuration_t barrier_conf =
{DCMF_DEFAULT_GLOBALBARRIER_PROTOCOL};
DCMF_Put_Configuration_t put_conf =
{DCMF_DEFAULT_PUT_PROTOCOL};
DCMF_GlobalAllreduce_Configuration_t reduce_conf =
{DCMF_TREE_GLOBALALLREDUCE_PROTOCOL};
DCMF_CriticalSection_enter(0);
DCMF_GlobalBarrier_register(&barrier_prot, &barrier_conf);
DCMF_Put_register(&put_prot, &put_conf);
DCMF_GlobalAllreduce_register(&reduce_prot, &reduce_conf);
DCMF_CriticalSection_exit(0);
}
unsigned me = DCMF_Messager_rank();
unsigned numproc = DCMF_Messager_size();
int p_left = -1, p_right = -1;
if (me > 0)
p_left = me-1;
if (me < numproc-1)
p_right = me+1;
int n_local0 = 1 + (me * (n-1)) / numproc;
int n_local1 = 1 + ((me+1) * (n-1)) / numproc;
// allocate only local part + ghost zone of the arrays x,y
float *x, *y;
x = new float[n_local1 - n_local0 + 2];
y = new float[n_local1 - n_local0 + 2];
x -= (n_local0 - 1);
y -= (n_local0 - 1);
// ghost zones
DCMF_Memregion_t memregion0, memregion1,
memregion_left, memregion_right;
size_t bytes;
DCMF_CriticalSection_enter(0);
DCMF_Memregion_create(&memregion0, &bytes,
2 * sizeof(float), &y[n_local0-1], 0);
DCMF_Memregion_create(&memregion1, &bytes,
2 * sizeof(float), &y[n_local1-1], 0);
// set memregion_left, memregion_right
DCMF_Control_Configuration_t c0_conf =
{ DCMF_DEFAULT_CONTROL_PROTOCOL, cb_recv, &memregion_right};
DCMF_Control_Configuration_t c1_conf =
{ DCMF_DEFAULT_CONTROL_PROTOCOL, cb_recv, &memregion_left};
DCMF_Control_register(&control0_prot, &c0_conf);
DCMF_Control_register(&control1_prot, &c1_conf);
barrier();
if (p_left != -1)
DCMF_Control(&control0_prot, DCMF_MATCH_CONSISTENCY,
p_left, (DCMF_Control_t*) &memregion0);
if (p_right != -1)
DCMF_Control(&control1_prot, DCMF_MATCH_CONSISTENCY,
p_right, (DCMF_Control_t*) &memregion1);
barrier();
DCMF_CriticalSection_exit(0);
... // fill x, y
{ // fill ghost zone
volatile unsigned active0 = 1, active1 = 1;
DCMF_Callback_t cb0 = { cb_decr, (void*)&active0 },
cb1 = { cb_decr, (void*)&active1 };
DCMF_Request_t req0, req1;
DCMF_CriticalSection_enter(0);
if (p_left != -1)
DCMF_Put(&put_prot, &req0, cb0, DCMF_SEQUENTIAL_CONSISTENCY,
p_left, sizeof(float), &memregion0, &memregion_left,
sizeof(float), sizeof(float));
if (p_right != -1)
DCMF_Put(&put_prot, &req1, cb1, DCMF_SEQUENTIAL_CONSISTENCY,
p_right, sizeof(float), &memregion1, &memregion_right,
sizeof(float), 0);
if (p_left != -1)
while (active0)
DCMF_Messager_advance();
if (p_right != -1)
while (active1)
DCMF_Messager_advance();
DCMF_CriticalSection_exit(0);
barrier();
}
// allocate GPU memory
float *fx, *fy, *fe;
cudaMalloc((void**)&fx, (n_local1-n_local0+2) * sizeof(float));
cudaMalloc((void**)&fy, (n_local1-n_local0+2) * sizeof(float));
cudaMalloc((void**)&fe, (n_local1-n_local0+2)/BLOCK * sizeof(float));
float *de = new float[(n_local1-n_local0+2)/BLOCK];
// copy to GPU memory
cudaMemcpy(fx+1, &x[n_local0],
(n_local1-n_local0) * sizeof(float), cudaMemcpyHostToDevice);
cudaMemcpy(fy, &y[n_local0-1],
(n_local1-n_local0+2) * sizeof(float), cudaMemcpyHostToDevice);
dim3 dimBlock(BLOCK, 1, 1);
dim3 dimGrid((n_local1-n_local0+2)/BLOCK, 1, 1);
float e = 0;
// call GPU
sub1<<<dimGrid, dimBlock>>>(fx, fy, fe);
// copy to host memory
cudaMemcpy(fx+1, &x[n_local0], (n_local1-n_local0) * sizeof(float),
cudaMemcpyDeviceToHost);
cudaMemcpy(fe, &de[n_local0-1], (n_local1-n_local0+2)/BLOCK * sizeof(float),
cudaMemcpyDeviceToHost);
// release GPU memory
cudaFree(fe);
cudaFree(fy);
cudaFree(fx);
float e_local = 0;
for (int i=0; i<(n_local1-n_local0+2)/BLOCK; ++i)
e_local += de[i];
e += e_local;
delete[] de;
{ // reduction
DCMF_CriticalSection_enter(0);
float e_local = e;
volatile unsigned active = 1;
DCMF_Callback_t cb = { cb_decr, (void*)&active };
DCMF_Request_t req;
DCMF_GlobalAllreduce(&reduce_prot, &req, cb,
DCMF_MATCH_CONSISTENCY, -1,
(char*)&e_local, (char*)&e, 1, DCMF_FLOAT, DCMF_SUM);
while (active)
DCMF_Messager_advance();
DCMF_CriticalSection_exit(0);
}
... // output x, e
barrier();
DCMF_Memregion_destroy(&memregion0);
DCMF_Memregion_destroy(&memregion1);
x += (n_local0 - 1);
y += (n_local0 - 1);
delete[] x, y;
DCMF_Messager_finalize();
return 0;
}
|