began kernel autotuner

hysop/gpu/gpu_stretching.py

@@ -58,7 +58,6 @@ class GPUStretching(DiscreteOperator, GPUOperator):
         self.order = 2 if self.method[SpaceDiscretisation] is FDC2 else 4
         
         # Worksize handling
-        #TODO
         self._cl_work_size = 0
 
         ## GPU allocations
@@ -112,21 +111,22 @@ class GPUStretching(DiscreteOperator, GPUOperator):
             raise NotImplementedError(msg)
 
     def _gen_cl_src(self):
-        topo   = self.velocity.topology
-        mesh   = topo.mesh
-        dim    = self.dim
+        typegen = self.cl_env.typegen
+        topo    = self.velocity.topology
+        dim     = self.dim
+        mesh    = topo.mesh
 
-        gwi = (256,256,256)
-        lwi = (4,4,4)
+        gwi = mesh.
+        lwi = (8,8,8)
 
         codegen, prg = self._gen_and_build_kernel(lwi, dump_src=True)
-        
-        cache_bytes    = codegen.cache_alloc_bytes(local_size=lwi)
+        cache_bytes = codegen.cache_alloc_bytes(local_size=lwi)
+
         self.local_mem = cl.LocalMemory(cache_bytes)
         self.size_local_alloc += cache_bytes
 
         from hysop.codegen.structs.mesh_info import MeshInfoStruct
-        mesh_info = MeshInfoStruct.build_instance_from_mesh(self.cl_env.typegen, mesh)
+        mesh_info = MeshInfoStruct.build_instance_from_mesh(typegen, mesh)
         mesh_info_buffer = cl.Buffer(self.cl_env.ctx, cl.mem_flags.READ_ONLY | cl.mem_flags.COPY_HOST_PTR,
                 hostbuf=mesh_info)
         self.mesh_info_buffer = mesh_info_buffer
@@ -165,20 +165,17 @@ class GPUStretching(DiscreteOperator, GPUOperator):
 
         return codegen, prg
 
-    def _compute_stretching(self, simulation, to_gpu=True, to_host=True):
-        if to_gpu:
-            for field in self.input:
-                field.toDevice()
-        
-        input_events  = [evt for input in self.input for evt in input.events]
-        
+    def _compute_stretching(self, simulation):
         dt = self.cl_env.typegen.make_floatn(simulation.time_step,1)
         kernel_args    = [dt] + self.velocity.gpu_data + self.vorticity.gpu_data \
-                            + [self.mesh_info_buffer] + [self.local_mem]
+                            + [self.mesh_info_buffer, self.local_mem]
+
+        input_events  = [evt for input in self.input for evt in input.events]
         stretching_evt = self.kernels['stretching'](*kernel_args, wait_for=input_events)
+        output_events = [stretching_evt]
         
-        if to_host:
-            self.vorticity.toHost()
+        self.vorticity.events.append(output_events)
+
 
     def apply(self, simulation):
         self._compute(simulation)

hysop/gpu/tools.py

@@ -13,6 +13,127 @@ FLOAT_GPU, DOUBLE_GPU = np.float32, np.float64
 __cl_env = None
 
 
+class KernelError(Exception):
+    def __init__(self, msg, err):
+        super(KernelError,self).__init__(msg)
+        self.msg = msg
+        self.err = err
+
+    def __str__(self):
+        return self.err + ': ' + self.msg
+
+class OpenClKernelStatistics(object):
+    def __init__(self, events=None):
+        if events is not None:
+            p0 = events[0].profile
+            t0 = p0.end - p0.start
+            total = 0
+            maxi = t0 
+            mini = t0
+            for evt in events:
+                dt = evt.profile.end - evt.profile.start
+                total += dt
+                if dt<mini: 
+                    mini = dt
+                if dt>maxi:
+                    maxi = dt
+            
+            self.tot = total
+            self.min = mini
+            self.max = maxi
+            self.mean = total/len(events)
+        else:
+            self.tot  = 0
+            self.min  = 0
+            self.max  = 0
+            self.mean = 0
+
+    def __str__(self):
+        mini  = self.min   * 1e-6
+        maxi  = self.max   * 1e-6
+        total = self.tot   * 1e-6
+        mean  = self.mean  * 1e-6
+        return 'min={:.2f}ms, max={:.2f}ms, mean={:.2f}ms'.format(mini,maxi,mean)
+            
+
+class KernelAutotuner(object):
+    """OpenCl kernel work group size autotuner.
+    """
+    def __init__(self,work_dim, runs=10):
+        """Initialize a KernelAutotuner.
+        
+        Parameters
+        ----------
+        work_dim: int
+            Work dimension used in targetted OpenCL kernels.
+        """
+        self.work_dim = work_dim
+        self.nruns    = nruns
+        self._load_default_filters()
+
+    def add_filter(fname, f):
+        self.filters[fname] = f
+        return self
+
+    def bench(self,ctx,device,global_size,args,kernel=None,kernel_generator=None,**kargs):
+        assert isinstance(args, list)
+        if (kernel is None) ^ (kernel_generator is None):
+            raise ValueError('Either kernel or kernel_generator should not be None!')
+        if (kernel_generator is None):
+            kernel_generator = lambda **kargs: (kernel, args)
+
+        for local_size in _get_wi_candidates(ctx,device,global_size,**kargs):
+            kernel, args = kernel_generator(ctx,device,global_size,**kargs)
+            stats = self._bench_one(global_size,local_size,kernels,args)
+            print '{}\t{}'.format(local_size,stats)
+    
+    def _bench_one(global_size,local_size,kernel,kargs):
+        evts = []
+        with cl.CommandQueue(ctx,device,cl.command_queue_properties.PROFILING_ENABLE) as queue:
+            for i in xrange(self.nruns):
+                evt = stretching_kernel(queue, global_size, local_size, *kargs)
+                evts.append(evt)
+        stats = OpenClKernelStatistics(evts)
+        return stats
+
+    def _get_wi_candidates(ctx,device,global_size,**kargs):
+        pows = []
+        size = device.max_work_group_size
+        while(size>0):
+            pows.append(size)
+            size >>= 1
+
+        candidates = itertools.product(pows,pows,pows)
+        for f in self.filters.values:
+            F = f(ctx=ctx,device=device,global_size=global_size,**kargs)
+            candidates = itertools.ifilter(F, candidates)
+        return candidates
+
+    def _load_default_filters(self):
+        self.filters = {}
+        self.add_filter('dim_reqs',self._dim_filter)
+        self.add_filter('ordering',self._ordering_filter)
+        self.add_filter('minmax_wi'self._minmax_workitems_filter)
+
+    
+    #filters
+    def _dim_filter(self, device,**kargs):
+            work_dim   = self.work_dim
+            max_wi_dim = device.max_work_item_dimensions
+            return lambda local_size: (work_dim<=max_wi_dim) and (local_size[work_dim:]==1).all()
+    def _ordering_filter(self, **kargs):
+        return lambda local_size: (local_size[2]<=local_size[1]) and (local_size[1]<=local_size[0])
+    def _global_size_filter(self, global_size, **kargs):
+        return lambda local_size: (local_size[0]<=global_size[0]) and (local_size[1]<=global_size[1]) and (local_size[2]<=global_size[2])
+    def _minmax_workitems_filter(self, device,**kargs):
+        def filter(local_size):
+            max_wi_size = device.max_work_item_sizes
+            wi=1
+            for i in xrange(3):
+                wi*=local_size[i]
+            return (wi>=max_wi_size/8) and (wi<=max_wi_size)
+
+
 class OpenCLEnvironment(object):
     """OpenCL environment informations and useful functions.
     """