GPULib

GPULib 1.4.4 released!

2011-01-31T14:27:00.002-07:00

We are pleased to announce that GPULib 1.4.4 is available from the Tech-X website.

The following changes have been made for version 1.4.4:

Support for CUDA 3.2 (rather than CUDA 3.2 rc2)
Added more extensive checks for issues in GPUINIT.
Added ability to transpose 1-dimensional arrays like TRANSPOSE does.
Now handles ranges, index arrays, and * in any indexing position of an array in the same manner as IDL.
Now can use single-dimensional indexing for multi-dimensional arrays.
Trying to create a view from discontinuous memory is now disallowed.
Fixed garbage collection issue with repeated assignment to the same variable name.
Fixed an issue whereby multiple calls to GPUINIT were causing cudaErrorSetOnActiveProcess errors.
Fixed memory allocation bug in GPUTRANSPOSE.
Fixed typo in GPUMATRIX_MULTIPLY.
Added unit tests for GPUTRANSPOSE, GPUMAXOP.
Now prints an error message when trying to create a view from discontinuous memory.
Fixed build issue on Mac OS X Leopard.
Fixed several install issues for Windows when building from source.
Improvements to the QuickStartGuide for Windows.
Fixed getDimensions bug for certain views.
Added error checking for changing dimensions.
Fixed memory leak in GPUFFT.
Fixed errors in GPUMAXOP.
Fixed failing unit tests of GPUMAXOP.
Added missing demo file to install list.
Fixed digital signing of installer file.
Fixed disappearing graphic in transform3d demo.
Corrected IDL_LIBDIR path.
Fixed path of file gpulib_version.txt in CMakeLists.txt.
Fixed full reduction in GPUTOTAL.
Fixed -fPIC warnings when building from source on Windows.
Fixed color table issue in GPU_SWIRL_DEMO.
Added "press q to stop" option to GPU_FDTD_DEMO.
Fixed flipped image in GPU_DECONHUBBLE_DEMO.

GPULib 1.4.2 released!

2010-11-15T12:33:00.000-07:00

We are pleased to announce that GPULib 1.4.2 is available from the Tech-X website.

For Windows users, the installer contains the following pre-built versions of GPULib 1.4.2:

32- or 64-bit single precision (compute capability 1.0) built with CUDA 3.2
32- or 64-bit double precision (compute capability 1.3) built with CUDA 3.2
32- or 64-bit Fermi (compute capability 2.0) built with CUDA 3.2

(As before, Windows users can opt to build GPULib from source if they so desire).

The following changes have been made for version 1.4.2:

Fixed make install so that appropriate files are now installed.
All demos cleaned up and numerous memory leaks fixed.
Created a new comprehensive PDF for Windows users, covering general use as well as how to build from source.
Windows installation now includes all source files in a zip archive, so that users who are not building from source do not have their install folder cluttered with source files.
gpuinit() now displays amount of free memory as well as total memory available on the device.
Fixed bug in GPUMATRIX_MULTIPLY.
Fixed several small bugs and memory leaks.

We are grateful to Mort Canty and David Grier for submitting bug reports which led to fixes for this release!

GPULib 1.4.0 released!

2010-10-01T13:29:00.000-06:00

We are pleased to announce that GPULib 1.4.0 is available from the Tech-X website.

For Windows users, we created an installer which installs one of the following pre-built versions of GPULib 1.4.0:

32- or 64-bit single precision (compute capability 1.0) built with CUDA 3.1
32- or 64-bit double precision (compute capability 1.3) built with CUDA 3.1
32- or 64-bit Fermi (compute capability 2.0) built with CUDA 3.1
32-bit single precision (compute capability 1.0) built with CUDA 2.3
32-bit double precision (compute capability 1.3) built with CUDA 2.3

(As before, Windows users can opt to build GPULib from source.)

In addition, the following changes have been made:

Now builds with CMake for cross-platform compatibility.
Now supports CUDA streams, enabling concurrent execution of multiple kernels.
Now supports asynchronous data transfer.
Now leverages new features of IDL 8.0 enabling more seamless integration between the two products.
Includes a variety of new algorithms, such as functions for sorting and large histogramming.
gpuinit() now provides additional information, including GPULib version and model of your CUDA-enabled card, and additionally performs a small allocation to ensure the card is available.
Demos updated to fail gracefully if you do not have enough memory on your card, or if your card does not have the compute capability to run the demo.
Fixed a bug whereby assigning a regular IDL variable to a slice failed.
gpushift() fixed for the case where a dimension is shifted by 0.
Fixed problems with gpuInterpolate functions.
Fixed memory leak in gpufix().
Fixed memory leak in gpufft().
MATLAB support has been dropped.

GPULib 1.2.2 Released

2009-11-17T16:09:00.007-07:00

GPULib 1.2.2 is now available from the Tech-X website.

We've made extensive changes to the build system, which is now cleaner and more robust. Full release notes follow.

Build system changes
- Added --with-extra-nvcc-flags=... to configure which allows extra flags to be passed to nvcc.
- If --prefix is not set, make install will fail gracefully, instead of attempting to install in /.
- Fixed --with-matlab-dir=... configure option.
- Added IDL and MATLAB configuration info to config.summary to make it easier to troubleshoot problem.
- Added several missing Windows build files.
- Removed several obsolete files and directories.
- Running 'make clean' will not affect documentation.
- Running 'make install' will properly build code if not already built.
- Install directory is now laid out properly.
- Fixed "No rule to make target `docs/GPULib_UsersGuide.pdf', needed by `all-am'" error.

IDL changes
- Fixed bug whereby FFT was only operating on a single row.
- Fixed bug whereby GPUPOW was not found.
- Corrected bwtest example.
- Fixed time reporting for FDTD demo.
- Fixed typo in FDTD demo README.

MATLAB changes
- Added potential to specify the device number form gpuInit() and accInit().
- Fixed Bug in gpuSet function.
- Fixed Makefile which was incorrect for 32-bit Linux.

2nd edition of Mort Canty's book uses GPULib

2009-11-17T15:33:00.001-07:00

From the CRC Press site for Image Analysis, Classification, and Change Detection in Remote Sensing: With Algorithms for ENVI/IDL, Second Edition:

This popular introduction to the processing of remote sensing imagery has been updated to include coverage of the latest versions of the ENVI software environment. This new edition covers support vector machines and other kernel-based methods. Illustrating many programming examples in the array-oriented language ID, the text includes coverage of basic Fourier, wavelet, principal components and minimum noise fraction transformations; convolution filters, topographic modeling, image-to-image registration and ortho-rectification; image fusion; supervised and unsupervised land cover classification with neural networks; hyperspectral analysis; multivariate change detection.

I was excited to hear that GPULib was used in this version of the book. Mort says:

In the text I discuss routines for nonlinear principal component analysis, supervised classification and nonlinear clustering, and explain that they can take advantage of GPULib/CUDA, if installed. (I use your routine GPU_DETECT() to check for GPULib).

GPULib docs from ENVI menu

2009-07-24T22:38:00.003-06:00

A recent post by Mort Canty provides a handy program that adds an item to ENVI's help menu that will bring up the GPULib docs.

GPULib 1.2 released

2009-07-14T21:52:00.004-06:00

GPULib 1.2 is available from the Tech-X website. This release focused on improved MATLAB bindings with a few important bug fixes for the IDL bindings along with a few new kernels. Full release notes follow:

Changes/new features in GPULib version 1.2

General

The main focus of this release is on the improved MATLAB bindings. Some new kernels were added since the release of version 1.0.8.

GPULib kernels

gpuAtan2, gpuFmod, gpuPow

IDL bindings

- Support for the new kernels. For the time being, these funtions only support float and double (so no complex types) and no affine transform arguments.
- Added example bwtest.pro showing the use of page-locked variables for fast CPU/GPU data transfer.
- Added finite-different time-domain example demonstrating the use of views for efficient array sub-selection
- Added spectral angle mapper example.
- Bug fixes for decon_hubble example
- improved documentation

MATLAB bindings

MATLAB GPULib version 1.2 has many major changes from the previous release. READ the README!

First and foremost, there are two distinct and completely separate interfaces to the library. They should NEVER be intermingled.

1.) The accArray class replaces the old gpuArray class from the previous release. This interface requires MATLAB R2008a or higher. This interface hass automatic garbage collection, overloaded operators, and overloaded versions of native MATLAB functions, ...
2.) "gpu" interface class can be used with older versions of MATLAB though it's not clear how far back one can go.

The interface was redesigned for speed. The accArray class is about 2.5X faster than the gpuArray interface for many functions tested. Some of the "gpu"-prefixed functions can be up to 10X faster than the gpuArray interface.

MATLAB GPULib has many new functions including
1.) fft, ifft, fft2, and ifft2
2.) Reduction operations, including sum, cumsum, prod, cumprod,... These functions support 1D vectors and 2D matrices currently.
3.) Single (Complex) and Double (Complex) precision versions of Matrix Multiplication, Transpose and Complex Conjugate Transpose.

The accArray class does not support the subsref.m (i.e. b=A(i)), subsasgn.m (i.e. A(i)=b), or array concatentation functions like A=[B; C; D], These will be supported in future releases.

The "gpu" interface supports subscripting through the gpuSubsref, gpuSubsasgn, and gpuSub2ind functions.

Both interfaces support page-locked host memory allocation via cudaMallocHost. This gives the possibility of much faster memory transfer from CPU memory to GPU memory and back.

Both interfaces include more comprehensive native MATLAB-like documentation.

New examples include: bench, bwtest, fdtd, and fftExample.

GPULib slides from VISualize 2009

2009-05-08T11:04:00.002-06:00

Here are the slides from Peter Messmer's GPULib talk at VISualize 2009 a couple weeks ago. Peter and I also stayed around after the IDL presentations to do hands on training for GPULib. The training was well attended; it was good to see the interest in GPU computing with IDL. Most people did not bring a laptop, making it less “hands on” than we had originally intended, but it was good to be able to answer individual questions.

NVIDIA Releases OpenCL Driver

2009-04-21T09:27:00.002-06:00

OpenCL is officially out -- have a look at the press release, or the OpenCL site.

Detecting presense of GPULib

2009-03-16T11:11:00.003-06:00

Over the weekend, a user (Mort Canty) asked the GPULib user's mailing list for a way to detect the presence. One of our developers wrote a routine to do just that, and I thought it might be of use to other GPULib users as well.

Below is the routine GPU_DETECT that will return a boolean indicating if GPULib is present. It will also initialize the GPU if it finds GPUINIT. If you have any questions, feel free to ask!

; docformat = 'rst'

;+
; Initializes GPULib if it is present.
;
; :Returns:
; 1 if GPULib is present, 0 if not
;
; :Params:
; devId: in, optional, type=numtype
; id of the GPU device to be used for GPU computations
;
; :Keywords:
; _ref_extra : in, optional, type=keywords
; keywords to GPUINIT
;-
function gpu_detect, devId, _ref_extra=e
compile_opt strictarr

catch, error
if (error ne 0L) then begin
catch, /cancel
return, 0
endif

gpuinit, devId, _extra

return, 1
end

GPULib 1.0.8 update available

2009-02-27T16:45:00.003-07:00

GPULib 1.0.8 is available at

http://gpulib.txcorp.com

This release is addressing several bugs pointed out by users; we're still working on the MATLAB refactoring for a future version. As always, if you have any questions, feel free to post in the comments, the GPULib mailing list, or contact us directly at support@txcorp.com.

Also, one note; during testing of this release, we found some problems with using it on Windows Vista. We're looking for solutions, but at the moment XP is the better choice for running GPULib.

32- vs. 64-bit IDL on Mac OS X

2009-01-22T10:42:00.003-07:00

IDL 7.0.4 was recently released, providing full 64-bit support for Mac OS X, and some users who have upgraded have asked how this impacts GPULib, as using the library when running IDL in 64-bit mode doesn't work.

Currently, in order to build 64-bit code using GCC on OS X, one needs to set an additional flag, depending on the architecture targeted. We don't do this at the moment for GPULib, so it defaults to building the more compatible 32-bit libraries. Full details at

http://developer.apple.com/documentation/Darwin/Conceptual/64bitPorting/building/chapter_5_section_2.html

Apple goes so far as to say, "You should transition your application to a 64-bit executable format only when the 64-bit environment offers a compelling advantage for your specific application." We haven't switched to using 64-bit libraries with GPULib on Mac OS X, since thus far there hasn't been a need. If you do need the extra address space using GPULib, please let us know! Otherwise, you can add the "-32" flag to IDL 7.0.4 and run IDL in 32-bit mode, which will be compatible with the current release of GPULib.

Performing a shift in IDL with GPULib

2009-01-13T14:12:00.003-07:00

A couple of users recently asked about doing a shift of a matrix using GPULib. While there is no interface that mimics 'shift' at the moment, all the functionality for shifting arrays is there. For example, you can use the following to shift an array along the x-direction:

IDL> x = findgen(5, 5)
IDL> print, x
0.00000 1.00000 2.00000 3.00000 4.00000
5.00000 6.00000 7.00000 8.00000 9.00000
10.0000 11.0000 12.0000 13.0000 14.0000
15.0000 16.0000 17.0000 18.0000 19.0000
20.0000 21.0000 22.0000 23.0000 24.0000

IDL> a = gpuPutArr(x)
IDL> b = gpuFltarr(5, 5)

; here comes the actual shift:
; we first perform b[0:3, *] = a[1:*, *]
; see the documentation for 'gpuSubArr' for an
; explanation of the arguments.
IDL> gpuSubArr, a, [1, -1], -1, b, [0, 3], -1

; and then b[4, * ] = a[0,*]
IDL> gpuSubArr, a, 0, -1, b, 4, -1

IDL> res = gpuGetArr(b)
IDL> print, res

1.00000 2.00000 3.00000 4.00000 0.00000
6.00000 7.00000 8.00000 9.00000 5.00000
11.0000 12.0000 13.0000 14.0000 10.0000
16.0000 17.0000 18.0000 19.0000 15.0000
21.0000 22.0000 23.0000 24.0000 20.0000

Shifts in other directions can be implemented similarly. This is not the fastest possible shift, but at least it should allow you to perform the shift on the GPU, rather than transferring it back to the CPU.

As always, if you have questions about this or any other use of GPULib, feel free to leave comments here, or email us at support@txcorp.com.

Double precision and GPULib

2009-01-13T10:27:00.002-07:00

A few users have asked about double precision calculations using GPULib. I thought I'd try to clear up some common questions.

First, you may notice when running the GPULib unit tests in IDL (using 'make check') that the double precision tests fail. There are two reasons for this. First, not all CUDA-enabled hardware is capable of double precision calculations -- currently, the GTX 200 series are the only cards that can do this; check the NVIDIA Web site for details on your specific card.

Secondly, you may need to update your video card drivers. We've had some issues with the 177.x series of CUDA drivers, but the 180.x series is doing much better. I'd recommend upgrading to the most recent drivers available from NVIDIA in any case, as they are constantly improving both features and performance. The downloads are available at http://www.nvidia.com/object/cuda_get.html

GPULib 1.0.6 update available

2008-12-17T18:15:00.002-07:00

We've just released GPULib 1.0.6 at

http://gpulib.txcorp.com

This fixes a bug for Windows users relating to using FFT calls.

MATLAB bindings undergoing major redesign

2008-12-16T17:22:00.003-07:00

We're currently doing a major redesign of the MATLAB bindings for GPULib -- if all goes well, they should be done sometime in the next few weeks. If you have any questions about using MATLAB with GPULib, please let us know.

GPULib 1.0.4 update available

2008-12-16T16:54:00.002-07:00

GPULib 1.0.4 is now available at

http://www.txcorp.com/products/GPULib/

This release contains various bug fixes for IDL, as well as 64 bit DLLs for IDL and MATLAB for Windows users.

Thanks for the comments and bug reports -- keep telling us what you'd like in GPULib, and we'll keep developing the software to meet your needs. And, as always, feel free to leave comments in the blog or email us at support@txcorp.com with questions, comments, or suggestions. Finally, if you're at the AGU meeting in San Francisco this week, stop by the Tech-X booth (#2114) and say hello!

GPULib tidbits

2008-12-10T14:50:00.003-07:00

We continue to get questions and suggestions from users -- thanks for your input! Some of the same questions have come up, so I thought I'd try to address them here.

To get some extra information on the GPU hardware (including memory available), you can do the following:

IDL> cardID = 0L ; the card ID you want to know more about
IDL> err = cudaGetDeviceProperties(prop, cardID)
IDL> print, prop.name
IDL> help, prop, /struct

The wrapper is a bit rough (it's a low level CUDA function), but it gives you a lot of useful information. Remember that your application will be limited by the amount of memory available on the GPU card -- if you go past this limit, you'll get unpredictable behavior.

We've also had some questions about the difference between CPU and GPU calculations. Right now we're shipping the library with the 'enable-fast-math' option turned on in CUDA. This uses the fastest, but least IEEE compliant form for floating point operations. It could easily be turned off and still yield good performance (as we're mainly memory bandwidth limited), and we may switch to this build method in the future. Hard numbers for the precision of GPU calculations can be found in the the CUDA user manual. In one of the appendices it has some documentation on the error bounds of the individual functions. It's usually within the last two bits of the mantissa.

Finally, som users are looking at investing in new hardware on which to run GPULib, and were looking for recommendations and comparison for different CUDA-enabled hardware. A starting point for evaluating such cards is at

http://www.nvidia.com/object/cuda_learn_products.html

Cost runs from left to right, performance runs roughly from top to bottom. If double support is important for your application, you have to go with either a GTX 260/280, a C1060, or the FX5800 right now.

If you have any questions about this (or anything else related to GPULib), feel free to post comments below, or email the user's list or Tech-X support. We're still working on the next release (1.0.4), and we'll let you know as soon as it's available.

Bug in gpuMatrix_Multiply

2008-11-21T11:26:00.002-07:00

A user recently reported a bug in the current version of GPULib:

The procedure gpuMatrix_Multiply calls the function gpuMatrixMultiply().
That should be gpuMatrix_Multiply(), i.e., with the underscore.

There was a typo in this function in the GPULib 1.0.2 release. As a workaround, you can edit the file

IDL/lib/gpumatrix_multiply.pro

to include the underscore in the call to gpuMatrix_Multiply(). This bug (and others) have been fixed and will be out for the 1.0.4 version of GPULib, coming soon.

Thanks for the bug report -- if anyone finds any other issues, please let us know and we'll address them as soon as possible.

Using Remote Desktop with GPULib

2008-11-20T10:56:00.003-07:00

We had a question recently from a user attempting to use Remote Desktop to run GPULib on a Windows machine. Unfortunately, this is a known limitation of CUDA; due to the way Remote Desktop functions, CUDA (and therefore, GPULib) won't function properly.

However, there is a bit of a workaround -- you can use VNC instead of Remote Desktop to access the machine remotely. VNC essentially screen-scrapes instead of trying to be clever about display APIs, so while display performance will not be as good as using Remote Desktop it should run GPULib applications just fine. Some developers on the NVIDIA discussion suggest a hybrid approach -- the use Remote Desktop to access the remote machine when developing code, and VNC when running it. Using VNC also has the advantage of being platform-independent; both client and server could be Linux, OS X, or Windows.

There are several implementations of VNC, including:

GPULib 1.0.2 update available

2008-11-19T14:45:00.003-07:00

A user discovered a bug when using GPULib 1.0.0 on Windows (the issue described in the earlier post) and we've corrected that in GPULib 1.0.2, released this afternoon. To obtain this update, visit the download link at

http://gpulib.txcorp.com

Thanks for the bug reports and questions!

Error: "Attempt to call undefined procedure/function: 'GPUADD'."

2008-11-19T13:13:00.003-07:00

Some users have seen the following error when using GPULib's IDL bindings:

IDL> gpuinit
% Attempt to call undefined procedure/function: 'GPUADD'.
% Error occurred at: GPUINIT 137 C:\Documents and
Settings\Sizemore\Desktop\gpulib-1.0.0\IDL\lib\gpuinit.pro
% $MAIN$
% Execution halted at: $MAIN$

If this happens to you, you may need to copy the file IDL\lib\gpuinit.pro.orig to IDL\lib\gpuinit.pro, overwriting the original gpuinit.pro file.

UPDATE: We've released a new version of GPULib, v1.0.2, that fixes this error. See

http://gpulib.txcorp.com

to get the new version.

GPULib 1.0.0 is available!

2008-11-18T15:16:00.003-07:00

Tech-X Corporation is pleased to announce that GPULib 1.0.0 has been released. This first major release contains full bindings for IDL and MATLAB, as well as header files for C. Python bindings are also included. GPULib is available for Linux, Mac OS X, and Windows -- the release includes pre-built DLLs for Windows users, as well as build files for all platforms. Full details are at

http://gpulib.txcorp.com/

GPULib is available for non-commercial use under AGPL, as well as commercial licensing from Tech-X.

We'd like to thank all of the beta testers who asked questions, provided suggestions, and pointed out bugs in the code. :-) We'll keep working on improving the software, so please continue to tell us how we can best make the code suit your needs. The GPULib User's List is a good place to contact us, as well as your fellow GPULib users. You can also email us at support@txcorp.com if you run into technical issues.

GPULib users mailing list

2008-11-18T11:18:00.003-07:00

We now have mailing list set up for users of GPULib. To sign up, go to

http://ice.txcorp.com/mailman/listinfo/gpulib-users

Questions, feature requests, feedback, etc. are all welcome.

Tech-X at SC08 -- booth 1324

2008-11-17T10:20:00.003-07:00

If you're attending SC08 in Austin, TX this week, please stop by and visit the Tech-X booth -- we're number 1324. GPULib developers will be available to answer any questions you might have, as well as to talk about plans for new features in upcoming versions.

GPULib 1.0 at SC08

2008-11-07T13:28:00.005-07:00

Tech-X will be releasing the 1.0 version of GPULib at SC08. This supercomputing conference runs from November 15-21, 2008 and will be held in Austin, TX. Full details are at

http://sc08.supercomputing.org/

If you're going to be at the conference, feel free to stop by the Tech-X booth to see demos of GPULib and chat with some of the developers.

Thanks for all of your feedback from the various beta releases, including the most recent 0.5 beta. We've gotten many good comments and suggestions -- keep them coming! You can contact us by leaving comments on the blog, or sending email to support@txcorp.com.

We hope GPULib continues to help you speed up your applications.

GPULib 0.5 is now available

2008-11-06T16:44:00.004-07:00

We've just released a new version of GPULib. Version 0.5 is available at

http://gpulib.txcorp.com

The interface continues to improve for both IDL and MATLAB. We've also made the package much easier to build; once you have CUDA installed, you should be able to build the software with a much more familiar

tar -xvzf gpulib-0.5.tar.gz

cd gpulib-0.5

./configure

make

Also, this version of GPULib should build easily on Mac OS X as well, with the same steps as above. With Apple using CUDA-enabled NVIDIA graphics chips in its new MacBook and MacBook Pro releases, this should allow even more users to begin using the GPU for number crunching.

For both Linux and OS X, the configure script will do its best to find IDL and MATLAB automatically. If you don't have IDL or MATLAB, you can disable building those bindings. See the README file for full details.

Once you have the package built, running

make check

will run a series of demos for IDL, MATLAB, and C. The latter is currently just a skeleton, but we'll be adding more C examples soon.

Finally, many users have been asking for better documentation. We're still working on the User's Guide, but in the meantime both the IDL and MATLAB APIs have much better documentation than the previous release. If you run

make html

GPULib will generate comprehensive documentation for the IDL bindings, contained in gpulib-0.5/IDL/docs. MATLAB users can run

help gpuArray

and browse the API and related documentation directly in MATLAB.

As always, feel free to leave questions, comments, feature requests, etc. in the comments, or email us at support@txcorp.com.

IDL tip: compile gpuinit before running your own procedures

2008-08-13T14:46:00.002-06:00

Another "gotcha" came up today from a user; when using GPULib in IDL, you may need to compile gpuinit before running your code. For example, to run a procedure you've written called foo, you should do something like the following:

IDL> .compile gpuinit
IDL> .compile foo
IDL> foo

As always, if you have questions or suggestion regarding GPULib, feel free to leave comments or email support@txcorp.com.

Tips on building GPULib

2008-08-13T11:57:00.003-06:00

Several users have pointed out recently that the documentation included with GPULib is sparser than they would like. The docs do require updating, and you should see better installation and use instructions with the next release of the libraries. Until then, here are some tips on how to deal with common issues.

If you're having trouble getting GPULib to build, make sure that the most recent CUDA libraries are installed for your platform. Also, make sure that you have any other software you need; you can't build the IDL bindings without IDL installed on the machine, for example.

If you see errors such as the following during the build:

cc -I/usr/local/rsi/idl/external/include -I/usr/local/cuda/include -O3 -fPIC -I../vectorOp -I../physicsOp -c gpulib.c
gpulib.c:38:24: error: idl_export.h: No such file or directory
gpulib.c:48: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'get_IDL_long'
In file included from gpulib.c:163:
../vectorOp/gpuVectorOpFuncList.h:38: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'IDL_gpuSqrtF'
../vectorOp/gpuVectorOpFuncList.h:39: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'IDL_gpuExpF'

you probably need to change your configure line to help GPULib figure out where IDL is. A configure line such as

./configure --disable-MATLAB --with-idl-dir=/path/to/idl

should fix this issue and allow the build to continue.

If you encounter any other issues, feel free to describe them in the comments or send email to support@txcorp.com.

Example MATLAB code in GPULib

2008-07-07T12:06:00.000-06:00

I recently had a question from a user looking for information on how to use GPULib with MATLAB; you can find examples of how to use GPULib in the

gpulib-0.3p7/MATLAB/ode_cell/

directory of the current distribution.

We're working on refining the MATLAB interface to the library, and hopefully we'll be able to share that work with you soon. In the meantime, if you have suggestions or comments about using GPULib with MATLAB, please let us know!

GPULib 0.3p7 released

2008-06-23T09:38:00.000-06:00

Development continues on GPULib -- the team has made a new release; 0.3p7 can be downloaded at

http://www.txcorp.com/technologies/GPULib/

New version 0.3p6 available

2008-06-18T17:06:00.000-06:00

Tech-X has just released a new version of GPULib. It is available from

http://www.txcorp.com/technologies/GPULib/download.php

Questions, comments, bug reports, and feature requests are welcome.

Nvidia's David Kirk on CUDA, CPUs and GPUs

2008-04-30T14:46:00.000-06:00

bit-tech has a quite interesting interview up with Nvidia's Chief Scientist David Kirk, where he discusses the future of GPU computing.

http://www.bit-tech.net/hardware/2008/04/30/david-kirk-interview/1

Intel to build sGPU supercomputer: Nvidia Tesla cards to debut in Bull system

2008-04-29T11:39:00.000-06:00

http://www.tgdaily.com/content/view/37070/135/

The original Bull NovaScale supercomputer setup was based on 1068 nodes, which will result in a total of 8544 processing cores for a peak floating point performance of 192 TFlops. Apparently the design was recently upgraded with 48 nodes of Nvidia Tesla S900 GPGPU cards with 96 (GT200) GPUs. The expected performance is now about 300 TFlops. In comparison, BlueGene/L, currently the world's most powerful supercomputer, peaks at 596 TFlops an uses 212,992 processing cores.

New version 0.3p1 available

2008-03-07T10:14:00.000-07:00

A new version of GPULib (0.3p1) is available at

http://www.txcorp.com/technologies/GPULib/download.php

This new version contains a variety of bug fixes and minor updates. Please contact us if you run into any issues or have feature requests.

Technology preview version 0.3 released

2008-02-21T13:38:00.000-07:00

Later today we will release the latest technology preview of the GPULib (version 0.3). This version now contains at least prototypes for all the language bindings (IDL, MATLAB, Python and Java) and many new functions (various collective operations, conditionals, random number generator and more) that should all make it easier to develop algorithms that can keep data on the GPU for as long as possible.

As the name suggests, this is neither a full version nor a full release, but it will give you the opportunity to play around with the library, see if your algorithm could take advantage of a GPU and provide us feedback on missing kernels/functions, surprises you've encountered during installation and use, and hopefully success stories.

We're looking forward to hear from your,

Peter

Blog set up

2008-02-20T09:54:00.000-07:00

In order to communicate with users quickly, the GPULib dev team has set up this blog. For more information on GPULib, visit

http://gpulib.txcorp.com