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
