Changes

Version 2014.1

Note

This version is the current development version. You can get it from PyCUDA’s version control repository.

  • Add PointerHolderBase.as_buffer() and DeviceAllocation.as_buffer().
  • Support for device_attribute values added in CUDA 5.0, 5.5, and 6.0.
  • Support for Managed Memory. (contributed by Stan Seibert)

Version 2013.1.1

  • Windows fix for PyCUDA on Python 3 (Thanks, Christoph Gohlke)

Version 2013.1

  • Python 3 support (large parts contributed by Tomasz Rybak)

  • Add pycuda.gpuarray.GPUArray.__getitem__(), supporting generic slicing.

    It is possible to create non-contiguous arrays using this functionality. Most operations (elementwise etc.) will not work on such arrays.

  • More generators in pycuda.curandom. (contributed by Tomasz Rybak)

  • Many bug fixes

Note

The addition of pyopencl.array.Array.__getitem__() has an unintended consequence due to numpy bug 3375. For instance, this expression:

numpy.float32(5) * some_gpu_array

may take a very long time to execute. This is because numpy first builds an object array of (compute-device) scalars (!) before it decides that that’s probably not such a bright idea and finally calls pycuda.gpuarray.GPUArray.__rmul__().

Note that only left arithmetic operations of pycuda.gpuarray.GPUArray by numpy scalars are affected. Python’s number types (float etc.) are unaffected, as are right multiplications.

If a program that used to run fast suddenly runs extremely slowly, it is likely that this bug is to blame.

Here’s what you can do:

  • Use Python scalars instead of numpy scalars.
  • Switch to right multiplications if possible.
  • Use a patched numpy. See the bug report linked above for a pull request with a fix.
  • Switch to a fixed version of numpy when available.

Version 2012.1

  • Numerous bug fixes. (including shipped-boost compilation on gcc 4.7)

Version 2011.2

  • Fix a memory leak when using pagelocked memory. (reported by Paul Cazeaux)
  • Fix complex scalar argument passing.
  • Fix pycuda.gpuarray.zeros() when used on complex arrays.
  • Add pycuda.tools.register_dtype() to enable scan/reduction on struct types.
  • More improvements to CURAND.
  • Add support for CUDA 4.1.

Version 2011.1.2

  • Various fixes.

Version 2011.1.1

  • Various fixes.

Version 2011.1

When you update code to run on this version of PyCUDA, please make sure to have deprecation warnings enabled, so that you know when your code needs updating. (See the Python docs. Caution: As of Python 2.7, deprecation warnings are disabled by default.)

Version 0.94.2

  • Fix the pesky Fermi reduction bug. (thanks to Tomasz Rybak)

Version 0.94.1

  • Support for CUDA debugging. (see FAQ for details.)

Version 0.94

Version 0.93

Warning

Version 0.93 makes some changes to the PyCUDA programming interface. In all cases where documented features were changed, the old usage continues to work, but results in a warning. It is recommended that you update your code to remove the warning.

Version 0.92

Note

If you’re upgrading from prior versions, you may delete the directory $HOME/.pycuda-compiler-cache to recover now-unused disk space.

Note

During this release time frame, I had the honor of giving a talk on PyCUDA for a class that a group around Nicolas Pinto was teaching at MIT. If you’re interested, the slides for it are available.

Version 0.91

Acknowledgments

  • Gert Wohlgemuth ported PyCUDA to MacOS X and contributed large parts of pycuda.gpuarray.GPUArray.
  • Alexander Mordvintsev contributed fixes for Windows XP.
  • Cosmin Stejerean provided multiple patches for PyCUDA’s build system.
  • Tom Annau contributed an alternative SourceModule compiler cache as well as Windows build insight.
  • Nicholas Tung improved PyCUDA’s documentation.
  • Jozef Vesely contributed a massively improved random number generator derived from the RSA Data Security, Inc. MD5 Message Digest Algorithm.
  • Chris Heuser provided a test cases for multi-threaded PyCUDA.
  • The reduction templating is based on code by Mark Harris at Nvidia.
  • Andrew Wagner provided a test case and contributed the port of the convolution example. The original convolution code is based on an example provided by Nvidia.
  • Hendrik Riedmann contributed the matrix transpose and list selection examples.
  • Peter Berrington contributed a working example for CUDA-OpenGL interoperability.
  • Maarten Breddels provided a patch for ‘flat-egg’ support.
  • Nicolas Pinto refactored pycuda.autoinit for automatic device finding.
  • Ian Ozsvald and Fabrizio Milo provided patches.
  • Min Ragan-Kelley solved the long-standing puzzle of why PyCUDA did not work on 64-bit CUDA on OS X (and provided a patch).
  • Tomasz Rybak solved another long-standing puzzle of why reduction failed to work on some Fermi chips. In addition, he provided a patch that updated PyCUDA’s OpenGL to the state of CUDA 3.0.
  • Martin Bergtholdt of Philips Research provided a patch that made PyCUDA work on 64-bit Windows 7.

Licensing

PyCUDA is licensed to you under the MIT/X Consortium license:

Copyright (c) 2009,10 Andreas Klöckner and Contributors.

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

PyCUDA includes derivatives of parts of the Thrust computing package (in particular the scan implementation). These parts are licensed as follows:

Copyright 2008-2011 NVIDIA Corporation

Licensed under the Apache License, Version 2.0 (the “License”); you may not use this file except in compliance with the License. You may obtain a copy of the License at

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Note

If you use Apache-licensed parts, be aware that these may be incompatible with software licensed exclusively under GPL2. (Most software is licensed as GPL2 or later, in which case this is not an issue.)

Frequently Asked Questions

The FAQ is now maintained collaboratively in the PyCUDA Wiki.

Citing PyCUDA

We are not asking you to gratuitously cite PyCUDA in work that is otherwise unrelated to software. That said, if you do discuss some of the development aspects of your code and would like to highlight a few of the ideas behind PyCUDA, feel free to cite this article:

Andreas Klöckner, Nicolas Pinto, Yunsup Lee, Bryan Catanzaro, Paul Ivanov, Ahmed Fasih, PyCUDA and PyOpenCL: A scripting-based approach to GPU run-time code generation, Parallel Computing, Volume 38, Issue 3, March 2012, Pages 157-174.

Here’s a Bibtex entry for your convenience:

@article{kloeckner_pycuda_2012,
   author = {{Kl{\"o}ckner}, Andreas
        and {Pinto}, Nicolas
        and {Lee}, Yunsup
        and {Catanzaro}, B.
        and {Ivanov}, Paul
        and {Fasih}, Ahmed },
   title = "{PyCUDA and PyOpenCL: A Scripting-Based Approach to GPU Run-Time Code Generation}",
   journal = "Parallel Computing",
   volume = "38",
   number = "3",
   pages = "157--174",
   year = "2012",
   issn = "0167-8191",
   doi = "10.1016/j.parco.2011.09.001",
}