--- /dev/null
+CUDASDK = /usr/local/cuda
+
+LIBRARY_PATH=$(CUDASDK)/lib:$(CUDASDK)/lib64
+
+all:
+ LIBRARY_PATH=$(LIBRARY_PATH) gnatmake -p -Pcuda_ada
+
+clean:
+ @rm -rf obj
+
+.PHONY: all clean
--- /dev/null
+project Cuda_Ada is
+
+ for Object_Dir use "obj";
+ for Main use ("enum_devices.adb", "add.adb");
+ for Source_Dirs use ("src", "thin");
+
+end Cuda_Ada;
+
--- /dev/null
+#LyX 1.6.7 created this file. For more info see http://www.lyx.org/
+\lyxformat 345
+\begin_document
+\begin_header
+\textclass article
+\use_default_options true
+\language english
+\inputencoding auto
+\font_roman default
+\font_sans default
+\font_typewriter default
+\font_default_family default
+\font_sc false
+\font_osf false
+\font_sf_scale 100
+\font_tt_scale 100
+
+\graphics default
+\paperfontsize default
+\spacing single
+\use_hyperref false
+\pdf_title "pyCUDA"
+\pdf_author "Reto Buerki"
+\pdf_subject "pyCUDA"
+\pdf_keywords "CUDA python pyCUDA GPU"
+\pdf_bookmarks true
+\pdf_bookmarksnumbered false
+\pdf_bookmarksopen false
+\pdf_bookmarksopenlevel 1
+\pdf_breaklinks false
+\pdf_pdfborder false
+\pdf_colorlinks false
+\pdf_backref false
+\pdf_pdfusetitle true
+\papersize a4paper
+\use_geometry false
+\use_amsmath 1
+\use_esint 1
+\cite_engine basic
+\use_bibtopic false
+\paperorientation portrait
+\secnumdepth 3
+\tocdepth 3
+\paragraph_separation indent
+\defskip medskip
+\quotes_language english
+\papercolumns 1
+\papersides 2
+\paperpagestyle fancy
+\tracking_changes false
+\output_changes false
+\author ""
+\author ""
+\end_header
+
+\begin_body
+
+\begin_layout Title
+Implementing a (minimal) Ada binding to CUDA (using PyCUDA as example)
+\end_layout
+
+\begin_layout Author
+Reto Bürki
+\end_layout
+
+\begin_layout Standard
+\align center
+University of Applied Sciences Rapperswil (HSR), Switzerland
+\end_layout
+
+\begin_layout Abstract
+Abstract about PyCUDA, Ada, ...
+\end_layout
+
+\begin_layout Section
+Introduction
+\end_layout
+
+\begin_layout Standard
+The aim of this article is to outline the design and the functionality of
+ a CUDA binding
+\begin_inset Foot
+status open
+
+\begin_layout Plain Layout
+Wrapper = binding
+\end_layout
+
+\end_inset
+
+ for the Ada programming language.
+ In order to do this PyCUDA, a CUDA wrapper for python, is examined and
+ the functionality is explained.
+\end_layout
+
+\begin_layout Standard
+The main characteristics of PyCUDA are then transferred to the Ada language
+ domain.
+ Since the time constraints of the project do not permit to write a fully
+ functional binding, only the main features of PyCUDA are implemented to
+ demonstrate the concepts of PyCUDA.
+ Nevertheless, the resulting Ada binding could serve as foundation for further
+ work.
+\end_layout
+
+\begin_layout Standard
+The article also documents the steps needed to write a thick binding for
+ Ada using a compiler generated thin binding.
+\end_layout
+
+\begin_layout Section
+CUDA
+\end_layout
+
+\begin_layout Standard
+Short introduction to CUDA in general.
+ References to further CUDA material.
+ Driver API vs.
+ Runtime API.
+\end_layout
+
+\begin_layout Section
+PyCUDA
+\end_layout
+
+\begin_layout Standard
+Introduction to PyCUDA.
+ Why this wrapper? Why another CUDA wrapper anyway?
+\end_layout
+
+\begin_layout Itemize
+PyCUDA is based on the driver API, not the higher-level CUDA runtime API
+\end_layout
+
+\begin_layout Itemize
+\begin_inset Quotes eld
+\end_inset
+
+GPU programming therefore relies extensively on experimentation and microbenchma
+rking to overcome missing knowledge of causes by obtaining measurements
+ of symptoms.
+\begin_inset Quotes eld
+\end_inset
+
+
+\end_layout
+
+\begin_layout Subsection
+Advantages
+\end_layout
+
+\begin_layout Itemize
+RAII (Object cleanup tied to lifetime of objects)
+\end_layout
+
+\begin_layout Itemize
+Convenience and abstraction
+\end_layout
+
+\begin_deeper
+\begin_layout Itemize
+pycuda.compiler.SourceModule
+\end_layout
+
+\begin_layout Itemize
+pycuda.gpuarray.GPUArray
+\end_layout
+
+\end_deeper
+\begin_layout Itemize
+Completeness
+\end_layout
+
+\begin_layout Itemize
+Automatic error checking
+\end_layout
+
+\begin_layout Itemize
+Speed (base layer is written in C
+\family typewriter
+++
+\family default
+)
+\end_layout
+
+\begin_layout Itemize
+pycuda.gpuarray
+\end_layout
+
+\begin_layout Itemize
+Simplifies memory transfers
+\end_layout
+
+\begin_deeper
+\begin_layout Itemize
+pycuda.driver.In, pycuda.driver.Out, and pycuda.driver.InOut
+\end_layout
+
+\end_deeper
+\begin_layout Itemize
+Helpful documentation
+\end_layout
+
+\begin_layout Subsection
+Concepts
+\end_layout
+
+\begin_layout Subsubsection
+Code is data
+\end_layout
+
+\begin_layout Standard
+It wants to be reasoned about at run time
+\end_layout
+
+\begin_layout Subsubsection
+GPU run-time code generation (RTCG)
+\end_layout
+
+\begin_layout Standard
+\begin_inset Quotes eld
+\end_inset
+
+PyCUDA augments the CUDA runtime system by a critical capability: It allows
+ the user to easily create on-GPU binaries simply by providing C-like CUDA
+ source code as a simple character string.
+ This is what enables GPU run-time code generation.
+\begin_inset Quotes erd
+\end_inset
+
+
+\end_layout
+
+\begin_layout Subsection
+Overview
+\end_layout
+
+\begin_layout Subsubsection
+Call-chain
+\end_layout
+
+\begin_layout Itemize
+pycuda → ../src/wrapper (C
+\family typewriter
+++
+\family default
+) → ../src/cpp → cuda API
+\end_layout
+
+\begin_layout Subsection
+pycuda.autoinit
+\end_layout
+
+\begin_layout Standard
+Takes care of CUDA init/cleanup and context creation: When imported, automatical
+ly performs all the steps necessary to get CUDA ready for submission of
+ compute kernels.
+ It uses pycuda.tools.make_default_context() to create a compute context.
+\end_layout
+
+\begin_layout Itemize
+cuda.Init() (cuda.hpp)
+\end_layout
+
+\begin_deeper
+\begin_layout Itemize
+cuInit
+\end_layout
+
+\end_deeper
+\begin_layout Itemize
+make_default_context
+\end_layout
+
+\begin_deeper
+\begin_layout Itemize
+check cuda.Device.count() /= 0
+\end_layout
+
+\begin_layout Itemize
+device::make_context()
+\end_layout
+
+\begin_layout Itemize
+CUcontext ctx
+\end_layout
+
+\begin_layout Itemize
+cuCtxCreate, (&ctx, flags, m_device)
+\end_layout
+
+\end_deeper
+\begin_layout Itemize
+clear_context_caches (cleanup)
+\end_layout
+
+\begin_layout Subsection
+Just-in-time Compilation
+\end_layout
+
+\begin_layout Itemize
+SourceModule
+\end_layout
+
+\begin_deeper
+\begin_layout Itemize
+compile()/compile_plain()
+\end_layout
+
+\begin_layout Itemize
+Check cache first if already done (using hashing)
+\end_layout
+
+\begin_layout Itemize
+Write source to ''cachedir/file.cu''
+\end_layout
+
+\begin_layout Itemize
+nvidia's nvcc (Open64) (
+\family typewriter
+./nvcc --cubin cachedir/file.cu
+\family default
+)
+\end_layout
+
+\begin_deeper
+\begin_layout Itemize
+Check return code and error messages
+\end_layout
+
+\begin_layout Itemize
+Read cubin file to buffer
+\end_layout
+
+\end_deeper
+\begin_layout Itemize
+module_from_buffer
+\end_layout
+
+\begin_layout Itemize
+cuModuleLoadDataEx
+\end_layout
+
+\begin_layout Itemize
+get_function
+\end_layout
+
+\begin_deeper
+\begin_layout Itemize
+function module::get_function (C
+\family typewriter
+++
+\family default
+, cuda.hpp)
+\end_layout
+
+\begin_layout Itemize
+CUfunction func
+\end_layout
+
+\begin_layout Itemize
+cuModuleGetFunction
+\end_layout
+
+\end_deeper
+\begin_layout Itemize
+driver.function_call
+\end_layout
+
+\begin_deeper
+\begin_layout Itemize
+_launch_grid
+\end_layout
+
+\begin_layout Itemize
+cuLaunchGrid
+\end_layout
+
+\begin_layout Itemize
+(cuLaunchKernel, CUDA >= 4)
+\end_layout
+
+\end_deeper
+\end_deeper
+\begin_layout Subsection
+Automatic error checking
+\end_layout
+
+\begin_layout Section
+CUDA/Ada
+\end_layout
+
+\begin_layout Subsection
+Limitations
+\end_layout
+
+\begin_layout Standard
+Ada does not support introspection so the Binding will not be as comfortable
+ to use as PyCUDA.
+\end_layout
+
+\begin_layout Section
+Optional (if not Ada)
+\end_layout
+
+\begin_layout Standard
+Explain PyCUDA architecture/features in more detail.
+\end_layout
+
+\begin_layout Subsection
+Debugging
+\end_layout
+
+\begin_layout Subsection
+Profiling
+\end_layout
+
+\begin_layout Subsection
+Metaprogramming with PyCUDA
+\end_layout
+
+\begin_layout Subsubsection
+Jinja 2
+\end_layout
+
+\begin_layout Subsubsection
+Cheetah
+\end_layout
+
+\begin_layout Subsubsection
+CodePy
+\end_layout
+
+\begin_layout Subsection
+Copperhead
+\end_layout
+
+\begin_layout Standard
+Uses PyCUDA, CodePy and Thrust
+\end_layout
+
+\begin_layout Section
+Conclusions
+\end_layout
+
+\end_body
+\end_document
--- /dev/null
+with Ada.Text_IO;
+
+with System;
+
+with Interfaces.C.Strings;
+
+with cuda_h;
+with cuda_runtime_api_h;
+with driver_types_h;
+
+with CUDA.Compiler;
+
+procedure Add
+is
+ pragma Linker_Options ("-lcuda");
+ pragma Linker_Options ("-lcudart");
+
+ package IC renames Interfaces.C;
+
+ CUDA_Error : exception;
+
+ type Kernel_Param_Type is array (1 .. 3) of System.Address;
+
+ procedure Check_Result
+ (Code : cuda_h.CUresult;
+ Msg : String)
+ is
+ use type cuda_h.CUresult;
+ begin
+ if Code /= driver_types_h.cudaSuccess then
+ raise CUDA_Error with Msg & " (" & Code'Img & ")";
+ end if;
+ end Check_Result;
+
+ Dev : aliased IC.int;
+ Ctx : cuda_h.CUcontext;
+begin
+ Check_Result (Code => cuda_h.cuInit (arg1 => 0),
+ Msg => "CUDA init failed");
+ Check_Result (Code => cuda_runtime_api_h.cudaGetDevice (arg1 => Dev'Access),
+ Msg => "Could not get device");
+ Check_Result
+ (Code => cuda_h.cuCtxCreate_v2
+ (arg1 => Ctx'Address,
+ arg2 => 0,
+ arg3 => Dev),
+ Msg => "Context creation failed");
+
+ declare
+ use type IC.unsigned;
+ use type IC.int;
+
+ A : IC.int := 123123;
+ B : IC.int := 6;
+ C : IC.int := 0;
+ Params : Kernel_Param_Type;
+ Dev_A : aliased cuda_h.CUdeviceptr;
+ Dev_B : aliased cuda_h.CUdeviceptr;
+ Dev_C : aliased cuda_h.CUdeviceptr;
+ CU_Func : cuda_h.CUfunction;
+ CU_Module : cuda_h.CUmodule;
+ Module : CUDA.Compiler.Buffer_Type
+ := CUDA.Compiler.Compile
+ (Source =>
+ "extern ""C"" { __global__ void add_them(int a, int b, int *c) {" &
+ " *c = 10;" &
+ "}}");
+ begin
+ Check_Result (Code => cuda_h.cuModuleLoadData
+ (arg1 => CU_Module'Address,
+ arg2 => Module'Address),
+ Msg => "Could not load module");
+ Check_Result (Code => cuda_h.cuModuleGetFunction
+ (arg1 => CU_Func'Address,
+ arg2 => CU_Module,
+ arg3 => IC.Strings.New_String ("add_them")),
+ Msg => "Could not get function");
+
+ -- Prepare for function call.
+
+ Check_Result (Code => cuda_h.cuMemAlloc_v2
+ (arg1 => Dev_A'Access,
+ arg2 => IC.int'Size / 8),
+ Msg => "Could not allocate memory for a");
+ Check_Result (Code => cuda_h.cuMemcpyHtoD_v2
+ (arg1 => Dev_A,
+ arg2 => A'Address,
+ arg3 => IC.int'Size / 8),
+ Msg => "Unable to copy A");
+
+ Check_Result (Code => cuda_h.cuMemAlloc_v2
+ (arg1 => Dev_B'Access,
+ arg2 => IC.int'size / 8),
+ Msg => "Could not allocate memory for b");
+ Check_Result (Code => cuda_h.cuMemcpyHtoD_v2
+ (arg1 => Dev_B,
+ arg2 => B'Address,
+ arg3 => IC.int'size / 8),
+ Msg => "Unable to copy B");
+
+ Check_Result (Code => cuda_h.cuMemAlloc_v2
+ (arg1 => Dev_C'Access,
+ arg2 => (IC.int'size / 8)),
+ Msg => "Could not allocate memory for c");
+
+ Params (1) := Dev_A'Address;
+ Params (2) := Dev_B'Address;
+ Params (3) := Dev_C'Address;
+
+ -- Call it.
+
+ Check_Result (Code => cuda_h.cuLaunchKernel
+ (arg1 => CU_Func,
+ arg2 => 1,
+ arg3 => 1,
+ arg4 => 1,
+ arg5 => 1,
+ arg6 => 1,
+ arg7 => 1,
+ arg8 => 0,
+ arg9 => cuda_h.CUStream (System.Null_Address),
+ arg10 => Params'Address,
+ arg11 => System.Null_Address),
+ Msg => "Could not launch function");
+
+ Check_Result (Code => cuda_h.cuMemcpyDtoH_v2
+ (arg1 => C'Address,
+ arg2 => Dev_C,
+ arg3 => (IC.int'size / 8)),
+ Msg => "Unable to copy c to host");
+
+ Ada.Text_IO.Put_Line ("C is" & C'Img);
+ end;
+
+ Check_Result (Code => cuda_h.cuCtxDestroy_v2 (arg1 => Ctx),
+ Msg => "Context destroy failed");
+end Add;
--- /dev/null
+with Ada.Directories;
+with Ada.Direct_IO;
+
+with System.OS_Lib;
+
+package body CUDA.Compiler is
+
+ package C renames Interfaces.C;
+
+ package D_IO is new Ada.Direct_IO (Element_Type => C.char);
+
+ Nvcc : constant String :=
+ "/usr/local/cuda/bin/nvcc";
+
+ Cache_Dir : constant String := "./cache";
+
+ -------------------------------------------------------------------------
+
+ function Compile (Source : String) return Buffer_Type
+ is
+ Source_Path : constant String := Cache_Dir & "/kernel.cu";
+ Kernel_Path : constant String := Cache_Dir & "/kernel.cubin";
+ File : D_IO.File_Type;
+ begin
+ if not Ada.Directories.Exists (Name => Cache_Dir) then
+ Ada.Directories.Create_Directory (New_Directory => Cache_Dir);
+ end if;
+
+ D_IO.Create (File => File,
+ Mode => D_IO.Out_File,
+ Name => Source_Path);
+
+ for I in Source'Range loop
+ D_IO.Write (File => File,
+ Item => C.char (Source (I)));
+ end loop;
+
+ D_IO.Close (File => File);
+
+ declare
+ Args : System.OS_Lib.Argument_List (1 .. 4);
+ Res : Boolean;
+ begin
+ Args (1) := new String'("-cubin");
+ Args (2) := new String'(Source_Path);
+ Args (3) := new String'("-o");
+ Args (4) := new String'(Kernel_Path);
+ System.OS_Lib.Spawn (Program_Name => Nvcc,
+ Args => Args,
+ Success => Res);
+
+ if not Res then
+ raise Program_Error with "Error calling nvcc";
+ end if;
+ end;
+
+ D_IO.Open (File => File,
+ Mode => D_IO.In_File,
+ Name => Kernel_Path);
+
+ declare
+ Result : Buffer_Type (1 .. Positive (D_IO.Size (File => File)));
+ begin
+ for I in Result'Range loop
+ D_IO.Read (File => File,
+ Item => Result (I));
+ end loop;
+
+ D_IO.Close (File => File);
+ return Result;
+ end;
+ end Compile;
+
+ -------------------------------------------------------------------------
+
+ procedure Load
+ is
+ begin
+ null;
+ end Load;
+
+end CUDA.Compiler;
--- /dev/null
+with Interfaces.C;
+
+package CUDA.Compiler is
+
+ type Buffer_Type is array (Positive range <>) of aliased Interfaces.C.char;
+
+ function Compile (Source : String) return Buffer_Type;
+ -- Compile given CUDA code to cubin. Return result in buffer.
+
+ procedure Load;
+ -- Load previously compiled code to GPU.
+
+end CUDA.Compiler;
--- /dev/null
+package CUDA is
+end CUDA;
--- /dev/null
+with Ada.Text_IO;
+
+with Interfaces.C;
+
+with cuda_runtime_api_h;
+with driver_types_h;
+
+procedure Enum_Devices
+is
+ pragma Linker_Options ("-lcudart");
+
+ package C renames Interfaces.C;
+
+ use type C.unsigned;
+
+ Devices : aliased C.int;
+ Res : driver_types_h.cudaError_t;
+begin
+ Res := cuda_runtime_api_h.cudaGetDeviceCount (arg1 => Devices'Access);
+
+ if Res /= driver_types_h.cudaSuccess then
+ Ada.Text_IO.Put_Line ("Error getting device count:" & Res'Img);
+ return;
+ end if;
+
+ Ada.Text_IO.Put_Line ("Found" & Devices'Img & " CUDA aware device(s):");
+
+ declare
+ Curr_Dev : aliased C.int;
+ Props : aliased driver_types_h.cudaDeviceProp;
+ begin
+ Res := cuda_runtime_api_h.cudaGetDevice (arg1 => Curr_Dev'Access);
+
+ if Res /= driver_types_h.cudaSuccess then
+ Ada.Text_IO.Put_Line ("Unable to get device:" & Res'Img);
+ return;
+ end if;
+
+ Res := cuda_runtime_api_h.cudaGetDeviceProperties
+ (arg1 => Props'Access,
+ arg2 => Curr_Dev);
+
+ if Res /= driver_types_h.cudaSuccess then
+ Ada.Text_IO.Put_Line ("Error getting device props:" & Res'Img);
+ return;
+ end if;
+
+ Ada.Text_IO.Put_Line ("Name : " & C.To_Ada (Props.name));
+ Ada.Text_IO.Put_Line ("Global mem :" & Props.totalGlobalMem'Img);
+ Ada.Text_IO.Put_Line ("Clock rate :" & Props.clockRate'Img);
+ end;
+
+end Enum_Devices;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+with stddef_h;
+with System;
+
+package alloca_h is
+
+ -- arg-macro: procedure alloca (size)
+ -- __builtin_alloca (size)
+ function alloca (arg1 : stddef_h.size_t) return System.Address; -- /usr/include/alloca.h:33
+ pragma Import (C, alloca, "alloca");
+
+end alloca_h;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+with Interfaces.C.Extensions;
+with System;
+
+package bits_pthreadtypes_h is
+
+ subtype pthread_t is unsigned_long; -- /usr/include/bits/pthreadtypes.h:50
+
+ subtype pthread_attr_t_uu_size_array is Interfaces.C.char_array (0 .. 35);
+ type pthread_attr_t (discr : unsigned := 0) is record
+ case discr is
+ when 0 =>
+ uu_size : aliased pthread_attr_t_uu_size_array; -- /usr/include/bits/pthreadtypes.h:55
+ when others =>
+ uu_align : aliased long; -- /usr/include/bits/pthreadtypes.h:56
+ end case;
+ end record;
+ pragma Convention (C_Pass_By_Copy, pthread_attr_t);
+ pragma Unchecked_Union (pthread_attr_t); -- /usr/include/bits/pthreadtypes.h:57
+
+ type uu_pthread_internal_slist is record
+ uu_next : access uu_pthread_internal_slist; -- /usr/include/bits/pthreadtypes.h:69
+ end record;
+ pragma Convention (C_Pass_By_Copy, uu_pthread_internal_slist); -- /usr/include/bits/pthreadtypes.h:67
+
+ subtype uu_pthread_slist_t is uu_pthread_internal_slist;
+
+ type anon_792 (discr : unsigned := 0) is record
+ case discr is
+ when 0 =>
+ uu_spins : aliased int; -- /usr/include/bits/pthreadtypes.h:97
+ when others =>
+ uu_list : aliased uu_pthread_slist_t; -- /usr/include/bits/pthreadtypes.h:98
+ end case;
+ end record;
+ pragma Convention (C_Pass_By_Copy, anon_792);
+ pragma Unchecked_Union (anon_792); -- /usr/include/bits/pthreadtypes.h:95
+
+ type anon791_anon792_union (discr : unsigned := 0) is record
+ case discr is
+ when 0 =>
+ uu_spins : aliased int; -- /usr/include/bits/pthreadtypes.h:97
+ when others =>
+ uu_list : aliased uu_pthread_slist_t; -- /usr/include/bits/pthreadtypes.h:98
+ end case;
+ end record;
+ pragma Convention (C_Pass_By_Copy, anon791_anon792_union);
+ pragma Unchecked_Union (anon791_anon792_union);
+ type uu_pthread_mutex_s is record
+ uu_lock : aliased int; -- /usr/include/bits/pthreadtypes.h:80
+ uu_count : aliased unsigned; -- /usr/include/bits/pthreadtypes.h:81
+ uu_owner : aliased int; -- /usr/include/bits/pthreadtypes.h:82
+ uu_kind : aliased int; -- /usr/include/bits/pthreadtypes.h:88
+ uu_nusers : aliased unsigned; -- /usr/include/bits/pthreadtypes.h:94
+ anon1441 : anon791_anon792_union; -- /usr/include/bits/pthreadtypes.h:99
+ end record;
+ pragma Convention (C_Pass_By_Copy, uu_pthread_mutex_s); -- /usr/include/bits/pthreadtypes.h:78
+
+ subtype anon790_anon794_array is Interfaces.C.char_array (0 .. 23);
+ type anon_790 (discr : unsigned := 0) is record
+ case discr is
+ when 0 =>
+ uu_data : aliased uu_pthread_mutex_s; -- /usr/include/bits/pthreadtypes.h:101
+ when 1 =>
+ uu_size : aliased anon790_anon794_array; -- /usr/include/bits/pthreadtypes.h:102
+ when others =>
+ uu_align : aliased long; -- /usr/include/bits/pthreadtypes.h:103
+ end case;
+ end record;
+ pragma Convention (C_Pass_By_Copy, anon_790);
+ pragma Unchecked_Union (anon_790); -- /usr/include/bits/pthreadtypes.h:76
+
+ subtype pthread_mutex_t_uu_size_array is Interfaces.C.char_array (0 .. 23);
+ type pthread_mutex_t (discr : unsigned := 0) is record
+ case discr is
+ when 0 =>
+ uu_data : aliased uu_pthread_mutex_s; -- /usr/include/bits/pthreadtypes.h:101
+ when 1 =>
+ uu_size : aliased pthread_mutex_t_uu_size_array; -- /usr/include/bits/pthreadtypes.h:102
+ when others =>
+ uu_align : aliased long; -- /usr/include/bits/pthreadtypes.h:103
+ end case;
+ end record;
+ pragma Convention (C_Pass_By_Copy, pthread_mutex_t);
+ pragma Unchecked_Union (pthread_mutex_t); -- /usr/include/bits/pthreadtypes.h:104
+
+ subtype pthread_mutexattr_t_uu_size_array is Interfaces.C.char_array (0 .. 3);
+ type pthread_mutexattr_t (discr : unsigned := 0) is record
+ case discr is
+ when 0 =>
+ uu_size : aliased pthread_mutexattr_t_uu_size_array; -- /usr/include/bits/pthreadtypes.h:108
+ when others =>
+ uu_align : aliased int; -- /usr/include/bits/pthreadtypes.h:109
+ end case;
+ end record;
+ pragma Convention (C_Pass_By_Copy, pthread_mutexattr_t);
+ pragma Unchecked_Union (pthread_mutexattr_t); -- /usr/include/bits/pthreadtypes.h:110
+
+ type anon_801 is record
+ uu_lock : aliased int; -- /usr/include/bits/pthreadtypes.h:119
+ uu_futex : aliased unsigned; -- /usr/include/bits/pthreadtypes.h:120
+ uu_total_seq : aliased Extensions.unsigned_long_long; -- /usr/include/bits/pthreadtypes.h:121
+ uu_wakeup_seq : aliased Extensions.unsigned_long_long; -- /usr/include/bits/pthreadtypes.h:122
+ uu_woken_seq : aliased Extensions.unsigned_long_long; -- /usr/include/bits/pthreadtypes.h:123
+ uu_mutex : System.Address; -- /usr/include/bits/pthreadtypes.h:124
+ uu_nwaiters : aliased unsigned; -- /usr/include/bits/pthreadtypes.h:125
+ uu_broadcast_seq : aliased unsigned; -- /usr/include/bits/pthreadtypes.h:126
+ end record;
+ pragma Convention (C_Pass_By_Copy, anon_801); -- /usr/include/bits/pthreadtypes.h:117
+
+ type pthread_cond_t;
+ type pthread_cond_t_uu_data_struct is record
+ uu_lock : aliased int; -- /usr/include/bits/pthreadtypes.h:119
+ uu_futex : aliased unsigned; -- /usr/include/bits/pthreadtypes.h:120
+ uu_total_seq : aliased Extensions.unsigned_long_long; -- /usr/include/bits/pthreadtypes.h:121
+ uu_wakeup_seq : aliased Extensions.unsigned_long_long; -- /usr/include/bits/pthreadtypes.h:122
+ uu_woken_seq : aliased Extensions.unsigned_long_long; -- /usr/include/bits/pthreadtypes.h:123
+ uu_mutex : System.Address; -- /usr/include/bits/pthreadtypes.h:124
+ uu_nwaiters : aliased unsigned; -- /usr/include/bits/pthreadtypes.h:125
+ uu_broadcast_seq : aliased unsigned; -- /usr/include/bits/pthreadtypes.h:126
+ end record;
+ pragma Convention (C_Pass_By_Copy, pthread_cond_t_uu_data_struct);
+ subtype pthread_cond_t_uu_size_array is Interfaces.C.char_array (0 .. 47);
+ type pthread_cond_t (discr : unsigned := 0) is record
+ case discr is
+ when 0 =>
+ uu_data : aliased anon_801; -- /usr/include/bits/pthreadtypes.h:127
+ when 1 =>
+ uu_size : aliased pthread_cond_t_uu_size_array; -- /usr/include/bits/pthreadtypes.h:128
+ when others =>
+ uu_align : aliased Long_Long_Integer; -- /usr/include/bits/pthreadtypes.h:129
+ end case;
+ end record;
+ pragma Convention (C_Pass_By_Copy, pthread_cond_t);
+ pragma Unchecked_Union (pthread_cond_t); -- /usr/include/bits/pthreadtypes.h:130
+
+ subtype pthread_condattr_t_uu_size_array is Interfaces.C.char_array (0 .. 3);
+ type pthread_condattr_t (discr : unsigned := 0) is record
+ case discr is
+ when 0 =>
+ uu_size : aliased pthread_condattr_t_uu_size_array; -- /usr/include/bits/pthreadtypes.h:134
+ when others =>
+ uu_align : aliased int; -- /usr/include/bits/pthreadtypes.h:135
+ end case;
+ end record;
+ pragma Convention (C_Pass_By_Copy, pthread_condattr_t);
+ pragma Unchecked_Union (pthread_condattr_t); -- /usr/include/bits/pthreadtypes.h:136
+
+ subtype pthread_key_t is unsigned; -- /usr/include/bits/pthreadtypes.h:140
+
+ subtype pthread_once_t is int; -- /usr/include/bits/pthreadtypes.h:144
+
+ type anon_812 is record
+ uu_lock : aliased int; -- /usr/include/bits/pthreadtypes.h:172
+ uu_nr_readers : aliased unsigned; -- /usr/include/bits/pthreadtypes.h:173
+ uu_readers_wakeup : aliased unsigned; -- /usr/include/bits/pthreadtypes.h:174
+ uu_writer_wakeup : aliased unsigned; -- /usr/include/bits/pthreadtypes.h:175
+ uu_nr_readers_queued : aliased unsigned; -- /usr/include/bits/pthreadtypes.h:176
+ uu_nr_writers_queued : aliased unsigned; -- /usr/include/bits/pthreadtypes.h:177
+ uu_flags : aliased unsigned_char; -- /usr/include/bits/pthreadtypes.h:180
+ uu_shared : aliased unsigned_char; -- /usr/include/bits/pthreadtypes.h:181
+ uu_pad1 : aliased unsigned_char; -- /usr/include/bits/pthreadtypes.h:182
+ uu_pad2 : aliased unsigned_char; -- /usr/include/bits/pthreadtypes.h:183
+ uu_writer : aliased int; -- /usr/include/bits/pthreadtypes.h:184
+ end record;
+ pragma Convention (C_Pass_By_Copy, anon_812); -- /usr/include/bits/pthreadtypes.h:170
+
+ type pthread_rwlock_t;
+ type pthread_rwlock_t_uu_data_struct is record
+ uu_lock : aliased int; -- /usr/include/bits/pthreadtypes.h:172
+ uu_nr_readers : aliased unsigned; -- /usr/include/bits/pthreadtypes.h:173
+ uu_readers_wakeup : aliased unsigned; -- /usr/include/bits/pthreadtypes.h:174
+ uu_writer_wakeup : aliased unsigned; -- /usr/include/bits/pthreadtypes.h:175
+ uu_nr_readers_queued : aliased unsigned; -- /usr/include/bits/pthreadtypes.h:176
+ uu_nr_writers_queued : aliased unsigned; -- /usr/include/bits/pthreadtypes.h:177
+ uu_flags : aliased unsigned_char; -- /usr/include/bits/pthreadtypes.h:180
+ uu_shared : aliased unsigned_char; -- /usr/include/bits/pthreadtypes.h:181
+ uu_pad1 : aliased unsigned_char; -- /usr/include/bits/pthreadtypes.h:182
+ uu_pad2 : aliased unsigned_char; -- /usr/include/bits/pthreadtypes.h:183
+ uu_writer : aliased int; -- /usr/include/bits/pthreadtypes.h:184
+ end record;
+ pragma Convention (C_Pass_By_Copy, pthread_rwlock_t_uu_data_struct);
+ subtype pthread_rwlock_t_uu_size_array is Interfaces.C.char_array (0 .. 31);
+ type pthread_rwlock_t (discr : unsigned := 0) is record
+ case discr is
+ when 0 =>
+ uu_data : aliased anon_812; -- /usr/include/bits/pthreadtypes.h:185
+ when 1 =>
+ uu_size : aliased pthread_rwlock_t_uu_size_array; -- /usr/include/bits/pthreadtypes.h:187
+ when others =>
+ uu_align : aliased long; -- /usr/include/bits/pthreadtypes.h:188
+ end case;
+ end record;
+ pragma Convention (C_Pass_By_Copy, pthread_rwlock_t);
+ pragma Unchecked_Union (pthread_rwlock_t); -- /usr/include/bits/pthreadtypes.h:189
+
+ subtype pthread_rwlockattr_t_uu_size_array is Interfaces.C.char_array (0 .. 7);
+ type pthread_rwlockattr_t (discr : unsigned := 0) is record
+ case discr is
+ when 0 =>
+ uu_size : aliased pthread_rwlockattr_t_uu_size_array; -- /usr/include/bits/pthreadtypes.h:193
+ when others =>
+ uu_align : aliased long; -- /usr/include/bits/pthreadtypes.h:194
+ end case;
+ end record;
+ pragma Convention (C_Pass_By_Copy, pthread_rwlockattr_t);
+ pragma Unchecked_Union (pthread_rwlockattr_t); -- /usr/include/bits/pthreadtypes.h:195
+
+ subtype pthread_spinlock_t is int; -- /usr/include/bits/pthreadtypes.h:201
+
+ subtype pthread_barrier_t_uu_size_array is Interfaces.C.char_array (0 .. 19);
+ type pthread_barrier_t (discr : unsigned := 0) is record
+ case discr is
+ when 0 =>
+ uu_size : aliased pthread_barrier_t_uu_size_array; -- /usr/include/bits/pthreadtypes.h:208
+ when others =>
+ uu_align : aliased long; -- /usr/include/bits/pthreadtypes.h:209
+ end case;
+ end record;
+ pragma Convention (C_Pass_By_Copy, pthread_barrier_t);
+ pragma Unchecked_Union (pthread_barrier_t); -- /usr/include/bits/pthreadtypes.h:210
+
+ subtype pthread_barrierattr_t_uu_size_array is Interfaces.C.char_array (0 .. 3);
+ type pthread_barrierattr_t (discr : unsigned := 0) is record
+ case discr is
+ when 0 =>
+ uu_size : aliased pthread_barrierattr_t_uu_size_array; -- /usr/include/bits/pthreadtypes.h:214
+ when others =>
+ uu_align : aliased int; -- /usr/include/bits/pthreadtypes.h:215
+ end case;
+ end record;
+ pragma Convention (C_Pass_By_Copy, pthread_barrierattr_t);
+ pragma Unchecked_Union (pthread_barrierattr_t); -- /usr/include/bits/pthreadtypes.h:216
+
+end bits_pthreadtypes_h;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+
+package bits_sigset_h is
+
+ subtype uu_sig_atomic_t is int; -- /usr/include/bits/sigset.h:24
+
+ type uu_sigset_t_uu_val_array is array (0 .. 31) of aliased unsigned_long;
+ type uu_sigset_t is record
+ uu_val : aliased uu_sigset_t_uu_val_array; -- /usr/include/bits/sigset.h:31
+ end record;
+ pragma Convention (C_Pass_By_Copy, uu_sigset_t); -- /usr/include/bits/sigset.h:32
+
+end bits_sigset_h;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+with bits_types_h;
+
+package bits_time_h is
+
+ type timeval is record
+ tv_sec : aliased bits_types_h.uu_time_t; -- /usr/include/bits/time.h:77
+ tv_usec : aliased bits_types_h.uu_suseconds_t; -- /usr/include/bits/time.h:78
+ end record;
+ pragma Convention (C_Pass_By_Copy, timeval); -- /usr/include/bits/time.h:75
+
+end bits_time_h;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+with Interfaces.C.Extensions;
+with System;
+with Interfaces.C.Strings;
+
+package bits_types_h is
+
+ subtype uu_u_char is unsigned_char; -- /usr/include/bits/types.h:31
+
+ subtype uu_u_short is unsigned_short; -- /usr/include/bits/types.h:32
+
+ subtype uu_u_int is unsigned; -- /usr/include/bits/types.h:33
+
+ subtype uu_u_long is unsigned_long; -- /usr/include/bits/types.h:34
+
+ subtype uu_int8_t is signed_char; -- /usr/include/bits/types.h:37
+
+ subtype uu_uint8_t is unsigned_char; -- /usr/include/bits/types.h:38
+
+ subtype uu_int16_t is short; -- /usr/include/bits/types.h:39
+
+ subtype uu_uint16_t is unsigned_short; -- /usr/include/bits/types.h:40
+
+ subtype uu_int32_t is int; -- /usr/include/bits/types.h:41
+
+ subtype uu_uint32_t is unsigned; -- /usr/include/bits/types.h:42
+
+ subtype uu_int64_t is Long_Long_Integer; -- /usr/include/bits/types.h:47
+
+ subtype uu_uint64_t is Extensions.unsigned_long_long; -- /usr/include/bits/types.h:48
+
+ subtype uu_quad_t is Long_Long_Integer; -- /usr/include/bits/types.h:56
+
+ subtype uu_u_quad_t is Extensions.unsigned_long_long; -- /usr/include/bits/types.h:57
+
+ subtype uu_dev_t is uu_u_quad_t; -- /usr/include/bits/types.h:134
+
+ subtype uu_uid_t is unsigned; -- /usr/include/bits/types.h:135
+
+ subtype uu_gid_t is unsigned; -- /usr/include/bits/types.h:136
+
+ subtype uu_ino_t is unsigned_long; -- /usr/include/bits/types.h:137
+
+ subtype uu_ino64_t is uu_u_quad_t; -- /usr/include/bits/types.h:138
+
+ subtype uu_mode_t is unsigned; -- /usr/include/bits/types.h:139
+
+ subtype uu_nlink_t is unsigned; -- /usr/include/bits/types.h:140
+
+ subtype uu_off_t is long; -- /usr/include/bits/types.h:141
+
+ subtype uu_off64_t is uu_quad_t; -- /usr/include/bits/types.h:142
+
+ subtype uu_pid_t is int; -- /usr/include/bits/types.h:143
+
+ type uu_fsid_t_uu_val_array is array (0 .. 1) of aliased int;
+ type uu_fsid_t is record
+ uu_val : aliased uu_fsid_t_uu_val_array; -- /usr/include/bits/types.h:144
+ end record;
+ pragma Convention (C_Pass_By_Copy, uu_fsid_t); -- /usr/include/bits/types.h:144
+
+ subtype uu_clock_t is long; -- /usr/include/bits/types.h:145
+
+ subtype uu_rlim_t is unsigned_long; -- /usr/include/bits/types.h:146
+
+ subtype uu_rlim64_t is uu_u_quad_t; -- /usr/include/bits/types.h:147
+
+ subtype uu_id_t is unsigned; -- /usr/include/bits/types.h:148
+
+ subtype uu_time_t is long; -- /usr/include/bits/types.h:149
+
+ subtype uu_useconds_t is unsigned; -- /usr/include/bits/types.h:150
+
+ subtype uu_suseconds_t is long; -- /usr/include/bits/types.h:151
+
+ subtype uu_daddr_t is int; -- /usr/include/bits/types.h:153
+
+ subtype uu_swblk_t is long; -- /usr/include/bits/types.h:154
+
+ subtype uu_key_t is int; -- /usr/include/bits/types.h:155
+
+ subtype uu_clockid_t is int; -- /usr/include/bits/types.h:158
+
+ type uu_timer_t is new System.Address; -- /usr/include/bits/types.h:161
+
+ subtype uu_blksize_t is long; -- /usr/include/bits/types.h:164
+
+ subtype uu_blkcnt_t is long; -- /usr/include/bits/types.h:169
+
+ subtype uu_blkcnt64_t is uu_quad_t; -- /usr/include/bits/types.h:170
+
+ subtype uu_fsblkcnt_t is unsigned_long; -- /usr/include/bits/types.h:173
+
+ subtype uu_fsblkcnt64_t is uu_u_quad_t; -- /usr/include/bits/types.h:174
+
+ subtype uu_fsfilcnt_t is unsigned_long; -- /usr/include/bits/types.h:177
+
+ subtype uu_fsfilcnt64_t is uu_u_quad_t; -- /usr/include/bits/types.h:178
+
+ subtype uu_ssize_t is int; -- /usr/include/bits/types.h:180
+
+ subtype uu_loff_t is uu_off64_t; -- /usr/include/bits/types.h:184
+
+ type uu_qaddr_t is access all uu_quad_t; -- /usr/include/bits/types.h:185
+
+ type uu_caddr_t is new Interfaces.C.Strings.chars_ptr; -- /usr/include/bits/types.h:186
+
+ subtype uu_intptr_t is int; -- /usr/include/bits/types.h:189
+
+ subtype uu_socklen_t is unsigned; -- /usr/include/bits/types.h:192
+
+end bits_types_h;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+with Interfaces.C.Extensions;
+
+package bits_waitstatus_h is
+
+ -- unsupported macro: w_termsig __wait_terminated.__w_termsig
+ -- unsupported macro: w_coredump __wait_terminated.__w_coredump
+ -- unsupported macro: w_retcode __wait_terminated.__w_retcode
+ -- unsupported macro: w_stopsig __wait_stopped.__w_stopsig
+ -- unsupported macro: w_stopval __wait_stopped.__w_stopval
+ type anon_598 is record
+ uu_w_termsig : Extensions.Unsigned_7; -- /usr/include/bits/waitstatus.h:73
+ uu_w_coredump : Extensions.Unsigned_1; -- /usr/include/bits/waitstatus.h:74
+ uu_w_retcode : aliased unsigned_char; -- /usr/include/bits/waitstatus.h:75
+ field_4 : unsigned_short;
+ end record;
+ pragma Convention (C_Pass_By_Copy, anon_598);
+ pragma Pack (anon_598); -- /usr/include/bits/waitstatus.h:70
+
+ type anon_601 is record
+ uu_w_stopval : aliased unsigned_char; -- /usr/include/bits/waitstatus.h:88
+ uu_w_stopsig : aliased unsigned_char; -- /usr/include/bits/waitstatus.h:89
+ field_3 : unsigned_short;
+ end record;
+ pragma Convention (C_Pass_By_Copy, anon_601); -- /usr/include/bits/waitstatus.h:85
+
+ type wait;
+ type anon597_anon598_struct is record
+ uu_w_termsig : Extensions.Unsigned_7; -- /usr/include/bits/waitstatus.h:73
+ uu_w_coredump : Extensions.Unsigned_1; -- /usr/include/bits/waitstatus.h:74
+ uu_w_retcode : aliased unsigned_char; -- /usr/include/bits/waitstatus.h:75
+ field_4 : unsigned_short;
+ end record;
+ pragma Convention (C_Pass_By_Copy, anon597_anon598_struct);
+ type anon597_anon601_struct is record
+ uu_w_stopval : aliased unsigned_char; -- /usr/include/bits/waitstatus.h:88
+ uu_w_stopsig : aliased unsigned_char; -- /usr/include/bits/waitstatus.h:89
+ field_3 : unsigned_short;
+ end record;
+ pragma Convention (C_Pass_By_Copy, anon597_anon601_struct);
+ type wait (discr : unsigned := 0) is record
+ case discr is
+ when 0 =>
+ w_status : aliased int; -- /usr/include/bits/waitstatus.h:69
+ when 1 =>
+ uu_wait_terminated : aliased anon_598; -- /usr/include/bits/waitstatus.h:84
+ when others =>
+ uu_wait_stopped : aliased anon_601; -- /usr/include/bits/waitstatus.h:97
+ end case;
+ end record;
+ pragma Convention (C_Pass_By_Copy, wait);
+ pragma Unchecked_Union (wait); -- /usr/include/bits/waitstatus.h:67
+
+end bits_waitstatus_h;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+with System;
+with stddef_h;
+with Interfaces.C.Strings;
+
+package cuda_h is
+
+ -- unsupported macro: cuDeviceTotalMem cuDeviceTotalMem_v2
+ -- unsupported macro: cuCtxCreate cuCtxCreate_v2
+ -- unsupported macro: cuModuleGetGlobal cuModuleGetGlobal_v2
+ -- unsupported macro: cuMemGetInfo cuMemGetInfo_v2
+ -- unsupported macro: cuMemAlloc cuMemAlloc_v2
+ -- unsupported macro: cuMemAllocPitch cuMemAllocPitch_v2
+ -- unsupported macro: cuMemFree cuMemFree_v2
+ -- unsupported macro: cuMemGetAddressRange cuMemGetAddressRange_v2
+ -- unsupported macro: cuMemAllocHost cuMemAllocHost_v2
+ -- unsupported macro: cuMemHostGetDevicePointer cuMemHostGetDevicePointer_v2
+ -- unsupported macro: cuMemcpyHtoD cuMemcpyHtoD_v2
+ -- unsupported macro: cuMemcpyDtoH cuMemcpyDtoH_v2
+ -- unsupported macro: cuMemcpyDtoD cuMemcpyDtoD_v2
+ -- unsupported macro: cuMemcpyDtoA cuMemcpyDtoA_v2
+ -- unsupported macro: cuMemcpyAtoD cuMemcpyAtoD_v2
+ -- unsupported macro: cuMemcpyHtoA cuMemcpyHtoA_v2
+ -- unsupported macro: cuMemcpyAtoH cuMemcpyAtoH_v2
+ -- unsupported macro: cuMemcpyAtoA cuMemcpyAtoA_v2
+ -- unsupported macro: cuMemcpyHtoAAsync cuMemcpyHtoAAsync_v2
+ -- unsupported macro: cuMemcpyAtoHAsync cuMemcpyAtoHAsync_v2
+ -- unsupported macro: cuMemcpy2D cuMemcpy2D_v2
+ -- unsupported macro: cuMemcpy2DUnaligned cuMemcpy2DUnaligned_v2
+ -- unsupported macro: cuMemcpy3D cuMemcpy3D_v2
+ -- unsupported macro: cuMemcpyHtoDAsync cuMemcpyHtoDAsync_v2
+ -- unsupported macro: cuMemcpyDtoHAsync cuMemcpyDtoHAsync_v2
+ -- unsupported macro: cuMemcpyDtoDAsync cuMemcpyDtoDAsync_v2
+ -- unsupported macro: cuMemcpy2DAsync cuMemcpy2DAsync_v2
+ -- unsupported macro: cuMemcpy3DAsync cuMemcpy3DAsync_v2
+ -- unsupported macro: cuMemsetD8 cuMemsetD8_v2
+ -- unsupported macro: cuMemsetD16 cuMemsetD16_v2
+ -- unsupported macro: cuMemsetD32 cuMemsetD32_v2
+ -- unsupported macro: cuMemsetD2D8 cuMemsetD2D8_v2
+ -- unsupported macro: cuMemsetD2D16 cuMemsetD2D16_v2
+ -- unsupported macro: cuMemsetD2D32 cuMemsetD2D32_v2
+ -- unsupported macro: cuArrayCreate cuArrayCreate_v2
+ -- unsupported macro: cuArrayGetDescriptor cuArrayGetDescriptor_v2
+ -- unsupported macro: cuArray3DCreate cuArray3DCreate_v2
+ -- unsupported macro: cuArray3DGetDescriptor cuArray3DGetDescriptor_v2
+ -- unsupported macro: cuTexRefSetAddress cuTexRefSetAddress_v2
+ -- unsupported macro: cuTexRefSetAddress2D cuTexRefSetAddress2D_v2
+ -- unsupported macro: cuTexRefGetAddress cuTexRefGetAddress_v2
+ -- unsupported macro: cuGraphicsResourceGetMappedPointer cuGraphicsResourceGetMappedPointer_v2
+ -- unsupported macro: cuCtxDestroy cuCtxDestroy_v2
+ -- unsupported macro: cuCtxPopCurrent cuCtxPopCurrent_v2
+ -- unsupported macro: cuCtxPushCurrent cuCtxPushCurrent_v2
+ -- unsupported macro: cuStreamDestroy cuStreamDestroy_v2
+ -- unsupported macro: cuEventDestroy cuEventDestroy_v2
+
+ CUDA_VERSION : constant := 4000; -- cuda.h:137
+
+ CU_MEMHOSTALLOC_PORTABLE : constant := 16#01#; -- cuda.h:834
+
+ CU_MEMHOSTALLOC_DEVICEMAP : constant := 16#02#; -- cuda.h:841
+
+ CU_MEMHOSTALLOC_WRITECOMBINED : constant := 16#04#; -- cuda.h:849
+
+ CU_MEMHOSTREGISTER_PORTABLE : constant := 16#01#; -- cuda.h:855
+
+ CU_MEMHOSTREGISTER_DEVICEMAP : constant := 16#02#; -- cuda.h:862
+
+ CUDA_ARRAY3D_LAYERED : constant := 16#01#; -- cuda.h:991
+
+ CUDA_ARRAY3D_2DARRAY : constant := 16#01#; -- cuda.h:996
+
+ CUDA_ARRAY3D_SURFACE_LDST : constant := 16#02#; -- cuda.h:1002
+
+ CU_TRSA_OVERRIDE_FORMAT : constant := 16#01#; -- cuda.h:1008
+
+ CU_TRSF_READ_AS_INTEGER : constant := 16#01#; -- cuda.h:1015
+
+ CU_TRSF_NORMALIZED_COORDINATES : constant := 16#02#; -- cuda.h:1021
+
+ CU_TRSF_SRGB : constant := 16#10#; -- cuda.h:1027
+ -- unsupported macro: CU_LAUNCH_PARAM_END ((void*)0x00)
+ -- unsupported macro: CU_LAUNCH_PARAM_BUFFER_POINTER ((void*)0x01)
+ -- unsupported macro: CU_LAUNCH_PARAM_BUFFER_SIZE ((void*)0x02)
+
+ CU_PARAM_TR_DEFAULT : constant := -1; -- cuda.h:1060
+
+ subtype CUdeviceptr is unsigned; -- cuda.h:151
+
+ subtype CUdevice is int; -- cuda.h:156
+
+ -- skipped empty struct CUctx_st
+
+ type CUcontext is new System.Address; -- cuda.h:157
+
+ -- skipped empty struct CUmod_st
+
+ type CUmodule is new System.Address; -- cuda.h:158
+
+ -- skipped empty struct CUfunc_st
+
+ type CUfunction is new System.Address; -- cuda.h:159
+
+ -- skipped empty struct CUarray_st
+
+ type CUarray is new System.Address; -- cuda.h:160
+
+ -- skipped empty struct CUtexref_st
+
+ type CUtexref is new System.Address; -- cuda.h:161
+
+ -- skipped empty struct CUsurfref_st
+
+ type CUsurfref is new System.Address; -- cuda.h:162
+
+ -- skipped empty struct CUevent_st
+
+ type CUevent is new System.Address; -- cuda.h:163
+
+ -- skipped empty struct CUstream_st
+
+ type CUstream is new System.Address; -- cuda.h:164
+
+ -- skipped empty struct CUgraphicsResource_st
+
+ type CUgraphicsResource is new System.Address; -- cuda.h:165
+
+ subtype anon1074_anon1076_array is Interfaces.C.char_array (0 .. 15);
+ type CUuuid_st is record
+ bytes : aliased anon1074_anon1076_array; -- cuda.h:168
+ end record;
+ pragma Convention (C_Pass_By_Copy, CUuuid_st); -- cuda.h:167
+
+ subtype CUuuid is CUuuid_st;
+
+ subtype CUctx_flags_enum is unsigned;
+ CU_CTX_SCHED_AUTO : constant CUctx_flags_enum := 0;
+ CU_CTX_SCHED_SPIN : constant CUctx_flags_enum := 1;
+ CU_CTX_SCHED_YIELD : constant CUctx_flags_enum := 2;
+ CU_CTX_SCHED_BLOCKING_SYNC : constant CUctx_flags_enum := 4;
+ CU_CTX_BLOCKING_SYNC : constant CUctx_flags_enum := 4;
+ CU_CTX_SCHED_MASK : constant CUctx_flags_enum := 7;
+ CU_CTX_MAP_HOST : constant CUctx_flags_enum := 8;
+ CU_CTX_LMEM_RESIZE_TO_MAX : constant CUctx_flags_enum := 16;
+ CU_CTX_FLAGS_MASK : constant CUctx_flags_enum := 31; -- cuda.h:174
+
+ subtype CUctx_flags is CUctx_flags_enum;
+
+ type CUevent_flags_enum is
+ (CU_EVENT_DEFAULT,
+ CU_EVENT_BLOCKING_SYNC,
+ CU_EVENT_DISABLE_TIMING);
+ pragma Convention (C, CUevent_flags_enum); -- cuda.h:189
+
+ subtype CUevent_flags is CUevent_flags_enum;
+
+ subtype CUarray_format_enum is unsigned;
+ CU_AD_FORMAT_UNSIGNED_INT8 : constant CUarray_format_enum := 1;
+ CU_AD_FORMAT_UNSIGNED_INT16 : constant CUarray_format_enum := 2;
+ CU_AD_FORMAT_UNSIGNED_INT32 : constant CUarray_format_enum := 3;
+ CU_AD_FORMAT_SIGNED_INT8 : constant CUarray_format_enum := 8;
+ CU_AD_FORMAT_SIGNED_INT16 : constant CUarray_format_enum := 9;
+ CU_AD_FORMAT_SIGNED_INT32 : constant CUarray_format_enum := 10;
+ CU_AD_FORMAT_HALF : constant CUarray_format_enum := 16;
+ CU_AD_FORMAT_FLOAT : constant CUarray_format_enum := 32; -- cuda.h:198
+
+ subtype CUarray_format is CUarray_format_enum;
+
+ type CUaddress_mode_enum is
+ (CU_TR_ADDRESS_MODE_WRAP,
+ CU_TR_ADDRESS_MODE_CLAMP,
+ CU_TR_ADDRESS_MODE_MIRROR,
+ CU_TR_ADDRESS_MODE_BORDER);
+ pragma Convention (C, CUaddress_mode_enum); -- cuda.h:212
+
+ subtype CUaddress_mode is CUaddress_mode_enum;
+
+ type CUfilter_mode_enum is
+ (CU_TR_FILTER_MODE_POINT,
+ CU_TR_FILTER_MODE_LINEAR);
+ pragma Convention (C, CUfilter_mode_enum); -- cuda.h:222
+
+ subtype CUfilter_mode is CUfilter_mode_enum;
+
+ subtype CUdevice_attribute_enum is unsigned;
+ CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK : constant CUdevice_attribute_enum := 1;
+ CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X : constant CUdevice_attribute_enum := 2;
+ CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y : constant CUdevice_attribute_enum := 3;
+ CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z : constant CUdevice_attribute_enum := 4;
+ CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X : constant CUdevice_attribute_enum := 5;
+ CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y : constant CUdevice_attribute_enum := 6;
+ CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z : constant CUdevice_attribute_enum := 7;
+ CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK : constant CUdevice_attribute_enum := 8;
+ CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK : constant CUdevice_attribute_enum := 8;
+ CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY : constant CUdevice_attribute_enum := 9;
+ CU_DEVICE_ATTRIBUTE_WARP_SIZE : constant CUdevice_attribute_enum := 10;
+ CU_DEVICE_ATTRIBUTE_MAX_PITCH : constant CUdevice_attribute_enum := 11;
+ CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK : constant CUdevice_attribute_enum := 12;
+ CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK : constant CUdevice_attribute_enum := 12;
+ CU_DEVICE_ATTRIBUTE_CLOCK_RATE : constant CUdevice_attribute_enum := 13;
+ CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT : constant CUdevice_attribute_enum := 14;
+ CU_DEVICE_ATTRIBUTE_GPU_OVERLAP : constant CUdevice_attribute_enum := 15;
+ CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT : constant CUdevice_attribute_enum := 16;
+ CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT : constant CUdevice_attribute_enum := 17;
+ CU_DEVICE_ATTRIBUTE_INTEGRATED : constant CUdevice_attribute_enum := 18;
+ CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY : constant CUdevice_attribute_enum := 19;
+ CU_DEVICE_ATTRIBUTE_COMPUTE_MODE : constant CUdevice_attribute_enum := 20;
+ CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH : constant CUdevice_attribute_enum := 21;
+ CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH : constant CUdevice_attribute_enum := 22;
+ CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT : constant CUdevice_attribute_enum := 23;
+ CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH : constant CUdevice_attribute_enum := 24;
+ CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT : constant CUdevice_attribute_enum := 25;
+ CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH : constant CUdevice_attribute_enum := 26;
+ CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH : constant CUdevice_attribute_enum := 27;
+ CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT : constant CUdevice_attribute_enum := 28;
+ CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS : constant CUdevice_attribute_enum := 29;
+ CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH : constant CUdevice_attribute_enum := 27;
+ CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT : constant CUdevice_attribute_enum := 28;
+ CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES : constant CUdevice_attribute_enum := 29;
+ CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT : constant CUdevice_attribute_enum := 30;
+ CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS : constant CUdevice_attribute_enum := 31;
+ CU_DEVICE_ATTRIBUTE_ECC_ENABLED : constant CUdevice_attribute_enum := 32;
+ CU_DEVICE_ATTRIBUTE_PCI_BUS_ID : constant CUdevice_attribute_enum := 33;
+ CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID : constant CUdevice_attribute_enum := 34;
+ CU_DEVICE_ATTRIBUTE_TCC_DRIVER : constant CUdevice_attribute_enum := 35;
+ CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE : constant CUdevice_attribute_enum := 36;
+ CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH : constant CUdevice_attribute_enum := 37;
+ CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE : constant CUdevice_attribute_enum := 38;
+ CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR : constant CUdevice_attribute_enum := 39;
+ CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT : constant CUdevice_attribute_enum := 40;
+ CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING : constant CUdevice_attribute_enum := 41;
+ CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH : constant CUdevice_attribute_enum := 42;
+ CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS : constant CUdevice_attribute_enum := 43;
+ CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID : constant CUdevice_attribute_enum := 50; -- cuda.h:230
+
+ subtype CUdevice_attribute is CUdevice_attribute_enum;
+
+ type anon1090_anon1092_array is array (0 .. 2) of aliased int;
+ type CUdevprop_st is record
+ maxThreadsPerBlock : aliased int; -- cuda.h:286
+ maxThreadsDim : aliased anon1090_anon1092_array; -- cuda.h:287
+ maxGridSize : aliased anon1090_anon1092_array; -- cuda.h:288
+ sharedMemPerBlock : aliased int; -- cuda.h:289
+ totalConstantMemory : aliased int; -- cuda.h:290
+ SIMDWidth : aliased int; -- cuda.h:291
+ memPitch : aliased int; -- cuda.h:292
+ regsPerBlock : aliased int; -- cuda.h:293
+ clockRate : aliased int; -- cuda.h:294
+ textureAlign : aliased int; -- cuda.h:295
+ end record;
+ pragma Convention (C_Pass_By_Copy, CUdevprop_st); -- cuda.h:285
+
+ subtype CUdevprop is CUdevprop_st;
+
+ subtype CUpointer_attribute_enum is unsigned;
+ CU_POINTER_ATTRIBUTE_CONTEXT : constant CUpointer_attribute_enum := 1;
+ CU_POINTER_ATTRIBUTE_MEMORY_TYPE : constant CUpointer_attribute_enum := 2;
+ CU_POINTER_ATTRIBUTE_DEVICE_POINTER : constant CUpointer_attribute_enum := 3;
+ CU_POINTER_ATTRIBUTE_HOST_POINTER : constant CUpointer_attribute_enum := 4; -- cuda.h:301
+
+ subtype CUpointer_attribute is CUpointer_attribute_enum;
+
+ type CUfunction_attribute_enum is
+ (CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK,
+ CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES,
+ CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES,
+ CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES,
+ CU_FUNC_ATTRIBUTE_NUM_REGS,
+ CU_FUNC_ATTRIBUTE_PTX_VERSION,
+ CU_FUNC_ATTRIBUTE_BINARY_VERSION,
+ CU_FUNC_ATTRIBUTE_MAX);
+ pragma Convention (C, CUfunction_attribute_enum); -- cuda.h:311
+
+ subtype CUfunction_attribute is CUfunction_attribute_enum;
+
+ type CUfunc_cache_enum is
+ (CU_FUNC_CACHE_PREFER_NONE,
+ CU_FUNC_CACHE_PREFER_SHARED,
+ CU_FUNC_CACHE_PREFER_L1);
+ pragma Convention (C, CUfunc_cache_enum); -- cuda.h:366
+
+ subtype CUfunc_cache is CUfunc_cache_enum;
+
+ subtype CUmemorytype_enum is unsigned;
+ CU_MEMORYTYPE_HOST : constant CUmemorytype_enum := 1;
+ CU_MEMORYTYPE_DEVICE : constant CUmemorytype_enum := 2;
+ CU_MEMORYTYPE_ARRAY : constant CUmemorytype_enum := 3;
+ CU_MEMORYTYPE_UNIFIED : constant CUmemorytype_enum := 4; -- cuda.h:375
+
+ subtype CUmemorytype is CUmemorytype_enum;
+
+ type CUcomputemode_enum is
+ (CU_COMPUTEMODE_DEFAULT,
+ CU_COMPUTEMODE_EXCLUSIVE,
+ CU_COMPUTEMODE_PROHIBITED,
+ CU_COMPUTEMODE_EXCLUSIVE_PROCESS);
+ pragma Convention (C, CUcomputemode_enum); -- cuda.h:385
+
+ subtype CUcomputemode is CUcomputemode_enum;
+
+ type CUjit_option_enum is
+ (CU_JIT_MAX_REGISTERS,
+ CU_JIT_THREADS_PER_BLOCK,
+ CU_JIT_WALL_TIME,
+ CU_JIT_INFO_LOG_BUFFER,
+ CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES,
+ CU_JIT_ERROR_LOG_BUFFER,
+ CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES,
+ CU_JIT_OPTIMIZATION_LEVEL,
+ CU_JIT_TARGET_FROM_CUCONTEXT,
+ CU_JIT_TARGET,
+ CU_JIT_FALLBACK_STRATEGY);
+ pragma Convention (C, CUjit_option_enum); -- cuda.h:395
+
+ subtype CUjit_option is CUjit_option_enum;
+
+ type CUjit_target_enum is
+ (CU_TARGET_COMPUTE_10,
+ CU_TARGET_COMPUTE_11,
+ CU_TARGET_COMPUTE_12,
+ CU_TARGET_COMPUTE_13,
+ CU_TARGET_COMPUTE_20,
+ CU_TARGET_COMPUTE_21);
+ pragma Convention (C, CUjit_target_enum); -- cuda.h:487
+
+ subtype CUjit_target is CUjit_target_enum;
+
+ type CUjit_fallback_enum is
+ (CU_PREFER_PTX,
+ CU_PREFER_BINARY);
+ pragma Convention (C, CUjit_fallback_enum); -- cuda.h:500
+
+ subtype CUjit_fallback is CUjit_fallback_enum;
+
+ subtype CUgraphicsRegisterFlags_enum is unsigned;
+ CU_GRAPHICS_REGISTER_FLAGS_NONE : constant CUgraphicsRegisterFlags_enum := 0;
+ CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY : constant CUgraphicsRegisterFlags_enum := 1;
+ CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD : constant CUgraphicsRegisterFlags_enum := 2;
+ CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST : constant CUgraphicsRegisterFlags_enum := 4; -- cuda.h:511
+
+ subtype CUgraphicsRegisterFlags is CUgraphicsRegisterFlags_enum;
+
+ type CUgraphicsMapResourceFlags_enum is
+ (CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE,
+ CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY,
+ CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD);
+ pragma Convention (C, CUgraphicsMapResourceFlags_enum); -- cuda.h:521
+
+ subtype CUgraphicsMapResourceFlags is CUgraphicsMapResourceFlags_enum;
+
+ type CUarray_cubemap_face_enum is
+ (CU_CUBEMAP_FACE_POSITIVE_X,
+ CU_CUBEMAP_FACE_NEGATIVE_X,
+ CU_CUBEMAP_FACE_POSITIVE_Y,
+ CU_CUBEMAP_FACE_NEGATIVE_Y,
+ CU_CUBEMAP_FACE_POSITIVE_Z,
+ CU_CUBEMAP_FACE_NEGATIVE_Z);
+ pragma Convention (C, CUarray_cubemap_face_enum); -- cuda.h:530
+
+ subtype CUarray_cubemap_face is CUarray_cubemap_face_enum;
+
+ type CUlimit_enum is
+ (CU_LIMIT_STACK_SIZE,
+ CU_LIMIT_PRINTF_FIFO_SIZE,
+ CU_LIMIT_MALLOC_HEAP_SIZE);
+ pragma Convention (C, CUlimit_enum); -- cuda.h:542
+
+ subtype CUlimit is CUlimit_enum;
+
+ subtype cudaError_enum is unsigned;
+ CUDA_SUCCESS : constant cudaError_enum := 0;
+ CUDA_ERROR_INVALID_VALUE : constant cudaError_enum := 1;
+ CUDA_ERROR_OUT_OF_MEMORY : constant cudaError_enum := 2;
+ CUDA_ERROR_NOT_INITIALIZED : constant cudaError_enum := 3;
+ CUDA_ERROR_DEINITIALIZED : constant cudaError_enum := 4;
+ CUDA_ERROR_PROFILER_DISABLED : constant cudaError_enum := 5;
+ CUDA_ERROR_PROFILER_NOT_INITIALIZED : constant cudaError_enum := 6;
+ CUDA_ERROR_PROFILER_ALREADY_STARTED : constant cudaError_enum := 7;
+ CUDA_ERROR_PROFILER_ALREADY_STOPPED : constant cudaError_enum := 8;
+ CUDA_ERROR_NO_DEVICE : constant cudaError_enum := 100;
+ CUDA_ERROR_INVALID_DEVICE : constant cudaError_enum := 101;
+ CUDA_ERROR_INVALID_IMAGE : constant cudaError_enum := 200;
+ CUDA_ERROR_INVALID_CONTEXT : constant cudaError_enum := 201;
+ CUDA_ERROR_CONTEXT_ALREADY_CURRENT : constant cudaError_enum := 202;
+ CUDA_ERROR_MAP_FAILED : constant cudaError_enum := 205;
+ CUDA_ERROR_UNMAP_FAILED : constant cudaError_enum := 206;
+ CUDA_ERROR_ARRAY_IS_MAPPED : constant cudaError_enum := 207;
+ CUDA_ERROR_ALREADY_MAPPED : constant cudaError_enum := 208;
+ CUDA_ERROR_NO_BINARY_FOR_GPU : constant cudaError_enum := 209;
+ CUDA_ERROR_ALREADY_ACQUIRED : constant cudaError_enum := 210;
+ CUDA_ERROR_NOT_MAPPED : constant cudaError_enum := 211;
+ CUDA_ERROR_NOT_MAPPED_AS_ARRAY : constant cudaError_enum := 212;
+ CUDA_ERROR_NOT_MAPPED_AS_POINTER : constant cudaError_enum := 213;
+ CUDA_ERROR_ECC_UNCORRECTABLE : constant cudaError_enum := 214;
+ CUDA_ERROR_UNSUPPORTED_LIMIT : constant cudaError_enum := 215;
+ CUDA_ERROR_CONTEXT_ALREADY_IN_USE : constant cudaError_enum := 216;
+ CUDA_ERROR_INVALID_SOURCE : constant cudaError_enum := 300;
+ CUDA_ERROR_FILE_NOT_FOUND : constant cudaError_enum := 301;
+ CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND : constant cudaError_enum := 302;
+ CUDA_ERROR_SHARED_OBJECT_INIT_FAILED : constant cudaError_enum := 303;
+ CUDA_ERROR_OPERATING_SYSTEM : constant cudaError_enum := 304;
+ CUDA_ERROR_INVALID_HANDLE : constant cudaError_enum := 400;
+ CUDA_ERROR_NOT_FOUND : constant cudaError_enum := 500;
+ CUDA_ERROR_NOT_READY : constant cudaError_enum := 600;
+ CUDA_ERROR_LAUNCH_FAILED : constant cudaError_enum := 700;
+ CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES : constant cudaError_enum := 701;
+ CUDA_ERROR_LAUNCH_TIMEOUT : constant cudaError_enum := 702;
+ CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING : constant cudaError_enum := 703;
+ CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED : constant cudaError_enum := 704;
+ CUDA_ERROR_PEER_ACCESS_NOT_ENABLED : constant cudaError_enum := 705;
+ CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE : constant cudaError_enum := 708;
+ CUDA_ERROR_CONTEXT_IS_DESTROYED : constant cudaError_enum := 709;
+ CUDA_ERROR_UNKNOWN : constant cudaError_enum := 999; -- cuda.h:551
+
+ subtype CUresult is cudaError_enum;
+
+ type CUDA_MEMCPY2D_st is record
+ srcXInBytes : aliased stddef_h.size_t; -- cuda.h:870
+ srcY : aliased stddef_h.size_t; -- cuda.h:871
+ srcMemoryType : aliased CUmemorytype; -- cuda.h:873
+ srcHost : System.Address; -- cuda.h:874
+ srcDevice : aliased CUdeviceptr; -- cuda.h:875
+ srcArray : CUarray; -- cuda.h:876
+ srcPitch : aliased stddef_h.size_t; -- cuda.h:877
+ dstXInBytes : aliased stddef_h.size_t; -- cuda.h:879
+ dstY : aliased stddef_h.size_t; -- cuda.h:880
+ dstMemoryType : aliased CUmemorytype; -- cuda.h:882
+ dstHost : System.Address; -- cuda.h:883
+ dstDevice : aliased CUdeviceptr; -- cuda.h:884
+ dstArray : CUarray; -- cuda.h:885
+ dstPitch : aliased stddef_h.size_t; -- cuda.h:886
+ WidthInBytes : aliased stddef_h.size_t; -- cuda.h:888
+ Height : aliased stddef_h.size_t; -- cuda.h:889
+ end record;
+ pragma Convention (C_Pass_By_Copy, CUDA_MEMCPY2D_st); -- cuda.h:869
+
+ subtype CUDA_MEMCPY2D is CUDA_MEMCPY2D_st;
+
+ type CUDA_MEMCPY3D_st is record
+ srcXInBytes : aliased stddef_h.size_t; -- cuda.h:896
+ srcY : aliased stddef_h.size_t; -- cuda.h:897
+ srcZ : aliased stddef_h.size_t; -- cuda.h:898
+ srcLOD : aliased stddef_h.size_t; -- cuda.h:899
+ srcMemoryType : aliased CUmemorytype; -- cuda.h:900
+ srcHost : System.Address; -- cuda.h:901
+ srcDevice : aliased CUdeviceptr; -- cuda.h:902
+ srcArray : CUarray; -- cuda.h:903
+ reserved0 : System.Address; -- cuda.h:904
+ srcPitch : aliased stddef_h.size_t; -- cuda.h:905
+ srcHeight : aliased stddef_h.size_t; -- cuda.h:906
+ dstXInBytes : aliased stddef_h.size_t; -- cuda.h:908
+ dstY : aliased stddef_h.size_t; -- cuda.h:909
+ dstZ : aliased stddef_h.size_t; -- cuda.h:910
+ dstLOD : aliased stddef_h.size_t; -- cuda.h:911
+ dstMemoryType : aliased CUmemorytype; -- cuda.h:912
+ dstHost : System.Address; -- cuda.h:913
+ dstDevice : aliased CUdeviceptr; -- cuda.h:914
+ dstArray : CUarray; -- cuda.h:915
+ reserved1 : System.Address; -- cuda.h:916
+ dstPitch : aliased stddef_h.size_t; -- cuda.h:917
+ dstHeight : aliased stddef_h.size_t; -- cuda.h:918
+ WidthInBytes : aliased stddef_h.size_t; -- cuda.h:920
+ Height : aliased stddef_h.size_t; -- cuda.h:921
+ Depth : aliased stddef_h.size_t; -- cuda.h:922
+ end record;
+ pragma Convention (C_Pass_By_Copy, CUDA_MEMCPY3D_st); -- cuda.h:895
+
+ subtype CUDA_MEMCPY3D is CUDA_MEMCPY3D_st;
+
+ type CUDA_MEMCPY3D_PEER_st is record
+ srcXInBytes : aliased stddef_h.size_t; -- cuda.h:929
+ srcY : aliased stddef_h.size_t; -- cuda.h:930
+ srcZ : aliased stddef_h.size_t; -- cuda.h:931
+ srcLOD : aliased stddef_h.size_t; -- cuda.h:932
+ srcMemoryType : aliased CUmemorytype; -- cuda.h:933
+ srcHost : System.Address; -- cuda.h:934
+ srcDevice : aliased CUdeviceptr; -- cuda.h:935
+ srcArray : CUarray; -- cuda.h:936
+ srcContext : CUcontext; -- cuda.h:937
+ srcPitch : aliased stddef_h.size_t; -- cuda.h:938
+ srcHeight : aliased stddef_h.size_t; -- cuda.h:939
+ dstXInBytes : aliased stddef_h.size_t; -- cuda.h:941
+ dstY : aliased stddef_h.size_t; -- cuda.h:942
+ dstZ : aliased stddef_h.size_t; -- cuda.h:943
+ dstLOD : aliased stddef_h.size_t; -- cuda.h:944
+ dstMemoryType : aliased CUmemorytype; -- cuda.h:945
+ dstHost : System.Address; -- cuda.h:946
+ dstDevice : aliased CUdeviceptr; -- cuda.h:947
+ dstArray : CUarray; -- cuda.h:948
+ dstContext : CUcontext; -- cuda.h:949
+ dstPitch : aliased stddef_h.size_t; -- cuda.h:950
+ dstHeight : aliased stddef_h.size_t; -- cuda.h:951
+ WidthInBytes : aliased stddef_h.size_t; -- cuda.h:953
+ Height : aliased stddef_h.size_t; -- cuda.h:954
+ Depth : aliased stddef_h.size_t; -- cuda.h:955
+ end record;
+ pragma Convention (C_Pass_By_Copy, CUDA_MEMCPY3D_PEER_st); -- cuda.h:928
+
+ subtype CUDA_MEMCPY3D_PEER is CUDA_MEMCPY3D_PEER_st;
+
+ type CUDA_ARRAY_DESCRIPTOR_st is record
+ Width : aliased stddef_h.size_t; -- cuda.h:963
+ Height : aliased stddef_h.size_t; -- cuda.h:964
+ Format : aliased CUarray_format; -- cuda.h:966
+ NumChannels : aliased unsigned; -- cuda.h:967
+ end record;
+ pragma Convention (C_Pass_By_Copy, CUDA_ARRAY_DESCRIPTOR_st); -- cuda.h:961
+
+ subtype CUDA_ARRAY_DESCRIPTOR is CUDA_ARRAY_DESCRIPTOR_st;
+
+ type CUDA_ARRAY3D_DESCRIPTOR_st is record
+ Width : aliased stddef_h.size_t; -- cuda.h:975
+ Height : aliased stddef_h.size_t; -- cuda.h:976
+ Depth : aliased stddef_h.size_t; -- cuda.h:977
+ Format : aliased CUarray_format; -- cuda.h:979
+ NumChannels : aliased unsigned; -- cuda.h:980
+ Flags : aliased unsigned; -- cuda.h:981
+ end record;
+ pragma Convention (C_Pass_By_Copy, CUDA_ARRAY3D_DESCRIPTOR_st); -- cuda.h:973
+
+ subtype CUDA_ARRAY3D_DESCRIPTOR is CUDA_ARRAY3D_DESCRIPTOR_st;
+
+ function cuInit (arg1 : unsigned) return CUresult; -- cuda.h:1095
+ pragma Import (C, cuInit, "cuInit");
+
+ function cuDriverGetVersion (arg1 : access int) return CUresult; -- cuda.h:1122
+ pragma Import (C, cuDriverGetVersion, "cuDriverGetVersion");
+
+ function cuDeviceGet (arg1 : access CUdevice; arg2 : int) return CUresult; -- cuda.h:1160
+ pragma Import (C, cuDeviceGet, "cuDeviceGet");
+
+ function cuDeviceGetCount (arg1 : access int) return CUresult; -- cuda.h:1186
+ pragma Import (C, cuDeviceGetCount, "cuDeviceGetCount");
+
+ function cuDeviceGetName
+ (arg1 : Interfaces.C.Strings.chars_ptr;
+ arg2 : int;
+ arg3 : CUdevice) return CUresult; -- cuda.h:1215
+ pragma Import (C, cuDeviceGetName, "cuDeviceGetName");
+
+ function cuDeviceComputeCapability
+ (arg1 : access int;
+ arg2 : access int;
+ arg3 : CUdevice) return CUresult; -- cuda.h:1244
+ pragma Import (C, cuDeviceComputeCapability, "cuDeviceComputeCapability");
+
+ function cuDeviceTotalMem_v2 (arg1 : access stddef_h.size_t; arg2 : CUdevice) return CUresult; -- cuda.h:1272
+ pragma Import (C, cuDeviceTotalMem_v2, "cuDeviceTotalMem_v2");
+
+ function cuDeviceGetProperties (arg1 : access CUdevprop; arg2 : CUdevice) return CUresult; -- cuda.h:1332
+ pragma Import (C, cuDeviceGetProperties, "cuDeviceGetProperties");
+
+ function cuDeviceGetAttribute
+ (arg1 : access int;
+ arg2 : CUdevice_attribute;
+ arg3 : CUdevice) return CUresult; -- cuda.h:1444
+ pragma Import (C, cuDeviceGetAttribute, "cuDeviceGetAttribute");
+
+ function cuCtxCreate_v2
+ (arg1 : System.Address;
+ arg2 : unsigned;
+ arg3 : CUdevice) return CUresult; -- cuda.h:1544
+ pragma Import (C, cuCtxCreate_v2, "cuCtxCreate_v2");
+
+ function cuCtxDestroy_v2 (arg1 : CUcontext) return CUresult; -- cuda.h:1583
+ pragma Import (C, cuCtxDestroy_v2, "cuCtxDestroy_v2");
+
+ function cuCtxAttach (arg1 : System.Address; arg2 : unsigned) return CUresult; -- cuda.h:1633
+ pragma Import (C, cuCtxAttach, "cuCtxAttach");
+
+ function cuCtxDetach (arg1 : CUcontext) return CUresult; -- cuda.h:1668
+ pragma Import (C, cuCtxDetach, "cuCtxDetach");
+
+ function cuCtxPushCurrent_v2 (arg1 : CUcontext) return CUresult; -- cuda.h:1704
+ pragma Import (C, cuCtxPushCurrent_v2, "cuCtxPushCurrent_v2");
+
+ function cuCtxPopCurrent_v2 (arg1 : System.Address) return CUresult; -- cuda.h:1737
+ pragma Import (C, cuCtxPopCurrent_v2, "cuCtxPopCurrent_v2");
+
+ function cuCtxSetCurrent (arg1 : CUcontext) return CUresult; -- cuda.h:1763
+ pragma Import (C, cuCtxSetCurrent, "cuCtxSetCurrent");
+
+ function cuCtxGetCurrent (arg1 : System.Address) return CUresult; -- cuda.h:1782
+ pragma Import (C, cuCtxGetCurrent, "cuCtxGetCurrent");
+
+ function cuCtxGetDevice (arg1 : access CUdevice) return CUresult; -- cuda.h:1811
+ pragma Import (C, cuCtxGetDevice, "cuCtxGetDevice");
+
+ function cuCtxSynchronize return CUresult; -- cuda.h:1839
+ pragma Import (C, cuCtxSynchronize, "cuCtxSynchronize");
+
+ function cuCtxSetLimit (arg1 : CUlimit; arg2 : stddef_h.size_t) return CUresult; -- cuda.h:1900
+ pragma Import (C, cuCtxSetLimit, "cuCtxSetLimit");
+
+ function cuCtxGetLimit (arg1 : access stddef_h.size_t; arg2 : CUlimit) return CUresult; -- cuda.h:1933
+ pragma Import (C, cuCtxGetLimit, "cuCtxGetLimit");
+
+ function cuCtxGetCacheConfig (arg1 : access CUfunc_cache) return CUresult; -- cuda.h:1974
+ pragma Import (C, cuCtxGetCacheConfig, "cuCtxGetCacheConfig");
+
+ function cuCtxSetCacheConfig (arg1 : CUfunc_cache) return CUresult; -- cuda.h:2022
+ pragma Import (C, cuCtxSetCacheConfig, "cuCtxSetCacheConfig");
+
+ function cuCtxGetApiVersion (arg1 : CUcontext; arg2 : access unsigned) return CUresult; -- cuda.h:2057
+ pragma Import (C, cuCtxGetApiVersion, "cuCtxGetApiVersion");
+
+ function cuModuleLoad (arg1 : System.Address; arg2 : Interfaces.C.Strings.chars_ptr) return CUresult; -- cuda.h:2106
+ pragma Import (C, cuModuleLoad, "cuModuleLoad");
+
+ function cuModuleLoadData (arg1 : System.Address; arg2 : System.Address) return CUresult; -- cuda.h:2140
+ pragma Import (C, cuModuleLoadData, "cuModuleLoadData");
+
+ function cuModuleLoadDataEx
+ (arg1 : System.Address;
+ arg2 : System.Address;
+ arg3 : unsigned;
+ arg4 : access CUjit_option;
+ arg5 : System.Address) return CUresult; -- cuda.h:2219
+ pragma Import (C, cuModuleLoadDataEx, "cuModuleLoadDataEx");
+
+ function cuModuleLoadFatBinary (arg1 : System.Address; arg2 : System.Address) return CUresult; -- cuda.h:2259
+ pragma Import (C, cuModuleLoadFatBinary, "cuModuleLoadFatBinary");
+
+ function cuModuleUnload (arg1 : CUmodule) return CUresult; -- cuda.h:2284
+ pragma Import (C, cuModuleUnload, "cuModuleUnload");
+
+ function cuModuleGetFunction
+ (arg1 : System.Address;
+ arg2 : CUmodule;
+ arg3 : Interfaces.C.Strings.chars_ptr) return CUresult; -- cuda.h:2314
+ pragma Import (C, cuModuleGetFunction, "cuModuleGetFunction");
+
+ function cuModuleGetGlobal_v2
+ (arg1 : access CUdeviceptr;
+ arg2 : access stddef_h.size_t;
+ arg3 : CUmodule;
+ arg4 : Interfaces.C.Strings.chars_ptr) return CUresult; -- cuda.h:2348
+ pragma Import (C, cuModuleGetGlobal_v2, "cuModuleGetGlobal_v2");
+
+ function cuModuleGetTexRef
+ (arg1 : System.Address;
+ arg2 : CUmodule;
+ arg3 : Interfaces.C.Strings.chars_ptr) return CUresult; -- cuda.h:2382
+ pragma Import (C, cuModuleGetTexRef, "cuModuleGetTexRef");
+
+ function cuModuleGetSurfRef
+ (arg1 : System.Address;
+ arg2 : CUmodule;
+ arg3 : Interfaces.C.Strings.chars_ptr) return CUresult; -- cuda.h:2413
+ pragma Import (C, cuModuleGetSurfRef, "cuModuleGetSurfRef");
+
+ function cuMemGetInfo_v2 (arg1 : access stddef_h.size_t; arg2 : access stddef_h.size_t) return CUresult; -- cuda.h:2456
+ pragma Import (C, cuMemGetInfo_v2, "cuMemGetInfo_v2");
+
+ function cuMemAlloc_v2 (arg1 : access CUdeviceptr; arg2 : stddef_h.size_t) return CUresult; -- cuda.h:2489
+ pragma Import (C, cuMemAlloc_v2, "cuMemAlloc_v2");
+
+ function cuMemAllocPitch_v2
+ (arg1 : access CUdeviceptr;
+ arg2 : access stddef_h.size_t;
+ arg3 : stddef_h.size_t;
+ arg4 : stddef_h.size_t;
+ arg5 : unsigned) return CUresult; -- cuda.h:2550
+ pragma Import (C, cuMemAllocPitch_v2, "cuMemAllocPitch_v2");
+
+ function cuMemFree_v2 (arg1 : CUdeviceptr) return CUresult; -- cuda.h:2579
+ pragma Import (C, cuMemFree_v2, "cuMemFree_v2");
+
+ function cuMemGetAddressRange_v2
+ (arg1 : access CUdeviceptr;
+ arg2 : access stddef_h.size_t;
+ arg3 : CUdeviceptr) return CUresult; -- cuda.h:2612
+ pragma Import (C, cuMemGetAddressRange_v2, "cuMemGetAddressRange_v2");
+
+ function cuMemAllocHost_v2 (arg1 : System.Address; arg2 : stddef_h.size_t) return CUresult; -- cuda.h:2658
+ pragma Import (C, cuMemAllocHost_v2, "cuMemAllocHost_v2");
+
+ function cuMemFreeHost (arg1 : System.Address) return CUresult; -- cuda.h:2688
+ pragma Import (C, cuMemFreeHost, "cuMemFreeHost");
+
+ function cuMemHostAlloc
+ (arg1 : System.Address;
+ arg2 : stddef_h.size_t;
+ arg3 : unsigned) return CUresult; -- cuda.h:2770
+ pragma Import (C, cuMemHostAlloc, "cuMemHostAlloc");
+
+ function cuMemHostGetDevicePointer_v2
+ (arg1 : access CUdeviceptr;
+ arg2 : System.Address;
+ arg3 : unsigned) return CUresult; -- cuda.h:2808
+ pragma Import (C, cuMemHostGetDevicePointer_v2, "cuMemHostGetDevicePointer_v2");
+
+ function cuMemHostGetFlags (arg1 : access unsigned; arg2 : System.Address) return CUresult; -- cuda.h:2833
+ pragma Import (C, cuMemHostGetFlags, "cuMemHostGetFlags");
+
+ function cuMemHostRegister
+ (arg1 : System.Address;
+ arg2 : stddef_h.size_t;
+ arg3 : unsigned) return CUresult; -- cuda.h:2896
+ pragma Import (C, cuMemHostRegister, "cuMemHostRegister");
+
+ function cuMemHostUnregister (arg1 : System.Address) return CUresult; -- cuda.h:2919
+ pragma Import (C, cuMemHostUnregister, "cuMemHostUnregister");
+
+ function cuMemcpy
+ (arg1 : CUdeviceptr;
+ arg2 : CUdeviceptr;
+ arg3 : stddef_h.size_t) return CUresult; -- cuda.h:2955
+ pragma Import (C, cuMemcpy, "cuMemcpy");
+
+ function cuMemcpyPeer
+ (arg1 : CUdeviceptr;
+ arg2 : CUcontext;
+ arg3 : CUdeviceptr;
+ arg4 : CUcontext;
+ arg5 : stddef_h.size_t) return CUresult; -- cuda.h:2988
+ pragma Import (C, cuMemcpyPeer, "cuMemcpyPeer");
+
+ function cuMemcpyHtoD_v2
+ (arg1 : CUdeviceptr;
+ arg2 : System.Address;
+ arg3 : stddef_h.size_t) return CUresult; -- cuda.h:3026
+ pragma Import (C, cuMemcpyHtoD_v2, "cuMemcpyHtoD_v2");
+
+ function cuMemcpyDtoH_v2
+ (arg1 : System.Address;
+ arg2 : CUdeviceptr;
+ arg3 : stddef_h.size_t) return CUresult; -- cuda.h:3059
+ pragma Import (C, cuMemcpyDtoH_v2, "cuMemcpyDtoH_v2");
+
+ function cuMemcpyDtoD_v2
+ (arg1 : CUdeviceptr;
+ arg2 : CUdeviceptr;
+ arg3 : stddef_h.size_t) return CUresult; -- cuda.h:3092
+ pragma Import (C, cuMemcpyDtoD_v2, "cuMemcpyDtoD_v2");
+
+ function cuMemcpyDtoA_v2
+ (arg1 : CUarray;
+ arg2 : stddef_h.size_t;
+ arg3 : CUdeviceptr;
+ arg4 : stddef_h.size_t) return CUresult; -- cuda.h:3126
+ pragma Import (C, cuMemcpyDtoA_v2, "cuMemcpyDtoA_v2");
+
+ function cuMemcpyAtoD_v2
+ (arg1 : CUdeviceptr;
+ arg2 : CUarray;
+ arg3 : stddef_h.size_t;
+ arg4 : stddef_h.size_t) return CUresult; -- cuda.h:3162
+ pragma Import (C, cuMemcpyAtoD_v2, "cuMemcpyAtoD_v2");
+
+ function cuMemcpyHtoA_v2
+ (arg1 : CUarray;
+ arg2 : stddef_h.size_t;
+ arg3 : System.Address;
+ arg4 : stddef_h.size_t) return CUresult; -- cuda.h:3196
+ pragma Import (C, cuMemcpyHtoA_v2, "cuMemcpyHtoA_v2");
+
+ function cuMemcpyAtoH_v2
+ (arg1 : System.Address;
+ arg2 : CUarray;
+ arg3 : stddef_h.size_t;
+ arg4 : stddef_h.size_t) return CUresult; -- cuda.h:3230
+ pragma Import (C, cuMemcpyAtoH_v2, "cuMemcpyAtoH_v2");
+
+ function cuMemcpyAtoA_v2
+ (arg1 : CUarray;
+ arg2 : stddef_h.size_t;
+ arg3 : CUarray;
+ arg4 : stddef_h.size_t;
+ arg5 : stddef_h.size_t) return CUresult; -- cuda.h:3268
+ pragma Import (C, cuMemcpyAtoA_v2, "cuMemcpyAtoA_v2");
+
+ function cuMemcpy2D_v2 (arg1 : System.Address) return CUresult; -- cuda.h:3428
+ pragma Import (C, cuMemcpy2D_v2, "cuMemcpy2D_v2");
+
+ function cuMemcpy2DUnaligned_v2 (arg1 : System.Address) return CUresult; -- cuda.h:3586
+ pragma Import (C, cuMemcpy2DUnaligned_v2, "cuMemcpy2DUnaligned_v2");
+
+ function cuMemcpy3D_v2 (arg1 : System.Address) return CUresult; -- cuda.h:3753
+ pragma Import (C, cuMemcpy3D_v2, "cuMemcpy3D_v2");
+
+ function cuMemcpy3DPeer (arg1 : System.Address) return CUresult; -- cuda.h:3784
+ pragma Import (C, cuMemcpy3DPeer, "cuMemcpy3DPeer");
+
+ function cuMemcpyAsync
+ (arg1 : CUdeviceptr;
+ arg2 : CUdeviceptr;
+ arg3 : stddef_h.size_t;
+ arg4 : CUstream) return CUresult; -- cuda.h:3824
+ pragma Import (C, cuMemcpyAsync, "cuMemcpyAsync");
+
+ function cuMemcpyPeerAsync
+ (arg1 : CUdeviceptr;
+ arg2 : CUcontext;
+ arg3 : CUdeviceptr;
+ arg4 : CUcontext;
+ arg5 : stddef_h.size_t;
+ arg6 : CUstream) return CUresult; -- cuda.h:3855
+ pragma Import (C, cuMemcpyPeerAsync, "cuMemcpyPeerAsync");
+
+ function cuMemcpyHtoDAsync_v2
+ (arg1 : CUdeviceptr;
+ arg2 : System.Address;
+ arg3 : stddef_h.size_t;
+ arg4 : CUstream) return CUresult; -- cuda.h:3897
+ pragma Import (C, cuMemcpyHtoDAsync_v2, "cuMemcpyHtoDAsync_v2");
+
+ function cuMemcpyDtoHAsync_v2
+ (arg1 : System.Address;
+ arg2 : CUdeviceptr;
+ arg3 : stddef_h.size_t;
+ arg4 : CUstream) return CUresult; -- cuda.h:3937
+ pragma Import (C, cuMemcpyDtoHAsync_v2, "cuMemcpyDtoHAsync_v2");
+
+ function cuMemcpyDtoDAsync_v2
+ (arg1 : CUdeviceptr;
+ arg2 : CUdeviceptr;
+ arg3 : stddef_h.size_t;
+ arg4 : CUstream) return CUresult; -- cuda.h:3974
+ pragma Import (C, cuMemcpyDtoDAsync_v2, "cuMemcpyDtoDAsync_v2");
+
+ function cuMemcpyHtoAAsync_v2
+ (arg1 : CUarray;
+ arg2 : stddef_h.size_t;
+ arg3 : System.Address;
+ arg4 : stddef_h.size_t;
+ arg5 : CUstream) return CUresult; -- cuda.h:4016
+ pragma Import (C, cuMemcpyHtoAAsync_v2, "cuMemcpyHtoAAsync_v2");
+
+ function cuMemcpyAtoHAsync_v2
+ (arg1 : System.Address;
+ arg2 : CUarray;
+ arg3 : stddef_h.size_t;
+ arg4 : stddef_h.size_t;
+ arg5 : CUstream) return CUresult; -- cuda.h:4058
+ pragma Import (C, cuMemcpyAtoHAsync_v2, "cuMemcpyAtoHAsync_v2");
+
+ function cuMemcpy2DAsync_v2 (arg1 : System.Address; arg2 : CUstream) return CUresult; -- cuda.h:4229
+ pragma Import (C, cuMemcpy2DAsync_v2, "cuMemcpy2DAsync_v2");
+
+ function cuMemcpy3DAsync_v2 (arg1 : System.Address; arg2 : CUstream) return CUresult; -- cuda.h:4404
+ pragma Import (C, cuMemcpy3DAsync_v2, "cuMemcpy3DAsync_v2");
+
+ function cuMemcpy3DPeerAsync (arg1 : System.Address; arg2 : CUstream) return CUresult; -- cuda.h:4429
+ pragma Import (C, cuMemcpy3DPeerAsync, "cuMemcpy3DPeerAsync");
+
+ function cuMemsetD8_v2
+ (arg1 : CUdeviceptr;
+ arg2 : unsigned_char;
+ arg3 : stddef_h.size_t) return CUresult; -- cuda.h:4464
+ pragma Import (C, cuMemsetD8_v2, "cuMemsetD8_v2");
+
+ function cuMemsetD16_v2
+ (arg1 : CUdeviceptr;
+ arg2 : unsigned_short;
+ arg3 : stddef_h.size_t) return CUresult; -- cuda.h:4497
+ pragma Import (C, cuMemsetD16_v2, "cuMemsetD16_v2");
+
+ function cuMemsetD32_v2
+ (arg1 : CUdeviceptr;
+ arg2 : unsigned;
+ arg3 : stddef_h.size_t) return CUresult; -- cuda.h:4530
+ pragma Import (C, cuMemsetD32_v2, "cuMemsetD32_v2");
+
+ function cuMemsetD2D8_v2
+ (arg1 : CUdeviceptr;
+ arg2 : stddef_h.size_t;
+ arg3 : unsigned_char;
+ arg4 : stddef_h.size_t;
+ arg5 : stddef_h.size_t) return CUresult; -- cuda.h:4568
+ pragma Import (C, cuMemsetD2D8_v2, "cuMemsetD2D8_v2");
+
+ function cuMemsetD2D16_v2
+ (arg1 : CUdeviceptr;
+ arg2 : stddef_h.size_t;
+ arg3 : unsigned_short;
+ arg4 : stddef_h.size_t;
+ arg5 : stddef_h.size_t) return CUresult; -- cuda.h:4606
+ pragma Import (C, cuMemsetD2D16_v2, "cuMemsetD2D16_v2");
+
+ function cuMemsetD2D32_v2
+ (arg1 : CUdeviceptr;
+ arg2 : stddef_h.size_t;
+ arg3 : unsigned;
+ arg4 : stddef_h.size_t;
+ arg5 : stddef_h.size_t) return CUresult; -- cuda.h:4644
+ pragma Import (C, cuMemsetD2D32_v2, "cuMemsetD2D32_v2");
+
+ function cuMemsetD8Async
+ (arg1 : CUdeviceptr;
+ arg2 : unsigned_char;
+ arg3 : stddef_h.size_t;
+ arg4 : CUstream) return CUresult; -- cuda.h:4681
+ pragma Import (C, cuMemsetD8Async, "cuMemsetD8Async");
+
+ function cuMemsetD16Async
+ (arg1 : CUdeviceptr;
+ arg2 : unsigned_short;
+ arg3 : stddef_h.size_t;
+ arg4 : CUstream) return CUresult; -- cuda.h:4718
+ pragma Import (C, cuMemsetD16Async, "cuMemsetD16Async");
+
+ function cuMemsetD32Async
+ (arg1 : CUdeviceptr;
+ arg2 : unsigned;
+ arg3 : stddef_h.size_t;
+ arg4 : CUstream) return CUresult; -- cuda.h:4754
+ pragma Import (C, cuMemsetD32Async, "cuMemsetD32Async");
+
+ function cuMemsetD2D8Async
+ (arg1 : CUdeviceptr;
+ arg2 : stddef_h.size_t;
+ arg3 : unsigned_char;
+ arg4 : stddef_h.size_t;
+ arg5 : stddef_h.size_t;
+ arg6 : CUstream) return CUresult; -- cuda.h:4796
+ pragma Import (C, cuMemsetD2D8Async, "cuMemsetD2D8Async");
+
+ function cuMemsetD2D16Async
+ (arg1 : CUdeviceptr;
+ arg2 : stddef_h.size_t;
+ arg3 : unsigned_short;
+ arg4 : stddef_h.size_t;
+ arg5 : stddef_h.size_t;
+ arg6 : CUstream) return CUresult; -- cuda.h:4838
+ pragma Import (C, cuMemsetD2D16Async, "cuMemsetD2D16Async");
+
+ function cuMemsetD2D32Async
+ (arg1 : CUdeviceptr;
+ arg2 : stddef_h.size_t;
+ arg3 : unsigned;
+ arg4 : stddef_h.size_t;
+ arg5 : stddef_h.size_t;
+ arg6 : CUstream) return CUresult; -- cuda.h:4880
+ pragma Import (C, cuMemsetD2D32Async, "cuMemsetD2D32Async");
+
+ function cuArrayCreate_v2 (arg1 : System.Address; arg2 : System.Address) return CUresult; -- cuda.h:4983
+ pragma Import (C, cuArrayCreate_v2, "cuArrayCreate_v2");
+
+ function cuArrayGetDescriptor_v2 (arg1 : access CUDA_ARRAY_DESCRIPTOR; arg2 : CUarray) return CUresult; -- cuda.h:5016
+ pragma Import (C, cuArrayGetDescriptor_v2, "cuArrayGetDescriptor_v2");
+
+ function cuArrayDestroy (arg1 : CUarray) return CUresult; -- cuda.h:5047
+ pragma Import (C, cuArrayDestroy, "cuArrayDestroy");
+
+ function cuArray3DCreate_v2 (arg1 : System.Address; arg2 : System.Address) return CUresult; -- cuda.h:5155
+ pragma Import (C, cuArray3DCreate_v2, "cuArray3DCreate_v2");
+
+ function cuArray3DGetDescriptor_v2 (arg1 : access CUDA_ARRAY3D_DESCRIPTOR; arg2 : CUarray) return CUresult; -- cuda.h:5191
+ pragma Import (C, cuArray3DGetDescriptor_v2, "cuArray3DGetDescriptor_v2");
+
+ function cuPointerGetAttribute
+ (arg1 : System.Address;
+ arg2 : CUpointer_attribute;
+ arg3 : CUdeviceptr) return CUresult; -- cuda.h:5398
+ pragma Import (C, cuPointerGetAttribute, "cuPointerGetAttribute");
+
+ function cuStreamCreate (arg1 : System.Address; arg2 : unsigned) return CUresult; -- cuda.h:5435
+ pragma Import (C, cuStreamCreate, "cuStreamCreate");
+
+ function cuStreamWaitEvent
+ (arg1 : CUstream;
+ arg2 : CUevent;
+ arg3 : unsigned) return CUresult; -- cuda.h:5477
+ pragma Import (C, cuStreamWaitEvent, "cuStreamWaitEvent");
+
+ function cuStreamQuery (arg1 : CUstream) return CUresult; -- cuda.h:5501
+ pragma Import (C, cuStreamQuery, "cuStreamQuery");
+
+ function cuStreamSynchronize (arg1 : CUstream) return CUresult; -- cuda.h:5526
+ pragma Import (C, cuStreamSynchronize, "cuStreamSynchronize");
+
+ function cuStreamDestroy_v2 (arg1 : CUstream) return CUresult; -- cuda.h:5554
+ pragma Import (C, cuStreamDestroy_v2, "cuStreamDestroy_v2");
+
+ function cuEventCreate (arg1 : System.Address; arg2 : unsigned) return CUresult; -- cuda.h:5603
+ pragma Import (C, cuEventCreate, "cuEventCreate");
+
+ function cuEventRecord (arg1 : CUevent; arg2 : CUstream) return CUresult; -- cuda.h:5641
+ pragma Import (C, cuEventRecord, "cuEventRecord");
+
+ function cuEventQuery (arg1 : CUevent) return CUresult; -- cuda.h:5672
+ pragma Import (C, cuEventQuery, "cuEventQuery");
+
+ function cuEventSynchronize (arg1 : CUevent) return CUresult; -- cuda.h:5706
+ pragma Import (C, cuEventSynchronize, "cuEventSynchronize");
+
+ function cuEventDestroy_v2 (arg1 : CUevent) return CUresult; -- cuda.h:5735
+ pragma Import (C, cuEventDestroy_v2, "cuEventDestroy_v2");
+
+ function cuEventElapsedTime
+ (arg1 : access float;
+ arg2 : CUevent;
+ arg3 : CUevent) return CUresult; -- cuda.h:5779
+ pragma Import (C, cuEventElapsedTime, "cuEventElapsedTime");
+
+ function cuFuncGetAttribute
+ (arg1 : access int;
+ arg2 : CUfunction_attribute;
+ arg3 : CUfunction) return CUresult; -- cuda.h:5842
+ pragma Import (C, cuFuncGetAttribute, "cuFuncGetAttribute");
+
+ function cuFuncSetCacheConfig (arg1 : CUfunction; arg2 : CUfunc_cache) return CUresult; -- cuda.h:5883
+ pragma Import (C, cuFuncSetCacheConfig, "cuFuncSetCacheConfig");
+
+ function cuLaunchKernel
+ (arg1 : CUfunction;
+ arg2 : unsigned;
+ arg3 : unsigned;
+ arg4 : unsigned;
+ arg5 : unsigned;
+ arg6 : unsigned;
+ arg7 : unsigned;
+ arg8 : unsigned;
+ arg9 : CUstream;
+ arg10 : System.Address;
+ arg11 : System.Address) return CUresult; -- cuda.h:5999
+ pragma Import (C, cuLaunchKernel, "cuLaunchKernel");
+
+ function cuFuncSetBlockShape
+ (arg1 : CUfunction;
+ arg2 : int;
+ arg3 : int;
+ arg4 : int) return CUresult; -- cuda.h:6055
+ pragma Import (C, cuFuncSetBlockShape, "cuFuncSetBlockShape");
+
+ function cuFuncSetSharedSize (arg1 : CUfunction; arg2 : unsigned) return CUresult; -- cuda.h:6089
+ pragma Import (C, cuFuncSetSharedSize, "cuFuncSetSharedSize");
+
+ function cuParamSetSize (arg1 : CUfunction; arg2 : unsigned) return CUresult; -- cuda.h:6121
+ pragma Import (C, cuParamSetSize, "cuParamSetSize");
+
+ function cuParamSeti
+ (arg1 : CUfunction;
+ arg2 : int;
+ arg3 : unsigned) return CUresult; -- cuda.h:6154
+ pragma Import (C, cuParamSeti, "cuParamSeti");
+
+ function cuParamSetf
+ (arg1 : CUfunction;
+ arg2 : int;
+ arg3 : float) return CUresult; -- cuda.h:6187
+ pragma Import (C, cuParamSetf, "cuParamSetf");
+
+ function cuParamSetv
+ (arg1 : CUfunction;
+ arg2 : int;
+ arg3 : System.Address;
+ arg4 : unsigned) return CUresult; -- cuda.h:6222
+ pragma Import (C, cuParamSetv, "cuParamSetv");
+
+ function cuLaunch (arg1 : CUfunction) return CUresult; -- cuda.h:6259
+ pragma Import (C, cuLaunch, "cuLaunch");
+
+ function cuLaunchGrid
+ (arg1 : CUfunction;
+ arg2 : int;
+ arg3 : int) return CUresult; -- cuda.h:6298
+ pragma Import (C, cuLaunchGrid, "cuLaunchGrid");
+
+ function cuLaunchGridAsync
+ (arg1 : CUfunction;
+ arg2 : int;
+ arg3 : int;
+ arg4 : CUstream) return CUresult; -- cuda.h:6342
+ pragma Import (C, cuLaunchGridAsync, "cuLaunchGridAsync");
+
+ function cuParamSetTexRef
+ (arg1 : CUfunction;
+ arg2 : int;
+ arg3 : CUtexref) return CUresult; -- cuda.h:6367
+ pragma Import (C, cuParamSetTexRef, "cuParamSetTexRef");
+
+ function cuTexRefSetArray
+ (arg1 : CUtexref;
+ arg2 : CUarray;
+ arg3 : unsigned) return CUresult; -- cuda.h:6408
+ pragma Import (C, cuTexRefSetArray, "cuTexRefSetArray");
+
+ function cuTexRefSetAddress_v2
+ (arg1 : access stddef_h.size_t;
+ arg2 : CUtexref;
+ arg3 : CUdeviceptr;
+ arg4 : stddef_h.size_t) return CUresult; -- cuda.h:6446
+ pragma Import (C, cuTexRefSetAddress_v2, "cuTexRefSetAddress_v2");
+
+ function cuTexRefSetAddress2D_v2
+ (arg1 : CUtexref;
+ arg2 : System.Address;
+ arg3 : CUdeviceptr;
+ arg4 : stddef_h.size_t) return CUresult; -- cuda.h:6487
+ pragma Import (C, cuTexRefSetAddress2D_v2, "cuTexRefSetAddress2D_v2");
+
+ function cuTexRefSetFormat
+ (arg1 : CUtexref;
+ arg2 : CUarray_format;
+ arg3 : int) return CUresult; -- cuda.h:6516
+ pragma Import (C, cuTexRefSetFormat, "cuTexRefSetFormat");
+
+ function cuTexRefSetAddressMode
+ (arg1 : CUtexref;
+ arg2 : int;
+ arg3 : CUaddress_mode) return CUresult; -- cuda.h:6556
+ pragma Import (C, cuTexRefSetAddressMode, "cuTexRefSetAddressMode");
+
+ function cuTexRefSetFilterMode (arg1 : CUtexref; arg2 : CUfilter_mode) return CUresult; -- cuda.h:6589
+ pragma Import (C, cuTexRefSetFilterMode, "cuTexRefSetFilterMode");
+
+ function cuTexRefSetFlags (arg1 : CUtexref; arg2 : unsigned) return CUresult; -- cuda.h:6621
+ pragma Import (C, cuTexRefSetFlags, "cuTexRefSetFlags");
+
+ function cuTexRefGetAddress_v2 (arg1 : access CUdeviceptr; arg2 : CUtexref) return CUresult; -- cuda.h:6647
+ pragma Import (C, cuTexRefGetAddress_v2, "cuTexRefGetAddress_v2");
+
+ function cuTexRefGetArray (arg1 : System.Address; arg2 : CUtexref) return CUresult; -- cuda.h:6673
+ pragma Import (C, cuTexRefGetArray, "cuTexRefGetArray");
+
+ function cuTexRefGetAddressMode
+ (arg1 : access CUaddress_mode;
+ arg2 : CUtexref;
+ arg3 : int) return CUresult; -- cuda.h:6699
+ pragma Import (C, cuTexRefGetAddressMode, "cuTexRefGetAddressMode");
+
+ function cuTexRefGetFilterMode (arg1 : access CUfilter_mode; arg2 : CUtexref) return CUresult; -- cuda.h:6723
+ pragma Import (C, cuTexRefGetFilterMode, "cuTexRefGetFilterMode");
+
+ function cuTexRefGetFormat
+ (arg1 : access CUarray_format;
+ arg2 : access int;
+ arg3 : CUtexref) return CUresult; -- cuda.h:6749
+ pragma Import (C, cuTexRefGetFormat, "cuTexRefGetFormat");
+
+ function cuTexRefGetFlags (arg1 : access unsigned; arg2 : CUtexref) return CUresult; -- cuda.h:6772
+ pragma Import (C, cuTexRefGetFlags, "cuTexRefGetFlags");
+
+ function cuTexRefCreate (arg1 : System.Address) return CUresult; -- cuda.h:6806
+ pragma Import (C, cuTexRefCreate, "cuTexRefCreate");
+
+ function cuTexRefDestroy (arg1 : CUtexref) return CUresult; -- cuda.h:6826
+ pragma Import (C, cuTexRefDestroy, "cuTexRefDestroy");
+
+ function cuSurfRefSetArray
+ (arg1 : CUsurfref;
+ arg2 : CUarray;
+ arg3 : unsigned) return CUresult; -- cuda.h:6864
+ pragma Import (C, cuSurfRefSetArray, "cuSurfRefSetArray");
+
+ function cuSurfRefGetArray (arg1 : System.Address; arg2 : CUsurfref) return CUresult; -- cuda.h:6885
+ pragma Import (C, cuSurfRefGetArray, "cuSurfRefGetArray");
+
+ function cuDeviceCanAccessPeer
+ (arg1 : access int;
+ arg2 : CUdevice;
+ arg3 : CUdevice) return CUresult; -- cuda.h:6923
+ pragma Import (C, cuDeviceCanAccessPeer, "cuDeviceCanAccessPeer");
+
+ function cuCtxEnablePeerAccess (arg1 : CUcontext; arg2 : unsigned) return CUresult; -- cuda.h:6966
+ pragma Import (C, cuCtxEnablePeerAccess, "cuCtxEnablePeerAccess");
+
+ function cuCtxDisablePeerAccess (arg1 : CUcontext) return CUresult; -- cuda.h:6991
+ pragma Import (C, cuCtxDisablePeerAccess, "cuCtxDisablePeerAccess");
+
+ function cuGraphicsUnregisterResource (arg1 : CUgraphicsResource) return CUresult; -- cuda.h:7032
+ pragma Import (C, cuGraphicsUnregisterResource, "cuGraphicsUnregisterResource");
+
+ function cuGraphicsSubResourceGetMappedArray
+ (arg1 : System.Address;
+ arg2 : CUgraphicsResource;
+ arg3 : unsigned;
+ arg4 : unsigned) return CUresult; -- cuda.h:7070
+ pragma Import (C, cuGraphicsSubResourceGetMappedArray, "cuGraphicsSubResourceGetMappedArray");
+
+ function cuGraphicsResourceGetMappedPointer_v2
+ (arg1 : access CUdeviceptr;
+ arg2 : access stddef_h.size_t;
+ arg3 : CUgraphicsResource) return CUresult; -- cuda.h:7104
+ pragma Import (C, cuGraphicsResourceGetMappedPointer_v2, "cuGraphicsResourceGetMappedPointer_v2");
+
+ function cuGraphicsResourceSetMapFlags (arg1 : CUgraphicsResource; arg2 : unsigned) return CUresult; -- cuda.h:7145
+ pragma Import (C, cuGraphicsResourceSetMapFlags, "cuGraphicsResourceSetMapFlags");
+
+ function cuGraphicsMapResources
+ (arg1 : unsigned;
+ arg2 : System.Address;
+ arg3 : CUstream) return CUresult; -- cuda.h:7183
+ pragma Import (C, cuGraphicsMapResources, "cuGraphicsMapResources");
+
+ function cuGraphicsUnmapResources
+ (arg1 : unsigned;
+ arg2 : System.Address;
+ arg3 : CUstream) return CUresult; -- cuda.h:7218
+ pragma Import (C, cuGraphicsUnmapResources, "cuGraphicsUnmapResources");
+
+ function cuGetExportTable (arg1 : System.Address; arg2 : System.Address) return CUresult; -- cuda.h:7222
+ pragma Import (C, cuGetExportTable, "cuGetExportTable");
+
+end cuda_h;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+with driver_types_h;
+with stddef_h;
+with Interfaces.C.Strings;
+with System;
+with vector_types_h;
+
+package cuda_runtime_api_h is
+
+
+ CUDART_VERSION : constant := 4000; -- cuda_runtime_api.h:82
+
+ function cudaDeviceReset return driver_types_h.cudaError_t; -- cuda_runtime_api.h:134
+ pragma Import (C, cudaDeviceReset, "cudaDeviceReset");
+
+ function cudaDeviceSynchronize return driver_types_h.cudaError_t; -- cuda_runtime_api.h:151
+ pragma Import (C, cudaDeviceSynchronize, "cudaDeviceSynchronize");
+
+ function cudaDeviceSetLimit (arg1 : driver_types_h.cudaLimit; arg2 : stddef_h.size_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:203
+ pragma Import (C, cudaDeviceSetLimit, "cudaDeviceSetLimit");
+
+ function cudaDeviceGetLimit (arg1 : access stddef_h.size_t; arg2 : driver_types_h.cudaLimit) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:227
+ pragma Import (C, cudaDeviceGetLimit, "cudaDeviceGetLimit");
+
+ function cudaDeviceGetCacheConfig (arg1 : access driver_types_h.cudaFuncCache) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:257
+ pragma Import (C, cudaDeviceGetCacheConfig, "cudaDeviceGetCacheConfig");
+
+ function cudaDeviceSetCacheConfig (arg1 : driver_types_h.cudaFuncCache) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:298
+ pragma Import (C, cudaDeviceSetCacheConfig, "cudaDeviceSetCacheConfig");
+
+ function cudaThreadExit return driver_types_h.cudaError_t; -- cuda_runtime_api.h:332
+ pragma Import (C, cudaThreadExit, "cudaThreadExit");
+
+ function cudaThreadSynchronize return driver_types_h.cudaError_t; -- cuda_runtime_api.h:356
+ pragma Import (C, cudaThreadSynchronize, "cudaThreadSynchronize");
+
+ function cudaThreadSetLimit (arg1 : driver_types_h.cudaLimit; arg2 : stddef_h.size_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:415
+ pragma Import (C, cudaThreadSetLimit, "cudaThreadSetLimit");
+
+ function cudaThreadGetLimit (arg1 : access stddef_h.size_t; arg2 : driver_types_h.cudaLimit) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:446
+ pragma Import (C, cudaThreadGetLimit, "cudaThreadGetLimit");
+
+ function cudaThreadGetCacheConfig (arg1 : access driver_types_h.cudaFuncCache) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:481
+ pragma Import (C, cudaThreadGetCacheConfig, "cudaThreadGetCacheConfig");
+
+ function cudaThreadSetCacheConfig (arg1 : driver_types_h.cudaFuncCache) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:527
+ pragma Import (C, cudaThreadSetCacheConfig, "cudaThreadSetCacheConfig");
+
+ function cudaGetLastError return driver_types_h.cudaError_t; -- cuda_runtime_api.h:581
+ pragma Import (C, cudaGetLastError, "cudaGetLastError");
+
+ function cudaPeekAtLastError return driver_types_h.cudaError_t; -- cuda_runtime_api.h:624
+ pragma Import (C, cudaPeekAtLastError, "cudaPeekAtLastError");
+
+ function cudaGetErrorString (arg1 : driver_types_h.cudaError_t) return Interfaces.C.Strings.chars_ptr; -- cuda_runtime_api.h:638
+ pragma Import (C, cudaGetErrorString, "cudaGetErrorString");
+
+ function cudaGetDeviceCount (arg1 : access int) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:668
+ pragma Import (C, cudaGetDeviceCount, "cudaGetDeviceCount");
+
+ function cudaGetDeviceProperties (arg1 : access driver_types_h.cudaDeviceProp; arg2 : int) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:829
+ pragma Import (C, cudaGetDeviceProperties, "cudaGetDeviceProperties");
+
+ function cudaChooseDevice (arg1 : access int; arg2 : System.Address) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:848
+ pragma Import (C, cudaChooseDevice, "cudaChooseDevice");
+
+ function cudaSetDevice (arg1 : int) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:881
+ pragma Import (C, cudaSetDevice, "cudaSetDevice");
+
+ function cudaGetDevice (arg1 : access int) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:898
+ pragma Import (C, cudaGetDevice, "cudaGetDevice");
+
+ function cudaSetValidDevices (arg1 : access int; arg2 : int) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:927
+ pragma Import (C, cudaSetValidDevices, "cudaSetValidDevices");
+
+ function cudaSetDeviceFlags (arg1 : unsigned) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:987
+ pragma Import (C, cudaSetDeviceFlags, "cudaSetDeviceFlags");
+
+ function cudaStreamCreate (arg1 : System.Address) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1013
+ pragma Import (C, cudaStreamCreate, "cudaStreamCreate");
+
+ function cudaStreamDestroy (arg1 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1034
+ pragma Import (C, cudaStreamDestroy, "cudaStreamDestroy");
+
+ function cudaStreamWaitEvent
+ (arg1 : driver_types_h.cudaStream_t;
+ arg2 : driver_types_h.cudaEvent_t;
+ arg3 : unsigned) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1070
+ pragma Import (C, cudaStreamWaitEvent, "cudaStreamWaitEvent");
+
+ function cudaStreamSynchronize (arg1 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1089
+ pragma Import (C, cudaStreamSynchronize, "cudaStreamSynchronize");
+
+ function cudaStreamQuery (arg1 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1107
+ pragma Import (C, cudaStreamQuery, "cudaStreamQuery");
+
+ function cudaEventCreate (arg1 : System.Address) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1139
+ pragma Import (C, cudaEventCreate, "cudaEventCreate");
+
+ function cudaEventCreateWithFlags (arg1 : System.Address; arg2 : unsigned) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1170
+ pragma Import (C, cudaEventCreateWithFlags, "cudaEventCreateWithFlags");
+
+ function cudaEventRecord (arg1 : driver_types_h.cudaEvent_t; arg2 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1203
+ pragma Import (C, cudaEventRecord, "cudaEventRecord");
+
+ function cudaEventQuery (arg1 : driver_types_h.cudaEvent_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1232
+ pragma Import (C, cudaEventQuery, "cudaEventQuery");
+
+ function cudaEventSynchronize (arg1 : driver_types_h.cudaEvent_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1264
+ pragma Import (C, cudaEventSynchronize, "cudaEventSynchronize");
+
+ function cudaEventDestroy (arg1 : driver_types_h.cudaEvent_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1289
+ pragma Import (C, cudaEventDestroy, "cudaEventDestroy");
+
+ function cudaEventElapsedTime
+ (arg1 : access float;
+ arg2 : driver_types_h.cudaEvent_t;
+ arg3 : driver_types_h.cudaEvent_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1330
+ pragma Import (C, cudaEventElapsedTime, "cudaEventElapsedTime");
+
+ function cudaConfigureCall
+ (arg1 : vector_types_h.dim3;
+ arg2 : vector_types_h.dim3;
+ arg3 : stddef_h.size_t;
+ arg4 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1369
+ pragma Import (C, cudaConfigureCall, "cudaConfigureCall");
+
+ function cudaSetupArgument
+ (arg1 : System.Address;
+ arg2 : stddef_h.size_t;
+ arg3 : stddef_h.size_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1396
+ pragma Import (C, cudaSetupArgument, "cudaSetupArgument");
+
+ function cudaFuncSetCacheConfig (arg1 : Interfaces.C.Strings.chars_ptr; arg2 : driver_types_h.cudaFuncCache) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1442
+ pragma Import (C, cudaFuncSetCacheConfig, "cudaFuncSetCacheConfig");
+
+ function cudaLaunch (arg1 : Interfaces.C.Strings.chars_ptr) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1477
+ pragma Import (C, cudaLaunch, "cudaLaunch");
+
+ function cudaFuncGetAttributes (arg1 : access driver_types_h.cudaFuncAttributes; arg2 : Interfaces.C.Strings.chars_ptr) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1510
+ pragma Import (C, cudaFuncGetAttributes, "cudaFuncGetAttributes");
+
+ function cudaSetDoubleForDevice (arg1 : access double) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1532
+ pragma Import (C, cudaSetDoubleForDevice, "cudaSetDoubleForDevice");
+
+ function cudaSetDoubleForHost (arg1 : access double) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1554
+ pragma Import (C, cudaSetDoubleForHost, "cudaSetDoubleForHost");
+
+ function cudaMalloc (arg1 : System.Address; arg2 : stddef_h.size_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1586
+ pragma Import (C, cudaMalloc, "cudaMalloc");
+
+ function cudaMallocHost (arg1 : System.Address; arg2 : stddef_h.size_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1615
+ pragma Import (C, cudaMallocHost, "cudaMallocHost");
+
+ function cudaMallocPitch
+ (arg1 : System.Address;
+ arg2 : access stddef_h.size_t;
+ arg3 : stddef_h.size_t;
+ arg4 : stddef_h.size_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1654
+ pragma Import (C, cudaMallocPitch, "cudaMallocPitch");
+
+ function cudaMallocArray
+ (arg1 : System.Address;
+ arg2 : System.Address;
+ arg3 : stddef_h.size_t;
+ arg4 : stddef_h.size_t;
+ arg5 : unsigned) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1693
+ pragma Import (C, cudaMallocArray, "cudaMallocArray");
+
+ function cudaFree (arg1 : System.Address) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1717
+ pragma Import (C, cudaFree, "cudaFree");
+
+ function cudaFreeHost (arg1 : System.Address) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1737
+ pragma Import (C, cudaFreeHost, "cudaFreeHost");
+
+ function cudaFreeArray (arg1 : System.Address) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1759
+ pragma Import (C, cudaFreeArray, "cudaFreeArray");
+
+ function cudaHostAlloc
+ (arg1 : System.Address;
+ arg2 : stddef_h.size_t;
+ arg3 : unsigned) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1818
+ pragma Import (C, cudaHostAlloc, "cudaHostAlloc");
+
+ function cudaHostRegister
+ (arg1 : System.Address;
+ arg2 : stddef_h.size_t;
+ arg3 : unsigned) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1874
+ pragma Import (C, cudaHostRegister, "cudaHostRegister");
+
+ function cudaHostUnregister (arg1 : System.Address) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1893
+ pragma Import (C, cudaHostUnregister, "cudaHostUnregister");
+
+ function cudaHostGetDevicePointer
+ (arg1 : System.Address;
+ arg2 : System.Address;
+ arg3 : unsigned) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1920
+ pragma Import (C, cudaHostGetDevicePointer, "cudaHostGetDevicePointer");
+
+ function cudaHostGetFlags (arg1 : access unsigned; arg2 : System.Address) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1939
+ pragma Import (C, cudaHostGetFlags, "cudaHostGetFlags");
+
+ function cudaMalloc3D (arg1 : access driver_types_h.cudaPitchedPtr; arg2 : driver_types_h.cudaExtent) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:1974
+ pragma Import (C, cudaMalloc3D, "cudaMalloc3D");
+
+ function cudaMalloc3DArray
+ (arg1 : System.Address;
+ arg2 : System.Address;
+ arg3 : driver_types_h.cudaExtent;
+ arg4 : unsigned) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2035
+ pragma Import (C, cudaMalloc3DArray, "cudaMalloc3DArray");
+
+ function cudaMemcpy3D (arg1 : System.Address) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2132
+ pragma Import (C, cudaMemcpy3D, "cudaMemcpy3D");
+
+ function cudaMemcpy3DPeer (arg1 : System.Address) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2159
+ pragma Import (C, cudaMemcpy3DPeer, "cudaMemcpy3DPeer");
+
+ function cudaMemcpy3DAsync (arg1 : System.Address; arg2 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2264
+ pragma Import (C, cudaMemcpy3DAsync, "cudaMemcpy3DAsync");
+
+ function cudaMemcpy3DPeerAsync (arg1 : System.Address; arg2 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2285
+ pragma Import (C, cudaMemcpy3DPeerAsync, "cudaMemcpy3DPeerAsync");
+
+ function cudaMemGetInfo (arg1 : access stddef_h.size_t; arg2 : access stddef_h.size_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2304
+ pragma Import (C, cudaMemGetInfo, "cudaMemGetInfo");
+
+ function cudaMemcpy
+ (arg1 : System.Address;
+ arg2 : System.Address;
+ arg3 : stddef_h.size_t;
+ arg4 : driver_types_h.cudaMemcpyKind) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2337
+ pragma Import (C, cudaMemcpy, "cudaMemcpy");
+
+ function cudaMemcpyPeer
+ (arg1 : System.Address;
+ arg2 : int;
+ arg3 : System.Address;
+ arg4 : int;
+ arg5 : stddef_h.size_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2368
+ pragma Import (C, cudaMemcpyPeer, "cudaMemcpyPeer");
+
+ function cudaMemcpyToArray
+ (arg1 : System.Address;
+ arg2 : stddef_h.size_t;
+ arg3 : stddef_h.size_t;
+ arg4 : System.Address;
+ arg5 : stddef_h.size_t;
+ arg6 : driver_types_h.cudaMemcpyKind) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2401
+ pragma Import (C, cudaMemcpyToArray, "cudaMemcpyToArray");
+
+ function cudaMemcpyFromArray
+ (arg1 : System.Address;
+ arg2 : System.Address;
+ arg3 : stddef_h.size_t;
+ arg4 : stddef_h.size_t;
+ arg5 : stddef_h.size_t;
+ arg6 : driver_types_h.cudaMemcpyKind) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2434
+ pragma Import (C, cudaMemcpyFromArray, "cudaMemcpyFromArray");
+
+ function cudaMemcpyArrayToArray
+ (arg1 : System.Address;
+ arg2 : stddef_h.size_t;
+ arg3 : stddef_h.size_t;
+ arg4 : System.Address;
+ arg5 : stddef_h.size_t;
+ arg6 : stddef_h.size_t;
+ arg7 : stddef_h.size_t;
+ arg8 : driver_types_h.cudaMemcpyKind) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2469
+ pragma Import (C, cudaMemcpyArrayToArray, "cudaMemcpyArrayToArray");
+
+ function cudaMemcpy2D
+ (arg1 : System.Address;
+ arg2 : stddef_h.size_t;
+ arg3 : System.Address;
+ arg4 : stddef_h.size_t;
+ arg5 : stddef_h.size_t;
+ arg6 : stddef_h.size_t;
+ arg7 : driver_types_h.cudaMemcpyKind) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2511
+ pragma Import (C, cudaMemcpy2D, "cudaMemcpy2D");
+
+ function cudaMemcpy2DToArray
+ (arg1 : System.Address;
+ arg2 : stddef_h.size_t;
+ arg3 : stddef_h.size_t;
+ arg4 : System.Address;
+ arg5 : stddef_h.size_t;
+ arg6 : stddef_h.size_t;
+ arg7 : stddef_h.size_t;
+ arg8 : driver_types_h.cudaMemcpyKind) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2552
+ pragma Import (C, cudaMemcpy2DToArray, "cudaMemcpy2DToArray");
+
+ function cudaMemcpy2DFromArray
+ (arg1 : System.Address;
+ arg2 : stddef_h.size_t;
+ arg3 : System.Address;
+ arg4 : stddef_h.size_t;
+ arg5 : stddef_h.size_t;
+ arg6 : stddef_h.size_t;
+ arg7 : stddef_h.size_t;
+ arg8 : driver_types_h.cudaMemcpyKind) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2593
+ pragma Import (C, cudaMemcpy2DFromArray, "cudaMemcpy2DFromArray");
+
+ function cudaMemcpy2DArrayToArray
+ (arg1 : System.Address;
+ arg2 : stddef_h.size_t;
+ arg3 : stddef_h.size_t;
+ arg4 : System.Address;
+ arg5 : stddef_h.size_t;
+ arg6 : stddef_h.size_t;
+ arg7 : stddef_h.size_t;
+ arg8 : stddef_h.size_t;
+ arg9 : driver_types_h.cudaMemcpyKind) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2632
+ pragma Import (C, cudaMemcpy2DArrayToArray, "cudaMemcpy2DArrayToArray");
+
+ function cudaMemcpyToSymbol
+ (arg1 : Interfaces.C.Strings.chars_ptr;
+ arg2 : System.Address;
+ arg3 : stddef_h.size_t;
+ arg4 : stddef_h.size_t;
+ arg5 : driver_types_h.cudaMemcpyKind) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2667
+ pragma Import (C, cudaMemcpyToSymbol, "cudaMemcpyToSymbol");
+
+ function cudaMemcpyFromSymbol
+ (arg1 : System.Address;
+ arg2 : Interfaces.C.Strings.chars_ptr;
+ arg3 : stddef_h.size_t;
+ arg4 : stddef_h.size_t;
+ arg5 : driver_types_h.cudaMemcpyKind) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2701
+ pragma Import (C, cudaMemcpyFromSymbol, "cudaMemcpyFromSymbol");
+
+ function cudaMemcpyAsync
+ (arg1 : System.Address;
+ arg2 : System.Address;
+ arg3 : stddef_h.size_t;
+ arg4 : driver_types_h.cudaMemcpyKind;
+ arg5 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2744
+ pragma Import (C, cudaMemcpyAsync, "cudaMemcpyAsync");
+
+ function cudaMemcpyPeerAsync
+ (arg1 : System.Address;
+ arg2 : int;
+ arg3 : System.Address;
+ arg4 : int;
+ arg5 : stddef_h.size_t;
+ arg6 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2774
+ pragma Import (C, cudaMemcpyPeerAsync, "cudaMemcpyPeerAsync");
+
+ function cudaMemcpyToArrayAsync
+ (arg1 : System.Address;
+ arg2 : stddef_h.size_t;
+ arg3 : stddef_h.size_t;
+ arg4 : System.Address;
+ arg5 : stddef_h.size_t;
+ arg6 : driver_types_h.cudaMemcpyKind;
+ arg7 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2816
+ pragma Import (C, cudaMemcpyToArrayAsync, "cudaMemcpyToArrayAsync");
+
+ function cudaMemcpyFromArrayAsync
+ (arg1 : System.Address;
+ arg2 : System.Address;
+ arg3 : stddef_h.size_t;
+ arg4 : stddef_h.size_t;
+ arg5 : stddef_h.size_t;
+ arg6 : driver_types_h.cudaMemcpyKind;
+ arg7 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2858
+ pragma Import (C, cudaMemcpyFromArrayAsync, "cudaMemcpyFromArrayAsync");
+
+ function cudaMemcpy2DAsync
+ (arg1 : System.Address;
+ arg2 : stddef_h.size_t;
+ arg3 : System.Address;
+ arg4 : stddef_h.size_t;
+ arg5 : stddef_h.size_t;
+ arg6 : stddef_h.size_t;
+ arg7 : driver_types_h.cudaMemcpyKind;
+ arg8 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2909
+ pragma Import (C, cudaMemcpy2DAsync, "cudaMemcpy2DAsync");
+
+ function cudaMemcpy2DToArrayAsync
+ (arg1 : System.Address;
+ arg2 : stddef_h.size_t;
+ arg3 : stddef_h.size_t;
+ arg4 : System.Address;
+ arg5 : stddef_h.size_t;
+ arg6 : stddef_h.size_t;
+ arg7 : stddef_h.size_t;
+ arg8 : driver_types_h.cudaMemcpyKind;
+ arg9 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:2959
+ pragma Import (C, cudaMemcpy2DToArrayAsync, "cudaMemcpy2DToArrayAsync");
+
+ function cudaMemcpy2DFromArrayAsync
+ (arg1 : System.Address;
+ arg2 : stddef_h.size_t;
+ arg3 : System.Address;
+ arg4 : stddef_h.size_t;
+ arg5 : stddef_h.size_t;
+ arg6 : stddef_h.size_t;
+ arg7 : stddef_h.size_t;
+ arg8 : driver_types_h.cudaMemcpyKind;
+ arg9 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3009
+ pragma Import (C, cudaMemcpy2DFromArrayAsync, "cudaMemcpy2DFromArrayAsync");
+
+ function cudaMemcpyToSymbolAsync
+ (arg1 : Interfaces.C.Strings.chars_ptr;
+ arg2 : System.Address;
+ arg3 : stddef_h.size_t;
+ arg4 : stddef_h.size_t;
+ arg5 : driver_types_h.cudaMemcpyKind;
+ arg6 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3053
+ pragma Import (C, cudaMemcpyToSymbolAsync, "cudaMemcpyToSymbolAsync");
+
+ function cudaMemcpyFromSymbolAsync
+ (arg1 : System.Address;
+ arg2 : Interfaces.C.Strings.chars_ptr;
+ arg3 : stddef_h.size_t;
+ arg4 : stddef_h.size_t;
+ arg5 : driver_types_h.cudaMemcpyKind;
+ arg6 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3096
+ pragma Import (C, cudaMemcpyFromSymbolAsync, "cudaMemcpyFromSymbolAsync");
+
+ function cudaMemset
+ (arg1 : System.Address;
+ arg2 : int;
+ arg3 : stddef_h.size_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3118
+ pragma Import (C, cudaMemset, "cudaMemset");
+
+ function cudaMemset2D
+ (arg1 : System.Address;
+ arg2 : stddef_h.size_t;
+ arg3 : int;
+ arg4 : stddef_h.size_t;
+ arg5 : stddef_h.size_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3144
+ pragma Import (C, cudaMemset2D, "cudaMemset2D");
+
+ function cudaMemset3D
+ (arg1 : driver_types_h.cudaPitchedPtr;
+ arg2 : int;
+ arg3 : driver_types_h.cudaExtent) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3183
+ pragma Import (C, cudaMemset3D, "cudaMemset3D");
+
+ function cudaMemsetAsync
+ (arg1 : System.Address;
+ arg2 : int;
+ arg3 : stddef_h.size_t;
+ arg4 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3210
+ pragma Import (C, cudaMemsetAsync, "cudaMemsetAsync");
+
+ function cudaMemset2DAsync
+ (arg1 : System.Address;
+ arg2 : stddef_h.size_t;
+ arg3 : int;
+ arg4 : stddef_h.size_t;
+ arg5 : stddef_h.size_t;
+ arg6 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3242
+ pragma Import (C, cudaMemset2DAsync, "cudaMemset2DAsync");
+
+ function cudaMemset3DAsync
+ (arg1 : driver_types_h.cudaPitchedPtr;
+ arg2 : int;
+ arg3 : driver_types_h.cudaExtent;
+ arg4 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3287
+ pragma Import (C, cudaMemset3DAsync, "cudaMemset3DAsync");
+
+ function cudaGetSymbolAddress (arg1 : System.Address; arg2 : Interfaces.C.Strings.chars_ptr) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3314
+ pragma Import (C, cudaGetSymbolAddress, "cudaGetSymbolAddress");
+
+ function cudaGetSymbolSize (arg1 : access stddef_h.size_t; arg2 : Interfaces.C.Strings.chars_ptr) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3337
+ pragma Import (C, cudaGetSymbolSize, "cudaGetSymbolSize");
+
+ function cudaPointerGetAttributes (arg1 : access driver_types_h.cudaPointerAttributes; arg2 : System.Address) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3482
+ pragma Import (C, cudaPointerGetAttributes, "cudaPointerGetAttributes");
+
+ function cudaDeviceCanAccessPeer
+ (arg1 : access int;
+ arg2 : int;
+ arg3 : int) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3516
+ pragma Import (C, cudaDeviceCanAccessPeer, "cudaDeviceCanAccessPeer");
+
+ function cudaDeviceEnablePeerAccess (arg1 : int; arg2 : unsigned) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3557
+ pragma Import (C, cudaDeviceEnablePeerAccess, "cudaDeviceEnablePeerAccess");
+
+ function cudaDeviceDisablePeerAccess (arg1 : int) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3582
+ pragma Import (C, cudaDeviceDisablePeerAccess, "cudaDeviceDisablePeerAccess");
+
+ function cudaGraphicsUnregisterResource (arg1 : driver_types_h.cudaGraphicsResource_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3628
+ pragma Import (C, cudaGraphicsUnregisterResource, "cudaGraphicsUnregisterResource");
+
+ function cudaGraphicsResourceSetMapFlags (arg1 : driver_types_h.cudaGraphicsResource_t; arg2 : unsigned) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3660
+ pragma Import (C, cudaGraphicsResourceSetMapFlags, "cudaGraphicsResourceSetMapFlags");
+
+ function cudaGraphicsMapResources
+ (arg1 : int;
+ arg2 : System.Address;
+ arg3 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3695
+ pragma Import (C, cudaGraphicsMapResources, "cudaGraphicsMapResources");
+
+ function cudaGraphicsUnmapResources
+ (arg1 : int;
+ arg2 : System.Address;
+ arg3 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3726
+ pragma Import (C, cudaGraphicsUnmapResources, "cudaGraphicsUnmapResources");
+
+ function cudaGraphicsResourceGetMappedPointer
+ (arg1 : System.Address;
+ arg2 : access stddef_h.size_t;
+ arg3 : driver_types_h.cudaGraphicsResource_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3755
+ pragma Import (C, cudaGraphicsResourceGetMappedPointer, "cudaGraphicsResourceGetMappedPointer");
+
+ function cudaGraphicsSubResourceGetMappedArray
+ (arg1 : System.Address;
+ arg2 : driver_types_h.cudaGraphicsResource_t;
+ arg3 : unsigned;
+ arg4 : unsigned) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3789
+ pragma Import (C, cudaGraphicsSubResourceGetMappedArray, "cudaGraphicsSubResourceGetMappedArray");
+
+ function cudaGetChannelDesc (arg1 : access driver_types_h.cudaChannelFormatDesc; arg2 : System.Address) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3822
+ pragma Import (C, cudaGetChannelDesc, "cudaGetChannelDesc");
+
+ function cudaCreateChannelDesc
+ (arg1 : int;
+ arg2 : int;
+ arg3 : int;
+ arg4 : int;
+ arg5 : driver_types_h.cudaChannelFormatKind) return driver_types_h.cudaChannelFormatDesc; -- cuda_runtime_api.h:3857
+ pragma Import (C, cudaCreateChannelDesc, "cudaCreateChannelDesc");
+
+ function cudaBindTexture
+ (arg1 : access stddef_h.size_t;
+ arg2 : System.Address;
+ arg3 : System.Address;
+ arg4 : System.Address;
+ arg5 : stddef_h.size_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3899
+ pragma Import (C, cudaBindTexture, "cudaBindTexture");
+
+ function cudaBindTexture2D
+ (arg1 : access stddef_h.size_t;
+ arg2 : System.Address;
+ arg3 : System.Address;
+ arg4 : System.Address;
+ arg5 : stddef_h.size_t;
+ arg6 : stddef_h.size_t;
+ arg7 : stddef_h.size_t) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3942
+ pragma Import (C, cudaBindTexture2D, "cudaBindTexture2D");
+
+ function cudaBindTextureToArray
+ (arg1 : System.Address;
+ arg2 : System.Address;
+ arg3 : System.Address) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3970
+ pragma Import (C, cudaBindTextureToArray, "cudaBindTextureToArray");
+
+ function cudaUnbindTexture (arg1 : System.Address) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:3991
+ pragma Import (C, cudaUnbindTexture, "cudaUnbindTexture");
+
+ function cudaGetTextureAlignmentOffset (arg1 : access stddef_h.size_t; arg2 : System.Address) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:4016
+ pragma Import (C, cudaGetTextureAlignmentOffset, "cudaGetTextureAlignmentOffset");
+
+ function cudaGetTextureReference (arg1 : System.Address; arg2 : Interfaces.C.Strings.chars_ptr) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:4040
+ pragma Import (C, cudaGetTextureReference, "cudaGetTextureReference");
+
+ function cudaBindSurfaceToArray
+ (arg1 : System.Address;
+ arg2 : System.Address;
+ arg3 : System.Address) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:4073
+ pragma Import (C, cudaBindSurfaceToArray, "cudaBindSurfaceToArray");
+
+ function cudaGetSurfaceReference (arg1 : System.Address; arg2 : Interfaces.C.Strings.chars_ptr) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:4091
+ pragma Import (C, cudaGetSurfaceReference, "cudaGetSurfaceReference");
+
+ function cudaDriverGetVersion (arg1 : access int) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:4118
+ pragma Import (C, cudaDriverGetVersion, "cudaDriverGetVersion");
+
+ function cudaRuntimeGetVersion (arg1 : access int) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:4135
+ pragma Import (C, cudaRuntimeGetVersion, "cudaRuntimeGetVersion");
+
+ function cudaGetExportTable (arg1 : System.Address; arg2 : System.Address) return driver_types_h.cudaError_t; -- cuda_runtime_api.h:4140
+ pragma Import (C, cudaGetExportTable, "cudaGetExportTable");
+
+end cuda_runtime_api_h;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+
+package device_types_h is
+
+ type cudaRoundMode is
+ (cudaRoundNearest,
+ cudaRoundZero,
+ cudaRoundPosInf,
+ cudaRoundMinInf);
+ pragma Convention (C, cudaRoundMode); -- device_types.h:60
+
+end device_types_h;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+with System;
+with stddef_h;
+with driver_types_h;
+
+package driver_functions_h is
+
+ function make_cudaPitchedPtr
+ (d : System.Address;
+ p : stddef_h.size_t;
+ xsz : stddef_h.size_t;
+ ysz : stddef_h.size_t) return driver_types_h.cudaPitchedPtr; -- driver_functions.h:79
+ pragma Import (C, make_cudaPitchedPtr, "make_cudaPitchedPtr");
+
+ function make_cudaPos
+ (x : stddef_h.size_t;
+ y : stddef_h.size_t;
+ z : stddef_h.size_t) return driver_types_h.cudaPos; -- driver_functions.h:106
+ pragma Import (C, make_cudaPos, "make_cudaPos");
+
+ function make_cudaExtent
+ (w : stddef_h.size_t;
+ h : stddef_h.size_t;
+ d : stddef_h.size_t) return driver_types_h.cudaExtent; -- driver_functions.h:132
+ pragma Import (C, make_cudaExtent, "make_cudaExtent");
+
+end driver_functions_h;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+with System;
+with stddef_h;
+
+package driver_types_h is
+
+
+ cudaHostAllocDefault : constant := 16#00#; -- driver_types.h:77
+ cudaHostAllocPortable : constant := 16#01#; -- driver_types.h:78
+ cudaHostAllocMapped : constant := 16#02#; -- driver_types.h:79
+ cudaHostAllocWriteCombined : constant := 16#04#; -- driver_types.h:80
+
+ cudaHostRegisterDefault : constant := 16#00#; -- driver_types.h:82
+ cudaHostRegisterPortable : constant := 16#01#; -- driver_types.h:83
+ cudaHostRegisterMapped : constant := 16#02#; -- driver_types.h:84
+
+ cudaPeerAccessDefault : constant := 16#00#; -- driver_types.h:86
+
+ cudaEventDefault : constant := 16#00#; -- driver_types.h:88
+ cudaEventBlockingSync : constant := 16#01#; -- driver_types.h:89
+ cudaEventDisableTiming : constant := 16#02#; -- driver_types.h:90
+
+ cudaDeviceScheduleAuto : constant := 16#00#; -- driver_types.h:92
+ cudaDeviceScheduleSpin : constant := 16#01#; -- driver_types.h:93
+ cudaDeviceScheduleYield : constant := 16#02#; -- driver_types.h:94
+ cudaDeviceScheduleBlockingSync : constant := 16#04#; -- driver_types.h:95
+ cudaDeviceBlockingSync : constant := 16#04#; -- driver_types.h:96
+ cudaDeviceMapHost : constant := 16#08#; -- driver_types.h:97
+ cudaDeviceLmemResizeToMax : constant := 16#10#; -- driver_types.h:98
+ cudaDeviceMask : constant := 16#1f#; -- driver_types.h:99
+
+ cudaArrayDefault : constant := 16#00#; -- driver_types.h:101
+ cudaArrayLayered : constant := 16#01#; -- driver_types.h:102
+ cudaArraySurfaceLoadStore : constant := 16#02#; -- driver_types.h:103
+ -- unsupported macro: cudaDevicePropDontCare { {'\0'}, 0, 0, 0, 0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0, -1, -1, 0, -1, 0, 0, 0, 0, 0, 0, {0, 0}, {0, 0, 0}, {0, 0}, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
+
+ subtype cudaError is unsigned;
+ cudaSuccess : constant cudaError := 0;
+ cudaErrorMissingConfiguration : constant cudaError := 1;
+ cudaErrorMemoryAllocation : constant cudaError := 2;
+ cudaErrorInitializationError : constant cudaError := 3;
+ cudaErrorLaunchFailure : constant cudaError := 4;
+ cudaErrorPriorLaunchFailure : constant cudaError := 5;
+ cudaErrorLaunchTimeout : constant cudaError := 6;
+ cudaErrorLaunchOutOfResources : constant cudaError := 7;
+ cudaErrorInvalidDeviceFunction : constant cudaError := 8;
+ cudaErrorInvalidConfiguration : constant cudaError := 9;
+ cudaErrorInvalidDevice : constant cudaError := 10;
+ cudaErrorInvalidValue : constant cudaError := 11;
+ cudaErrorInvalidPitchValue : constant cudaError := 12;
+ cudaErrorInvalidSymbol : constant cudaError := 13;
+ cudaErrorMapBufferObjectFailed : constant cudaError := 14;
+ cudaErrorUnmapBufferObjectFailed : constant cudaError := 15;
+ cudaErrorInvalidHostPointer : constant cudaError := 16;
+ cudaErrorInvalidDevicePointer : constant cudaError := 17;
+ cudaErrorInvalidTexture : constant cudaError := 18;
+ cudaErrorInvalidTextureBinding : constant cudaError := 19;
+ cudaErrorInvalidChannelDescriptor : constant cudaError := 20;
+ cudaErrorInvalidMemcpyDirection : constant cudaError := 21;
+ cudaErrorAddressOfConstant : constant cudaError := 22;
+ cudaErrorTextureFetchFailed : constant cudaError := 23;
+ cudaErrorTextureNotBound : constant cudaError := 24;
+ cudaErrorSynchronizationError : constant cudaError := 25;
+ cudaErrorInvalidFilterSetting : constant cudaError := 26;
+ cudaErrorInvalidNormSetting : constant cudaError := 27;
+ cudaErrorMixedDeviceExecution : constant cudaError := 28;
+ cudaErrorCudartUnloading : constant cudaError := 29;
+ cudaErrorUnknown : constant cudaError := 30;
+ cudaErrorNotYetImplemented : constant cudaError := 31;
+ cudaErrorMemoryValueTooLarge : constant cudaError := 32;
+ cudaErrorInvalidResourceHandle : constant cudaError := 33;
+ cudaErrorNotReady : constant cudaError := 34;
+ cudaErrorInsufficientDriver : constant cudaError := 35;
+ cudaErrorSetOnActiveProcess : constant cudaError := 36;
+ cudaErrorInvalidSurface : constant cudaError := 37;
+ cudaErrorNoDevice : constant cudaError := 38;
+ cudaErrorECCUncorrectable : constant cudaError := 39;
+ cudaErrorSharedObjectSymbolNotFound : constant cudaError := 40;
+ cudaErrorSharedObjectInitFailed : constant cudaError := 41;
+ cudaErrorUnsupportedLimit : constant cudaError := 42;
+ cudaErrorDuplicateVariableName : constant cudaError := 43;
+ cudaErrorDuplicateTextureName : constant cudaError := 44;
+ cudaErrorDuplicateSurfaceName : constant cudaError := 45;
+ cudaErrorDevicesUnavailable : constant cudaError := 46;
+ cudaErrorInvalidKernelImage : constant cudaError := 47;
+ cudaErrorNoKernelImageForDevice : constant cudaError := 48;
+ cudaErrorIncompatibleDriverContext : constant cudaError := 49;
+ cudaErrorPeerAccessAlreadyEnabled : constant cudaError := 50;
+ cudaErrorPeerAccessNotEnabled : constant cudaError := 51;
+ cudaErrorDeviceAlreadyInUse : constant cudaError := 54;
+ cudaErrorProfilerDisabled : constant cudaError := 55;
+ cudaErrorProfilerNotInitialized : constant cudaError := 56;
+ cudaErrorProfilerAlreadyStarted : constant cudaError := 57;
+ cudaErrorProfilerAlreadyStopped : constant cudaError := 58;
+ cudaErrorStartupFailure : constant cudaError := 127;
+ cudaErrorApiFailureBase : constant cudaError := 10000; -- driver_types.h:118
+
+ type cudaChannelFormatKind is
+ (cudaChannelFormatKindSigned,
+ cudaChannelFormatKindUnsigned,
+ cudaChannelFormatKindFloat,
+ cudaChannelFormatKindNone);
+ pragma Convention (C, cudaChannelFormatKind); -- driver_types.h:541
+
+ type cudaChannelFormatDesc is record
+ x : aliased int; -- driver_types.h:555
+ y : aliased int; -- driver_types.h:556
+ z : aliased int; -- driver_types.h:557
+ w : aliased int; -- driver_types.h:558
+ f : aliased cudaChannelFormatKind; -- driver_types.h:559
+ end record;
+ pragma Convention (C_Pass_By_Copy, cudaChannelFormatDesc); -- driver_types.h:553
+
+ -- skipped empty struct cudaArray
+
+ subtype cudaMemoryType is unsigned;
+ cudaMemoryTypeHost : constant cudaMemoryType := 1;
+ cudaMemoryTypeDevice : constant cudaMemoryType := 2; -- driver_types.h:572
+
+ type cudaMemcpyKind is
+ (cudaMemcpyHostToHost,
+ cudaMemcpyHostToDevice,
+ cudaMemcpyDeviceToHost,
+ cudaMemcpyDeviceToDevice,
+ cudaMemcpyDefault);
+ pragma Convention (C, cudaMemcpyKind); -- driver_types.h:582
+
+ type cudaPitchedPtr is record
+ ptr : System.Address; -- driver_types.h:598
+ pitch : aliased stddef_h.size_t; -- driver_types.h:599
+ xsize : aliased stddef_h.size_t; -- driver_types.h:600
+ ysize : aliased stddef_h.size_t; -- driver_types.h:601
+ end record;
+ pragma Convention (C_Pass_By_Copy, cudaPitchedPtr); -- driver_types.h:596
+
+ type cudaExtent is record
+ width : aliased stddef_h.size_t; -- driver_types.h:611
+ height : aliased stddef_h.size_t; -- driver_types.h:612
+ depth : aliased stddef_h.size_t; -- driver_types.h:613
+ end record;
+ pragma Convention (C_Pass_By_Copy, cudaExtent); -- driver_types.h:609
+
+ type cudaPos is record
+ x : aliased stddef_h.size_t; -- driver_types.h:623
+ y : aliased stddef_h.size_t; -- driver_types.h:624
+ z : aliased stddef_h.size_t; -- driver_types.h:625
+ end record;
+ pragma Convention (C_Pass_By_Copy, cudaPos); -- driver_types.h:621
+
+ type cudaMemcpy3DParms is record
+ srcArray : System.Address; -- driver_types.h:634
+ srcPos : aliased cudaPos; -- driver_types.h:635
+ srcPtr : aliased cudaPitchedPtr; -- driver_types.h:636
+ dstArray : System.Address; -- driver_types.h:638
+ dstPos : aliased cudaPos; -- driver_types.h:639
+ dstPtr : aliased cudaPitchedPtr; -- driver_types.h:640
+ extent : aliased cudaExtent; -- driver_types.h:642
+ kind : aliased cudaMemcpyKind; -- driver_types.h:643
+ end record;
+ pragma Convention (C_Pass_By_Copy, cudaMemcpy3DParms); -- driver_types.h:632
+
+ type cudaMemcpy3DPeerParms is record
+ srcArray : System.Address; -- driver_types.h:652
+ srcPos : aliased cudaPos; -- driver_types.h:653
+ srcPtr : aliased cudaPitchedPtr; -- driver_types.h:654
+ srcDevice : aliased int; -- driver_types.h:655
+ dstArray : System.Address; -- driver_types.h:657
+ dstPos : aliased cudaPos; -- driver_types.h:658
+ dstPtr : aliased cudaPitchedPtr; -- driver_types.h:659
+ dstDevice : aliased int; -- driver_types.h:660
+ extent : aliased cudaExtent; -- driver_types.h:662
+ end record;
+ pragma Convention (C_Pass_By_Copy, cudaMemcpy3DPeerParms); -- driver_types.h:650
+
+ -- skipped empty struct cudaGraphicsResource
+
+ subtype cudaGraphicsRegisterFlags is unsigned;
+ cudaGraphicsRegisterFlagsNone : constant cudaGraphicsRegisterFlags := 0;
+ cudaGraphicsRegisterFlagsReadOnly : constant cudaGraphicsRegisterFlags := 1;
+ cudaGraphicsRegisterFlagsWriteDiscard : constant cudaGraphicsRegisterFlags := 2;
+ cudaGraphicsRegisterFlagsSurfaceLoadStore : constant cudaGraphicsRegisterFlags := 4; -- driver_types.h:675
+
+ type cudaGraphicsMapFlags is
+ (cudaGraphicsMapFlagsNone,
+ cudaGraphicsMapFlagsReadOnly,
+ cudaGraphicsMapFlagsWriteDiscard);
+ pragma Convention (C, cudaGraphicsMapFlags); -- driver_types.h:687
+
+ type cudaGraphicsCubeFace is
+ (cudaGraphicsCubeFacePositiveX,
+ cudaGraphicsCubeFaceNegativeX,
+ cudaGraphicsCubeFacePositiveY,
+ cudaGraphicsCubeFaceNegativeY,
+ cudaGraphicsCubeFacePositiveZ,
+ cudaGraphicsCubeFaceNegativeZ);
+ pragma Convention (C, cudaGraphicsCubeFace); -- driver_types.h:698
+
+ type cudaPointerAttributes is record
+ memoryType : aliased cudaMemoryType; -- driver_types.h:717
+ device : aliased int; -- driver_types.h:728
+ devicePointer : System.Address; -- driver_types.h:734
+ hostPointer : System.Address; -- driver_types.h:740
+ end record;
+ pragma Convention (C_Pass_By_Copy, cudaPointerAttributes); -- driver_types.h:711
+
+ type cudaFuncAttributes is record
+ sharedSizeBytes : aliased stddef_h.size_t; -- driver_types.h:754
+ constSizeBytes : aliased stddef_h.size_t; -- driver_types.h:760
+ localSizeBytes : aliased stddef_h.size_t; -- driver_types.h:765
+ maxThreadsPerBlock : aliased int; -- driver_types.h:772
+ numRegs : aliased int; -- driver_types.h:777
+ ptxVersion : aliased int; -- driver_types.h:784
+ binaryVersion : aliased int; -- driver_types.h:791
+ end record;
+ pragma Convention (C_Pass_By_Copy, cudaFuncAttributes); -- driver_types.h:747
+
+ type cudaFuncCache is
+ (cudaFuncCachePreferNone,
+ cudaFuncCachePreferShared,
+ cudaFuncCachePreferL1);
+ pragma Convention (C, cudaFuncCache); -- driver_types.h:798
+
+ type cudaComputeMode is
+ (cudaComputeModeDefault,
+ cudaComputeModeExclusive,
+ cudaComputeModeProhibited,
+ cudaComputeModeExclusiveProcess);
+ pragma Convention (C, cudaComputeMode); -- driver_types.h:809
+
+ type cudaLimit is
+ (cudaLimitStackSize,
+ cudaLimitPrintfFifoSize,
+ cudaLimitMallocHeapSize);
+ pragma Convention (C, cudaLimit); -- driver_types.h:821
+
+ type cudaOutputMode is
+ (cudaKeyValuePair,
+ cudaCSV);
+ pragma Convention (C, cudaOutputMode); -- driver_types.h:832
+
+ subtype anon621_anon623_array is Interfaces.C.char_array (0 .. 255);
+ type anon621_anon625_array is array (0 .. 2) of aliased int;
+ type anon621_anon629_array is array (0 .. 1) of aliased int;
+ type cudaDeviceProp is record
+ name : aliased anon621_anon623_array; -- driver_types.h:844
+ totalGlobalMem : aliased stddef_h.size_t; -- driver_types.h:845
+ sharedMemPerBlock : aliased stddef_h.size_t; -- driver_types.h:846
+ regsPerBlock : aliased int; -- driver_types.h:847
+ warpSize : aliased int; -- driver_types.h:848
+ memPitch : aliased stddef_h.size_t; -- driver_types.h:849
+ maxThreadsPerBlock : aliased int; -- driver_types.h:850
+ maxThreadsDim : aliased anon621_anon625_array; -- driver_types.h:851
+ maxGridSize : aliased anon621_anon625_array; -- driver_types.h:852
+ clockRate : aliased int; -- driver_types.h:853
+ totalConstMem : aliased stddef_h.size_t; -- driver_types.h:854
+ major : aliased int; -- driver_types.h:855
+ minor : aliased int; -- driver_types.h:856
+ textureAlignment : aliased stddef_h.size_t; -- driver_types.h:857
+ deviceOverlap : aliased int; -- driver_types.h:858
+ multiProcessorCount : aliased int; -- driver_types.h:859
+ kernelExecTimeoutEnabled : aliased int; -- driver_types.h:860
+ integrated : aliased int; -- driver_types.h:861
+ canMapHostMemory : aliased int; -- driver_types.h:862
+ computeMode : aliased int; -- driver_types.h:863
+ maxTexture1D : aliased int; -- driver_types.h:864
+ maxTexture2D : aliased anon621_anon629_array; -- driver_types.h:865
+ maxTexture3D : aliased anon621_anon625_array; -- driver_types.h:866
+ maxTexture1DLayered : aliased anon621_anon629_array; -- driver_types.h:867
+ maxTexture2DLayered : aliased anon621_anon625_array; -- driver_types.h:868
+ surfaceAlignment : aliased stddef_h.size_t; -- driver_types.h:869
+ concurrentKernels : aliased int; -- driver_types.h:870
+ ECCEnabled : aliased int; -- driver_types.h:871
+ pciBusID : aliased int; -- driver_types.h:872
+ pciDeviceID : aliased int; -- driver_types.h:873
+ pciDomainID : aliased int; -- driver_types.h:874
+ tccDriver : aliased int; -- driver_types.h:875
+ asyncEngineCount : aliased int; -- driver_types.h:876
+ unifiedAddressing : aliased int; -- driver_types.h:877
+ memoryClockRate : aliased int; -- driver_types.h:878
+ memoryBusWidth : aliased int; -- driver_types.h:879
+ l2CacheSize : aliased int; -- driver_types.h:880
+ maxThreadsPerMultiProcessor : aliased int; -- driver_types.h:881
+ end record;
+ pragma Convention (C_Pass_By_Copy, cudaDeviceProp); -- driver_types.h:842
+
+ subtype cudaError_t is cudaError;
+
+ -- skipped empty struct CUstream_st
+
+ type cudaStream_t is new System.Address; -- driver_types.h:942
+
+ -- skipped empty struct CUevent_st
+
+ type cudaEvent_t is new System.Address; -- driver_types.h:948
+
+ type cudaGraphicsResource_t is new System.Address; -- driver_types.h:954
+
+ -- skipped empty struct CUuuid_st
+
+ -- skipped empty struct cudaUUID_t
+
+ subtype cudaOutputMode_t is cudaOutputMode;
+
+end driver_types_h;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+
+package stddef_h is
+
+ -- unsupported macro: NULL ((void *)0)
+ -- arg-macro: procedure offsetof (TYPE, MEMBER)
+ -- __builtin_offsetof (TYPE, MEMBER)
+ subtype ptrdiff_t is int; -- /opt/gnat-2011-i686-gnu-linux-libc2.3-bin/bin/../lib/gcc/i686-pc-linux-gnu/4.5.3/include/stddef.h:149
+
+ subtype size_t is unsigned; -- /opt/gnat-2011-i686-gnu-linux-libc2.3-bin/bin/../lib/gcc/i686-pc-linux-gnu/4.5.3/include/stddef.h:211
+
+ subtype wchar_t is long; -- /opt/gnat-2011-i686-gnu-linux-libc2.3-bin/bin/../lib/gcc/i686-pc-linux-gnu/4.5.3/include/stddef.h:323
+
+end stddef_h;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+limited with bits_waitstatus_h;
+with Interfaces.C.Strings;
+with System;
+with Interfaces.C.Extensions;
+with stddef_h;
+with sys_types_h;
+
+package stdlib_h is
+
+ -- arg-macro: procedure WEXITSTATUS (status)
+ -- __WEXITSTATUS (__WAIT_INT (status))
+ -- arg-macro: procedure WTERMSIG (status)
+ -- __WTERMSIG (__WAIT_INT (status))
+ -- arg-macro: procedure WSTOPSIG (status)
+ -- __WSTOPSIG (__WAIT_INT (status))
+ -- arg-macro: procedure WIFEXITED (status)
+ -- __WIFEXITED (__WAIT_INT (status))
+ -- arg-macro: procedure WIFSIGNALED (status)
+ -- __WIFSIGNALED (__WAIT_INT (status))
+ -- arg-macro: procedure WIFSTOPPED (status)
+ -- __WIFSTOPPED (__WAIT_INT (status))
+ -- arg-macro: procedure WIFCONTINUED (status)
+ -- __WIFCONTINUED (__WAIT_INT (status))
+
+ RAND_MAX : constant := 2147483647; -- /usr/include/stdlib.h:129
+
+ EXIT_FAILURE : constant := 1; -- /usr/include/stdlib.h:134
+ EXIT_SUCCESS : constant := 0; -- /usr/include/stdlib.h:135
+ -- unsupported macro: MB_CUR_MAX (__ctype_get_mb_cur_max ())
+
+ type uu_WAIT_STATUS (discr : unsigned := 0) is record
+ case discr is
+ when 0 =>
+ uu_uptr : access bits_waitstatus_h.wait; -- /usr/include/stdlib.h:70
+ when others =>
+ uu_iptr : access int; -- /usr/include/stdlib.h:71
+ end case;
+ end record;
+ pragma Convention (C_Pass_By_Copy, uu_WAIT_STATUS);
+ pragma Unchecked_Union (uu_WAIT_STATUS); -- /usr/include/stdlib.h:72
+
+ type div_t is record
+ quot : aliased int; -- /usr/include/stdlib.h:100
+ c_rem : aliased int; -- /usr/include/stdlib.h:101
+ end record;
+ pragma Convention (C_Pass_By_Copy, div_t); -- /usr/include/stdlib.h:102
+
+ type ldiv_t is record
+ quot : aliased long; -- /usr/include/stdlib.h:108
+ c_rem : aliased long; -- /usr/include/stdlib.h:109
+ end record;
+ pragma Convention (C_Pass_By_Copy, ldiv_t); -- /usr/include/stdlib.h:110
+
+ type lldiv_t is record
+ quot : aliased Long_Long_Integer; -- /usr/include/stdlib.h:120
+ c_rem : aliased Long_Long_Integer; -- /usr/include/stdlib.h:121
+ end record;
+ pragma Convention (C_Pass_By_Copy, lldiv_t); -- /usr/include/stdlib.h:122
+
+ function atof (arg1 : Interfaces.C.Strings.chars_ptr) return double; -- /usr/include/stdlib.h:145
+ pragma Import (C, atof, "atof");
+
+ function atoi (arg1 : Interfaces.C.Strings.chars_ptr) return int; -- /usr/include/stdlib.h:148
+ pragma Import (C, atoi, "atoi");
+
+ function atol (arg1 : Interfaces.C.Strings.chars_ptr) return long; -- /usr/include/stdlib.h:151
+ pragma Import (C, atol, "atol");
+
+ function atoll (arg1 : Interfaces.C.Strings.chars_ptr) return Long_Long_Integer; -- /usr/include/stdlib.h:158
+ pragma Import (C, atoll, "atoll");
+
+ function strtod (arg1 : Interfaces.C.Strings.chars_ptr; arg2 : System.Address) return double; -- /usr/include/stdlib.h:165
+ pragma Import (C, strtod, "strtod");
+
+ function strtof (arg1 : Interfaces.C.Strings.chars_ptr; arg2 : System.Address) return float; -- /usr/include/stdlib.h:173
+ pragma Import (C, strtof, "strtof");
+
+ function strtold (arg1 : Interfaces.C.Strings.chars_ptr; arg2 : System.Address) return long_double; -- /usr/include/stdlib.h:176
+ pragma Import (C, strtold, "strtold");
+
+ function strtol
+ (arg1 : Interfaces.C.Strings.chars_ptr;
+ arg2 : System.Address;
+ arg3 : int) return long; -- /usr/include/stdlib.h:184
+ pragma Import (C, strtol, "strtol");
+
+ function strtoul
+ (arg1 : Interfaces.C.Strings.chars_ptr;
+ arg2 : System.Address;
+ arg3 : int) return unsigned_long; -- /usr/include/stdlib.h:188
+ pragma Import (C, strtoul, "strtoul");
+
+ function strtoq
+ (arg1 : Interfaces.C.Strings.chars_ptr;
+ arg2 : System.Address;
+ arg3 : int) return Long_Long_Integer; -- /usr/include/stdlib.h:196
+ pragma Import (C, strtoq, "strtoq");
+
+ function strtouq
+ (arg1 : Interfaces.C.Strings.chars_ptr;
+ arg2 : System.Address;
+ arg3 : int) return Extensions.unsigned_long_long; -- /usr/include/stdlib.h:201
+ pragma Import (C, strtouq, "strtouq");
+
+ function strtoll
+ (arg1 : Interfaces.C.Strings.chars_ptr;
+ arg2 : System.Address;
+ arg3 : int) return Long_Long_Integer; -- /usr/include/stdlib.h:210
+ pragma Import (C, strtoll, "strtoll");
+
+ function strtoull
+ (arg1 : Interfaces.C.Strings.chars_ptr;
+ arg2 : System.Address;
+ arg3 : int) return Extensions.unsigned_long_long; -- /usr/include/stdlib.h:215
+ pragma Import (C, strtoull, "strtoull");
+
+ function l64a (arg1 : long) return Interfaces.C.Strings.chars_ptr; -- /usr/include/stdlib.h:311
+ pragma Import (C, l64a, "l64a");
+
+ function a64l (arg1 : Interfaces.C.Strings.chars_ptr) return long; -- /usr/include/stdlib.h:314
+ pragma Import (C, a64l, "a64l");
+
+ function random return long; -- /usr/include/stdlib.h:327
+ pragma Import (C, random, "random");
+
+ procedure srandom (arg1 : unsigned); -- /usr/include/stdlib.h:330
+ pragma Import (C, srandom, "srandom");
+
+ function initstate
+ (arg1 : unsigned;
+ arg2 : Interfaces.C.Strings.chars_ptr;
+ arg3 : stddef_h.size_t) return Interfaces.C.Strings.chars_ptr; -- /usr/include/stdlib.h:336
+ pragma Import (C, initstate, "initstate");
+
+ function setstate (arg1 : Interfaces.C.Strings.chars_ptr) return Interfaces.C.Strings.chars_ptr; -- /usr/include/stdlib.h:341
+ pragma Import (C, setstate, "setstate");
+
+ type random_data is record
+ fptr : access sys_types_h.int32_t; -- /usr/include/stdlib.h:351
+ rptr : access sys_types_h.int32_t; -- /usr/include/stdlib.h:352
+ state : access sys_types_h.int32_t; -- /usr/include/stdlib.h:353
+ rand_type : aliased int; -- /usr/include/stdlib.h:354
+ rand_deg : aliased int; -- /usr/include/stdlib.h:355
+ rand_sep : aliased int; -- /usr/include/stdlib.h:356
+ end_ptr : access sys_types_h.int32_t; -- /usr/include/stdlib.h:357
+ end record;
+ pragma Convention (C_Pass_By_Copy, random_data); -- /usr/include/stdlib.h:349
+
+ function random_r (arg1 : access random_data; arg2 : access sys_types_h.int32_t) return int; -- /usr/include/stdlib.h:360
+ pragma Import (C, random_r, "random_r");
+
+ function srandom_r (arg1 : unsigned; arg2 : access random_data) return int; -- /usr/include/stdlib.h:363
+ pragma Import (C, srandom_r, "srandom_r");
+
+ function initstate_r
+ (arg1 : unsigned;
+ arg2 : Interfaces.C.Strings.chars_ptr;
+ arg3 : stddef_h.size_t;
+ arg4 : access random_data) return int; -- /usr/include/stdlib.h:366
+ pragma Import (C, initstate_r, "initstate_r");
+
+ function setstate_r (arg1 : Interfaces.C.Strings.chars_ptr; arg2 : access random_data) return int; -- /usr/include/stdlib.h:371
+ pragma Import (C, setstate_r, "setstate_r");
+
+ function rand return int; -- /usr/include/stdlib.h:380
+ pragma Import (C, rand, "rand");
+
+ procedure srand (arg1 : unsigned); -- /usr/include/stdlib.h:382
+ pragma Import (C, srand, "srand");
+
+ function rand_r (arg1 : access unsigned) return int; -- /usr/include/stdlib.h:387
+ pragma Import (C, rand_r, "rand_r");
+
+ function drand48 return double; -- /usr/include/stdlib.h:395
+ pragma Import (C, drand48, "drand48");
+
+ function erand48 (arg1 : access unsigned_short) return double; -- /usr/include/stdlib.h:396
+ pragma Import (C, erand48, "erand48");
+
+ function lrand48 return long; -- /usr/include/stdlib.h:399
+ pragma Import (C, lrand48, "lrand48");
+
+ function nrand48 (arg1 : access unsigned_short) return long; -- /usr/include/stdlib.h:400
+ pragma Import (C, nrand48, "nrand48");
+
+ function mrand48 return long; -- /usr/include/stdlib.h:404
+ pragma Import (C, mrand48, "mrand48");
+
+ function jrand48 (arg1 : access unsigned_short) return long; -- /usr/include/stdlib.h:405
+ pragma Import (C, jrand48, "jrand48");
+
+ procedure srand48 (arg1 : long); -- /usr/include/stdlib.h:409
+ pragma Import (C, srand48, "srand48");
+
+ function seed48 (arg1 : access unsigned_short) return access unsigned_short; -- /usr/include/stdlib.h:410
+ pragma Import (C, seed48, "seed48");
+
+ procedure lcong48 (arg1 : access unsigned_short); -- /usr/include/stdlib.h:412
+ pragma Import (C, lcong48, "lcong48");
+
+ type anon881_anon859_array is array (0 .. 2) of aliased unsigned_short;
+ type anon881_anon859_array is array (0 .. 2) of aliased unsigned_short;
+ type drand48_data is record
+ uu_x : aliased anon881_anon859_array; -- /usr/include/stdlib.h:420
+ uu_old_x : aliased anon881_anon859_array; -- /usr/include/stdlib.h:421
+ uu_c : aliased unsigned_short; -- /usr/include/stdlib.h:422
+ uu_init : aliased unsigned_short; -- /usr/include/stdlib.h:423
+ uu_a : aliased Extensions.unsigned_long_long; -- /usr/include/stdlib.h:424
+ end record;
+ pragma Convention (C_Pass_By_Copy, drand48_data); -- /usr/include/stdlib.h:418
+
+ function drand48_r (arg1 : access drand48_data; arg2 : access double) return int; -- /usr/include/stdlib.h:428
+ pragma Import (C, drand48_r, "drand48_r");
+
+ function erand48_r
+ (arg1 : access unsigned_short;
+ arg2 : access drand48_data;
+ arg3 : access double) return int; -- /usr/include/stdlib.h:430
+ pragma Import (C, erand48_r, "erand48_r");
+
+ function lrand48_r (arg1 : access drand48_data; arg2 : access long) return int; -- /usr/include/stdlib.h:435
+ pragma Import (C, lrand48_r, "lrand48_r");
+
+ function nrand48_r
+ (arg1 : access unsigned_short;
+ arg2 : access drand48_data;
+ arg3 : access long) return int; -- /usr/include/stdlib.h:438
+ pragma Import (C, nrand48_r, "nrand48_r");
+
+ function mrand48_r (arg1 : access drand48_data; arg2 : access long) return int; -- /usr/include/stdlib.h:444
+ pragma Import (C, mrand48_r, "mrand48_r");
+
+ function jrand48_r
+ (arg1 : access unsigned_short;
+ arg2 : access drand48_data;
+ arg3 : access long) return int; -- /usr/include/stdlib.h:447
+ pragma Import (C, jrand48_r, "jrand48_r");
+
+ function srand48_r (arg1 : long; arg2 : access drand48_data) return int; -- /usr/include/stdlib.h:453
+ pragma Import (C, srand48_r, "srand48_r");
+
+ function seed48_r (arg1 : access unsigned_short; arg2 : access drand48_data) return int; -- /usr/include/stdlib.h:456
+ pragma Import (C, seed48_r, "seed48_r");
+
+ function lcong48_r (arg1 : access unsigned_short; arg2 : access drand48_data) return int; -- /usr/include/stdlib.h:459
+ pragma Import (C, lcong48_r, "lcong48_r");
+
+ function malloc (arg1 : stddef_h.size_t) return System.Address; -- /usr/include/stdlib.h:471
+ pragma Import (C, malloc, "malloc");
+
+ function calloc (arg1 : stddef_h.size_t; arg2 : stddef_h.size_t) return System.Address; -- /usr/include/stdlib.h:473
+ pragma Import (C, calloc, "calloc");
+
+ function realloc (arg1 : System.Address; arg2 : stddef_h.size_t) return System.Address; -- /usr/include/stdlib.h:485
+ pragma Import (C, realloc, "realloc");
+
+ procedure free (arg1 : System.Address); -- /usr/include/stdlib.h:488
+ pragma Import (C, free, "free");
+
+ procedure cfree (arg1 : System.Address); -- /usr/include/stdlib.h:493
+ pragma Import (C, cfree, "cfree");
+
+ function valloc (arg1 : stddef_h.size_t) return System.Address; -- /usr/include/stdlib.h:503
+ pragma Import (C, valloc, "valloc");
+
+ function posix_memalign
+ (arg1 : System.Address;
+ arg2 : stddef_h.size_t;
+ arg3 : stddef_h.size_t) return int; -- /usr/include/stdlib.h:508
+ pragma Import (C, posix_memalign, "posix_memalign");
+
+ procedure c_abort; -- /usr/include/stdlib.h:514
+ pragma Import (C, c_abort, "abort");
+
+ function atexit (arg1 : access procedure) return int; -- /usr/include/stdlib.h:518
+ pragma Import (C, atexit, "atexit");
+
+ function on_exit (arg1 : access procedure (arg1 : int; arg2 : System.Address); arg2 : System.Address) return int; -- /usr/include/stdlib.h:536
+ pragma Import (C, on_exit, "on_exit");
+
+ procedure c_exit (arg1 : int); -- /usr/include/stdlib.h:544
+ pragma Import (C, c_exit, "exit");
+
+ function getenv (arg1 : Interfaces.C.Strings.chars_ptr) return Interfaces.C.Strings.chars_ptr; -- /usr/include/stdlib.h:567
+ pragma Import (C, getenv, "getenv");
+
+ function putenv (arg1 : Interfaces.C.Strings.chars_ptr) return int; -- /usr/include/stdlib.h:579
+ pragma Import (C, putenv, "putenv");
+
+ function setenv
+ (arg1 : Interfaces.C.Strings.chars_ptr;
+ arg2 : Interfaces.C.Strings.chars_ptr;
+ arg3 : int) return int; -- /usr/include/stdlib.h:585
+ pragma Import (C, setenv, "setenv");
+
+ function unsetenv (arg1 : Interfaces.C.Strings.chars_ptr) return int; -- /usr/include/stdlib.h:589
+ pragma Import (C, unsetenv, "unsetenv");
+
+ function clearenv return int; -- /usr/include/stdlib.h:596
+ pragma Import (C, clearenv, "clearenv");
+
+ function mktemp (arg1 : Interfaces.C.Strings.chars_ptr) return Interfaces.C.Strings.chars_ptr; -- /usr/include/stdlib.h:606
+ pragma Import (C, mktemp, "mktemp");
+
+ function mkstemp (arg1 : Interfaces.C.Strings.chars_ptr) return int; -- /usr/include/stdlib.h:620
+ pragma Import (C, mkstemp, "mkstemp");
+
+ function mkstemps (arg1 : Interfaces.C.Strings.chars_ptr; arg2 : int) return int; -- /usr/include/stdlib.h:642
+ pragma Import (C, mkstemps, "mkstemps");
+
+ function mkdtemp (arg1 : Interfaces.C.Strings.chars_ptr) return Interfaces.C.Strings.chars_ptr; -- /usr/include/stdlib.h:663
+ pragma Import (C, mkdtemp, "mkdtemp");
+
+ function c_system (arg1 : Interfaces.C.Strings.chars_ptr) return int; -- /usr/include/stdlib.h:717
+ pragma Import (C, c_system, "system");
+
+ function realpath (arg1 : Interfaces.C.Strings.chars_ptr; arg2 : Interfaces.C.Strings.chars_ptr) return Interfaces.C.Strings.chars_ptr; -- /usr/include/stdlib.h:734
+ pragma Import (C, realpath, "realpath");
+
+ type uu_compar_fn_t is access function (arg1 : System.Address; arg2 : System.Address) return int; -- /usr/include/stdlib.h:742
+
+ function bsearch
+ (arg1 : System.Address;
+ arg2 : System.Address;
+ arg3 : stddef_h.size_t;
+ arg4 : stddef_h.size_t;
+ arg5 : access function (arg1 : System.Address; arg2 : System.Address) return int) return System.Address; -- /usr/include/stdlib.h:755
+ pragma Import (C, bsearch, "bsearch");
+
+ procedure qsort
+ (arg1 : System.Address;
+ arg2 : stddef_h.size_t;
+ arg3 : stddef_h.size_t;
+ arg4 : access function (arg1 : System.Address; arg2 : System.Address) return int); -- /usr/include/stdlib.h:761
+ pragma Import (C, qsort, "qsort");
+
+ function c_abs (arg1 : int) return int; -- /usr/include/stdlib.h:771
+ pragma Import (C, c_abs, "abs");
+
+ function labs (arg1 : long) return long; -- /usr/include/stdlib.h:772
+ pragma Import (C, labs, "labs");
+
+ function llabs (arg1 : Long_Long_Integer) return Long_Long_Integer; -- /usr/include/stdlib.h:776
+ pragma Import (C, llabs, "llabs");
+
+ function div (arg1 : int; arg2 : int) return div_t; -- /usr/include/stdlib.h:785
+ pragma Import (C, div, "div");
+
+ function ldiv (arg1 : long; arg2 : long) return ldiv_t; -- /usr/include/stdlib.h:787
+ pragma Import (C, ldiv, "ldiv");
+
+ function lldiv (arg1 : Long_Long_Integer; arg2 : Long_Long_Integer) return lldiv_t; -- /usr/include/stdlib.h:793
+ pragma Import (C, lldiv, "lldiv");
+
+ function ecvt
+ (arg1 : double;
+ arg2 : int;
+ arg3 : access int;
+ arg4 : access int) return Interfaces.C.Strings.chars_ptr; -- /usr/include/stdlib.h:808
+ pragma Import (C, ecvt, "ecvt");
+
+ function fcvt
+ (arg1 : double;
+ arg2 : int;
+ arg3 : access int;
+ arg4 : access int) return Interfaces.C.Strings.chars_ptr; -- /usr/include/stdlib.h:814
+ pragma Import (C, fcvt, "fcvt");
+
+ function gcvt
+ (arg1 : double;
+ arg2 : int;
+ arg3 : Interfaces.C.Strings.chars_ptr) return Interfaces.C.Strings.chars_ptr; -- /usr/include/stdlib.h:820
+ pragma Import (C, gcvt, "gcvt");
+
+ function qecvt
+ (arg1 : long_double;
+ arg2 : int;
+ arg3 : access int;
+ arg4 : access int) return Interfaces.C.Strings.chars_ptr; -- /usr/include/stdlib.h:826
+ pragma Import (C, qecvt, "qecvt");
+
+ function qfcvt
+ (arg1 : long_double;
+ arg2 : int;
+ arg3 : access int;
+ arg4 : access int) return Interfaces.C.Strings.chars_ptr; -- /usr/include/stdlib.h:829
+ pragma Import (C, qfcvt, "qfcvt");
+
+ function qgcvt
+ (arg1 : long_double;
+ arg2 : int;
+ arg3 : Interfaces.C.Strings.chars_ptr) return Interfaces.C.Strings.chars_ptr; -- /usr/include/stdlib.h:832
+ pragma Import (C, qgcvt, "qgcvt");
+
+ function ecvt_r
+ (arg1 : double;
+ arg2 : int;
+ arg3 : access int;
+ arg4 : access int;
+ arg5 : Interfaces.C.Strings.chars_ptr;
+ arg6 : stddef_h.size_t) return int; -- /usr/include/stdlib.h:838
+ pragma Import (C, ecvt_r, "ecvt_r");
+
+ function fcvt_r
+ (arg1 : double;
+ arg2 : int;
+ arg3 : access int;
+ arg4 : access int;
+ arg5 : Interfaces.C.Strings.chars_ptr;
+ arg6 : stddef_h.size_t) return int; -- /usr/include/stdlib.h:841
+ pragma Import (C, fcvt_r, "fcvt_r");
+
+ function qecvt_r
+ (arg1 : long_double;
+ arg2 : int;
+ arg3 : access int;
+ arg4 : access int;
+ arg5 : Interfaces.C.Strings.chars_ptr;
+ arg6 : stddef_h.size_t) return int; -- /usr/include/stdlib.h:845
+ pragma Import (C, qecvt_r, "qecvt_r");
+
+ function qfcvt_r
+ (arg1 : long_double;
+ arg2 : int;
+ arg3 : access int;
+ arg4 : access int;
+ arg5 : Interfaces.C.Strings.chars_ptr;
+ arg6 : stddef_h.size_t) return int; -- /usr/include/stdlib.h:849
+ pragma Import (C, qfcvt_r, "qfcvt_r");
+
+ function mblen (arg1 : Interfaces.C.Strings.chars_ptr; arg2 : stddef_h.size_t) return int; -- /usr/include/stdlib.h:860
+ pragma Import (C, mblen, "mblen");
+
+ function mbtowc
+ (arg1 : access stddef_h.wchar_t;
+ arg2 : Interfaces.C.Strings.chars_ptr;
+ arg3 : stddef_h.size_t) return int; -- /usr/include/stdlib.h:863
+ pragma Import (C, mbtowc, "mbtowc");
+
+ function wctomb (arg1 : Interfaces.C.Strings.chars_ptr; arg2 : stddef_h.wchar_t) return int; -- /usr/include/stdlib.h:867
+ pragma Import (C, wctomb, "wctomb");
+
+ function mbstowcs
+ (arg1 : access stddef_h.wchar_t;
+ arg2 : Interfaces.C.Strings.chars_ptr;
+ arg3 : stddef_h.size_t) return stddef_h.size_t; -- /usr/include/stdlib.h:871
+ pragma Import (C, mbstowcs, "mbstowcs");
+
+ function wcstombs
+ (arg1 : Interfaces.C.Strings.chars_ptr;
+ arg2 : access stddef_h.wchar_t;
+ arg3 : stddef_h.size_t) return stddef_h.size_t; -- /usr/include/stdlib.h:874
+ pragma Import (C, wcstombs, "wcstombs");
+
+ function rpmatch (arg1 : Interfaces.C.Strings.chars_ptr) return int; -- /usr/include/stdlib.h:885
+ pragma Import (C, rpmatch, "rpmatch");
+
+ function getsubopt
+ (arg1 : System.Address;
+ arg2 : System.Address;
+ arg3 : System.Address) return int; -- /usr/include/stdlib.h:896
+ pragma Import (C, getsubopt, "getsubopt");
+
+ function getloadavg (arg1 : access double; arg2 : int) return int; -- /usr/include/stdlib.h:948
+ pragma Import (C, getloadavg, "getloadavg");
+
+end stdlib_h;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+with driver_types_h;
+
+package surface_types_h is
+
+ type cudaSurfaceBoundaryMode is
+ (cudaBoundaryModeZero,
+ cudaBoundaryModeClamp,
+ cudaBoundaryModeTrap);
+ pragma Convention (C, cudaSurfaceBoundaryMode); -- surface_types.h:77
+
+ type cudaSurfaceFormatMode is
+ (cudaFormatModeForced,
+ cudaFormatModeAuto);
+ pragma Convention (C, cudaSurfaceFormatMode); -- surface_types.h:88
+
+ type surfaceReference is record
+ channelDesc : aliased driver_types_h.cudaChannelFormatDesc; -- surface_types.h:103
+ end record;
+ pragma Convention (C_Pass_By_Copy, surfaceReference); -- surface_types.h:98
+
+end surface_types_h;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+with bits_sigset_h;
+with bits_types_h;
+limited with bits_time_h;
+with System;
+
+package sys_select_h is
+
+ -- unsupported macro: FD_SETSIZE __FD_SETSIZE
+ -- unsupported macro: NFDBITS __NFDBITS
+ -- arg-macro: procedure FD_SET (fd, fdsetp)
+ -- __FD_SET (fd, fdsetp)
+ -- arg-macro: procedure FD_CLR (fd, fdsetp)
+ -- __FD_CLR (fd, fdsetp)
+ -- arg-macro: procedure FD_ISSET (fd, fdsetp)
+ -- __FD_ISSET (fd, fdsetp)
+ -- arg-macro: procedure FD_ZERO (fdsetp)
+ -- __FD_ZERO (fdsetp)
+ subtype sigset_t is bits_sigset_h.uu_sigset_t; -- /usr/include/sys/select.h:38
+
+ subtype suseconds_t is bits_types_h.uu_suseconds_t; -- /usr/include/sys/select.h:49
+
+ subtype uu_fd_mask is long; -- /usr/include/sys/select.h:55
+
+ type fd_set_uu_fds_bits_array is array (0 .. 31) of aliased uu_fd_mask;
+ type fd_set is record
+ uu_fds_bits : aliased fd_set_uu_fds_bits_array; -- /usr/include/sys/select.h:75
+ end record;
+ pragma Convention (C_Pass_By_Copy, fd_set); -- /usr/include/sys/select.h:78
+
+ subtype fd_mask is uu_fd_mask; -- /usr/include/sys/select.h:85
+
+ function c_select
+ (arg1 : int;
+ arg2 : access fd_set;
+ arg3 : access fd_set;
+ arg4 : access fd_set;
+ arg5 : access bits_time_h.timeval) return int; -- /usr/include/sys/select.h:109
+ pragma Import (C, c_select, "select");
+
+ function pselect
+ (arg1 : int;
+ arg2 : access fd_set;
+ arg3 : access fd_set;
+ arg4 : access fd_set;
+ arg5 : System.Address;
+ arg6 : access constant bits_sigset_h.uu_sigset_t) return int; -- /usr/include/sys/select.h:121
+ pragma Import (C, pselect, "pselect");
+
+end sys_select_h;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+with Interfaces.C.Extensions;
+
+package sys_sysmacros_h is
+
+ -- arg-macro: procedure major (dev)
+ -- gnu_dev_major (dev)
+ -- arg-macro: procedure minor (dev)
+ -- gnu_dev_minor (dev)
+ -- arg-macro: procedure makedev (maj, min)
+ -- gnu_dev_makedev (maj, min)
+ function gnu_dev_major (arg1 : Extensions.unsigned_long_long) return unsigned; -- /usr/include/sys/sysmacros.h:31
+ pragma Import (C, gnu_dev_major, "gnu_dev_major");
+
+ function gnu_dev_minor (arg1 : Extensions.unsigned_long_long) return unsigned; -- /usr/include/sys/sysmacros.h:34
+ pragma Import (C, gnu_dev_minor, "gnu_dev_minor");
+
+ function gnu_dev_makedev (arg1 : unsigned; arg2 : unsigned) return Extensions.unsigned_long_long; -- /usr/include/sys/sysmacros.h:37
+ pragma Import (C, gnu_dev_makedev, "gnu_dev_makedev");
+
+end sys_sysmacros_h;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+with bits_types_h;
+with Interfaces.C.Extensions;
+
+package sys_types_h is
+
+ subtype u_char is bits_types_h.uu_u_char; -- /usr/include/sys/types.h:34
+
+ subtype u_short is bits_types_h.uu_u_short; -- /usr/include/sys/types.h:35
+
+ subtype u_int is bits_types_h.uu_u_int; -- /usr/include/sys/types.h:36
+
+ subtype u_long is bits_types_h.uu_u_long; -- /usr/include/sys/types.h:37
+
+ subtype quad_t is bits_types_h.uu_quad_t; -- /usr/include/sys/types.h:38
+
+ subtype u_quad_t is bits_types_h.uu_u_quad_t; -- /usr/include/sys/types.h:39
+
+ subtype fsid_t is bits_types_h.uu_fsid_t; -- /usr/include/sys/types.h:40
+
+ subtype loff_t is bits_types_h.uu_loff_t; -- /usr/include/sys/types.h:45
+
+ subtype ino_t is bits_types_h.uu_ino_t; -- /usr/include/sys/types.h:49
+
+ subtype dev_t is bits_types_h.uu_dev_t; -- /usr/include/sys/types.h:61
+
+ subtype gid_t is bits_types_h.uu_gid_t; -- /usr/include/sys/types.h:66
+
+ subtype mode_t is bits_types_h.uu_mode_t; -- /usr/include/sys/types.h:71
+
+ subtype nlink_t is bits_types_h.uu_nlink_t; -- /usr/include/sys/types.h:76
+
+ subtype uid_t is bits_types_h.uu_uid_t; -- /usr/include/sys/types.h:81
+
+ subtype off_t is bits_types_h.uu_off_t; -- /usr/include/sys/types.h:87
+
+ subtype pid_t is bits_types_h.uu_pid_t; -- /usr/include/sys/types.h:99
+
+ subtype id_t is bits_types_h.uu_id_t; -- /usr/include/sys/types.h:105
+
+ subtype ssize_t is bits_types_h.uu_ssize_t; -- /usr/include/sys/types.h:110
+
+ subtype daddr_t is bits_types_h.uu_daddr_t; -- /usr/include/sys/types.h:116
+
+ subtype caddr_t is bits_types_h.uu_caddr_t; -- /usr/include/sys/types.h:117
+
+ subtype key_t is bits_types_h.uu_key_t; -- /usr/include/sys/types.h:123
+
+ subtype ulong is unsigned_long; -- /usr/include/sys/types.h:151
+
+ subtype ushort is unsigned_short; -- /usr/include/sys/types.h:152
+
+ subtype uint is unsigned; -- /usr/include/sys/types.h:153
+
+ subtype int8_t is signed_char; -- /usr/include/sys/types.h:195
+
+ subtype int16_t is short; -- /usr/include/sys/types.h:196
+
+ subtype int32_t is int; -- /usr/include/sys/types.h:197
+
+ subtype int64_t is Long_Long_Integer; -- /usr/include/sys/types.h:198
+
+ subtype u_int8_t is unsigned_char; -- /usr/include/sys/types.h:201
+
+ subtype u_int16_t is unsigned_short; -- /usr/include/sys/types.h:202
+
+ subtype u_int32_t is unsigned; -- /usr/include/sys/types.h:203
+
+ subtype u_int64_t is Extensions.unsigned_long_long; -- /usr/include/sys/types.h:204
+
+ subtype register_t is int; -- /usr/include/sys/types.h:206
+
+ subtype blksize_t is bits_types_h.uu_blksize_t; -- /usr/include/sys/types.h:229
+
+ subtype blkcnt_t is bits_types_h.uu_blkcnt_t; -- /usr/include/sys/types.h:236
+
+ subtype fsblkcnt_t is bits_types_h.uu_fsblkcnt_t; -- /usr/include/sys/types.h:240
+
+ subtype fsfilcnt_t is bits_types_h.uu_fsfilcnt_t; -- /usr/include/sys/types.h:244
+
+end sys_types_h;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+with driver_types_h;
+
+package texture_types_h is
+
+
+ cudaTextureType1D : constant := 16#01#; -- texture_types.h:73
+ cudaTextureType2D : constant := 16#02#; -- texture_types.h:74
+ cudaTextureType3D : constant := 16#03#; -- texture_types.h:75
+ cudaTextureType1DLayered : constant := 16#F1#; -- texture_types.h:76
+ cudaTextureType2DLayered : constant := 16#F2#; -- texture_types.h:77
+
+ type cudaTextureAddressMode is
+ (cudaAddressModeWrap,
+ cudaAddressModeClamp,
+ cudaAddressModeMirror,
+ cudaAddressModeBorder);
+ pragma Convention (C, cudaTextureAddressMode); -- texture_types.h:83
+
+ type cudaTextureFilterMode is
+ (cudaFilterModePoint,
+ cudaFilterModeLinear);
+ pragma Convention (C, cudaTextureFilterMode); -- texture_types.h:95
+
+ type cudaTextureReadMode is
+ (cudaReadModeElementType,
+ cudaReadModeNormalizedFloat);
+ pragma Convention (C, cudaTextureReadMode); -- texture_types.h:105
+
+ type anon654_anon656_array is array (0 .. 2) of aliased cudaTextureAddressMode;
+ type anon654_anon659_array is array (0 .. 14) of aliased int;
+ type textureReference is record
+ normalized : aliased int; -- texture_types.h:120
+ filterMode : aliased cudaTextureFilterMode; -- texture_types.h:124
+ addressMode : aliased anon654_anon656_array; -- texture_types.h:128
+ channelDesc : aliased driver_types_h.cudaChannelFormatDesc; -- texture_types.h:132
+ sRGB : aliased int; -- texture_types.h:136
+ uu_cudaReserved : aliased anon654_anon659_array; -- texture_types.h:137
+ end record;
+ pragma Convention (C_Pass_By_Copy, textureReference); -- texture_types.h:115
+
+end texture_types_h;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+with bits_types_h;
+
+package time_h is
+
+ subtype clock_t is bits_types_h.uu_clock_t; -- /usr/include/time.h:60
+
+ subtype time_t is bits_types_h.uu_time_t; -- /usr/include/time.h:76
+
+ subtype clockid_t is bits_types_h.uu_clockid_t; -- /usr/include/time.h:92
+
+ subtype timer_t is bits_types_h.uu_timer_t; -- /usr/include/time.h:104
+
+ type timespec is record
+ tv_sec : aliased bits_types_h.uu_time_t; -- /usr/include/time.h:122
+ tv_nsec : aliased long; -- /usr/include/time.h:123
+ end record;
+ pragma Convention (C_Pass_By_Copy, timespec); -- /usr/include/time.h:120
+
+end time_h;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+with vector_types_h;
+with Interfaces.C.Extensions;
+
+package vector_functions_h is
+
+ function make_char1 (x : signed_char) return vector_types_h.char1; -- vector_functions.h:69
+ pragma Import (C, make_char1, "make_char1");
+
+ function make_uchar1 (x : unsigned_char) return vector_types_h.uchar1; -- vector_functions.h:74
+ pragma Import (C, make_uchar1, "make_uchar1");
+
+ function make_char2 (x : signed_char; y : signed_char) return vector_types_h.char2; -- vector_functions.h:79
+ pragma Import (C, make_char2, "make_char2");
+
+ function make_uchar2 (x : unsigned_char; y : unsigned_char) return vector_types_h.uchar2; -- vector_functions.h:84
+ pragma Import (C, make_uchar2, "make_uchar2");
+
+ function make_char3
+ (x : signed_char;
+ y : signed_char;
+ z : signed_char) return vector_types_h.char3; -- vector_functions.h:89
+ pragma Import (C, make_char3, "make_char3");
+
+ function make_uchar3
+ (x : unsigned_char;
+ y : unsigned_char;
+ z : unsigned_char) return vector_types_h.uchar3; -- vector_functions.h:94
+ pragma Import (C, make_uchar3, "make_uchar3");
+
+ function make_char4
+ (x : signed_char;
+ y : signed_char;
+ z : signed_char;
+ w : signed_char) return vector_types_h.char4; -- vector_functions.h:99
+ pragma Import (C, make_char4, "make_char4");
+
+ function make_uchar4
+ (x : unsigned_char;
+ y : unsigned_char;
+ z : unsigned_char;
+ w : unsigned_char) return vector_types_h.uchar4; -- vector_functions.h:104
+ pragma Import (C, make_uchar4, "make_uchar4");
+
+ function make_short1 (x : short) return vector_types_h.short1; -- vector_functions.h:109
+ pragma Import (C, make_short1, "make_short1");
+
+ function make_ushort1 (x : unsigned_short) return vector_types_h.ushort1; -- vector_functions.h:114
+ pragma Import (C, make_ushort1, "make_ushort1");
+
+ function make_short2 (x : short; y : short) return vector_types_h.short2; -- vector_functions.h:119
+ pragma Import (C, make_short2, "make_short2");
+
+ function make_ushort2 (x : unsigned_short; y : unsigned_short) return vector_types_h.ushort2; -- vector_functions.h:124
+ pragma Import (C, make_ushort2, "make_ushort2");
+
+ function make_short3
+ (x : short;
+ y : short;
+ z : short) return vector_types_h.short3; -- vector_functions.h:129
+ pragma Import (C, make_short3, "make_short3");
+
+ function make_ushort3
+ (x : unsigned_short;
+ y : unsigned_short;
+ z : unsigned_short) return vector_types_h.ushort3; -- vector_functions.h:134
+ pragma Import (C, make_ushort3, "make_ushort3");
+
+ function make_short4
+ (x : short;
+ y : short;
+ z : short;
+ w : short) return vector_types_h.short4; -- vector_functions.h:139
+ pragma Import (C, make_short4, "make_short4");
+
+ function make_ushort4
+ (x : unsigned_short;
+ y : unsigned_short;
+ z : unsigned_short;
+ w : unsigned_short) return vector_types_h.ushort4; -- vector_functions.h:144
+ pragma Import (C, make_ushort4, "make_ushort4");
+
+ function make_int1 (x : int) return vector_types_h.int1; -- vector_functions.h:149
+ pragma Import (C, make_int1, "make_int1");
+
+ function make_uint1 (x : unsigned) return vector_types_h.uint1; -- vector_functions.h:154
+ pragma Import (C, make_uint1, "make_uint1");
+
+ function make_int2 (x : int; y : int) return vector_types_h.int2; -- vector_functions.h:159
+ pragma Import (C, make_int2, "make_int2");
+
+ function make_uint2 (x : unsigned; y : unsigned) return vector_types_h.uint2; -- vector_functions.h:164
+ pragma Import (C, make_uint2, "make_uint2");
+
+ function make_int3
+ (x : int;
+ y : int;
+ z : int) return vector_types_h.int3; -- vector_functions.h:169
+ pragma Import (C, make_int3, "make_int3");
+
+ function make_uint3
+ (x : unsigned;
+ y : unsigned;
+ z : unsigned) return vector_types_h.uint3; -- vector_functions.h:174
+ pragma Import (C, make_uint3, "make_uint3");
+
+ function make_int4
+ (x : int;
+ y : int;
+ z : int;
+ w : int) return vector_types_h.int4; -- vector_functions.h:179
+ pragma Import (C, make_int4, "make_int4");
+
+ function make_uint4
+ (x : unsigned;
+ y : unsigned;
+ z : unsigned;
+ w : unsigned) return vector_types_h.uint4; -- vector_functions.h:184
+ pragma Import (C, make_uint4, "make_uint4");
+
+ function make_long1 (x : long) return vector_types_h.long1; -- vector_functions.h:189
+ pragma Import (C, make_long1, "make_long1");
+
+ function make_ulong1 (x : unsigned_long) return vector_types_h.ulong1; -- vector_functions.h:194
+ pragma Import (C, make_ulong1, "make_ulong1");
+
+ function make_long2 (x : long; y : long) return vector_types_h.long2; -- vector_functions.h:199
+ pragma Import (C, make_long2, "make_long2");
+
+ function make_ulong2 (x : unsigned_long; y : unsigned_long) return vector_types_h.ulong2; -- vector_functions.h:204
+ pragma Import (C, make_ulong2, "make_ulong2");
+
+ function make_long3
+ (x : long;
+ y : long;
+ z : long) return vector_types_h.long3; -- vector_functions.h:209
+ pragma Import (C, make_long3, "make_long3");
+
+ function make_ulong3
+ (x : unsigned_long;
+ y : unsigned_long;
+ z : unsigned_long) return vector_types_h.ulong3; -- vector_functions.h:214
+ pragma Import (C, make_ulong3, "make_ulong3");
+
+ function make_long4
+ (x : long;
+ y : long;
+ z : long;
+ w : long) return vector_types_h.long4; -- vector_functions.h:219
+ pragma Import (C, make_long4, "make_long4");
+
+ function make_ulong4
+ (x : unsigned_long;
+ y : unsigned_long;
+ z : unsigned_long;
+ w : unsigned_long) return vector_types_h.ulong4; -- vector_functions.h:224
+ pragma Import (C, make_ulong4, "make_ulong4");
+
+ function make_float1 (x : float) return vector_types_h.float1; -- vector_functions.h:229
+ pragma Import (C, make_float1, "make_float1");
+
+ function make_float2 (x : float; y : float) return vector_types_h.float2; -- vector_functions.h:234
+ pragma Import (C, make_float2, "make_float2");
+
+ function make_float3
+ (x : float;
+ y : float;
+ z : float) return vector_types_h.float3; -- vector_functions.h:239
+ pragma Import (C, make_float3, "make_float3");
+
+ function make_float4
+ (x : float;
+ y : float;
+ z : float;
+ w : float) return vector_types_h.float4; -- vector_functions.h:244
+ pragma Import (C, make_float4, "make_float4");
+
+ function make_longlong1 (x : Long_Long_Integer) return vector_types_h.longlong1; -- vector_functions.h:249
+ pragma Import (C, make_longlong1, "make_longlong1");
+
+ function make_ulonglong1 (x : Extensions.unsigned_long_long) return vector_types_h.ulonglong1; -- vector_functions.h:254
+ pragma Import (C, make_ulonglong1, "make_ulonglong1");
+
+ function make_longlong2 (x : Long_Long_Integer; y : Long_Long_Integer) return vector_types_h.longlong2; -- vector_functions.h:259
+ pragma Import (C, make_longlong2, "make_longlong2");
+
+ function make_ulonglong2 (x : Extensions.unsigned_long_long; y : Extensions.unsigned_long_long) return vector_types_h.ulonglong2; -- vector_functions.h:264
+ pragma Import (C, make_ulonglong2, "make_ulonglong2");
+
+ function make_longlong3
+ (x : Long_Long_Integer;
+ y : Long_Long_Integer;
+ z : Long_Long_Integer) return vector_types_h.longlong3; -- vector_functions.h:269
+ pragma Import (C, make_longlong3, "make_longlong3");
+
+ function make_ulonglong3
+ (x : Extensions.unsigned_long_long;
+ y : Extensions.unsigned_long_long;
+ z : Extensions.unsigned_long_long) return vector_types_h.ulonglong3; -- vector_functions.h:274
+ pragma Import (C, make_ulonglong3, "make_ulonglong3");
+
+ function make_longlong4
+ (x : Long_Long_Integer;
+ y : Long_Long_Integer;
+ z : Long_Long_Integer;
+ w : Long_Long_Integer) return vector_types_h.longlong4; -- vector_functions.h:279
+ pragma Import (C, make_longlong4, "make_longlong4");
+
+ function make_ulonglong4
+ (x : Extensions.unsigned_long_long;
+ y : Extensions.unsigned_long_long;
+ z : Extensions.unsigned_long_long;
+ w : Extensions.unsigned_long_long) return vector_types_h.ulonglong4; -- vector_functions.h:284
+ pragma Import (C, make_ulonglong4, "make_ulonglong4");
+
+ function make_double1 (x : double) return vector_types_h.double1; -- vector_functions.h:289
+ pragma Import (C, make_double1, "make_double1");
+
+ function make_double2 (x : double; y : double) return vector_types_h.double2; -- vector_functions.h:294
+ pragma Import (C, make_double2, "make_double2");
+
+ function make_double3
+ (x : double;
+ y : double;
+ z : double) return vector_types_h.double3; -- vector_functions.h:299
+ pragma Import (C, make_double3, "make_double3");
+
+ function make_double4
+ (x : double;
+ y : double;
+ z : double;
+ w : double) return vector_types_h.double4; -- vector_functions.h:304
+ pragma Import (C, make_double4, "make_double4");
+
+end vector_functions_h;
--- /dev/null
+with Interfaces.C; use Interfaces.C;
+with Interfaces.C.Extensions;
+
+package vector_types_h is
+
+ type char1 is record
+ x : aliased signed_char; -- vector_types.h:94
+ end record;
+ pragma Convention (C_Pass_By_Copy, char1); -- vector_types.h:92
+
+ type uchar1 is record
+ x : aliased unsigned_char; -- vector_types.h:100
+ end record;
+ pragma Convention (C_Pass_By_Copy, uchar1); -- vector_types.h:98
+
+ type char2 is record
+ x : aliased signed_char; -- vector_types.h:106
+ y : aliased signed_char; -- vector_types.h:106
+ end record;
+ pragma Convention (C_Pass_By_Copy, char2); -- vector_types.h:104
+
+ type uchar2 is record
+ x : aliased unsigned_char; -- vector_types.h:112
+ y : aliased unsigned_char; -- vector_types.h:112
+ end record;
+ pragma Convention (C_Pass_By_Copy, uchar2); -- vector_types.h:110
+
+ type char3 is record
+ x : aliased signed_char; -- vector_types.h:118
+ y : aliased signed_char; -- vector_types.h:118
+ z : aliased signed_char; -- vector_types.h:118
+ end record;
+ pragma Convention (C_Pass_By_Copy, char3); -- vector_types.h:116
+
+ type uchar3 is record
+ x : aliased unsigned_char; -- vector_types.h:124
+ y : aliased unsigned_char; -- vector_types.h:124
+ z : aliased unsigned_char; -- vector_types.h:124
+ end record;
+ pragma Convention (C_Pass_By_Copy, uchar3); -- vector_types.h:122
+
+ type char4 is record
+ x : aliased signed_char; -- vector_types.h:130
+ y : aliased signed_char; -- vector_types.h:130
+ z : aliased signed_char; -- vector_types.h:130
+ w : aliased signed_char; -- vector_types.h:130
+ end record;
+ pragma Convention (C_Pass_By_Copy, char4); -- vector_types.h:128
+
+ type uchar4 is record
+ x : aliased unsigned_char; -- vector_types.h:136
+ y : aliased unsigned_char; -- vector_types.h:136
+ z : aliased unsigned_char; -- vector_types.h:136
+ w : aliased unsigned_char; -- vector_types.h:136
+ end record;
+ pragma Convention (C_Pass_By_Copy, uchar4); -- vector_types.h:134
+
+ type short1 is record
+ x : aliased short; -- vector_types.h:142
+ end record;
+ pragma Convention (C_Pass_By_Copy, short1); -- vector_types.h:140
+
+ type ushort1 is record
+ x : aliased unsigned_short; -- vector_types.h:148
+ end record;
+ pragma Convention (C_Pass_By_Copy, ushort1); -- vector_types.h:146
+
+ type short2 is record
+ x : aliased short; -- vector_types.h:154
+ y : aliased short; -- vector_types.h:154
+ end record;
+ pragma Convention (C_Pass_By_Copy, short2); -- vector_types.h:152
+
+ type ushort2 is record
+ x : aliased unsigned_short; -- vector_types.h:160
+ y : aliased unsigned_short; -- vector_types.h:160
+ end record;
+ pragma Convention (C_Pass_By_Copy, ushort2); -- vector_types.h:158
+
+ type short3 is record
+ x : aliased short; -- vector_types.h:166
+ y : aliased short; -- vector_types.h:166
+ z : aliased short; -- vector_types.h:166
+ end record;
+ pragma Convention (C_Pass_By_Copy, short3); -- vector_types.h:164
+
+ type ushort3 is record
+ x : aliased unsigned_short; -- vector_types.h:172
+ y : aliased unsigned_short; -- vector_types.h:172
+ z : aliased unsigned_short; -- vector_types.h:172
+ end record;
+ pragma Convention (C_Pass_By_Copy, ushort3); -- vector_types.h:170
+
+ type short4 is record
+ x : aliased short; -- vector_types.h:176
+ y : aliased short; -- vector_types.h:176
+ z : aliased short; -- vector_types.h:176
+ w : aliased short; -- vector_types.h:176
+ end record;
+ pragma Convention (C_Pass_By_Copy, short4); -- vector_types.h:176
+
+ type ushort4 is record
+ x : aliased unsigned_short; -- vector_types.h:179
+ y : aliased unsigned_short; -- vector_types.h:179
+ z : aliased unsigned_short; -- vector_types.h:179
+ w : aliased unsigned_short; -- vector_types.h:179
+ end record;
+ pragma Convention (C_Pass_By_Copy, ushort4); -- vector_types.h:179
+
+ type int1 is record
+ x : aliased int; -- vector_types.h:184
+ end record;
+ pragma Convention (C_Pass_By_Copy, int1); -- vector_types.h:182
+
+ type uint1 is record
+ x : aliased unsigned; -- vector_types.h:190
+ end record;
+ pragma Convention (C_Pass_By_Copy, uint1); -- vector_types.h:188
+
+ type int2 is record
+ x : aliased int; -- vector_types.h:194
+ y : aliased int; -- vector_types.h:194
+ end record;
+ pragma Convention (C_Pass_By_Copy, int2); -- vector_types.h:194
+
+ type uint2 is record
+ x : aliased unsigned; -- vector_types.h:197
+ y : aliased unsigned; -- vector_types.h:197
+ end record;
+ pragma Convention (C_Pass_By_Copy, uint2); -- vector_types.h:197
+
+ type int3 is record
+ x : aliased int; -- vector_types.h:202
+ y : aliased int; -- vector_types.h:202
+ z : aliased int; -- vector_types.h:202
+ end record;
+ pragma Convention (C_Pass_By_Copy, int3); -- vector_types.h:200
+
+ type uint3 is record
+ x : aliased unsigned; -- vector_types.h:208
+ y : aliased unsigned; -- vector_types.h:208
+ z : aliased unsigned; -- vector_types.h:208
+ end record;
+ pragma Convention (C_Pass_By_Copy, uint3); -- vector_types.h:206
+
+ type int4 is record
+ x : aliased int; -- vector_types.h:214
+ y : aliased int; -- vector_types.h:214
+ z : aliased int; -- vector_types.h:214
+ w : aliased int; -- vector_types.h:214
+ end record;
+ pragma Convention (C_Pass_By_Copy, int4); -- vector_types.h:212
+
+ type uint4 is record
+ x : aliased unsigned; -- vector_types.h:220
+ y : aliased unsigned; -- vector_types.h:220
+ z : aliased unsigned; -- vector_types.h:220
+ w : aliased unsigned; -- vector_types.h:220
+ end record;
+ pragma Convention (C_Pass_By_Copy, uint4); -- vector_types.h:218
+
+ type long1 is record
+ x : aliased long; -- vector_types.h:226
+ end record;
+ pragma Convention (C_Pass_By_Copy, long1); -- vector_types.h:224
+
+ type ulong1 is record
+ x : aliased unsigned_long; -- vector_types.h:232
+ end record;
+ pragma Convention (C_Pass_By_Copy, ulong1); -- vector_types.h:230
+
+ type long2 is record
+ x : aliased long; -- vector_types.h:248
+ y : aliased long; -- vector_types.h:248
+ end record;
+ pragma Convention (C_Pass_By_Copy, long2); -- vector_types.h:246
+
+ type ulong2 is record
+ x : aliased unsigned_long; -- vector_types.h:254
+ y : aliased unsigned_long; -- vector_types.h:254
+ end record;
+ pragma Convention (C_Pass_By_Copy, ulong2); -- vector_types.h:252
+
+ type long3 is record
+ x : aliased long; -- vector_types.h:262
+ y : aliased long; -- vector_types.h:262
+ z : aliased long; -- vector_types.h:262
+ end record;
+ pragma Convention (C_Pass_By_Copy, long3); -- vector_types.h:260
+
+ type ulong3 is record
+ x : aliased unsigned_long; -- vector_types.h:268
+ y : aliased unsigned_long; -- vector_types.h:268
+ z : aliased unsigned_long; -- vector_types.h:268
+ end record;
+ pragma Convention (C_Pass_By_Copy, ulong3); -- vector_types.h:266
+
+ type long4 is record
+ x : aliased long; -- vector_types.h:274
+ y : aliased long; -- vector_types.h:274
+ z : aliased long; -- vector_types.h:274
+ w : aliased long; -- vector_types.h:274
+ end record;
+ pragma Convention (C_Pass_By_Copy, long4); -- vector_types.h:272
+
+ type ulong4 is record
+ x : aliased unsigned_long; -- vector_types.h:280
+ y : aliased unsigned_long; -- vector_types.h:280
+ z : aliased unsigned_long; -- vector_types.h:280
+ w : aliased unsigned_long; -- vector_types.h:280
+ end record;
+ pragma Convention (C_Pass_By_Copy, ulong4); -- vector_types.h:278
+
+ type float1 is record
+ x : aliased float; -- vector_types.h:286
+ end record;
+ pragma Convention (C_Pass_By_Copy, float1); -- vector_types.h:284
+
+ type float2 is record
+ x : aliased float; -- vector_types.h:290
+ y : aliased float; -- vector_types.h:290
+ end record;
+ pragma Convention (C_Pass_By_Copy, float2); -- vector_types.h:290
+
+ type float3 is record
+ x : aliased float; -- vector_types.h:295
+ y : aliased float; -- vector_types.h:295
+ z : aliased float; -- vector_types.h:295
+ end record;
+ pragma Convention (C_Pass_By_Copy, float3); -- vector_types.h:293
+
+ type float4 is record
+ x : aliased float; -- vector_types.h:301
+ y : aliased float; -- vector_types.h:301
+ z : aliased float; -- vector_types.h:301
+ w : aliased float; -- vector_types.h:301
+ end record;
+ pragma Convention (C_Pass_By_Copy, float4); -- vector_types.h:299
+
+ type longlong1 is record
+ x : aliased Long_Long_Integer; -- vector_types.h:307
+ end record;
+ pragma Convention (C_Pass_By_Copy, longlong1); -- vector_types.h:305
+
+ type ulonglong1 is record
+ x : aliased Extensions.unsigned_long_long; -- vector_types.h:313
+ end record;
+ pragma Convention (C_Pass_By_Copy, ulonglong1); -- vector_types.h:311
+
+ type longlong2 is record
+ x : aliased Long_Long_Integer; -- vector_types.h:319
+ y : aliased Long_Long_Integer; -- vector_types.h:319
+ end record;
+ pragma Convention (C_Pass_By_Copy, longlong2); -- vector_types.h:317
+
+ type ulonglong2 is record
+ x : aliased Extensions.unsigned_long_long; -- vector_types.h:325
+ y : aliased Extensions.unsigned_long_long; -- vector_types.h:325
+ end record;
+ pragma Convention (C_Pass_By_Copy, ulonglong2); -- vector_types.h:323
+
+ type longlong3 is record
+ x : aliased Long_Long_Integer; -- vector_types.h:331
+ y : aliased Long_Long_Integer; -- vector_types.h:331
+ z : aliased Long_Long_Integer; -- vector_types.h:331
+ end record;
+ pragma Convention (C_Pass_By_Copy, longlong3); -- vector_types.h:329
+
+ type ulonglong3 is record
+ x : aliased Extensions.unsigned_long_long; -- vector_types.h:337
+ y : aliased Extensions.unsigned_long_long; -- vector_types.h:337
+ z : aliased Extensions.unsigned_long_long; -- vector_types.h:337
+ end record;
+ pragma Convention (C_Pass_By_Copy, ulonglong3); -- vector_types.h:335
+
+ type longlong4 is record
+ x : aliased Long_Long_Integer; -- vector_types.h:343
+ y : aliased Long_Long_Integer; -- vector_types.h:343
+ z : aliased Long_Long_Integer; -- vector_types.h:343
+ w : aliased Long_Long_Integer; -- vector_types.h:343
+ end record;
+ pragma Convention (C_Pass_By_Copy, longlong4); -- vector_types.h:341
+
+ type ulonglong4 is record
+ x : aliased Extensions.unsigned_long_long; -- vector_types.h:349
+ y : aliased Extensions.unsigned_long_long; -- vector_types.h:349
+ z : aliased Extensions.unsigned_long_long; -- vector_types.h:349
+ w : aliased Extensions.unsigned_long_long; -- vector_types.h:349
+ end record;
+ pragma Convention (C_Pass_By_Copy, ulonglong4); -- vector_types.h:347
+
+ type double1 is record
+ x : aliased double; -- vector_types.h:355
+ end record;
+ pragma Convention (C_Pass_By_Copy, double1); -- vector_types.h:353
+
+ type double2 is record
+ x : aliased double; -- vector_types.h:361
+ y : aliased double; -- vector_types.h:361
+ end record;
+ pragma Convention (C_Pass_By_Copy, double2); -- vector_types.h:359
+
+ type double3 is record
+ x : aliased double; -- vector_types.h:367
+ y : aliased double; -- vector_types.h:367
+ z : aliased double; -- vector_types.h:367
+ end record;
+ pragma Convention (C_Pass_By_Copy, double3); -- vector_types.h:365
+
+ type double4 is record
+ x : aliased double; -- vector_types.h:373
+ y : aliased double; -- vector_types.h:373
+ z : aliased double; -- vector_types.h:373
+ w : aliased double; -- vector_types.h:373
+ end record;
+ pragma Convention (C_Pass_By_Copy, double4); -- vector_types.h:371
+
+ type dim3 is record
+ x : aliased unsigned; -- vector_types.h:495
+ y : aliased unsigned; -- vector_types.h:495
+ z : aliased unsigned; -- vector_types.h:495
+ end record;
+ pragma Convention (C_Pass_By_Copy, dim3); -- vector_types.h:493
+
+end vector_types_h;
git.codelabs.ch / cuda-ada.git / commitdiff