void put_job_in_foreground(t_context *context, t_job *job)
{
int status;
set_fg_job(context, job);
status = wait_job(job, WUNTRACED, 0);
context->last_status = WEXITSTATUS(status);
unwatch_job(context, job, !WIFSTOPPED(status));
if (!WIFSTOPPED(status))
set_fg_job(context, 0);
}
void probe_jobs(t_context *context)
{
t_list *it;
t_job *job;
int status;
int done;
it = context->jobs;
while (it)
{
job = (t_job *)it->content;
status = wait_job(job, WNOHANG, &done);
if (done)
{
context->last_status = WEXITSTATUS(status);
show_finished_job(context, job, status);
unwatch_job(context, job, 1);
}
it = it->next;
}
}
int node(int argc, char **argv)
{
int k, myid;
char my_mbox[MAILBOX_NAME_SIZE];
node_job_t myjob, jobs[GRID_NUM_NODES];
xbt_matrix_t A, B, C, sA, sB, sC;
result_t result;
xbt_assert(argc != 1, "Wrong number of arguments for this node");
/* Initialize the node's data-structures */
myid = atoi(argv[1]);
snprintf(my_mbox, MAILBOX_NAME_SIZE - 1, "%d", myid);
sC = xbt_matrix_double_new_zeros(NODE_MATRIX_SIZE, NODE_MATRIX_SIZE);
if(myid == 0) {
/* Create the matrices to multiply and one to store the result */
A = xbt_matrix_double_new_id(MATRIX_SIZE, MATRIX_SIZE);
B = xbt_matrix_double_new_seq(MATRIX_SIZE, MATRIX_SIZE);
C = xbt_matrix_double_new_zeros(MATRIX_SIZE, MATRIX_SIZE);
/* Create the nodes' jobs */
create_jobs(A, B, jobs);
/* Get own job first */
myjob = jobs[0];
/* Broadcast the rest of the jobs to the other nodes */
broadcast_jobs(jobs + 1);
} else {
A = B = C = NULL; /* Avoid warning at compilation */
myjob = wait_job(myid);
}
/* Multiplication main-loop */
XBT_VERB("Start Multiplication's Main-loop");
for(k=0; k < GRID_SIZE; k++) {
if(k == myjob->col) {
XBT_VERB("Broadcast sA(%d,%d) to row %d", myjob->row, k, myjob->row);
broadcast_matrix(myjob->A, NEIGHBOURS_COUNT, myjob->nodes_in_row);
}
if(k == myjob->row) {
XBT_VERB("Broadcast sB(%d,%d) to col %d", k, myjob->col, myjob->col);
broadcast_matrix(myjob->B, NEIGHBOURS_COUNT, myjob->nodes_in_col);
}
if(myjob->row == k && myjob->col == k) {
xbt_matrix_double_addmult(myjob->A, myjob->B, sC);
} else if(myjob->row == k) {
get_sub_matrix(&sA, myid);
xbt_matrix_double_addmult(sA, myjob->B, sC);
xbt_matrix_free(sA);
} else if(myjob->col == k) {
get_sub_matrix(&sB, myid);
xbt_matrix_double_addmult(myjob->A, sB, sC);
xbt_matrix_free(sB);
} else {
get_sub_matrix(&sA, myid);
get_sub_matrix(&sB, myid);
xbt_matrix_double_addmult(sA, sB, sC);
xbt_matrix_free(sA);
xbt_matrix_free(sB);
}
}
/* Node 0: gather the results and reconstruct the final matrix */
if(myid == 0) {
int node;
result_t results[GRID_NUM_NODES] = {0};
XBT_VERB("Multiplication done.");
/* Get the result from the nodes in the GRID */
receive_results(results);
/* First add our results */
xbt_matrix_copy_values(C, sC, NODE_MATRIX_SIZE, NODE_MATRIX_SIZE,
0, 0, 0, 0, NULL);
/* Reconstruct the rest of the result matrix */
for (node = 1; node < GRID_NUM_NODES; node++) {
xbt_matrix_copy_values(C, results[node]->sC,
NODE_MATRIX_SIZE, NODE_MATRIX_SIZE,
NODE_MATRIX_SIZE * results[node]->row,
NODE_MATRIX_SIZE * results[node]->col,
0, 0, NULL);
xbt_matrix_free(results[node]->sC);
xbt_free(results[node]);
}
//xbt_matrix_dump(C, "C:res", 0, xbt_matrix_dump_display_double);
xbt_matrix_free(A);
xbt_matrix_free(B);
xbt_matrix_free(C);
/* The rest: return the result to node 0 */
} else {
msg_task_t task;
XBT_VERB("Multiplication done. Send the sub-result.");
result = xbt_new0(s_result_t, 1);
result->row = myjob->row;
result->col = myjob->col;
result->sC =
xbt_matrix_new_sub(sC, NODE_MATRIX_SIZE, NODE_MATRIX_SIZE, 0, 0, NULL);
task = MSG_task_create("result",100,100,result);
MSG_task_send(task, "0");
}
/* Clean up and finish*/
xbt_matrix_free(sC);
xbt_matrix_free(myjob->A);
xbt_matrix_free(myjob->B);
xbt_free(myjob);
return 0;
}
