static int parse_client_line(const int client_socket, char *msg)
{
char *token;
/* On récupère le premier mot, s'il est vide, on retourne direct */
if (!(token = strtok(msg, " ")))
return MSG_OK;
/*****************************************************************************
* CMD_QUIT
****************************************************************************/
if (!strcmp(CMD_QUIT, token))
{
send_ok(client_socket, DETAIL_RET_QUIT);
return MSG_QUIT;
}
/*****************************************************************************
* CMD_CREATE_PROCESS
****************************************************************************/
else if (!strcmp(CMD_CREATE_PROCESS, token))
{
char *args[MAX_ARGS];
char **pc = args;
/* On récup le nom du prog */
if (!(token = strtok(NULL, " ")))
{
send_failure(client_socket, DETAIL_RET_CREATE_PROCESS_SYNTAX);
return MSG_ERR;
}
/* strtok renvoie un buffer static, on le copie */
/* *pc = args[0] = nom du programme */
if (!(*pc++ = strdup(token)))
{
perror("strdup");
return MSG_ERR;
}
/* La suite devient optionelle, c'est les arguments */
while ((token = strtok(NULL, " ")))
{
if ((*pc++ = strdup(token)) == NULL)
{
perror("strdup");
return MSG_ERR;
}
}
*pc = NULL; /* Fin des arguments */
/* On crée le processus */
pid_t proc = create_process(args[0], args);
/* Le processus n'a pas pu être créé */
if (proc == -1) {
send_failure(client_socket, DETAIL_RET_CREATE_PROCESS_ERROR);
return MSG_ERR;
}
send_ok(client_socket, itoa(proc));
return MSG_OK;
}
/*****************************************************************************
* CMD_DESTROY_PROCESS
****************************************************************************/
else if (!strcmp(CMD_DESTROY_PROCESS, token))
{
if ((token = strtok(NULL, " ")) == NULL)
{
send_failure(client_socket, DETAIL_RET_DESTROY_PROCESS_SYNTAX);
return MSG_ERR;
}
pid_t process_to_kill = atoi(token);
if (!process_exists(process_to_kill))
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_PROCESS);
return MSG_ERR;
}
destroy_process(process_to_kill);
send_ok(client_socket, NULL);
return MSG_OK;
}
/*****************************************************************************
* CMD_SEND_INPUT
****************************************************************************/
else if (!strcmp(CMD_SEND_INPUT, token))
{
char buffer[MESSAGE_BUFFER_SIZE];
buffer[0] = '\0';
/* On récup le PID */
if ((token = strtok(NULL, " ")) == NULL)
{
send_failure(client_socket, DETAIL_RET_SEND_INPUT_SYNTAX);
return MSG_ERR;
}
/* Il existe ? */
pid_t send_to_process = atoi(token);
if (!process_exists(send_to_process))
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_PROCESS);
return MSG_ERR;
}
/* Il est déjà terminé ? */
if (get_return_code(send_to_process) != PROCESS_NOT_TERMINATED)
{
send_failure(client_socket, DETAIL_RET_PROCESS_TERMINATED);
return MSG_ERR;
}
/* Son stdin est ouvert ? */
if (!input_open(send_to_process))
{
send_failure(client_socket, DETAIL_RET_INPUT_CLOSE);
return MSG_ERR;
}
/* On récup' le message à envoyer */
/* TODO: Prendre la chaîne telle qu'elle, sans splitter puis merger avec un espace */
while ((token = strtok(NULL, " ")))
{
strcat(buffer, token);
strcat(buffer, " ");
}
/* Si le message est vide, erreur ! */
if (strlen(buffer) == 0)
{
send_failure(client_socket, DETAIL_RET_SEND_INPUT_SYNTAX);
return MSG_ERR;
}
/* Sinon on envoie ! */
send_input(send_to_process, buffer);
send_ok(client_socket, NULL);
return MSG_OK;
}
/*****************************************************************************
* CMD_CLOSE_INPUT
****************************************************************************/
else if (!strcmp(CMD_CLOSE_INPUT, token))
{
if ((token = strtok(NULL, " ")) == NULL)
{
send_failure(client_socket, DETAIL_RET_CLOSE_INPUT_SYNTAX);
return MSG_ERR;
}
pid_t process_to_close_input = atoi(token);
if (!process_exists(process_to_close_input))
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_PROCESS);
return MSG_ERR;
}
close_input(process_to_close_input);
send_ok(client_socket, NULL);
return MSG_OK;
}
/*****************************************************************************
* CMD_GET_OUTPUT
****************************************************************************/
else if (!strcmp(CMD_GET_OUTPUT, token))
{
if ((token = strtok(NULL, " ")) == NULL)
{
send_failure(client_socket, DETAIL_RET_GET_OUTPUT_SYNTAX);
return MSG_ERR;
}
pid_t process_to_get_output = atoi(token);
if (!process_exists(process_to_get_output))
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_PROCESS);
return MSG_ERR;
}
get_output(client_socket, process_to_get_output);
send_ok(client_socket, NULL);
return MSG_OK;
}
/*****************************************************************************
* CMD_GET_ERROR
****************************************************************************/
else if (!strcmp(CMD_GET_ERROR, token))
{
if ((token = strtok(NULL, " ")) == NULL)
{
send_failure(client_socket, DETAIL_RET_GET_ERROR_SYNTAX);
return MSG_ERR;
}
pid_t process_to_get_error = atoi(token);
if (!process_exists(process_to_get_error))
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_PROCESS);
return MSG_ERR;
}
get_error(client_socket, process_to_get_error);
send_ok(client_socket, NULL);
return MSG_OK;
}
/*****************************************************************************
* CMD_GET_RETURN_CODE
****************************************************************************/
else if (!strcmp(CMD_GET_RETURN_CODE, token))
{
if ((token = strtok(NULL, " ")) == NULL)
{
send_failure(client_socket, DETAIL_RET_GET_RETURN_CODE_SYNTAX);
return MSG_ERR;
}
pid_t process_to_get_ret = atoi(token);
if (!process_exists(process_to_get_ret))
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_PROCESS);
return MSG_ERR;
}
int ret = get_return_code(process_to_get_ret);
if (ret == PROCESS_NOT_TERMINATED)
{
send_failure(client_socket, DETAIL_RET_GET_RETURN_CODE_ERROR);
return MSG_ERR;
}
send_ok(client_socket, itoa(ret));
return MSG_OK;
}
/*****************************************************************************
* CMD_LIST_PROCESS
****************************************************************************/
else if (!strcmp(CMD_LIST_PROCESS, token))
{
list_process(client_socket);
send_ok(client_socket, NULL);
return MSG_OK;
}
/*****************************************************************************
* CMD_GET_HELP
****************************************************************************/
else if (!strcmp(CMD_GET_HELP, token))
{
send_basic(client_socket, help, strlen(help));
return MSG_OK;
}
/*****************************************************************************
* COMMANDE INCONNUE
****************************************************************************/
else
{
send_failure(client_socket, DETAIL_RET_UNKNOWN_COMMAND);
return MSG_UNKNOWN_COMMAND;
}
}
int main(int argc, char** argv)
{
cl_platform_id pf[MAX_PLATFORMS];
cl_uint nb_platforms = 0;
cl_int err; // error code returned from api calls
cl_device_type device_type = CL_DEVICE_TYPE_ALL;
// Filter args
//
argv++;
while (argc > 1) {
if(!strcmp(*argv, "-g") || !strcmp(*argv, "--gpu-only")) {
if(device_type != CL_DEVICE_TYPE_ALL)
error("--gpu-only and --cpu-only can not be specified at the same time\n");
device_type = CL_DEVICE_TYPE_GPU;
} else if(!strcmp(*argv, "-c") || !strcmp(*argv, "--cpu-only")) {
if(device_type != CL_DEVICE_TYPE_ALL)
error("--gpu-only and --cpu-only can not be specified at the same time\n");
device_type = CL_DEVICE_TYPE_CPU;
} else if(!strcmp(*argv, "-s") || !strcmp(*argv, "--size")) {
unsigned i;
int r;
char c;
r = sscanf(argv[1], "%u%[mMkK]", &SIZE, &c);
if (r == 2) {
if (c == 'k' || c == 'K')
SIZE *= 1024;
else if (c == 'm' || c == 'M')
SIZE *= 1024 * 1024;
}
argc--; argv++;
} else
break;
argc--; argv++;
}
if(argc > 1)
TILE = atoi(*argv);
// Get list of OpenCL platforms detected
//
err = clGetPlatformIDs(3, pf, &nb_platforms);
check(err, "Failed to get platform IDs");
printf("%d OpenCL platforms detected\n", nb_platforms);
// For each platform do
//
for (cl_int p = 0; p < nb_platforms; p++) {
cl_uint num;
int platform_valid = 1;
char name[1024], vendor[1024];
cl_device_id devices[MAX_DEVICES];
cl_uint nb_devices = 0;
cl_context context; // compute context
cl_program program; // compute program
cl_kernel kernel;
err = clGetPlatformInfo(pf[p], CL_PLATFORM_NAME, 1024, name, NULL);
check(err, "Failed to get Platform Info");
err = clGetPlatformInfo(pf[p], CL_PLATFORM_VENDOR, 1024, vendor, NULL);
check(err, "Failed to get Platform Info");
printf("Platform %d: %s - %s\n", p, name, vendor);
// Get list of devices
//
err = clGetDeviceIDs(pf[p], device_type, MAX_DEVICES, devices, &nb_devices);
printf("nb devices = %d\n", nb_devices);
if(nb_devices == 0)
continue;
// Create compute context with "device_type" devices
//
context = clCreateContext (0, nb_devices, devices, NULL, NULL, &err);
check(err, "Failed to create compute context");
// Load program source into memory
//
const char *opencl_prog;
opencl_prog = file_load(KERNEL_FILE);
// Attach program source to context
//
program = clCreateProgramWithSource(context, 1, &opencl_prog, NULL, &err);
check(err, "Failed to create program");
// Compile program
//
{
char flags[1024];
sprintf (flags,
"-cl-mad-enable -cl-fast-relaxed-math -DSIZE=%d -DTILE=%d -DTYPE=%s",
SIZE, TILE, "float");
err = clBuildProgram (program, 0, NULL, flags, NULL, NULL);
if(err != CL_SUCCESS) {
size_t len;
// Display compiler log
//
clGetProgramBuildInfo(program, devices[0], CL_PROGRAM_BUILD_LOG, 0, NULL, &len);
{
char buffer[len+1];
fprintf(stderr, "--- Compiler log ---\n");
clGetProgramBuildInfo(program, devices[0], CL_PROGRAM_BUILD_LOG, sizeof(buffer), buffer, NULL);
fprintf(stderr, "%s\n", buffer);
fprintf(stderr, "--------------------\n");
}
if(err != CL_SUCCESS)
error("Failed to build program!\n");
}
}
// Create the compute kernel in the program we wish to run
//
kernel = clCreateKernel(program, KERNEL_NAME, &err);
check(err, "Failed to create compute kernel");
// Allocate and initialize input data
//
alloc_buffers_and_user_data(context);
// Iterate over devices
//
for(cl_int dev = 0; dev < nb_devices; dev++) {
cl_command_queue queue;
char name[1024];
cl_device_type dtype;
err = clGetDeviceInfo(devices[dev], CL_DEVICE_NAME, 1024, name, NULL);
check(err, "Cannot get type of device");
err = clGetDeviceInfo(devices[dev], CL_DEVICE_TYPE, sizeof(cl_device_type), &dtype, NULL);
check(err, "Cannot get type of device");
printf("\tDevice %d : %s [%s]\n", dev, (dtype == CL_DEVICE_TYPE_GPU) ? "GPU" : "CPU", name);
// Create a command queue
//
queue = clCreateCommandQueue(context, devices[dev], CL_QUEUE_PROFILING_ENABLE, &err);
check(err,"Failed to create command queue");
// Write our data set into device buffer
//
send_input(queue);
// Execute kernel
//
{
cl_event prof_event;
cl_ulong start, end;
struct timeval t1,t2;
double timeInMicroseconds;
size_t global[1] = { SIZE }; // global domain size for our calculation
size_t local[1] = { TILE }; // local domain size for our calculation
printf("\t%d Threads in workgroups of %d\n", global[0], local[0]);
// Set kernel arguments
//
err = 0;
err = clSetKernelArg(kernel, 0, sizeof(cl_mem), &input_buffer);
err |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &output_buffer);
err |= clSetKernelArg(kernel, 2, sizeof(float), &factor);
check(err, "Failed to set kernel arguments");
gettimeofday (&t1, NULL);
for (unsigned iter = 0; iter < ITERATIONS; iter++) {
err = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, global, local,
0, NULL, &prof_event);
check(err, "Failed to execute kernel");
}
// Wait for the command commands to get serviced before reading back results
//
clFinish(queue);
gettimeofday (&t2,NULL);
// Check performance
//
timeInMicroseconds = (double)TIME_DIFF(t1, t2) / ITERATIONS;
printf("\tComputation performed in %lf µs over device #%d\n",
timeInMicroseconds,
dev);
clReleaseEvent(prof_event);
}
// Read back the results from the device to verify the output
//
retrieve_output(queue);
// Validate computation
//
check_output_data();
clReleaseCommandQueue(queue);
}
// Cleanup
//
free_buffers_and_user_data();
clReleaseKernel(kernel);
clReleaseProgram(program);
clReleaseContext(context);
}
return 0;
}
MODULE wait_for_socket_input (THREAD *thread)
{
tcb = thread-> tcb; /* Point to thread's context */
send_input (&sockq, 0, tcb-> handle, 0);
}
bool VDAgent::handle_mouse_event(VDAgentMouseState* state)
{
DisplayMode* mode = NULL;
DWORD mouse_move = 0;
DWORD buttons_change = 0;
DWORD mouse_wheel = 0;
bool ret = true;
ASSERT(_desktop_layout);
_desktop_layout->lock();
if (state->display_id < _desktop_layout->get_display_count()) {
mode = _desktop_layout->get_display(state->display_id);
}
if (!mode || !mode->get_attached()) {
_desktop_layout->unlock();
return true;
}
ZeroMemory(&_input, sizeof(INPUT));
_input.type = INPUT_MOUSE;
if (state->x != _mouse_x || state->y != _mouse_y) {
_mouse_x = state->x;
_mouse_y = state->y;
mouse_move = MOUSEEVENTF_MOVE;
_input.mi.dx = (mode->get_pos_x() + _mouse_x) * 0xffff /
_desktop_layout->get_total_width();
_input.mi.dy = (mode->get_pos_y() + _mouse_y) * 0xffff /
_desktop_layout->get_total_height();
}
if (state->buttons != _buttons_state) {
buttons_change = get_buttons_change(_buttons_state, state->buttons, VD_AGENT_LBUTTON_MASK,
MOUSEEVENTF_LEFTDOWN, MOUSEEVENTF_LEFTUP) |
get_buttons_change(_buttons_state, state->buttons, VD_AGENT_MBUTTON_MASK,
MOUSEEVENTF_MIDDLEDOWN, MOUSEEVENTF_MIDDLEUP) |
get_buttons_change(_buttons_state, state->buttons, VD_AGENT_RBUTTON_MASK,
MOUSEEVENTF_RIGHTDOWN, MOUSEEVENTF_RIGHTUP);
mouse_wheel = get_buttons_change(_buttons_state, state->buttons,
VD_AGENT_UBUTTON_MASK | VD_AGENT_DBUTTON_MASK,
MOUSEEVENTF_WHEEL, 0);
if (mouse_wheel) {
if (state->buttons & VD_AGENT_UBUTTON_MASK) {
_input.mi.mouseData = WHEEL_DELTA;
} else if (state->buttons & VD_AGENT_DBUTTON_MASK) {
_input.mi.mouseData = (DWORD)(-WHEEL_DELTA);
}
}
_buttons_state = state->buttons;
}
_input.mi.dwFlags = MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_VIRTUALDESK | mouse_move |
mouse_wheel | buttons_change;
if ((mouse_move && GetTickCount() - _input_time > VD_INPUT_INTERVAL_MS) || buttons_change ||
mouse_wheel) {
ret = send_input();
} else if (!_pending_input) {
if (SetTimer(_hwnd, VD_TIMER_ID, VD_INPUT_INTERVAL_MS, NULL)) {
_pending_input = true;
} else {
vd_printf("SetTimer failed: %lu", GetLastError());
_running = false;
ret = false;
}
}
_desktop_layout->unlock();
return ret;
}
