def generate_c_code(self, **kwargs): res = '' # include header res += '\n'.join([ c_helper.generate_local_include(h) for h in self.get_c_op_include_header() ]) res += '\n\n' # param type res += self.get_c_param_type() res += '\n\n' # 1 TemplateArrayAddLoop = c_helper.generate_ndim_for_loop( np.ones(self.output_tensor_shapes[0])) # 2 lcoal_var_name = '_output_val' indent = ' ' * 4 c_array = ', '.join([str(v) for v in self.output_tensor_values[0]]) TemplateConstValue = indent + 'int ' + lcoal_var_name + str( self.input_tensor_ndims) + '={' + c_array + '};' mapping = {} TemplateStatements = 'output[i] =' + lcoal_var_name + '[i];' mapping.update({'X': lcoal_var_name}) mapping.update({'Y': self.output_tensor_names[0]}) TemplateFunction = cleandoc(''' void {op_func_name}(void *op_param,{tx} input{XDims} , {ty} output{YDims}, void *inputs_params, void* outputs_params) {{ {statements1} {statements2} }} ''') mappingf = {} mappingf.update({'op_func_name': self.get_func_name()}) mappingf.update({ 'XDims': c_helper.generate_dim_bracket(self.input_tensor_shapes[0]) }) mappingf.update({ 'YDims': c_helper.generate_dim_bracket(self.output_tensor_shapes[0]) }) mappingf.update({'tx': data_type.np2c(self.input_tensor_dtypes[0])}) mappingf.update({'ty': data_type.np2c(self.output_tensor_dtypes[0])}) mappingf.update({'statements1': TemplateConstValue}) mappingf.update({ 'statements2': TemplateArrayAddLoop.replace('[statements]', TemplateStatements.format(**mapping)) }) res += '\n\n' res += TemplateFunction.format(**mappingf) return res
def generate_c_code(self, **kwargs): res = '' res += '\n'.join([ c_helper.generate_local_include(h) for h in self.get_c_op_include_header() ]) res += '\n\n' # param type res += self.get_c_param_type() res += '\n\n' # 1 TemplateArrayDropoutLoop = c_helper.generate_ndim_for_loop( np.ones(self.output_tensor_shapes[0])) TemplateStatements = ''' output{dims} = ((high - low) * rand()/RAND_MAX ) - low; ''' mapping = {} mapping.update({ 'dims': ''.join([ '[' + v + ']' for v in string.ascii_lowercase[8:8 + self.output_tensor_ndims[0]] ]) }) # 3 TemplateFunction = cleandoc(''' void {op_func_name}(void *op_param, {t_in} data{dims}, {t_out} output{dims}, void *inputs_params, void* outputs_params) {{ const float high = {high}; const float low = {low}; {statements} }} ''') mappingf = {} mappingf.update({'op_func_name': self.get_func_name()}) mappingf.update({ 'dims': c_helper.generate_dim_bracket(self.output_tensor_shapes[0]) }) mappingf.update({'t_in': data_type.np2c(self.input_tensor_dtypes[0])}) mappingf.update( {'t_out': data_type.np2c(self.output_tensor_dtypes[0])}) mappingf.update({'high': self.attrs.get('high', 1.0)}) mappingf.update({'low': self.attrs.get('low', 0.0)}) mappingf.update({ 'statements': TemplateArrayDropoutLoop.replace( '[statements]', TemplateStatements.format(**mapping)) }) res += '\n\n' res += TemplateFunction.format(**mappingf) return res
def generate_c_code(self, **kwargs): res ='' # include header res += '\n'.join([c_helper.generate_local_include(h) for h in self.get_c_op_include_header()]) res +='\n\n' # param type res += self.get_c_param_type() res +='\n\n' # 1 TemplateArrayAddLoop = c_helper.generate_ndim_for_loop(np.ones(self.output_tensor_shapes[0])) # 2 TemplateStatements = '{Y}{StatementDims} = {c_abs}({X}{StatementDims});' mapping = {} mapping.update({'X': self.input_tensor_names[0]}) mapping.update({'Y': self.output_tensor_names[0]}) StatementDims = '' for _, step in zip_longest(self.input_tensor[0].shape[::-1], reversed(string.ascii_lowercase[8:8 + self.output_tensor_ndims[0]])): StatementDims = '[{0}]'.format(step) + StatementDims mapping.update({'StatementDims': StatementDims}) out_c_type = data_type.np2c(self.output_tensor_dtypes[0]) if out_c_type.startswith('double'): mapping.update({'c_abs': 'fabs'}) elif out_c_type.startswith('float'): mapping.update({'c_abs': 'fabsf'}) elif out_c_type.startswith('int'): mapping.update({'c_abs': 'fabsf'}) else: raise ValueError('{0} is not supported'.format(out_c_type)) TemplateFunction = cleandoc(''' void {op_func_name}(void *op_param,{t} {X}{Dims} , {t} {Y}{Dims}, void *inputs_params, void* outputs_params) {{ {statements} }} ''') mappingf = {} mappingf.update({'op_func_name': self.get_func_name()}) mappingf.update({'X': self.input_tensor_names[0]}) mappingf.update({'Y': self.output_tensor_names[0]}) mappingf.update({'Dims':c_helper.generate_dim_bracket(self.input_tensor_shapes[0])}) mappingf.update({'Dims': c_helper.generate_dim_bracket(self.output_tensor_shapes[0])}) mappingf.update({'t': data_type.np2c(self.output_tensor_dtypes[0])}) mappingf.update({'statements': TemplateArrayAddLoop.replace('[statements]', TemplateStatements.format(**mapping))}) res += '\n\n' res += TemplateFunction.format(**mappingf) return res
def generate_c_code(self, **kwargs): res = '' res += '\n'.join([ c_helper.generate_local_include(h) for h in self.get_c_op_include_header() ]) res += '\n\n' # param type res += self.get_c_param_type() res += '\n\n' # 1 TemplateArrayExpLoop = c_helper.generate_ndim_for_loop( np.ones(self.output_tensor_shapes[0]), pragma=self.OpenMP) if self.OpenMP: TemplateArrayExpLoop = TemplateArrayExpLoop.replace( '[pragma]', self.PRAGMA_OMP) # 2 TemplateStatements = ''' Y{dims} = exp(X{dims}); ''' mapping = {} mapping.update({ 'dims': ''.join([ '[' + v + ']' for v in string.ascii_lowercase[8:8 + self.output_tensor_ndims[0]] ]) }) # 3 TemplateFunction = cleandoc(''' void {op_func_name}(void *op_param, {t} X{dims}, {t} Y{dims}, void *inputs_params, void* outputs_params) {{ {statements} }} ''') mappingf = {} mappingf.update({'op_func_name': self.get_func_name()}) mappingf.update({ 'dims': c_helper.generate_dim_bracket(self.output_tensor_shapes[0]) }) mappingf.update({'t': data_type.np2c(self.output_tensor_dtypes[0])}) mappingf.update({ 'statements': TemplateArrayExpLoop.replace('[statements]', TemplateStatements.format(**mapping)) }) res += '\n\n' res += TemplateFunction.format(**mappingf) return res
def generate_c_code(self, **kwargs): res = '' # include header res += '\n'.join([ c_helper.generate_local_include(h) for h in self.get_c_op_include_header() ]) res += '\n\n' # param type res += self.get_c_param_type() res += '\n\n' # 1 TemplateArrayTransposeLoop = c_helper.generate_ndim_for_loop( np.ones(self.output_tensor_shapes[0]), pragma=self.OpenMP) if self.OpenMP: TemplateArrayTransposeLoop = TemplateArrayTransposeLoop.replace( '[pragma]', self.PRAGMA_OMP) TemplateFunction = cleandoc(''' void {op_func_name}(void *op_param, {t} {X}{XDims}, {t} {C}{CDims}, void *inputs_params, void* outputs_params) {{ {statements} }} ''') mappingf = {} mappingf.update({'op_func_name': self.get_func_name()}) mappingf.update({'X': self.input_tensor_names[0]}) mappingf.update({'C': self.output_tensor_names[0]}) mappingf.update({ 'XDims': c_helper.generate_dim_bracket(self.input_tensor_shapes[0]) }) mappingf.update({ 'CDims': c_helper.generate_dim_bracket(self.output_tensor_shapes[0]) }) mappingf.update({'t': data_type.np2c(self.output_tensor_dtypes[0])}) mappingf.update({ 'statements': TemplateArrayTransposeLoop.replace('[statements]', self.generate_kernel_code()) }) res += '\n\n' res += TemplateFunction.format(**mappingf) return res
def generate_c_code(self, **kwargs): res = '' res += '\n'.join([ c_helper.generate_local_include(h) for h in self.get_c_op_include_header() ]) res += '\n\n' # param type res += self.get_c_param_type() res += '\n\n' # 1 TemplateArrayLeakyReluLoop = c_helper.generate_ndim_for_loop( np.ones(self.output_tensor_shapes[0]), pragma=self.OpenMP) if self.OpenMP: TemplateArrayLeakyReluLoop = TemplateArrayLeakyReluLoop.replace( '[pragma]', self.PRAGMA_OMP) TemplateFunction = cleandoc(''' void {op_func_name}(void *op_param, {t} {X}{dims}, {t} {Y}{dims}, void *inputs_params, void* outputs_params) {{ LeakyReluOpParam *param_ptr = (LeakyReluOpParam *)op_param; const {t} alpha = {alpha}; {statements} }} ''') mappingf = {} mappingf.update({'op_func_name': self.get_func_name()}) mappingf.update({ 'dims': c_helper.generate_dim_bracket(self.output_tensor_shapes[0]) }) mappingf.update({'t': data_type.np2c(self.output_tensor_dtypes[0])}) mappingf.update({'alpha': self.attrs['alpha']}) mappingf.update({'X': self.input_tensor_names[0]}) mappingf.update({'Y': self.output_tensor_names[0]}) mappingf.update({ 'statements': TemplateArrayLeakyReluLoop.replace( '[statements]', self.generate_kernel_code(alpha_variable_value=False)) }) res += '\n\n' res += TemplateFunction.format(**mappingf) return res
def generate_c_code(self, **kwargs): res ='' # include header res += '\n'.join([c_helper.generate_local_include(h) for h in self.get_c_op_include_header()]) res +='\n\n' # param type res += self.get_c_param_type() res +='\n\n' # 1 TemplateArrayAddLoop = c_helper.generate_ndim_for_loop(np.empty(self.output_tensor_shapes[0]),indent=0) # 2 input_vals = OrderedDict({k: self._gen_array_element_val(self.output_tensor_ndims[0], v) for k, v in self.input_tensor_dict.items()}) output_vals = {self.output_tensor_names[0]: self._gen_array_element_val(self.output_tensor_ndims[0], self.output_tensor_values[0])} Conditions = '' MeanStatement = '' TemplateCondition = cleandoc(''' {t} sum = 0.0f; int num = 0; {conditions} {indent}{outputVal} = sum/num; ''') TemplateCompare = cleandoc(''' {indent}num++; {indent}sum += {input}; ''') for k, v in input_vals.items(): Conditions += TemplateCompare.format(**{'input': k + v, 'indent': ' ' * 4 * (self.input_tensor_ndims[0] + 1)}) Conditions += '\n' else: mapping_cond ={'t': data_type.np2c(self.input_tensor_dtypes[0])} mapping_cond.update({'conditions': Conditions}) mapping_cond.update({'outputVal': list(output_vals.keys())[0] + list(output_vals.values())[0]}) mapping_cond.update({'indent': ' ' * 4 * (self.output_tensor_ndims[0] + 1)}) MeanStatement += TemplateCondition.format(**mapping_cond) TemplateFunction = cleandoc(''' void {op_func_name}(void *op_param,{InputsParamSignature}, {OutputsParamSignature}, void *inputs_params, void* outputs_params) {{ {statements} }} ''') mappingf = {} mappingf.update({'op_func_name': self.get_func_name()}) input_sigs = [] for name, value in self.input_tensor_dict.items(): input_sigs.append(self.gen_param_signature(name, value)) mappingf.update({'InputsParamSignature':','.join(input_sigs)}) mappingf.update({'OutputsParamSignature': self.gen_param_signature(self.output_tensor_names[0], self.output_tensor_values[0])}) mappingf.update({'statements': TemplateArrayAddLoop.replace('[statements]', MeanStatement)}) res += '\n\n' res += TemplateFunction.format(**mappingf) return res
def generate_c_code(self, **kwargs): res = '' # include header res += '\n'.join([ c_helper.generate_local_include(h) for h in self.get_c_op_include_header() ]) res += '\n\n' # param type res += self.get_c_param_type() res += '\n\n' res += self.get_op_variale_def() res += '\n\n' # 1 TemplateArrayAddLoop = c_helper.generate_ndim_for_loop( np.empty(self.output_tensor_shapes[0]), pragma=self.OpenMP) if self.OpenMP: TemplateArrayAddLoop = TemplateArrayAddLoop.replace( '[pragma]', self.PRAGMA_OMP) # 2 mapping = {} # TemplateStatements = 'temp_arr{CStatementDims} = ROUND({X}{XStatementDims} / {Y}{YStatementDims}) + {Z}{ZStatementDims};\n' # # if data_type.np2c(self.output_tensor_dtypes[0]) == 'uint8_t': # TemplateStatements += ' {C}{CStatementDims} = CLAMP(temp_arr{CStatementDims}, 0, 255);\n' # else: # TemplateStatements += ' {C}{CStatementDims} = CLAMP(temp_arr{CStatementDims}, -127, 128);\n' if data_type.np2c(self.output_tensor_dtypes[0]) == 'uint8_t': TemplateStatements = '{C}{CStatementDims} = CLAMP(ROUND({X}{XStatementDims} / {Y}{YStatementDims}) + {Z}{ZStatementDims}, 0, 255);\n' else: TemplateStatements = '{C}{CStatementDims} = CLAMP(ROUND({X}{XStatementDims} / {Y}{YStatementDims}) + {Z}{ZStatementDims}, -127, 128);\n' mapping.update({'X': self.input_tensor_names[0]}) mapping.update({'Y': self.input_tensor_names[1]}) mapping.update({'Z': self.input_tensor_names[2]}) mapping.update({'C': self.output_tensor_names[0]}) XStatementDims = '' YStatementDims = '' ZStatementDims = '' CStatementDims = '' X, Y, Z = self.input_tensor_values for element_num_x, element_num_y, element_num_z, step in zip_longest( X.shape[::-1], Y.shape[::-1], Z.shape[::-1], reversed(string.ascii_lowercase[8:8 + self.output_tensor_ndims[0]])): if element_num_x is not None: if element_num_x == 1: XStatementDims = '[0]' + XStatementDims else: XStatementDims = '[{0}]'.format(step) + XStatementDims if element_num_y is not None: if element_num_y == 1: YStatementDims = '[0]' + YStatementDims else: YStatementDims = '[{0}]'.format(step) + YStatementDims if element_num_z is not None: if element_num_z == 1: ZStatementDims = '[0]' + ZStatementDims else: ZStatementDims = '[{0}]'.format(step) + ZStatementDims CStatementDims = '[{0}]'.format(step) + CStatementDims mapping.update({'XStatementDims': XStatementDims}) mapping.update({'YStatementDims': YStatementDims}) mapping.update({'ZStatementDims': ZStatementDims}) mapping.update({'CStatementDims': CStatementDims}) TemplateFunction = cleandoc(''' void {op_func_name}(void *op_param,{x_type} {X}{XDims} , {y_type} {Y}{YDims}, {z_type} {Z}{ZDims}, {c_type} {C}{CDims}, void *inputs_params, void* outputs_params) {{ {statements} }} ''') mappingf = {} mappingf.update({'op_func_name': self.get_func_name()}) mappingf.update({'X': self.input_tensor_names[0]}) mappingf.update({'Y': self.input_tensor_names[1]}) mappingf.update({'Z': self.input_tensor_names[2]}) mappingf.update({'C': self.output_tensor_names[0]}) mappingf.update({ 'XDims': c_helper.generate_dim_bracket(self.input_tensor_shapes[0]) }) mappingf.update({ 'YDims': c_helper.generate_dim_bracket(self.input_tensor_shapes[1]) }) mappingf.update({ 'ZDims': c_helper.generate_dim_bracket(self.input_tensor_shapes[2]) }) mappingf.update({ 'CDims': c_helper.generate_dim_bracket(self.output_tensor_shapes[0]) }) mappingf.update( {'x_type': data_type.np2c(self.node.input_tensor_values[0].dtype)}) mappingf.update( {'y_type': data_type.np2c(self.node.input_tensor_values[1].dtype)}) mappingf.update( {'z_type': data_type.np2c(self.node.input_tensor_values[2].dtype)}) mappingf.update( {'c_type': data_type.np2c(self.output_tensor_dtypes[0])}) mappingf.update({ 'statements': TemplateArrayAddLoop.replace('[statements]', TemplateStatements.format(**mapping)) }) res += '\n\n' res += TemplateFunction.format(**mappingf) return res
def generate_c_code(self, **kwargs): res = '' # include header res += '\n'.join([ c_helper.generate_local_include(h) for h in self.get_c_op_include_header() ]) res += '\n\n' # param type res += self.get_c_param_type() res += '\n\n' # 1 TemplateArrayAddLoop = c_helper.generate_ndim_for_loop( np.ones(self.output_tensor_shapes[0])) # 2 mapping = {} TemplateStatements = '{C}{CStatementDims} = {X}{XStatementDims} ^ {Y}{YStatementDims};' mapping.update({'X': self.input_tensor_names[0]}) mapping.update({'Y': self.input_tensor_names[1]}) mapping.update({'C': self.output_tensor_names[0]}) XStatementDims = '' YStatementDims = '' CStatementDims = '' X, Y = self.input_tensor_values for element_num_x, element_num_y, step in zip_longest( X.shape[::-1], Y.shape[::-1], reversed(string.ascii_lowercase[8:8 + self.output_tensor_ndims[0]])): if element_num_x is not None: if element_num_x == 1: XStatementDims = '[0]' + XStatementDims else: XStatementDims = '[{0}]'.format(step) + XStatementDims if element_num_y is not None: if element_num_y == 1: YStatementDims = '[0]' + YStatementDims else: YStatementDims = '[{0}]'.format(step) + YStatementDims CStatementDims = '[{0}]'.format(step) + CStatementDims mapping.update({'XStatementDims': XStatementDims}) mapping.update({'YStatementDims': YStatementDims}) mapping.update({'CStatementDims': CStatementDims}) TemplateFunction = cleandoc(''' void {op_func_name}(void *op_param,{t} {X}{XDims} , {t} {Y}{YDims}, {t} {C}{CDims}, void *inputs_params, void* outputs_params) {{ {statements} }} ''') mappingf = {} mappingf.update({'op_func_name': self.get_func_name()}) mappingf.update({'X': self.input_tensor_names[0]}) mappingf.update({'Y': self.input_tensor_names[1]}) mappingf.update({'C': self.output_tensor_names[0]}) mappingf.update({ 'XDims': c_helper.generate_dim_bracket(self.input_tensor_shapes[0]) }) mappingf.update({ 'YDims': c_helper.generate_dim_bracket(self.input_tensor_shapes[1]) }) mappingf.update({ 'CDims': c_helper.generate_dim_bracket(self.output_tensor_shapes[0]) }) mappingf.update({'t': data_type.np2c(self.output_tensor_dtypes[0])}) mappingf.update({ 'statements': TemplateArrayAddLoop.replace('[statements]', TemplateStatements.format(**mapping)) }) res += '\n\n' res += TemplateFunction.format(**mappingf) return res
def generate_c_code(self, **kwargs): axis = self.attrs['axis'] data_ndims = self.input_tensor_ndims[0] output_ndims = self.output_tensor_ndims[0] indices_ndims = self.input_tensor_ndims[1] res = '' # include header res += '\n'.join([ c_helper.generate_local_include(h) for h in self.get_c_op_include_header() ]) res += '\n\n' # param type res += self.get_c_param_type() res += '\n\n' textwrap.TextWrapper() TemplateKernel = textwrap.indent(""" if ({array_indices}>= 0) {{ {array_output}= {array_data}; }} else {{ {array_output} = 0.0; }} """, prefix=" " * 4 * output_ndims) TemplateLoop = c_helper.generate_ndim_for_loop( np.ones(self.output_tensor_shapes[0])) array_right_data = ''.join( ['[' + v + ']' for v in string.ascii_lowercase[8:8 + axis]]) array_left_data = ''.join([ '[' + v + ']' for v in string.ascii_lowercase[9 + axis + indices_ndims - 1:8 + data_ndims + indices_ndims - 1] ]) array_indices = "indices" + "".join([ '[' + v + ']' for v in string.ascii_lowercase[8 + axis:8 + axis + indices_ndims] ]) array_data = "data" + array_right_data + '[' + array_indices + ']' + array_left_data array_output = "output" + ''.join([ '[' + v + ']' for v in string.ascii_lowercase[8:8 + output_ndims] ]) mapping_kernel = {} mapping_kernel.update({"array_data": array_data}) mapping_kernel.update({"array_indices": array_indices}) mapping_kernel.update({"array_output": array_output}) # 3 TemplateFunction = cleandoc(''' void {op_func_name}(void *op_param, {t1} data{dims_data}, {t2} indices{dims_indices}, {t1} output{dims_output}, void *inputs_params, void* outputs_params) {{ {loop_statements} }} ''') mappingf = {} mappingf.update({'op_func_name': self.get_func_name()}) mappingf.update({ 'dims_data': c_helper.generate_dim_bracket(self.input_tensor_shapes[0]) }) mappingf.update({ 'dims_indices': c_helper.generate_dim_bracket(self.input_tensor_shapes[1]) }) mappingf.update({ 'dims_output': c_helper.generate_dim_bracket(self.output_tensor_shapes[0]) }) mappingf.update({'t1': data_type.np2c(self.output_tensor_dtypes[0])}) mappingf.update({'t2': data_type.np2c(self.input_tensor_dtypes[1])}) mappingf.update({ 'loop_statements': TemplateLoop.replace('[statements]', TemplateKernel.format(**mapping_kernel)) }) res += '\n\n' res += TemplateFunction.format(**mappingf) return res
def generate_c_code(self, **kwargs): res = '' res += '\n'.join([ c_helper.generate_local_include(h) for h in self.get_c_op_include_header() ]) res += '\n\n' # param type res += self.get_c_param_type() res += '\n\n' ratio = self.attrs.get('ratio', 0.5) # 1 TemplateArrayDropoutLoop = c_helper.generate_ndim_for_loop( np.ones(self.output_tensor_shapes[0])) TemplateStatements = ''' if (random() > RAND_MAX * ratio) {{ output{dims} = data{dims}; }} else {{ output{dims} = 0.0; }} ''' mapping = {} mapping.update({ 'dims': ''.join([ '[' + v + ']' for v in string.ascii_lowercase[8:8 + self.output_tensor_ndims[0]] ]) }) # 3 TemplateFunction = cleandoc(''' void {op_func_name}(void *op_param, {t} data{dims}, {t} output{dims}, void *inputs_params, void* outputs_params) {{ const float ratio = {ratio}; {statements} }} ''') mappingf = {} mappingf.update({'op_func_name': self.get_func_name()}) mappingf.update({ 'dims': c_helper.generate_dim_bracket(self.output_tensor_shapes[0]) }) mappingf.update({'t': data_type.np2c(self.output_tensor_dtypes[0])}) mappingf.update({'ratio': ratio}) mappingf.update({ 'statements': TemplateArrayDropoutLoop.replace( '[statements]', TemplateStatements.format(**mapping)) }) res += '\n\n' res += TemplateFunction.format(**mappingf) return res
def generate_c_code(self, **kwargs): res = '' # include header res += '\n'.join([ c_helper.generate_local_include(h) for h in self.get_c_op_include_header() ]) res += '\n\n' # param type res += self.get_c_param_type() res += '\n\n' # 1 TemplateArrayAddLoop = c_helper.generate_ndim_for_loop(np.ones( self.output_tensor_shapes[0]), indent=0) # 2 input_vals = OrderedDict({ k: self._gen_array_element_val(self.output_tensor_ndims[0], v) for k, v in self.input_tensor_dict.items() }) output_vals = { self.output_tensor_names[0]: self._gen_array_element_val(self.output_tensor_ndims[0], self.output_tensor_values[0]) } TemplateSumExpression = cleandoc(''' {indent}{outputVal} = {sum_expression}; ''') mapping = {} mapping.update({'indent': ' ' * 4 * (self.output_tensor_ndims[0] + 1)}) mapping.update({ 'outputVal': list(output_vals.keys())[0] + list(output_vals.values())[0] }) mapping.update({ 'sum_expression': '+'.join([k + v for k, v in input_vals.items()]) }) SubStatement = TemplateSumExpression.format(**mapping) TemplateFunction = cleandoc(''' void {op_func_name}(void *op_param,{InputsParamSignature}, {OutputsParamSignature}, void *inputs_params, void* outputs_params) {{ {statements} }} ''') mappingf = {} mappingf.update({'op_func_name': self.get_func_name()}) input_sigs = [] for name, value in self.input_tensor_dict.items(): input_sigs.append(self.gen_param_signature(name, value)) mappingf.update({'InputsParamSignature': ','.join(input_sigs)}) mappingf.update({ 'OutputsParamSignature': self.gen_param_signature(self.output_tensor_names[0], self.output_tensor_values[0]) }) mappingf.update({ 'statements': TemplateArrayAddLoop.replace('[statements]', SubStatement) }) res += '\n\n' res += TemplateFunction.format(**mappingf) return res
def generate_c_code(self, **kwargs): b_min = 0 b_max = 0 input_array_boundary = [] for (_, d) in enumerate(self.input_tensor_shapes): b_max += d[self.attrs['axis']] input_array_boundary.append( (self.input_tensor_names[_], b_min, b_max)) b_min = b_max loop_idx = string.ascii_lowercase[8:8 + self.output_tensor_ndims[0]] concat_idx = loop_idx[self.attrs['axis']] res = '' # include header res += '\n'.join([ c_helper.generate_local_include(h) for h in self.get_c_op_include_header() ]) res += '\n\n' # param type res += self.get_c_param_type() res += '\n\n' # 1 TemplateArrayConcatLoop = c_helper.generate_ndim_for_loop(np.ones( self.output_tensor_shapes[0]), indent=0) # 2 input_vals = OrderedDict({ k: self._gen_array_element_val(self.output_tensor_ndims[0], v) for k, v in self.input_tensor_dict.items() }) output_vals = { self.output_tensor_names[0]: self._gen_array_element_val(self.output_tensor_ndims[0], self.output_tensor_values[0]) } Conditions = '' ConcatStatement = '' TemplateConditionElement = cleandoc(''' {if} ({concat_idx} < {concat_boundary}) {{ {indent} {outputVal} = {inputVal}; {indent}}} ''') for (i, boundary) in enumerate(input_array_boundary): mapping_cond_element = { 't': data_type.np2c(self.input_tensor_dtypes[0]) } mapping_cond_element.update({'concat_idx': concat_idx}) mapping_cond_element.update( {'indent': ' ' * 4 * (self.output_tensor_ndims[0] + 1)}) # mapping_cond_element.update({'inputVal': list(input_vals.keys())[i] + list(input_vals.values())[i]}) # list(val.keys()) の順番がordered_dictに従わず、安定しないため、別に持っている変数boundary順に変更 input_axis_idx = input_vals[boundary[0]] input_axis_idx = input_axis_idx.replace( concat_idx, concat_idx + '-' + str(boundary[1])) mapping_cond_element.update( {'inputVal': boundary[0] + input_axis_idx}) mapping_cond_element.update({ 'outputVal': list(output_vals.keys())[0] + list(output_vals.values())[0] }) mapping_cond_element.update({'concat_boundary': boundary[2]}) if (i == 0): mapping_cond_element.update( {'if': ' ' * 4 * (self.output_tensor_ndims[0] + 1) + 'if'}) else: mapping_cond_element.update({'if': 'else if'}) ConcatStatement += TemplateConditionElement.format( **mapping_cond_element) TemplateFunction = cleandoc(''' void {op_func_name}(void *op_param,{InputsParamSignature}, {OutputsParamSignature}, void *inputs_params, void* outputs_params) {{ {statements} }} ''') mappingf = {} mappingf.update({'op_func_name': self.get_func_name()}) input_sigs = [] for name, value in self.input_tensor_dict.items(): input_sigs.append(self.gen_param_signature(name, value)) mappingf.update({'InputsParamSignature': ','.join(input_sigs)}) mappingf.update({ 'OutputsParamSignature': self.gen_param_signature(self.output_tensor_names[0], self.output_tensor_values[0]) }) mappingf.update({ 'statements': TemplateArrayConcatLoop.replace('[statements]', ConcatStatement) }) res += '\n\n' res += TemplateFunction.format(**mappingf) return res
def generate_c_code(self, **kwargs): axis = self.attrs['axis'] value_ndims = self.output_tensor_ndims[0] value_shapes = self.output_tensor_shapes[0] res = '' res += '\n'.join([ c_helper.generate_local_include(h) for h in self.get_c_op_include_header() ]) res += '\n\n' # param type res += self.get_c_param_type() res += '\n\n' TemplateStatements = ''' const int axis = {axis}; const int largest = {largest}; const int sorted = {sorted}; const int X_shape[] = {X_shape}; const int K_val = K[0]; const int Values_shape[] = {Values_shape}; const int Indices_shape[] = {Indices_shape}; int sorted_indices{dims_X}; ''' mapping = {} mapping.update({'op_func_name': self.get_func_name()}) mapping.update({'axis': self.attrs['axis']}) mapping.update({'largest': self.attrs['largest']}) mapping.update({'sorted': self.attrs['sorted']}) mapping.update({ 'dims_X': c_helper.generate_dim_bracket(self.input_tensor_shapes[0]) }) mapping.update({ 'X_shape': str(self.input_tensor_shapes[0]).replace('(', '{').replace(')', '}') }) mapping.update({ 'Values_shape': str(self.output_tensor_shapes[0]).replace('(', '{').replace(')', '}') }) mapping.update({ 'Indices_shape': str(self.output_tensor_shapes[1]).replace('(', '{').replace(')', '}') }) mapping.update( {'target_range': self.input_tensor_shapes[0][self.attrs['axis']]}) mapping.update({'t': data_type.np2c(self.output_tensor_dtypes[0])}) TemplatePreProcessLoop = c_helper.generate_ndim_for_loop( np.ones(self.input_tensor_shapes[0])) TemplatePreProcessCore = ''' sorted_indices{dims_all} = {target_rank}; ''' TemplateArrayLoopLeft = c_helper.generate_ndim_for_loop( np.ones(self.output_tensor_shapes[0][0:axis + 1])) if ( axis >= 0) else '[statements]' TemplateArrayLoopRight = c_helper.generate_ndim_for_loop( np.ones(self.output_tensor_shapes[0][axis + 1:]), gen=iter(string.ascii_lowercase[9 + axis:])) if ( axis < value_ndims - 1) else '[statements]' TemplateLoopCore = ''' for (int z={target_rank}+1; z<{target_range}; z++) {{ ''' if (self.attrs['largest'] == 1): TemplateLoopCore += ''' if (X{dims_left}[sorted_indices{dims_left}[{target_rank}]{dims_right}]{dims_right} < X{dims_left}[sorted_indices{dims_left}[z]{dims_right}]{dims_right}) {{ ''' else: TemplateLoopCore += ''' if (X{dims_left}[sorted_indices{dims_left}[{target_rank}]{dims_right}]{dims_right} > X{dims_left}[sorted_indices{dims_left}[z]{dims_right}]{dims_right}) {{ ''' TemplateLoopCore += ''' int tmp_idx = sorted_indices{dims_all}; sorted_indices{dims_all} = sorted_indices{dims_left}[z]{dims_right}; sorted_indices{dims_left}[z]{dims_right} = tmp_idx; }} }} ''' mapping_loop = {} mapping_loop.update({ 'dims_all': ''.join([ '[' + v + ']' for v in string.ascii_lowercase[8:8 + value_ndims] ]) }) mapping_loop.update({ 'dims_left': ''.join( ['[' + v + ']' for v in string.ascii_lowercase[8:8 + axis]]) }) mapping_loop.update({ 'dims_right': ''.join([ '[' + v + ']' for v in string.ascii_lowercase[9 + axis:8 + value_ndims] ]) }) mapping_loop.update( {'target_range': self.input_tensor_shapes[0][axis]}) mapping_loop.update({'target_rank': string.ascii_lowercase[8 + axis]}) TemplatePostProcessLoop = c_helper.generate_ndim_for_loop( np.ones(self.output_tensor_shapes[0])) TemplatePostProcessCore = ''' Values{dims_all} = X{dims_left}[sorted_indices{dims_left}[{target_rank}]{dims_right}]{dims_right}; Indices{dims_all} = sorted_indices{dims_left}[{target_rank}]{dims_right}; ''' # 3 TemplateFunction = cleandoc(''' void {op_func_name}(void *op_param, {t} X{dims_X}, long long int K[], {t} Values{dims_Values}, long long int Indices{dims_Indices}, void *inputs_params, void* outputs_params) {{ {pre_statements} {preloop_statements} {loop_statements} {postloop_statements} }} ''') mappingf = {} mappingf.update({'op_func_name': self.get_func_name()}) mappingf.update({ 'dims_X': c_helper.generate_dim_bracket(self.input_tensor_shapes[0]) }) mappingf.update({ 'dims_Values': c_helper.generate_dim_bracket(self.output_tensor_shapes[0]) }) mappingf.update({ 'dims_Indices': c_helper.generate_dim_bracket(self.output_tensor_shapes[1]) }) mappingf.update({'t': data_type.np2c(self.output_tensor_dtypes[0])}) mappingf.update( {'pre_statements': TemplateStatements.format(**mapping)}) mappingf.update({ 'preloop_statements': TemplatePreProcessLoop.replace( '[statements]', TemplatePreProcessCore.format(**mapping_loop)) }) mappingf.update({ 'loop_statements': TemplateArrayLoopLeft.replace( '[statements]', TemplateArrayLoopRight.replace( '[statements]', TemplateLoopCore.format(**mapping_loop))) }) mappingf.update({ 'postloop_statements': TemplatePostProcessLoop.replace( '[statements]', TemplatePostProcessCore.format(**mapping_loop)) }) res += '\n\n' res += TemplateFunction.format(**mappingf) return res
def generate_c_code(self, **kwargs): res = "" res += "\n".join([ c_helper.generate_local_include(h) for h in self.get_c_op_include_header() ]) res += "\n\n" # param type res += self.get_c_param_type() res += "\n\n" # 1 TemplateArrayFuseLoop = c_helper.generate_ndim_for_loop( np.empty(self.output_tensor_shapes[0]), pragma=self.OpenMP) if self.OpenMP: TemplateArrayFuseLoop = TemplateArrayFuseLoop.replace( "[pragma]", self.PRAGMA_OMP) # param type res += self.get_c_param_type() res += "\n\n" premap = self.prev_node.op.generate_kernel_map() # transpose postmap = self.post_node.op.generate_kernel_map() postmap.update({"X": premap["X"]}) postmap.update({"XStatementDims": premap["XStatementDims"]}) template = self.post_node.op.generate_kernel_template() statements = template.format(**postmap) # 3 post_input_count = len(self.post_node.input_tensor) if post_input_count == 1: TemplateFunction = cleandoc(""" void {op_func_name}(void *op_param, {t} {X}{dims_i}, {t} {C}{dims_o}, void *inputs_params, void* outputs_params) {{ {statements} }} """) mappingf = {} mappingf.update({"op_func_name": self.get_func_name()}) mappingf.update({ "dims_i": c_helper.generate_dim_bracket(self.input_tensor_shapes[0]) }) mappingf.update({ "dims_o": c_helper.generate_dim_bracket(self.output_tensor_shapes[0]) }) mappingf.update( {"t": data_type.np2c(self.output_tensor_dtypes[0])}) mappingf.update({"X": self.input_tensor_names[0]}) mappingf.update({"C": self.output_tensor_names[0]}) mappingf.update({ "statements": TemplateArrayFuseLoop.replace("[statements]", statements) }) res += "\n\n" res += TemplateFunction.format(**mappingf) elif post_input_count == 2: TemplateFunction = cleandoc(""" void {op_func_name}(void *op_param, {t} {X1}{dims_i1}, {t} {X2}{dims_i2}, {t} {C}{dims_o}, void *inputs_params, void* outputs_params) {{ {statements} }} """) mappingf = {} mappingf.update({"op_func_name": self.get_func_name()}) mappingf.update({ "dims_i1": c_helper.generate_dim_bracket(self.input_tensor_shapes[0]) }) mappingf.update({ "dims_i2": c_helper.generate_dim_bracket(self.input_tensor_shapes[1]) }) mappingf.update({ "dims_o": c_helper.generate_dim_bracket(self.output_tensor_shapes[0]) }) mappingf.update( {"t": data_type.np2c(self.output_tensor_dtypes[0])}) mappingf.update({"X1": self.input_tensor_names[0]}) mappingf.update({"X2": self.input_tensor_names[1]}) mappingf.update({"C": self.output_tensor_names[0]}) mappingf.update({ "statements": TemplateArrayFuseLoop.replace("[statements]", statements) }) res += "\n\n" res += TemplateFunction.format(**mappingf) else: raise ValueError() return res