Ajout d'un opérateur de transfert de données GPU<->CPU

HySoP/hysop/gpu/__init__.py

@@ -45,3 +45,6 @@ GPU_SRC = os.path.join(__path__[0], "cl_src", '')
 ## If use OpenCL profiling events to time computations
 CL_PROFILE = False
 
+## Transfert direction
+HostToDevice = 9876
+DeviceToHost = 6789

HySoP/hysop/gpu/gpu_transfer.py

+from parmepy.operator.computational import Computational
+from parmepy.gpu import HostToDevice, DeviceToHost
+
+
+class DataTransfer(Computational):
+    """Operator for moving data between CPU and GPU."""
+
+    def __init__(self, way, freq=1, **kwds):
+        """
+        @param way: HostToDevice or DeviceToHost flag setting
+        the data copy direction.
+        """
+        super(DataTransfer, self).__init__(**kwds)
+        ## Transfer way
+        self.way = way
+        ## Transfer frequency in iteration number
+        self.freq = freq
+        ## Current transfer function
+        if self.way == HostToDevice:
+            self._transfer = self._apply_toDevice
+        else:
+            self._transfer = self._apply_toHost
+
+    def setup(self):
+        pass
+
+    def apply(self, simulation):
+        ite = simulation.currentIteration
+        if ite % self.freq == 0:
+            self._transfer()
+
+    def _apply_toHost(self):
+        for v in self.variables:
+            df = self.discreteFields[v]
+            df.toHost()
+            df.wait()
+
+    def _apply_toDevice(self):
+        for v in self.variables:
+            df = self.discreteFields[v]
+            df.toDevice()
+            df.wait()

HySoP/hysop/operator/computational.py

@@ -334,4 +334,5 @@ class Computational(Operator):
         return s + "\n"
 
     def get_profiling_info(self):
-        self.profiler += self.discreteOperator.profiler
+        if self.discreteOperator is not None:
+            self.profiler += self.discreteOperator.profiler

HySoP/hysop/operator/hdf_io.py

@@ -206,16 +206,6 @@ class HDF_Writer(HDF_IO):
             raise ValueError("Missing simulation value for monitoring.")
         ite = simulation.currentIteration
         if ite % self.io_params.frequency == 0:
-            # Transfer from GPU to CPU if required
-            for v in self.variables:
-                df = self.discreteFields[v]
-                try:
-                    if not df.isBatch:
-                        # To host only if data fit in the device memory
-                        df.toHost()
-                        df.wait()
-                except AttributeError:
-                    pass
             self.step(simulation)
             self._count += 1