Changeset 36a2418 in sasmodels

Timestamp:

Mar 6, 2019 3:16:13 PM (6 years ago)

Author:

Paul Kienzle <pkienzle@…>

Branches:

master, core_shell_microgels, magnetic_model, ticket-1257-vesicle-product, ticket_1156, ticket_1265_superball, ticket_822_more_unit_tests

Children:

da3638f

Parents:

fa26e78 (diff), e5bbe64 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'beta_approx' into ticket-1015-gpu-mem-error

Files:

• README.rst (modified) (2 diffs)
• explore/beta/data_files/sasfit_ellipsoid_schulz_IQBD.txt (moved) (moved from explore/beta/data_files/richard_test6.txt)
• explore/beta/data_files/sasfit_ellipsoid_schulz_IQD.txt (moved) (moved from explore/beta/data_files/richard_test4.txt)
• explore/beta/data_files/sasfit_ellipsoid_schulz_IQSD.txt (moved) (moved from explore/beta/data_files/richard_test5.txt)
• explore/beta/data_files/sasfit_sphere_schulz_IQBD.txt (moved) (moved from explore/beta/data_files/richard_test3.txt)
• explore/beta/data_files/sasfit_sphere_schulz_IQD.txt (moved) (moved from explore/beta/data_files/richard_test.txt)
• explore/beta/data_files/sasfit_sphere_schulz_IQSD.txt (moved) (moved from explore/beta/data_files/richard_test2.txt)
• explore/beta/sasfit_compare.py (modified) (2 diffs)
• explore/precision.py (modified) (3 diffs)
• sasmodels/generate.py (modified) (2 diffs)
• sasmodels/kernel.py (modified) (1 diff)
• sasmodels/models/pearl_necklace.c (modified) (1 diff)
• sasmodels/sasview_model.py (modified) (4 diffs)
• sasmodels/kernelcl.py (modified) (35 diffs)
• sasmodels/kernelcuda.py (modified) (26 diffs)
• sasmodels/kerneldll.py (modified) (15 diffs)
• sasmodels/kernelpy.py (modified) (11 diffs)
• sasmodels/model_test.py (modified) (1 diff)
• sasmodels/models/rpa.c (modified) (6 diffs)

README.rst

@@ -10 +10 @@
 is available.
 
-Example
+Install
 -------
+
+The easiest way to use sasmodels is from `SasView <http://www.sasview.org/>`_.
+
+You can also install sasmodels as a standalone package in python. Use
+`miniconda <https://docs.conda.io/en/latest/miniconda.html>`_
+or `anaconda <https://www.anaconda.com/>`_
+to create a python environment with the sasmodels dependencies::
+
+    $ conda create -n sasmodels -c conda-forge numpy scipy matplotlib pyopencl
+
+The option ``-n sasmodels`` names the environment sasmodels, and the option
+``-c conda-forge`` selects the conda-forge package channel because pyopencl
+is not part of the base anaconda distribution.
+
+Activate the environment and install sasmodels::
+
+    $ conda activate sasmodels
+    (sasmodels) $ pip install sasmodels
+
+Install `bumps <https://github.com/bumps/bumps>`_ if you want to use it to fit
+your data::
+
+    (sasmodels) $ pip install bumps
+
+Usage
+-----
+
+Check that the works::
+
+    (sasmodels) $ python -m sasmodels.compare cylinder
+
+To show the orientation explorer::
+
+    (sasmodels) $ python -m sasmodels.jitter
+
+Documentation is available online as part of the SasView
+`fitting perspective <http://www.sasview.org/docs/index.html>`_
+as well as separate pages for
+`individual models <http://www.sasview.org/docs/user/sasgui/perspectives/fitting/models/index.html>`_.
+Programming details for sasmodels are available in the
+`developer documentation <http://www.sasview.org/docs/dev/dev.html>`_.
+
+
+Fitting Example
+---------------
 
 The example directory contains a radial+tangential data set for an oriented
 rod-like shape.
 
-The data is loaded by sas.dataloader from the sasview package, so sasview
-is needed to run the example.
+To load the example data, you will need the SAS data loader from the sasview
+package. This is not yet available on PyPI, so you will need a copy of the
+SasView source code to run it.  Create a directory somewhere to hold the
+sasview and sasmodels source code, which we will refer to as $SOURCE.
 
-To run the example, you need sasview, sasmodels and bumps.  Assuming these
-repositories are installed side by side, change to the sasmodels/example
-directory and enter::
+Use the following to install sasview, and the sasmodels examples::
 
-    PYTHONPATH=..:../../sasview/src ../../bumps/run.py fit.py \
-        cylinder --preview
+    (sasmodels) $ cd $SOURCE
+    (sasmodels) $ conda install git
+    (sasmodels) $ git clone https://github.com/sasview/sasview.git
+    (sasmodels) $ git clone https://github.com/sasview/sasmodels.git
 
-See bumps documentation for instructions on running the fit.  With the
-python packages installed, e.g., into a virtual environment, then the
-python path need not be set, and the command would be::
+Set the path to the sasview source on your python path within the sasmodels
+environment.  On Windows, this will be::
 
-    bumps fit.py cylinder --preview
+    (sasmodels)> set PYTHONPATH="$SOURCE\sasview\src"
+    (sasmodels)> cd $SOURCE/sasmodels/example
+    (sasmodels)> python -m bumps.cli fit.py cylinder --preview
+
+On Mac/Linux with the standard shell this will be::
+
+    (sasmodels) $ export PYTHONPATH="$SOURCE/sasview/src"
+    (sasmodels) $ cd $SOURCE/sasmodels/example
+    (sasmodels) $ bumps fit.py cylinder --preview
 
 The fit.py model accepts up to two arguments.  The first argument is the
@@ -38 +92 @@
 both radial and tangential simultaneously, use the word "both".
 
-Notes
------
-
-cylinder.c + cylinder.py is the cylinder model with renamed variables and
-sld scaled by 1e6 so the numbers are nicer.  The model name is "cylinder"
-
-lamellar.py is an example of a single file model with embedded C code.
+See `bumps documentation <https://bumps.readthedocs.io/>`_ for detailed
+instructions on running the fit.
 
 |TravisStatus|_

explore/beta/sasfit_compare.py

@@ -505 +505 @@
     }
 
-    Q, IQ = load_sasfit(data_file('richard_test.txt'))
-    Q, IQSD = load_sasfit(data_file('richard_test2.txt'))
-    Q, IQBD = load_sasfit(data_file('richard_test3.txt'))
+    Q, IQ = load_sasfit(data_file('sasfit_sphere_schulz_IQD.txt'))
+    Q, IQSD = load_sasfit(data_file('sasfit_sphere_schulz_IQSD.txt'))
+    Q, IQBD = load_sasfit(data_file('sasfit_sphere_schulz_IQBD.txt'))
     target = Theory(Q=Q, F1=None, F2=None, P=IQ, S=None, I=IQSD, Seff=None, Ibeta=IQBD)
     actual = sphere_r(Q, norm="sasfit", **pars)
@@ -526 +526 @@
     }
 
-    Q, IQ = load_sasfit(data_file('richard_test4.txt'))
-    Q, IQSD = load_sasfit(data_file('richard_test5.txt'))
-    Q, IQBD = load_sasfit(data_file('richard_test6.txt'))
+    Q, IQ = load_sasfit(data_file('sasfit_ellipsoid_shulz_IQD.txt'))
+    Q, IQSD = load_sasfit(data_file('sasfit_ellipsoid_shulz_IQSD.txt'))
+    Q, IQBD = load_sasfit(data_file('sasfit_ellipsoid_shulz_IQBD.txt'))
     target = Theory(Q=Q, F1=None, F2=None, P=IQ, S=None, I=IQSD, Seff=None, Ibeta=IQBD)
     actual = ellipsoid_pe(Q, norm="sasfit", **pars)

explore/precision.py

@@ -207 +207 @@
     return model_info
 
-# Hack to allow second parameter A in two parameter functions
+# Hack to allow second parameter A in the gammainc and gammaincc functions.
+# Create a 2-D variant of the precision test if we need to handle other two
+# parameter functions.
 A = 1
 def parse_extra_pars():
+    """
+    Parse the command line looking for the second parameter "A=..." for the
+    gammainc/gammaincc functions.
+    """
     global A
 
@@ -333 +339 @@
 )
 add_function(
+    # Note: "a" is given as A=... on the command line via parse_extra_pars
     name="gammainc(x)",
     mp_function=lambda x, a=A: mp.gammainc(a, a=0, b=x)/mp.gamma(a),
@@ -339 +346 @@
 )
 add_function(
+    # Note: "a" is given as A=... on the command line via parse_extra_pars
     name="gammaincc(x)",
     mp_function=lambda x, a=A: mp.gammainc(a, a=x, b=mp.inf)/mp.gamma(a),

sasmodels/generate.py

@@ -703 +703 @@
     """
     for code in source:
-        m = _FQ_PATTERN.search(code)
-        if m is not None:
+        if _FQ_PATTERN.search(code) is not None:
             return True
     return False
@@ -712 +711 @@
     # type: (List[str]) -> bool
     """
-    Return True if C source defines "void Fq(".
+    Return True if C source defines "double shell_volume(".
     """
     for code in source:
-        m = _SHELL_VOLUME_PATTERN.search(code)
-        if m is not None:
+        if _SHELL_VOLUME_PATTERN.search(code) is not None:
             return True
     return False

sasmodels/kernel.py

@@ -135 +135 @@
         nout = 2 if self.info.have_Fq and self.dim == '1d' else 1
         total_weight = self.result[nout*self.q_input.nq + 0]
+        # Note: total_weight = sum(weight > cutoff), with cutoff >= 0, so it
+        # is okay to test directly against zero.  If weight is zero then I(q),
+        # etc. must also be zero.
         if total_weight == 0.:
             total_weight = 1.

sasmodels/models/pearl_necklace.c

@@ -40 +40 @@
     const double si = sas_sinx_x(q*A_s);
     const double omsi = 1.0 - si;
-    const double pow_si = pow(si, num_pearls);
+    const double pow_si = pown(si, num_pearls);
 
     // form factor for num_pearls

sasmodels/sasview_model.py

@@ -695 +695 @@
             return self._calculate_Iq(qx, qy)
 
-    def _calculate_Iq(self, qx, qy=None, Fq=False, effective_radius_type=1):
+    def _calculate_Iq(self, qx, qy=None):
         if self._model is None:
             self._model = core.build_model(self._model_info)
@@ -715 +715 @@
         #print("values", values)
         #print("is_mag", is_magnetic)
-        if Fq:
-            result = calculator.Fq(call_details, values, cutoff=self.cutoff,
-                                   magnetic=is_magnetic,
-                                   effective_radius_type=effective_radius_type)
         result = calculator(call_details, values, cutoff=self.cutoff,
                             magnetic=is_magnetic)
@@ -736 +732 @@
         Calculate the effective radius for P(q)*S(q)
 
+        *mode* is the R_eff type, which defaults to 1 to match the ER
+        calculation for sasview models from version 3.x.
+
         :return: the value of the effective radius
         """
-        Fq = self._calculate_Iq([0.1], True, mode)
-        return Fq[2]
+        # ER and VR are only needed for old multiplication models, based on
+        # sas.sascalc.fit.MultiplicationModel.  Fail for now.  If we want to
+        # continue supporting them then add some test cases so that the code
+        # is exercised.  We can access ER/VR using the kernel Fq function by
+        # extending _calculate_Iq so that it calls:
+        #    if er_mode > 0:
+        #        res = calculator.Fq(call_details, values, cutoff=self.cutoff,
+        #                            magnetic=False, effective_radius_type=mode)
+        #        R_eff, form_shell_ratio = res[2], res[4]
+        #        return R_eff, form_shell_ratio
+        # Then use the following in calculate_ER:
+        #    ER, VR = self._calculate_Iq(q=[0.1], er_mode=mode)
+        #    return ER
+        # Similarly, for calculate_VR:
+        #    ER, VR = self._calculate_Iq(q=[0.1], er_mode=1)
+        #    return VR
+        # Obviously a combined calculate_ER_VR method would be better, but
+        # we only need them to support very old models, so ignore the 2x
+        # performance hit.
+        raise NotImplementedError("ER function is no longer available.")
 
     def calculate_VR(self):
@@ -748 +765 @@
         :return: the value of the form:shell volume ratio
         """
-        Fq = self._calculate_Iq([0.1], True, mode)
-        return Fq[4]
+        # See comments in calculate_ER.
+        raise NotImplementedError("VR function is no longer available.")
 
     def set_dispersion(self, parameter, dispersion):

sasmodels/kernelcl.py

@@ -61 +61 @@
 
 
-# Attempt to setup opencl. This may fail if the pyopencl package is not
+# Attempt to setup OpenCL. This may fail if the pyopencl package is not
 # installed or if it is installed but there are no devices available.
 try:
@@ -67 +67 @@
     from pyopencl import mem_flags as mf
     from pyopencl.characterize import get_fast_inaccurate_build_options
-    # Ask OpenCL for the default context so that we know that one exists
+    # Ask OpenCL for the default context so that we know that one exists.
     cl.create_some_context(interactive=False)
     HAVE_OPENCL = True
@@ -88 +88 @@
 # pylint: enable=unused-import
 
-# CRUFT: pyopencl < 2017.1  (as of June 2016 needs quotes around include path)
+
+# CRUFT: pyopencl < 2017.1 (as of June 2016 needs quotes around include path).
 def quote_path(v):
     """
@@ -99 +100 @@
     return '"'+v+'"' if v and ' ' in v and not v[0] in "\"'-" else v
 
+
 def fix_pyopencl_include():
     """
@@ -105 +107 @@
     import pyopencl as cl
     if hasattr(cl, '_DEFAULT_INCLUDE_OPTIONS'):
-        cl._DEFAULT_INCLUDE_OPTIONS = [quote_path(v) for v in cl._DEFAULT_INCLUDE_OPTIONS]
+        cl._DEFAULT_INCLUDE_OPTIONS = [
+            quote_path(v) for v in cl._DEFAULT_INCLUDE_OPTIONS
+            ]
+
 
 if HAVE_OPENCL:
@@ -118 +123 @@
 MAX_LOOPS = 2048
 
-
 # Pragmas for enable OpenCL features.  Be sure to protect them so that they
 # still compile even if OpenCL is not present.
@@ -133 +137 @@
 """
 
+
 def use_opencl():
     sas_opencl = os.environ.get("SAS_OPENCL", "OpenCL").lower()
     return HAVE_OPENCL and sas_opencl != "none" and not sas_opencl.startswith("cuda")
 
+
 ENV = None
 def reset_environment():
@@ -144 +150 @@
     global ENV
     ENV = GpuEnvironment() if use_opencl() else None
+
 
 def environment():
@@ -161 +168 @@
     return ENV
 
+
 def has_type(device, dtype):
     # type: (cl.Device, np.dtype) -> bool
@@ -171 +179 @@
         return "cl_khr_fp64" in device.extensions
     else:
-        # Not supporting F16 type since it isn't accurate enough
+        # Not supporting F16 type since it isn't accurate enough.
         return False
+
 
 def get_warp(kernel, queue):
@@ -182 +191 @@
         cl.kernel_work_group_info.PREFERRED_WORK_GROUP_SIZE_MULTIPLE,
         queue.device)
+
 
 def compile_model(context, source, dtype, fast=False):
@@ -203 +213 @@
         source_list.insert(0, _F64_PRAGMA)
 
-    # Note: USE_SINCOS makes the intel cpu slower under opencl
+    # Note: USE_SINCOS makes the Intel CPU slower under OpenCL.
     if context.devices[0].type == cl.device_type.GPU:
         source_list.insert(0, "#define USE_SINCOS\n")
@@ -210 +220 @@
     source = "\n".join(source_list)
     program = cl.Program(context, source).build(options=options)
+
     #print("done with "+program)
     return program
 
 
-# for now, this returns one device in the context
-# TODO: create a context that contains all devices on all platforms
+# For now, this returns one device in the context.
+# TODO: Create a context that contains all devices on all platforms.
 class GpuEnvironment(object):
     """
-    GPU context, with possibly many devices, and one queue per device.
-
-    Because the environment can be reset during a live program (e.g., if the
-    user changes the active GPU device in the GUI), everything associated
-    with the device context must be cached in the environment and recreated
-    if the environment changes.  The *cache* attribute is a simple dictionary
-    which holds keys and references to objects, such as compiled kernels and
-    allocated buffers.  The running program should check in the cache for
-    long lived objects and create them if they are not there.  The program
-    should not hold onto cached objects, but instead only keep them active
-    for the duration of a function call.  When the environment is destroyed
-    then the *release* method for each active cache item is called before
-    the environment is freed.  This means that each cl buffer should be
-    in its own cache entry.
+    GPU context for OpenCL, with possibly many devices and one queue per device.
     """
     def __init__(self):
         # type: () -> None
-        # find gpu context
+        # Find gpu context.
         context_list = _create_some_context()
 
@@ -249 +247 @@
                 self.context[dtype] = None
 
-        # Build a queue for each context
+        # Build a queue for each context.
         self.queue = {}
         context = self.context[F32]
@@ -259 +257 @@
             self.queue[F64] = cl.CommandQueue(context, context.devices[0])
 
-        # Byte boundary for data alignment
+        ## Byte boundary for data alignment.
         #self.data_boundary = max(context.devices[0].min_data_type_align_size
         #                         for context in self.context.values())
 
-        # Cache for compiled programs, and for items in context
+        # Cache for compiled programs, and for items in context.
         self.compiled = {}
-        self.cache = {}
 
     def has_type(self, dtype):
@@ -280 +277 @@
         """
         # Note: PyOpenCL caches based on md5 hash of source, options and device
-        # so we don't really need to cache things for ourselves.  I'll do so
-        # anyway just to save some data munging time.
+        # but I'll do so as well just to save some data munging time.
         tag = generate.tag_source(source)
         key = "%s-%s-%s%s"%(name, dtype, tag, ("-fast" if fast else ""))
-        # Check timestamp on program
+        # Check timestamp on program.
         program, program_timestamp = self.compiled.get(key, (None, np.inf))
         if program_timestamp < timestamp:
@@ -297 +293 @@
         return program
 
-    def free_buffer(self, key):
-        if key in self.cache:
-            self.cache[key].release()
-            del self.cache[key]
-
-    def __del__(self):
-        for v in self.cache.values():
-            release = getattr(v, 'release', lambda: None)
-            release()
-        self.cache = {}
-
-_CURRENT_ID = 0
-def unique_id():
-    global _CURRENT_ID
-    _CURRENT_ID += 1
-    return _CURRENT_ID
 
 def _create_some_context():
@@ -325 +305 @@
     which one (and not a CUDA device, or no GPU).
     """
-    # Assume we do not get here if SAS_OPENCL is None or CUDA
+    # Assume we do not get here if SAS_OPENCL is None or CUDA.
     sas_opencl = os.environ.get('SAS_OPENCL', 'opencl')
     if sas_opencl.lower() != 'opencl':
-        # Setting PYOPENCL_CTX as a SAS_OPENCL to create cl context
+        # Setting PYOPENCL_CTX as a SAS_OPENCL to create cl context.
         os.environ["PYOPENCL_CTX"] = sas_opencl
 
@@ -336 +316 @@
         except Exception as exc:
             warnings.warn(str(exc))
-            warnings.warn("pyopencl.create_some_context() failed")
-            warnings.warn("the environment variable 'SAS_OPENCL' or 'PYOPENCL_CTX' might not be set correctly")
+            warnings.warn("pyopencl.create_some_context() failed.  The "
+                "environment variable 'SAS_OPENCL' or 'PYOPENCL_CTX' might "
+                "not be set correctly")
 
     return _get_default_context()
+
 
 def _get_default_context():
@@ -352 +334 @@
     # is running may increase throughput.
     #
-    # Macbook pro, base install:
+    # MacBook Pro, base install:
     #     {'Apple': [Intel CPU, NVIDIA GPU]}
-    # Macbook pro, base install:
+    # MacBook Pro, base install:
     #     {'Apple': [Intel CPU, Intel GPU]}
-    # 2 x nvidia 295 with Intel and NVIDIA opencl drivers installed
+    # 2 x NVIDIA 295 with Intel and NVIDIA opencl drivers install:
     #     {'Intel': [CPU], 'NVIDIA': [GPU, GPU, GPU, GPU]}
     gpu, cpu = None, None
@@ -379 +361 @@
             else:
                 # System has cl.device_type.ACCELERATOR or cl.device_type.CUSTOM
-                # Intel Phi for example registers as an accelerator
+                # Intel Phi for example registers as an accelerator.
                 # Since the user installed a custom device on their system
                 # and went through the pain of sorting out OpenCL drivers for
@@ -386 +368 @@
                 gpu = device
 
-    # order the devices by gpu then by cpu; when searching for an available
+    # Order the devices by gpu then by cpu; when searching for an available
     # device by data type they will be checked in this order, which means
     # that if the gpu supports double then the cpu will never be used (though
@@ -413 +395 @@
     that the compiler is allowed to take shortcuts.
     """
+    info = None  # type: ModelInfo
+    source = ""  # type: str
+    dtype = None  # type: np.dtype
+    fast = False  # type: bool
+    _program = None  # type: cl.Program
+    _kernels = None  # type: Dict[str, cl.Kernel]
+
     def __init__(self, source, model_info, dtype=generate.F32, fast=False):
         # type: (Dict[str,str], ModelInfo, np.dtype, bool) -> None
@@ -419 +408 @@
         self.dtype = dtype
         self.fast = fast
-        self.timestamp = generate.ocl_timestamp(self.info)
-        self._cache_key = unique_id()
 
     def __getstate__(self):
@@ -429 +416 @@
         # type: (Tuple[ModelInfo, str, np.dtype, bool]) -> None
         self.info, self.source, self.dtype, self.fast = state
+        self._program = self._kernels = None
 
     def make_kernel(self, q_vectors):
@@ -434 +422 @@
         return GpuKernel(self, q_vectors)
 
-    @property
-    def Iq(self):
-        return self._fetch_kernel('Iq')
-
-    def fetch_kernel(self, name):
+    def get_function(self, name):
         # type: (str) -> cl.Kernel
         """
@@ -444 +428 @@
         does not already exist.
         """
-        gpu = environment()
-        key = self._cache_key
-        if key not in gpu.cache:
-            program = gpu.compile_program(
-                self.info.name,
-                self.source['opencl'],
-                self.dtype,
-                self.fast,
-                self.timestamp)
-            variants = ['Iq', 'Iqxy', 'Imagnetic']
-            names = [generate.kernel_name(self.info, k) for k in variants]
-            kernels = [getattr(program, k) for k in names]
-            data = dict((k, v) for k, v in zip(variants, kernels))
-            # keep a handle to program so GC doesn't collect
-            data['program'] = program
-            gpu.cache[key] = data
-        else:
-            data = gpu.cache[key]
-        return data[name]
-
-# TODO: check that we don't need a destructor for buffers which go out of scope
+        if self._program is None:
+            self._prepare_program()
+        return self._kernels[name]
+
+    def _prepare_program(self):
+        # type: (str) -> None
+        env = environment()
+        timestamp = generate.ocl_timestamp(self.info)
+        program = env.compile_program(
+            self.info.name,
+            self.source['opencl'],
+            self.dtype,
+            self.fast,
+            timestamp)
+        variants = ['Iq', 'Iqxy', 'Imagnetic']
+        names = [generate.kernel_name(self.info, k) for k in variants]
+        functions = [getattr(program, k) for k in names]
+        self._kernels = {k: v for k, v in zip(variants, functions)}
+        # Keep a handle to program so GC doesn't collect.
+        self._program = program
+
+
+# TODO: Check that we don't need a destructor for buffers which go out of scope.
 class GpuInput(object):
     """
@@ -486 +472 @@
     def __init__(self, q_vectors, dtype=generate.F32):
         # type: (List[np.ndarray], np.dtype) -> None
-        # TODO: do we ever need double precision q?
+        # TODO: Do we ever need double precision q?
         self.nq = q_vectors[0].size
         self.dtype = np.dtype(dtype)
         self.is_2d = (len(q_vectors) == 2)
-        # TODO: stretch input based on get_warp()
-        # not doing it now since warp depends on kernel, which is not known
+        # TODO: Stretch input based on get_warp().
+        # Not doing it now since warp depends on kernel, which is not known
         # at this point, so instead using 32, which is good on the set of
         # architectures tested so far.
@@ -504 +490 @@
             self.q[:self.nq] = q_vectors[0]
         self.global_size = [self.q.shape[0]]
-        self._cache_key = unique_id()
-
-    @property
-    def q_b(self):
-        """Lazy creation of q buffer so it can survive context reset"""
+        #print("creating inputs of size", self.global_size)
+
+        # Transfer input value to GPU.
         env = environment()
-        key = self._cache_key
-        if key not in env.cache:
-            context = env.context[self.dtype]
-            #print("creating inputs of size", self.global_size)
-            buffer = cl.Buffer(context, mf.READ_ONLY | mf.COPY_HOST_PTR,
-                               hostbuf=self.q)
-            env.cache[key] = buffer
-        return env.cache[key]
+        context = env.context[self.dtype]
+        self.q_b = cl.Buffer(context, mf.READ_ONLY | mf.COPY_HOST_PTR,
+                             hostbuf=self.q)
 
     def release(self):
         # type: () -> None
         """
-        Free the buffer associated with the q value
-        """
-        environment().free_buffer(id(self))
+        Free the buffer associated with the q value.
+        """
+        if self.q_b is not None:
+            self.q_b.release()
+            self.q_b = None
 
     def __del__(self):
@@ -530 +511 @@
         self.release()
 
+
 class GpuKernel(Kernel):
     """
@@ -536 +518 @@
     *model* is the GpuModel object to call
 
-    The following attributes are defined:
-
-    *info* is the module information
-
-    *dtype* is the kernel precision
-
-    *dim* is '1d' or '2d'
-
-    *result* is a vector to contain the results of the call
-
-    The resulting call method takes the *pars*, a list of values for
-    the fixed parameters to the kernel, and *pd_pars*, a list of (value,weight)
-    vectors for the polydisperse parameters.  *cutoff* determines the
-    integration limits: any points with combined weight less than *cutoff*
-    will not be calculated.
+    The kernel is derived from :class:`Kernel`, providing the
+    :meth:`call_kernel` method to evaluate the kernel for a given set of
+    parameters.  Because of the need to move the q values to the GPU before
+    evaluation, the kernel is instantiated for a particular set of q vectors,
+    and can be called many times without transfering q each time.
 
     Call :meth:`release` when done with the kernel instance.
     """
+    #: SAS model information structure.
+    info = None  # type: ModelInfo
+    #: Kernel precision.
+    dtype = None  # type: np.dtype
+    #: Kernel dimensions (1d or 2d).
+    dim = ""  # type: str
+    #: Calculation results, updated after each call to :meth:`_call_kernel`.
+    result = None  # type: np.ndarray
+
     def __init__(self, model, q_vectors):
-        # type: (cl.Kernel, np.dtype, ModelInfo, List[np.ndarray]) -> None
+        # type: (GpuModel, List[np.ndarray]) -> None
         dtype = model.dtype
         self.q_input = GpuInput(q_vectors, dtype)
         self._model = model
-        # F16 isn't sufficient, so don't support it
-        self._as_dtype = np.float64 if dtype == generate.F64 else np.float32
-        self._cache_key = unique_id()
-
-        # attributes accessed from the outside
+
+        # Attributes accessed from the outside.
         self.dim = '2d' if self.q_input.is_2d else '1d'
         self.info = model.info
-        self.dtype = model.dtype
-
-        # holding place for the returned value
+        self.dtype = dtype
+
+        # Converter to translate input to target type.
+        self._as_dtype = np.float64 if dtype == generate.F64 else np.float32
+
+        # Holding place for the returned value.
         nout = 2 if self.info.have_Fq and self.dim == '1d' else 1
-        extra_q = 4  # total weight, form volume, shell volume and R_eff
-        self.result = np.empty(self.q_input.nq*nout+extra_q, dtype)
-
-    @property
-    def _result_b(self):
-        """Lazy creation of result buffer so it can survive context reset"""
+        extra_q = 4  # Total weight, form volume, shell volume and R_eff.
+        self.result = np.empty(self.q_input.nq*nout + extra_q, dtype)
+
+        # Allocate result value on GPU.
         env = environment()
-        key = self._cache_key
-        if key not in env.cache:
-            context = env.context[self.dtype]
-            width = ((self.result.size+31)//32)*32 * self.dtype.itemsize
-            buffer = cl.Buffer(context, mf.READ_WRITE, width)
-            env.cache[key] = buffer
-        return env.cache[key]
-
-    def _call_kernel(self, call_details, values, cutoff, magnetic, effective_radius_type):
-        # type: (CallDetails, np.ndarray, np.ndarray, float, bool) -> np.ndarray
+        context = env.context[self.dtype]
+        width = ((self.result.size+31)//32)*32 * self.dtype.itemsize
+        self._result_b = cl.Buffer(context, mf.READ_WRITE, width)
+
+    def _call_kernel(self, call_details, values, cutoff, magnetic,
+                     effective_radius_type):
+        # type: (CallDetails, np.ndarray, float, bool, int) -> np.ndarray
         env = environment()
         queue = env.queue[self._model.dtype]
         context = queue.context
 
-        # Arrange data transfer to/from card
-        q_b = self.q_input.q_b
-        result_b = self._result_b
+        # Arrange data transfer to card.
         details_b = cl.Buffer(context, mf.READ_ONLY | mf.COPY_HOST_PTR,
                               hostbuf=call_details.buffer)
@@ -599 +573 @@
                              hostbuf=values)
 
+        # Setup kernel function and arguments.
         name = 'Iq' if self.dim == '1d' else 'Imagnetic' if magnetic else 'Iqxy'
-        kernel = self._model.fetch_kernel(name)
+        kernel = self._model.get_function(name)
         kernel_args = [
-            np.uint32(self.q_input.nq), None, None,
-            details_b, values_b, q_b, result_b,
-            self._as_dtype(cutoff),
-            np.uint32(effective_radius_type),
+            np.uint32(self.q_input.nq),  # Number of inputs.
+            None,  # Placeholder for pd_start.
+            None,  # Placeholder for pd_stop.
+            details_b,  # Problem definition.
+            values_b,  # Parameter values.
+            self.q_input.q_b,  # Q values.
+            self._result_b,   # Result storage.
+            self._as_dtype(cutoff),  # Probability cutoff.
+            np.uint32(effective_radius_type),  # R_eff mode.
         ]
+
+        # Call kernel and retrieve results.
         #print("Calling OpenCL")
         #call_details.show(values)
-        #Call kernel and retrieve results
         wait_for = None
         last_nap = time.clock()
@@ -620 +601 @@
                                *kernel_args, wait_for=wait_for)]
             if stop < call_details.num_eval:
-                # Allow other processes to run
+                # Allow other processes to run.
                 wait_for[0].wait()
                 current_time = time.clock()
@@ -626 +607 @@
                     time.sleep(0.001)
                     last_nap = current_time
-        cl.enqueue_copy(queue, self.result, result_b, wait_for=wait_for)
+        cl.enqueue_copy(queue, self.result, self._result_b, wait_for=wait_for)
         #print("result", self.result)
 
-        # Free buffers
-        for v in (details_b, values_b):
-            if v is not None:
-                v.release()
+        # Free buffers.
+        details_b.release()
+        values_b.release()
 
     def release(self):
@@ -639 +619 @@
         Release resources associated with the kernel.
         """
-        environment().free_buffer(id(self))
         self.q_input.release()
+        if self._result_b is not None:
+            self._result_b.release()
+            self._result_b = None
 
     def __del__(self):

sasmodels/kernelcuda.py

@@ -63 +63 @@
 import time
 import re
+import atexit
 
 import numpy as np  # type: ignore
 
 
-# Attempt to setup cuda. This may fail if the pycuda package is not
+# Attempt to setup CUDA. This may fail if the pycuda package is not
 # installed or if it is installed but there are no devices available.
 try:
@@ -107 +108 @@
 MAX_LOOPS = 2048
 
+
 def use_cuda():
-    env = os.environ.get("SAS_OPENCL", "").lower()
-    return HAVE_CUDA and (env == "" or env.startswith("cuda"))
+    sas_opencl = os.environ.get("SAS_OPENCL", "CUDA").lower()
+    return HAVE_CUDA and sas_opencl.startswith("cuda")
+
 
 ENV = None
@@ -121 +124 @@
         ENV.release()
     ENV = GpuEnvironment() if use_cuda() else None
+
 
 def environment():
@@ -138 +142 @@
     return ENV
 
+
+# PyTest is not freeing ENV, so make sure it gets freed.
+atexit.register(lambda: ENV.release() if ENV is not None else None)
+
+
 def has_type(dtype):
     # type: (np.dtype) -> bool
@@ -143 +152 @@
     Return true if device supports the requested precision.
     """
-    # Assume the nvidia card supports 32-bit and 64-bit floats.
-    # TODO: check if pycuda support F16
+    # Assume the NVIDIA card supports 32-bit and 64-bit floats.
+    # TODO: Check if pycuda support F16.
     return dtype in (generate.F32, generate.F64)
 
 
 FUNCTION_PATTERN = re.compile(r"""^
-  (?P<space>\s*)                   # initial space
-  (?P<qualifiers>^(?:\s*\b\w+\b\s*)+) # one or more qualifiers before function
-  (?P<function>\s*\b\w+\b\s*[(])      # function name plus open parens
+  (?P<space>\s*)                       # Initial space.
+  (?P<qualifiers>^(?:\s*\b\w+\b\s*)+)  # One or more qualifiers before function.
+  (?P<function>\s*\b\w+\b\s*[(])       # Function name plus open parens.
   """, re.VERBOSE|re.MULTILINE)
 
@@ -158 +167 @@
   """, re.VERBOSE|re.MULTILINE)
 
+
 def _add_device_tag(match):
     # type: (None) -> str
-    # Note: should be re.Match, but that isn't a simple type
+    # Note: Should be re.Match, but that isn't a simple type.
     """
     replace qualifiers with __device__ qualifiers if needed
@@ -173 +183 @@
         return "".join((space, "__device__ ", qualifiers, function))
 
+
 def mark_device_functions(source):
     # type: (str) -> str
@@ -179 +190 @@
     """
     return FUNCTION_PATTERN.sub(_add_device_tag, source)
+
 
 def show_device_functions(source):
@@ -188 +200 @@
         print(match.group('qualifiers').replace('\n',r'\n'), match.group('function'), '(')
     return source
+
 
 def compile_model(source, dtype, fast=False):
@@ -212 +225 @@
     #options = ['--verbose', '-E']
     options = ['--use_fast_math'] if fast else None
-    program = SourceModule(source, no_extern_c=True, options=options) # include_dirs=[...]
+    program = SourceModule(source, no_extern_c=True, options=options) #, include_dirs=[...])
 
     #print("done with "+program)
@@ -218 +231 @@
 
 
-# for now, this returns one device in the context
-# TODO: create a context that contains all devices on all platforms
+# For now, this returns one device in the context.
+# TODO: Create a context that contains all devices on all platforms.
 class GpuEnvironment(object):
     """
-    GPU context, with possibly many devices, and one queue per device.
+    GPU context for CUDA.
     """
     context = None # type: cuda.Context
     def __init__(self, devnum=None):
         # type: (int) -> None
-        # Byte boundary for data alignment
-        #self.data_boundary = max(d.min_data_type_align_size
-        #                         for d in self.context.devices)
-        self.compiled = {}
         env = os.environ.get("SAS_OPENCL", "").lower()
         if devnum is None and env.startswith("cuda:"):
             devnum = int(env[5:])
+
         # Set the global context to the particular device number if one is
         # given, otherwise use the default context.  Perhaps this will be set
@@ -242 +252 @@
             self.context = make_default_context()
 
+        ## Byte boundary for data alignment.
+        #self.data_boundary = max(d.min_data_type_align_size
+        #                         for d in self.context.devices)
+
+        # Cache for compiled programs, and for items in context.
+        self.compiled = {}
+
     def release(self):
         if self.context is not None:
@@ -262 +279 @@
         Compile the program for the device in the given context.
         """
-        # Note: PyOpenCL caches based on md5 hash of source, options and device
-        # so we don't really need to cache things for ourselves.  I'll do so
-        # anyway just to save some data munging time.
+        # Note: PyCuda (probably) caches but I'll do so as well just to
+        # save some data munging time.
         tag = generate.tag_source(source)
         key = "%s-%s-%s%s"%(name, dtype, tag, ("-fast" if fast else ""))
-        # Check timestamp on program
+        # Check timestamp on program.
         program, program_timestamp = self.compiled.get(key, (None, np.inf))
         if program_timestamp < timestamp:
@@ -277 +293 @@
         return program
 
+
 class GpuModel(KernelModel):
     """
@@ -292 +309 @@
     that the compiler is allowed to take shortcuts.
     """
-    info = None # type: ModelInfo
-    source = "" # type: str
-    dtype = None # type: np.dtype
-    fast = False # type: bool
-    program = None # type: SourceModule
-    _kernels = None # type: List[cuda.Function]
+    info = None  # type: ModelInfo
+    source = ""  # type: str
+    dtype = None  # type: np.dtype
+    fast = False  # type: bool
+    _program = None  # type: SourceModule
+    _kernels = None  # type: Dict[str, cuda.Function]
 
     def __init__(self, source, model_info, dtype=generate.F32, fast=False):
@@ -305 +322 @@
         self.dtype = dtype
         self.fast = fast
-        self.program = None # delay program creation
-        self._kernels = None
 
     def __getstate__(self):
@@ -315 +330 @@
         # type: (Tuple[ModelInfo, str, np.dtype, bool]) -> None
         self.info, self.source, self.dtype, self.fast = state
-        self.program = None
+        self._program = self._kernels = None
 
     def make_kernel(self, q_vectors):
         # type: (List[np.ndarray]) -> "GpuKernel"
-        if self.program is None:
-            compile_program = environment().compile_program
-            timestamp = generate.ocl_timestamp(self.info)
-            self.program = compile_program(
-                self.info.name,
-                self.source['opencl'],
-                self.dtype,
-                self.fast,
-                timestamp)
-            variants = ['Iq', 'Iqxy', 'Imagnetic']
-            names = [generate.kernel_name(self.info, k) for k in variants]
-            kernels = [self.program.get_function(k) for k in names]
-            self._kernels = dict((k, v) for k, v in zip(variants, kernels))
-        is_2d = len(q_vectors) == 2
-        if is_2d:
-            kernel = [self._kernels['Iqxy'], self._kernels['Imagnetic']]
-        else:
-            kernel = [self._kernels['Iq']]*2
-        return GpuKernel(kernel, self.dtype, self.info, q_vectors)
-
-    def release(self):
-        # type: () -> None
-        """
-        Free the resources associated with the model.
-        """
-        if self.program is not None:
-            self.program = None
-
-    def __del__(self):
-        # type: () -> None
-        self.release()
-
-# TODO: check that we don't need a destructor for buffers which go out of scope
+        return GpuKernel(self, q_vectors)
+
+    def get_function(self, name):
+        # type: (str) -> cuda.Function
+        """
+        Fetch the kernel from the environment by name, compiling it if it
+        does not already exist.
+        """
+        if self._program is None:
+            self._prepare_program()
+        return self._kernels[name]
+
+    def _prepare_program(self):
+        # type: (str) -> None
+        env = environment()
+        timestamp = generate.ocl_timestamp(self.info)
+        program = env.compile_program(
+            self.info.name,
+            self.source['opencl'],
+            self.dtype,
+            self.fast,
+            timestamp)
+        variants = ['Iq', 'Iqxy', 'Imagnetic']
+        names = [generate.kernel_name(self.info, k) for k in variants]
+        functions = [program.get_function(k) for k in names]
+        self._kernels = {k: v for k, v in zip(variants, functions)}
+        # Keep a handle to program so GC doesn't collect.
+        self._program = program
+
+
+# TODO: Check that we don't need a destructor for buffers which go out of scope.
 class GpuInput(object):
     """
@@ -373 +386 @@
     def __init__(self, q_vectors, dtype=generate.F32):
         # type: (List[np.ndarray], np.dtype) -> None
-        # TODO: do we ever need double precision q?
+        # TODO: Do we ever need double precision q?
         self.nq = q_vectors[0].size
         self.dtype = np.dtype(dtype)
         self.is_2d = (len(q_vectors) == 2)
-        # TODO: stretch input based on get_warp()
-        # not doing it now since warp depends on kernel, which is not known
+        # TODO: Stretch input based on get_warp().
+        # Not doing it now since warp depends on kernel, which is not known
         # at this point, so instead using 32, which is good on the set of
         # architectures tested so far.
         if self.is_2d:
-            # Note: 16 rather than 15 because result is 1 longer than input.
-            width = ((self.nq+16)//16)*16
+            width = ((self.nq+15)//16)*16
             self.q = np.empty((width, 2), dtype=dtype)
             self.q[:self.nq, 0] = q_vectors[0]
             self.q[:self.nq, 1] = q_vectors[1]
         else:
-            # Note: 32 rather than 31 because result is 1 longer than input.
-            width = ((self.nq+32)//32)*32
+            width = ((self.nq+31)//32)*32
             self.q = np.empty(width, dtype=dtype)
             self.q[:self.nq] = q_vectors[0]
         self.global_size = [self.q.shape[0]]
         #print("creating inputs of size", self.global_size)
+
+        # Transfer input value to GPU.
         self.q_b = cuda.to_device(self.q)
 
@@ -399 +412 @@
         # type: () -> None
         """
-        Free the memory.
+        Free the buffer associated with the q value.
         """
         if self.q_b is not None:
@@ -409 +422 @@
         self.release()
 
+
 class GpuKernel(Kernel):
     """
     Callable SAS kernel.
 
-    *kernel* is the GpuKernel object to call
-
-    *model_info* is the module information
-
-    *q_vectors* is the q vectors at which the kernel should be evaluated
-
-    *dtype* is the kernel precision
-
-    The resulting call method takes the *pars*, a list of values for
-    the fixed parameters to the kernel, and *pd_pars*, a list of (value,weight)
-    vectors for the polydisperse parameters.  *cutoff* determines the
-    integration limits: any points with combined weight less than *cutoff*
-    will not be calculated.
+    *model* is the GpuModel object to call
+
+    The kernel is derived from :class:`Kernel`, providing the
+    :meth:`call_kernel` method to evaluate the kernel for a given set of
+    parameters.  Because of the need to move the q values to the GPU before
+    evaluation, the kernel is instantiated for a particular set of q vectors,
+    and can be called many times without transfering q each time.
 
     Call :meth:`release` when done with the kernel instance.
     """
-    def __init__(self, kernel, dtype, model_info, q_vectors):
-        # type: (cl.Kernel, np.dtype, ModelInfo, List[np.ndarray]) -> None
+    #: SAS model information structure.
+    info = None  # type: ModelInfo
+    #: Kernel precision.
+    dtype = None  # type: np.dtype
+    #: Kernel dimensions (1d or 2d).
+    dim = ""  # type: str
+    #: Calculation results, updated after each call to :meth:`_call_kernel`.
+    result = None  # type: np.ndarray
+
+    def __init__(self, model, q_vectors):
+        # type: (GpuModel, List[np.ndarray]) -> None
+        dtype = model.dtype
         self.q_input = GpuInput(q_vectors, dtype)
-        self.kernel = kernel
-        # F16 isn't sufficient, so don't support it
+        self._model = model
+
+        # Attributes accessed from the outside.
+        self.dim = '2d' if self.q_input.is_2d else '1d'
+        self.info = model.info
+        self.dtype = dtype
+
+        # Converter to translate input to target type.
         self._as_dtype = np.float64 if dtype == generate.F64 else np.float32
 
-        # attributes accessed from the outside
-        self.dim = '2d' if self.q_input.is_2d else '1d'
-        self.info = model_info
-        self.dtype = dtype
-
-        # holding place for the returned value
+        # Holding place for the returned value.
         nout = 2 if self.info.have_Fq and self.dim == '1d' else 1
-        extra_q = 4  # total weight, form volume, shell volume and R_eff
-        self.result = np.empty(self.q_input.nq*nout+extra_q, dtype)
-
-        # Inputs and outputs for each kernel call
-        # Note: res may be shorter than res_b if global_size != nq
+        extra_q = 4  # Total weight, form volume, shell volume and R_eff.
+        self.result = np.empty(self.q_input.nq*nout + extra_q, dtype)
+
+        # Allocate result value on GPU.
         width = ((self.result.size+31)//32)*32 * self.dtype.itemsize
-        self.result_b = cuda.mem_alloc(width)
-        self._need_release = [self.result_b]
-
-    def _call_kernel(self, call_details, values, cutoff, magnetic, effective_radius_type):
-        # type: (CallDetails, np.ndarray, np.ndarray, float, bool) -> np.ndarray
-        # Arrange data transfer to card
+        self._result_b = cuda.mem_alloc(width)
+
+    def _call_kernel(self, call_details, values, cutoff, magnetic,
+                     effective_radius_type):
+        # type: (CallDetails, np.ndarray, float, bool, int) -> np.ndarray
+
+        # Arrange data transfer to card.
         details_b = cuda.to_device(call_details.buffer)
         values_b = cuda.to_device(values)
 
-        kernel = self.kernel[1 if magnetic else 0]
-        args = [
-            np.uint32(self.q_input.nq), None, None,
-            details_b, values_b, self.q_input.q_b, self.result_b,
-            self._as_dtype(cutoff),
-            np.uint32(effective_radius_type),
+        # Setup kernel function and arguments.
+        name = 'Iq' if self.dim == '1d' else 'Imagnetic' if magnetic else 'Iqxy'
+        kernel = self._model.get_function(name)
+        kernel_args = [
+            np.uint32(self.q_input.nq),  # Number of inputs.
+            None,  # Placeholder for pd_start.
+            None,  # Placeholder for pd_stop.
+            details_b,  # Problem definition.
+            values_b,  # Parameter values.
+            self.q_input.q_b,  # Q values.
+            self._result_b,   # Result storage.
+            self._as_dtype(cutoff),  # Probability cutoff.
+            np.uint32(effective_radius_type),  # R_eff mode.
         ]
         grid = partition(self.q_input.nq)
-        #print("Calling OpenCL")
+
+        # Call kernel and retrieve results.
+        #print("Calling CUDA")
         #call_details.show(values)
-        # Call kernel and retrieve results
         last_nap = time.clock()
         step = 100000000//self.q_input.nq + 1
@@ -475 +502 @@
             stop = min(start + step, call_details.num_eval)
             #print("queuing",start,stop)
-            args[1:3] = [np.int32(start), np.int32(stop)]
-            kernel(*args, **grid)
+            kernel_args[1:3] = [np.int32(start), np.int32(stop)]
+            kernel(*kernel_args, **grid)
             if stop < call_details.num_eval:
                 sync()
-                # Allow other processes to run
+                # Allow other processes to run.
                 current_time = time.clock()
                 if current_time - last_nap > 0.5:
@@ -485 +512 @@
                     last_nap = current_time
         sync()
-        cuda.memcpy_dtoh(self.result, self.result_b)
+        cuda.memcpy_dtoh(self.result, self._result_b)
         #print("result", self.result)
 
@@ -496 +523 @@
         Release resources associated with the kernel.
         """
-        for p in self._need_release:
-            p.free()
-        self._need_release = []
+        self.q_input.release()
+        if self._result_b is not None:
+            self._result_b.free()
+            self._result_b = None
 
     def __del__(self):
@@ -512 +540 @@
     Note: Maybe context.synchronize() is sufficient.
     """
-    #return # The following works in C++; don't know what pycuda is doing
-    # Create an event with which to synchronize
+    # Create an event with which to synchronize.
     done = cuda.Event()
 
@@ -519 +546 @@
     done.record()
 
-    #line added to not hog resources
+    # Make sure we don't hog resource while waiting to sync.
     while not done.query():
         time.sleep(0.01)
@@ -525 +552 @@
     # Block until the GPU executes the kernel.
     done.synchronize()
+
     # Clean up the event; I don't think they can be reused.
     del done

sasmodels/kerneldll.py

@@ -100 +100 @@
 # pylint: enable=unused-import
 
-# Compiler output is a byte stream that needs to be decode in python 3
+# Compiler output is a byte stream that needs to be decode in python 3.
 decode = (lambda s: s) if sys.version_info[0] < 3 else (lambda s: s.decode('utf8'))
 
@@ -115 +115 @@
         COMPILER = "tinycc"
     elif "VCINSTALLDIR" in os.environ:
-        # If vcvarsall.bat has been called, then VCINSTALLDIR is in the environment
-        # and we can use the MSVC compiler.  Otherwise, if tinycc is available
-        # the use it.  Otherwise, hope that mingw is available.
+        # If vcvarsall.bat has been called, then VCINSTALLDIR is in the
+        # environment and we can use the MSVC compiler.  Otherwise, if
+        # tinycc is available then use it.  Otherwise, hope that mingw
+        # is available.
         COMPILER = "msvc"
     else:
@@ -124 +125 @@
     COMPILER = "unix"
 
-ARCH = "" if ct.sizeof(ct.c_void_p) > 4 else "x86"  # 4 byte pointers on x86
+ARCH = "" if ct.sizeof(ct.c_void_p) > 4 else "x86"  # 4 byte pointers on x86.
 if COMPILER == "unix":
-    # Generic unix compile
-    # On mac users will need the X code command line tools installed
+    # Generic unix compile.
+    # On Mac users will need the X code command line tools installed.
     #COMPILE = "gcc-mp-4.7 -shared -fPIC -std=c99 -fopenmp -O2 -Wall %s -o %s -lm -lgomp"
     CC = "cc -shared -fPIC -std=c99 -O2 -Wall".split()
-    # add openmp support if not running on a mac
+    # Add OpenMP support if not running on a Mac.
     if sys.platform != "darwin":
-        # OpenMP seems to be broken on gcc 5.4.0 (ubuntu 16.04.9)
+        # OpenMP seems to be broken on gcc 5.4.0 (ubuntu 16.04.9).
         # Shut it off for all unix until we can investigate.
         #CC.append("-fopenmp")
@@ -144 +145 @@
     # vcomp90.dll on the path.  One may be found here:
     #       C:/Windows/winsxs/x86_microsoft.vc90.openmp*/vcomp90.dll
-    # Copy this to the python directory and uncomment the OpenMP COMPILE
-    # TODO: remove intermediate OBJ file created in the directory
-    # TODO: maybe don't use randomized name for the c file
-    # TODO: maybe ask distutils to find MSVC
+    # Copy this to the python directory and uncomment the OpenMP COMPILE.
+    # TODO: Remove intermediate OBJ file created in the directory.
+    # TODO: Maybe don't use randomized name for the c file.
+    # TODO: Maybe ask distutils to find MSVC.
     CC = "cl /nologo /Ox /MD /W3 /GS- /DNDEBUG".split()
     if "SAS_OPENMP" in os.environ:
@@ -172 +173 @@
 ALLOW_SINGLE_PRECISION_DLLS = True
 
+
 def compile(source, output):
     # type: (str, str) -> None
@@ -183 +185 @@
     logging.info(command_str)
     try:
-        # need shell=True on windows to keep console box from popping up
+        # Need shell=True on windows to keep console box from popping up.
         shell = (os.name == 'nt')
         subprocess.check_output(command, shell=shell, stderr=subprocess.STDOUT)
@@ -192 +194 @@
         raise RuntimeError("compile failed.  File is in %r"%source)
 
+
 def dll_name(model_info, dtype):
     # type: (ModelInfo, np.dtype) ->  str
@@ -202 +205 @@
     basename += ARCH + ".so"
 
-    # Hack to find precompiled dlls
+    # Hack to find precompiled dlls.
     path = joinpath(generate.DATA_PATH, '..', 'compiled_models', basename)
     if os.path.exists(path):
@@ -242 +245 @@
         raise ValueError("16 bit floats not supported")
     if dtype == F32 and not ALLOW_SINGLE_PRECISION_DLLS:
-        dtype = F64  # Force 64-bit dll
-    # Note: dtype may be F128 for long double precision
+        dtype = F64  # Force 64-bit dll.
+    # Note: dtype may be F128 for long double precision.
 
     dll = dll_path(model_info, dtype)
@@ -254 +257 @@
         need_recompile = dll_time < newest_source
     if need_recompile:
-        # Make sure the DLL path exists
+        # Make sure the DLL path exists.
         if not os.path.exists(SAS_DLL_PATH):
             os.makedirs(SAS_DLL_PATH)
@@ -263 +266 @@
             file_handle.write(source)
         compile(source=filename, output=dll)
-        # comment the following to keep the generated c file
-        # Note: if there is a syntax error then compile raises an error
+        # Comment the following to keep the generated C file.
+        # Note: If there is a syntax error then compile raises an error
         # and the source file will not be deleted.
         os.unlink(filename)
@@ -303 +306 @@
         self.dllpath = dllpath
         self._dll = None  # type: ct.CDLL
-        self._kernels = None # type: List[Callable, Callable]
+        self._kernels = None  # type: List[Callable, Callable]
         self.dtype = np.dtype(dtype)
 
@@ -338 +341 @@
         # type: (List[np.ndarray]) -> DllKernel
         q_input = PyInput(q_vectors, self.dtype)
-        # Note: pickle not supported for DllKernel
+        # Note: DLL is lazy loaded.
         if self._dll is None:
             self._load_dll()
@@ -358 +361 @@
         self._dll = None
 
+
 class DllKernel(Kernel):
     """
@@ -379 +383 @@
     def __init__(self, kernel, model_info, q_input):
         # type: (Callable[[], np.ndarray], ModelInfo, PyInput) -> None
-        #,model_info,q_input)
+        dtype = q_input.dtype
+        self.q_input = q_input
         self.kernel = kernel
+
+        # Attributes accessed from the outside.
+        self.dim = '2d' if q_input.is_2d else '1d'
         self.info = model_info
-        self.q_input = q_input
-        self.dtype = q_input.dtype
-        self.dim = '2d' if q_input.is_2d else '1d'
-        # leave room for f1/f2 results in case we need to compute beta for 1d models
+        self.dtype = dtype
+
+        # Converter to translate input to target type.
+        self._as_dtype = (np.float32 if dtype == generate.F32
+                          else np.float64 if dtype == generate.F64
+                          else np.float128)
+
+        # Holding place for the returned value.
         nout = 2 if self.info.have_Fq else 1
-        # +4 for total weight, shell volume, effective radius, form volume
-        self.result = np.empty(q_input.nq*nout + 4, self.dtype)
-        self.real = (np.float32 if self.q_input.dtype == generate.F32
-                     else np.float64 if self.q_input.dtype == generate.F64
-                     else np.float128)
-
-    def _call_kernel(self, call_details, values, cutoff, magnetic, effective_radius_type):
-        # type: (CallDetails, np.ndarray, np.ndarray, float, bool, int) -> np.ndarray
+        extra_q = 4  # Total weight, form volume, shell volume and R_eff.
+        self.result = np.empty(self.q_input.nq*nout + extra_q, dtype)
+
+    def _call_kernel(self, call_details, values, cutoff, magnetic,
+                     effective_radius_type):
+        # type: (CallDetails, np.ndarray, float, bool, int) -> np.ndarray
+
+        # Setup kernel function and arguments.
         kernel = self.kernel[1 if magnetic else 0]
-        args = [
-            self.q_input.nq, # nq
-            None, # pd_start
-            None, # pd_stop pd_stride[MAX_PD]
-            call_details.buffer.ctypes.data, # problem
-            values.ctypes.data,  # pars
-            self.q_input.q.ctypes.data, # q
-            self.result.ctypes.data,   # results
-            self.real(cutoff), # cutoff
-            effective_radius_type, # cutoff
+        kernel_args = [
+            self.q_input.nq,  # Number of inputs.
+            None,  # Placeholder for pd_start.
+            None,  # Placeholder for pd_stop.
+            call_details.buffer.ctypes.data,  # Problem definition.
+            values.ctypes.data,  # Parameter values.
+            self.q_input.q.ctypes.data,  # Q values.
+            self.result.ctypes.data,   # Result storage.
+            self._as_dtype(cutoff),  # Probability cutoff.
+            effective_radius_type,  # R_eff mode.
         ]
+
+        # Call kernel and retrieve results.
         #print("Calling DLL")
         #call_details.show(values)
         step = 100
+        # TODO: Do we need the explicit sleep like the OpenCL and CUDA loops?
         for start in range(0, call_details.num_eval, step):
             stop = min(start + step, call_details.num_eval)
-            args[1:3] = [start, stop]
-            kernel(*args) # type: ignore
+            kernel_args[1:3] = [start, stop]
+            kernel(*kernel_args) # type: ignore
 
     def release(self):
         # type: () -> None
         """
-        Release any resources associated with the kernel.
+        Release resources associated with the kernel.
         """
-        self.q_input.release()
+        # TODO: OpenCL/CUDA allocate q_input in __init__ and free it in release.
+        # Should we be doing the same for DLL?
+        #self.q_input.release()
+        pass
+
+    def __del__(self):
+        # type: () -> None
+        self.release()

sasmodels/kernelpy.py

@@ -33 +33 @@
 logger = logging.getLogger(__name__)
 
+
 class PyModel(KernelModel):
     """
@@ -38 +39 @@
     """
     def __init__(self, model_info):
-        # Make sure Iq is available and vectorized
+        # Make sure Iq is available and vectorized.
         _create_default_functions(model_info)
         self.info = model_info
@@ -53 +54 @@
         """
         pass
+
 
 class PyInput(object):
@@ -91 +93 @@
         self.q = None
 
+
 class PyKernel(Kernel):
     """
@@ -131 +134 @@
         parameter_vector = np.empty(len(partable.call_parameters)-2, 'd')
 
-        # Create views into the array to hold the arguments
+        # Create views into the array to hold the arguments.
         offset = 0
         kernel_args, volume_args = [], []
@@ -174 +177 @@
                         else (lambda mode: 1.0))
 
-
-
     def _call_kernel(self, call_details, values, cutoff, magnetic, effective_radius_type):
         # type: (CallDetails, np.ndarray, np.ndarray, float, bool) -> np.ndarray
@@ -195 +196 @@
         self.q_input.release()
         self.q_input = None
+
 
 def _loops(parameters,    # type: np.ndarray
@@ -254 +256 @@
         total = np.zeros(nq, 'd')
         for loop_index in range(call_details.num_eval):
-            # update polydispersity parameter values
+            # Update polydispersity parameter values.
             if p0_index == p0_length:
                 pd_index = (loop_index//pd_stride)%pd_length
@@ -265 +267 @@
             p0_index += 1
             if weight > cutoff:
-                # Call the scattering function
+                # Call the scattering function.
                 # Assume that NaNs are only generated if the parameters are bad;
                 # exclude all q for that NaN.  Even better would be to have an
@@ -273 +275 @@
                     continue
 
-                # update value and norm
+                # Update value and norm.
                 total += weight * Iq
                 weight_norm += weight
@@ -293 +295 @@
     any functions that are not already marked as vectorized.
     """
-    # Note: must call create_vector_Iq before create_vector_Iqxy
+    # Note: Must call create_vector_Iq before create_vector_Iqxy.
     _create_vector_Iq(model_info)
     _create_vector_Iqxy(model_info)

sasmodels/model_test.py

@@ -167 +167 @@
         # test using cuda if desired and available
         if 'cuda' in loaders and use_cuda():
-            test_name = "%s-cuda"%model_name
+            test_name = "%s-cuda" % model_info.id
             test_method_name = "test_%s_cuda" % model_info.id
             # Using dtype=None so that the models that are only

sasmodels/models/rpa.c

@@ -25 +25 @@
   double S0ba,Pbb,S0bb,Pbc,S0bc,Pbd,S0bd;
   double S0ca,S0cb,Pcc,S0cc,Pcd,S0cd;
-  double S0da,S0db,S0dc;
+  //double S0da,S0db,S0dc;
   double Pdd,S0dd;
   double Kaa,Kbb,Kcc;
   double Kba,Kca,Kcb;
-  double Kda,Kdb,Kdc,Kdd;
+  //double Kda,Kdb,Kdc,Kdd;
   double Zaa,Zab,Zac,Zba,Zbb,Zbc,Zca,Zcb,Zcc;
   double DenT,T11,T12,T13,T21,T22,T23,T31,T32,T33;
@@ -36 +36 @@
   double N11,N12,N13,N21,N22,N23,N31,N32,N33;
   double M11,M12,M13,M21,M22,M23,M31,M32,M33;
-  double S11,S12,S13,S14,S21,S22,S23,S24;
-  double S31,S32,S33,S34,S41,S42,S43,S44;
+  double S11,S12,S22,S23,S13,S33;
+  //double S21,S31,S32,S44; 
+  //double S14,S24,S34,S41,S42,S43;
   double Lad,Lbd,Lcd,Nav,Intg;
 
@@ -115 +116 @@
   S0cd=(Phicd*vcd*Ncd)*Pcd;
 
-  S0da=S0ad;
-  S0db=S0bd;
-  S0dc=S0cd;
+  //S0da=S0ad;
+  //S0db=S0bd;
+  //S0dc=S0cd;
   Pdd=2.0*(exp(-Xd)-1.0+Xd)/(Xd*Xd); // free D chain
   S0dd=N[3]*Phi[3]*v[3]*Pdd;
@@ -198 +199 @@
   S0ca=S0ac;
   S0cb=S0bc;
-  S0da=S0ad;
-  S0db=S0bd;
-  S0dc=S0cd;
+  //S0da=S0ad;
+  //S0db=S0bd;
+  //S0dc=S0cd;
 
   // self chi parameter is 0 ... of course
@@ -206 +207 @@
   Kbb=0.0;
   Kcc=0.0;
-  Kdd=0.0;
+  //Kdd=0.0;
 
   Kba=Kab;
   Kca=Kac;
   Kcb=Kbc;
-  Kda=Kad;
-  Kdb=Kbd;
-  Kdc=Kcd;
+  //Kda=Kad;
+  //Kdb=Kbd;
+  //Kdc=Kcd;
 
   Zaa=Kaa-Kad-Kad;
@@ -294 +295 @@
   S12= Q12*S0aa + Q22*S0ab + Q32*S0ac;
   S13= Q13*S0aa + Q23*S0ab + Q33*S0ac;
-  S14=-S11-S12-S13;
-  S21= Q11*S0ba + Q21*S0bb + Q31*S0bc;
   S22= Q12*S0ba + Q22*S0bb + Q32*S0bc;
   S23= Q13*S0ba + Q23*S0bb + Q33*S0bc;
-  S24=-S21-S22-S23;
-  S31= Q11*S0ca + Q21*S0cb + Q31*S0cc;
-  S32= Q12*S0ca + Q22*S0cb + Q32*S0cc;
   S33= Q13*S0ca + Q23*S0cb + Q33*S0cc;
-  S34=-S31-S32-S33;
-  S41=S14;
-  S42=S24;
-  S43=S34;
-  S44=S11+S22+S33+2.0*S12+2.0*S13+2.0*S23;
+  //S21= Q11*S0ba + Q21*S0bb + Q31*S0bc;
+  //S31= Q11*S0ca + Q21*S0cb + Q31*S0cc;
+  //S32= Q12*S0ca + Q22*S0cb + Q32*S0cc;
+  //S44=S11+S22+S33+2.0*S12+2.0*S13+2.0*S23;
+  //S14=-S11-S12-S13;
+  //S24=-S21-S22-S23;
+  //S34=-S31-S32-S33;
+  //S41=S14;
+  //S42=S24;
+  //S43=S34;
 
   //calculate contrast where L[i] is the scattering length of i and D is the matrix