def _generate_map_macros(self):
g = cgen.Module([cgen.Comment('#### KERNEL_MAP_MACROS ####')])
for i, dat in enumerate(self._dat_dict.items()):
if type(dat[1][0]) is cuda_data.GlobalArray or \
issubclass(type(dat[1][0]), cuda_base.Array):
g.append(cgen.Define(dat[0] + '(x)', '(' + dat[0] + '[(x)])'))
if issubclass(type(dat[1][0]), cuda_base.Matrix):
g.append(cgen.Define(dat[0] + '(y)', dat[0] + '.i[(y)]'))
self._components['KERNEL_MAP_MACROS'] = g
def pluto_include():
libraries = ['omp.h', 'math.h']
statements = [cgen.Include(s) for s in libraries]
statements += [
cgen.Define("ceild(n,d)", "ceil(((double)(n))/((double)(d)))")
]
statements += [
cgen.Define("floord(n,d)", "floor(((double)(n))/((double)(d)))")
]
statements += [cgen.Define("max(x,y)", "((x) > (y)? (x) : (y))")]
statements += [cgen.Define("min(x,y)", "((x) < (y)? (x) : (y))")]
return statements
def _generate_map_macros(self):
g = cgen.Module([cgen.Comment('#### KERNEL_MAP_MACROS ####')])
for i, dat in enumerate(self._dat_dict.items()):
if issubclass(type(dat[1][0]), host._Array):
g.append(cgen.Define(dat[0] + '(x)', '(' + dat[0] + '[(x)])'))
if issubclass(type(dat[1][0]), host.Matrix):
g.append(cgen.Define(dat[0] + '(x,y)', dat[0] + '_##x(y)'))
g.append(cgen.Define(dat[0] + '_0(y)', dat[0] + '.i[(y)]'))
g.append(cgen.Define(dat[0] + '_1(y)', dat[0] + '.j[(y)]'))
self._components['KERNEL_MAP_MACROS'] = g
def visit_Operator(self, o, mode='all'):
# Kernel signature and body
body = flatten(self._visit(i) for i in o.children)
decls = self._args_decl(o.parameters)
signature = c.FunctionDeclaration(c.Value(o.retval, o.name), decls)
retval = [c.Line(), c.Statement("return 0")]
kernel = c.FunctionBody(signature, c.Block(body + retval))
# Elemental functions
esigns = []
efuncs = [blankline]
for i in o._func_table.values():
if i.local:
prefix = ' '.join(i.root.prefix + (i.root.retval, ))
esigns.append(
c.FunctionDeclaration(c.Value(prefix, i.root.name),
self._args_decl(i.root.parameters)))
efuncs.extend([self._visit(i.root), blankline])
# Definitions
headers = [c.Define(*i) for i in o._headers] + [blankline]
# Header files
includes = self._operator_includes(o) + [blankline]
# Type declarations
typedecls = self._operator_typedecls(o, mode)
if mode in ('all', 'public') and o._compiler.src_ext in ('cpp', 'cu'):
typedecls.append(c.Extern('C', signature))
typedecls = [i for j in typedecls for i in (j, blankline)]
return c.Module(headers + includes + typedecls + esigns +
[blankline, kernel] + efuncs)
def includes(self):
statements = includes.copyright()
statements += [cgen.Define('M_PI', '3.14159265358979323846')]
statements += includes.common_include()
if self.io:
statements += includes.io_include()
if self.pluto:
statements += includes.pluto_include()
if self.profiling:
statements += includes.profiling_include()
return cgen.Module(statements)
def code(self):
iters = []
statements = []
node = self._node
cond = node.condition
domain = str(node.domain)
if domain[0] == '[' and '->' in domain:
domain = domain[domain.find('->') + 3:]
is_set = '[' in domain and ']' in domain
if is_set:
iters = domain.split('[')[1].split(']')[0].replace(' ', '').replace('0', 'z').split(',')
for stmt in node.statements:
for iter in iters:
cond = re.sub(r"\b%s\b" % iter, '(%s)' % iter, cond)
stmt = re.sub(r"\b%s\b" % iter, '(%s)' % iter, stmt)
statements.append(stmt)
else:
statements = node._statements
stmtlist = ";\\\n".join(statements)
if len(cond) > 0:
stmtlist = 'if (%s) { %s; }' % (cond, stmtlist)
define = cg.Define('%s(%s)' % (node.label, ','.join(iters)), stmtlist)
code = "\n%s" % str(define)
# TODO: If node reads and writes intersect, reset values. This is mostly a hack in need of refactoring...
intersection = list(set(node.reads) & set(node.writes))
if len(intersection) > 0:
code += "\n"
for item in intersection:
name = item.split('(')[0]
dnode = node.graph[name]
if dnode.scalar:
code += "\n%s = %s;" % (name, dnode.defval)
else:
code += "\nmemset(%s, %s, %s * sizeof(%s));" % (name, dnode.defval, dnode.size, dnode.type)
if is_set and node.set:
lines = node.graph.set_factory.codegen(node.set, [node.label]).split("\n")
if config['skipguard'] and 'if (' in lines[0]:
braced = (lines[0].find('{') > 0)
lines = lines[1:]
if braced:
lines = lines[0:len(lines) - 1]
code = "%s\n\n%s" % (code, "\n".join(lines))
else:
code = "%s\n\n %s();" % (code, node.label)
code = "%s\n" % code.rstrip()
self._outer.lines.append(code)
return code
def emit_extern_global_variables(self, source_file):
source_file.add(cgen.Pragma("""push_macro("_SFR_IO8")"""))
source_file.add(cgen.Line("#undef _SFR_IO8"))
source_file.add(cgen.Define("_SFR_IO8(x)", "x"))
for name, definition in self.definitions:
port = definition.port[0]
assert port in ("A", "B", "C", "D", "E")
pin = int(definition.port[1])
source_file.add(
cgen.Statement(f"static kGPIO<PORT{port},{pin}> {name}"))
source_file.add(cgen.Pragma("""pop_macro("_SFR_IO8")"""))
def visit_Operator(self, o):
# Generate the code for the cfile
ccode = super().visit_Operator(o, mode='private')
# Generate the code for the hfile
typedecls = self._operator_typedecls(o, mode='public')
guarded_typedecls = []
for i in typedecls:
guard = "DEVITO_%s" % i.tpname.upper()
iflines = [c.Define(guard, ""), blankline, i, blankline]
guarded_typedecl = c.IfNDef(guard, iflines, [])
guarded_typedecls.extend([guarded_typedecl, blankline])
decls = self._args_decl(o.parameters)
signature = c.FunctionDeclaration(c.Value(o.retval, o.name), decls)
hcode = c.Module(guarded_typedecls + [blankline, signature, blankline])
return ccode, hcode
def emit_internal_header(self, source_file):
if self.modbus.rs485_dir_pin is not None:
source_file.add(
cgen.Define(f"MODBUS_RS485_DIR_PIN",
self.modbus.rs485_dir_pin))
if self.modbus.missing_as_zero is True:
source_file.add(cgen.Define(f"MODBUS_MISSING_AS_ZERO", 1))
cnt = 0
for func_name in self.modbus.functions:
if func_name == "read_input":
source_file.add(cgen.Define(f"MB_FUNC_READ_INPUT_ENABLED", 1))
cnt += 1
elif func_name == "read_holding":
source_file.add(cgen.Define(f"MB_FUNC_READ_HOLDING_ENABLED",
1))
cnt += 1
elif func_name == "write_holding":
source_file.add(
cgen.Define(f"MB_FUNC_WRITE_HOLDING_ENABLED", 1))
cnt += 1
elif func_name == "write_multiple_holding":
source_file.add(
cgen.Define(f"MB_FUNC_WRITE_MULTIPLE_HOLDING_ENABLED", 1))
cnt += 1
elif func_name == "read_coils":
source_file.add(cgen.Define(f"MB_FUNC_READ_COILS_ENABLED", 1))
cnt += 1
elif func_name == "write_coils":
source_file.add(cgen.Define(f"MB_FUNC_WRITE_COIL_ENABLED", 1))
cnt += 1
else:
print(f"invalid function: {func_name}")
exit(1)
source_file.add(cgen.Define(f"MB_FUNC_HANDLERS_MAX", cnt))
def visit_Operator(self, o):
blankline = c.Line("")
# Kernel signature and body
body = flatten(self._visit(i) for i in o.children)
decls = self._args_decl(o.parameters)
signature = c.FunctionDeclaration(c.Value(o.retval, o.name), decls)
retval = [c.Line(), c.Statement("return 0")]
kernel = c.FunctionBody(signature, c.Block(body + retval))
# Elemental functions
esigns = []
efuncs = [blankline]
for i in o._func_table.values():
if i.local:
esigns.append(
c.FunctionDeclaration(c.Value(i.root.retval, i.root.name),
self._args_decl(i.root.parameters)))
efuncs.extend([i.root.ccode, blankline])
# Header files, extra definitions, ...
header = [c.Define(*i) for i in o._headers] + [blankline]
includes = [
c.Include(i, system=(False if i.endswith('.h') else True))
for i in o._includes
]
includes += [blankline]
cdefs = [
i._C_typedecl for i in o.parameters if i._C_typedecl is not None
]
for i in o._func_table.values():
if i.local:
cdefs.extend([
j._C_typedecl for j in i.root.parameters
if j._C_typedecl is not None
])
cdefs = filter_sorted(cdefs, key=lambda i: i.tpname)
if o._compiler.src_ext == 'cpp':
cdefs += [c.Extern('C', signature)]
cdefs = [i for j in cdefs for i in (j, blankline)]
return c.Module(header + includes + cdefs + esigns +
[blankline, kernel] + efuncs)
def emit_extern_global_variables(self, source_file):
source_file.add(cgen.Statement(f"static kModbus Modbus"))
source_file.add(cgen.Define(f"MODBUS_ENABLED", 1))
def _cgen(self):
return cgen.Define(self.symbol, self.value)
def _cgen(self):
return cgen.Define(self.macro.definition, self.macro.value)
# INÍCIO BLOCO DE DECLARAÇÃO DE VARIAVEIS GLOBAIS
tempString = c.Assign('int ny', '2')
tempString = append(tempString, c.Assign('int nx', '80'))
tempString = append(tempString, c.Assign('int nt', '100'))
tempString = append(tempString, c.Assign('double nx', '2.0 / (nx + 1.0)'))
tempString = append(tempString, c.Assign('double dy', '2.0 / (ny + 1.0)'))
tempString = append(tempString, c.Assign('double sigma', '0.2'))
tempString = append(tempString, c.Assign('double dt', 'sigma * dx'))
# FIM BLOCO DE DECLARAÇÃO DE VARIAVEIS GLOBAIS
# SALVANDO O VALOR NA STRING PRINCIPAL DE SAÍDA
CodeOutput = tempString
# INÍCIO BLOCO DE INCLUDES E DEFINES
tempString = c.Define("OPS_2D", '')
tempString = append(tempString, c.Include('ops_seq.h', system=True))
tempString = append(tempString, c.Include('iostream', system=True))
tempString = append(tempString, c.Include('fstream', system=True))
tempString = append(tempString, c.Include('convec.h', system=False))
tempString = append(tempString, c.Value('using namespace std', ''))
# FIM BLOCO DE INCLUDES
CodeOutput = append(CodeOutput, tempString)
temp = c.FunctionDeclaration(
c.Value("", "ops_init"),
[c.Value("", "argc"),
c.Value("char", "argv"),
c.Value("", "1")])
# Array para salvar as operações do Main
import cgen as c
code = c.Module([
c.Include('iostream'),
c.Include('stdlib.h'),
c.Include('math.h'),
c.Line(),
c.LineComment('Necessary to declare constant for OPS.'),
c.Value('double', 'dx, dy, dt'),
c.LineComment('Step for each dimension and time.'),
c.Value('double', 'nx, ny'),
c.Line(),
c.Define('PREVIOUS', '0'),
c.Define('CURRENT', '1'),
c.Define('NEXT', '2'),
c.Define('M_PI', '3.14159265358979323846'),
c.Define('BORDER_SIZE', '20'),
c.Define('CPML', '20'),
c.Define('SOURCE_LOCATION_X', '0'),
c.Define('SOURCE_LOCATION_Y', '0'),
c.Define('RICKER_PEAK_FREQUENCY', '5'),
c.Define('MAX_VELOCITY', '5000'),
c.Line(),
c.Define('OPS_2D', ''),
c.Include('ops_seq.h'),
c.Include('ops_lib_cpp.h'),
c.Include('sources.cpp'),
c.Include('velocity-model.cpp'),
c.Include('wave-propagation-ops.h'),
c.Line(),
c.Statement('using namespace std'),
def setup(self, g):
if g.is_parent:
if len(self._path) < 1:
self._path = '%s/%s.%s' % (os.getcwd(), g.name, self._lang.lower())
if len(self.includes) > 0:
for incfile in self.includes:
include = cg.Include('%s.h' % incfile)
self._lines.append(str(include))
self._lines.append('')
if len(self.defines) > 0:
for tuple in self.defines:
(lhs, rhs) = tuple
define = cg.Define(lhs, rhs)
self._lines.append(str(define))
self._lines.append('')
if len(self._typedefs) > 0:
for tuple in self._typedefs:
(lhs, rhs) = tuple
typedef = cg.Typedef(cg.Value(lhs, rhs))
self._lines.append(str(typedef))
self._lines.append('')
if len(self._functions) > 0:
for tuple in self._functions:
(lhs, rhs) = tuple
fxndef = 'inline %s { %s }' % (lhs, rhs)
self._lines.append(fxndef)
self._lines.append('')
if len(self._structs) > 0:
for structname in self._structs:
struct = self._structs[structname]
fields = [cg.Value(struct[name], name) for name in struct]
struct = cg.Struct('', fields)
typedef = cg.Typedef(cg.Value(struct, '%s%s' % (structname, StructNode.suffix())))
self._lines.append(str(typedef).replace('} ;', '}'))
self._lines.append('')
if len(g.constants) > 0:
for const in g.constants:
define = cg.Define(const.name, const.value)
self._lines.append(str(define))
self._lines.append('')
if len(g.includes) > 0:
for incfile in g.includes:
include = cg.Include('%s.h' % incfile)
self._lines.append(str(include))
self._lines.append('')
if len(g.subgraphs) < 1:
func = CGenHelper.functionDecl(g.returntype, g.name, g.params)
decl = str(func)
self._lines.append(decl)
self._lines.append('inline %s' % decl.replace(';', ' {'))
if len(g.constants) > 0:
structname = self._structname
if len(structname) < 1:
structname = g.name.split('_')[0]
if structname not in self._structs:
self._structs[structname] = OrderedDict()
for const in g.constants:
self._structs[structname][const.name] = const.type # Add const to struct for later use...
# -*- mode: python -*-
from gg.ast import *
from gg.lib.graph import Graph
from gg.lib.wl import Worklist
from gg.ast.params import GraphParam
import cgen
G = Graph("graph")
WL = Worklist()
ast = Module([
CBlock(["typedef int edge_data_type", "typedef int node_data_type"]),
CBlock([cgen.Define("MAXFORBID", "32")]),
Kernel("ipgc_init", [G.param()], [
ForAll("node", G.nodes(),
[CBlock(["graph.node_data[node] = 0"]),
WL.push("node")])
]), #initializing all nodes to color 0
Kernel(
"assignColors",
[G.param()],
[
ForAll(
"node",
G.nodes(),
[
CDecl([("int", "FORBIDDEN", ""), ("int", "offset", "=0"),
("bool", "colored", "=false")]),
If(
