def setUp(self):
self.input = {}
self.input["a1_M"] = Tensor.fromUncompressed(["M"],
[1, 0, 3, 0, 5, 0, 7])
self.input["a1_m"] = self.input["a1_M"].getRoot()
self.input["b1_M"] = Tensor.fromUncompressed(["M"], [2, 0, 4, 5])
self.input["b1_m"] = self.input["b1_M"].getRoot()
self.input['c1_M'] = Tensor.fromUncompressed(["M"], [1, 2, 3])
self.input["c1_m"] = self.input["c1_M"].getRoot()
self.input["a2_MK"] = Tensor.fromUncompressed(
["M", "K"], [[1, 0, 3, 0, 5, 0, 7], [2, 2, 0, 3, 0, 0, 8],
[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0],
[4, 0, 5, 0, 8, 0, 9]])
self.input["a2_m"] = self.input["a2_MK"].getRoot()
self.input["b2_MK"] = Tensor.fromUncompressed(
["M", "K"], [[2, 0, 4, 5], [0, 0, 0, 0], [3, 4, 6, 0],
[0, 0, 0, 0], [1, 2, 3, 4]])
self.input["b2_m"] = self.input["b2_MK"].getRoot()
def get_A_HFA(a_file):
# read in inputs
# jhu_len = 5157
shape = 500 # TODO: take this as input
# generate input frontier and tile it
A_data = [0] * shape
# read in frontier
count = 1
A_HFA = None
if not a_file.endswith('.yaml'):
with open(a_file, 'r') as f:
for line in f:
elt = int(line)
A_data[elt] = count
count += 1
A_untiled = Tensor.fromUncompressed(["S"], A_data, name="A")
A_HFA = A_untiled.splitUniform(32, relativeCoords=True) # split S
print("A untiled shape {}, tiled shape {}".format(
A_untiled.getShape(), A_HFA.getShape()))
else: # already in pretiled yaml
A_HFA = Tensor.fromYAMLfile(a_file)
A_HFA.setName("A")
return A_HFA
def test_shape_fromUncompressed_1D(self):
"""Test shape of a tensor from 1D nested lists"""
l1 = [100, 101, 0, 102]
t1 = Tensor.fromUncompressed(["M"], l1)
self.assertEqual(t1.getRankIds(), ["M"])
self.assertEqual(t1.getShape(), [4])
l2 = [100, 101, 0, 0]
t2 = Tensor.fromUncompressed(["M"], l2)
self.assertEqual(t2.getRankIds(), ["M"])
self.assertEqual(t2.getShape(), [4])
def test_rankid_2D(self):
"""Test setting rank ids of 2D tensor"""
# 0 1 2 3
#
l1 = [
[0, 0, 0, 0], # 0
[100, 101, 102, 0], # 1
[0, 201, 0, 203], # 2
[0, 0, 0, 0], # 3
[400, 0, 402, 0], # 4
[0, 0, 0, 0], # 5
[0, 601, 0, 603]
] # 6
rank_ids = ["M", "K"]
t1 = Tensor.fromUncompressed(rank_ids, l1)
rank_ids2 = t1.getRankIds()
self.assertEqual(rank_ids2, rank_ids)
rank_ids_new = ["M2", "M1"]
t1.setRankIds(rank_ids_new)
rank_ids3 = t1.getRankIds()
self.assertEqual(rank_ids3, rank_ids_new)
def test_fromUncompressed_2D_wo_ids(self):
"""Test construction of a tensor from nested lists without ids"""
tensor_in = Tensor.fromYAMLfile("./data/test_tensor-1.yaml")
root = tensor_in.getRoot()
tensor_ref = Tensor.fromFiber(["R1", "R0"], root)
# Manual copy of test_tensor-1.yaml
# 0 1 2 3
#
t = [
[0, 0, 0, 0], # 0
[100, 101, 102, 0], # 1
[0, 201, 0, 203], # 2
[0, 0, 0, 0], # 3
[400, 0, 402, 0], # 4
[0, 0, 0, 0], # 5
[0, 601, 0, 603]
] # 6
tensor = Tensor.fromUncompressed(["R1", "R0"], t)
self.assertEqual(tensor, tensor_ref)
def get_Z_HFA(B_shape):
Z_data = [[0], [0]]
Z_HFA = Tensor.fromUncompressed(["D1", "D0"],
Z_data,
shape=[B_shape[0], B_shape[2]],
name="Z")
return Z_HFA
def test_fromUncompressed_20(self):
"""Test construction of a tensor a scalar"""
t_ref = Tensor(rank_ids=[])
p = t_ref.getRoot()
p += 2
t0 = Tensor.fromUncompressed([], 2)
self.assertEqual(t0, t_ref)
t1 = Tensor.fromUncompressed(rank_ids=[], root=2)
self.assertEqual(t1, t_ref)
t2 = Tensor.fromUncompressed(root=2)
self.assertEqual(t2, t_ref)
def test_flattenRanks_l3_sa(self):
"""Test flattenRanks - levels=3, coord_style=absolute"""
t0 = Tensor.fromUncompressed(rank_ids=["A"], root=list(range(16)))
s1 = t0.splitUniform(8, depth=0)
s2 = s1.splitUniform(4, depth=1)
s3 = s2.splitUniform(2, depth=2)
f4 = s3.flattenRanks(levels=3, coord_style="absolute")
f4.setRankIds(["A"])
self.assertEqual(f4, t0)
def test_fromUncompressed_1D(self):
"""Test construction of a tensor from nested lists"""
tensor_ref = Tensor.fromYAMLfile("./data/test_tensor-1.yaml")
# Manual copy of test_tensor-1.yaml
# 0 1 2 3
#
t = [100, 101, 0, 102]
fiber = Fiber([0, 1, 3], [100, 101, 102])
tensor = Tensor.fromUncompressed(["M"], t)
self.assertEqual(tensor.getRoot(), fiber)
def test_fromRandom_wo_ids(self):
"""Test construction of a random tensor without rankids"""
rank_ids = ["R1", "R0"]
shape = [10, 10]
tensor_ref = Tensor.fromUncompressed(
rank_ids,
[[0, 10, 10, 1, 0, 9, 8, 0, 0, 3], [
9, 1, 0, 10, 1, 0, 10, 0, 0, 0
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 3, 0, 3, 5, 0, 5, 7, 0, 0],
[6, 0, 0, 0, 0, 0, 6, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 2, 8, 2, 3, 7, 0, 0, 10], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 4, 0, 2, 9, 4, 0, 5], [6, 3, 0, 8, 0, 10, 0, 9, 4, 0]])
tensor = Tensor.fromRandom(None, shape, [0.5, 0.5], 10, seed=3)
self.assertEqual(tensor, tensor_ref)
self.assertEqual(tensor.getRankIds(), rank_ids)
def test_shape_fromUncompressed_2D_A1(self):
"""Test shape of a tensor from 2D nested lists (tensor A)"""
# 0 1 2 3
#
l1 = [
[0, 0, 0, 0], # 0
[100, 101, 102, 0], # 1
[0, 201, 0, 203], # 2
[0, 0, 0, 0], # 3
[400, 0, 402, 0], # 4
[0, 0, 0, 0], # 5
[0, 601, 0, 603]
] # 6
t1 = Tensor.fromUncompressed(["M", "K"], l1)
with self.subTest(test="All ranks"):
self.assertEqual(t1.getRankIds(), ["M", "K"])
self.assertEqual(t1.getShape(), [7, 4])
with self.subTest(test="All ranks specified"):
self.assertEqual(t1.getShape(["M", "K"]), [7, 4])
with self.subTest(test="Just rank 'M' as list"):
self.assertEqual(t1.getShape(["M"]), [7])
with self.subTest(test="Just rank 'K' as list"):
self.assertEqual(t1.getShape(["K"]), [4])
with self.subTest(test="Just rank 'M'"):
self.assertEqual(t1.getShape("M"), 7)
with self.subTest(test="Just rank 'K'"):
self.assertEqual(t1.getShape("K"), 4)
with self.subTest(test="Check authoritative"):
self.assertEqual(t1.getShape(authoritative=True), [7, 4])
self.assertEqual(t1.getShape(["M", "K"], authoritative=True),
[7, 4])
self.assertEqual(t1.getShape(["M"], authoritative=True), [7])
self.assertEqual(t1.getShape(["K"], authoritative=True), [4])
self.assertEqual(t1.getShape("M", authoritative=True), 7)
self.assertEqual(t1.getShape("K", authoritative=True), 4)
def test_shape_fromUncompressed_2D_B(self):
"""Test shape of a tensor from 2D nested lists (tensor B)"""
# 0 1 2 3
#
l2 = [
[0, 0, 0, 0], # 0
[100, 101, 102, 0], # 1
[0, 201, 0, 0], # 2
[0, 0, 0, 0], # 3
[400, 0, 402, 0], # 4
[0, 0, 0, 0], # 5
[0, 601, 0, 0]
] # 6
t2 = Tensor.fromUncompressed(["M", "K"], l2)
self.assertEqual(t2.getRankIds(), ["M", "K"])
self.assertEqual(t2.getShape(), [7, 4])
def test_fromUncompressed_2D(self):
"""Test construction of a tensor from nested lists"""
tensor_ref = Tensor.fromYAMLfile("./data/test_tensor-1.yaml")
# Manual copy of test_tensor-1.yaml
# 0 1 2 3
#
t = [
[0, 0, 0, 0], # 0
[100, 101, 102, 0], # 1
[0, 201, 0, 203], # 2
[0, 0, 0, 0], # 3
[400, 0, 402, 0], # 4
[0, 0, 0, 0], # 5
[0, 601, 0, 603]
] # 6
tensor = Tensor.fromUncompressed(["M", "K"], t)
self.assertEqual(tensor, tensor_ref)
def test_swizzleRanks(self):
""" Test swizzleRanks """
a_MK = Tensor.fromUncompressed(["M", "K"],
[[0, 0, 4, 0, 0, 5],
[3, 2, 0, 3, 0, 2],
[0, 2, 0, 0, 1, 2],
[0, 0, 0, 0, 0, 0],
[2, 5, 0, 0, 0, 5],
[4, 1, 0, 0, 0, 0],
[5, 0, 0, 1, 0, 0],
[4, 0, 0, 5, 1, 3]])
a_KM = a_MK.swapRanks()
M = 8
M1 = 2
M0 = (M+1)//M1
K = 6
K1 = 2
K0 = (K+1)//K1
a_MMKK = a_MK.splitUniform(M0).splitUniform(K0, depth=2)
a_MKMK = a_MMKK.swapRanks(depth=1)
a_KMMK = a_KM.splitUniform(K0).swapRanks(depth=1).splitUniform(M0, depth=1)
a_KM_2 = a_MK.swizzleRanks(["K", "M"])
self.assertEqual(a_KM_2, a_KM)
a_MK_2 = a_KM_2.swizzleRanks(["M", "K"])
self.assertEqual(a_MK_2, a_MK)
a_MKMK_2 = a_MMKK.swizzleRanks(["M.1","K.1", "M.0", "K.0"])
self.assertEqual(a_MKMK_2, a_MKMK)
a_MMKK_2 = a_MKMK.swizzleRanks(["M.1", "M.0", "K.1", "K.0"])
self.assertEqual(a_MMKK_2, a_MMKK)
from fibertree import Tensor, TensorImage a = Tensor.fromUncompressed(root=2) print(a) i = TensorImage(a) i.show()
if __name__ == "__main__":
print("a - multiple highlights")
a = Tensor.fromYAMLfile("../../examples/data/sparse-matrix-a.yaml")
a.setColor("blue")
i = UncompressedImage(a, highlights={"PE": [(0, 1), (1, 2), (3, )]})
i.show()
#
print("a - single highlights")
i = UncompressedImage(a, {"PE": [(1, 2)]})
i.show()
#
print("b")
b = Tensor.fromUncompressed(["X"], [1, 2, 0, 0, 4])
i = UncompressedImage(b, {"PE": [(1, ), (4, )]})
i.show()
#
print("c")
a_root = a.getRoot()
c = Tensor.fromFiber(["X", "Y", "Z"],
Fiber([0, 1, 2],
[a_root, Fiber([], []), a_root]))
i = UncompressedImage(c)
i.show()
#
print("d")
d = c.getRoot()
from fibertree import Fiber, Tensor, TensorImage
x = [[[1, 2, 8, 20, 0, 0, 11], [1, 0, 0, 11, 0, 0, 33], [0, 0, 0, 0, 0, 0, 0],
[1, 1, 8, 12, 0, 0, 44], [1, 3, 0, 13, 0, 0, 42], [0, 0, 4, 14, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]],
[[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]],
[[1, 2, 8, 20, 0, 0, 11], [1, 0, 0, 11, 0, 0, 33], [0, 0, 0, 0, 0, 0, 0],
[1, 1, 8, 12, 0, 0, 44], [1, 3, 0, 13, 0, 0, 42], [0, 0, 4, 14, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]]
f = Fiber.fromUncompressed(x)
f.dump("/tmp/tensor-3d.yaml")
f.print("Fiber from uncompressed")
t1 = Tensor.fromFiber(["X", "Y", "Z"], f)
t1.print("Tensor from fiber")
t2 = Tensor.fromUncompressed(["X", "Y", "Z"], x)
t2.print("Tensor from uncompressed")
[5, 6, 7],
[6, 7, 8]],
[[8, 10, 12],
[10, 12, 14],
[12, 14, 16]]],
[[[12, 15, 18],
[15, 18, 21],
[18, 21, 24]],
[[16, 20, 24],
[20, 24, 28],
[24, 28, 32]]]
]
Z_data = [[0, 0, 0], [0, 0, 0]]
A_HFA = Tensor.fromUncompressed(["K1", "K0"], A_data, name = "A")
B_HFA = Tensor.fromUncompressed(["N1", "K1", "N0", "K0"], B_data, name = "B")
Z_HFA = Tensor.fromUncompressed(["N1", "N0"], Z_data, shape=[N1, N0], name = "Z")
str_desc = sys.argv[1]
frontier_descriptor = [str_desc[0], str_desc[1]]
myA = encodeSwoopTensorInFormat(A_HFA, frontier_descriptor)
print("encoded A")
myB = encodeSwoopTensorInFormat(B_HFA, ["U", "U", "U", "C"])
print("encoded B")
myZ = encodeSwoopTensorInFormat(Z_HFA, frontier_descriptor)
print("done encoding\n")
a.setImplementations("root", myA[0])
a.setImplementations("K1", myA[1])
from fibertree import Tensor
from fibertree import Payload
print("----------------------------------------")
print(" BFS graph traversal")
print("----------------------------------------")
print("")
data_dir = "../../data"
#a = Tensor.fromYAMLfile(os.path.join(data_dir, "graph-a.yaml"))
# Adjacency matrix
a = Tensor.fromUncompressed(
["S", "D"], [[0, 1, 1, 0, 0, 0], [0, 0, 1, 1, 0, 0], [0, 0, 0, 1, 1, 0],
[0, 0, 0, 0, 1, 1], [1, 0, 0, 0, 0, 1], [1, 1, 0, 0, 0, 0]])
# Fringe (current and next)
f0 = Tensor.fromUncompressed(["D"], [1, 0, 0, 0, 0, 0])
# Distance
d = Tensor(rank_ids=["S"])
# Get root fibers
a_s = a.getRoot()
f0_d = f0.getRoot()
d_d = d.getRoot()
print("BFS")
z_root_update_acks = UpdatePayloads(z_root, z_root_handles,
z_n1_new_fiber_handles)
# read in inputs
# jhu_len = 5157
shape = 500 # TODO: take this as input or get it from yaml somehow
# generate input frontier and tile it
A_data = [0] * shape
# read in frontier
with open(sys.argv[2], 'r') as f:
for line in f:
elt = int(line)
A_data[elt] = 1
A_untiled = Tensor.fromUncompressed(["S"], A_data, name="A")
A_HFA = A_untiled.splitUniform(32, relativeCoords=False) # split S
print("A untiled shape {}, tiled shape {}".format(A_untiled.getShape(),
A_HFA.getShape()))
# A_HFA.dump("tiled_frontier.yaml")
print("reading tiled mtx from yaml")
t0 = time.clock()
B_HFA = Tensor.fromYAMLfile(sys.argv[3])
t1 = time.clock() - t0
print("read B from yaml in {} s".format(t1))
# output
Z_data = [[0], [0]]
Z_HFA = Tensor.fromUncompressed(
["D1", "D0"],
