Changeset 48fbd50 in sasmodels

Timestamp:

Mar 21, 2016 6:02:51 PM (9 years ago)

Author:

Paul Kienzle <pkienzle@…>

Branches:

master, core_shell_microgels, costrafo411, magnetic_model, release_v0.94, release_v0.95, ticket-1257-vesicle-product, ticket_1156, ticket_1265_superball, ticket_822_more_unit_tests

Children:

25b30fd, 3a45c2c

Parents:

88aa3ee

Message:

twiddle with kernel interface

Files:

• doc/developer/calculator.rst (modified) (1 diff)
• sasmodels/core.py (modified) (3 diffs)
• sasmodels/direct_model.py (modified) (2 diffs)
• sasmodels/generate.py (modified) (1 diff)
• sasmodels/kernelcl.py (modified) (6 diffs)
• sasmodels/kerneldll.py (modified) (3 diffs)
• sasmodels/kernelpy.py (modified) (2 diffs)
• sasmodels/model_test.py (modified) (2 diffs)
• sasmodels/resolution.py (modified) (4 diffs)

doc/developer/calculator.rst

@@ -133 +133 @@
 decreasing order of length for highest efficiency.
 
-We limit the number of polydisperse dimensions to MAX_PD (currently 4).
-This cuts the size of the structure in half compared to allowing a
-separate polydispersity for each parameter.  This will help a little
-bit for models with large numbers of parameters, such as the onion model.
+We limit the number of polydisperse dimensions to MAX_PD (currently 4),
+though some models may have fewer if they have fewer polydisperse
+parameters. This cuts the size of the structure in half compared to
+allowing a separate polydispersity for each parameter.  This will
+help a little bit for models with large numbers of parameters, such
+as the onion model.
 
 Parameters may be coordinated.  That is, we may have the value of one

sasmodels/core.py

@@ -26 +26 @@
 __all__ = [
     "list_models", "load_model_info", "precompile_dll",
-    "build_model", "make_kernel", "call_kernel", "call_ER_VR",
+    "build_model", "call_kernel", "call_ER_VR",
 ]
 
@@ -167 +167 @@
 
 
-def make_kernel(model, q_vectors):
-    """
-    Return a computation kernel from the model definition and the q input.
-    """
-    return model(q_vectors)
-
 def get_weights(parameter, values):
     """
@@ -210 +204 @@
 def call_kernel(kernel, pars, cutoff=0, mono=False):
     """
-    Call *kernel* returned from :func:`make_kernel` with parameters *pars*.
+    Call *kernel* returned from *model.make_kernel* with parameters *pars*.
 
     *cutoff* is the limiting value for the product of dispersion weights used

sasmodels/direct_model.py

@@ -25 +25 @@
 import numpy as np
 
-from .core import make_kernel
 from .core import call_kernel, call_ER_VR
 from . import sesans
@@ -153 +152 @@
     def _calc_theory(self, pars, cutoff=0.0):
         if self._kernel is None:
-            self._kernel = make_kernel(self._model, self._kernel_inputs)  # pylint: disable=attribute-dedata_type
-            self._kernel_mono = make_kernel(self._model, self._kernel_mono_inputs) if self._kernel_mono_inputs else None
+            self._kernel = self._model.make_kernel(self._kernel_inputs)
+            self._kernel_mono = (
+                self._model.make_kernel(self._kernel_mono_inputs)
+                if self._kernel_mono_inputs else None
+            )
 
         Iq_calc = call_kernel(self._kernel, pars, cutoff=cutoff)
-        Iq_mono = call_kernel(self._kernel_mono, pars, mono=True) if self._kernel_mono_inputs else None
+        Iq_mono = (call_kernel(self._kernel_mono, pars, mono=True)
+                   if self._kernel_mono_inputs else None)
         if self.data_type == 'sesans':
             result = sesans.transform(self._data,

sasmodels/generate.py

@@ -685 +685 @@
 def poly_details(model_info, weights):
     print("entering poly",weights)
+    print([p.name for p in model_info['parameters']])
     pars = model_info['parameters'][2:]  # skip scale and background
     max_pd = model_info['max_pd']

sasmodels/kernelcl.py

@@ -336 +336 @@
         self.program = None
 
-    def make_calculator(self, q_vectors, details):
+    def make_kernel(self, q_vectors):
         if self.program is None:
             compiler = environment().compile_program
@@ -344 +344 @@
         kernel_name = generate.kernel_name(self.info, is_2d)
         kernel = getattr(self.program, kernel_name)
-        return GpuKernel(kernel, self.info, q_vectors, details, self.dtype)
+        return GpuKernel(kernel, self.info, q_vectors, self.dtype)
 
     def release(self):
@@ -403 +403 @@
         context = env.get_context(self.dtype)
         #print("creating inputs of size", self.global_size)
-        # COPY_HOST_PTR initiates transfer as necessary?
         self.q_b = cl.Buffer(context, mf.READ_ONLY | mf.COPY_HOST_PTR,
                              hostbuf=self.q)
@@ -438 +437 @@
     Call :meth:`release` when done with the kernel instance.
     """
-    def __init__(self, kernel, model_info, q_vectors, details, dtype):
-        if details.dtype != np.int32:
-            raise TypeError("numeric type does not match the kernel type")
-
+    def __init__(self, kernel, model_info, q_vectors, dtype):
         max_pd = self.info['max_pd']
         npars = len(model_info['parameters'])-2
@@ -449 +445 @@
         self.kernel = kernel
         self.info = model_info
-        self.details = details
         self.pd_stop_index = 4*max_pd-1
         # plus three for the normalization values
@@ -459 +454 @@
         self.queue = env.get_queue(dtype)
 
-        # details is int32 data, padded to a 32 integer boundary
-        size = 4*((self.info['mono'].size+7)//8)*8 # padded to 32 byte boundary
-        self.details_b = cl.Buffer(self.queue.context,
-                                   mf.READ_ONLY | mf.COPY_HOST_PTR,
-                                   hostbuf=details)
-        size = np.sum(details[max_pd:2*max_pd])
-        self.weights_b = cl.Buffer(self.queue.context, mf.READ_ONLY, size)
-        size = np.sum(details[max_pd:2*max_pd])+npars
-        self.values_b = cl.Buffer(self.queue.context, mf.READ_ONLY, size)
+        # details is int32 data, padded to an 8 integer boundary
+        size = ((max_pd*5 + npars*3 + 2 + 7)//8)*8
         self.result_b = cl.Buffer(self.queue.context, mf.READ_WRITE,
                                q_input.global_size[0] * q_input.dtype.itemsize)
         self.q_input = q_input # allocated by GpuInput above
 
-        self._need_release = [
-            self.details_b, self.weights_b, self.values_b, self.result_b,
-            self.q_input,
-        ]
-
-    def __call__(self, weights, values, cutoff):
+        self._need_release = [ self.result_b, self.q_input ]
+
+    def __call__(self, details, weights, values, cutoff):
         real = (np.float32 if self.q_input.dtype == generate.F32
                 else np.float64 if self.q_input.dtype == generate.F64
                 else np.float16 if self.q_input.dtype == generate.F16
                 else np.float32)  # will never get here, so use np.float32
-
-        if weights.dtype != real or values.dtype != real:
-            raise TypeError("numeric type does not match the kernel type")
-
-        cl.enqueue_copy(self.queue, self.weights_b, weights)
-        cl.enqueue_copy(self.queue, self.values_b, values)
-
+        assert details.dtype == np.int32
+        assert weights.dtype == real and values.dtype == real
+
+        context = self.queue.context
+        details_b = cl.Buffer(context, mf.READ_ONLY | mf.COPY_HOST_PTR,
+                              hostbuf=details)
+        weights_b = cl.Buffer(context, mf.READ_ONLY | mf.COPY_HOST_PTR,
+                              hostbuf=weights)
+        values_b = cl.Buffer(context, mf.READ_ONLY | mf.COPY_HOST_PTR,
+                             hostbuf=values)
+
+        start, stop = 0, self.details[self.pd_stop_index]
         args = [
-            np.uint32(self.q_input.nq),
-            np.uint32(0),
-            np.uint32(self.details[self.pd_stop_index]),
-            self.details_b,
-            self.weights_b,
-            self.values_b,
-            self.q_input.q_b,
-            self.result_b,
-            real(cutoff),
+            np.uint32(self.q_input.nq), np.uint32(start), np.uint32(stop),
+            self.details_b, self.weights_b, self.values_b,
+            self.q_input.q_b, self.result_b, real(cutoff),
         ]
         self.kernel(self.queue, self.q_input.global_size, None, *args)
         cl.enqueue_copy(self.queue, self.result, self.result_b)
+        [v.release() for v in details_b, weights_b, values_b]
 
         return self.result[:self.nq]

sasmodels/kerneldll.py

@@ -218 +218 @@
         self.dll = None
 
-    def __call__(self, q_vectors):
+    def make_kernel(self, q_vectors):
         q_input = PyInput(q_vectors, self.dtype)
         if self.dll is None: self._load_dll()
@@ -251 +251 @@
     """
     def __init__(self, kernel, model_info, q_input):
+        self.kernel = kernel
         self.info = model_info
         self.q_input = q_input
         self.dtype = q_input.dtype
-        self.kernel = kernel
-        self.res = np.empty(q_input.nq+3, q_input.dtype)
         self.dim = '2d' if q_input.is_2d else '1d'
-
-        # In dll kernel, but not in opencl kernel
-        self.p_res = self.res.ctypes.data
+        self.result = np.empty(q_input.nq+3, q_input.dtype)
 
     def __call__(self, details, weights, values, cutoff):
@@ -265 +262 @@
                 else np.float64 if self.q_input.dtype == generate.F64
                 else np.float128)
-        if details.dtype != np.int32 or weights.dtype != real or values.dtype != real:
-            raise TypeError("numeric type does not match the kernel type")
-        #details = np.asarray(details, dtype='int32')
-        #weights = np.asarray(weights, dtype=real)
-        #values = np.asarray(values, dtype=real)
-        #TODO: How can I access max_pd and is this the way to do it?
-        #max_pd = model_info['max_pd']
-        max_pd = 1
+        assert details.dtype == np.int32
+        assert weights.dtype == real and values.dtype == real
+
+        max_pd = self.info['max_pd']
+        start, stop = 0, details[4*max_pd-1]
         args = [
             self.q_input.nq, # nq
-            #TODO: pd_start will need to be changed
-            0, # pd_start
-            details[3*max_pd:4*max_pd], # pd_stop pd_stride[MAX_PD]
+            start, # pd_start
+            stop, # pd_stop pd_stride[MAX_PD]
             details.ctypes.data, # problem
             weights.ctypes.data,  # weights
             values.ctypes.data,  #pars
-            self.q_input.q_pointers[0], #q
-            self.p_res,   # results
+            self.q_input.q.ctypes.data, #q
+            self.result.ctypes.data,   # results
             real(cutoff), # cutoff
             ]
         self.kernel(*args)
-        return self.res[:-3]
+        return self.result[:-3]
 
     def release(self):

sasmodels/kernelpy.py

@@ -53 +53 @@
         self.dtype = dtype
         self.is_2d = (len(q_vectors) == 2)
-        self.q_vectors = [np.ascontiguousarray(q, self.dtype) for q in q_vectors]
-        self.q_pointers = [q.ctypes.data for q in self.q_vectors]
+        if self.is_2d:
+            self.q = np.empty((self.nq, 2), dtype=dtype)
+            self.q[:, 0] = q_vectors[0]
+            self.q[:, 1] = q_vectors[1]
+        else:
+            self.q = np.empty(self.nq, dtype=dtype)
+            self.q[:self.nq] = q_vectors[0]
 
     def release(self):
@@ -60 +65 @@
         Free resources associated with the model inputs.
         """
-        self.q_vectors = []
+        self.q = None
 
 class PyKernel(object):

sasmodels/model_test.py

@@ -51 +51 @@
 
 from .core import list_models, load_model_info, build_model, HAVE_OPENCL
-from .core import make_kernel, call_kernel, call_ER, call_VR
+from .core import call_kernel, call_ER, call_VR
 from .exception import annotate_exception
 
@@ -187 +187 @@
                 Qx, Qy = zip(*x)
                 q_vectors = [np.array(Qx), np.array(Qy)]
-                kernel = make_kernel(model, q_vectors)
+                kernel = model.make_kernel(q_vectors)
                 actual = call_kernel(kernel, pars)
             else:
                 q_vectors = [np.array(x)]
-                kernel = make_kernel(model, q_vectors)
+                kernel = model.make_kernel(q_vectors)
                 actual = call_kernel(kernel, pars)
 

sasmodels/resolution.py

@@ -479 +479 @@
     """
     from sasmodels import core
-    kernel = core.make_kernel(form, [q])
+    kernel = form.make_kernel([q])
     theory = core.call_kernel(kernel, pars)
     kernel.release()
@@ -562 +562 @@
         extra = set(pars.keys()) - par_set
         raise ValueError("bad parameters: [%s] not in [%s]"%
-                         (", ".join(sorted(extra)), ", ".join(sorted(keys))))
+                         (", ".join(sorted(extra)),
+                          ", ".join(sorted(pars.keys()))))
 
     _fn = lambda q, q0, dq: eval_form(q, form, pars)*gaussian(q, q0, dq)
@@ -696 +697 @@
     def _eval_sphere(self, pars, resolution):
         from sasmodels import core
-        kernel = core.make_kernel(self.model, [resolution.q_calc])
+        kernel = self.model.make_kernel([resolution.q_calc])
         theory = core.call_kernel(kernel, pars)
         result = resolution.apply(theory)
@@ -1065 +1066 @@
     model = core.build_model(model_info)
 
-    kernel = core.make_kernel(model, [resolution.q_calc])
+    kernel = model.make_kernel([resolution.q_calc])
     theory = core.call_kernel(kernel, pars)
     Iq = resolution.apply(theory)