예제 #1
0
        def transform(self, tree, program_config):
            subconfig, tuning_config = program_config
            name_shape_map = {name: arg.shape for name, arg in subconfig.items()}
            shapes = set(name_shape_map.values())
            self.parent_cls.IndexOpToEncode(name_shape_map).visit(tree)
            encode_funcs = []
            c_tree = PyBasicConversions().visit(tree)
            # print(dump(c_tree))
            for shape in shapes:
                encode_funcs.append(generate_encode_macro('encode'+CCompiler._shape_to_str(shape), shape))
            components = []
            for target, ispace in zip(self.target_names, c_tree.body):
                shape = subconfig[target].shape
                sub = fill_iteration_spaces(ispace, shape)
                sub = self.parent_cls.IterationSpaceExpander(self.index_name, shape).visit(sub)
                sub = self.parent_cls.BlockConverter().visit(sub)
                components.append(sub)

            c_func = FunctionDecl(
                name=SymbolRef("kernel"),
                params=[
                    SymbolRef(name=arg_name, sym_type=get_ctype(
                        arg if not isinstance(arg, np.ndarray) else arg.ravel()
                    ), _restrict=True) for arg_name, arg in subconfig.items()
                ],
                defn=components
            )
            TilingOptimization().optimize(c_func, self.tile_size)
            includes = [
                CppInclude("stdint.h")
            ]
            out_file = CFile(body=includes + encode_funcs + [c_func])
            return out_file
예제 #2
0
 def visit_FunctionDef(self, node):
     self.decls = {}
     node.defn = [self.visit(s) for s in node.body]
     new_params = []
     for param in node.args.args:
         if sys.version_info > (3, 0):
             _id = param.arg
         else:
             _id = param.id
         if _id == 'self':
             continue
         value = self.symbol_table[_id]
         if isinstance(value, Array):
             _type = np.ctypeslib.ndpointer(
                 value.dtype, value.ndim, value.shape)()
         else:
             _type = get_ctype(value)
         new_params.append(
             C.SymbolRef(_id, _type))
     for name, value in self.decls.items():
         if isinstance(value, Array):
             type = np.ctypeslib.ndpointer(
                 value.dtype, value.ndim, value.shape)()
             value = value.ctypes.data
             new_params.append(
                 C.SymbolRef(name, type))
         else:
             if value is True:
                 value = 1
                 type = ct.c_int()
             elif value is False:
                 value = 0
                 type = ct.c_int()
             else:
                 type = get_ctype(value)
             node.body.insert(
                 0,
                 C.Assign(C.SymbolRef(name, type),
                          C.Constant(value)))
     node.args.args = new_params
     return node
예제 #3
0
 def visit_FunctionDef(self, node):
     self.decls = {}
     node.defn = [self.visit(s) for s in node.body]
     new_params = []
     for param in node.args.args:
         if sys.version_info > (3, 0):
             _id = param.arg
         else:
             _id = param.id
         if _id == 'self':
             continue
         value = self.symbol_table[_id]
         if isinstance(value, Array):
             _type = np.ctypeslib.ndpointer(value.dtype, value.ndim,
                                            value.shape)()
         else:
             _type = get_ctype(value)
         new_params.append(C.SymbolRef(_id, _type))
     for name, value in self.decls.items():
         if isinstance(value, Array):
             type = np.ctypeslib.ndpointer(value.dtype, value.ndim,
                                           value.shape)()
             value = value.ctypes.data
             new_params.append(C.SymbolRef(name, type))
         else:
             if value is True:
                 value = 1
                 type = ct.c_int()
             elif value is False:
                 value = 0
                 type = ct.c_int()
             else:
                 type = get_ctype(value)
             node.body.insert(
                 0, C.Assign(C.SymbolRef(name, type), C.Constant(value)))
     node.args.args = new_params
     return node
예제 #4
0
파일: hwacha.py 프로젝트: ucb-sejits/ctree
    def visit_For(self, node):
        if node.pragma == "ivdep":
            block = []
            loopvar = node.incr.arg
            size = node.test.right
            scalars = get_scalars_in_body(node)
            refs = get_array_references_in_body(node)
            ref_register_map = {}
            scalar_register_map = {}
            for index, ref in enumerate(refs):
                ref_register_map[str(ref)] = (ref, "va{}".format(index))
            for index, scalar in enumerate(scalars):
                reg = "vs{}".format(index)
                scalar_register_map[scalar] = reg
                self.type_map[reg] = get_ctype(scalar)
            body = []
            block.append(StringTemplate(hwacha_configure_block.format(SIZE=size)))

            node.incr = C.AddAssign(loopvar, C.SymbolRef("vector_length"))
            self.defns.append(get_asm_body(node, scalar_register_map,
                ref_register_map, self.type_map))
            block.append(node)

            body.append(StringTemplate(bounds_check.format(SIZE=size,
                loopvar=loopvar)))

            for scalar in scalars:
                body.append(scalar_init(scalar))

            body.append(StringTemplate(obtained_vector_length.format(SIZE=size,
                loopvar=loopvar)))

            block1 = ""
            block2 = ""
            index = 0
            for _, info in ref_register_map.items():
                ref, register = info
                block1 += "\t \"vmsa {0}, %{1}\\n\"\n".format(register, index)
                block2 += "\"r\"({0} + {1}),\n".format(
                    ref.left.name, ref.right.name)
                index += 1
            for scalar, register in scalar_register_map.items():
                block1 += "\t \"vmss {0}, %{1}\\n\"\n".format(register, index)
                block2 += "\"r\"({0}.i),\n".format(
                    "".join(number_dict[digit] for digit in str(scalar)))
                index += 1
            block1 += "\"fence\\n\"\n"
            block1 += "\"vf 0(%{0})\\n\"\n".format(index)
            block2 += "\"r\" (&__hwacha_body)"
            body.append(StringTemplate(
                """
__asm__ volatile(
{block1}
    :
    : {block2}
    : "memory"
);
                """.format(block1=block1, block2=block2)))

            node.body = body
            block.append(
StringTemplate("""
__asm__ volatile(
    "fence\\n"
);
"""))
            return block
예제 #5
0
파일: hwacha.py 프로젝트: ucb-sejits/ctree
 def visit_Constant(self, node):
     self.type_map[node.value] = get_ctype(node.value)
     return self.scalars[node.value]
예제 #6
0
 def get_type(self, env=None):
     return get_ctype(self.value)
예제 #7
0
 def test_bad_type(self):
     class Bad(object): pass
     with self.assertRaises(ValueError):
         ty = get_ctype(Bad())
예제 #8
0
 def test_bool(self):
     ty = get_ctype(True)
     self.assertIsInstance(ty, ctypes.c_bool)
예제 #9
0
 def test_char(self):
     ty = get_ctype("c")
     self.assertIsInstance(ty, ctypes.c_char)
예제 #10
0
 def args_to_subconfig(self, args):
     return {'arg_typesig': tuple(type(get_ctype(arg)) for arg in args)}
예제 #11
0
 def test_int_array_1d(self):
     ty = get_ctype(np.arange(10, dtype=np.int32))
     tree = SymbolRef("i", ty)
     self._check_code(tree, "int* i")
예제 #12
0
 def test_int_array_2d(self):
     ty = get_ctype(np.arange(10, dtype=np.float32).reshape(2, 5))
     tree = SymbolRef("i", ty)
     self._check_code(tree, "float** i")
예제 #13
0
 def test_int_array(self):
     ty = get_ctype(np.arange(10, dtype=np.int32))
     self.assertIsInstance(ty, _ctypes.Array)
예제 #14
0
 def test_int_array_1d(self):
     ty = get_ctype(np.arange(10, dtype=np.int32))
     tree = SymbolRef("i", ty)
     self._check_code(tree, "int* i")
예제 #15
0
 def test_int(self):
     ty = get_ctype(123)
     self.assertIsInstance(ty, ctypes.c_long)
예제 #16
0
 def test_float(self):
     ty = get_ctype(456.7)
     self.assertIsInstance(ty, ctypes.c_double)
예제 #17
0
파일: nodes.py 프로젝트: devvirus/CsvToJson
 def get_type(self):
     return get_ctype(self.value)
예제 #18
0
 def test_none(self):
     ty = get_ctype(None)
     self.assertIsInstance(ty, type(None))
예제 #19
0
 def args_to_subconfig(self, args):
     return {'arg_type': type(get_ctype(args[0]))}
예제 #20
0
 def test_string(self):
     self.assertIsInstance(get_ctype("foo"),     ctypes.c_char_p)
     self.assertIsInstance(get_ctype(""),        ctypes.c_char_p)
     self.assertIsInstance(get_ctype("one two"), ctypes.c_char_p)
예제 #21
0
파일: test_numpy.py 프로젝트: i-Zaak/ctree
 def test_int_array(self):
     ty = get_ctype(np.arange(10, dtype=np.int32))
     self.assertIsInstance(ty, _ctypes.Array)
예제 #22
0
파일: nodes.py 프로젝트: i-Zaak/ctree
 def get_type(self):
     return get_ctype(self.value)
예제 #23
0
파일: test_numpy.py 프로젝트: i-Zaak/ctree
 def test_int_array_2d(self):
     ty = get_ctype(np.arange(10, dtype=np.float32).reshape(2,5))
     tree = SymbolRef("i", ty)
     self._check_code(tree, "float** i")
 def args_to_subconfig(self, args):
     return {'arg_type': type(get_ctype(args[0]))}
예제 #25
0
 def get_type(self, env=None):
     return get_ctype(self.value)