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)
