def test_order_1(self):
# given
A = Cannon.Matrix(1, [3])
B = Cannon.Matrix(1, [4])
# when
C = matrix_multiply(A, B)
# then
assert_that(C, is_(Cannon.Matrix(1, [12])))
def test_horizontal_shift_2x2_by_blocks_1x1(self):
# given
M = Cannon.Matrix(2, [1, 2, 3, 4])
# when
actual = matrix_horizontal_shift(M, block_order=1)
# then
expected = Cannon.Matrix(2, [1, 2, 4, 3])
assert_that(actual, is_(expected))
def matrix_split(M, block_order):
matriz_order = M.ncols
fragments = (matriz_order / block_order) ** 2
matriz_frag = None
end = True
fila_matriz = 0
columna_matriz = 0
bloques = []
while end:
if columna_matriz == matriz_order:
columna_matriz = 0
fila_matriz += block_order
if (columna_matriz % block_order) == 0:
matriz_frag = Cannon.Matrix(block_order, [0] * (block_order ** 2))
bloques.append(matriz_frag)
frag_col = 0
frag_fila = 0
limit=fila_matriz + block_order
i=fila_matriz
while i<limit:
matriz_frag.data[block_order * frag_fila + frag_col] = M.data[matriz_order * i + columna_matriz]
frag_fila += 1
i+=1
def matrix_add(A, B):
order = A.ncols
C = Cannon.Matrix(order, [])
for pos in range(0, order**2):
C.data.append(A.data[pos] + B.data[pos])
return C
def test_5x5_processors_200x200_operands(self):
nprocs = 25
# given
P = [self.broker.add_servant(ProcessorI(), Cannon.ProcessorPrx) for i in range(nprocs)]
loader = self.broker.add_servant(OperationsI(P), Cannon.OperationsPrx)
A_last = 200 * 200
A = Cannon.Matrix(200, range(1, 1 + A_last))
B = Cannon.Matrix(200, range(1 + A_last, 1 + A_last * 2))
# when
C = loader.matrixMultiply(A, B)
# then
expected = matrix_multiply(A, B)
assert_that(C, is_(expected))
def matrix_multiply(A, B):
order = A.ncols
C = Cannon.Matrix(order, [])
for r in range(order):
for c in range(order):
cell = 0
for i in range(order):
cell += A.data[(r * order) + i] * B.data[(i * order) + c]
C.data.append(cell)
def __init__(self, order):
self.blocks = []
self.nblocks = 0
self.g_order = order
self.C = Cannon.Matrix(order, [])
self.event = threading.Event()
for i in range(order**2):
self.blocks.append(None)
def matrix_multiply(A, B):
order = A.ncols
C = Cannon.Matrix(order, [])
for i, j in itertools.product(xrange(order), repeat=2):
C.data.append(
sum(A.data[i * order + k] * B.data[k * order + j] for k in xrange(order))
)
return C
def injectFirst(self, A, step, current=None):
if self.C == None:
self.C = Cannon.Matrix(A.ncols, [])
for i in range(A.ncols**2):
self.C.data.append(0)
self.p_A[step] = A
if self.p_B[step] != None:
self.Sum(A, self.p_B[step], step)
def matrix_vertical_shift(M, block_order):
order = M.ncols
retval = Cannon.Matrix(order, [])
for row in range(0, order):
for col in range(0, order):
step = block_order * int(col/block_order)
retval.data.append(M.data[((row+step)%order)*order+col])
return retval
def matrix_horizontal_shift(M, block_order):
order = M.ncols
retval = Cannon.Matrix(order, [])
for row in range(0, order):
for col in range(0, order):
step = block_order * int(row/block_order)
retval.data.append(M.data[((col+step)%order)+row*order])
return retval
def matrix_add(A, B):
filsA = len(A.data) / A.ncols
colsA = A.ncols
filsB = len(B.data) / B.ncols
colsB = B.ncols
C = Cannon.Matrix(colsA, [0] * colsA * filsA)
i=0
for i in range(colsA * filsA):
C.data[i] = A.data[i] + B.data[i]
i+=1
def matrix_multiply(A, B):
order = A.ncols
C = Cannon.Matrix(order, [])
for row in range(0, order):
for col in range(0, order):
result = 0
for i in range(0, order):
result += A.data[row*order+i] * B.data[i*order+col]
C.data.append(result)
return C
def matrix_join(*blocks):
nblocks = len(blocks)
block_order = blocks[0].ncols
order = int(math.sqrt(nblocks)) * block_order
retval = Cannon.Matrix(order, [])
for row in range(0, order):
for col in range(0, order):
n_block = int(row/block_order) * int(order/block_order) + int(col/block_order)
block_pos = row%block_order * block_order + col%block_order
retval.data.append(blocks[n_block].data[block_pos])
return retval
class cliente(Ice.Application):
def run(self, argv):
prxFrontend = self.communicator().stringToProxy(argv[1])
frontend = Cannon.FrontendPrx.checkedCast(prxFrontend)
if not frontend:
raise RuntimeError("Invalid proxy frontend")
A_last = 400 * 400
A400 = Cannon.Matrix(400, range(1, 1 + A_last))
B400 = Cannon.Matrix(400, range(1 + A_last, 1 + A_last * 2))
res400=frontend.multiply(A400,B400)
res400dir=matrix_multiply(A400,B400)
if(res400 == res400dir):
print("Ok en matrix 400x400")
print_matrix(res400)
else:
print("Error en matrix 400x400")
A_last = 600 * 600
def test_vertical_shift_6x6_blocks_3x3(self):
# given
original = M6(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
31, 32, 33, 34, 35, 36)
# when
actual = matrix_vertical_shift(original, block_order=3)
# then
expected = M6(1, 2, 3, 22, 23, 24, 7, 8, 9, 28, 29, 30, 13, 14, 15, 34,
35, 36, 19, 20, 21, 4, 5, 6, 25, 26, 27, 10, 11, 12, 31,
32, 33, 16, 17, 18)
assert_that(actual, is_(Cannon.Matrix(6, expected)))
def load_matrix_from_file(filename):
with file(filename) as f:
rows = f.readlines()
order = len(rows[0].split())
retval = Cannon.Matrix(order, [])
for row in rows:
rowdata = row.split()
assert len(rowdata) == order
for n in rowdata:
retval.data.append(float(n))
assert len(retval.data) == order ** 2
return retval
def matrix_split(M, block_order):
blocks = []
order = M.ncols
blocks_row = int(order / block_order)
nblocks = blocks_row ** 2
for n_block in range(0, nblocks):
blocks.insert(n_block, Cannon.Matrix(block_order, []))
for row in range(0, order):
for col in range(0, order):
n_block = int(row/block_order) * int(blocks_row) + int(col/block_order)
blocks[n_block].data.append(M.data[row*order+col])
return blocks
def matrix_horizontal_shift(M, block_order):
order = M.ncols
retval = Cannon.Matrix(order, [])
for i in range(order ** 2):
retval.data.append(0)
for row in range(block_order):
for col in range(order):
retval.data[row*order + col] = M.data[row*order + col]
for row in range(block_order, order):
salto = int(row/block_order)
for col in range(order):
mov = ((col + order - salto * block_order) % order)
retval.data[row * order + mov] = M.data[row * order + col]
return retval
def matrix_join(blocks):
nbl = int(math.sqrt(len(blocks)))
block_order = blocks[0].ncols
order = nbl * block_order
M = Cannon.Matrix(order, [])
for nveces in range(nbl):
for ind_y in range(block_order):
pos = ind_y * block_order
block = nveces * nbl
for ind_x in range(nbl):
for inc in range(block_order):
M.data.append(blocks[block].data[pos + inc])
block = block + 1
return M
def try_multiply(self):
current_A = self.A_blocks[self.current_step]
current_B = self.B_blocks[self.current_step]
if current_A is None or current_B is None:
return
if self.current_step == 0:
self.result_parcial = Cannon.Matrix(current_A.ncols,
[0] * (current_A.ncols**2))
product = matrix_multiply(current_A, current_B)
self.result_parcial = matrix_add(self.result_parcial, product)
self.current_step += 1
if self.current_step == self.order:
self.target.injectSubmatrix(self.result_parcial, self.row,
self.col)
return
self.left.injectFirst(current_A, self.current_step)
self.above.injectSecond(current_B, self.current_step)
self.try_multiply()
def matrix_join(*blocks):
tamano = 0
fila = 0
col = 0
matriz_order = int(math.sqrt(len(blocks) *(blocks[0].ncols ** 2)))
matrix_joined = Cannon.Matrix(matriz_order, [0] * (matriz_order ** 2))
subMatrixOrder = blocks[0].ncols
block_order=matriz_order / subMatrixOrder
while tamano != matriz_order ** 2:
if block_order == col:
col = 0
fila += 1
col_aux = col * subMatrixOrder
fila_aux = fila * subMatrixOrder
for matrix_fila in range(subMatrixOrder):
for matrix_column in range(subMatrixOrder):
matrix_joined.data[(fila_aux + matrix_fila) * matriz_order + col_aux + matrix_column] = blocks[
block_order * fila + col].data[matrix_fila * subMatrixOrder + matrix_column]
tamano += 1
col += 1
def gen_matrix(ini, order):
return Cannon.Matrix(order, xrange(ini, ini + order ** 2))
def matrix_vertical_shift(M, block_order): order = M.ncols retval = Cannon.Matrix(order, [])
def matrix_split(M, block_order):
order = M.ncols
blocks = []
nbl = order / block_order
m = []
for ind_by in range(nbl):
for ind_bx in range(nbl):
pos = (ind_bx * block_order) + (ind_by * (block_order * order))
for ind_c in range(block_order):
for inc in range(block_order):
m.append(M.data[pos + (ind_c * order) + inc])
blocks.append(Cannon.Matrix(block_order, m))
m = []
return blocks
def list_split (M, block_order):
order = len(M)
blocks = []
nbl = order / block_order
m = []
for ind_bx in range(nbl):
for inc in range(block_order):
m.append(M[(ind_bx * block_order) + inc])
def M1(*data):
return Cannon.Matrix(1, list(data))
def M8(*data):
return Cannon.Matrix(8, list(data))
def M6(*data):
return Cannon.Matrix(6, list(data))
def M4(*data):
return Cannon.Matrix(4, list(data))
def matrix_add(A, B):
order = A.ncols
C = Cannon.Matrix(order, [])
for i in range(order ** 2):
C.data.append(A.data[i] + B.data[i])
