Beispiel #1
0
    def test_offsets(self):
        sdfg = dace.SDFG('mapfission_offsets')
        sdfg.add_array('A', [20], dace.float64)
        sdfg.add_scalar('interim', dace.float64, transient=True)
        state = sdfg.add_state()
        me, mx = state.add_map('outer', dict(i='10:20'))

        t1 = state.add_tasklet('addone', {'a'}, {'b'}, 'b = a + 1')
        t2 = state.add_tasklet('addtwo', {'a'}, {'b'}, 'b = a + 2')

        aread = state.add_read('A')
        awrite = state.add_write('A')
        state.add_memlet_path(aread,
                              me,
                              t1,
                              dst_conn='a',
                              memlet=dace.Memlet.simple('A', 'i'))
        state.add_edge(t1, 'b', t2, 'a', dace.Memlet.simple('interim', '0'))
        state.add_memlet_path(t2,
                              mx,
                              awrite,
                              src_conn='b',
                              memlet=dace.Memlet.simple('A', 'i'))

        self.assertGreater(sdfg.apply_transformations(MapFission), 0)

        dace.propagate_labels_sdfg(sdfg)
        sdfg.validate()

        # Test
        A = np.random.rand(20)
        expected = A.copy()
        expected[10:] += 3
        sdfg(A=A)
        self.assertTrue(np.allclose(A, expected))
Beispiel #2
0
 def test_uneven(self):
     # For testing uneven decomposition, use longer buffer and ensure
     # it's not filled over
     output = np.ones(20, np.int32)
     sdfg = arange.to_sdfg()
     sdfg.apply_transformations([MapTiling, OutLocalStorage],
                                options=[{
                                    'tile_sizes': [5]
                                }, {}])
     dace.propagate_labels_sdfg(sdfg)
     sdfg(N=16, __return=output)
     self.assertTrue(
         np.array_equal(output[:16], np.arange(16, dtype=np.int32)))
     self.assertTrue(np.array_equal(output[16:], np.ones(4, np.int32)))
Beispiel #3
0
            # Gather inputs from entry node
            inputs = sum(e.data.num_accesses for e in state.in_edges(node)
                         if e not in edges_counted)
            # Do not count edges twice
            edges_counted |= set(state.in_edges(node))
            # Gather outputs from exit node
            exit_node = state.exit_nodes(node)[0]
            outputs = sum(e.data.num_accesses
                          for e in state.out_edges(exit_node)
                          if e not in edges_counted)
            edges_counted |= set(state.out_edges(exit_node))
            iprint('Scope',
                   type(node).__name__, node, 'inputs:', inputs, 'outputs:',
                   outputs)
            node_result += inputs + outputs
        result += node_result
    return result


if __name__ == '__main__':
    if len(sys.argv) != 2:
        print('USAGE: %s <SDFG FILE>' % sys.argv[0])
        exit(1)

    sdfg = dace.SDFG.from_file(sys.argv[1])
    print('Propagating memlets')
    dace.propagate_labels_sdfg(sdfg)
    print('Counting data movement')
    dm = count_moved_data(sdfg)
    print('Total data movement', dm)