def build_library(self, directory): source_filename = self.get_filename(directory, ".cpp") header_filename = self.get_filename(directory, ".h") # Build .cpp builder = build.Builder(self.project, source_filename) library.write_library(builder, self.project.get_name() + ".h") builder.write_to_file() # Build .h builder = build.Builder(self.project, header_filename) library.write_library_header_file(builder) builder.write_to_file()
def build(self, directory): self.write_header_file(directory) builder = build.Builder(self.project, self.get_filename(directory, ".cpp")) program.write_standalone_program(builder) builder.write_to_file() makefiles.write_program_makefile(self.project, directory)
def run(self): builder = build.Builder(self.project, os.path.join("/tmp", self.project.get_name() + ".h")) build.write_header_file(builder) builder.write_to_file() tester = base.tester.Tester() tester.prepare_writer = self.prepare_writer tester.args = [ "-I", os.path.join(paths.KAIRA_ROOT, paths.CAILIE_INCLUDE_DIR), "-I", self.project.root_directory ] if self.project.get_build_with_octave(): import ptp # To avoid cyclic import tester.args += [ "-I", os.path.join(paths.KAIRA_ROOT, paths.CAOCTAVE_INCLUDE_DIR) ] tester.args += ptp.get_config("Octave", "INCFLAGS").split() if self.project.build_target == "simrun": tester.args += [ "-I", os.path.join(paths.KAIRA_ROOT, paths.CASIMRUN_INCLUDE_DIR) ] tester.args += self.project.get_build_option("CFLAGS").split() tester.run() if tester.stderr: raise utils.PtpException(tester.stderr) for t in self.types.values(): t.add_checks(tester) for check in self.checks: tester.add(check) check = tester.run() if check is not None: check.throw_exception()
def build_statespace(self, directory): self.write_header_file(directory) builder = build.Builder(self.project, self.get_filename(directory, ".cpp")) statespace.write_statespace_program(builder) builder.write_to_file() makefiles.write_statespace_makefile(self.project, directory)
def write_fire_phase1(builder, tr): builder.line( "ca::Binding* Transition_{0.id}::fire_phase1" "(ca::ThreadBase *$thread, ca::NetBase *$net)", tr) builder.block_begin() builder.line("ca::Context ctx($thread, $net);") # ---- Prepare builder --- # w = build.Builder(builder.project) if tr.need_trace(): builder.line("ca::TraceLog *$tracelog = $thread->get_tracelog();") write_remove_tokens(w, builder.expand("$n"), tr) w.line("Tokens_{0.id} *$tokens = new Tokens_{0.id}();", tr) for inscription in tr.get_token_inscriptions_in(): w.line("$tokens->token_{0.uid} = $token_{0.uid};", inscription) if inscription.is_source_reader(): w.line( "$tokens->source_{0.uid} = " "$n->place_{0.edge.place.id}.get_source($token_{0.uid});", inscription) for edge in tr.get_bulk_edges_in(): w.line("$tokens->tokens_{0.uid}.overtake($n->place_{1.id});", edge, edge.place) if tr.collective: collectives.write_collective_phase1(w, tr) w.line("return $tokens;") # --- End of prepare --- # write_enable_pattern_match(builder, tr, w, "return NULL;") builder.line("return NULL;") builder.block_end()
def prepare_writer(self, filename): builder = build.Builder(self.project, filename) build.write_header(builder) if self.project.get_build_with_octave(): builder.line("#include <caoctave.h>") return builder
def build_simrun(self, directory): if not self.project.communication_model_code: raise base.utils.PtpException("Communication model is not setted") self.write_header_file(directory) builder = build.Builder(self.project, self.get_filename(directory, ".cpp")) simrun.write_simrun_program(builder) builder.write_to_file() makefiles.write_simrun_makefile(self.project, directory)
def build_oct_files(self, directory): source_filename = os.path.join(directory, self.project.get_name() + "_oct.cpp") m_filename = os.path.join(directory, self.project.get_name() + ".m") builder = build.Builder(self.project, source_filename) octave.write_oct_file(builder) builder.write_to_file() builder = octave.OctaveBuilder(self.project) octave.write_loader(builder, self.project.get_name() + ".oct") builder.write_to_file(m_filename)
def write_full_fire(builder, tr): builder.line( "ca::FireResult Transition_{0.id}::full_fire" "(ca::ThreadBase *$thread, ca::NetBase *$net)", tr) builder.block_begin() builder.line("ca::Context ctx($thread, $net);") w = build.Builder(builder.project) write_fire_body(w, tr) w.line("return ca::TRANSITION_FIRED;") write_enable_pattern_match(builder, tr, w, "return ca::NOT_ENABLED;") builder.line("return ca::NOT_ENABLED;") builder.block_end()
def build_server(self, directory): server_directory = os.path.join(directory, "server") source_filename = self.get_filename(server_directory, "_server.cpp") # Check for server directory if os.path.exists(server_directory): if not os.path.isdir(server_directory): raise base.utils.PtpException( "'server' exists but it is not directory") else: os.makedirs(server_directory) self.write_header_file(server_directory) builder = build.Builder(self.project, source_filename) rpc.write_server(builder) builder.write_to_file() makefiles.write_server_makefile(self.project, server_directory)
def write_full_fire_with_binding(builder, tr): builder.line( "ca::FireResult Transition_{0.id}::full_fire_with_binding(ca::ThreadBase *$thread, ca::NetBase *$net, ca::Packer &$packer)", tr) builder.block_begin() builder.line("ca::Context ctx($thread, $net);") w = build.Builder(builder.project) for inscription in tr.get_token_inscriptions_in(): w.line("ca::pack($packer, $token_{0}->value);", inscription.uid) for edge in tr.get_bulk_edges_in(): w.line("ca::pack($packer, $n->place_{0.id});", edge.place) write_fire_body(w, tr) w.line("return ca::TRANSITION_FIRED;") write_enable_pattern_match(builder, tr, w, "return ca::NOT_ENABLED;") builder.line("return ca::NOT_ENABLED;") builder.block_end()
def get_header(self): builder = build.Builder(self.project) build.write_header_file(builder) return builder.get_string()
def get_param_struct(self): builder = build.Builder(self.project) build.write_parameters_forward(builder) return builder.get_string()
def write_header_file(self, directory): builder = build.Builder(self.project, self.get_filename(directory, ".h")) build.write_header_file(builder) builder.write_to_file()
logging.basicConfig(level=logging.INFO, format="%(message)s") source = conference.Conferences() engine = search.GoogleScholar() papers = [] # papers += source.extract(["graph convolution", "knowledge graph", "embedding", "reasoning"], 2018) # Search missing links in Google Scholar for paper in papers: if "pdf" not in paper: print(paper) results = engine.search(paper["title"]) if results: print(results[0]) paper["pdf"] = results[0]["pdf"] builder = build.Builder(title="Literature of Deep Learning for Graphs", description=""" This is a paper list about deep learning for graphs. .. raw:: html <div><a href="README.rst">Sort by topic</a></div> <div><a href="BYVENUE.rst">Sort by venue</a></div> """) builder.load("data/BYTOPIC.rst") builder.add(papers) # builder.build("data/BYTOPIC.rst", index="topic") builder.build("data/BYVENUE.rst", index="venue") # builder.download()
import os import random import stat import json import jinja2 random.seed(os.environ["SEED"]) try: import build b = build.Builder() except Exception as e: print(e) b = type("", (), {})() b.flag = os.environ["FLAG"] b.flag_format = os.environ["FLAG_FORMAT"] if hasattr(b, "prebuild"): b.prebuild() cflags = ["-DFLAG=%s" % b.flag, "-DFLAG_FORMAT=%s" % b.flag_format] if hasattr(b, "x86_64") and not b.x86_64: cflags.append("-m32") if hasattr(b, "executable_stack") and b.executable_stack: cflags.append("-zexecstack") if hasattr(b, "stack_guards") and not b.stack_guards: cflags.append("-fno-stack-protector")
def init(args, *, pathdata: route.PathData) -> List[build.PatternedPermutation]: np.random.seed(seed=args.init_seed) bld_dist = distances.get_multiple_func(args.init_bld_dists, pathdata=pathdata) cls_dist = distances.get_multiple_func(args.init_cls_dists, pathdata=pathdata) n_random = round(args.init_random_rate * args.n_indiv) n_special = args.n_indiv - n_random if n_random < 0 or n_special < 0 or n_random + n_special != args.n_indiv: raise RuntimeError('Invalid number of individuals.') init_p_perms: List[build.PatternedPermutation] = [] # Random generation for _ in range(n_random): init_p_perms.append(build.build_randomly(pathdata.nodes)) # Cluster-patterned generation if n_special: clusters_nodes = clustering.get_function( method=args.init_cls_method, nodes=pathdata.nodes, n_cluster=args.init_n_cls, dist=cls_dist, dist_compare=distances.compare_multiple)() if args.init_bld_method == 'rg': builder = build.Builder(methods_func_dof={ 'R': (lambda nodes: build.build_randomly(nodes), 1), 'G': (lambda nodes: build.build_greedy( nodes, bld_dist, distances.compare_multiple, nn_n_random=args.init_greedy_rnum, start_node=pathdata.home_poses[0]), 0), }, clusters_nodes=clusters_nodes) init_p_perms.extend(builder.build_with_dof(n_special)) elif args.init_bld_method == 'r': for _ in range(n_special): init_p_perms.append( build.chain_patterned_permutations([ build.build_randomly(c_nodes) for c_nodes in clusters_nodes ])) else: raise RuntimeError('Unknown initialzation building method.') # Validation if not all([ permutation.is_valid(p_perm.nodes, pathdata.nodes) for p_perm in init_p_perms ]): raise RuntimeError('Invalid individuals.') return init_p_perms