def gen_function(self, kernel_name, kernel_arg_type_name, code=None):
if code is None:
code = CodeBlock()
code.comment("Output iteration space reduced to %s iteration spaces" % (self.kernel_dims))
code.write("void {}({} *Args) {{", kernel_name, kernel_arg_type_name)
code.indent()
for kerarg_name, kerarg_type in self.kernel_args:
code.write('{0} {1} = Args->{1};', kerarg_type, kerarg_name)
if self.kernel_dims == 1:
last_first = "Sz"
code.write('unsigned int Sz = W * H;')
elif self.kernel_dims == 2:
last_first = "H"
elif self.kernel_dims == 3:
last_first = "InFeatures"
else:
raise ValueError("expression has too many dimensions")
code.write('unsigned int CoreId = gap_coreid();')
code.write('unsigned int Chunk = ChunkSize({});', last_first)
code.write('unsigned int First = Chunk*CoreId;')
code.write('unsigned int Last = gap_min(First+Chunk, {});', last_first)
self._func_col.create_kernel(code)
code.write('gap_waitbarrier(0);')
code.deindent()
code.write('}}')
return code
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
code_block.write(f'CNN_SignedUnsigned("{self.cname}", {self.in_type}, {self.out_type}, {self.size});')
return code_block
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
gen_expression_sq8(code_block, self.gen_name, self.cname)
return code_block
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
gen_at_imageformat(code_block, self.cname, self.in_dim, self.do_offset, NNTOOL_KOP[self.in_format])
return code_block
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
code_block.write('{}("{}");'.format(self.gen_name, self.cname))
return code_block
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
gen_at_resizer(code_block, self.cname, self.in_dim, self.new_shape,
self.inout_type, RESIZE_KOP[self.type], self.q16)
return code_block
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
if not self.gen_ctrl.is_unmodified:
self.gen_ctrl.gen_ctrl_decl(code_block)
gen_ctrl = self.gen_ctrl.ctrl_name
else:
gen_ctrl = "0"
if self.at_conv_params == NO_CONV:
pp = self.at_pool_params
ap = self.at_act_params
gen_cnn_conv_pool_act_fp16(code_block, self.cname, self.in_dim.c,
self.out_dim.c, self.in_dim.w, self.in_dim.h,
self.bias_q.bits//8 if self.bias_q is not None else 0,
"KOP_NONE", 0, 0, 0, 0, 0, 0, 0,
pp.PoolOper, pp.Fpx, pp.Fpy, pp.Dpx, pp.Dpy,
pp.Spx, pp.Spy, pp.PoolPad,
ap.ReLUOper, gen_ctrl,
at_ver=self.at_ver)
else:
cp = self.at_conv_params
pp = self.at_pool_params
ap = self.at_act_params
if isinstance(self.at_conv_params, ConvATParam):
LOG.debug("%s: conv pool relu inq %s outq %s control block",
self.node_name, self.in_q, self.out_q)
gen_cnn_conv_pool_act_fp16(code_block, self.cname, self.in_dim.c,
self.out_dim.c, self.in_dim.w, self.in_dim.h,
self.bias_q.bits//8,
cp.ConvOper, cp.Fcx, cp.Fcy, cp.Dcx, cp.Dcy,
cp.Scx, cp.Scy, cp.ConvPad,
pp.PoolOper, pp.Fpx, pp.Fpy, pp.Dpx, pp.Dpy,
pp.Spx, pp.Spy, pp.PoolPad,
ap.ReLUOper, gen_ctrl,
at_ver=self.at_ver)
elif isinstance(self.at_conv_params, GroupedConvATParam):
LOG.debug("%s: grouped mulconv pool relu inq %s outq %s control block",
self.node_name, self.in_q, self.out_q)
gen_cnn_grp_conv_pool_act_fp16(code_block, self.cname, cp.GroupIn, cp.GroupOut,
self.in_dim.c,
self.out_dim.c, self.in_dim.w, self.in_dim.h,
self.bias_q.bits//8,
cp.ConvOper, cp.Fcx, cp.Fcy, cp.Dcx, cp.Dcy,
cp.Scx, cp.Scy, cp.ConvPad,
pp.PoolOper, pp.Fpx, pp.Fpy, pp.Dpx, pp.Dpy,
pp.Spx, pp.Spy, pp.PoolPad,
ap.ReLUOper, gen_ctrl,
at_ver=self.at_ver)
else:
raise ValueError('Internal error')
return code_block
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
if not self.gen_ctrl.is_unmodified:
self.gen_ctrl.gen_ctrl_decl(code_block)
gen_at_softmax(code_block, self.cname, self.in_dim,
self.at_softmax_params.SoftMaxOper, at_ver=self.at_ver)
return code_block
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
code_block.comment("transpose from {} to {} ({})", self.in_dim,
self.out_dim, self.real_transpose)
if not self.gen_ctrl.is_unmodified:
self.gen_ctrl.gen_ctrl_decl(code_block)
gen_at_3d_transpose(code_block, self.cname, self.in_shape, self.permop)
return code_block
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
if not self.gen_ctrl.is_unmodified:
self.gen_ctrl.gen_ctrl_decl(code_block)
gen_at_globalpool(code_block, self.cname, self.in_q, self.out_q,
self.in_dim, self.out_dim, self.at_globalpool_params,
at_ver=self.at_ver)
return code_block
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
if not self.gen_ctrl.is_unmodified:
self.gen_ctrl.gen_ctrl_decl(code_block)
gen_at_matrixadddyn(code_block, self.cname, self.in_q1, self.in_q2, self.out_q,
self.in_dim, self.out_dim, self.at_matrixadd_params,
gen_ctrl=self.gen_ctrl)
return code_block
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
if not self.gen_ctrl.is_unmodified:
self.gen_ctrl.gen_ctrl_decl(code_block)
gen_at_matscale(code_block, self.cname, self.otherq, self.vectorq,
self.scalarq, self.out_q, self.in_dim, self.out_dim,
self.at_matscale_params)
return code_block
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
if not self.gen_ctrl.is_unmodified:
self.gen_ctrl.gen_ctrl_decl(code_block)
gen_at_linear_relu(code_block, self.cname, self.in_q, self.out_q,
self.filter_q, self.bias_q,
self.in_dim, self.out_dim, self.at_linear_params, self.at_act_params,
at_ver=self.at_ver, gen_ctrl=self.gen_ctrl)
return code_block
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
if not self.gen_ctrl.is_unmodified:
self.gen_ctrl.gen_ctrl_decl(code_block)
gen_ctrl = self.gen_ctrl.ctrl_name
else:
gen_ctrl = "0"
gen_copy(code_block, self.cname, gen_ctrl, self.params.out_dims[0].size())
return code_block
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
if not self.gen_ctrl.is_unmodified:
self.gen_ctrl.gen_ctrl_decl(code_block)
gen_ctrl = self.gen_ctrl.ctrl_name
else:
gen_ctrl = "0"
gen_cnn_pool_act_sq8(code_block, self.cname, gen_ctrl, self.in_dim.c,
self.in_dim.w, self.in_dim.h, self.at_pool_params,
self.at_act_params.ReLUOper)
return code_block
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
if not self.gen_ctrl.is_unmodified:
self.gen_ctrl.gen_ctrl_decl(code_block)
gen_ctrl = self.gen_ctrl.ctrl_name
else:
gen_ctrl = "0"
gen_mat_add_sq8(code_block, self.cname, gen_ctrl, self.feat_dim,
self.width, self.height, self.at_act_params.ReLUOper)
return code_block
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
if not self.gen_ctrl.is_unmodified:
self.gen_ctrl.gen_ctrl_decl(code_block)
gen_ctrl = self.gen_ctrl.ctrl_name
else:
gen_ctrl = "0"
gen_rnn_fp16(code_block, self.kname, self.cname, gen_ctrl,
self.n_cells, self.n_input_cells, self.n_output_cells,
self.n_states, self.n_inputs, self.revert and "1" or "0")
return code_block
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
if not self.gen_ctrl.is_unmodified:
self.gen_ctrl.gen_ctrl_decl(code_block)
gen_ctrl = self.gen_ctrl.ctrl_name
else:
gen_ctrl = "0"
gen_mat_mul_fp16(code_block, self.cname, gen_ctrl, self.colM1,
self.lineM1, self.colM2, self.lineM2,
self.at_act_params)
return code_block
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
if not self.gen_ctrl.is_unmodified:
self.gen_ctrl.gen_ctrl_decl(code_block)
gen_at_ssd_parameter(code_block,
self.cname,
self.num_anchors,
self.num_classes,
self.out_boxes,
self.max_bb_before_nms,
at_ver=self.at_ver)
return code_block
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
if not self.gen_ctrl.is_unmodified:
self.gen_ctrl.gen_ctrl_decl(code_block)
gen_ctrl = self.gen_ctrl.ctrl_name
else:
gen_ctrl = "0"
gen_at_linear_relu(code_block, self.cname, self.bias_q.bits//8, self.mulbiases_q.bits//8,
self.in_dim, self.out_dim,
self.at_linear_params.LinearOper,
self.at_act_params.ReLUOper,
at_ver=self.at_ver, gen_ctrl=gen_ctrl)
return code_block
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
code_block.comment("transpose from {} to {} ({})", self.in_dim,
self.out_dim, self.real_transpose)
if not self.gen_ctrl.is_unmodified:
self.gen_ctrl.gen_ctrl_decl(code_block)
gen_ctrl = self.gen_ctrl.ctrl_name
else:
gen_ctrl = "0"
gen_at_2d_transpose(code_block,
self.cname,
abs(at_bits(self.in_q)),
self.in_shape,
gen_ctrl=gen_ctrl)
return code_block
def gen_function(self, kernel_name, kernel_arg_type_name, code=None):
if code is None:
code = CodeBlock()
code.comment("Output iteration space reduced to %s iteration spaces" %
(self.kernel_dims))
code.write(f"void {kernel_name}({kernel_arg_type_name} *Args) {{")
code.indent()
for kerarg_name, kerarg_type in self.kernel_args:
code.write('{0} {1} = Args->{1};', kerarg_type, kerarg_name)
# paralellize on largest dimension
last_first = self.parallel_iterator.name.upper()
code.write('unsigned int CoreId = gap_coreid();')
code.write('unsigned int Chunk = ChunkSize({});', last_first)
code.write('unsigned int First = Chunk*CoreId;')
code.write('unsigned int Last = gap_min(First+Chunk, {});', last_first)
self._func_col.create_kernel(self.parallel_iterator,
self.fixed_iterators, code)
code.write('gap_waitbarrier(0);')
code.deindent()
code.write('}')
return code
def code(self, code_block=None):
if code_block is None:
code_block = CodeBlock()
code_block.comment("generator for {}", self.node_name)
if not self.gen_ctrl.is_unmodified:
self.gen_ctrl.gen_ctrl_decl(code_block)
if self.at_conv_params == NO_CONV:
if self.in_q.bits != self.out_q.bits:
raise NotImplementedError(
"only homogenious operations are supported at present")
LOG.debug("%s: pool relu inq %s outq %s control block",
self.node_name, self.in_q, self.out_q)
gen_at_pool_relu(code_block,
self.cname,
self.in_q,
self.out_q,
self.in_dim,
self.out_dim,
self.at_pool_params,
self.at_act_params,
gen_ctrl=self.gen_ctrl,
at_ver=self.at_ver)
else:
if isinstance(self.at_conv_params, ConvATParam):
if self.mul_biases_q is not None:
LOG.debug(
"%s: mulconv pool relu inq %s outq %s control block",
self.node_name, self.in_q, self.out_q)
gen_at_mulconv_pool_relu(code_block,
self.cname,
self.in_q,
self.out_q,
self.filter_q,
self.bias_q,
self.mul_biases_q,
self.in_dim,
self.out_dim,
self.at_conv_params,
self.at_pool_params,
self.at_act_params,
gen_ctrl=self.gen_ctrl,
at_ver=self.at_ver)
else:
LOG.debug(
"%s: conv pool relu inq %s outq %s control block",
self.node_name, self.in_q, self.out_q)
gen_at_conv_pool_relu(code_block,
self.cname,
self.in_q,
self.out_q,
self.filter_q,
self.bias_q,
self.in_dim,
self.out_dim,
self.at_conv_params,
self.at_pool_params,
self.at_act_params,
gen_ctrl=self.gen_ctrl,
at_ver=self.at_ver)
elif isinstance(self.at_conv_params, GroupedConvATParam):
if self.mul_biases_q is not None:
LOG.debug(
"%s: grouped conv pool relu inq %s outq %s control block",
self.node_name, self.in_q, self.out_q)
gen_at_grouped_mulconv_pool_relu(code_block,
self.cname,
self.in_q,
self.out_q,
self.filter_q,
self.bias_q,
self.mul_biases_q,
self.in_dim,
self.out_dim,
self.at_conv_params,
self.at_pool_params,
self.at_act_params,
gen_ctrl=self.gen_ctrl,
at_ver=self.at_ver)
else:
LOG.debug(
"%s: grouped mulconv pool relu inq %s outq %s control block",
self.node_name, self.in_q, self.out_q)
gen_at_grouped_conv_pool_relu(code_block,
self.cname,
self.in_q,
self.out_q,
self.filter_q,
self.bias_q,
self.in_dim,
self.out_dim,
self.at_conv_params,
self.at_pool_params,
self.at_act_params,
gen_ctrl=self.gen_ctrl,
at_ver=self.at_ver)
else:
raise ValueError('Internal error')
return code_block
