Description: fix spelling-error-in-manpage and other typos
Author: Andreas Beckmann <anbe@debian.org>
Author: Graham Inggs <graham@nerve.org.za>

--- a/nvidia-cuda/cuda_cudart/include/cuda.h
+++ b/nvidia-cuda/cuda_cudart/include/cuda.h
@@ -783,7 +783,7 @@ typedef enum CUcomputemode_enum {
  * Memory advise values
  */
 typedef enum CUmem_advise_enum {
-    CU_MEM_ADVISE_SET_READ_MOSTLY          = 1, /**< Data will mostly be read and only occassionally be written to */
+    CU_MEM_ADVISE_SET_READ_MOSTLY          = 1, /**< Data will mostly be read and only occasionally be written to */
     CU_MEM_ADVISE_UNSET_READ_MOSTLY        = 2, /**< Undo the effect of ::CU_MEM_ADVISE_SET_READ_MOSTLY */
     CU_MEM_ADVISE_SET_PREFERRED_LOCATION   = 3, /**< Set the preferred location for the data as the specified device */
     CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION = 4, /**< Clear the preferred location for the data */
@@ -792,7 +792,7 @@ typedef enum CUmem_advise_enum {
 } CUmem_advise;
 
 typedef enum CUmem_range_attribute_enum {
-    CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY            = 1, /**< Whether the range will mostly be read and only occassionally be written to */
+    CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY            = 1, /**< Whether the range will mostly be read and only occasionally be written to */
     CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION     = 2, /**< The preferred location of the range */
     CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY            = 3, /**< Memory range has ::CU_MEM_ADVISE_SET_ACCESSED_BY set for specified device */
     CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION = 4  /**< The last location to which the range was prefetched */
@@ -3074,7 +3074,7 @@ CUresult CUDAAPI cuDeviceGet(CUdevice *d
 CUresult CUDAAPI cuDeviceGetCount(int *count);
 
 /**
- * \brief Returns an identifer string for the device
+ * \brief Returns an identifier string for the device
  *
  * Returns an ASCII string identifying the device \p dev in the NULL-terminated
  * string pointed to by \p name. \p len specifies the maximum length of the
@@ -3385,7 +3385,7 @@ CUresult CUDAAPI cuDeviceGetTexture1DLin
  *   supports native atomic operations.
  * - ::CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO: Ratio of single precision performance
  *   (in floating-point operations per second) to double precision performance.
- * - ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS: Device suppports coherently accessing
+ * - ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS: Device supports coherently accessing
  *   pageable memory without calling cudaHostRegister on it.
  * - ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS: Device can coherently access managed memory
  *   concurrently with the CPU.
@@ -3393,7 +3393,7 @@ CUresult CUDAAPI cuDeviceGetTexture1DLin
  * - ::CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM: Device can access host registered
  *   memory at the same virtual address as the CPU.
  * -  ::CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN: The maximum per block shared memory size
- *    suported on this device. This is the maximum value that can be opted into when using the cuFuncSetAttribute() call.
+ *    supported on this device. This is the maximum value that can be opted into when using the cuFuncSetAttribute() call.
  *    For more details see ::CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES
  * - ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES: Device accesses pageable memory via the host's
  *   page tables.
@@ -3455,7 +3455,7 @@ CUresult CUDAAPI cuDeviceGetAttribute(in
  *
  * At least one of these flags must be set, failing which the API
  * returns ::CUDA_ERROR_INVALID_VALUE. Both the flags are orthogonal
- * to one another: a developer may set both these flags that allows to
+ * to one another: a developer may set both these flags that allows one to
  * set both wait and signal specific attributes in the same \p nvSciSyncAttrList.
  *
  * \param nvSciSyncAttrList     - Return NvSciSync attributes supported.
@@ -3564,7 +3564,7 @@ __CUDA_DEPRECATED CUresult CUDAAPI cuDev
  *
  * \deprecated
  *
- * This function was deprecated as of CUDA 5.0 and its functionality superceded
+ * This function was deprecated as of CUDA 5.0 and its functionality superseded
  * by ::cuDeviceGetAttribute().
  *
  * Returns in \p *major and \p *minor the major and minor revision numbers that
@@ -3704,7 +3704,7 @@ CUresult CUDAAPI cuDevicePrimaryCtxRelea
 /**
  * \brief Set flags for the primary context
  *
- * Sets the flags for the primary context on the device overwriting perviously
+ * Sets the flags for the primary context on the device overwriting previously
  * set ones.
  *
  * The three LSBs of the \p flags parameter can be used to control how the OS
@@ -5663,7 +5663,7 @@ CUresult CUDAAPI cuMemHostGetFlags(unsig
  * ::cuStreamAttachMemAsync will be required to enable access on such devices.
  *
  * If the association is later changed via ::cuStreamAttachMemAsync to
- * a single stream, the default association as specifed during ::cuMemAllocManaged
+ * a single stream, the default association as specified during ::cuMemAllocManaged
  * is restored when that stream is destroyed. For __managed__ variables, the
  * default association is always ::CU_MEM_ATTACH_GLOBAL. Note that destroying a
  * stream is an asynchronous operation, and as a result, the change to default
@@ -8848,13 +8848,13 @@ CUresult CUDAAPI cuMemAddressFree(CUdevi
 * \brief Create a CUDA memory handle representing a memory allocation of a given size described by the given properties
 *
 * This creates a memory allocation on the target device specified through the
-* \p prop strcuture. The created allocation will not have any device or host
+* \p prop structure. The created allocation will not have any device or host
 * mappings. The generic memory \p handle for the allocation can be
 * mapped to the address space of calling process via ::cuMemMap. This handle
 * cannot be transmitted directly to other processes (see
 * ::cuMemExportToShareableHandle).  On Windows, the caller must also pass
 * an LPSECURITYATTRIBUTE in \p prop to be associated with this handle which
-* limits or allows access to this handle for a recepient process (see
+* limits or allows access to this handle for a recipient process (see
 * ::CUmemAllocationProp::win32HandleMetaData for more).  The \p size of this
 * allocation must be a multiple of the the value given via
 * ::cuMemGetAllocationGranularity with the ::CU_MEM_ALLOC_GRANULARITY_MINIMUM
@@ -8892,7 +8892,7 @@ CUresult CUDAAPI cuMemCreate(CUmemGeneri
 * are unmapped and when all outstanding references to the handle (including it's
 * shareable counterparts) are also released. The generic memory handle can be
 * freed when there are still outstanding mappings made with this handle. Each
-* time a recepient process imports a shareable handle, it needs to pair it with
+* time a recipient process imports a shareable handle, it needs to pair it with
 * ::cuMemRelease for the handle to be freed.  If \p handle is not a valid handle
 * the behavior is undefined. 
 *
@@ -12210,7 +12210,7 @@ CUresult CUDAAPI cuLaunchCooperativeKern
  * All kernels launched must be identical with respect to the compiled code. Note that
  * any __device__, __constant__ or __managed__ variables present in the module that owns
  * the kernel launched on each device, are independently instantiated on every device.
- * It is the application's responsiblity to ensure these variables are initialized and
+ * It is the application's responsibility to ensure these variables are initialized and
  * used appropriately.
  *
  * The size of the grids as specified in blocks, the size of the blocks themselves
--- a/nvidia-cuda/cuda_cudart/include/cuda_runtime.h
+++ b/nvidia-cuda/cuda_cudart/include/cuda_runtime.h
@@ -171,8 +171,8 @@ struct  __device_builtin__ __nv_lambda_p
  * \p stream specifies a stream the invocation is associated to.
  *
  * \param func        - Device function symbol
- * \param gridDim     - Grid dimentions
- * \param blockDim    - Block dimentions
+ * \param gridDim     - Grid dimensions
+ * \param blockDim    - Block dimensions
  * \param args        - Arguments
  * \param sharedMem   - Shared memory (defaults to 0)
  * \param stream      - Stream identifier (defaults to NULL)
@@ -237,8 +237,8 @@ static __inline__ __host__ cudaError_t c
  * \p stream specifies a stream the invocation is associated to.
  *
  * \param func        - Device function symbol
- * \param gridDim     - Grid dimentions
- * \param blockDim    - Block dimentions
+ * \param gridDim     - Grid dimensions
+ * \param blockDim    - Block dimensions
  * \param args        - Arguments
  * \param sharedMem   - Shared memory (defaults to 0)
  * \param stream      - Stream identifier (defaults to NULL)
@@ -420,7 +420,7 @@ static __inline__ __host__ cudaError_t c
  * ::cudaStreamAttachMemAsync will be required to enable access on such devices.
  *
  * If the association is later changed via ::cudaStreamAttachMemAsync to
- * a single stream, the default association, as specifed during ::cudaMallocManaged,
+ * a single stream, the default association, as specified during ::cudaMallocManaged,
  * is restored when that stream is destroyed. For __managed__ variables, the
  * default association is always ::cudaMemAttachGlobal. Note that destroying a
  * stream is an asynchronous operation, and as a result, the change to default
@@ -1772,7 +1772,7 @@ static __inline__ __host__ cudaError_t c
  * streaming multiprocessor for the device function.
  *
  * \param numBlocks       - Returned occupancy
- * \param func            - Kernel function for which occupancy is calulated
+ * \param func            - Kernel function for which occupancy is calculated
  * \param blockSize       - Block size the kernel is intended to be launched with
  * \param dynamicSMemSize - Per-block dynamic shared memory usage intended, in bytes
  *
@@ -1823,7 +1823,7 @@ static __inline__ __host__ cudaError_t c
  *   section of the Maxwell tuning guide.
  *
  * \param numBlocks       - Returned occupancy
- * \param func            - Kernel function for which occupancy is calulated
+ * \param func            - Kernel function for which occupancy is calculated
  * \param blockSize       - Block size the kernel is intended to be launched with
  * \param dynamicSMemSize - Per-block dynamic shared memory usage intended, in bytes
  * \param flags           - Requested behavior for the occupancy calculator
@@ -2206,7 +2206,7 @@ static __inline__ __host__ cudaError_t c
 }
 
 /**
- * \brief Returns grid and block size that achived maximum potential occupancy for a device function with the specified flags
+ * \brief Returns grid and block size that achieved maximum potential occupancy for a device function with the specified flags
  *
  * Returns in \p *minGridSize and \p *blocksize a suggested grid /
  * block size pair that achieves the best potential occupancy
--- a/nvidia-cuda/cuda_cudart/include/cuda_runtime_api.h
+++ b/nvidia-cuda/cuda_cudart/include/cuda_runtime_api.h
@@ -409,7 +409,7 @@ extern __host__ cudaError_t CUDARTAPI cu
  * - ::cudaLimitMallocHeapSize: size in bytes of the heap used by the
  *   ::malloc() and ::free() device system calls;
  * - ::cudaLimitDevRuntimeSyncDepth: maximum grid depth at which a
- *   thread can isssue the device runtime call ::cudaDeviceSynchronize()
+ *   thread can issue the device runtime call ::cudaDeviceSynchronize()
  *   to wait on child grid launches to complete.
  * - ::cudaLimitDevRuntimePendingLaunchCount: maximum number of outstanding
  *   device runtime launches.
@@ -902,7 +902,7 @@ extern __host__ cudaError_t CUDARTAPI cu
 /**
  * \brief Attempts to close memory mapped with cudaIpcOpenMemHandle
  * 
- * Decrements the reference count of the memory returnd by ::cudaIpcOpenMemHandle by 1.
+ * Decrements the reference count of the memory returned by ::cudaIpcOpenMemHandle by 1.
  * When the reference count reaches 0, this API unmaps the memory. The original allocation
  * in the exporting process as well as imported mappings in other processes
  * will be unaffected.
@@ -1830,7 +1830,7 @@ extern __host__ __cudart_builtin__ cudaE
  *
  * At least one of these flags must be set, failing which the API
  * returns ::cudaErrorInvalidValue. Both the flags are orthogonal
- * to one another: a developer may set both these flags that allows to
+ * to one another: a developer may set both these flags that allows one to
  * set both wait and signal specific attributes in the same \p nvSciSyncAttrList.
  *
  * \param nvSciSyncAttrList     - Return NvSciSync attributes supported.
@@ -3762,8 +3762,8 @@ extern __host__ cudaError_t CUDARTAPI cu
  * \p stream specifies a stream the invocation is associated to.
  *
  * \param func        - Device function symbol
- * \param gridDim     - Grid dimentions
- * \param blockDim    - Block dimentions
+ * \param gridDim     - Grid dimensions
+ * \param blockDim    - Block dimensions
  * \param args        - Arguments
  * \param sharedMem   - Shared memory
  * \param stream      - Stream identifier
@@ -3821,8 +3821,8 @@ extern __host__ cudaError_t CUDARTAPI cu
  * \p stream specifies a stream the invocation is associated to.
  *
  * \param func        - Device function symbol
- * \param gridDim     - Grid dimentions
- * \param blockDim    - Block dimentions
+ * \param gridDim     - Grid dimensions
+ * \param blockDim    - Block dimensions
  * \param args        - Arguments
  * \param sharedMem   - Shared memory
  * \param stream      - Stream identifier
@@ -3862,7 +3862,7 @@ extern __host__ cudaError_t CUDARTAPI cu
  *
  * The same kernel must be launched on all devices. Note that any __device__ or __constant__
  * variables are independently instantiated on every device. It is the application's
- * responsiblity to ensure these variables are initialized and used appropriately.
+ * responsibility to ensure these variables are initialized and used appropriately.
  *
  * The size of the grids as specified in blocks, the size of the blocks themselves and the
  * amount of shared memory used by each thread block must also match across all launched kernels.
@@ -4410,7 +4410,7 @@ extern __host__ __cudart_builtin__ cudaE
  * ::cudaStreamAttachMemAsync will be required to enable access on such devices.
  *
  * If the association is later changed via ::cudaStreamAttachMemAsync to
- * a single stream, the default association, as specifed during ::cudaMallocManaged,
+ * a single stream, the default association, as specified during ::cudaMallocManaged,
  * is restored when that stream is destroyed. For __managed__ variables, the
  * default association is always ::cudaMemAttachGlobal. Note that destroying a
  * stream is an asynchronous operation, and as a result, the change to default
@@ -5379,7 +5379,7 @@ struct cudaMemcpy3DParms {
 };
 \endcode
  *
- * ::cudaMemcpy3D() copies data betwen two 3D objects. The source and
+ * ::cudaMemcpy3D() copies data between two 3D objects. The source and
  * destination objects may be in either host memory, device memory, or a CUDA
  * array. The source, destination, extent, and kind of copy performed is
  * specified by the ::cudaMemcpy3DParms struct which should be initialized to
@@ -5515,7 +5515,7 @@ struct cudaMemcpy3DParms {
 };
 \endcode
  *
- * ::cudaMemcpy3DAsync() copies data betwen two 3D objects. The source and
+ * ::cudaMemcpy3DAsync() copies data between two 3D objects. The source and
  * destination objects may be in either host memory, device memory, or a CUDA
  * array. The source, destination, extent, and kind of copy performed is
  * specified by the ::cudaMemcpy3DParms struct which should be initialized to
--- a/nvidia-cuda/cuda_cupti/extras/CUPTI/include/cupti_callbacks.h
+++ b/nvidia-cuda/cuda_cupti/extras/CUPTI/include/cupti_callbacks.h
@@ -590,7 +590,7 @@ CUptiResult CUPTIAPI cuptiSupportedDomai
  * \param subscriber Returns handle to initialize subscriber
  * \param callback The callback function
  * \param userdata A pointer to user data. This data will be passed to
- * the callback function via the \p userdata paramater.
+ * the callback function via the \p userdata parameter.
  *
  * \retval CUPTI_SUCCESS on success
  * \retval CUPTI_ERROR_NOT_INITIALIZED if unable to initialize CUPTI
--- a/nvidia-cuda/libcublas/include/cublasXt.h
+++ b/nvidia-cuda/libcublas/include/cublasXt.h
@@ -73,7 +73,7 @@ cublasStatus_t CUBLASWINAPI cublasXtMaxB
 /* This routine selects the Gpus that the user want to use for CUBLAS-XT */
 cublasStatus_t CUBLASWINAPI cublasXtDeviceSelect(cublasXtHandle_t handle, int nbDevices, int deviceId[]);
 
-/* This routine allows to change the dimension of the tiles ( blockDim x blockDim ) */
+/* This routine allows one to change the dimension of the tiles ( blockDim x blockDim ) */
 cublasStatus_t CUBLASWINAPI cublasXtSetBlockDim(cublasXtHandle_t handle, int blockDim);
 cublasStatus_t CUBLASWINAPI cublasXtGetBlockDim(cublasXtHandle_t handle, int *blockDim);
 
@@ -81,7 +81,7 @@ typedef enum {
     CUBLASXT_PINNING_DISABLED   = 0,  
     CUBLASXT_PINNING_ENABLED    = 1        
 } cublasXtPinnedMemMode_t;
-/* This routine allows to CUBLAS-XT to pin the Host memory if it find out that some of the matrix passed
+/* This routine allows one to CUBLAS-XT to pin the Host memory if it find out that some of the matrix passed
    are not pinned : Pinning/Unpinning the Host memory is still a costly operation
    It is better if the user controls the memory on its own (by pinning/unpinning oly when necessary)
 */
--- a/nvidia-cuda/cuda_cudart/include/driver_types.h
+++ b/nvidia-cuda/cuda_cudart/include/driver_types.h
@@ -1599,7 +1599,7 @@ enum __device_builtin__ cudaLimit
  */
 enum __device_builtin__ cudaMemoryAdvise
 {
-    cudaMemAdviseSetReadMostly          = 1, /**< Data will mostly be read and only occassionally be written to */
+    cudaMemAdviseSetReadMostly          = 1, /**< Data will mostly be read and only occasionally be written to */
     cudaMemAdviseUnsetReadMostly        = 2, /**< Undo the effect of ::cudaMemAdviseSetReadMostly */
     cudaMemAdviseSetPreferredLocation   = 3, /**< Set the preferred location for the data as the specified device */
     cudaMemAdviseUnsetPreferredLocation = 4, /**< Clear the preferred location for the data */
@@ -1612,7 +1612,7 @@ enum __device_builtin__ cudaMemoryAdvise
  */
 enum __device_builtin__ cudaMemRangeAttribute
 {
-    cudaMemRangeAttributeReadMostly           = 1, /**< Whether the range will mostly be read and only occassionally be written to */
+    cudaMemRangeAttributeReadMostly           = 1, /**< Whether the range will mostly be read and only occasionally be written to */
     cudaMemRangeAttributePreferredLocation    = 2, /**< The preferred location of the range */
     cudaMemRangeAttributeAccessedBy           = 3, /**< Memory range has ::cudaMemAdviseSetAccessedBy set for specified device */
     cudaMemRangeAttributeLastPrefetchLocation = 4  /**< The last location to which the range was prefetched */
@@ -2384,8 +2384,8 @@ enum __device_builtin__ cudaCGScope {
 struct __device_builtin__ cudaLaunchParams
 {
     void *func;          /**< Device function symbol */
-    dim3 gridDim;        /**< Grid dimentions */
-    dim3 blockDim;       /**< Block dimentions */
+    dim3 gridDim;        /**< Grid dimensions */
+    dim3 blockDim;       /**< Block dimensions */
     void **args;         /**< Arguments */
     size_t sharedMem;    /**< Shared memory */
     cudaStream_t stream; /**< Stream identifier */
--- a/nvidia-cuda/cuda_nvml_dev/include/nvml.h
+++ b/nvidia-cuda/cuda_nvml_dev/include/nvml.h
@@ -725,7 +725,7 @@ typedef enum nvmlPStates_enum
 /**
  * GPU Operation Mode
  *
- * GOM allows to reduce power usage and optimize GPU throughput by disabling GPU features.
+ * GOM allows one to reduce power usage and optimize GPU throughput by disabling GPU features.
  *
  * Each GOM is designed to meet specific user needs.
  */
@@ -781,7 +781,7 @@ typedef enum nvmlReturn_enum
     NVML_ERROR_IN_USE = 19,                  //!< An operation cannot be performed because the GPU is currently in use
     NVML_ERROR_MEMORY = 20,                  //!< Insufficient memory
     NVML_ERROR_NO_DATA = 21,                 //!< No data
-    NVML_ERROR_VGPU_ECC_NOT_SUPPORTED = 22,  //!< The requested vgpu operation is not available on target device, becasue ECC is enabled
+    NVML_ERROR_VGPU_ECC_NOT_SUPPORTED = 22,  //!< The requested vgpu operation is not available on target device, because ECC is enabled
     NVML_ERROR_INSUFFICIENT_RESOURCES = 23,  //!< Ran out of critical resources, other than memory
     NVML_ERROR_UNKNOWN = 999                 //!< An internal driver error occurred
 } nvmlReturn_t;
@@ -1930,7 +1930,7 @@ nvmlReturn_t DECLDIR nvmlSystemGetNVMLVe
  *
  * For all products.
  *
- * The CUDA driver version returned will be retreived from the currently installed version of CUDA.
+ * The CUDA driver version returned will be retrieved from the currently installed version of CUDA.
  * If the cuda library is not found, this function will return a known supported version number.
  *
  * @param cudaDriverVersion                    Reference in which to return the version identifier
@@ -4084,7 +4084,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetEncode
  * array elememt count is passed in \a sessionCount, and \a sessionCount is used to return the number of sessions
  * written to the buffer.
  *
- * If the supplied buffer is not large enough to accomodate the active session array, the function returns
+ * If the supplied buffer is not large enough to accommodate the active session array, the function returns
  * NVML_ERROR_INSUFFICIENT_SIZE, with the element count of nvmlEncoderSessionInfo_t array required in \a sessionCount.
  * To query the number of active encoder sessions, call this function with *sessionCount = 0.  The code will return
  * NVML_SUCCESS with number of active encoder sessions updated in *sessionCount.
@@ -4132,7 +4132,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetDecode
 * For Maxwell &tm; or newer fully supported devices.
 *
 * @param device                            The identifier of the target device
-* @param fbcStats                          Reference to nvmlFBCStats_t structure contianing NvFBC stats
+* @param fbcStats                          Reference to nvmlFBCStats_t structure containing NvFBC stats
 *
 * @return
 *         - \ref NVML_SUCCESS                  if \a fbcStats is fetched
@@ -5900,7 +5900,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetProces
  * pointed at by \a vgpuTypeIds. The element count of nvmlVgpuTypeId_t array is passed in \a vgpuCount, and \a vgpuCount
  * is used to return the number of vGPU types written to the buffer.
  *
- * If the supplied buffer is not large enough to accomodate the vGPU type array, the function returns
+ * If the supplied buffer is not large enough to accommodate the vGPU type array, the function returns
  * NVML_ERROR_INSUFFICIENT_SIZE, with the element count of nvmlVgpuTypeId_t array required in \a vgpuCount.
  * To query the number of vGPU types supported for the GPU, call this function with *vgpuCount = 0.
  * The code will return NVML_ERROR_INSUFFICIENT_SIZE, or NVML_SUCCESS if no vGPU types are supported.
@@ -5929,7 +5929,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetSuppor
  * can concurrently run on a device.  For example, if only one vGPU type is allowed at a time on a device, then the creatable
  * list will be restricted to whatever vGPU type is already running on the device.
  *
- * If the supplied buffer is not large enough to accomodate the vGPU type array, the function returns
+ * If the supplied buffer is not large enough to accommodate the vGPU type array, the function returns
  * NVML_ERROR_INSUFFICIENT_SIZE, with the element count of nvmlVgpuTypeId_t array required in \a vgpuCount.
  * To query the number of vGPU types createable for the GPU, call this function with *vgpuCount = 0.
  * The code will return NVML_ERROR_INSUFFICIENT_SIZE, or NVML_SUCCESS if no vGPU types are creatable.
@@ -6011,7 +6011,7 @@ nvmlReturn_t DECLDIR nvmlVgpuTypeGetGpuI
  *
  * @param vgpuTypeId               Handle to vGPU type
  * @param deviceID                 Device ID and vendor ID of the device contained in single 32 bit value
- * @param subsystemID              Subsytem ID and subsytem vendor ID of the device contained in single 32 bit value
+ * @param subsystemID              Subsystem ID and subsystem vendor ID of the device contained in single 32 bit value
  *
  * @return
  *         - \ref NVML_SUCCESS                 successful completion
@@ -6153,7 +6153,7 @@ nvmlReturn_t DECLDIR nvmlVgpuTypeGetMaxI
  * array elememt count is passed in \a vgpuCount, and \a vgpuCount is used to return the number of vGPU instances
  * written to the buffer.
  *
- * If the supplied buffer is not large enough to accomodate the vGPU instance array, the function returns
+ * If the supplied buffer is not large enough to accommodate the vGPU instance array, the function returns
  * NVML_ERROR_INSUFFICIENT_SIZE, with the element count of nvmlVgpuInstance_t array required in \a vgpuCount.
  * To query the number of active vGPU instances, call this function with *vgpuCount = 0.  The code will return
  * NVML_ERROR_INSUFFICIENT_SIZE, or NVML_SUCCESS if no vGPU Types are supported.
@@ -6352,7 +6352,7 @@ nvmlReturn_t DECLDIR nvmlVgpuInstanceGet
  * @param encoderCapacity          Reference to an unsigned int for the encoder capacity
  *
  * @return
- *         - \ref NVML_SUCCESS                 if \a encoderCapacity has been retrived
+ *         - \ref NVML_SUCCESS                 if \a encoderCapacity has been retrieved
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a vgpuInstance is 0, or \a encoderQueryType is invalid
  *         - \ref NVML_ERROR_NOT_FOUND         if \a vgpuInstance does not match a valid active vGPU instance on the system
@@ -6405,7 +6405,7 @@ nvmlReturn_t DECLDIR nvmlVgpuInstanceGet
  * array element count is passed in \a sessionCount, and \a sessionCount is used to return the number of sessions
  * written to the buffer.
  *
- * If the supplied buffer is not large enough to accomodate the active session array, the function returns
+ * If the supplied buffer is not large enough to accommodate the active session array, the function returns
  * NVML_ERROR_INSUFFICIENT_SIZE, with the element count of nvmlEncoderSessionInfo_t array required in \a sessionCount.
  * To query the number of active encoder sessions, call this function with *sessionCount = 0. The code will return
  * NVML_SUCCESS with number of active encoder sessions updated in *sessionCount.
@@ -6435,7 +6435,7 @@ nvmlReturn_t DECLDIR nvmlVgpuInstanceGet
 * For Maxwell &tm; or newer fully supported devices.
 *
 * @param vgpuInstance                      Identifier of the target vGPU instance
-* @param fbcStats                          Reference to nvmlFBCStats_t structure contianing NvFBC stats
+* @param fbcStats                          Reference to nvmlFBCStats_t structure containing NvFBC stats
 *
 * @return
 *         - \ref NVML_SUCCESS                  if \a fbcStats is fetched
@@ -6506,7 +6506,7 @@ typedef struct nvmlVgpuMetadata_st
     char                     guestDriverVersion[NVML_SYSTEM_DRIVER_VERSION_BUFFER_SIZE]; //!< Version of driver installed in guest
     char                     hostDriverVersion[NVML_SYSTEM_DRIVER_VERSION_BUFFER_SIZE];  //!< Version of driver installed in host
     unsigned int             reserved[6];                                                //!< Reserved for internal use
-    unsigned int             vgpuVirtualizationCaps;                                     //!< vGPU virtualizaion capabilities bitfileld
+    unsigned int             vgpuVirtualizationCaps;                                     //!< vGPU virtualization capabilities bitfield
     unsigned int             guestVgpuVersion;                                           //!< vGPU version of guest driver
     unsigned int             opaqueDataSize;                                             //!< Size of opaque data field in bytes
     char                     opaqueData[4];                                              //!< Opaque data
@@ -6520,7 +6520,7 @@ typedef struct nvmlVgpuPgpuMetadata_st
     unsigned int            version;                                                    //!< Current version of the structure
     unsigned int            revision;                                                   //!< Current revision of the structure
     char                    hostDriverVersion[NVML_SYSTEM_DRIVER_VERSION_BUFFER_SIZE];  //!< Host driver version
-    unsigned int            pgpuVirtualizationCaps;                                     //!< Pgpu virtualizaion capabilities bitfileld
+    unsigned int            pgpuVirtualizationCaps;                                     //!< Pgpu virtualization capabilities bitfield
     unsigned int            reserved[5];                                                //!< Reserved for internal use
     nvmlVgpuVersion_t       hostSupportedVgpuRange;                                     //!< vGPU version range supported by host driver
     unsigned int            opaqueDataSize;                                             //!< Size of opaque data field in bytes
@@ -6618,7 +6618,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetVgpuMe
  *
  * The caller passes in a buffer via \a compatibilityInfo, into which a compatibility information structure is written. The
  * structure defines the states in which the vGPU / VM may be booted on the physical GPU. If the vGPU / VM compatibility
- * with the physical GPU is limited, a limit code indicates the factor limiting compability.
+ * with the physical GPU is limited, a limit code indicates the factor limiting compatibility.
  * (see \ref nvmlVgpuPgpuCompatibilityLimitCode_t for details).
  *
  * Note: vGPU compatibility does not take into account dynamic capacity conditions that may limit a system's ability to
--- a/nvidia-cuda/cuda_cupti/extras/CUPTI/samples/openacc_trace/openacc_trace.cpp
+++ b/nvidia-cuda/cuda_cupti/extras/CUPTI/samples/openacc_trace/openacc_trace.cpp
@@ -108,7 +108,7 @@ void finalize()
 }
 
 // acc_register_library is defined by the OpenACC tools interface
-// and allows to register this library with the OpenACC runtime.
+// and allows one to register this library with the OpenACC runtime.
 
 extern "C" void
 acc_register_library(void *profRegister, void *profUnregister, void *profLookup)
--- a/nvidia-cuda/libcublas/include/cublasLt.h
+++ b/nvidia-cuda/libcublas/include/cublasLt.h
@@ -746,7 +746,7 @@ cublasLtMatrixTransformDescGetAttribute(
     size_t sizeInBytes,
     size_t *sizeWritten);
 
-/** For computation with complex numbers, this enum allows to apply the Gauss Complexity reduction algorithm
+/** For computation with complex numbers, this enum allows one to apply the Gauss Complexity reduction algorithm
  */
 typedef enum {
     CUBLASLT_3M_MODE_DISALLOWED = 0,
--- a/nvidia-cuda/libcusolver/include/cusolverMg.h
+++ b/nvidia-cuda/libcusolver/include/cusolverMg.h
@@ -92,7 +92,7 @@ cusolverStatus_t CUSOLVERAPI cusolverMgD
 
 /**
  * \brief Allocates resources related to the shared memory device grid.
- * \param[out] grid the opaque data strcuture that holds the grid
+ * \param[out] grid the opaque data structure that holds the grid
  * \param[in] numRowDevices number of devices in the row
  * \param[in] numColDevices number of devices in the column
  * \param[in] deviceId This array of size height * width stores the
@@ -109,7 +109,7 @@ cusolverStatus_t CUSOLVERAPI cusolverMgC
 
 /**
  * \brief Releases the allocated resources related to the distributed grid.
- * \param[in] grid the opaque data strcuture that holds the distributed grid
+ * \param[in] grid the opaque data structure that holds the distributed grid
  * \returns the status code
  */
 cusolverStatus_t CUSOLVERAPI cusolverMgDestroyGrid(
@@ -117,7 +117,7 @@ cusolverStatus_t CUSOLVERAPI cusolverMgD
 
 /**
  * \brief Allocates resources related to the distributed matrix descriptor.
- * \param[out] desc the opaque data strcuture that holds the descriptor
+ * \param[out] desc the opaque data structure that holds the descriptor
  * \param[in] numRows number of total rows
  * \param[in] numCols number of total columns
  * \param[in] rowBlockSize row block size
@@ -137,7 +137,7 @@ cusolverStatus_t CUSOLVERAPI cusolverMgC
 
 /**
  * \brief Releases the allocated resources related to the distributed matrix descriptor.
- * \param[in] desc the opaque data strcuture that holds the descriptor
+ * \param[in] desc the opaque data structure that holds the descriptor
  * \returns the status code
  */
 cusolverStatus_t CUSOLVERAPI cusolverMgDestroyMatrixDesc(
--- a/nvidia-cuda/cuda_cudart/include/cuda_egl_interop.h
+++ b/nvidia-cuda/cuda_cudart/include/cuda_egl_interop.h
@@ -360,7 +360,7 @@ extern __host__ cudaError_t CUDARTAPI cu
  *
  * Disconnect CUDA as a consumer to EGLStreamKHR.
  *
- * \param conn            - Conection to disconnect.
+ * \param conn            - Connection to disconnect.
  *
  * \return
  * ::cudaSuccess,
@@ -458,7 +458,7 @@ extern __host__ cudaError_t CUDARTAPI cu
  *
  * Disconnect CUDA as a producer to EGLStreamKHR.
  *
- * \param conn            - Conection to disconnect.
+ * \param conn            - Connection to disconnect.
  *
  * \return
  * ::cudaSuccess,