//[*]--------------------------------------------------------------------------------------------------[*]
//[*]--------------------------------------------------------------------------------------------------[*]
static ssize_t store_fw_status (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
struct touch *ts = dev_get_drvdata(dev);
int err;
unsigned long val;
if ((err = strict_strtoul(buf, 10, &val))) return err;
switch(val) {
case STATUS_BOOT_MODE:
ts->fw_status |= (touch_set_mode(ts, TOUCH_BOOT_MODE) == 0) ? STATUS_BOOT_MODE : err_status(STATUS_BOOT_MODE);
if(!err_mask(ts->fw_status)) {
ts->fw_size = 0;
if(ts->fw_buf != NULL) memset(ts->fw_buf, 0x00, MAX_FW_SIZE);
else ts->fw_buf = (unsigned char *)kzalloc(MAX_FW_SIZE, GFP_KERNEL);
if(ts->fw_buf == NULL) ts->fw_status |= err_status(STATUS_NO_MEMORY);
}
break;
case STATUS_FW_CHECK:
if(ts->fw_status & STATUS_BOOT_MODE) {
ts->fw_status &= (~STATUS_FW_CHECK);
ts->fw_status |= (ts->fw_size <= MAX_FW_SIZE) ? STATUS_FW_CHECK : err_status(STATUS_FW_CHECK);
}
break;
case STATUS_FW_ERASE:
if(ts->fw_status & STATUS_BOOT_MODE) {
ts->fw_status &= (~STATUS_FW_ERASE);
ts->fw_status |= (touch_flash_erase(ts, ts->fw_size) == 0) ? STATUS_FW_ERASE : err_status(STATUS_FW_ERASE);
}
break;
case STATUS_FW_WRITE:
if(ts->fw_status & STATUS_BOOT_MODE) {
ts->fw_status &= (~STATUS_FW_WRITE);
ts->fw_status |= (touch_flash_write(ts, ts->fw_size, ts->fw_buf) == 0) ? STATUS_FW_WRITE : err_status(STATUS_FW_WRITE);
}
break;
case STATUS_FW_VERIFY:
if(ts->fw_status & STATUS_BOOT_MODE) {
ts->fw_status &= (~STATUS_FW_VERIFY);
ts->fw_status |= (touch_flash_verify(ts, ts->fw_size, ts->fw_buf) == 0) ? STATUS_FW_VERIFY : err_status(STATUS_FW_VERIFY);
}
break;
case STATUS_USER_MODE:
if(ts->fw_buf != NULL) {
kfree(ts->fw_buf); ts->fw_buf = NULL; ts->fw_size = 0;
}
ts->fw_status =
(touch_set_mode(ts, TOUCH_USER_MODE) == 0) ? STATUS_USER_MODE : (err_status(STATUS_USER_MODE) | STATUS_BOOT_MODE);
break;
default :
ts->fw_status |= err_status(STATUS_NO_COMMAND);
break;
}
return count;
}
int main(int argc, char *argv[])
{
int myid, numprocs, i, j;
int size, align_size;
// host buffer
char *s_buf, *r_buf, *s_buf1, *r_buf1;
double t_start = 0.0, t_end = 0.0, t = 0.0;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
MPI_Comm_rank(MPI_COMM_WORLD, &myid);
align_size = getpagesize();
assert(align_size <= MAX_ALIGNMENT);
#ifdef PINNED
// Get platform and device information
cl_platform_id platform_id = NULL;
cl_device_id device_id = NULL;
cl_uint ret_num_devices;
cl_uint ret_num_platforms;
cl_int ret = clGetPlatformIDs(1, &platform_id, &ret_num_platforms);
err_status(ret);
ret = clGetDeviceIDs( platform_id, CL_DEVICE_TYPE_GPU, 1,
&device_id, &ret_num_devices);
err_status(ret);
printf("%d device(s) in %d platform(s)\n",ret_num_devices, ret_num_platforms);
char cBuffer[1024];
ret = clGetDeviceInfo(device_id, CL_DEVICE_NAME, sizeof(cBuffer), &cBuffer,
NULL);
err_status(ret);
printf("CL_DEVICE_NAME: %s\n", cBuffer);
// Create an OpenCL context
cl_context context = clCreateContext (NULL,
1,
&device_id,
NULL,
NULL,
&ret);
err_status(ret);
// Create a command queue
cl_command_queue command_queue = clCreateCommandQueue (context,
device_id,
0,
&ret);
err_status(ret);
// Create memory buffers on the device
cl_mem s_mem = clCreateBuffer(context,
CL_MEM_WRITE_ONLY | CL_MEM_ALLOC_HOST_PTR,
// CL_MEM_COPY_HOST_PTR is only valid with non-NULL pointer
MYBUFSIZE,
NULL,
&ret);
err_status(ret);
cl_mem r_mem = clCreateBuffer(context,
CL_MEM_WRITE_ONLY | CL_MEM_ALLOC_HOST_PTR,
// CL_MEM_COPY_HOST_PTR is only valid with non-NULL pointer
MYBUFSIZE,
NULL,
&ret);
err_status(ret);
// pinned memory (blocked call)
s_buf1 = (char *) clEnqueueMapBuffer(command_queue,
s_mem,
CL_TRUE,
CL_MAP_WRITE,
0,
MYBUFSIZE,
0,
NULL,
NULL,
&ret);
err_status(ret);
r_buf1 = (char *) clEnqueueMapBuffer(command_queue,
r_mem,
CL_TRUE,
CL_MAP_WRITE,
0,
MYBUFSIZE,
0,
NULL,
NULL,
&ret);
err_status(ret);
#else
if (myid == 0) printf("# Using PAGEABLE host memory!\n");
s_buf1 = (char*) malloc(MYBUFSIZE);
r_buf1 = (char*) malloc(MYBUFSIZE);
#endif
s_buf =
(char *) (((unsigned long) s_buf1 + (align_size - 1)) /
align_size * align_size);
r_buf =
(char *) (((unsigned long) r_buf1 + (align_size - 1)) /
align_size * align_size);
if(numprocs != 2) {
if(myid == 0) {
fprintf(stderr, "This test requires exactly two processes\n");
}
MPI_Finalize();
return EXIT_FAILURE;
}
if(myid == 0) {
fprintf(stdout, "# %s\n", BENCHMARK);
fprintf(stdout, "%-*s%*s\n", 10, "# Size", FIELD_WIDTH,
"Bandwidth (MB/s)");
fflush(stdout);
}
/* Bandwidth test */
for(size = 1; size <= MAX_MSG_SIZE; size *= 2) {
/* touch the data */
for(i = 0; i < size; i++) {
s_buf[i] = 'a';
r_buf[i] = 'b';
}
// puts("2");
if(size > large_message_size) {
loop = loop_large;
skip = skip_large;
window_size = window_size_large;
}
if(myid == 0) {
for(i = 0; i < loop + skip; i++) {
if(i == skip) {
t_start = MPI_Wtime();
}
for(j = 0; j < window_size; j++) {
MPI_Isend(s_buf, size, MPI_CHAR, 1, 100, MPI_COMM_WORLD,
request + j);
}
MPI_Waitall(window_size, request, reqstat);
MPI_Recv(r_buf, 4, MPI_CHAR, 1, 101, MPI_COMM_WORLD,
&reqstat[0]);
}
t_end = MPI_Wtime();
// printf("%d %d\n",myid,size);
t = t_end - t_start;
}
else if(myid == 1) {
for(i = 0; i < loop + skip; i++) {
for(j = 0; j < window_size; j++) {
MPI_Irecv(r_buf, size, MPI_CHAR, 0, 100, MPI_COMM_WORLD,
request + j);
}
MPI_Waitall(window_size, request, reqstat);
MPI_Send(s_buf, 4, MPI_CHAR, 0, 101, MPI_COMM_WORLD);
}
// printf("%d %d\n",myid,size);
}
if(myid == 0) {
double tmp = size / 1e6 * loop * window_size;
fprintf(stdout, "%-*d%*.*f\n", 10, size, FIELD_WIDTH,
FLOAT_PRECISION, tmp / t);
fflush(stdout);
}
}
#ifdef PINNED
// cudaFree(s_buf1);
// cudaFree(r_buf1);
// clReleaseMemObject(s_mem);
// clReleaseMemObject(r_mem);
#else
free(s_buf1);
free(r_buf1);
#endif
MPI_Finalize();
return EXIT_SUCCESS;
}
