def add(self,fct_name,acts,subs_dict,action_data,check=True) : """add a file""" do_it = True fname = action_data["file"].replace('$fct_name$',fct_name) fct_name_path = os.path.abspath(os.path.join(self.get_tb_abs_path(),acts,fname)) if acts != "" : rel_path = os.path.join(self.get_tb_pathfnt2(),acts) else : rel_path = 'nt2/include/functions' do_it = self.get_tb_style()[0]=='s' if do_it : tplname = '../tpl/'+action_data["tmpl"] # print "action_data[tmpl] %s" % action_data["tmpl"] tpl_name_path = os.path.join(nt2_py_dir(),tplname) if "parm" in action_data.keys() : s = subs_dict["\$parms_type_and_ranges\$"] subs_dict["\$parms_type_and_ranges\$"] = re.sub('\$parm\$', action_data["parm"], s) subs_dict["\$acts\$"] = acts inner_text = self.__treat(read(tpl_name_path),subs_dict) if "parm" in action_data.keys() : subs_dict["\$parms_type_and_ranges\$"] = s comment = action_data["cmmt"] flag = action_data["head"] h = Headers(rel_path,fct_name,inner=inner_text,comment=comment) # print "fct_name_path %s" % fct_name_path h.write_header2(fct_name_path,flag=flag,check=check)
def mk_base(self,check,a,r,name,key) : """the created file is the main include file for the toolboxes users. """ na = os.path.abspath(os.path.join(a,'..')) fname = os.path.join(na,name+'.hpp') if check == 'check_only' : r = exist(fname) if not r : self.logger.info("\nbase file %s does not exist" % fname) return r self.logger.info( "\ncreating toolbox include template for %s\n" % self.get_root_name() ) inner_text = [ "", "// Please do not remove or modify the next line comment", "// This toolbox is of %s type" % self.__tb_style, "#include <nt2/nt2.hpp>", "#include <nt2/toolbox/" + self.get_root_name() + "/"+ \ self.get_root_name() + ".hpp>", "" ] n = self.get_root_name()+'/' rp = 'nt2/toolbox/' h = Headers(rp,self.get_root_name(),inner=inner_text) h.write_header2(os.path.join(na,name+'.hpp'),check=check) return True
def hie(self,fct_name,acts,subs_dict,action_data,check=True) : """create an include hierarchy for simd""" fname = action_data["file"].replace('$fct_name$',fct_name) path = os.path.join(self.get_tb_abs_path(),acts) hierarchy = action_data["hier"] cmmt = action_data["cmmt"] head = action_data["head"] relpath = os.path.join(self.get_tb_pathfnt2(),acts) relpathm1 = '/'.join(relpath.split('/')[:-1]) for base, prev in hierarchy.Variants.items() : file = os.path.join(path,base,fct_name+'.hpp') inner_text = ["#include <" + os.path.join(relpathm1, prev,fct_name + '.hpp>')] rpath = os.path.join(relpath,base) h = Headers(rpath,fct_name, inner=inner_text) h.write_header2(file,flag='full',check=check)
def create_include(self, pattern, fil, option="create"): """ create the include files in the global include files directory of nt2 if the toolbox is of 'sys' style and pattern is '../../include' also create the local toolbox functor include file if pattern is 'include' """ path = os.path.join(self.get_tb_path(), fil) sys = self.get_tb_style() name = self.get_fct_name() tb_name = self.get_tb_name() done = True if sys == 'sys' and pattern == '../../include': txt = [ "#include <nt2/toolbox/%s/include/%s.hpp>" % (tb_name, name) ] elif pattern == 'include': txt = [ "#include <nt2/toolbox/%s/function/%s.hpp>" % (tb_name, name) ] else: done = False print("done = %s" % done) if done: new_txt = Headers(self.get_nt2_rel_tb_path(self.get_tb_name()) + fil[:-4], "", inner=txt).txt() self.finalize(path, new_txt, option)
def mk_root(self,check,a,r,name,key) : """the created file will contain the include list of functors immediately available from the toolbox. """ fname = os.path.join(a,name+'.hpp') if check == 'check_only' : r = exist(fname) if not r : self.logger.info("\nroot file %s does not exist" % fname) return r self.logger.info( "\ncreating include template for %s\n" % self.get_root_name() ) rp = os.path.join('nt2/toolbox/',r) h = Headers(rp,self.get_root_name()) h.write_header2(fname,check=check) return True
def mk_py_data(self,check,a,r,name,key) : """this file contains python infos for pursuing the toolbox completion with functors """ fname = os.path.join(a,name) if check == 'check_only' : r = exist(fname) if not r : self.logger.info("\npy_data file %s does not exist" % fname) return r self.logger.info( "\ncreating toolbox py datas for %s\n" % self.get_root_name() ) inner_text = [ "datas = {", "'style' : '%s'" % self.__tb_style, "}" ] rp = os.path.join('nt2/toolbox/',r) h = Headers(rp, self.get_root_name(),inner=inner_text, ext='.py') h.write_header2(fname,flag='inner',check=check) return True
def __mk_s(self,check,a,r,name,key,st) : """ creation de CMakeLists.txt dans nt2/<tb>/<unit/bench>/<name>""" fname = os.path.join(a,name) benchortest = key.split('/')[0] if check == 'check_only' : r = exist(fname) if not r : self.logger.info("\ns file %s does not exist" % fname) return r self.logger.info( "\ncreating CMakeLists.txt for %s benchmarks\n" % self.get_root_name() ) inner_text = [ "", "SET( SOURCES", "# List of %s test files for toolbox %s"% (st,self.get_root_name()), " )", "", "##****************************************************************************", "# For each filename", "##****************************************************************************", "FOREACH( EXAMPLE ${SOURCES})", " ##**************************************************************************", " ## Build the executable filename from the example source filename", " ##**************************************************************************", ' STRING(REGEX REPLACE ".cpp" ".%s.%s.%s" EXECUTABLE "${EXAMPLE}")'%(self.get_root_name(),st,benchortest), ' STRING(REGEX REPLACE ".cpp" "-%s.%s.%s" TEST "${EXAMPLE}")'%(self.get_root_name(),st,benchortest), "", " ##**************************************************************************", " ## Add as a target", " ##**************************************************************************", " ADD_EXECUTABLE(${EXECUTABLE} ${EXAMPLE})", " TARGET_LINK_LIBRARIES(${EXECUTABLE} nt2)", " SET_TARGET_PROPERTIES(${EXECUTABLE} PROPERTIES COMPILE_FLAGS ${NT2_CXX_SIMD_FLAGS})" if st=="simd" else "", " ADD_TEST(${TEST} ${CMAKE_CURRENT_BINARY_DIR}/${EXECUTABLE})" if benchortest == 'unit' else "", "ENDFOREACH()", ] rp = os.path.join('nt2/toolbox/',r) h = Headers(rp,"/%s/CMakelists"%key, inner=inner_text, ext='.txt',comment='##') h.write_header2(os.path.join(a,name),flag='banner+inner',check=check) return True
def gen_scalar(self, fil, option="create"): """ auxilliary of create_function create the functor skel file for the scalar version with the functor name at the proper spots """ path = os.path.join(self.get_tb_path(), fil) arity = self.fct_dict[0]["functor"]["arity"] a = int(arity) sys = self.get_tb_style() name = self.get_fct_name() txt = [ "", "/////////////////////////////////////////////////////////////////////////////", "// Implementation when type A0 is arithmetic_", "/////////////////////////////////////////////////////////////////////////////", "NT2_REGISTER_DISPATCH(tag::%s_, tag::cpu_," % name, " %s," % self.strlist('(A%d)', sep='', arity=a), " %s" % self.strlist('(arithmetic_<A%d>)', sep='', arity=a), " )", "", "namespace nt2 { namespace ext", "{", " template<class Dummy>", " struct call<tag::%s_(%s)," % (name, self.strlist('tag::arithmetic_', n=0, sep=',', arity=a)), " tag::cpu_, Dummy> : callable", " {", " template<class Sig> struct result;", " template<class This,%s>" % self.strlist('class A%d', sep=',', arity=a), " struct result<This(%s)> :" % self.strlist('A%d', sep=',', arity=a), " boost::result_of<meta::floating(%s)>{};" % self.strlist('A%d', sep=',', arity=a), "", " NT2_FUNCTOR_CALL(%s)" % arity, " {", " typedef typename NT2_RETURN_TYPE(%s)::type type;" % arity, " // CODE HERE", " return WHATEVER", " }", " };", "} }", "", ] new_txt = Headers(self.get_nt2_rel_tb_path(self.get_tb_name()) + fil[:-4], "", inner=txt).txt() self.finalize(path, new_txt, option)
def mk_inner(self,check,a,r,name,key) : """ creation de CMakeLists.txt dans nt2/<tb>/doc/<name>""" fname = os.path.join(a,name) if check == 'check_only' : r = exist(fname) if not r : self.logger.info("\ninner file %s does not exist" % fname) return r self.logger.info( "\ncreating CMakeLists.txt for %s benches/unit tests\n" % self.get_root_name() ) inner_text = [ "", "################################################################################", "# Add global unit driver rules", "################################################################################", "ADD_CUSTOM_TARGET(%s.scalar.unit)" % self.get_root_name(), "ADD_CUSTOM_TARGET(%s.simd.unit)"% self.get_root_name(), "ADD_CUSTOM_TARGET(%s.unit)"% self.get_root_name(), "", "##****************************************************************************", "##* Toolbox %s %s tests" % (self.get_root_name(),key), "##****************************************************************************", "", "ADD_SUBDIRECTORY(scalar)", "ADD_SUBDIRECTORY(simd)", "", "################################################################################", "# Add driver rule dependencies", "################################################################################", "ADD_DEPENDENCIES(%s.unit %s.scalar.unit)" % (self.get_root_name(),self.get_root_name()), "ADD_DEPENDENCIES(%s.unit %s.simd.unit)"% (self.get_root_name(),self.get_root_name()), "ADD_DEPENDENCIES(unit %s.unit)"% self.get_root_name(), ] rp = os.path.join('nt2/toolbox/',r) h = Headers(rp,"/%s/CMakelists"%key, inner=inner_text, ext='.txt',comment='##') h.write_header2(fname,flag='banner+inner',check=check) return True
def mk_root_include(self,check,a,r,name,key) : """the created file include.hpp contains the BASE_<tb>... MACROS under toolbox/<tb>. """ fname = os.path.join(a,'include.hpp') if check == 'check_only' : r = exist(fname) if not r : self.logger.info("\nroot include file %s does not exist" % fname) return r self.logger.info( "\ncreating toolbox include template for %s\n" % self.get_root_name() ) inner_text = [ "#include <nt2/sdk/details/preprocessor.hpp>", "", "#define NT2_$tb_nameupper$_BASE() nt2/toolbox/$tb_name$/function/scalar/", "#define NT2_$tb_nameupper$_RELATIVE() nt2/toolbox/$tb_name$/function/", "", "#if defined(NT2_SIMD_DETECTED)", "#define NT2_$tb_nameupper$_INCLUDE(F) NT2_SIMD_RELATIVE_INCLUDE(NT2_$tb_nameupper$_RELATIVE, F)", "#else", "#define NT2_$tb_nameupper$_INCLUDE(F) NT2_PP_INCLUDE(NT2_$tb_nameupper$_BASE, F)", "#endif", "" ] inn=[] for l in inner_text : z=re.sub('\$tb_nameupper\$',self.get_root_name().upper(),l) z=re.sub('\$tb_name\$',self.get_root_name(),z) inn.append(z) rp = os.path.join('nt2/toolbox/',r) h = Headers(rp,"include",inner=inn) h.write_header2(fname,check=check) # phase 2 creation of the CMakeLists global file fname = os.path.join(a,'CMakeLists.txt') inner_text = [ "", "ADD_SUBDIRECTORY(bench)", "ADD_SUBDIRECTORY(unit)", "", "##############################################################################", "## TODO: Write command for building your own sources", "##############################################################################" ] rp = os.path.join('nt2/toolbox/',r) h = Headers(rp, "/%s/CMakelists"%key,inner=inner_text, ext='.txt',comment='##') h.write_header2(fname,flag='banner+inner',check=check) return True
def gen_def(self, fil, option="create"): """ auxilliary of create_function create the functor definition file with the functor name """ path = os.path.join(self.get_tb_path(), fil) arity = self.fct_dict[0]["functor"]["arity"] sys = self.get_tb_style() name = self.get_fct_name() tb_name = self.get_tb_name() namespace = "" if sys == 'sys' else self.get_tb_name() namespacecolon2 = "" if sys == 'sys' else namespace + '::' namespacebrak = "" if sys == 'sys' else namespace + ' {' txt = [ "#include <nt2/include/simd.hpp>", "#include <nt2/include/functor.hpp>", "#include <nt2/toolbox/%s/include.hpp>" % tb_name, "", "namespace nt2 {" + namespacebrak, " namespace tag", " {", " struct %s_ {};" % name, " }", " NT2_FUNCTION_IMPLEMENTATION(%stag::%s_, %s, %s)" % (namespacecolon2, name, name, arity), "}", "", "#include <nt2/toolbox/%s/function/scalar/%s.hpp>" % (tb_name, name), "#include NT2_%s_INCLUDE(%s.hpp) " % (tb_name.upper(), name), "", ] ## print("---------") ## print("gen_def") ## print("---------") new_txt = Headers(self.get_nt2_rel_tb_path(self.get_tb_name()) + fil[:-4], "", inner=txt).txt() self.finalize(path, new_txt, option)
def gen_simd(self, fil, option="create"): """ auxilliary of create_function create the functor skel file for the common version and the cascade include files for each simd variants with the functor name at the proper spots """ path = os.path.join(self.get_tb_path(), fil) ## print(path) ## print("---------") ## print("gen_simd") ## print("---------") l = fil.split('/') if l[2] == 'common': arity = self.fct_dict[0]["functor"]["arity"] a = int(arity) sys = self.get_tb_style() name = self.get_fct_name() txt = [ "#include <nt2/sdk/meta/as_real.hpp>", "", "/////////////////////////////////////////////////////////////////////////////", "// Implementation when type A0 is arithmetic_", "/////////////////////////////////////////////////////////////////////////////", "NT2_REGISTER_DISPATCH(tag::%s_, tag::cpu_," % name, " (A0)(X),", " %s" % self.strlist( '((simd_<arithmetic_<A0>,X>))', sep='', n=0, arity=a), " );", "", "namespace nt2 { namespace ext", "{", " template<class X, class Dummy>", " struct call<tag::%s_(%s)," % (name, self.strlist( 'tag::simd_<tag::arithmetic_, X>', n=0, sep=',', arity=a)), " tag::cpu_, Dummy> : callable", " {", " template<class Sig> struct result;", " template<class This,%s>" % self.strlist('class A%d', sep=',', arity=a), " struct result<This(%s)> : meta::as_real<A0>{};" % self.strlist('A%d', sep=',', arity=a), "", " NT2_FUNCTOR_CALL(%s)" % arity, " {", " typedef typename NT2_RETURN_TYPE(%s)::type type;" % arity, " // CODE HERE", " return WHATEVER", " }", " };", "} }", "", ] else: arch = Nt2_archis_struct.get_archi(l[2]) rppath = Nt2_archis_struct.get_archi( l[2]).get_previous_path(l[2] + '/' + l[3]) ## print("path %s"%(l[2]+'/'+l[3])) ## print("prev %s"%rppath) txt = [ "#include <nt2/toolbox/%s/function/simd/%s/%s.hpp>" % (self.get_tb_name(), rppath, self.get_fct_name()) ] new_txt = Headers(self.get_nt2_rel_tb_path(self.get_tb_name()) + fil[:-4], "", inner=txt).txt() self.finalize(path, new_txt, option)
def gen_bench(self, mode, option="create"): """ auxilliary of create_bench """ name = self.get_fct_name() tb_name = self.get_tb_name() txt = [ "#include <nt2/toolbox/%s/include/%s.hpp>" % (tb_name, name), "#include <nt2/sdk/unit/benchmark.hpp>", "#include <cmath>", "" if mode == 'scalar' else "typedef NT2_SIMD_DEFAULT_EXTENSION ext_t;", "", "//////////////////////////////////////////////////////////////////////////////", "// %s runtime benchmark for functor<%s_> from %s" % (mode, name, tb_name), "//////////////////////////////////////////////////////////////////////////////", "using nt2::tag::%s_;" % (name), "", "//////////////////////////////////////////////////////////////////////////////", "// range macro", "//////////////////////////////////////////////////////////////////////////////", "#define RS(T,V1,V2) (T, %(T)s(V1) ,%(T)s(V2))" % { "T": "" if mode == 'simd' else "T" }, "", ] txtf = [ "", "#undef RS", "", ] d = self.fct_dict[0] d1 = d.get('bench', False) if d1: pass else: d1 = { "arity": int(d["functor"]["arity"]), "ranges": d["unit"]["ranges"], "types": d["functor"]['types'], "type_defs": d["functor"]['type_defs'], "call_types": d["functor"]["call_types"], } if d1["call_types"] == []: d1["call_types"] = ["T"] ## PrettyPrinter().pprint(d1) if True: call = " NT2_TIMING(nt2::tag::%s_,%s)" % (name, "%s") variety = { 'real_': ["float", "double"], 'signed_int_': [ "nt2::uint8_t", "nt2::uint16_t", "nt2::uint32_t", "nt2::uint64_t" ], 'unsigned_int_': [ "nt2::uint8_t", "nt2::uint16_t", "nt2::uint32_t", "nt2::uint64_t" ], 'float': ["float"], 'double': ["double"], 'float_': ["float"], 'double_': ["double"], } r = [] k = 1 for typ in d1["types"]: for t in variety[typ]: r += ["namespace n%s {" % str(k)] k += 1 r.append(" typedef %s T;" % t) r += [" " + td for td in d1["type_defs"]] if mode == "simd": r += [ " typedef boost::simd::native<%s,ext_t> v%s;" % (ct, ct) for ct in d1["call_types"] ] tpl = "(RS(%s,%s,%s))" rges = d1["ranges"].get(typ, d1["ranges"]["default"]) if not isinstance(rges[0][0], list): rges = [rges] prefix = "v" if mode == 'simd' else '' calls = d1["call_types"] * d1["arity"] if len( d1["call_types"]) == 1 else d1["call_types"] for rgen in rges: param = "" for j, rge in enumerate(rgen): param += tpl % (prefix + calls[j], rge[0], rge[1]) r.append(call % param) r += ["}"] else: pass txt += r + txtf h = Headers(os.path.join(self.get_nt2_rel_tb_path(tb_name), 'bench', mode), name, inner=txt, guard_begin=[], guard_end=[]).txt() return h
prefix = "v" if mode == 'simd' else '' scalar_ints = d['functor'].get('scalar_ints',False) == 'True' iprefix = "v" if (mode == 'simd' and (name[-1]!='i') and (not scalar_ints)) else '' calls = d1["call_types"]*d1["arity"] if len( d1["call_types"]) == 1 else d1["call_types"][0:int(d1["arity"])] if isinstance(calls,str) : calls = [calls] print(calls) for rgen in rges : param="" for j,rge in enumerate(rgen) : print("calls[%s] = %s"%(j,calls[j])) if calls[j][0]=='i' : param += tpl%(iprefix+calls[j],rge[0],rge[1]) elif calls[j][0]=='s' : param += tpl%(calls[j][1:],rge[0],rge[1]) else : param += tpl%(prefix+calls[j],rge[0],rge[1]) r.append(call%param) r += ["}"] txt += r+txtf; h = Headers(os.path.join(self.bg.get_nt2_rel_tb_path(tb_name),'bench',mode), name,inner=txt,guard_begin=[],guard_end=[]).txt() return h.split('\n') if __name__ == "__main__" : print __doc__ from pprint import PrettyPrinter bg = Base_gen("exponential",'pipo','simd') bbg = Bench_gen(bg) PrettyPrinter().pprint(bbg.get_gen_result())
def __create_unit_txt(self): """ auxilliary of create_bench """ name = self.bg.get_fct_name() tb_name = self.bg.get_tb_name() mode = self.bg.get_fct_mode() nsp = "" if self.bg.get_tb_style() == "sys" else tb_name + "::" txt = [ '#define NT2_BENCH_MODULE "nt2 %s toolbox - %s/%s Mode"' % (tb_name, name, mode), "", "//////////////////////////////////////////////////////////////////////////////", "// timing Test behavior of %s components in %s mode" % (tb_name, mode), "//////////////////////////////////////////////////////////////////////////////", "" "#include <%s/include/%s.hpp>" % (self.bg.demangle(tb_name, "toolbox"), name.lower()), "#include <nt2/sdk/unit/benchmark.hpp>", "#include <nt2/sdk/unit/bench_includes.hpp>", "#include <boost/dispatch/meta/as_integer.hpp>", "#include <cmath>", "" if mode == "scalar" else "typedef NT2_SIMD_DEFAULT_EXTENSION ext_t;", "", "//////////////////////////////////////////////////////////////////////////////", "// %s runtime benchmark for functor<%s_> from %s" % (mode, name, tb_name), "//////////////////////////////////////////////////////////////////////////////", "using nt2::%stag::%s_;" % (nsp, name.lower()), "", "//////////////////////////////////////////////////////////////////////////////", "// range macro", "//////////////////////////////////////////////////////////////////////////////", "#define RS(T,V1,V2) (T, %(T)s(V1) ,%(T)s(V2))" % {"T": "" if mode == "simd" else "T"}, "", ] txtf = ["", "#undef RS", ""] dl = self.bg.get_fct_dict_list() k = 1 r = [] for d in dl: d1 = d.get("bench", False) if d1: pass else: d1 = { "arity": int(d["functor"]["arity"]), "ranges": d["unit"].get("ranges", [["0", "1"]]), "types": d["functor"].get("types", ["T"]), "simd_types": d["functor"].get("simd_types", d["functor"].get("types", ["T"])), "type_defs": d["functor"].get("type_defs", []), "call_types": d["functor"]["call_types"], } if d1["call_types"] == []: d1["call_types"] = ["T"] ## PrettyPrinter().pprint(d1) if True: tpl = d["functor"].get("tpl", "") call = " NT2_TIMING(%s_%s,%s)" % (name, tpl, "%s") variety = { "real_": ["float", "double"], "signed_int_": ["nt2::int8_t", "nt2::int16_t", "nt2::int32_t", "nt2::int64_t"], "unsigned_int_": ["nt2::uint8_t", "nt2::uint16_t", "nt2::uint32_t", "nt2::uint64_t"], "float": ["float"], "double": ["double"], "float_": ["float"], "double_": ["double"], "integer_": [ "nt2::int8_t", "nt2::int16_t", "nt2::int32_t", "nt2::int64_t", "nt2::uint8_t", "nt2::uint16_t", "nt2::uint32_t", "nt2::uint64_t", ], "int32_t": ["nt2::int32_t"], "int64_t": ["nt2::int64_t"], "uint32_t": ["nt2::uint32_t"], "uint64_t": ["nt2::uint64_t"], "int64_": ["nt2::uint64_t", "nt2::int64_t"], "int32_": ["nt2::uint32_t", "nt2::int32_t"], "int16_": ["nt2::uint16_t", "nt2::int16_t"], "int8_": ["nt2::uint8_t", "nt2::int8_t"], "groupable_": [ "nt2::int16_t", "nt2::uint16_t", "nt2::int32_t", "nt2::uint32_t", "nt2::int64_t", "nt2::uint64_t", "double", ], "splitable_": [ "nt2::int8_t", "nt2::uint8_t", "nt2::int16_t", "nt2::uint16_t", "nt2::int32_t", "nt2::uint32_t", "float", ], "gt_8_": [ "nt2::int16_t", "nt2::uint16_t", "nt2::int32_t", "nt2::uint32_t", "nt2::int64_t", "nt2::uint64_t", "double", "float", ], "lt_64_": [ "nt2::int16_t", "nt2::uint16_t", "nt2::int32_t", "nt2::uint32_t", "nt2::int8_t", "nt2::uint8_t", "float", ], "gt_16_": ["nt2::int32_t", "nt2::uint32_t", "nt2::int64_t", "nt2::uint64_t", "float", "double"], "sintgt_16_": ["nt2::int32_t", "nt2::int64_t"], "uintgt_16_": ["nt2::uint32_t", "nt2::uint64_t"], "int_convert_": ["nt2::int32_t", "nt2::int64_t"], "uint_convert_": ["nt2::uint32_t", "nt2::uint64_t"], "sintgt_8_": ["nt2::int16_t", "nt2::int32_t", "nt2::int64_t"], } typs = d1["simd_types"] if mode == "simd" else d1["types"] if self.__simd_type == "altivec" and mode == "simd": variety["real_"] = ["float"] variety["double"] = [] variety["double_"] = [] variety["gt_16_"] = [ "nt2::int32_t", "nt2::uint32_t", "nt2::int64_t", "nt2::uint64_t", "float", "double", ] variety["groupable_"] = [ "nt2::int16_t", "nt2::uint16_t", "nt2::int32_t", "nt2::uint32_t", "nt2::int64_t", "nt2::uint64_t", ] variety["gt_8_"] = [ "nt2::int16_t", "nt2::uint16_t", "nt2::int32_t", "nt2::uint32_t", "nt2::int64_t", "nt2::uint64_t", "double", "float", ] print ("typs %s" % typs) for typ in typs: ## print("typ = %s, variety = %s"%(typ,variety[typ])) for t in variety[typ]: def get_ranges(typ, variety): ## print ("in get_ranges") ## print ("d1['ranges'] %s"% d1["ranges"]) d = d1["ranges"] if t in d.keys(): rges = d[t] elif typ in d.keys(): rges = d[typ] elif "default" in d.keys(): rges = d["default"] else: rges = None return rges ## rges = d1["ranges"].get(t,d1["ranges"].get("default",None)) rges = get_ranges(typ, variety) ## print("rges %s"%rges) r += ["namespace n%s {" % str(k)] k += 1 r.append(" typedef %s T;" % t) r.append(" typedef boost::dispatch::meta::as_integer<T>::type iT;") ## r += [" "+td for td in d1["type_defs"]] if mode == "simd": r += [ " typedef boost::simd::native<%s,ext_t> v%s;" % (ct, ct) for ct in d1["call_types"] if ct[0] != "s" ] tpl = "(RS(%s,%s,%s))" ## print( 'd1["ranges"] %s'%d1["ranges"]) ## print("rges %s"%rges) ## if isinstance(rges[0][0],list) : print(rges) if not isinstance(rges[0][0], list): rges = [rges] prefix = "v" if mode == "simd" else "" scalar_ints = d["functor"].get("scalar_ints", False) == "True" iprefix = "v" if (mode == "simd" and (name[-1] != "i") and (not scalar_ints)) else "" calls = ( d1["call_types"] * d1["arity"] if len(d1["call_types"]) == 1 else d1["call_types"][0 : int(d1["arity"])] ) if isinstance(calls, str): calls = [calls] ## print("callls %s"%calls) for rgen in rges: ## print("rgen %s"%rgen) param = "" for j, rge in enumerate(rgen): ## print("calls[%s] = %s"%(j,calls[j])) if calls[j][0] == "i": param += tpl % (iprefix + calls[j], rge[0], rge[1]) elif calls[j][0] == "s": param += tpl % (calls[j][1:], rge[0], rge[1]) else: param += tpl % (prefix + calls[j], rge[0], rge[1]) r.append(call % param) r += ["}"] txt += r + txtf if tb_name.find(".") != -1: for i, l in enumerate(txt): txt[i] = re.sub("nt2::", "boost::simd::", l) h = Headers( os.path.join(self.bg.get_nt2_rel_tb_path(tb_name), "bench", mode), name, inner=txt, guard_begin=[], guard_end=[], ).txt() return h.split("\n")
def __create_unit_txt(self): """ auxilliary of create_bench """ name = self.bg.get_fct_name() tb_name = self.bg.get_tb_name() mode = self.bg.get_fct_mode() nsp = "" if self.bg.get_tb_style() == "sys" else tb_name + '::' txt = [ '#define NT2_BENCH_MODULE "nt2 %s toolbox - %s/%s Mode"' % (tb_name, name, mode), "", "//////////////////////////////////////////////////////////////////////////////", "// timing Test behavior of %s components in %s mode" % (tb_name, mode), "//////////////////////////////////////////////////////////////////////////////", "" "#include <%s/include/%s.hpp>" % (self.bg.demangle(tb_name, 'toolbox'), name.lower()), "#include <nt2/sdk/unit/benchmark.hpp>", "#include <nt2/sdk/unit/bench_includes.hpp>", "#include <boost/dispatch/meta/as_integer.hpp>", "#include <cmath>", "" if mode == 'scalar' else "typedef NT2_SIMD_DEFAULT_EXTENSION ext_t;", "", "//////////////////////////////////////////////////////////////////////////////", "// %s runtime benchmark for functor<%s_> from %s" % (mode, name, tb_name), "//////////////////////////////////////////////////////////////////////////////", "using nt2::%stag::%s_;" % (nsp, name.lower()), "", "//////////////////////////////////////////////////////////////////////////////", "// range macro", "//////////////////////////////////////////////////////////////////////////////", "#define RS(T,V1,V2) (T, %(T)s(V1) ,%(T)s(V2))" % { "T": "" if mode == 'simd' else "T" }, "", ] txtf = [ "", "#undef RS", "", ] dl = self.bg.get_fct_dict_list() k = 1 r = [] for d in dl: d1 = d.get('bench', False) if d1: pass else: d1 = { "arity": int(d["functor"]["arity"]), "ranges": d["unit"].get("ranges", [['0', '1']]), "types": d["functor"].get('types', ['T']), "simd_types": d["functor"].get('simd_types', d["functor"].get('types', ['T'])), "type_defs": d["functor"].get('type_defs', []), "call_types": d["functor"]["call_types"], } if d1["call_types"] == []: d1["call_types"] = ["T"] ## PrettyPrinter().pprint(d1) if True: tpl = d["functor"].get("tpl", "") call = " NT2_TIMING(%s_%s,%s)" % (name, tpl, "%s") variety = { 'real_': ["float", "double"], 'signed_int_': [ "nt2::int8_t", "nt2::int16_t", "nt2::int32_t", "nt2::int64_t" ], 'unsigned_int_': [ "nt2::uint8_t", "nt2::uint16_t", "nt2::uint32_t", "nt2::uint64_t" ], 'float': ["float"], 'double': ["double"], 'float_': ["float"], 'double_': ["double"], 'integer_': [ "nt2::int8_t", "nt2::int16_t", "nt2::int32_t", "nt2::int64_t", "nt2::uint8_t", "nt2::uint16_t", "nt2::uint32_t", "nt2::uint64_t" ], 'int32_t': ["nt2::int32_t"], 'int64_t': ["nt2::int64_t"], 'uint32_t': ["nt2::uint32_t"], 'uint64_t': ["nt2::uint64_t"], 'int64_': ["nt2::uint64_t", "nt2::int64_t"], 'int32_': ["nt2::uint32_t", "nt2::int32_t"], 'int16_': ["nt2::uint16_t", "nt2::int16_t"], 'int8_': ["nt2::uint8_t", "nt2::int8_t"], "groupable_": [ "nt2::int16_t", "nt2::uint16_t", "nt2::int32_t", "nt2::uint32_t", "nt2::int64_t", "nt2::uint64_t", "double" ], "splitable_": [ "nt2::int8_t", "nt2::uint8_t", "nt2::int16_t", "nt2::uint16_t", "nt2::int32_t", "nt2::uint32_t", "float" ], "gt_8_": [ "nt2::int16_t", "nt2::uint16_t", "nt2::int32_t", "nt2::uint32_t", "nt2::int64_t", "nt2::uint64_t", "double", "float" ], "lt_64_": [ "nt2::int16_t", "nt2::uint16_t", "nt2::int32_t", "nt2::uint32_t", "nt2::int8_t", "nt2::uint8_t", "float" ], "gt_16_": [ "nt2::int32_t", "nt2::uint32_t", "nt2::int64_t", "nt2::uint64_t", "float", "double" ], "sintgt_16_": ["nt2::int32_t", "nt2::int64_t"], "uintgt_16_": ["nt2::uint32_t", "nt2::uint64_t"], "int_convert_": ["nt2::int32_t", "nt2::int64_t"], "uint_convert_": ["nt2::uint32_t", "nt2::uint64_t"], "sintgt_8_": ["nt2::int16_t", "nt2::int32_t", "nt2::int64_t"], } typs = d1["simd_types"] if mode == 'simd' else d1["types"] if self.__simd_type == 'altivec' and mode == 'simd': variety['real_'] = ["float"] variety['double'] = [] variety['double_'] = [] variety["gt_16_"] = [ "nt2::int32_t", "nt2::uint32_t", "nt2::int64_t", "nt2::uint64_t", "float", "double" ] variety["groupable_"] = [ "nt2::int16_t", "nt2::uint16_t", "nt2::int32_t", "nt2::uint32_t", "nt2::int64_t", "nt2::uint64_t" ] variety["gt_8_"] = [ "nt2::int16_t", "nt2::uint16_t", "nt2::int32_t", "nt2::uint32_t", "nt2::int64_t", "nt2::uint64_t", "double", "float" ] print("typs %s" % typs) for typ in typs: ## print("typ = %s, variety = %s"%(typ,variety[typ])) for t in variety[typ]: def get_ranges(typ, variety): ## print ("in get_ranges") ## print ("d1['ranges'] %s"% d1["ranges"]) d = d1["ranges"] if t in d.keys(): rges = d[t] elif typ in d.keys(): rges = d[typ] elif "default" in d.keys(): rges = d["default"] else: rges = None return rges ## rges = d1["ranges"].get(t,d1["ranges"].get("default",None)) rges = get_ranges(typ, variety) ## print("rges %s"%rges) r += ["namespace n%s {" % str(k)] k += 1 r.append(" typedef %s T;" % t) r.append( " typedef boost::dispatch::meta::as_integer<T>::type iT;" ) ## r += [" "+td for td in d1["type_defs"]] if mode == "simd": r += [ " typedef boost::simd::native<%s,ext_t> v%s;" % (ct, ct) for ct in d1["call_types"] if ct[0] != 's' ] tpl = "(RS(%s,%s,%s))" ## print( 'd1["ranges"] %s'%d1["ranges"]) ## print("rges %s"%rges) ## if isinstance(rges[0][0],list) : print(rges) if not isinstance(rges[0][0], list): rges = [rges] prefix = "v" if mode == 'simd' else '' scalar_ints = d['functor'].get('scalar_ints', False) == 'True' iprefix = "v" if (mode == 'simd' and (name[-1] != 'i') and (not scalar_ints)) else '' calls = d1["call_types"] * d1["arity"] if len( d1["call_types"] ) == 1 else d1["call_types"][0:int(d1["arity"])] if isinstance(calls, str): calls = [calls] ## print("callls %s"%calls) for rgen in rges: ## print("rgen %s"%rgen) param = "" for j, rge in enumerate(rgen): ## print("calls[%s] = %s"%(j,calls[j])) if calls[j][0] == 'i': param += tpl % (iprefix + calls[j], rge[0], rge[1]) elif calls[j][0] == 's': param += tpl % (calls[j][1:], rge[0], rge[1]) else: param += tpl % (prefix + calls[j], rge[0], rge[1]) r.append(call % param) r += ["}"] txt += r + txtf if tb_name.find('.') != -1: for i, l in enumerate(txt): txt[i] = re.sub('nt2::', 'boost::simd::', l) h = Headers(os.path.join(self.bg.get_nt2_rel_tb_path(tb_name), 'bench', mode), name, inner=txt, guard_begin=[], guard_end=[]).txt() return h.split('\n')