DECLARE_TEST(matrix, vec) {
vector_t vec;
VECTOR_ALIGN float32_t aligned_rotm[] = {
0, 2, 0, 11,
0, 0, 3, 12,
1, 0, 0, 13,
7, 8, 9, 10
};
VECTOR_ALIGN float32_t aligned_tformm[] = {
0, 2, 0, 0,
0, 0, 3, 0,
1, 0, 0, 0,
-1, 2, 5, 1
};
vec = matrix_rotate(matrix_zero(), vector_zero());
EXPECT_VECTOREQ(vec, vector_zero());
vec = matrix_rotate(matrix_zero(), vector_one());
EXPECT_VECTOREQ(vec, vector(0, 0, 0, 1));
vec = matrix_rotate(matrix_identity(), vector_one());
EXPECT_VECTOREQ(vec, vector_one());
vec = matrix_rotate(matrix_aligned(aligned_rotm), vector_xaxis());
EXPECT_VECTOREQ(vec, vector(0, 2, 0, 1));
vec = matrix_rotate(matrix_aligned(aligned_rotm), vector_yaxis());
EXPECT_VECTOREQ(vec, vector(0, 0, 3, 1));
vec = matrix_rotate(matrix_aligned(aligned_rotm), vector_zaxis());
EXPECT_VECTOREQ(vec, vector(1, 0, 0, 1));
vec = matrix_transform(matrix_zero(), vector_zero());
EXPECT_VECTOREQ(vec, vector_zero());
vec = matrix_transform(matrix_zero(), vector_one());
EXPECT_VECTOREQ(vec, vector(0, 0, 0, 0));
vec = matrix_transform(matrix_identity(), vector_one());
EXPECT_VECTOREQ(vec, vector_one());
vec = matrix_transform(matrix_aligned(aligned_tformm), vector_xaxis());
EXPECT_VECTOREQ(vec, vector(-1, 4, 5, 1));
vec = matrix_transform(matrix_aligned(aligned_tformm), vector_yaxis());
EXPECT_VECTOREQ(vec, vector(-1, 2, 8, 1));
vec = matrix_transform(matrix_aligned(aligned_tformm), vector_zaxis());
EXPECT_VECTOREQ(vec, vector(0, 2, 5, 1));
return 0;
}
struct task_desc *execute_task(struct task_desc *task)
{
switch (task->task_type) {
case 0:
/* STUB */
break;
case 1:
common_sleep(task->params);
break;
case 2:
matrix_zero(task->params);
break;
case 3:
naive_matrix_multiplication(task->params);
break;
case 4:
optimized_matrix_multiplication(task->params);
break;
case 5:
blocking_matrix_multiplication(task->params);
break;
case 6:
parallel_matrix_multiplication(task->num_threads, task->params);
break;
default:
/* Error not supported! */
break;
}
return task;
}
void
app_init (App * app)
{
GError *err = NULL;
app->definitions = gtk_builder_new ();
gtk_builder_add_from_file (app->definitions,
UI_DEFINITIONS_FILE, &err);
if (err != NULL) {
g_printerr
("Error while loading app definitions file: %s\n",
err->message);
g_error_free (err);
gtk_main_quit ();
}
gtk_builder_connect_signals (app->definitions, app);
app_init_colors (app);
app->filename = NULL;
app->display_level = FALSE;
app->display_weight = FALSE;
GtkCellRenderer *renderer=gtk_cell_renderer_text_new();
GET_UI_ELEMENT(GtkComboBox, combobox_from);
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combobox_from),renderer,FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combobox_from),renderer,
"text",0,
NULL);
gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_from),0);
GET_UI_ELEMENT(GtkComboBox, combobox_to);
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combobox_to),renderer,FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combobox_to),renderer,
"text",0,
NULL);
gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_to),0);
//init non graphical units
app->p_graph = malloc(sizeof(graph));
app->p_matrix = malloc(sizeof(matrix));
app->p_matrix->i_size = 3;
matrix_malloc(app->p_matrix);
matrix_zero(app->p_matrix);
//construct the graph from the matrix
init_all(app->p_graph, app->p_matrix);
}
matrix* matrix_transpose(matrix* m) {
matrix* mat_out = matrix_zero(m->n_cols, m->n_rows);
int i_row, i_col;
for (i_row = 0; i_row < m->n_rows; i_row++) {
for (i_col = 0; i_col < m->n_cols; i_col++) {
matrix_write(mat_out, i_col, i_row, matrix_read(m, i_row, i_col));
}
}
return mat_out;
}
/*
** Matrix Multiplication Routine
** matrix1 = input matrix (m x p)
** matrix2 = input matrix (p x n)
** m = number of rows in matrix1
** p = number of columns in matrix1 and number of rows in matrix2
** n = number of columns in matrix2
** output = output matrix = matrix1 * matrix2 (m x n)
*/
void matrix_multiply(float *matrix1, float *matrix2, int m, int p, int n, float *output)
{
int i, j, k;
matrix_zero(output, m, n);
for (i = 0; i < m; i++)
for (j = 0; j < p; j++)
for (k = 0; k < n; k++)
output[i*n+k] += matrix1[i*p+j] * matrix2[j*n+k];
}
// calculate the sum of divergences for the all pyramid level
// the smaller divergence map is upsamled and added to the divergence map for the higher level of pyramid
// temp is a temporary matrix of size (cols, rows), assumed to already be allocated
static void pyramid_calculate_divergence_sum(pyramid_t* pyramid, float* divG_sum)
{
float* temp = matrix_alloc(pyramid->rows*pyramid->cols);
// Find the coarsest pyramid, and the number of pyramid levels
int levels = 1;
while (pyramid->next != NULL)
{
levels++;
pyramid = pyramid->next;
}
// For every level, we swap temp and divG_sum. So, if there are an odd number of levels...
if (levels % 2)
{
float* const dummy = divG_sum;
divG_sum = temp;
temp = dummy;
}
// Add them all together
while (pyramid != NULL)
{
// Upsample or zero as needed
if (pyramid->next != NULL)
matrix_upsample(pyramid->cols, pyramid->rows, divG_sum, temp);
else
matrix_zero(pyramid->rows * pyramid->cols, temp);
// Add in the (freshly calculated) divergences
calculate_and_add_divergence(pyramid->cols, pyramid->rows, pyramid->Gx, pyramid->Gy, temp);
// char name[256];
// sprintf( name, "Up_%d.pfs", pyramid->cols );
// dump_matrix_to_file( pyramid->cols, pyramid->rows, temp, name );
// matrix_copy(pyramid->rows*pyramid->cols, temp, divG_sum);
// Rather than copying, just switch round the pointers: we know we get them the right way round at the end.
float* const dummy = divG_sum;
divG_sum = temp;
temp = dummy;
pyramid = pyramid->prev;
}
matrix_free(temp);
}
DECLARE_TEST(matrix, construct) {
matrix_t mat;
mat = matrix_zero();
EXPECT_VECTOREQ(mat.row[0], vector_zero());
EXPECT_VECTOREQ(mat.row[1], vector_zero());
EXPECT_VECTOREQ(mat.row[2], vector_zero());
EXPECT_VECTOREQ(mat.row[3], vector_zero());
mat = matrix_identity();
EXPECT_VECTOREQ(mat.row[0], vector(1, 0, 0, 0));
EXPECT_VECTOREQ(mat.row[1], vector(0, 1, 0, 0));
EXPECT_VECTOREQ(mat.row[2], vector(0, 0, 1, 0));
EXPECT_VECTOREQ(mat.row[3], vector(0, 0, 0, 1));
float32_t unaligned[] = {
0,
1, -2, 3, -4,
-5, 6, -7, 8,
9, 10, 11, 12,
-13, -14, -15, -16
};
mat = matrix_unaligned(&unaligned[1]);
EXPECT_VECTOREQ(mat.row[0], vector(1, -2, 3, -4));
EXPECT_VECTOREQ(mat.row[1], vector(-5, 6, -7, 8));
EXPECT_VECTOREQ(mat.row[2], vector(9, 10, 11, 12));
EXPECT_VECTOREQ(mat.row[3], vector(-13, -14, -15, -16));
VECTOR_ALIGN float32_t aligned[] = {
1, -2, 3, -4,
-5, 6, -7, 8,
9, 10, 11, 12,
-13, -14, -15, -16
};
mat = matrix_aligned(aligned);
EXPECT_VECTOREQ(mat.row[0], vector(1, -2, 3, -4));
EXPECT_VECTOREQ(mat.row[1], vector(-5, 6, -7, 8));
EXPECT_VECTOREQ(mat.row[2], vector(9, 10, 11, 12));
EXPECT_VECTOREQ(mat.row[3], vector(-13, -14, -15, -16));
return 0;
}
matrix gather_matrix(double* c,
int N, int gd,
MPI_Datatype * type_block)
{
matrix res;
matrix_zero(&res, N);
int NB = N/gd;
int counts[gd*gd];
int disps[gd*gd];
for (int i=0; i<gd; i++) {
for (int j=0; j<gd; j++) {
disps[i*gd+j] = i*N*NB+j*NB;
counts [i*gd+j] = 1;
}
}
MPI_Gatherv(c, NB*NB, MPI_DOUBLE,
res.content, counts, disps, *type_block,
0, MPI_COMM_WORLD);
return res;
}
DECLARE_TEST(matrix, ops) {
matrix_t mat;
VECTOR_ALIGN float32_t aligned[] = {
1, -2, 3, -4,
-5, 6, -7, 8,
9, 10, 11, 12,
-13, -14, -15, -16
};
float32_t unaligned[] = {
0, 1, 2, 3,
4, 5, 6, 7,
8, 9, 10, 11,
12, 13, 14, 15
};
mat = matrix_transpose(matrix_aligned(aligned));
EXPECT_VECTOREQ(mat.row[0], vector(1, -5, 9, -13));
EXPECT_VECTOREQ(mat.row[1], vector(-2, 6, 10, -14));
EXPECT_VECTOREQ(mat.row[2], vector(3, -7, 11, -15));
EXPECT_VECTOREQ(mat.row[3], vector(-4, 8, 12, -16));
mat = matrix_add(matrix_zero(), matrix_zero());
EXPECT_VECTOREQ(mat.row[0], vector_zero());
EXPECT_VECTOREQ(mat.row[1], vector_zero());
EXPECT_VECTOREQ(mat.row[2], vector_zero());
EXPECT_VECTOREQ(mat.row[3], vector_zero());
mat = matrix_add(matrix_zero(), matrix_identity());
EXPECT_VECTOREQ(mat.row[0], vector(1, 0, 0, 0));
EXPECT_VECTOREQ(mat.row[1], vector(0, 1, 0, 0));
EXPECT_VECTOREQ(mat.row[2], vector(0, 0, 1, 0));
EXPECT_VECTOREQ(mat.row[3], vector(0, 0, 0, 1));
mat = matrix_add(matrix_identity(), matrix_zero());
EXPECT_VECTOREQ(mat.row[0], vector(1, 0, 0, 0));
EXPECT_VECTOREQ(mat.row[1], vector(0, 1, 0, 0));
EXPECT_VECTOREQ(mat.row[2], vector(0, 0, 1, 0));
EXPECT_VECTOREQ(mat.row[3], vector(0, 0, 0, 1));
mat = matrix_add(matrix_aligned(aligned), matrix_unaligned(unaligned));
EXPECT_VECTOREQ(mat.row[0], vector(1, -1, 5, -1));
EXPECT_VECTOREQ(mat.row[1], vector(-1, 11, -1, 15));
EXPECT_VECTOREQ(mat.row[2], vector(17, 19, 21, 23));
EXPECT_VECTOREQ(mat.row[3], vector(-1, -1, -1, -1));
mat = matrix_add(matrix_aligned(aligned), matrix_transpose(matrix_aligned(aligned)));
EXPECT_VECTOREQ(mat.row[0], vector(2, -7, 12, -17));
EXPECT_VECTOREQ(mat.row[1], vector(-7, 12, 3, -6));
EXPECT_VECTOREQ(mat.row[2], vector(12, 3, 22, -3));
EXPECT_VECTOREQ(mat.row[3], vector(-17, -6, -3, -32));
mat = matrix_sub(matrix_zero(), matrix_zero());
EXPECT_VECTOREQ(mat.row[0], vector_zero());
EXPECT_VECTOREQ(mat.row[1], vector_zero());
EXPECT_VECTOREQ(mat.row[2], vector_zero());
EXPECT_VECTOREQ(mat.row[3], vector_zero());
mat = matrix_sub(matrix_zero(), matrix_identity());
EXPECT_VECTOREQ(mat.row[0], vector(-1, 0, 0, 0));
EXPECT_VECTOREQ(mat.row[1], vector(0, -1, 0, 0));
EXPECT_VECTOREQ(mat.row[2], vector(0, 0, -1, 0));
EXPECT_VECTOREQ(mat.row[3], vector(0, 0, 0, -1));
mat = matrix_add(matrix_identity(), matrix_zero());
EXPECT_VECTOREQ(mat.row[0], vector(1, 0, 0, 0));
EXPECT_VECTOREQ(mat.row[1], vector(0, 1, 0, 0));
EXPECT_VECTOREQ(mat.row[2], vector(0, 0, 1, 0));
EXPECT_VECTOREQ(mat.row[3], vector(0, 0, 0, 1));
mat = matrix_sub(matrix_aligned(aligned), matrix_unaligned(unaligned));
EXPECT_VECTOREQ(mat.row[0], vector(1, -3, 1, -7));
EXPECT_VECTOREQ(mat.row[1], vector(-9, 1, -13, 1));
EXPECT_VECTOREQ(mat.row[2], vector(1, 1, 1, 1));
EXPECT_VECTOREQ(mat.row[3], vector(-25, -27, -29, -31));
mat = matrix_sub(matrix_aligned(aligned), matrix_transpose(matrix_aligned(aligned)));
EXPECT_VECTOREQ(mat.row[0], vector(0, 3, -6, 9));
EXPECT_VECTOREQ(mat.row[1], vector(-3, 0, -17, 22));
EXPECT_VECTOREQ(mat.row[2], vector(6, 17, 0, 27));
EXPECT_VECTOREQ(mat.row[3], vector(-9, -22, -27, 0));
mat = matrix_mul(matrix_zero(), matrix_zero());
EXPECT_VECTOREQ(mat.row[0], vector_zero());
EXPECT_VECTOREQ(mat.row[1], vector_zero());
EXPECT_VECTOREQ(mat.row[2], vector_zero());
EXPECT_VECTOREQ(mat.row[3], vector_zero());
mat = matrix_mul(matrix_zero(), matrix_identity());
EXPECT_VECTOREQ(mat.row[0], vector_zero());
EXPECT_VECTOREQ(mat.row[1], vector_zero());
EXPECT_VECTOREQ(mat.row[2], vector_zero());
EXPECT_VECTOREQ(mat.row[3], vector_zero());
mat = matrix_mul(matrix_identity(), matrix_zero());
EXPECT_VECTOREQ(mat.row[0], vector_zero());
EXPECT_VECTOREQ(mat.row[1], vector_zero());
EXPECT_VECTOREQ(mat.row[2], vector_zero());
EXPECT_VECTOREQ(mat.row[3], vector_zero());
mat = matrix_mul(matrix_identity(), matrix_identity());
EXPECT_VECTOREQ(mat.row[0], vector(1, 0, 0, 0));
EXPECT_VECTOREQ(mat.row[1], vector(0, 1, 0, 0));
EXPECT_VECTOREQ(mat.row[2], vector(0, 0, 1, 0));
EXPECT_VECTOREQ(mat.row[3], vector(0, 0, 0, 1));
mat = matrix_mul(matrix_aligned(aligned), matrix_unaligned(unaligned));
EXPECT_VECTOREQ(mat.row[0], vector(-8 + 24 - 48, 1 - 10 + 27 - 4 * 13, 2 - 12 + 30 - 4 * 14,
3 - 14 + 33 - 4 * 15));
EXPECT_VECTOREQ(mat.row[1], vector(6 * 4 - 7 * 8 + 8 * 12, -5 * 1 + 6 * 5 - 7 * 9 + 8 * 13,
-5 * 2 + 6 * 6 - 7 * 10 + 8 * 14, -5 * 3 + 6 * 7 - 7 * 11 + 8 * 15));
EXPECT_VECTOREQ(mat.row[2], vector(10 * 4 + 11 * 8 + 12 * 12, 9 * 1 + 10 * 5 + 11 * 9 + 12 * 13,
9 * 2 + 10 * 6 + 11 * 10 + 12 * 14, 9 * 3 + 10 * 7 + 11 * 11 + 12 * 15));
EXPECT_VECTOREQ(mat.row[3], vector(-14 * 4 - 15 * 8 - 16 * 12, -13 * 1 - 14 * 5 - 15 * 9 - 16 * 13,
-13 * 2 - 14 * 6 - 15 * 10 - 16 * 14, -13 * 3 - 14 * 7 - 15 * 11 - 16 * 15));
return 0;
}
