diff options
Diffstat (limited to 'Godeps/_workspace/src/github.com/ethereum/ethash/libethash-cuda/cuPrintf.cuh')
| -rw-r--r-- | Godeps/_workspace/src/github.com/ethereum/ethash/libethash-cuda/cuPrintf.cuh | 162 |
1 files changed, 162 insertions, 0 deletions
diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/libethash-cuda/cuPrintf.cuh b/Godeps/_workspace/src/github.com/ethereum/ethash/libethash-cuda/cuPrintf.cuh new file mode 100644 index 000000000..cf3fe4868 --- /dev/null +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/libethash-cuda/cuPrintf.cuh @@ -0,0 +1,162 @@ +/* + Copyright 2009 NVIDIA Corporation. All rights reserved. + + NOTICE TO LICENSEE: + + This source code and/or documentation ("Licensed Deliverables") are subject + to NVIDIA intellectual property rights under U.S. and international Copyright + laws. + + These Licensed Deliverables contained herein is PROPRIETARY and CONFIDENTIAL + to NVIDIA and is being provided under the terms and conditions of a form of + NVIDIA software license agreement by and between NVIDIA and Licensee ("License + Agreement") or electronically accepted by Licensee. Notwithstanding any terms + or conditions to the contrary in the License Agreement, reproduction or + disclosure of the Licensed Deliverables to any third party without the express + written consent of NVIDIA is prohibited. + + NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE LICENSE AGREEMENT, + NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THESE LICENSED + DELIVERABLES FOR ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED + WARRANTY OF ANY KIND. NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE + LICENSED DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY, + NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE. NOTWITHSTANDING ANY + TERMS OR CONDITIONS TO THE CONTRARY IN THE LICENSE AGREEMENT, IN NO EVENT SHALL + NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, + OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER + IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THESE LICENSED DELIVERABLES. + + U.S. Government End Users. These Licensed Deliverables are a "commercial item" + as that term is defined at 48 C.F.R. 2.101 (OCT 1995), consisting of + "commercial computer software" and "commercial computer software documentation" + as such terms are used in 48 C.F.R. 12.212 (SEPT 1995) and is provided to the + U.S. Government only as a commercial end item. Consistent with 48 C.F.R.12.212 + and 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all U.S. Government + End Users acquire the Licensed Deliverables with only those rights set forth + herein. + + Any use of the Licensed Deliverables in individual and commercial software must + include, in the user documentation and internal comments to the code, the above + Disclaimer and U.S. Government End Users Notice. + */ + +#ifndef CUPRINTF_H +#define CUPRINTF_H + +/* + * This is the header file supporting cuPrintf.cu and defining both + * the host and device-side interfaces. See that file for some more + * explanation and sample use code. See also below for details of the + * host-side interfaces. + * + * Quick sample code: + * + #include "cuPrintf.cu" + + __global__ void testKernel(int val) + { + cuPrintf("Value is: %d\n", val); + } + + int main() + { + cudaPrintfInit(); + testKernel<<< 2, 3 >>>(10); + cudaPrintfDisplay(stdout, true); + cudaPrintfEnd(); + return 0; + } + */ + +/////////////////////////////////////////////////////////////////////////////// +// DEVICE SIDE +// External function definitions for device-side code + +// Abuse of templates to simulate varargs +__device__ int cuPrintf(const char *fmt); +template <typename T1> __device__ int cuPrintf(const char *fmt, T1 arg1); +template <typename T1, typename T2> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2); +template <typename T1, typename T2, typename T3> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3); +template <typename T1, typename T2, typename T3, typename T4> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4); +template <typename T1, typename T2, typename T3, typename T4, typename T5> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5); +template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6); +template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7); +template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8); +template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9); +template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10); + + +// +// cuPrintfRestrict +// +// Called to restrict output to a given thread/block. Pass +// the constant CUPRINTF_UNRESTRICTED to unrestrict output +// for thread/block IDs. Note you can therefore allow +// "all printfs from block 3" or "printfs from thread 2 +// on all blocks", or "printfs only from block 1, thread 5". +// +// Arguments: +// threadid - Thread ID to allow printfs from +// blockid - Block ID to allow printfs from +// +// NOTE: Restrictions last between invocations of +// kernels unless cudaPrintfInit() is called again. +// +#define CUPRINTF_UNRESTRICTED -1 +__device__ void cuPrintfRestrict(int threadid, int blockid); + + + +/////////////////////////////////////////////////////////////////////////////// +// HOST SIDE +// External function definitions for host-side code + +// +// cudaPrintfInit +// +// Call this once to initialise the printf system. If the output +// file or buffer size needs to be changed, call cudaPrintfEnd() +// before re-calling cudaPrintfInit(). +// +// The default size for the buffer is 1 megabyte. For CUDA +// architecture 1.1 and above, the buffer is filled linearly and +// is completely used; however for architecture 1.0, the buffer +// is divided into as many segments are there are threads, even +// if some threads do not call cuPrintf(). +// +// Arguments: +// bufferLen - Length, in bytes, of total space to reserve +// (in device global memory) for output. +// +// Returns: +// cudaSuccess if all is well. +// +extern "C" cudaError_t cudaPrintfInit(size_t bufferLen=1048576); // 1-meg - that's enough for 4096 printfs by all threads put together + +// +// cudaPrintfEnd +// +// Cleans up all memories allocated by cudaPrintfInit(). +// Call this at exit, or before calling cudaPrintfInit() again. +// +extern "C" void cudaPrintfEnd(); + +// +// cudaPrintfDisplay +// +// Dumps the contents of the output buffer to the specified +// file pointer. If the output pointer is not specified, +// the default "stdout" is used. +// +// Arguments: +// outputFP - A file pointer to an output stream. +// showThreadID - If "true", output strings are prefixed +// by "[blockid, threadid] " at output. +// +// Returns: +// cudaSuccess if all is well. +// +extern "C" cudaError_t cudaPrintfDisplay(void *outputFP=NULL, bool showThreadID=false); + +#endif // CUPRINTF_H |