Array context

.github/workflows/ci.yml

@@ -18,7 +18,7 @@ jobs:
         -
             uses: actions/setup-python@v1
             with:
-                python-version: '3.x' 
+                python-version: '3.x'
         -   name: "Main Script"
             run: |
                 curl -L -O -k https://gitlab.tiker.net/inducer/ci-support/raw/master/prepare-and-run-flake8.sh
@@ -32,7 +32,7 @@ jobs:
         -
             uses: actions/setup-python@v1
             with:
-                python-version: '3.x' 
+                python-version: '3.x'
         -   name: "Main Script"
             run: |
                 set -e
@@ -51,18 +51,35 @@ jobs:
                 . ./prepare-and-run-pylint.sh pytential test/test_*.py
 
     pytest3:
-        name: Pytest on Py3
+        name: Pytest Linux
         runs-on: ubuntu-latest
         steps:
         -   uses: actions/checkout@v2
         -   name: "Main Script"
             run: |
-                set -e
                 grep -v symengine .test-conda-env-py3.yml > .test-conda-env.yml
                 CONDA_ENVIRONMENT=.test-conda-env.yml
                 curl -L -O -k https://gitlab.tiker.net/inducer/ci-support/raw/master/build-and-test-py-project-within-miniconda.sh
                 . ./build-and-test-py-project-within-miniconda.sh
 
+    pytest3mac:
+        name: Pytest Mac
+        runs-on: macos-latest
+        steps:
+        -   uses: actions/checkout@v2
+        -   name: "Main Script"
+            run: |
+                export LC_ALL=en_US.UTF-8
+                export LANG=en_US.UTF-8
+                grep -v symengine .test-conda-env-py3.yml > .test-conda-env.yml
+                echo "- compiler" >> .test-conda-env.yml
+                echo "- openmp" >> .test-conda-env.yml
+                CONDA_ENVIRONMENT=.test-conda-env.yml
+                export PYTEST_ADDOPTS=${PYTEST_ADDOPTS:--k-slowtest}
+                set -o xtrace
+                curl -L -O -k https://gitlab.tiker.net/inducer/ci-support/raw/master/build-and-test-py-project-within-miniconda.sh
+                . ./build-and-test-py-project-within-miniconda.sh
+
     pytest3symengine:
         name: Pytest on Py3 with SymEngine
         runs-on: ubuntu-latest

.gitlab-ci.yml

@@ -73,29 +73,6 @@ Python 3 Conda:
     reports:
       junit: test/pytest.xml
 
-Python 3 Conda Apple:
-  script:
-  - export LC_ALL=en_US.UTF-8
-  - export LANG=en_US.UTF-8
-  - export CONDA_ENVIRONMENT=.test-conda-env-py3-macos.yml
-  - export PYTEST_ADDOPTS=${PYTEST_ADDOPTS:--k-slowtest}
-  - export CC=clang
-  # https://stackoverflow.com/q/60934005; https://reviews.llvm.org/D71579
-  - export LDFLAGS="-mlinker-version=519"
-  - set -o xtrace
-  - curl -L -O -k https://gitlab.tiker.net/inducer/ci-support/raw/master/build-and-test-py-project-within-miniconda.sh
-  - ". ./build-and-test-py-project-within-miniconda.sh"
-
-  tags:
-  - apple
-  except:
-  - tags
-  retry: 2
-
-  artifacts:
-    reports:
-      junit: test/pytest.xml
-
 Documentation:
   script:
   - EXTRA_INSTALL="Cython pybind11 numpy mako"

.test-conda-env-py3.yml

@@ -23,4 +23,4 @@ dependencies:
     - git+https://github.com/inducer/pymbolic
     - git+https://github.com/inducer/loopy
     - git+https://gitlab.tiker.net/inducer/sumpy
-    - git+https://github.com/inducer/meshmode
+    - git+https://gitlab.tiker.net/inducer/meshmode@array-context

examples/cost.py

@@ -2,6 +2,8 @@
 
 import pyopencl as cl
 import numpy as np
+from meshmode.array_context import PyOpenCLArrayContext
+from meshmode.dof_array import thaw
 
 from pytential import sym, bind
 from pytools import one
@@ -26,7 +28,7 @@
 TESTING_ARMS = (20,)
 
 
-def starfish_lpot_source(queue, n_arms):
+def starfish_lpot_source(actx, n_arms):
     from meshmode.discretization import Discretization
     from meshmode.discretization.poly_element import (
             InterpolatoryQuadratureSimplexGroupFactory)
@@ -39,7 +41,7 @@ def starfish_lpot_source(queue, n_arms):
             TARGET_ORDER)
 
     pre_density_discr = Discretization(
-            queue.context, mesh,
+            actx, mesh,
             InterpolatoryQuadratureSimplexGroupFactory(TARGET_ORDER))
 
     lpot_kwargs = DEFAULT_LPOT_KWARGS.copy()
@@ -60,14 +62,14 @@ def starfish_lpot_source(queue, n_arms):
 # }}}
 
 
-def training_geometries(queue):
+def training_geometries(actx):
     for n_arms in TRAINING_ARMS:
-        yield starfish_lpot_source(queue, n_arms)
+        yield starfish_lpot_source(actx, n_arms)
 
 
-def test_geometries(queue):
+def test_geometries(actx):
     for n_arms in TESTING_ARMS:
-        yield starfish_lpot_source(queue, n_arms)
+        yield starfish_lpot_source(actx, n_arms)
 
 
 def get_bound_op(places):
@@ -79,40 +81,41 @@ def get_bound_op(places):
     return bind(places, op)
 
 
-def get_test_density(queue, density_discr):
-    nodes = density_discr.nodes().with_queue(queue)
-    sigma = cl.clmath.sin(10 * nodes[0])
-
+def get_test_density(actx, density_discr):
+    nodes = thaw(actx, density_discr.nodes())
+    sigma = actx.np.sin(10 * nodes[0])
     return sigma
 
 
 def calibrate_cost_model(ctx):
     queue = cl.CommandQueue(ctx)
+    actx = PyOpenCLArrayContext(queue)
 
     from pytential.qbx.cost import CostModel, estimate_calibration_params
     cost_model = CostModel()
 
     model_results = []
     timing_results = []
 
-    for lpot_source in training_geometries(queue):
+    for lpot_source in training_geometries(actx):
         lpot_source = lpot_source.copy(cost_model=cost_model)
 
         from pytential import GeometryCollection
         places = GeometryCollection(lpot_source)
         density_discr = places.get_discretization(places.auto_source.geometry)
 
         bound_op = get_bound_op(places)
-        sigma = get_test_density(queue, density_discr)
+        sigma = get_test_density(actx, density_discr)
 
-        cost_S = bound_op.get_modeled_cost(queue, sigma=sigma)
+        cost_S = bound_op.get_modeled_cost(actx, sigma=sigma)
 
         # Warm-up run.
-        bound_op.eval(queue, {"sigma": sigma})
+        bound_op.eval({"sigma": sigma}, array_context=actx)
 
         for _ in range(RUNS):
             timing_data = {}
-            bound_op.eval(queue, {"sigma": sigma}, timing_data=timing_data)
+            bound_op.eval({"sigma": sigma}, array_context=actx,
+                    timing_data=timing_data)
 
             model_results.append(one(cost_S.values()))
             timing_results.append(one(timing_data.values()))
@@ -125,29 +128,31 @@ def calibrate_cost_model(ctx):
 
 def test_cost_model(ctx, cost_model):
     queue = cl.CommandQueue(ctx)
+    actx = PyOpenCLArrayContext(queue)
 
-    for lpot_source in test_geometries(queue):
+    for lpot_source in test_geometries(actx):
         lpot_source = lpot_source.copy(cost_model=cost_model)
 
         from pytential import GeometryCollection
         places = GeometryCollection(lpot_source)
         density_discr = places.get_discretization(places.auto_source.geometry)
 
         bound_op = get_bound_op(places)
-        sigma = get_test_density(queue, density_discr)
+        sigma = get_test_density(actx, density_discr)
 
-        cost_S = bound_op.get_modeled_cost(queue, sigma=sigma)
+        cost_S = bound_op.get_modeled_cost(actx, sigma=sigma)
         model_result = (
                 one(cost_S.values())
                 .get_predicted_times(merge_close_lists=True))
 
         # Warm-up run.
-        bound_op.eval(queue, {"sigma": sigma})
+        bound_op.eval({"sigma": sigma}, array_context=actx)
 
         temp_timing_results = []
         for _ in range(RUNS):
             timing_data = {}
-            bound_op.eval(queue, {"sigma": sigma}, timing_data=timing_data)
+            bound_op.eval({"sigma": sigma},
+                    array_context=actx, timing_data=timing_data)
             temp_timing_results.append(one(timing_data.values()))
 
         timing_result = {}

examples/fmm-error.py

@@ -1,6 +1,8 @@
 from __future__ import division
 import numpy as np
 import pyopencl as cl
+from meshmode.array_context import PyOpenCLArrayContext
+from meshmode.dof_array import thaw
 from meshmode.mesh.generation import (  # noqa
         make_curve_mesh, starfish, ellipse, drop)
 from sumpy.visualization import FieldPlotter
@@ -13,6 +15,7 @@ def main():
 
     cl_ctx = cl.create_some_context()
     queue = cl.CommandQueue(cl_ctx)
+    actx = PyOpenCLArrayContext(queue)
 
     target_order = 16
     qbx_order = 3
@@ -37,13 +40,13 @@ def main():
             InterpolatoryQuadratureSimplexGroupFactory
 
     pre_density_discr = Discretization(
-            cl_ctx, mesh,
+            actx, mesh,
             InterpolatoryQuadratureSimplexGroupFactory(target_order))
 
     unaccel_qbx = QBXLayerPotentialSource(
             pre_density_discr, fine_order=2*target_order,
             qbx_order=qbx_order, fmm_order=False,
-            target_association_tolerance=.05
+            target_association_tolerance=.05,
             )
 
     from pytential.target import PointsTarget
@@ -57,24 +60,35 @@ def main():
         })
     density_discr = places.get_discretization("unaccel_qbx")
 
-    nodes = density_discr.nodes().with_queue(queue)
-    angle = cl.clmath.atan2(nodes[1], nodes[0])
+    nodes = thaw(actx, density_discr.nodes())
+    angle = actx.np.atan2(nodes[1], nodes[0])
 
     from pytential import bind, sym
-    #op = sym.d_dx(sym.S(kernel, sym.var("sigma")), qbx_forced_limit=None)
-    #op = sym.D(kernel, sym.var("sigma"), qbx_forced_limit=None)
-    op = sym.S(kernel, sym.var("sigma"), qbx_forced_limit=None)
+    if k:
+        kernel_kwargs = {"k": sym.var("k")}
+    else:
+        kernel_kwargs = {}
+
+    def get_op():
+        kwargs = dict(qbx_forced_limit=None)
+        kwargs.update(kernel_kwargs)
+        # return sym.d_dx(2, sym.S(kernel, sym.var("sigma"), **kwargs))
+        # return sym.D(kernel, sym.var("sigma"), **kwargs)
+        return sym.S(kernel, sym.var("sigma"), **kwargs)
+
+    op = get_op()
 
-    sigma = cl.clmath.cos(mode_nr*angle)
+    sigma = actx.np.cos(mode_nr*angle)
 
     if isinstance(kernel, HelmholtzKernel):
-        sigma = sigma.astype(np.complex128)
+        for i, elem in np.ndenumerate(sigma):
+            sigma[i] = elem.astype(np.complex128)
 
     fld_in_vol = bind(places, op, auto_where=("unaccel_qbx", "targets"))(
-            queue, sigma=sigma, k=k).get()
+            actx, sigma=sigma, k=k).get()
 
     fmm_fld_in_vol = bind(places, op, auto_where=("qbx", "targets"))(
-            queue, sigma=sigma, k=k).get()
+            actx, sigma=sigma, k=k).get()
 
     err = fmm_fld_in_vol-fld_in_vol