added docs for the DeviceInfo class

doc/gpu_initialization.tex

@@ -22,52 +22,97 @@ Returns the current device index, which was set by \cvCppCross{gpu::getDevice} o
 \cvdefCpp{int getDevice();}
 
 
-\cvCppFunc{gpu::getComputeCapability}
-Returns compute capability version for the given device.
+\cvclass{gpu::DeviceInfo}
+This class provides functionality for querying the specified GPU properties. 
 
-\cvdefCpp{void getComputeCapability(int device, int\& major, int\& minor);}
+\begin{lstlisting}
+class CV_EXPORTS DeviceInfo
+{
+public:
+    DeviceInfo();
+    DeviceInfo(int device_id);
+
+    string name() const;
+
+    int major() const;
+    int minor() const;
+
+    int multiProcessorCount() const;
+
+    size_t freeMemory() const;
+    size_t totalMemory() const;
+
+    bool has(GpuFeature feature) const;
+    bool isCompatible() const;
+};
+\end{lstlisting}
+
+
+\cvCppFunc{gpu::DeviceInfo::DeviceInfo}
+Constructs DeviceInfo object for the specified device. If \texttt{device\_id} parameter is missed it constructs object for the current device.
+
+\cvdefCpp{DeviceInfo::DeviceInfo();\newline
+DeviceInfo::DeviceInfo(int device\_id);}
 \begin{description}
-\cvarg{device}{GPU index. Can be obtained via \cvCppCross{gpu::getDevice}.}
-\cvarg{major}{Major CC version.}
-\cvarg{minor}{Minor CC version.}
-\end{description}
-
-\cvCppFunc{gpu::getNumberOfSMs}
-Returns number of Streaming Multiprocessors for given device.
-
-\cvdefCpp{int getNumberOfSMs(int device);}
-\begin{description}
-\cvarg{device}{GPU index. Can be obtained via \cvCppCross{gpu::getDevice}.}
+\cvarg{device\_id}{Index of the GPU device in system starting with 0.}
 \end{description}
 
 
-\cvCppFunc{gpu::getGpuMemInfo}
-Returns free and total memory size for the current device.
+\cvCppFunc{gpu::DeviceInfo::name}
+Returns the device name.
 
-\cvdefCpp{void getGpuMemInfo(size\_t\& free, size\_t\& total);}
+\cvdefCpp{string DeviceInfo::name();}
+
+
+\cvCppFunc{gpu::DeviceInfo::major}
+Returns the major compute capability version.
+
+\cvdefCpp{int DeviceInfo::major();}
+
+
+\cvCppFunc{gpu::DeviceInfo::minor}
+Returns the minor compute capability version.
+
+\cvdefCpp{int DeviceInfo::minor();}
+
+
+\cvCppFunc{gpu::DeviceInfo::multiProcessorCount}
+Returns the number of streaming multiprocessors.
+
+\cvdefCpp{int DeviceInfo::multiProcessorCount();}
+
+
+\cvCppFunc{gpu::DeviceInfo::freeMemory}
+Returns the amount of free memory in bytes.
+
+\cvdefCpp{size\_t DeviceInfo::freeMemory();}
+
+
+\cvCppFunc{gpu::DeviceInfo::totalMemory}
+Returns the amount of total memory in bytes.
+
+\cvdefCpp{size\_t DeviceInfo::totalMemory();}
+
+
+\cvCppFunc{gpu::DeviceInfo::has}
+Returns true if the device has the given GPU feature, otherwise false.
+
+\cvdefCpp{bool DeviceInfo::has(GpuFeature feature);}
 \begin{description}
-\cvarg{free}{Reference to free GPU memory counter.}
-\cvarg{total}{Reference to total GPU memory counter.}
+\cvarg{feature}{Feature to be checked. Available alternatives:
+\begin{itemize}
+\item NATIVE\_DOUBLE Native double operations support
+\item ATOMICS Atomic operations support
+\end{itemize}}
 \end{description}
 
 
-\cvCppFunc{gpu::hasNativeDoubleSupport}
-Returns true, if the specified GPU has native double support, otherwise false.
+\cvCppFunc{gpu::DeviceInfo::isCompatible}
+Returns true if the GPU module can be run on the specified device, otherwise false.
 
-\cvdefCpp{bool hasNativeDoubleSupport(int device);}
-\begin{description}
-\cvarg{device}{GPU index. Can be obtained via \cvCppCross{gpu::getDevice}.}
-\end{description}
+\cvdefCpp{bool DeviceInfo::isCompatible();}
 
 
-\cvCppFunc{gpu::hasAtomicsSupport}
-Returns true, if the specified GPU has atomics support, otherwise false.
-
-\cvdefCpp{bool hasAtomicsSupport(int device);}
-\begin{description}
-\cvarg{device}{GPU index. Can be obtained via \cvCppCross{gpu::getDevice}.}
-\end{description} 
-
 \cvclass{gpu::TargetArchs}
 This class provides functionality (as set of static methods) for checking which NVIDIA card architectures the GPU module was built for.
 
@@ -83,7 +128,7 @@ The following method checks whether the module was built with the support of the
 \end{itemize}}
 \end{description}
 
-There are a set of methods for checking whether the module contains intermediate (PTX) or binary GPU code for the given architecture:
+There are a set of methods for checking whether the module contains intermediate (PTX) or binary GPU code for the given architecture(s):
 \cvdefCpp{
 static bool has(int major, int minor);\newline
 static bool hasPtx(int major, int minor);\newline
@@ -97,14 +142,6 @@ static bool hasEqualOrGreaterBin(int major, int minor);}
 \cvarg{minor}{Minor compute capability version.}
 \end{description}
 
-\cvCppFunc{gpu::isCompatibleWith}
-Returns true, if the GPU module is built with PTX or CUBIN compatible with the given GPU device, otherwise false.
-
-\cvdefCpp{bool isCompatibleWith(int device);}
-\begin{description}
-\cvarg{device}{GPU index. Can be obtained via \cvCppCross{gpu::getDevice}.}
-\end{description}
-
 % By default GPU module is no compiled for devices with compute capability equal to 1.0. So if you run
 
 According to the CUDA C Programming Guide Version 3.2: "PTX code produced for some specific compute capability can always be compiled to binary code of greater or equal compute capability". 

doc/gpu_introduction.tex

@@ -28,7 +28,7 @@ That means for devices with CC 1.3 and 2.0 binary images are ready to run. For a
 
 Devices with compute capability 1.0 are supported by most of GPU functionality now (just compile the library corresponding settings).  There are only a couple things that can not run on it. They are guarded with asserts. But the in future the number will raise, because of CC 1.0 support requires writing special implementation for it. So, It is decided not to spend time for old platform support.
 
-Because of OpenCV can be compiled not for all architectures, there can be binary incompatibility between GPU and code linked to OpenCV. In this case unclear error is returned in arbitrary place. But there is a way to check if the module was build to be able to run on the given device using \cvCppCross{gpu::isCompatibleWith} function.
+Because of OpenCV can be compiled not for all architectures, there can be binary incompatibility between GPU and code linked to OpenCV. In this case unclear error is returned in arbitrary place. But there is a way to check if the module was build to be able to run on the given device using \cvCppCross{gpu::DeviceInfo::isCompatible} function.
 
 
 \subsection{Threading and multi-threading.}