Hi

below the files to build (build.sh) and to run the example that creates the panic.


TestCudaSelect.sh is a non-gui program. It will run normally.
TestCudaSelectGUI.sh pops up a window. It will run. When you exit it from the menu (or ctrl-c)
it will generate a kernel panic, trace in panic-report.txt.


While creating the examples I noticed that the kernel panic is related to:

1. -Xmx1024M on the command line to start java. Take it away and it will run w/o panic.
2. GUI. The non gui version also has -Xmx1024M and runs fine. 


It is some combination of the two, however we need the memory and the GPU, so we are stuck for
the moment. 

Hope you can help me...

Regards
Mark Donszelmann

p.s. The attachment upload did not seem to work, so all files included below:
-- build.sh
-- TestCudaSelect.sh
-- TestCudaSelectGUI.sh
-- Cuda.java
-- CudaDeviceProp.java
-- CudaError.java
-- CudaMemcpyKind.java
-- CUresult.java
-- CudaJNI.java
-- cuda_wrap.c
-- TestCudaSelect.java
-- TestCudaSelectGUI.java



-- build.sh
#!/bin/sh

swig -D__GNUC__ -o cuda_wrap.c -java -I/usr/local/cuda/include cuda.swg
gcc -arch i386 -c -I/usr/local/cuda/include -I${JAVA_HOME}/include cuda_wrap.c -o cuda_wrap.o
gcc -arch i386 -dynamiclib -o libjcuda-i386.jnilib cuda_wrap.o -framework JavaVM -L/usr/local/cuda/lib -lcudart -lcuda
lipo -create -output libjcuda.jnilib libjcuda-i386.jnilib

rm *.class
javac -source 1.5 -target 1.5 *.java

-- TestCudaSelect.sh
#!/bin/sh

JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Versions/1.5/Home
PATH=${JAVA_HOME}/bin:${PATH}

DYLD_LIBRARY_PATH=.:/usr/local/cuda/lib
java -Xmx1024M -classpath . TestCudaSelect


-- TestCudaSelectGUI.sh
#!/bin/sh

JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Versions/1.5/Home
PATH=${JAVA_HOME}/bin:${PATH}

DYLD_LIBRARY_PATH=.:/usr/local/cuda/lib
java -Xmx1024M -classpath . TestCudaSelectGUI

-- Cuda.java
/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3.35
 *
 * Do not make changes to this file unless you know what you are doing--modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */


public class Cuda {
  public static CudaError cudaGetDeviceCount(int[] count) {
    return CudaError.swigToEnum(CudaJNI.cudaGetDeviceCount(count));
  }

  public static CudaError cudaGetDeviceProperties(CudaDeviceProp prop, int device) {
    return CudaError.swigToEnum(CudaJNI.cudaGetDeviceProperties(CudaDeviceProp.getCPtr(prop), prop, device));
  }

  public static CudaError cudaSetDevice(int device) {
    return CudaError.swigToEnum(CudaJNI.cudaSetDevice(device));
  }

  public static CudaError cudaThreadSynchronize() {
    return CudaError.swigToEnum(CudaJNI.cudaThreadSynchronize());
  }

}

-- CudaDeviceProp.java
/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3.35
 *
 * Do not make changes to this file unless you know what you are doing--modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */


public class CudaDeviceProp {
  private long swigCPtr;
  protected boolean swigCMemOwn;

  protected CudaDeviceProp(long cPtr, boolean cMemoryOwn) {
    swigCMemOwn = cMemoryOwn;
    swigCPtr = cPtr;
  }

  protected static long getCPtr(CudaDeviceProp obj) {
    return (obj == null) ? 0 : obj.swigCPtr;
  }

  protected void finalize() {
    delete();
  }

  public synchronized void delete() {
    if(swigCPtr != 0 && swigCMemOwn) {
      swigCMemOwn = false;
      CudaJNI.delete_CudaDeviceProp(swigCPtr);
    }
    swigCPtr = 0;
  }

  public String toString() {
    StringBuffer s = new StringBuffer("CUDA Graphics Card");
    
    s.append("\nDevice: ");
    s.append(getName());
    
    s.append("\n  Version:                                       ");
    s.append(getMajor());
    s.append(".");
    s.append(getMinor());

    s.append("\n  Total amount of global memory:                 ");
    s.append(getTotalGlobalMem());
    s.append(" bytes");      
    
    s.append("\n  Total amount of constant memory:               ");
    s.append(getTotalConstMem());
    s.append(" bytes");      
    
    s.append("\n  Total amount of shared memory per block:       ");
    s.append(getSharedMemPerBlock());
    s.append(" bytes");      
    
    s.append("\n  Total number of registers available per block: ");
    s.append(getRegsPerBlock());
    
    s.append("\n  Warp size:                                     ");
    s.append(getWarpSize());
    
    s.append("\n  Maximum number of threads per block:           ");
    s.append(getMaxThreadsPerBlock());
    
    int[] maxThreadsDim = getMaxThreadsDim();
    s.append("\n  Maximum sizes of each dimension of a block:    ");
    for (int i=0; i<maxThreadsDim.length; i++) {
        if (i > 0) s.append(" x ");
        s.append(maxThreadsDim[i]);
    }   
       
    int[] maxGridSize = getMaxGridSize();
    s.append("\n  Maximum sizes of each dimension of a grid:     ");
    for (int i=0; i<maxGridSize.length; i++) {
        if (i > 0) s.append(" x ");
        s.append(maxGridSize[i]);
    }   
       
    s.append("\n  Maximum memory pitch:                          ");
    s.append(getMemPitch());
    s.append(" bytes");      

    s.append("\n  Texture alignment:                             ");
    s.append(getTextureAlignment());
    s.append(" bytes");      
    
    s.append("\n  Clock rate:                                    ");
    s.append(getClockRate());
    s.append(" kilohertz");      
     
    return s.toString();
  }

  public void setName(String value) {
    CudaJNI.CudaDeviceProp_name_set(swigCPtr, this, value);
  }

  public String getName() {
    return CudaJNI.CudaDeviceProp_name_get(swigCPtr, this);
  }

  public void setTotalGlobalMem(long value) {
    CudaJNI.CudaDeviceProp_totalGlobalMem_set(swigCPtr, this, value);
  }

  public long getTotalGlobalMem() {
    return CudaJNI.CudaDeviceProp_totalGlobalMem_get(swigCPtr, this);
  }

  public void setSharedMemPerBlock(long value) {
    CudaJNI.CudaDeviceProp_sharedMemPerBlock_set(swigCPtr, this, value);
  }

  public long getSharedMemPerBlock() {
    return CudaJNI.CudaDeviceProp_sharedMemPerBlock_get(swigCPtr, this);
  }

  public void setRegsPerBlock(int value) {
    CudaJNI.CudaDeviceProp_regsPerBlock_set(swigCPtr, this, value);
  }

  public int getRegsPerBlock() {
    return CudaJNI.CudaDeviceProp_regsPerBlock_get(swigCPtr, this);
  }

  public void setWarpSize(int value) {
    CudaJNI.CudaDeviceProp_warpSize_set(swigCPtr, this, value);
  }

  public int getWarpSize() {
    return CudaJNI.CudaDeviceProp_warpSize_get(swigCPtr, this);
  }

  public void setMemPitch(long value) {
    CudaJNI.CudaDeviceProp_memPitch_set(swigCPtr, this, value);
  }

  public long getMemPitch() {
    return CudaJNI.CudaDeviceProp_memPitch_get(swigCPtr, this);
  }

  public void setMaxThreadsPerBlock(int value) {
    CudaJNI.CudaDeviceProp_maxThreadsPerBlock_set(swigCPtr, this, value);
  }

  public int getMaxThreadsPerBlock() {
    return CudaJNI.CudaDeviceProp_maxThreadsPerBlock_get(swigCPtr, this);
  }

  public void setMaxThreadsDim(int[] value) {
    CudaJNI.CudaDeviceProp_maxThreadsDim_set(swigCPtr, this, value);
  }

  public int[] getMaxThreadsDim() {
    return CudaJNI.CudaDeviceProp_maxThreadsDim_get(swigCPtr, this);
  }

  public void setMaxGridSize(int[] value) {
    CudaJNI.CudaDeviceProp_maxGridSize_set(swigCPtr, this, value);
  }

  public int[] getMaxGridSize() {
    return CudaJNI.CudaDeviceProp_maxGridSize_get(swigCPtr, this);
  }

  public void setTotalConstMem(long value) {
    CudaJNI.CudaDeviceProp_totalConstMem_set(swigCPtr, this, value);
  }

  public long getTotalConstMem() {
    return CudaJNI.CudaDeviceProp_totalConstMem_get(swigCPtr, this);
  }

  public void setMajor(int value) {
    CudaJNI.CudaDeviceProp_major_set(swigCPtr, this, value);
  }

  public int getMajor() {
    return CudaJNI.CudaDeviceProp_major_get(swigCPtr, this);
  }

  public void setMinor(int value) {
    CudaJNI.CudaDeviceProp_minor_set(swigCPtr, this, value);
  }

  public int getMinor() {
    return CudaJNI.CudaDeviceProp_minor_get(swigCPtr, this);
  }

  public void setClockRate(int value) {
    CudaJNI.CudaDeviceProp_clockRate_set(swigCPtr, this, value);
  }

  public int getClockRate() {
    return CudaJNI.CudaDeviceProp_clockRate_get(swigCPtr, this);
  }

  public void setTextureAlignment(long value) {
    CudaJNI.CudaDeviceProp_textureAlignment_set(swigCPtr, this, value);
  }

  public long getTextureAlignment() {
    return CudaJNI.CudaDeviceProp_textureAlignment_get(swigCPtr, this);
  }

  public CudaDeviceProp() {
    this(CudaJNI.new_CudaDeviceProp(), true);
  }

}


-- CudaError.java
/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3.35
 *
 * Do not make changes to this file unless you know what you are doing--modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */


public enum CudaError {
  cudaSuccess(0),
  cudaErrorMissingConfiguration,
  cudaErrorMemoryAllocation,
  cudaErrorInitializationError,
  cudaErrorLaunchFailure,
  cudaErrorPriorLaunchFailure,
  cudaErrorLaunchTimeout,
  cudaErrorLaunchOutOfResources,
  cudaErrorInvalidDeviceFunction,
  cudaErrorInvalidConfiguration,
  cudaErrorInvalidDevice,
  cudaErrorInvalidValue,
  cudaErrorInvalidPitchValue,
  cudaErrorInvalidSymbol,
  cudaErrorMapBufferObjectFailed,
  cudaErrorUnmapBufferObjectFailed,
  cudaErrorInvalidHostPointer,
  cudaErrorInvalidDevicePointer,
  cudaErrorInvalidTexture,
  cudaErrorInvalidTextureBinding,
  cudaErrorInvalidChannelDescriptor,
  cudaErrorInvalidMemcpyDirection,
  cudaErrorAddressOfConstant,
  cudaErrorTextureFetchFailed,
  cudaErrorTextureNotBound,
  cudaErrorSynchronizationError,
  cudaErrorInvalidFilterSetting,
  cudaErrorInvalidNormSetting,
  cudaErrorMixedDeviceExecution,
  cudaErrorCudartUnloading,
  cudaErrorUnknown,
  cudaErrorNotYetImplemented,
  cudaErrorMemoryValueTooLarge,
  cudaErrorInvalidResourceHandle,
  cudaErrorNotReady,
  cudaEmulationError,
  cudaErrorStartupFailure(0x7f),
  cudaErrorApiFailureBase(10000);

  public final int swigValue() {
    return swigValue;
  }

  public static CudaError swigToEnum(int swigValue) {
    CudaError[] swigValues = CudaError.class.getEnumConstants();
    if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue)
      return swigValues[swigValue];
    for (CudaError swigEnum : swigValues)
      if (swigEnum.swigValue == swigValue)
        return swigEnum;
    throw new IllegalArgumentException("No enum " + CudaError.class + " with value " + swigValue);
  }

  @SuppressWarnings("unused")
  private CudaError() {
    this.swigValue = SwigNext.next++;
  }

  @SuppressWarnings("unused")
  private CudaError(int swigValue) {
    this.swigValue = swigValue;
    SwigNext.next = swigValue+1;
  }

  @SuppressWarnings("unused")
  private CudaError(CudaError swigEnum) {
    this.swigValue = swigEnum.swigValue;
    SwigNext.next = this.swigValue+1;
  }

  private final int swigValue;

  private static class SwigNext {
    private static int next = 0;
  }
}


-- CudaMemcpyKind.java
/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3.35
 *
 * Do not make changes to this file unless you know what you are doing--modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */


public enum CudaMemcpyKind {
  cudaMemcpyHostToHost(0),
  cudaMemcpyHostToDevice,
  cudaMemcpyDeviceToHost,
  cudaMemcpyDeviceToDevice;

  public final int swigValue() {
    return swigValue;
  }

  public static CudaMemcpyKind swigToEnum(int swigValue) {
    CudaMemcpyKind[] swigValues = CudaMemcpyKind.class.getEnumConstants();
    if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue)
      return swigValues[swigValue];
    for (CudaMemcpyKind swigEnum : swigValues)
      if (swigEnum.swigValue == swigValue)
        return swigEnum;
    throw new IllegalArgumentException("No enum " + CudaMemcpyKind.class + " with value " + swigValue);
  }

  @SuppressWarnings("unused")
  private CudaMemcpyKind() {
    this.swigValue = SwigNext.next++;
  }

  @SuppressWarnings("unused")
  private CudaMemcpyKind(int swigValue) {
    this.swigValue = swigValue;
    SwigNext.next = swigValue+1;
  }

  @SuppressWarnings("unused")
  private CudaMemcpyKind(CudaMemcpyKind swigEnum) {
    this.swigValue = swigEnum.swigValue;
    SwigNext.next = this.swigValue+1;
  }

  private final int swigValue;

  private static class SwigNext {
    private static int next = 0;
  }
}


-- CUresult.java
/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3.35
 *
 * Do not make changes to this file unless you know what you are doing--modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */


public enum CUresult {
  CUDA_SUCCESS(0),
  CUDA_ERROR_INVALID_VALUE(1),
  CUDA_ERROR_OUT_OF_MEMORY(2),
  CUDA_ERROR_NOT_INITIALIZED(3),
  CUDA_ERROR_NO_DEVICE(100),
  CUDA_ERROR_INVALID_DEVICE(101),
  CUDA_ERROR_INVALID_IMAGE(200),
  CUDA_ERROR_INVALID_CONTEXT(201),
  CUDA_ERROR_CONTEXT_ALREADY_CURRENT(202),
  CUDA_ERROR_MAP_FAILED(205),
  CUDA_ERROR_UNMAP_FAILED(206),
  CUDA_ERROR_ARRAY_IS_MAPPED(207),
  CUDA_ERROR_ALREADY_MAPPED(208),
  CUDA_ERROR_NO_BINARY_FOR_GPU(209),
  CUDA_ERROR_ALREADY_ACQUIRED(210),
  CUDA_ERROR_NOT_MAPPED(211),
  CUDA_ERROR_INVALID_SOURCE(300),
  CUDA_ERROR_FILE_NOT_FOUND(301),
  CUDA_ERROR_INVALID_HANDLE(400),
  CUDA_ERROR_NOT_FOUND(500),
  CUDA_ERROR_NOT_READY(600),
  CUDA_ERROR_LAUNCH_FAILED(700),
  CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES(701),
  CUDA_ERROR_LAUNCH_TIMEOUT(702),
  CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING(703),
  CUDA_ERROR_UNKNOWN(999);

  public final int swigValue() {
    return swigValue;
  }

  public static CUresult swigToEnum(int swigValue) {
    CUresult[] swigValues = CUresult.class.getEnumConstants();
    if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue)
      return swigValues[swigValue];
    for (CUresult swigEnum : swigValues)
      if (swigEnum.swigValue == swigValue)
        return swigEnum;
    throw new IllegalArgumentException("No enum " + CUresult.class + " with value " + swigValue);
  }

  @SuppressWarnings("unused")
  private CUresult() {
    this.swigValue = SwigNext.next++;
  }

  @SuppressWarnings("unused")
  private CUresult(int swigValue) {
    this.swigValue = swigValue;
    SwigNext.next = swigValue+1;
  }

  @SuppressWarnings("unused")
  private CUresult(CUresult swigEnum) {
    this.swigValue = swigEnum.swigValue;
    SwigNext.next = this.swigValue+1;
  }

  private final int swigValue;

  private static class SwigNext {
    private static int next = 0;
  }
}


-- CudaJNI.java
/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3.35
 *
 * Do not make changes to this file unless you know what you are doing--modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */


class CudaJNI {
  public final static native void CudaDeviceProp_name_set(long jarg1, CudaDeviceProp jarg1_, String jarg2);
  public final static native String CudaDeviceProp_name_get(long jarg1, CudaDeviceProp jarg1_);
  public final static native void CudaDeviceProp_totalGlobalMem_set(long jarg1, CudaDeviceProp jarg1_, long jarg2);
  public final static native long CudaDeviceProp_totalGlobalMem_get(long jarg1, CudaDeviceProp jarg1_);
  public final static native void CudaDeviceProp_sharedMemPerBlock_set(long jarg1, CudaDeviceProp jarg1_, long jarg2);
  public final static native long CudaDeviceProp_sharedMemPerBlock_get(long jarg1, CudaDeviceProp jarg1_);
  public final static native void CudaDeviceProp_regsPerBlock_set(long jarg1, CudaDeviceProp jarg1_, int jarg2);
  public final static native int CudaDeviceProp_regsPerBlock_get(long jarg1, CudaDeviceProp jarg1_);
  public final static native void CudaDeviceProp_warpSize_set(long jarg1, CudaDeviceProp jarg1_, int jarg2);
  public final static native int CudaDeviceProp_warpSize_get(long jarg1, CudaDeviceProp jarg1_);
  public final static native void CudaDeviceProp_memPitch_set(long jarg1, CudaDeviceProp jarg1_, long jarg2);
  public final static native long CudaDeviceProp_memPitch_get(long jarg1, CudaDeviceProp jarg1_);
  public final static native void CudaDeviceProp_maxThreadsPerBlock_set(long jarg1, CudaDeviceProp jarg1_, int jarg2);
  public final static native int CudaDeviceProp_maxThreadsPerBlock_get(long jarg1, CudaDeviceProp jarg1_);
  public final static native void CudaDeviceProp_maxThreadsDim_set(long jarg1, CudaDeviceProp jarg1_, int[] jarg2);
  public final static native int[] CudaDeviceProp_maxThreadsDim_get(long jarg1, CudaDeviceProp jarg1_);
  public final static native void CudaDeviceProp_maxGridSize_set(long jarg1, CudaDeviceProp jarg1_, int[] jarg2);
  public final static native int[] CudaDeviceProp_maxGridSize_get(long jarg1, CudaDeviceProp jarg1_);
  public final static native void CudaDeviceProp_totalConstMem_set(long jarg1, CudaDeviceProp jarg1_, long jarg2);
  public final static native long CudaDeviceProp_totalConstMem_get(long jarg1, CudaDeviceProp jarg1_);
  public final static native void CudaDeviceProp_major_set(long jarg1, CudaDeviceProp jarg1_, int jarg2);
  public final static native int CudaDeviceProp_major_get(long jarg1, CudaDeviceProp jarg1_);
  public final static native void CudaDeviceProp_minor_set(long jarg1, CudaDeviceProp jarg1_, int jarg2);
  public final static native int CudaDeviceProp_minor_get(long jarg1, CudaDeviceProp jarg1_);
  public final static native void CudaDeviceProp_clockRate_set(long jarg1, CudaDeviceProp jarg1_, int jarg2);
  public final static native int CudaDeviceProp_clockRate_get(long jarg1, CudaDeviceProp jarg1_);
  public final static native void CudaDeviceProp_textureAlignment_set(long jarg1, CudaDeviceProp jarg1_, long jarg2);
  public final static native long CudaDeviceProp_textureAlignment_get(long jarg1, CudaDeviceProp jarg1_);
  public final static native long new_CudaDeviceProp();
  public final static native void delete_CudaDeviceProp(long jarg1);
  public final static native int cudaGetDeviceCount(int[] jarg1);
  public final static native int cudaGetDeviceProperties(long jarg1, CudaDeviceProp jarg1_, int jarg2);
  public final static native int cudaSetDevice(int jarg1);
  public final static native int cudaThreadSynchronize();

    static {
        String libName = "jcuda";
        try {
            System.err.print("Loading JNI Library: "+libName+"...");
            System.loadLibrary(libName);
            System.err.println("OK.");
            System.err.print("Init JNI Library...");
            
            System.err.println("OK.");
        } catch (UnsatisfiedLinkError e) {
            System.err.println("\nJNI Library "+libName+" failed to load.\n" + e);
            System.exit(1);
        }
    }

}


-- cuda_wrap.c
/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3.35
 * 
 * This file is not intended to be easily readable and contains a number of 
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG 
 * interface file instead. 
 * ----------------------------------------------------------------------------- */

/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__)) 
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__)) 
# else
#   define SWIGUNUSED 
# endif
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#  ifndef GCC_HASCLASSVISIBILITY
#    define GCC_HASCLASSVISIBILITY
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif 
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif



/* Fix for jlong on some versions of gcc on Windows */
#if defined(__GNUC__) && !defined(__INTELC__)
  typedef long long __int64;
#endif

/* Fix for jlong on 64-bit x86 Solaris */
#if defined(__x86_64)
# ifdef _LP64
#   undef _LP64
# endif
#endif

#include <jni.h>
#include <stdlib.h>
#include <string.h>


/* Support for throwing Java exceptions */
typedef enum {
  SWIG_JavaOutOfMemoryError = 1, 
  SWIG_JavaIOException, 
  SWIG_JavaRuntimeException, 
  SWIG_JavaIndexOutOfBoundsException,
  SWIG_JavaArithmeticException,
  SWIG_JavaIllegalArgumentException,
  SWIG_JavaNullPointerException,
  SWIG_JavaDirectorPureVirtual,
  SWIG_JavaUnknownError
} SWIG_JavaExceptionCodes;

typedef struct {
  SWIG_JavaExceptionCodes code;
  const char *java_exception;
} SWIG_JavaExceptions_t;


static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) {
  jclass excep;
  static const SWIG_JavaExceptions_t java_exceptions[] = {
    { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" },
    { SWIG_JavaIOException, "java/io/IOException" },
    { SWIG_JavaRuntimeException, "java/lang/RuntimeException" },
    { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" },
    { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" },
    { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" },
    { SWIG_JavaNullPointerException, "java/lang/NullPointerException" },
    { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" },
    { SWIG_JavaUnknownError,  "java/lang/UnknownError" },
    { (SWIG_JavaExceptionCodes)0,  "java/lang/UnknownError" } };
  const SWIG_JavaExceptions_t *except_ptr = java_exceptions;

  while (except_ptr->code != code && except_ptr->code)
    except_ptr++;

  (*jenv)->ExceptionClear(jenv);
  excep = (*jenv)->FindClass(jenv, except_ptr->java_exception);
  if (excep)
    (*jenv)->ThrowNew(jenv, excep, msg);
}


/* Contract support */

#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } else


#include "cuda.h"
#include "cuda_runtime.h"


#if defined(SWIG_NOINCLUDE) || defined(SWIG_NOARRAYS)


int SWIG_JavaArrayInSchar (JNIEnv *jenv, jbyte **jarr, signed char **carr, jbyteArray input);
void SWIG_JavaArrayArgoutSchar (JNIEnv *jenv, jbyte *jarr, signed char *carr, jbyteArray input);
jbyteArray SWIG_JavaArrayOutSchar (JNIEnv *jenv, signed char *result, jsize sz);


int SWIG_JavaArrayInUchar (JNIEnv *jenv, jshort **jarr, unsigned char **carr, jshortArray input);
void SWIG_JavaArrayArgoutUchar (JNIEnv *jenv, jshort *jarr, unsigned char *carr, jshortArray input);
jshortArray SWIG_JavaArrayOutUchar (JNIEnv *jenv, unsigned char *result, jsize sz);


int SWIG_JavaArrayInShort (JNIEnv *jenv, jshort **jarr, short **carr, jshortArray input);
void SWIG_JavaArrayArgoutShort (JNIEnv *jenv, jshort *jarr, short *carr, jshortArray input);
jshortArray SWIG_JavaArrayOutShort (JNIEnv *jenv, short *result, jsize sz);


int SWIG_JavaArrayInUshort (JNIEnv *jenv, jint **jarr, unsigned short **carr, jintArray input);
void SWIG_JavaArrayArgoutUshort (JNIEnv *jenv, jint *jarr, unsigned short *carr, jintArray input);
jintArray SWIG_JavaArrayOutUshort (JNIEnv *jenv, unsigned short *result, jsize sz);


int SWIG_JavaArrayInInt (JNIEnv *jenv, jint **jarr, int **carr, jintArray input);
void SWIG_JavaArrayArgoutInt (JNIEnv *jenv, jint *jarr, int *carr, jintArray input);
jintArray SWIG_JavaArrayOutInt (JNIEnv *jenv, int *result, jsize sz);


int SWIG_JavaArrayInUint (JNIEnv *jenv, jlong **jarr, unsigned int **carr, jlongArray input);
void SWIG_JavaArrayArgoutUint (JNIEnv *jenv, jlong *jarr, unsigned int *carr, jlongArray input);
jlongArray SWIG_JavaArrayOutUint (JNIEnv *jenv, unsigned int *result, jsize sz);


int SWIG_JavaArrayInLong (JNIEnv *jenv, jint **jarr, long **carr, jintArray input);
void SWIG_JavaArrayArgoutLong (JNIEnv *jenv, jint *jarr, long *carr, jintArray input);
jintArray SWIG_JavaArrayOutLong (JNIEnv *jenv, long *result, jsize sz);


int SWIG_JavaArrayInUlong (JNIEnv *jenv, jlong **jarr, unsigned long **carr, jlongArray input);
void SWIG_JavaArrayArgoutUlong (JNIEnv *jenv, jlong *jarr, unsigned long *carr, jlongArray input);
jlongArray SWIG_JavaArrayOutUlong (JNIEnv *jenv, unsigned long *result, jsize sz);


int SWIG_JavaArrayInLonglong (JNIEnv *jenv, jlong **jarr, jlong **carr, jlongArray input);
void SWIG_JavaArrayArgoutLonglong (JNIEnv *jenv, jlong *jarr, jlong *carr, jlongArray input);
jlongArray SWIG_JavaArrayOutLonglong (JNIEnv *jenv, jlong *result, jsize sz);


int SWIG_JavaArrayInFloat (JNIEnv *jenv, jfloat **jarr, float **carr, jfloatArray input);
void SWIG_JavaArrayArgoutFloat (JNIEnv *jenv, jfloat *jarr, float *carr, jfloatArray input);
jfloatArray SWIG_JavaArrayOutFloat (JNIEnv *jenv, float *result, jsize sz);


int SWIG_JavaArrayInDouble (JNIEnv *jenv, jdouble **jarr, double **carr, jdoubleArray input);
void SWIG_JavaArrayArgoutDouble (JNIEnv *jenv, jdouble *jarr, double *carr, jdoubleArray input);
jdoubleArray SWIG_JavaArrayOutDouble (JNIEnv *jenv, double *result, jsize sz);


#else


/* signed char[] support */
int SWIG_JavaArrayInSchar (JNIEnv *jenv, jbyte **jarr, signed char **carr, jbyteArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = (*jenv)->GetArrayLength(jenv, input);
  *jarr = (*jenv)->GetByteArrayElements(jenv, input, 0);
  if (!*jarr)
    return 0; 
  *carr = (signed char*) calloc(sz, sizeof(signed char)); 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (signed char)(*jarr)[i];
  return 1;
}

void SWIG_JavaArrayArgoutSchar (JNIEnv *jenv, jbyte *jarr, signed char *carr, jbyteArray input) {
  int i;
  jsize sz = (*jenv)->GetArrayLength(jenv, input);
  for (i=0; i<sz; i++)
    jarr[i] = (jbyte)carr[i];
  (*jenv)->ReleaseByteArrayElements(jenv, input, jarr, 0);
}

jbyteArray SWIG_JavaArrayOutSchar (JNIEnv *jenv, signed char *result, jsize sz) {
  jbyte *arr;
  int i;
  jbyteArray jresult = (*jenv)->NewByteArray(jenv, sz);
  if (!jresult)
    return NULL;
  arr = (*jenv)->GetByteArrayElements(jenv, jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jbyte)result[i];
  (*jenv)->ReleaseByteArrayElements(jenv, jresult, arr, 0);
  return jresult;
}


/* unsigned char[] support */
int SWIG_JavaArrayInUchar (JNIEnv *jenv, jshort **jarr, unsigned char **carr, jshortArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = (*jenv)->GetArrayLength(jenv, input);
  *jarr = (*jenv)->GetShortArrayElements(jenv, input, 0);
  if (!*jarr)
    return 0; 
  *carr = (unsigned char*) calloc(sz, sizeof(unsigned char)); 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (unsigned char)(*jarr)[i];
  return 1;
}

void SWIG_JavaArrayArgoutUchar (JNIEnv *jenv, jshort *jarr, unsigned char *carr, jshortArray input) {
  int i;
  jsize sz = (*jenv)->GetArrayLength(jenv, input);
  for (i=0; i<sz; i++)
    jarr[i] = (jshort)carr[i];
  (*jenv)->ReleaseShortArrayElements(jenv, input, jarr, 0);
}

jshortArray SWIG_JavaArrayOutUchar (JNIEnv *jenv, unsigned char *result, jsize sz) {
  jshort *arr;
  int i;
  jshortArray jresult = (*jenv)->NewShortArray(jenv, sz);
  if (!jresult)
    return NULL;
  arr = (*jenv)->GetShortArrayElements(jenv, jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jshort)result[i];
  (*jenv)->ReleaseShortArrayElements(jenv, jresult, arr, 0);
  return jresult;
}


/* short[] support */
int SWIG_JavaArrayInShort (JNIEnv *jenv, jshort **jarr, short **carr, jshortArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = (*jenv)->GetArrayLength(jenv, input);
  *jarr = (*jenv)->GetShortArrayElements(jenv, input, 0);
  if (!*jarr)
    return 0; 
  *carr = (short*) calloc(sz, sizeof(short)); 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (short)(*jarr)[i];
  return 1;
}

void SWIG_JavaArrayArgoutShort (JNIEnv *jenv, jshort *jarr, short *carr, jshortArray input) {
  int i;
  jsize sz = (*jenv)->GetArrayLength(jenv, input);
  for (i=0; i<sz; i++)
    jarr[i] = (jshort)carr[i];
  (*jenv)->ReleaseShortArrayElements(jenv, input, jarr, 0);
}

jshortArray SWIG_JavaArrayOutShort (JNIEnv *jenv, short *result, jsize sz) {
  jshort *arr;
  int i;
  jshortArray jresult = (*jenv)->NewShortArray(jenv, sz);
  if (!jresult)
    return NULL;
  arr = (*jenv)->GetShortArrayElements(jenv, jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jshort)result[i];
  (*jenv)->ReleaseShortArrayElements(jenv, jresult, arr, 0);
  return jresult;
}


/* unsigned short[] support */
int SWIG_JavaArrayInUshort (JNIEnv *jenv, jint **jarr, unsigned short **carr, jintArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = (*jenv)->GetArrayLength(jenv, input);
  *jarr = (*jenv)->GetIntArrayElements(jenv, input, 0);
  if (!*jarr)
    return 0; 
  *carr = (unsigned short*) calloc(sz, sizeof(unsigned short)); 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (unsigned short)(*jarr)[i];
  return 1;
}

void SWIG_JavaArrayArgoutUshort (JNIEnv *jenv, jint *jarr, unsigned short *carr, jintArray input) {
  int i;
  jsize sz = (*jenv)->GetArrayLength(jenv, input);
  for (i=0; i<sz; i++)
    jarr[i] = (jint)carr[i];
  (*jenv)->ReleaseIntArrayElements(jenv, input, jarr, 0);
}

jintArray SWIG_JavaArrayOutUshort (JNIEnv *jenv, unsigned short *result, jsize sz) {
  jint *arr;
  int i;
  jintArray jresult = (*jenv)->NewIntArray(jenv, sz);
  if (!jresult)
    return NULL;
  arr = (*jenv)->GetIntArrayElements(jenv, jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jint)result[i];
  (*jenv)->ReleaseIntArrayElements(jenv, jresult, arr, 0);
  return jresult;
}


/* int[] support */
int SWIG_JavaArrayInInt (JNIEnv *jenv, jint **jarr, int **carr, jintArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = (*jenv)->GetArrayLength(jenv, input);
  *jarr = (*jenv)->GetIntArrayElements(jenv, input, 0);
  if (!*jarr)
    return 0; 
  *carr = (int*) calloc(sz, sizeof(int)); 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (int)(*jarr)[i];
  return 1;
}

void SWIG_JavaArrayArgoutInt (JNIEnv *jenv, jint *jarr, int *carr, jintArray input) {
  int i;
  jsize sz = (*jenv)->GetArrayLength(jenv, input);
  for (i=0; i<sz; i++)
    jarr[i] = (jint)carr[i];
  (*jenv)->ReleaseIntArrayElements(jenv, input, jarr, 0);
}

jintArray SWIG_JavaArrayOutInt (JNIEnv *jenv, int *result, jsize sz) {
  jint *arr;
  int i;
  jintArray jresult = (*jenv)->NewIntArray(jenv, sz);
  if (!jresult)
    return NULL;
  arr = (*jenv)->GetIntArrayElements(jenv, jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jint)result[i];
  (*jenv)->ReleaseIntArrayElements(jenv, jresult, arr, 0);
  return jresult;
}


/* unsigned int[] support */
int SWIG_JavaArrayInUint (JNIEnv *jenv, jlong **jarr, unsigned int **carr, jlongArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = (*jenv)->GetArrayLength(jenv, input);
  *jarr = (*jenv)->GetLongArrayElements(jenv, input, 0);
  if (!*jarr)
    return 0; 
  *carr = (unsigned int*) calloc(sz, sizeof(unsigned int)); 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (unsigned int)(*jarr)[i];
  return 1;
}

void SWIG_JavaArrayArgoutUint (JNIEnv *jenv, jlong *jarr, unsigned int *carr, jlongArray input) {
  int i;
  jsize sz = (*jenv)->GetArrayLength(jenv, input);
  for (i=0; i<sz; i++)
    jarr[i] = (jlong)carr[i];
  (*jenv)->ReleaseLongArrayElements(jenv, input, jarr, 0);
}

jlongArray SWIG_JavaArrayOutUint (JNIEnv *jenv, unsigned int *result, jsize sz) {
  jlong *arr;
  int i;
  jlongArray jresult = (*jenv)->NewLongArray(jenv, sz);
  if (!jresult)
    return NULL;
  arr = (*jenv)->GetLongArrayElements(jenv, jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jlong)result[i];
  (*jenv)->ReleaseLongArrayElements(jenv, jresult, arr, 0);
  return jresult;
}


/* long[] support */
int SWIG_JavaArrayInLong (JNIEnv *jenv, jint **jarr, long **carr, jintArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = (*jenv)->GetArrayLength(jenv, input);
  *jarr = (*jenv)->GetIntArrayElements(jenv, input, 0);
  if (!*jarr)
    return 0; 
  *carr = (long*) calloc(sz, sizeof(long)); 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (long)(*jarr)[i];
  return 1;
}

void SWIG_JavaArrayArgoutLong (JNIEnv *jenv, jint *jarr, long *carr, jintArray input) {
  int i;
  jsize sz = (*jenv)->GetArrayLength(jenv, input);
  for (i=0; i<sz; i++)
    jarr[i] = (jint)carr[i];
  (*jenv)->ReleaseIntArrayElements(jenv, input, jarr, 0);
}

jintArray SWIG_JavaArrayOutLong (JNIEnv *jenv, long *result, jsize sz) {
  jint *arr;
  int i;
  jintArray jresult = (*jenv)->NewIntArray(jenv, sz);
  if (!jresult)
    return NULL;
  arr = (*jenv)->GetIntArrayElements(jenv, jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jint)result[i];
  (*jenv)->ReleaseIntArrayElements(jenv, jresult, arr, 0);
  return jresult;
}


/* unsigned long[] support */
int SWIG_JavaArrayInUlong (JNIEnv *jenv, jlong **jarr, unsigned long **carr, jlongArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = (*jenv)->GetArrayLength(jenv, input);
  *jarr = (*jenv)->GetLongArrayElements(jenv, input, 0);
  if (!*jarr)
    return 0; 
  *carr = (unsigned long*) calloc(sz, sizeof(unsigned long)); 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (unsigned long)(*jarr)[i];
  return 1;
}

void SWIG_JavaArrayArgoutUlong (JNIEnv *jenv, jlong *jarr, unsigned long *carr, jlongArray input) {
  int i;
  jsize sz = (*jenv)->GetArrayLength(jenv, input);
  for (i=0; i<sz; i++)
    jarr[i] = (jlong)carr[i];
  (*jenv)->ReleaseLongArrayElements(jenv, input, jarr, 0);
}

jlongArray SWIG_JavaArrayOutUlong (JNIEnv *jenv, unsigned long *result, jsize sz) {
  jlong *arr;
  int i;
  jlongArray jresult = (*jenv)->NewLongArray(jenv, sz);
  if (!jresult)
    return NULL;
  arr = (*jenv)->GetLongArrayElements(jenv, jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jlong)result[i];
  (*jenv)->ReleaseLongArrayElements(jenv, jresult, arr, 0);
  return jresult;
}


/* jlong[] support */
int SWIG_JavaArrayInLonglong (JNIEnv *jenv, jlong **jarr, jlong **carr, jlongArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = (*jenv)->GetArrayLength(jenv, input);
  *jarr = (*jenv)->GetLongArrayElements(jenv, input, 0);
  if (!*jarr)
    return 0; 
  *carr = (jlong*) calloc(sz, sizeof(jlong)); 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (jlong)(*jarr)[i];
  return 1;
}

void SWIG_JavaArrayArgoutLonglong (JNIEnv *jenv, jlong *jarr, jlong *carr, jlongArray input) {
  int i;
  jsize sz = (*jenv)->GetArrayLength(jenv, input);
  for (i=0; i<sz; i++)
    jarr[i] = (jlong)carr[i];
  (*jenv)->ReleaseLongArrayElements(jenv, input, jarr, 0);
}

jlongArray SWIG_JavaArrayOutLonglong (JNIEnv *jenv, jlong *result, jsize sz) {
  jlong *arr;
  int i;
  jlongArray jresult = (*jenv)->NewLongArray(jenv, sz);
  if (!jresult)
    return NULL;
  arr = (*jenv)->GetLongArrayElements(jenv, jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jlong)result[i];
  (*jenv)->ReleaseLongArrayElements(jenv, jresult, arr, 0);
  return jresult;
}


/* float[] support */
int SWIG_JavaArrayInFloat (JNIEnv *jenv, jfloat **jarr, float **carr, jfloatArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = (*jenv)->GetArrayLength(jenv, input);
  *jarr = (*jenv)->GetFloatArrayElements(jenv, input, 0);
  if (!*jarr)
    return 0; 
  *carr = (float*) calloc(sz, sizeof(float)); 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (float)(*jarr)[i];
  return 1;
}

void SWIG_JavaArrayArgoutFloat (JNIEnv *jenv, jfloat *jarr, float *carr, jfloatArray input) {
  int i;
  jsize sz = (*jenv)->GetArrayLength(jenv, input);
  for (i=0; i<sz; i++)
    jarr[i] = (jfloat)carr[i];
  (*jenv)->ReleaseFloatArrayElements(jenv, input, jarr, 0);
}

jfloatArray SWIG_JavaArrayOutFloat (JNIEnv *jenv, float *result, jsize sz) {
  jfloat *arr;
  int i;
  jfloatArray jresult = (*jenv)->NewFloatArray(jenv, sz);
  if (!jresult)
    return NULL;
  arr = (*jenv)->GetFloatArrayElements(jenv, jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jfloat)result[i];
  (*jenv)->ReleaseFloatArrayElements(jenv, jresult, arr, 0);
  return jresult;
}


/* double[] support */
int SWIG_JavaArrayInDouble (JNIEnv *jenv, jdouble **jarr, double **carr, jdoubleArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = (*jenv)->GetArrayLength(jenv, input);
  *jarr = (*jenv)->GetDoubleArrayElements(jenv, input, 0);
  if (!*jarr)
    return 0; 
  *carr = (double*) calloc(sz, sizeof(double)); 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (double)(*jarr)[i];
  return 1;
}

void SWIG_JavaArrayArgoutDouble (JNIEnv *jenv, jdouble *jarr, double *carr, jdoubleArray input) {
  int i;
  jsize sz = (*jenv)->GetArrayLength(jenv, input);
  for (i=0; i<sz; i++)
    jarr[i] = (jdouble)carr[i];
  (*jenv)->ReleaseDoubleArrayElements(jenv, input, jarr, 0);
}

jdoubleArray SWIG_JavaArrayOutDouble (JNIEnv *jenv, double *result, jsize sz) {
  jdouble *arr;
  int i;
  jdoubleArray jresult = (*jenv)->NewDoubleArray(jenv, sz);
  if (!jresult)
    return NULL;
  arr = (*jenv)->GetDoubleArrayElements(jenv, jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jdouble)result[i];
  (*jenv)->ReleaseDoubleArrayElements(jenv, jresult, arr, 0);
  return jresult;
}


#endif


#ifdef __cplusplus
extern "C" {
#endif

SWIGEXPORT void JNICALL Java_CudaJNI_CudaDeviceProp_1name_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  char *arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
    if (!arg2) return ;
  }
  {
    if (arg2) strncpy((char *)arg1->name, (const char *)arg2, 256);
    else arg1->name[0] = 0;
  }
  
  if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
}


SWIGEXPORT jstring JNICALL Java_CudaJNI_CudaDeviceProp_1name_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  result = (char *)(char *) ((arg1)->name);
  if(result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result);
  return jresult;
}


SWIGEXPORT void JNICALL Java_CudaJNI_CudaDeviceProp_1totalGlobalMem_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  size_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  arg2 = (size_t)jarg2; 
  if (arg1) (arg1)->totalGlobalMem = arg2;
  
}


SWIGEXPORT jlong JNICALL Java_CudaJNI_CudaDeviceProp_1totalGlobalMem_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  size_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  result =  ((arg1)->totalGlobalMem);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_CudaJNI_CudaDeviceProp_1sharedMemPerBlock_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  size_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  arg2 = (size_t)jarg2; 
  if (arg1) (arg1)->sharedMemPerBlock = arg2;
  
}


SWIGEXPORT jlong JNICALL Java_CudaJNI_CudaDeviceProp_1sharedMemPerBlock_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  size_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  result =  ((arg1)->sharedMemPerBlock);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_CudaJNI_CudaDeviceProp_1regsPerBlock_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->regsPerBlock = arg2;
  
}


SWIGEXPORT jint JNICALL Java_CudaJNI_CudaDeviceProp_1regsPerBlock_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  result = (int) ((arg1)->regsPerBlock);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_CudaJNI_CudaDeviceProp_1warpSize_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->warpSize = arg2;
  
}


SWIGEXPORT jint JNICALL Java_CudaJNI_CudaDeviceProp_1warpSize_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  result = (int) ((arg1)->warpSize);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_CudaJNI_CudaDeviceProp_1memPitch_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  size_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  arg2 = (size_t)jarg2; 
  if (arg1) (arg1)->memPitch = arg2;
  
}


SWIGEXPORT jlong JNICALL Java_CudaJNI_CudaDeviceProp_1memPitch_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  size_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  result =  ((arg1)->memPitch);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_CudaJNI_CudaDeviceProp_1maxThreadsPerBlock_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->maxThreadsPerBlock = arg2;
  
}


SWIGEXPORT jint JNICALL Java_CudaJNI_CudaDeviceProp_1maxThreadsPerBlock_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  result = (int) ((arg1)->maxThreadsPerBlock);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_CudaJNI_CudaDeviceProp_1maxThreadsDim_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jintArray jarg2) {
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  int *arg2 ;
  jint *jarr2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  if (jarg2 && (*jenv)->GetArrayLength(jenv, jarg2) != 3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
    return ;
  }
  if (!SWIG_JavaArrayInInt(jenv, &jarr2, &arg2, jarg2)) return ; 
  {
    size_t ii;
    int *b = (int *) arg1->maxThreadsDim;
    for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((int *) arg2 + ii);
  }
  SWIG_JavaArrayArgoutInt(jenv, jarr2, arg2, jarg2); 
  free(arg2); 
}


SWIGEXPORT jintArray JNICALL Java_CudaJNI_CudaDeviceProp_1maxThreadsDim_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jintArray jresult = 0 ;
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  int *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  result = (int *)(int *) ((arg1)->maxThreadsDim);
  jresult = SWIG_JavaArrayOutInt(jenv, result, 3); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_CudaJNI_CudaDeviceProp_1maxGridSize_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jintArray jarg2) {
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  int *arg2 ;
  jint *jarr2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  if (jarg2 && (*jenv)->GetArrayLength(jenv, jarg2) != 3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
    return ;
  }
  if (!SWIG_JavaArrayInInt(jenv, &jarr2, &arg2, jarg2)) return ; 
  {
    size_t ii;
    int *b = (int *) arg1->maxGridSize;
    for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((int *) arg2 + ii);
  }
  SWIG_JavaArrayArgoutInt(jenv, jarr2, arg2, jarg2); 
  free(arg2); 
}


SWIGEXPORT jintArray JNICALL Java_CudaJNI_CudaDeviceProp_1maxGridSize_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jintArray jresult = 0 ;
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  int *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  result = (int *)(int *) ((arg1)->maxGridSize);
  jresult = SWIG_JavaArrayOutInt(jenv, result, 3); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_CudaJNI_CudaDeviceProp_1totalConstMem_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  size_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  arg2 = (size_t)jarg2; 
  if (arg1) (arg1)->totalConstMem = arg2;
  
}


SWIGEXPORT jlong JNICALL Java_CudaJNI_CudaDeviceProp_1totalConstMem_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  size_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  result =  ((arg1)->totalConstMem);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_CudaJNI_CudaDeviceProp_1major_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->major = arg2;
  
}


SWIGEXPORT jint JNICALL Java_CudaJNI_CudaDeviceProp_1major_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  result = (int) ((arg1)->major);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_CudaJNI_CudaDeviceProp_1minor_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->minor = arg2;
  
}


SWIGEXPORT jint JNICALL Java_CudaJNI_CudaDeviceProp_1minor_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  result = (int) ((arg1)->minor);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_CudaJNI_CudaDeviceProp_1clockRate_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->clockRate = arg2;
  
}


SWIGEXPORT jint JNICALL Java_CudaJNI_CudaDeviceProp_1clockRate_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  result = (int) ((arg1)->clockRate);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_CudaJNI_CudaDeviceProp_1textureAlignment_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  size_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  arg2 = (size_t)jarg2; 
  if (arg1) (arg1)->textureAlignment = arg2;
  
}


SWIGEXPORT jlong JNICALL Java_CudaJNI_CudaDeviceProp_1textureAlignment_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  size_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  result =  ((arg1)->textureAlignment);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_CudaJNI_new_1CudaDeviceProp(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  struct cudaDeviceProp *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (struct cudaDeviceProp *)calloc(1, sizeof(struct cudaDeviceProp));
  *(struct cudaDeviceProp **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_CudaJNI_delete_1CudaDeviceProp(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  free((char *) arg1);
  
}


SWIGEXPORT jint JNICALL Java_CudaJNI_cudaGetDeviceCount(JNIEnv *jenv, jclass jcls, jintArray jarg1) {
  jint jresult = 0 ;
  int *arg1 = (int *) 0 ;
  cudaError_t result;
  int temp1 ;
  
  (void)jenv;
  (void)jcls;
  {
    if (!jarg1) {
      SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
      return 0;
    }
    if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
      SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
      return 0;
    }
    arg1 = &temp1; 
  }
  result = (cudaError_t)cudaGetDeviceCount(arg1);
  jresult = (jint)result; 
  {
    jint jvalue = (jint)temp1;
    (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
  }
  
  return jresult;
}


SWIGEXPORT jint JNICALL Java_CudaJNI_cudaGetDeviceProperties(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jint jresult = 0 ;
  struct cudaDeviceProp *arg1 = (struct cudaDeviceProp *) 0 ;
  int arg2 ;
  cudaError_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(struct cudaDeviceProp **)&jarg1; 
  arg2 = (int)jarg2; 
  result = (cudaError_t)cudaGetDeviceProperties(arg1,arg2);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_CudaJNI_cudaSetDevice(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jint jresult = 0 ;
  int arg1 ;
  cudaError_t result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  result = (cudaError_t)cudaSetDevice(arg1);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_CudaJNI_cudaThreadSynchronize(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  cudaError_t result;
  
  (void)jenv;
  (void)jcls;
  result = (cudaError_t)cudaThreadSynchronize();
  jresult = (jint)result; 
  return jresult;
}


#ifdef __cplusplus
}
#endif


-- TestCudaSelect.java

public class TestCudaSelect {

	private static void cuCheckError(CUresult error) {
		if (error != CUresult.CUDA_SUCCESS) {
			throw new RuntimeException("Java Cu Exception: " + error.toString());
		}
	}

	private static void cudaCheckErrorNoSynch(CudaError error) {
		if (error != CudaError.cudaSuccess) {
			throw new RuntimeException("Java Cuda Exception: "
					+ error.toString());
		}
	}

	private static void cudaCheckError(CudaError error) {
		cudaCheckErrorNoSynch(error);
		error = Cuda.cudaThreadSynchronize();
		if (error != CudaError.cudaSuccess) {
			throw new RuntimeException("Java Cuda Synch Exception: "
					+ error.toString());
		}
	}

	public static void main(String[] args) {
		int[] deviceCount = new int[1];
		cudaCheckErrorNoSynch(Cuda.cudaGetDeviceCount(deviceCount));
		if (deviceCount[0] == 0) {
			System.err.println("There is no device.");
			System.exit(1);
		}

		int dev = 0;
		for (; dev < deviceCount[0]; ++dev) {
			CudaDeviceProp deviceProp = new CudaDeviceProp();
			cudaCheckErrorNoSynch(Cuda.cudaGetDeviceProperties(deviceProp, dev));
			if (deviceProp.getMajor() >= 1) {
				System.err.println(deviceProp.toString());
				break;
			}
		}
		if (dev == deviceCount[0]) {
			System.err.println("There is no device supporting CUDA.");
			System.exit(1);
		} else {
			cudaCheckError(Cuda.cudaSetDevice(dev));
		}
	}

}



-- TestCudaSelectGUI.java

public class TestCudaSelect {

	private static void cuCheckError(CUresult error) {
		if (error != CUresult.CUDA_SUCCESS) {
			throw new RuntimeException("Java Cu Exception: " + error.toString());
		}
	}

	private static void cudaCheckErrorNoSynch(CudaError error) {
		if (error != CudaError.cudaSuccess) {
			throw new RuntimeException("Java Cuda Exception: "
					+ error.toString());
		}
	}

	private static void cudaCheckError(CudaError error) {
		cudaCheckErrorNoSynch(error);
		error = Cuda.cudaThreadSynchronize();
		if (error != CudaError.cudaSuccess) {
			throw new RuntimeException("Java Cuda Synch Exception: "
					+ error.toString());
		}
	}

	public static void main(String[] args) {
		int[] deviceCount = new int[1];
		cudaCheckErrorNoSynch(Cuda.cudaGetDeviceCount(deviceCount));
		if (deviceCount[0] == 0) {
			System.err.println("There is no device.");
			System.exit(1);
		}

		int dev = 0;
		for (; dev < deviceCount[0]; ++dev) {
			CudaDeviceProp deviceProp = new CudaDeviceProp();
			cudaCheckErrorNoSynch(Cuda.cudaGetDeviceProperties(deviceProp, dev));
			if (deviceProp.getMajor() >= 1) {
				System.err.println(deviceProp.toString());
				break;
			}
		}
		if (dev == deviceCount[0]) {
			System.err.println("There is no device supporting CUDA.");
			System.exit(1);
		} else {
			cudaCheckError(Cuda.cudaSetDevice(dev));
		}
	}

}


-- panic-report.txt
Tue Apr 22 14:52:28 2008
panic(cpu 0 caller 0x001A8C8A): Kernel trap at 0x00b2c6b3, type 14=page fault, registers:
CR0: 0x8001003b, CR2: 0x0000000c, CR3: 0x013dd000, CR4: 0x00000660
EAX: 0x0728f800, EBX: 0x00000000, ECX: 0x00000001, EDX: 0x076f51d8
CR2: 0x0000000c, EBP: 0x65147978, ESI: 0xc1d0005c, EDI: 0x00000000
EFL: 0x00010206, EIP: 0x00b2c6b3, CS:  0x00000008, DS:  0x5c000010
Error code: 0x00000000

Backtrace, Format - Frame : Return Address (4 potential args on stack) 
0x65147778 : 0x12b0f7 (0x4581f4 0x651477ac 0x133230 0x0) 
0x651477c8 : 0x1a8c8a (0x461720 0xb2c6b3 0xe 0x460ed0) 
0x651478a8 : 0x19ece5 (0x651478c0 0x65147a74 0x65147978 0xb2c6b3) 
0x651478b8 : 0xb2c6b3 (0xe 0x48 0x10 0xb30010) 
0x65147978 : 0xb3cbef (0x0 0x76f51d8 0x0 0x6514799c) 
0x651479a8 : 0xb86434 (0x7511004 0x0 0x4c8f8000 0x4c8f8000) 
0x65147a38 : 0xb37173 (0xc1d0005c 0x5c000001 0x5c000018 0x4c8f8000) 
0x65147a98 : 0xb421fa (0xc1d0005c 0x5c000001 0x5c000018 0x5c000018) 
0x65147b08 : 0xb462d9 (0xc1d0005c 0x5c000001 0x40 0x5c000018) 
0x65147b88 : 0xb464a2 (0xc1d0005c 0x5c000001 0x0 0x120fcb) 
0x65147bd8 : 0xb4a89b (0xc1d0005c 0x65147c2c 0x65147c08 0x3ea7d9) 
0x65147c48 : 0xb2e2b0 (0xc1d0005c 0x0 0xc1d0005c 0xb2c203) 
0x65147c68 : 0xb2e326 (0x8f6f700 0x8f6f700 0x65147c98 0xb2bcd8) 
0x65147c78 : 0xb2bcd8 (0x8f6f700 0x10f0 0x65147cb8 0x1d) 
0x65147c98 : 0x43d4ed (0x8f6f700 0x5328b0 0x65147ce8 0x0) 
0x65147cb8 : 0x187332 (0x8f6f700 0x909c7a8 0x1d 0x65147ce8) 
	Backtrace continues...
      Kernel loadable modules in backtrace (with dependencies):
         com.apple.NVDAResman(5.2.4)@0xb28000->0xd67fff
            dependency: com.apple.iokit.IONDRVSupport(1.5)@0xb1a000
            dependency: com.apple.iokit.IOPCIFamily(2.4.1)@0x5c1000
            dependency: com.apple.iokit.IOGraphicsFamily(1.5.1)@0xafe000

BSD process name corresponding to current thread: java

Mac OS version:
9C7010

Kernel version:
Darwin Kernel Version 9.2.2: Tue Mar  4 21:17:34 PST 2008; root:xnu-1228.4.31~1/RELEASE_I386
System model name: MacBookPro3,1 (Mac-F4238BC8)

--