int on_url (http_parser* parser, const char *at, size_t length) { client_t* client = (client_t*) parser->data; if(parser->method != 1) return 0; LOGF ("[ %5d ] url parsed", client->request_num); struct http_parser_url *u = malloc (sizeof (struct http_parser_url) ); uv_tcp_t* handle = &client->handle; char* path = malloc ((length +1)* sizeof (char) ); char * content = malloc (304800); char * buffer = malloc (304800); uv_buf_t resbuf; strncpy (path, at, length); size_t user_id=server_param->model.parameters.users_number; path[length]=0; sscanf (path, "/user=%u", &user_id); if (user_id >= server_param->model.parameters.users_number) { strcpy (content, "{ \n"\ "\"error\": { \n"\ "\"message\": \"Unsupported get request.\", \n"\ "\"type\": \"User Not Valid\", \n"\ "}\n"\ "}"); } else { rating_estimator_parameters_t* estim_param = malloc (sizeof (rating_estimator_parameters_t) ); int backup=0; if (uv_mutex_trylock(&factors_mutex)) { uv_mutex_lock(&factors_backup_mutex); backup=1; estim_param->lfactors = factors; printf("Backup \n"); printf("factors_backup_mutex locked outside of thread \n"); }else { estim_param->lfactors = factors_backup; } estim_param->tset = training_set; estim_param->user_index = user_id; recommended_items_t* rec = recommend_items (estim_param, server_param->model, 4); uv_mutex_unlock(&factors_mutex); if(backup==1) { uv_mutex_unlock(&factors_backup_mutex); } LOG ("recommendation completed"); int i; sprintf (content, "{ \n \"user_index\" : %u, \n",user_id); sprintf (content, "%s \"recommended_items\" : [ \n",content); for (i = 0; i < rec->items_number - 1; i++) { sprintf (content, "%s { \"item\" : %u , \"rating\" : %lf }, \n", content, rec->items[i].index, rec->items[i].rating); } sprintf (content, "%s { \"item\" : %u , \"rating\" : %lf } \n ], \n", content, rec->items[rec->items_number - 1].index, rec->items[rec->items_number - 1].rating); coo_matrix_t* top_rated_items=get_top_rated_items(training_set,user_id,6); sprintf (content, "%s \"top_rated_items\" : [ \n",content); for(i=0;i < top_rated_items->size - 1; i++) { sprintf (content, "%s { \"item\" : %u , \"rating\" : %lf }, \n", content, top_rated_items->entries[i].row_i, top_rated_items->entries[i].value); } sprintf (content, "%s { \"item\" : %u , \"rating\" : %lf } \n ], \n", content, top_rated_items->entries[top_rated_items->size-1].row_i, top_rated_items->entries[top_rated_items->size-1].value); coo_matrix_t* rated_items=get_rated_items(training_set,user_id); sprintf (content, "%s \"rated_items\" : [ \n",content); for(i=0;i < rated_items->current_size; i++) { sprintf (content, "%s { \"item\" : %u , \"rating\" : %lf }, \n", content, rated_items->entries[i].row_i, rated_items->entries[i].value); } sprintf (content, "%s { \"item\" : %u , \"rating\" : %lf } \n ] \n", content, rated_items->entries[rated_items->current_size-1].row_i, rated_items->entries[rated_items->current_size-1].value); sprintf (content, "%s \n }", content); free_coo_matrix(rated_items); free_coo_matrix(top_rated_items); } sprintf (buffer, "%s %u \r\n\r\n%s\n", HEADER, strlen (content), content); resbuf.base = buffer; resbuf.len = strlen (resbuf.base); uv_write ( &client->write_req, (uv_stream_t*) &client->handle, &resbuf, 1, after_write); free (content); free (path); return 0; }
void benchmark_coo(char* clspmvpath, char* oclfilename, int ntimes, cl_device_type deviceType) { char outname[1000]; sprintf(outname, "%s%s", clspmvpath, "/benchmark/coo.ben"); FILE* outfile = fopen(outname, "w"); int methodnum = 1; double floptable[methodnum]; //Get device info cl_device_id* devices = NULL; cl_context context = NULL; cl_command_queue cmdQueue = NULL; cl_program program = NULL; assert(initialization(deviceType, devices, &context, &cmdQueue, &program, oclfilename) == 1); cl_int errorCode = CL_SUCCESS; //Assuming GPU is at devices[0] cl_uint dev_exec_num; size_t devicesSize = 0; errorCode = clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, NULL, &devicesSize ); CHECKERROR; devices = new cl_device_id[devicesSize / sizeof(cl_device_id)]; CHECKERROR; errorCode = clGetContextInfo(context, CL_CONTEXT_DEVICES, devicesSize, devices, NULL ); CHECKERROR; errorCode = clGetDeviceInfo(devices[0], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof( dev_exec_num ), &dev_exec_num, NULL ); CHECKERROR; freeObjects(devices, &context, &cmdQueue, &program); printf("\nCompute units %d\n", dev_exec_num); unsigned int max_group_num = dev_exec_num*MIN_WAVE_PER_GROUP*4; //unsigned int size = 16384; //unsigned int coonum = 128; //unsigned int groupnum = dev_exec_num; for (unsigned int size = 1024; size <= 2*1024*1024; size*=2) { float* vec = (float*)malloc(sizeof(float)*size); float* res = (float*)malloc(sizeof(float)*size); initVectorOne<int, float>(vec, size); initVectorZero<int, float>(res, size); for (unsigned int coonum = 1; coonum <= 128; coonum *= 2) { if (size*coonum > 67108864) break; if (coonum > size) break; coo_matrix<int, float> coomat; init_coo_mat(coomat, size, coonum); for (unsigned int groupnum = dev_exec_num; groupnum <= max_group_num; groupnum += dev_exec_num) { double opttime = 10000.0f; double optflop = 0.0f; int optmethod = 0; spmv_coo_ocl(&coomat, vec, res, 1, opttime, optflop, optmethod, oclfilename, deviceType, ntimes, floptable, groupnum); printf("\n------------------------------------------------------------------------\n"); printf("COO Dim %d BN %d GN %d opttime %f ms optflop %f optmethod %d", size, coonum, groupnum, opttime*1000.0, optflop, optmethod); printf("\n------------------------------------------------------------------------\n"); fprintf(outfile, "%d %d %d", size, coonum, groupnum); for (unsigned int k = 0; k < methodnum; k++) fprintf(outfile, " %f", floptable[k]); fprintf(outfile, "\n"); } free_coo_matrix(coomat); } free(vec); free(res); } fclose(outfile); }
/* * Update the learned factors */ void update_learned_factors_social (struct learned_factors* lfactors, struct training_set* tset, sparse_matrix_t* social_matrix, struct model_parameters * params) { size_t r, k, i, u, n, vv; double r_iu = 0; double e_iu = 0; double prediction; double sig_score; double score; double *sum = malloc (sizeof (double) * params->dimensionality); double *friend_sum = malloc (sizeof (double) * params->dimensionality); double* user_bias_copy; double** user_factors_copy; lfactors->dimensionality = params->dimensionality; lfactors->items_number = params->items_number; lfactors->users_number = params->users_number; r = k = u = i = 0; for (k = 0; k < params->iteration_number; k++) { user_bias_copy = malloc (sizeof (double) * params->users_number); user_factors_copy = malloc (sizeof (double*) *params->users_number); memcpy (user_bias_copy, lfactors->user_bias, sizeof (double) *params->users_number); for (r = 0; r < params->users_number; r++) { user_factors_copy[r] = malloc (sizeof (double) * params->dimensionality); memcpy (user_factors_copy[r], lfactors->user_factor_vectors[r], params->dimensionality * sizeof (double) ); } for (r = 0; r < tset->training_set_size; r++) { r_iu = tset->ratings->entries[r].value; i = tset->ratings->entries[r].row_i; u = tset->ratings->entries[r].column_j; score = lfactors->ratings_average + lfactors->user_bias[u] + lfactors->item_bias[i] + dot_product (lfactors->user_factor_vectors[u], lfactors->item_factor_vectors[i], lfactors->dimensionality); sig_score = 1 / (1 + exp (-score) ); prediction = 1 + sig_score * 4; e_iu = r_iu - prediction; if (e_iu) { compute_factors_social (u, i, lfactors, e_iu , params); } } for (u = 0; u < params->users_number; u++) lfactors->user_bias[u] += params->step_bias * user_bias_copy[u] * params->lambda_bias; for (i = 0; i < params->items_number; i++) lfactors->item_bias[i] += params->step_bias * lfactors->item_bias[i] * params->lambda_bias; for (u = 0; u < params->users_number; u++) for (r = 0; r < params->dimensionality; r++) lfactors->user_factor_vectors[u][r] +=params->step * user_factors_copy[u][r] * params->lambda; for (i = 0; i < params->items_number; i++) for (r = 0; r < params->dimensionality; r++) lfactors->item_factor_vectors[i][r] +=params->step * lfactors->item_factor_vectors[i][r] * params->lambda; for (u = 0; u < params->users_number; u++) { coo_matrix_t* user_relations = get_row_in_coo (social_matrix, u); size_t v; double bias_diff = 0; memset (sum, 0, params->dimensionality * sizeof (double) ); for (v = 0 ; v < user_relations->current_size; v++) { for (r = 0; r < params->dimensionality; r++) { sum[r] += user_factors_copy[user_relations->entries[v].column_j][r] / user_relations->current_size; } bias_diff += user_bias_copy[user_relations->entries[v].column_j] / user_relations->current_size; } for (r = 0; r < params->dimensionality; r++) { lfactors->user_factor_vectors[u][r] += params->betha * params->step* (user_factors_copy[u][r] - sum[r]); } lfactors->user_bias[u] += params->betha * params->step_bias * (user_bias_copy[u] - bias_diff); bias_diff=0; memset(sum,0,params->dimensionality * sizeof (double)); for (v = 0 ; v < user_relations->current_size; v++) { size_t friend_id = user_relations->entries[v].column_j; coo_matrix_t* friend_relations = get_row_in_coo (social_matrix, friend_id); double friend_bias_diff = 0; memset (friend_sum, 0, params->dimensionality * sizeof (double) ); for (vv = 0 ; vv < friend_relations->current_size; vv++) { for (r = 0; r < params->dimensionality; r++) { friend_sum[r] += user_factors_copy[friend_relations->entries[vv].column_j][r] / friend_relations->current_size; } friend_bias_diff += user_bias_copy[friend_relations->entries[vv].column_j] / friend_relations->current_size; } for (r = 0; r < params->dimensionality; r++) { sum[r] += (user_factors_copy[friend_id][r] - friend_sum[r]) / user_relations->current_size; } bias_diff += (user_bias_copy[friend_id] - friend_bias_diff) / user_relations->current_size; free_coo_matrix (friend_relations); } for (r = 0; r < params->dimensionality; r++) { lfactors->user_factor_vectors[u][r] -= params->betha * params->step * ( sum[r]); } lfactors->user_bias[u] -= params->betha * params->step_bias * (bias_diff); free_coo_matrix (user_relations); } free (user_bias_copy); for (n = 0; n < params->users_number; n++) { free (user_factors_copy[n]); } free (user_factors_copy); } free (sum); }