def lhs_overhead(self, a, bcs=None, N=1000):
     A = assemble(a, bcs=bcs)
     A.M
     tic('matrix assembly')
     for _ in range(N):
         assemble(a, tensor=A, bcs=bcs).M
     return toc('matrix assembly')/N
Example #2
0
    def timestep_iteration():
        # Advection

        if have_advection:
            tic('advection')
            tic('assembly')
            mat.zero()

            op2.par_loop(
                mass, elements(3, 3),
                mat((elem_node[op2.i[0]], elem_node[op2.i[1]]), op2.INC),
                coords(elem_node, op2.READ))

            op2.par_loop(zero_dat, nodes, b(op2.IdentityMap, op2.WRITE))

            op2.par_loop(adv_rhs, elements(3), b(elem_node[op2.i[0]], op2.INC),
                         coords(elem_node, op2.READ),
                         tracer(elem_node, op2.READ),
                         velocity(elem_node, op2.READ))
            toc('assembly')
            tic('solve')
            op2.solve(mat, tracer, b)
            toc('solve')
            toc('advection')

        # Diffusion

        if have_diffusion:
            tic('diffusion')
            tic('assembly')
            mat.zero()

            op2.par_loop(
                diff_matrix, elements(3, 3),
                mat((elem_node[op2.i[0]], elem_node[op2.i[1]]), op2.INC),
                coords(elem_node, op2.READ))

            op2.par_loop(zero_dat, nodes, b(op2.IdentityMap, op2.WRITE))

            op2.par_loop(diff_rhs, elements(3), b(elem_node[op2.i[0]],
                                                  op2.INC),
                         coords(elem_node, op2.READ),
                         tracer(elem_node, op2.READ))

            toc('assembly')
            tic('solve')
            op2.solve(mat, tracer, b)
            toc('solve')
            toc('diffusion')
Example #3
0
 def test_reset_timers(self):
     tic('test_reset')
     toc('test_reset')
     reset_timers()
     assert get_timers().keys() == []
Example #4
0
 def test_create(self):
     tic('create')
     toc('create')
     assert 'create' in get_timers().keys()
Example #5
0
 def test_reset(self):
     tic("test_reset")
     toc("test_reset")
     reset()
     assert get_timers().keys() == []
Example #6
0
 def test_create(self):
     tic("create")
     toc("create")
     assert "create" in get_timers().keys()
 def rhs_ffc_overhead(self, L, bcs=None, N=1000):
     tic('rhs assembly')
     for _ in range(N):
         # Need to create new copies of the forms, since kernels are cached
         assemble(copy(L), bcs=bcs).dat.data_ro
     return toc('rhs assembly')/N
 def rhs_overhead(self, L, bcs=None, N=1000):
     b = assemble(L, bcs=bcs)
     tic('rhs assembly')
     for _ in range(N):
         assemble(L, tensor=b, bcs=bcs).dat.data_ro
     return toc('rhs assembly')/N
 def lhs_ffc_overhead(self, a, bcs=None, N=1000):
     tic('matrix assembly')
     for _ in range(N):
         # Need to create new copies of the forms, since kernels are cached
         assemble(copy(a), bcs=bcs).M
     return toc('matrix assembly')/N
Example #10
0
 def test_reset_timers(self):
     tic('test_reset')
     toc('test_reset')
     reset_timers()
     assert get_timers().keys() == []
Example #11
0
 def test_create(self):
     tic('create')
     toc('create')
     assert 'create' in get_timers().keys()
Example #12
0
    def wave(self, scale=1.0, lump_mass=True, N=100, save=False, weak=False,
             verbose=False, measure_overhead=False):
        if weak:
            self.series['weak'] = scale
            scale = round(scale/sqrt(op2.MPI.comm.size), 3)
            self.meta['scale'] = scale
        else:
            self.series['scale'] = scale
        self.meta['cells'] = cells[scale]
        self.meta['vertices'] = vertices[scale]
        if measure_overhead:
            mesh = UnitSquareMesh(1, 1)
        else:
            t_, mesh = self.make_mesh(scale)
            self.register_timing('mesh', t_)
        with self.timed_region('setup'):
            V = FunctionSpace(mesh, 'Lagrange', 1)
            total_dofs = np.zeros(1, dtype=int)
            op2.MPI.comm.Allreduce(np.array([V.dof_dset.size], dtype=int), total_dofs)
            self.meta['dofs'] = total_dofs[0]
            if verbose:
                print '[%d]' % op2.MPI.comm.rank, 'DOFs:', V.dof_dset.size
            p = Function(V)
            phi = Function(V, name="phi")

            u = TrialFunction(V)
            v = TestFunction(V)

            bcval = Constant(0.0)
            bc = DirichletBC(V, bcval, 1)

            if lump_mass:
                Ml = assemble(1.0 / assemble(v*dx))

            dt = 0.001 * scale
            dtc = Constant(dt)
            t = 0.0

            rhs = inner(grad(v), grad(phi)) * dx

            if save:
                outfile = File("vtk/firedrake_wave_%s.pvd" % scale)
                outfile << phi

        b = assemble(rhs)
        dphi = 0.5 * dtc * p
        dp = dtc * Ml * b
        if measure_overhead:
            repeats = 1000
            tic('phi')
            for _ in range(repeats):
                phi -= dphi
                phi.dat.data_ro
            phi_overhead = N*toc('phi')/repeats
            print "phi overhead:", phi_overhead
            tic('p')
            for _ in range(repeats):
                bcval.assign(sin(2*pi*5*_*dt))
                assemble(rhs, tensor=b)
                p += dp
                bc.apply(p)
                p.dat.data_ro
            p_overhead = N*toc('p')/repeats
            print "p overhead:", p_overhead
            return phi_overhead, p_overhead
        with self.timed_region('timestepping'):
            while t < N*dt:
                bcval.assign(sin(2*pi*5*t))

                with self.timed_region('phi'):
                    phi -= dphi
                    phi.dat.data_ro

                with self.timed_region('p'):
                    if lump_mass:
                        assemble(rhs, tensor=b)
                        p += dp
                        bc.apply(p)
                        p.dat.data_ro
                    else:
                        solve(u * v * dx == v * p * dx + dtc * rhs,
                              p, bcs=bc, solver_parameters={'ksp_type': 'cg',
                                                            'pc_type': 'sor',
                                                            'pc_sor_symmetric': True})

                with self.timed_region('phi'):
                    phi -= dphi
                    phi.dat.data_ro

                t += dt
                if save:
                    outfile << phi
        for task, timer in get_timers(reset=True).items():
            self.register_timing(task, timer.total)
Example #13
0
    def timestep_iteration():
        # Advection

        if have_advection:
            tic("advection")
            tic("assembly")
            mat.zero()

            op2.par_loop(
                mass,
                elements(3, 3),
                mat((elem_node[op2.i[0]], elem_node[op2.i[1]]), op2.INC),
                coords(elem_node, op2.READ),
            )

            op2.par_loop(zero_dat, nodes, b(op2.IdentityMap, op2.WRITE))

            op2.par_loop(
                adv_rhs,
                elements(3),
                b(elem_node[op2.i[0]], op2.INC),
                coords(elem_node, op2.READ),
                tracer(elem_node, op2.READ),
                velocity(elem_node, op2.READ),
            )
            toc("assembly")
            tic("solve")
            op2.solve(mat, tracer, b)
            toc("solve")
            toc("advection")

        # Diffusion

        if have_diffusion:
            tic("diffusion")
            tic("assembly")
            mat.zero()

            op2.par_loop(
                diff_matrix,
                elements(3, 3),
                mat((elem_node[op2.i[0]], elem_node[op2.i[1]]), op2.INC),
                coords(elem_node, op2.READ),
            )

            op2.par_loop(zero_dat, nodes, b(op2.IdentityMap, op2.WRITE))

            op2.par_loop(
                diff_rhs,
                elements(3),
                b(elem_node[op2.i[0]], op2.INC),
                coords(elem_node, op2.READ),
                tracer(elem_node, op2.READ),
            )

            toc("assembly")
            tic("solve")
            op2.solve(mat, tracer, b)
            toc("solve")
            toc("diffusion")