void parallelOperation(double **a, double **b, double **c, int size, int operation)
{
int i;
struct work_struct *jobs[CPUCORES];
aa = a;
bb = b;
cc = c;
matrixSize = size;
for (i = 0; i < CPUCORES; i++) {
jobs[i] = malloc(sizeof(struct work_struct));
if (jobs[i] == NULL) {
perror(NULL);
exit(1);
}
jobs[i]->id = i;
}
job_init();
switch(operation){
case MULTIPLY:{
// printf("Multiply[%d]: ", size);
for (i = 1; i < CPUCORES; i++)
job_create(mm, jobs[i], 0);
mm(jobs[0]);
}break;
case VECTOR:{
// printf("Vector[%d]: ", size);
for (i = 1; i < CPUCORES; i++)
job_create(mv, jobs[i], 0);
mv(jobs[0]);
}break;
case ADD:{
// printf("Add[%d]: ", size);
for (i = 1; i < CPUCORES; i++)
job_create(add, jobs[i], 0);
add(jobs[0]);
}break;
case SCALE:{
// printf("Scale[%d]: ", size);
for (i = 1; i < CPUCORES; i++)
job_create(scale, jobs[i], 0);
scale(jobs[0]);
}break;
}
for (i = 1; i < CPUCORES; i++)
job_join(jobs[i]);
// printf("\n");
}
ushort lcs(const struct sequence *s1, const struct sequence *s2)
{
ushort alen = s1->len;
ushort blen = s2->len;
job_init();
struct work_struct a_work = {
.id = 0,
.a = s1->str,
.alen = alen,
.b = s2->str,
.blen = blen,
.ret = NULL
};
struct work_struct b_work = {
.id = 1,
.a = s1->str,
.alen = alen,
.b = s2->str,
.blen = blen,
.ret = NULL
};
job_create(memo_lcs_front, &a_work, 0);
memo_lcs_back(&b_work);
job_join(&a_work);
ushort *forward = a_work.ret;
ushort *backward = b_work.ret;
ushort i = 0;
ushort ibest = 0;
for (i = 1; i < blen + 1; i++) {
if (forward[i] + backward[i - 1] > ibest)
ibest = forward[i] + backward[i - 1];
}
return ibest;
}
void strassen_8thread_mult(matrix a, matrix b, matrix c){
matrix quar[12];
matrix m[7];
struct work_struct *jobs[7];
int size = a.size/2;
int i, j;
if(size==0){
c.rows[0][0] = a.rows[0][0] * b.rows[0][0];
return;
}
/*
if (a.size <= BREAK) {
int i, j, k;
for (i = 0; i < (a.size); i++) {
for (k = 0; k < (a.size); k++) {
for (j = 0; j < (a.size); j++) {
c.rows[i][j] += a.rows[i][k] * b.rows[k][j];
}
}
}
return;
}
*/
job_init();
quar[0]=get00(a); quar[1]=get01(a);
quar[2]=get10(a); quar[3]=get11(a);
quar[4]=get00(b); quar[5]=get01(b);
quar[6]=get10(b); quar[7]=get11(b);
quar[8]=get00(c); quar[9]=get01(c);
quar[10]=get10(c); quar[11]=get11(c);
for(i=0;i<7;i++){
m[i] = new_matrix(size);
}
for (i = 0; i < 7; i++) {
jobs[i] = malloc(sizeof(struct work_struct));
if (jobs[i] == NULL) {
perror(NULL);
exit(1);
}
}
jobs[0]->a_1 = quar[0];
jobs[0]->a_2 = quar[3];
jobs[0]->b_1 = quar[4];
jobs[0]->b_2 = quar[7];
jobs[0]->c = m[0];
jobs[0]->tid = 0;
job_create(thread_main, jobs[0], 0);
jobs[1]->a_1 = quar[2];
jobs[1]->a_2 = quar[3];
jobs[1]->b_1 = quar[4];
jobs[1]->c = m[1];
jobs[1]->tid = 1;
job_create(thread_main, jobs[1], 0);
jobs[2]->a_1 = quar[0];
jobs[2]->b_1 = quar[5];
jobs[2]->b_2 = quar[7];
jobs[2]->c = m[2];
jobs[2]->tid = 2;
job_create(thread_main, jobs[2], 0);
jobs[3]->a_1 = quar[3];
jobs[3]->b_1 = quar[6];
jobs[3]->b_2 = quar[4];
jobs[3]->c = m[3];
jobs[3]->tid = 3;
job_create(thread_main, jobs[3], 0);
jobs[4]->a_1 = quar[0];
jobs[4]->a_2 = quar[1];
jobs[4]->b_1 = quar[7];
jobs[4]->c = m[4];
jobs[4]->tid = 4;
job_create(thread_main, jobs[4], 0);
jobs[5]->a_1 = quar[2];
jobs[5]->a_2 = quar[0];
jobs[5]->b_1 = quar[4];
jobs[5]->b_2 = quar[5];
jobs[5]->c = m[5];
jobs[5]->tid = 5;
job_create(thread_main, jobs[5], 0);
jobs[6]->a_1 = quar[1];
jobs[6]->a_2 = quar[3];
jobs[6]->b_1 = quar[6];
jobs[6]->b_2 = quar[7];
jobs[6]->c = m[6];
jobs[6]->tid = 6;
job_create(thread_main, jobs[6], 0);
for(i=0;i<7;i++){
job_join(jobs[i]);
}
for(i=0;i<size;i++){
for(j=0;j<size;j++){
quar[8].rows[i][j] = m[0].rows[i][j] + m[3].rows[i][j] - m[4].rows[i][j] + m[6].rows[i][j];
quar[9].rows[i][j] = m[2].rows[i][j] + m[4].rows[i][j];
quar[10].rows[i][j] = m[1].rows[i][j] + m[3].rows[i][j];
quar[11].rows[i][j] = m[0].rows[i][j] - m[1].rows[i][j] + m[2].rows[i][j] + m[5].rows[i][j];
}
}
for(i=0;i<12;i++){
delete_matrix(quar[i]);
}
for(i=0;i<7;i++){
delete_matrix(m[i]);
}
}
