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