def calculation_helper(self, p, q, r, tsize):
m1 = np.random.rand(p, q)
m2 = np.random.rand(q, r)
m3 = np.matmul(m1, m2)
_m1 = _matrix.Matrix(m1)
_m2 = _matrix.Matrix(m2)
tstart = time.clock()
ret_naive = _matrix.multiply_naive(_m1, _m2)
tnaive = time.clock() - tstart
tstart = time.clock()
ret_tile = _matrix.multiply_tile(_m1, _m2, tsize)
ttile = time.clock() - tstart
tstart = time.clock()
ret_mkl = _matrix.multiply_mkl(_m1, _m2)
tmkl = time.clock() - tstart
assert m3.shape[0] == ret_naive.nrow and m3.shape[1] == ret_naive.ncol
assert m3.shape[0] == ret_tile.nrow and m3.shape[1] == ret_tile.ncol
assert m3.shape[0] == ret_mkl.nrow and m3.shape[1] == ret_mkl.ncol
assert (self.is_close_to_equal(m3, ret_naive, p, r))
assert (self.is_close_to_equal(m3, ret_tile, p, r))
assert (self.is_close_to_equal(m3, ret_mkl, p, r))
with open('performance.txt', 'w') as f:
f.write('multiply_naive: {}\n'.format(tnaive))
f.write('multiply_tile: {}\n'.format(ttile))
f.write('multiply_mkl: {}\n'.format(tmkl))
f.write('tile speed-up over naive: {}\n'.format(tnaive / ttile))
f.write('MKL speed-up over naive: {}\n'.format(tnaive / tmkl))
def test_speed():
mat1 = m.Matrix(largesize, largesize)
mat2 = m.Matrix(largesize, largesize)
fp = open("performance.txt", "a")
for x in range( largesize ):
for y in range( largesize ):
mat1[x,y] = random.random()
mat2[x,y] = random.random()
t_naive = time.time()
naive = m.multiply_naive(mat1, mat2)
t_naive = time.time() - t_naive
fp.write('multiply_naive use ' + str(t_naive) + 's\n' )
tilesize = 1
t_tilemin = t_naive * 2
while tilesize * tilesize <= largesize :
tilesize *= 2
t_tile = time.time()
tile = m.multiply_tile(mat1, mat2, tilesize)
t_tile = time.time() - t_tile
fp.write('multiply_tile use ' + str(t_tile) +'s with tile size ' + str(tilesize) + '\n' )
if t_tilemin > t_tile :
t_tilemin = t_tile
t_mkl = time.time()
mkl = m.multiply_mkl(mat1, mat2)
t_mkl = time.time() - t_mkl
fp.write('multiply_mkl use ' + str(t_mkl) + 's\n' )
fp.close()
assert t_naive * 0.8 > t_tilemin
def calculation_helper(self, p, q, r, tsize):
m1 = np.random.rand(p, q)
m2 = np.random.rand(q, r)
m3 = np.matmul(m1, m2)
_m1 = _matrix.Matrix(m1)
_m2 = _matrix.Matrix(m2)
start = self.time_report(-1)
naive = _matrix.multiply_naive(_m1, _m2)
tnaive = self.time_report(start)
start = self.time_report(-1)
tile = _matrix.multiply_tile(_m1, _m2, tsize)
ttile = self.time_report(start)
start = self.time_report(-1)
mkl = _matrix.multiply_mkl(_m1, _m2)
tmkl = self.time_report(start)
assert m3.shape[0] == naive.nrow and m3.shape[1] == naive.ncol
assert m3.shape[0] == tile.nrow and m3.shape[1] == tile.ncol
assert m3.shape[0] == mkl.nrow and m3.shape[1] == mkl.ncol
assert(self.is_close_to_equal(m3, naive, p, r))
assert(self.is_close_to_equal(m3, tile, p, r))
assert(self.is_close_to_equal(m3, mkl, p, r))
f = open("performance.txt", "w")
f.write('multiply_naive costs: {} seconds\n'.format(tnaive))
f.write('multiply_tile costs: {} seconds\n'.format(ttile))
f.write('multiply_mkl costs: {} seconds\n'.format(tmkl))
f.write('tile speed-up over naive: {}\n'.format(tnaive / ttile))
f.write('MKL speed-up over naive: {}\n'.format(tnaive / tmkl))
f.close()
def odd_tile_size():
matrix_size = 3
A_content = np.eye(matrix_size)
A = _matrix.Matrix(A_content)
# print(A)
B_content = np.arange(1,
matrix_size**2 + 1).reshape(matrix_size, matrix_size)
B = _matrix.Matrix(B_content)
print(_matrix.multiply_tile(A, B, 2))
def make_matrices(self, size):
mat1 = _matrix.Matrix(size, size)
mat2 = _matrix.Matrix(size, size)
mat3 = _matrix.Matrix(size, size)
for it in range(size):
for jt in range(size):
mat1[it, jt] = it * size + jt + 1
mat2[it, jt] = it * size + jt + 1
mat3[it, jt] = 0
return mat1, mat2, mat3
def test_multiply_naive():
np.random.seed(5555)
a = np.random.random((1000, 1000))
b = np.random.random((1000, 1000))
mat_a = _matrix.Matrix(a)
mat_b = _matrix.Matrix(b)
mat_ret = _matrix.multiply_naive(mat_a, mat_b)
assert mat_ret.nrow == mat_a.nrow
assert mat_ret.ncol == mat_b.ncol
assert np.array(mat_ret) == pytest.approx(np.matmul(a, b))
def test_tile():
mat1 = m.Matrix(size, size)
mat2 = m.Matrix(size, size)
np_mat = np_matrix(size, size)
copy_matrix(mat1, np_mat, size, size)
copy_matrix(mat2, np_mat, size, size)
mat_tile = m.multiply_tile(mat1, mat2, 8)
mat_mkl = m.multiply_mkl(mat1, mat2)
for i in range(size):
for j in range(size):
npt.assert_equal(mat_tile[i, j], mat_mkl[i, j])
def test_generate_cipher(self):
origin = Image.open('testing/message.png')
origin = origin.convert('1')
width=origin.size[0]*2
height=origin.size[1]*2
pix = numpy.array(origin)
_m1 = _matrix.Matrix(pix)
out_image_B = Image.new('1', (width, height))
b = numpy.array(out_image_B)
_m2 = _matrix.Matrix(numpy.array(Image.open('testing/secret.png').convert('1')))
_m3 = _matrix.Matrix(b)
res = _matrix.generate_cipher(_m1,_m2,_m3,int(width/2),int(height/2))
res = numpy.asarray(_matrix.to_matrix(res))
target = numpy.array(Image.open('testing/ciphered.png').convert('1'))
assert self.compare_helper(res,target) == 1
def create_matrix(self, m, n):
# setup matrix
A = _matrix.Matrix(m, n)
for i in range(m):
for j in range(n):
A[i, j] = random.randint(0, 1000)
return A
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 make_matrices(self, row, col):
matrix = _matrix.Matrix(row, col)
darray = np.zeros((row, col))
for i in range(row):
for j in range(col):
v = random.randint(0, 10000)
matrix[i, j] = v
darray[i, j] = v
return matrix, darray
def test_copy():
mat1 = m.Matrix(smallsize, smallsize)
for x in range( smallsize ):
for y in range( smallsize ):
mat1[x,y] = x*y
mat2 = mat1
assert mat2[ smallsize - 1 , smallsize - 1 ] == ( smallsize - 1 )*( smallsize - 1 )
def test_compare():
mat1 = m.Matrix(smallsize, smallsize)
for x in range( smallsize ):
for y in range( smallsize ):
mat1[x,y] = x*y
mat2 = mat1
assert mat1 == mat2
def different_tile_size():
matrix_size = 512
A_content = np.eye(matrix_size)
A = _matrix.Matrix(A_content)
# print(A)
B_content = np.arange(1,
matrix_size**2 + 1).reshape(matrix_size, matrix_size)
B = _matrix.Matrix(B_content)
# print(B)
MKL_MM = _matrix.multiply_mkl(A, B)
for p in range(1, 9):
tiled_MM = _matrix.multiply_tile(A, B, 2**p)
assert tiled_MM == MKL_MM
for p in [14, 22, 56]:
tiled_MM = _matrix.multiply_tile(A, B, p)
assert tiled_MM == MKL_MM
def test_matrix(self):
size = 1000
tile_width = random.randint(10, 100)
mat1 = _matrix.Matrix(size, size)
mat2 = _matrix.Matrix(size, size)
for i in range(size):
for j in range(size):
mat1[i, j] = random.randint(1, 100)
mat2[i, j] = random.randint(1, 100)
starttime = time.time()
ret_naive = _matrix.multiply_naive(mat1, mat2)
endtime = time.time()
naive_time = endtime - starttime
starttime = time.time()
ret_tile = _matrix.multiply_tile(mat1, mat2, tile_width)
endtime = time.time()
tile_time = endtime - starttime
starttime = time.time()
ret_mkl = _matrix.multiply_naive(mat1, mat2)
endtime = time.time()
mkl_time = endtime - starttime
f = open('performance.txt', 'w')
f.writelines([
'tile_width = ',
repr(tile_width), '\nnaive costs ',
repr(naive_time), ' seconds.\ntile costs ',
repr(tile_time), ' seconds.\nmkl costs ',
repr(mkl_time), ' seconds.\ntile/naive = ',
repr(tile_time / naive_time)
])
f.close()
for a in range(ret_naive.nrow):
for b in range(ret_naive.ncol):
self.assertEqual(ret_naive[a, b], ret_tile[a, b])
self.assertEqual(ret_tile[a, b], ret_mkl[a, b])
self.assertEqual(ret_naive[a, b], ret_mkl[a, b])
self.assertLess(tile_time / naive_time, 0.8)
def performance():
matrix_size = 512
A_content = np.eye(matrix_size)
A = _matrix.Matrix(A_content)
# print(A)
B_content = np.arange(1,
matrix_size**2 + 1).reshape(matrix_size, matrix_size)
B = _matrix.Matrix(B_content)
for p in range(4, 8):
tsize = 2**p
ns = dict(_matrix=_matrix, mat1=A, mat2=B, tsize=tsize)
t_tile = timeit.Timer('_matrix.multiply_tile(mat1, mat2, tsize)',
globals=ns)
t_naive = timeit.Timer('_matrix.multiply_naive(mat1, mat2)',
globals=ns)
time_tile = min(t_tile.repeat(10, 1))
time_naive = min(t_naive.repeat(10, 1))
ratio = time_tile / time_naive
print(tsize, ratio)
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 nd_array_test():
size = 100
mat = _matrix.Matrix(size, size)
for it in range(size):
for jt in range(size):
mat[it, jt] = it * size + jt + 1
np_array = np.array(mat, copy=False)
np_array[0, 0] = 10
print(np_array[0, 0], mat[0, 0])
np_array[1, 0] = 200
print(np_array[1, 0], mat[1, 0])
np_array.fill(0)
print(np_array[0, 0], mat[0, 0])
mat.array.fill(-1)
print(mat.array[0, 0], mat[0, 0])
def test_ndarray(self):
size = 100
mat = _matrix.Matrix(size, size)
for it in range(size):
for jt in range(size):
mat[it, jt] = it * size + jt + 1
for i in range(size):
for j in range(size):
self.assertNotEqual(0, mat[i, j])
self.assertTrue(isinstance(mat.array, np.ndarray))
self.assertEqual((size, size), mat.array.shape)
self.assertEqual(np.dtype('float64'), mat.array.dtype)
mat.array.fill(0)
for i in range(size):
for j in range(size):
self.assertEqual(0, mat[i, j])
def test_attributes():
mat = m.Matrix(2, 3)
npt.assert_equal(2, mat.nrow)
npt.assert_equal(3, mat.ncol)
flag = True
try:
mat.nrow == 2
except AttributeError:
pass
except:
flag = False
try:
mat.ncol == 3
except AttributeError:
pass
except:
flag = False
return npt.assert_equal(flag, True)
BOLD = '\033[1m'
UNDERLINE = '\033[4m'
if __name__ == "__main__":
# benchmark configuration
# n: the matrix with n * n
# tsize: the tiling size of tile version
# repeat: number of testing, take the `min` executation time
n = 1000
tsize = 64
repeat = 5
# setup matrix
print("setup random matrix with {} * {}...".format(n, n))
A = _matrix.Matrix(n, n)
B = _matrix.Matrix(n, n)
for i in range(n):
for j in range(n):
A[i, j] = random.randint(0, 1000)
B[i, j] = random.randint(0, 1000)
# doing benchmark
print("doing benchmark ... repeat {} times".format(repeat))
min_naive_time = float("inf")
min_dgemm_time = float("inf")
min_tile_time = float("inf")
for i in range(repeat):
# naive
(C1, naive_time) = benchmark(_matrix.multiply_naive, A, B)
try:
img = Image.open(infile)
except IOError as e:
logging.fatal(
"Fatal error: I/O error while loading message image '%s' (%s)" %
(args.message, str(e)))
sys.exit(1)
#f, e = os.path.splitext(infile)
uuid = uuid.uuid1()
logging.info('UUID: %s' % (uuid))
if args.resize:
img = img.resize(args.resize, Image.ANTIALIAS)
img = img.convert('1') #convert image to 1 bit
pix = numpy.array(img)
_m1 = _matrix.Matrix(pix)
# prepare two empty matrix
width = img.size[0] * 2
height = img.size[1] * 2
out_image_A = Image.new('1', (width, height))
out_image_B = Image.new('1', (width, height))
a = numpy.array(out_image_A)
b = numpy.array(out_image_B)
_m2 = _matrix.Matrix(a)
_m3 = _matrix.Matrix(b)
f = args.format.lower()
if not f == 'jpeg' and not f == 'png':
logging.fatal("Not support format type: '%s' , only supprt jpeg or png" %
(f))
def test_setitem():
mat = m.Matrix(2, 3)
for i in range(2):
for j in range(2):
mat[i, j] = 2.3
def test_getitem():
mat = m.Matrix(2, 3)
for i in range(2):
for j in range(3):
tmp = mat[i, j]
def test_no_match_size():
npt.assert_raises(IndexError, m.multiply_naive, m.Matrix(2, 3),
m.Matrix(2, 3))
npt.assert_raises(IndexError, m.multiply_tile, m.Matrix(2, 3),
m.Matrix(2, 3), 2)
SIZE = 1000
REPEAT = 5
FILE_NAME = "performance.txt"
def benchmark(func, A, B, *args):
start = time.time()
C = func(A, B, *args)
end = time.time()
return end - start
if __name__ == "__main__":
# set up matrix
mat1 = _matrix.Matrix(SIZE, SIZE)
mat2 = _matrix.Matrix(SIZE, SIZE)
for i in range(SIZE):
for j in range(SIZE):
mat1[i, j] = random.uniform(0, 1000)
mat2[i, j] = random.uniform(0, 1000)
# start bench
min_mkl_time = float('inf')
min_tile_time = float('inf')
for i in range(REPEAT):
temp = benchmark(_matrix.multiply_mkl, mat1, mat2)
if min_mkl_time > temp: min_mkl_time = temp
temp = benchmark(_matrix.multiply_tile, mat1, mat2, 17)
if min_tile_time > temp: min_tile_time = temp
# output to file
with open(FILE_NAME, "w") as f:
log(
f'test case {idx+1:2}/{len(test_cases):2}: , dim= {m:4} x {n:4} x {k:4} (repeat={times})',
f)
total_size = m * k
population_size = 100
random_population = [
int(random.randrange(-500, 1000))
for _ in range(int(population_size))
]
naive_list = [0 for _ in range(times)]
MKL_list = [0 for _ in range(times)]
for i in range(times):
A = _matrix.Matrix(m, n)
A_content = random.choices(random_population, k=m * n)
copy_to_mat(A, m, n, A_content)
B = _matrix.Matrix(n, k)
B_content = random.choices(random_population, k=n * k)
copy_to_mat(B, n, k, B_content)
naive_result, naive_time = naive_MM(A, B)
MKL_result, MKL_time = MKL_MM(A, B)
assert naive_result == MKL_result
naive_list[i] = naive_time
MKL_list[i] = MKL_time
naive_runtime[idx] = sum(naive_list) / len(naive_list)
def test_insert():
mat1 = m.Matrix(smallsize, smallsize)
mat1[ 0,0 ] = 100
assert mat1[ 0,0 ] == 100
