Debian Codegraph @

rts/python/memory.py

raw
1 # Start of memory.py.
2
3 import ctypes as ct
4
5
6 def allocateMem(size):
7 return np.empty(size, dtype=np.byte)
8
9
10 # Copy an array if its is not-None. This is important for treating
11 # Numpy arrays as flat memory, but has some overhead.
12 def normaliseArray(x):
13 if (x.base is x) or (x.base is None):
14 return x
15 else:
16 return x.copy()
17
18
19 def unwrapArray(x):
20 return x.ravel().view(np.byte)
21
22
23 def indexArray(x, offset, bt):
24 return x.view(bt)[offset]
25
26
27 def writeScalarArray(x, offset, v):
28 x.view(type(v))[offset] = v
29
30
31 # An opaque Futhark value.
32 class opaque(object):
33 def __init__(self, desc, *payload):
34 self.data = payload
35 self.desc = desc
36
37 def __repr__(self):
38 return "<opaque Futhark value of type {}>".format(self.desc)
39
40
41 # LMAD stuff
42
43
44 def lmad_contiguous_search(checked, expected, strides, shape, used):
45 for i in range(len(strides)):
46 for j in range(len(strides)):
47 if not used[j] and strides[j] == expected and strides[j] >= 0:
48 used[j] = True
49 if checked + 1 == len(strides) or lmad_contiguous_search(
50 checked + 1, expected * shape[j], strides, shape, used
51 ):
52 return True
53 used[j] = False
54 return False
55
56
57 def lmad_contiguous(strides, shape):
58 used = len(strides) * [False]
59 return lmad_contiguous_search(0, 1, strides, shape, used)
60
61
62 def lmad_memcpyable(dst_strides, src_strides, shape):
63 if not lmad_contiguous(dst_strides, shape):
64 return False
65 for i in range(len(dst_strides)):
66 if dst_strides[i] != src_strides[i] and shape[i] != 1:
67 return False
68 return True
69
70
71 def lmad_is_tr(strides, shape):
72 r = len(shape)
73 for i in range(1, r):
74 n = 1
75 m = 1
76 ok = True
77 expected = 1
78 # Check strides before 'i'.
79 for j in range(i - 1, -1, -1):
80 ok = ok and strides[j] == expected
81 expected *= shape[j]
82 n *= shape[j]
83 # Check strides after 'i'.
84 for j in range(r - 1, i - 1, -1):
85 ok = ok and strides[j] == expected
86 expected *= shape[j]
87 m *= shape[j]
88 if ok:
89 return (n, m)
90 return None
91
92
93 def lmad_map_tr(dst_strides, src_strides, shape):
94 r = len(dst_strides)
95 rowmajor_strides = [0] * r
96 rowmajor_strides[r - 1] = 1
97
98 for i in range(r - 2, -1, -1):
99 rowmajor_strides[i] = rowmajor_strides[i + 1] * shape[i + 1]
100
101 # map_r will be the number of mapped dimensions on top.
102 map_r = 0
103 k = 1
104 for i in range(r):
105 if (
106 dst_strides[i] != rowmajor_strides[i]
107 or src_strides[i] != rowmajor_strides[i]
108 ):
109 break
110 else:
111 k *= shape[i]
112 map_r += 1
113
114 if rowmajor_strides[map_r:] == dst_strides[map_r:]:
115 r = lmad_is_tr(src_strides[map_r:], shape[map_r:])
116 if r is not None:
117 (n, m) = r
118 return (k, n, m)
119 elif rowmajor_strides[map_r:] == src_strides[map_r:]:
120 r = lmad_is_tr(dst_strides[map_r:], shape[map_r:])
121 if r is not None:
122 (n, m) = r
123 return (k, m, n) # Sic!
124 return None
125
126
127 def lmad_copy_elements(
128 pt, dst, dst_offset, dst_strides, src, src_offset, src_strides, shape
129 ):
130 if len(shape) == 1:
131 for i in range(shape[0]):
132 writeScalarArray(
133 dst,
134 dst_offset + i * dst_strides[0],
135 indexArray(src, src_offset + i * src_strides[0], pt),
136 )
137 else:
138 for i in range(shape[0]):
139 lmad_copy_elements(
140 pt,
141 dst,
142 dst_offset + i * dst_strides[0],
143 dst_strides[1:],
144 src,
145 src_offset + i * src_strides[0],
146 src_strides[1:],
147 shape[1:],
148 )
149
150
151 def lmad_copy(
152 pt, dst, dst_offset, dst_strides, src, src_offset, src_strides, shape
153 ):
154 if lmad_memcpyable(dst_strides, src_strides, shape):
155 dst[
156 dst_offset * ct.sizeof(pt) : dst_offset * ct.sizeof(pt)
157 + np.prod(shape) * ct.sizeof(pt)
158 ] = src[
159 src_offset * ct.sizeof(pt) : src_offset * ct.sizeof(pt)
160 + np.prod(shape) * ct.sizeof(pt)
161 ]
162 else:
163 lmad_copy_elements(
164 pt,
165 dst,
166 dst_offset,
167 dst_strides,
168 src,
169 src_offset,
170 src_strides,
171 shape,
172 )
173
174
175 # End of memory.py.