def test_match_naive_mkl(self): size = 100 mat1, mat2, *_ = self.make_matrices(size) ret_naive = _matrix.multiply_naive(mat1, mat2) ret_mkl = _matrix.multiply_mkl(mat1, mat2) self.assertEqual(size, ret_naive.nrow) self.assertEqual(size, ret_naive.ncol) self.assertEqual(size, ret_mkl.nrow) self.assertEqual(size, ret_mkl.ncol) for i in range(ret_naive.nrow): for j in range(ret_naive.ncol): self.assertNotEqual(mat1[i, j], ret_mkl[i, j]) self.assertEqual(ret_naive[i, j], ret_mkl[i, j])
def test_caculation(self): size = 1000 np_mat1 = np.random.random(size * size) np_mat2 = np.random.random(size * size) mat1 = _matrix.Matrix(size, size, np_mat1.tolist()) mat2 = _matrix.Matrix(size, size, np_mat2.tolist()) start = time.time() ret_naive = _matrix.multiply_naive(mat1, mat2) end = time.time() navie_time = end - start print('multiply_naive runtime = {0:2.4f} seconds'.format(end - start)) start = time.time() ret_tile = _matrix.multiply_tile(mat1, mat2, 100) end = time.time() tile_time = end - start print(end - start) start = time.time() ret_mkl = _matrix.multiply_mkl(mat1, mat2) end = time.time() mkl_time = end - start print(end - start) self.assertEqual(size, ret_naive.nrow) self.assertEqual(size, ret_naive.ncol) self.assertEqual(size, ret_mkl.nrow) self.assertEqual(size, ret_mkl.ncol) for i in range(ret_naive.nrow): for j in range(ret_naive.ncol): self.assertNotEqual(mat1[i, j], ret_mkl[i, j]) self.assertEqual(ret_naive[i, j], pytest.approx(ret_mkl[i, j], abs=1e-05)) self.assertEqual(ret_tile[i, j], pytest.approx(ret_mkl[i, j], abs=1e-05)) fp = open("performance.txt", "w") fp.write( 'multiply_naive runtime = {0:2.4f} seconds\n'.format(navie_time)) fp.write( 'multiply_tile runtime = {0:2.4f} seconds\n'.format(tile_time)) fp.write('multiply_mkl runtime = {0:2.4f} seconds\n'.format(mkl_time)) fp.close
def test_correct(): mat1 = m.Matrix(smallsize, smallsize) mat2 = m.Matrix(smallsize, smallsize) for x in range( smallsize ): for y in range( smallsize ): mat1[x,y] = x* y mat2[x,y] = x * y naive = m.multiply_naive(mat1, mat2) tile = m.multiply_tile(mat1, mat2, 32) mkl = m.multiply_mkl(mat1, mat2) for x in range( smallsize ): for y in range( smallsize ): print( tile[x,y] ) assert tile == naive assert naive == mkl assert tile == mkl
def test_multiply_naive(self): for i in range(2): row_n_col = 1000 np_mat1 = np.random.random(row_n_col * row_n_col) np_mat2 = np.random.random(row_n_col * row_n_col) mat1 = Matrix(row_n_col, row_n_col, np_mat1.tolist()) mat2 = Matrix(row_n_col, row_n_col, np_mat2.tolist()) np_mat1 = np_mat1.reshape((row_n_col, row_n_col)) np_mat2 = np_mat2.reshape((row_n_col, row_n_col)) naive_answer = multiply_naive(mat1, mat2) assert naive_answer.nrow == row_n_col assert naive_answer.ncol == row_n_col mkl_answer = multiply_mkl(mat1, mat2) naive_ver_in_np = np.array(naive_answer.buffer_vector()).reshape( (row_n_col, row_n_col)) mkl_ver_in_np = np.array(mkl_answer.buffer_vector()).reshape( (row_n_col, row_n_col)) assert naive_ver_in_np == pytest.approx(mkl_ver_in_np, abs=1e-05)
def check_tile(self, mat1, mat2, tsize): if 0 == tsize: ret_tile = _matrix.multiply_naive(mat1, mat2) tile_str = "_matrix.multiply_naive(mat1, mat2)" else: ret_tile = _matrix.multiply_tile(mat1, mat2, tsize) tile_str = "_matrix.multiply_tile(mat1, mat2, tsize)" ret_mkl = _matrix.multiply_mkl(mat1, mat2) for i in range(ret_tile.nrow): for j in range(ret_tile.ncol): self.assertNotEqual(mat1[i, j], ret_mkl[i, j]) self.assertEqual(ret_tile[i, j], ret_mkl[i, j]) ns = dict(_matrix=_matrix, mat1=mat1, mat2=mat2, tsize=tsize) t_tile = timeit.Timer(tile_str, globals=ns) t_mkl = timeit.Timer('_matrix.multiply_mkl(mat1, mat2)', globals=ns) time_tile = min(t_tile.repeat(10, 1)) time_mkl = min(t_mkl.repeat(10, 1)) ratio = time_tile / time_mkl return ratio, time_tile
def test_performance(): m = np.random.randint(500, 501) n = np.random.randint(500, 501) k = np.random.randint(500, 501) np_mat1 = np.random.random((m, k)) np_mat2 = np.random.random((k, n)) mat1 = Matrix(np_mat1) mat2 = Matrix(np_mat2) naive_timing = [] for i in range(2): start = time.time() naive_ans = multiply_naive(mat1, mat2) end = time.time() naive_timing.append(end - start) mkl_timing = [] for i in range(2): start = time.time() mkl_ans = multiply_mkl(mat1, mat2) end = time.time() mkl_timing.append(end - start) tile16_timing = [] for i in range(2): start = time.time() tile16_ans = multiply_tile(mat1, mat2, 16) end = time.time() tile16_timing.append(end - start) tile17_timing = [] for i in range(2): start = time.time() tile17_ans = multiply_tile(mat1, mat2, 17) end = time.time() tile17_timing.append(end - start) tile19_timing = [] for i in range(2): start = time.time() tile19_ans = multiply_tile(mat1, mat2, 19) end = time.time() tile19_timing.append(end - start) naive_timing = np.mean(naive_timing) mkl_timing = np.mean(mkl_timing) tile16_timing = np.mean(tile16_timing) tile17_timing = np.mean(tile17_timing) tile19_timing = np.mean(tile19_timing) with open('performance.txt', 'w') as f: print('Performance Measurement', file=f) print('Input Matrix size:', file=f) print('Matrix 1: {} x {}'.format(m, k), file=f) print('Matrix 2: {} x {}'.format(k, n), file=f) print('Average Time for multiply_naive: {}'.format(naive_timing), file=f) print('Average Time for multiply_mkl: {}'.format(mkl_timing), file=f) print('Average Time for multiply_tile16: {}'.format(tile16_timing), file=f) print('Average Time for multiply_tile17: {}'.format(tile17_timing), file=f) print('Average Time for multiply_tile19: {}'.format(tile19_timing), file=f) assert tile16_timing / naive_timing <= 0.8 assert tile17_timing / naive_timing <= 0.8 assert tile19_timing / naive_timing <= 0.8
def naive_MM(A, B): return _matrix.multiply_naive(A, B)