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
