Fix/Add profiling times.

parmepy/examples/mainJM.py

@@ -27,10 +27,12 @@ def scalaire(x):
 
 def run():
     # Parameters
+    t0 = time.time()
     dim = 3
+    nb = 16
     boxLength = [1., 1., 1.]
     boxMin = [0., 0., 0.]
-    nbElem = [16, 16, 16]
+    nbElem = [nb, nb, nb]
     timeStep = 0.02
     FinalTime = 1.
     outputFilePrefix = './res/RK2_'
@@ -47,6 +49,9 @@ def run():
                               formula=scalaire, scalar=True)
     advec = Advection(velo, scal)
     cTspPb = ContinuousTransportProblem(advection=advec)
+
+    t1 = time.time()
+
     cTspPb.discretize(dSpec=[nbElem])
 
     InterpolationMethod = Linear(grid=box.discreteDomain, gvalues=velo.discreteVariable)
@@ -58,14 +63,17 @@ def run():
     solver = GPUParticularSolver(ODESolver, InterpolationMethod, RemeshingMethod)
     cTspPb.setSolver(solver)
     #cTspPb.setPrinter(Printer(frequency=outputModulo, outputPrefix=outputFilePrefix, problem=cTspPb))
-    c0 = time.clock()
+
+    t2 = time.time()
 
     cTspPb.solve(T=FinalTime, dt=timeStep)
-    #tspPb.solve(T=FinalTime, output=outputModulo, outputPrefix=outputFilePrefix)
 
-    c0 = time.clock() - c0
-    print "Solving CPU time : ", c0, "sec (CPU)"
+    tf = time.time()
 
+    print "Total time : ", tf - t0, "sec (CPU)"
+    print "Init Problem : ", t1 - t0, "sec (CPU)"
+    print "Init Solver : ", t2 - t1, "sec (CPU)"
+    print "Solving time : ", tf - t2, "sec (CPU)"
 
 
 if __name__ == "__main__":

parmepy/new_ParMePy/Domain/CartesianGrid.py

@@ -24,7 +24,6 @@ class CartesianGrid(DiscreteDomain):
         @param box Box.Box : ContinuousDomain.ContinuousDomain discretized.
         @param spec : element number for each directions.
         """
-        print "Je construit une CartesianGrid"
         DiscreteDomain.__init__(self, box.dimension)
         self.elementNumber = spec
         self.elementSize = box.length / self.elementNumber

parmepy/new_ParMePy/Operator/AdvectionDOp.py

@@ -76,22 +76,14 @@ class AdvectionDOp(DiscreteOperator):
                 np.concatenate((self.velocity.domain.min, [1.])).astype(np.float32),
                 np.concatenate((self.velocity.domain.max, [1.])).astype(np.float32))
             self.gpu_queue.finish()
-            self.queued_time  += (evt.profile.submit - evt.profile.queued)
-            self.submit_time  += (evt.profile.start  - evt.profile.submit)
+            self.queued_time += (evt.profile.submit - evt.profile.queued)
+            self.submit_time += (evt.profile.start - evt.profile.submit)
             self.compute_time += (evt.profile.end - evt.profile.start)
-            print self.compute_time*10e-10
+            #print "Advection:", self.compute_time * 1e-9
 
     def __str__(self):
         """ToString method"""
-        s = "AdvectionDOp (DiscreteOperator) : {0} \n".format(id(self))
-        s += "  velocity={0}, scalar={1}\n".format(id(self.velocity), id(self.scalar))
-        s += "  Variables : \n"
-        for v in self.variables:
-            s += str(id(v)) + "\n"
-        s += "  Domains : \n"
-        for d in self.domains:
-            s += str(id(d)) + "\n"
-        return s + "\n"
+        return "AdvectionDOp (DiscreteOperator)"
 
 if __name__ == "__main__":
     print __doc__

parmepy/new_ParMePy/Operator/RemeshingDOp.py

@@ -101,8 +101,9 @@ class RemeshingDOp(DiscreteOperator):
                 np.concatenate((self.resultScalar.domain.max, [1.])).astype(np.float32))
             self.gpu_queue.finish()
             self.queued_time += (evt.profile.submit - evt.profile.queued)
-            self.submit_time += (evt.profile.start  - evt.profile.submit)
-            self.compute_time += (evt.profile.end   - evt.profile.start)
+            self.submit_time += (evt.profile.start - evt.profile.submit)
+            self.compute_time += (evt.profile.end - evt.profile.start)
+            #print "Remeshing M'6:", self.compute_time * 1e-9
             evt = self.gpu_kernel[1](self.gpu_queue, self.gpu_shape, None,
                 self.resultScalar.gpu_mem_object, self.gpu_buffer,
                 np.float32(t), np.float32(dt), np.int32(splittingDirection),
@@ -110,20 +111,14 @@ class RemeshingDOp(DiscreteOperator):
                 np.concatenate((self.resultScalar.domain.max, [1.])).astype(np.float32))
             self.gpu_queue.finish()
             self.queued_time += (evt.profile.submit - evt.profile.queued)
-            self.submit_time += (evt.profile.start  - evt.profile.submit)
-            self.compute_time += (evt.profile.end   - evt.profile.start)
+            self.submit_time += (evt.profile.start - evt.profile.submit)
+            self.compute_time += (evt.profile.end - evt.profile.start)
+            #print "Remeshing reduce:", self.compute_time * 1e-9
 
     def __str__(self):
         """ToString method"""
-        s = "RemeshingDOp (DiscreteOperator) : {0} \n".format(id(self))
-        s += "  particles positions = {0}, particles scalar = {1}\n".format(id(self.ppos), id(self.pscal))
-        s += "  Variables : \n"
-        for v in self.variables:
-            s += str(id(v)) + "\n"
-        s += "  Domains : \n"
-        for d in self.domains:
-            s += str(id(d)) + "\n"
-        return s + "\n"
+        return "RemeshingDOp (DiscreteOperator)"
+
 
 if __name__ == "__main__":
     print __doc__

parmepy/new_ParMePy/Problem/DiscreteTransportProblem.py

@@ -59,17 +59,18 @@ class DiscreteTransportProblem(DiscreteProblem):
                 [[op.applyOperator(self.t, dt * i[1], i[0]) for op in self.operators] for i in self.splittingStep]
                 self.t += dt
                 ite += 1
-                print "Iteration ", ite, "\t t =", self.t, "\t(No output mode)"
+                #print "Iteration ", ite, "\t t =", self.t, "\t(No output mode)"
         c_time = 0.
         q_time = 0.
         s_time = 0.
         for op in self.operators:
             c_time += op.compute_time
+            print op, c_time * 1e-9, "s"
             q_time += op.queued_time
             s_time += op.submit_time
-        print "OpenCL queued time  : ", q_time * 10e-9, "s"
-        print "OpenCL submit time  : ", s_time * 10e-9, "s"
-        print "OpenCL computing time : ", c_time * 10e-9, "s"
+        print "OpenCL queued time  : ", q_time * 1e-9, "s"
+        print "OpenCL submit time  : ", s_time * 1e-9, "s"
+        print "OpenCL computing time : ", c_time * 1e-9, "s"
 
     def __str__(self):
         """ToString method"""