def free_memory(self):
"""
- generate code for free allocated memory
- return the generated code as string
"""
statements = []
for field in self.fields:
# alloc aligned memory (on windows and linux)
ifdef = cgen.IfDef('_MSC_VER', [cgen.Statement('_aligned_free(grid->%s)' % (ccode(field.label)))],
[cgen.Statement('free(grid->%s)' % (ccode(field.label)))])
statements.append(ifdef)
return cgen.Module(statements)
def converge_test(self):
"""
- generate code for convergence test
- convergence test implemented by calculating L2 norm
of the simulation against analytical solution
- L2 norm of each field is calculated and output with printf()
- return generated code as string
"""
result = []
if not self.converge:
return cgen.Module(result)
m = self.margin.value
ti = self.ntsteps.value % 2 # last updated grid
loop = [Symbol('_'+x.name) for x in self.index] # symbols for loop
for i in range(len(self.spacing)):
result.append(cgen.Statement('printf("%d\\n")' % self.spacing[i].value))
for field in self.fields:
body = []
l2 = ccode(field.label)+'_l2'
idx = [ti] + loop
result.append(cgen.Initializer(cgen.Value(self.real_t, l2), 0.0))
# populate xvalue, yvalue zvalue code
for d in range(self.dimension-1, -1, -1):
i = loop[d]
i0 = m
i1 = ccode(self.dim[d]-m)
expr = self.spacing[d]*(loop[d] - self.margin.value)
pre = [cgen.Initializer(cgen.Value(self.real_t, self.index[d].name), ccode(expr))]
if d == self.dimension-1:
# inner loop
tn = self.dt.value*self.ntsteps.value \
if not field.staggered[0] \
else self.dt.value*self.ntsteps.value \
+ self.dt.value/2.0
body = [cgen.Statement('%s += %s' % (l2, ccode((field[idx] - (field.sol.subs(self.t, tn)))**2.0)))]
body = pre+body
body = [cgen.For(cgen.InlineInitializer(cgen.Value('int', i), i0), cgen.Line('%s<%s' % (i, i1)), cgen.Line('++%s' % i), cgen.Block(body))]
result += body
volume = 1.0
for i in range(len(self.spacing)):
volume *= self.spacing[i].value
l2_value = 'pow(' + l2 + '*' + ccode(volume) + ', 0.5)'
result.append(cgen.Statement('conv->%s = %s' % (l2, l2_value)))
return cgen.Module(result)
def save_field_block(self, filename, field):
statements = []
statements.append(cgen.Initializer(cgen.Value("int", "dims[]"), "{dim1, dim1, dim1}"))
statements.append(cgen.Initializer(cgen.Value("float", "spacing[]"), "{dx1, dx2, dx3}"))
statements.append(cgen.Assign("std::string vtkfile", "\""+filename+"\" + std::to_string(_ti)"))
statements.append(cgen.Statement("opesci_dump_field_vts_3d(vtkfile, dims, spacing, 2, &"+field+"["+ccode(self.time[len(self.time)-1])+"][0][0][0])"))
return cgen.Module([cgen.Pragma("omp single"), cgen.Block(statements)])
def declare_fields(self):
"""
- generate code for declaring fields
- the generated code first declare fields as std::vector
of size=vec_size, then cast to multidimensional array
- return the generated code as string
"""
result = []
arr = '' # = [dim1][dim2][dim3]...
for d in self.dim:
arr += '[' + d.name + ']'
vsize = 1
for d in self.dim:
vsize *= d.value
vsize *= len(self.time)
statements = []
for field in self.fields:
vec = "_%s_vec" % ccode(field.label)
vec_value = cgen.Pointer(cgen.Value(self.real_t, vec))
# alloc aligned memory (on windows and linux)
statements.append(vec_value)
ifdef = cgen.IfDef('_MSC_VER', [cgen.Assign(vec, '(%s*) _aligned_malloc(%s*sizeof(%s), %s)' % (self.real_t, str(vsize), self.real_t, str(self.alignment)))],
[cgen.Statement('posix_memalign((void **)(&%s), %d, %d*sizeof(%s))' % (vec, self.alignment, vsize, self.real_t))])
statements.append(ifdef)
# cast pointer to multidimensional array
cast_pointer = cgen.Initializer(cgen.Value(self.real_t, "(*%s)%s" % (ccode(field.label), arr)), '(%s (*)%s) %s' % (self.real_t, arr, vec))
statements.append(cast_pointer)
vec = "_%s_vec" % ccode("m")
vec_value = cgen.Pointer(cgen.Value(self.real_t, vec))
statements.append(vec_value)
result += statements
return cgen.Module(result)
def define_papi_events(self):
"""Code fragment that starts PAPI counters for specified events"""
code = []
code.append(cgen.Initializer(cgen.Value('int', 'numevents'), self.numevents_papi))
code.append(cgen.ArrayOf(cgen.Value('int', 'events'), self.numevents_papi))
code.append(cgen.ArrayOf(cgen.Value('long long', 'counters'), self.numevents_papi))
code += [cgen.Statement('opesci_papi_name2event("%s", &(events[%d]))' % (e, i)) for i, e in enumerate(self._papi_events)]
return cgen.Module(code)
def print_convergence(self):
"""Code fragment that prints convergence norms"""
statements = [cgen.Statement('printf("%s %s\\n", conv.%s_l2)' % (ccode(f.label), '\t%.10f', ccode(f.label))) for f in self.fields]
return cgen.Module(statements)
def sum_papi_events(self):
"""Code fragment that reads PAPI counters for specified events"""
code = [cgen.Statement('profiling->g_%s += counters[%d]' % (e, i)) for i, e in enumerate(self._papi_events)]
return cgen.Module(code)