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; }