Я создал серийную задачу для подсчета определителя:
class serialTask : public task {
matrix m;
int *determinant;
serialTask(matrix m_, int* sum) : m(m_), determinant(sum) {}
task* execute()
{
*determinant = 0;
for (int i = 0; i < m.get_size(); i++)
{
int cur_elem = m.get_values()[0][i];
if (m.get_size() == 1)
{
*determinant += cur_elem;
}
else
{
int x;
matrix new_m = m.cut_matrix(0, i);
serialTask& task = *new(allocate_child()) serialTask(new_m, &x);
set_ref_count(2);
spawn_and_wait_for_all(task);
int step = 2 + i;
*determinant += cur_elem * pow(-1, step) * x;
}
}
return NULL;
}
};
... и параллельная задача:
class parallelTask : public task {
matrix m;
int *determinant;
int* results;
parallelTask(matrix mat, int* sum) : m(mat), determinant(sum), results(new int[m.get_size()]) {}
task* execute()
{
task_list tasks;
int *elems = new int[m.get_size()];
if (m.get_size() == 1)
{
*determinant = m.get_values()[0][0];
}
else
{
*determinant = 0;
for (int i = 0; i < m.get_size(); i++)
{
elems[i] = m.get_values()[0][i];
matrix new_m = m.cut_matrix(0, i);
tasks.push_back(*new(allocate_child()) parallelTask(new_m, &results[i]));
}
set_ref_count(m.get_size() + 1);
spawn_and_wait_for_all(tasks);
for (int j = 0; j < m.get_size(); j++)
{
int step = 1 + j + 1;
*determinant += elems[j] * pow(-1, step) * results[j];
}
}
return NULL;
}
};
Параллельная задача должна работать быстрее последовательной для большой матрицы и медленнее для маленькой. Но ситуация обратная: последовательная задача намного быстрее, чем параллельная для большой матрицы.
Может кто подскажет, в чем проблема?
