taskflow/docs/CompileTaskflowWithCUDA.html at master · NcStudios/taskflow · GitHub

History

196 lines (181 loc) · 21.5 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

<!DOCTYPE html>

<head>

<title>Building and Installing » Compile Taskflow with CUDA | Taskflow QuickStart</title>

</head>

<body>

<a href="https://taskflow.github.io"><img src="taskflow_logo.png" alt="" />Taskflow</a> | <a href="index.html" class="m-thin">QuickStart</a>

</svg></a>

</div>

<li><a href="pages.html">Handbook</a></li>

<li><a href="namespaces.html">Namespaces</a></li>

</ol>

<li><a href="annotated.html">Classes</a></li>

<li><a href="files.html">Files</a></li>

</svg></a></li>

</ol>

</div>

</nav></header>

<h1>

<a href="install.html">Building and Installing</a> »

Compile Taskflow with CUDA

</h1>

<h3>Contents</h3>

<ul>

<li><a href="#InstallCUDACompiler">Install CUDA Compiler</a></li>

<li><a href="#CompileTaskflowWithCUDADirectly">Compile Source Code Directly</a></li>

<li>

<a href="#CompileTaskflowWithCUDASeparately">Compile Source Code Separately</a>

<ul>

<li><a href="#CompileTaskflowWithCUDANaiveLinking">Link Objects Using nvcc</a></li>

<li><a href="#CompileTaskflowWithCUDADifferentLinkers">Link Objects Using Different Linkers</a></li>

</ul>

</li>

</ul>

</nav>

<section id="InstallCUDACompiler"><h2><a href="#InstallCUDACompiler">Install CUDA Compiler</a></h2>To compile Taskflow with CUDA code, you need a <code>nvcc</code> compiler. Please visit the official page of <a href="https://developer.nvidia.com/cuda-downloads">Downloading CUDA Toolkit</a>.</section><section id="CompileTaskflowWithCUDADirectly"><h2><a href="#CompileTaskflowWithCUDADirectly">Compile Source Code Directly</a></h2>Taskflow's GPU programming interface for CUDA is <a href="classtf_1_1cudaFlow.html" class="m-doc">tf::cudaFlow</a>. Consider the following <code>simple.cu</code> program that launches a single kernel function to output a message:<pre class="m-code">#include <taskflow/taskflow.hpp>

#include <taskflow/cudaflow.hpp>

#include <taskflow/cuda/for_each.hpp>

int main(int argc, const char** argv) {

tf::Executor executor;

tf::Taskflow taskflow;

tf::Task task2 = taskflow.emplace([](){

// create a cudaFlow of a single-threaded task

tf::cudaFlow cf;

cf.single_task([] __device__ () { printf("hello cudaFlow!\n"); });

// launch the cudaflow through a stream

tf::cudaStream stream;

cf.run(stream);

stream.synchronize();

}).name("gpu task");

task1.precede(task2);

executor.run(taskflow).wait();

return 0;

}</pre>The easiest way to compile Taskflow with CUDA code (e.g., cudaFlow, kernels) is to use <a href="https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html">nvcc</a>:<pre class="m-console">~$ nvcc -std=c++17 -I path/to/taskflow/ --extended-lambda simple.cu -o simple

~$ ./simple

hello cudaFlow!</pre></section><section id="CompileTaskflowWithCUDASeparately"><h2><a href="#CompileTaskflowWithCUDASeparately">Compile Source Code Separately</a></h2>Large GPU applications often compile a program into separate objects and link them together to form an executable or a library. You can compile your CPU code and GPU code separately with Taskflow using <code>nvcc</code> and other compilers (such as <code>g++</code> and <code>clang++</code>). Consider the following example that defines two tasks on two different pieces (<code>main.cpp</code> and <code>cudaflow.cpp</code>) of source code:<pre class="m-code">// main.cpp

#include <taskflow/taskflow.hpp>

tf::Task make_cudaflow(tf::Taskflow& taskflow); // create a cudaFlow task

int main() {

tf::Executor executor;

tf::Taskflow taskflow;

tf::Task task1 = taskflow.emplace([](){ std::cout << "main.cpp!\n"; })

.name("cpu task");

tf::Task task2 = make_cudaflow(taskflow);

task1.precede(task2);

return 0;

}</pre><pre class="m-code">// cudaflow.cpp

#include <taskflow/taskflow.hpp>

#include <taskflow/cudaflow.hpp>

tf::Task make_cudaflow(tf::Taskflow& taskflow) {

return taskflow.emplace([](){

// create a cudaFlow of a single-threaded task

tf::cudaFlow cf;

cf.single_task([] __device__ () { printf("cudaflow.cpp!\n"); });

// launch the cudaflow through a stream

tf::cudaStream stream;

cf.run(stream);

stream.synchronize();

}).name("gpu task");

}</pre>Compile each source to an object (<code>g++</code> as an example):<pre class="m-console">~$ g++ -std=c++17 -I path/to/taskflow -c main.cpp -o main.o

~$ nvcc -std=c++17 --extended-lambda -x cu -I path/to/taskflow \

-dc cudaflow.cpp -o cudaflow.o

~$ ls

# now we have the two compiled .o objects, main.o and cudaflow.o

main.o cudaflow.o </pre>The <code>–extended-lambda</code> option tells <code>nvcc</code> to generate GPU code for the lambda defined with <code>device</code>. The <code>-x cu</code> tells <code>nvcc</code> to treat the input files as .cu files containing both CPU and GPU code. By default, <code>nvcc</code> treats .cpp files as CPU-only code. This option is required to have <code>nvcc</code> generate device code here, but it is also a handy way to avoid renaming source files in larger projects. The <code>–dc</code> option tells <code>nvcc</code> to generate device code for later linking.You may also need to specify the target architecture to tell <code>nvcc</code> to target on a compatible SM architecture using the option -arch. For instance, the following command requires device code linking to have compute capability 7.5 or later:<pre class="m-console">~$ nvcc -std=c++17 --extended-lambda -x cu -arch=sm_75 -I path/to/taskflow \

-dc cudaflow.cpp -o cudaflow.o</pre><section id="CompileTaskflowWithCUDANaiveLinking"><h3><a href="#CompileTaskflowWithCUDANaiveLinking">Link Objects Using nvcc</a></h3>Using <code>nvcc</code> to link compiled object code is nothing special but replacing the normal compiler with <code>nvcc</code> and it takes care of all the necessary steps:<pre class="m-console">~$ nvcc main.o cudaflow.o -o main

# run the main program

~$ ./main

main.cpp!

cudaflow.cpp!</pre></section><section id="CompileTaskflowWithCUDADifferentLinkers"><h3><a href="#CompileTaskflowWithCUDADifferentLinkers">Link Objects Using Different Linkers</a></h3>You can choose to use a compiler other than <code>nvcc</code> for the final link step. Since your CPU compiler does not know how to link CUDA device code, you have to add a step in your build to have <code>nvcc</code> link the CUDA device code, using the option <code>-dlink:</code><pre class="m-console">~$ nvcc -o gpuCode.o -dlink main.o cudaflow.o</pre>This step links all the device object code and places it into <code>gpuCode.o</code>.<aside class="m-note m-warning"><h4>Attention</h4>Note that this step does not link the CPU object code and discards the CPU object code in <code>main.o</code> and <code>cudaflow.o</code>.</aside>To complete the link to an executable, you can use, for example, <code>ld</code> or <code>g++</code>.<pre class="m-console"># replace /usr/local/cuda/lib64 with your own CUDA library installation path

~$ g++ -pthread -L /usr/local/cuda/lib64/ -lcudart \

gpuCode.o main.o cudaflow.o -o main

# run the main program

~$ ./main

main.cpp!

cudaflow.cpp!</pre>We give <code>g++</code> all of the objects again because it needs the CPU object code, which is not in <code>gpuCode.o</code>. The device code stored in the original objects, <code>main.o</code> and <code>cudaflow.o</code>, does not conflict with the code in <code>gpuCode.o</code>. <code>g++</code> ignores device code because it does not know how to link it, and the device code in <code>gpuCode.o</code> is already linked and ready to go.<aside class="m-note m-warning"><h4>Attention</h4>This intentional ignorance is extremely useful in large builds where intermediate objects may have both CPU and GPU code. In this case, we just let the GPU and CPU linkers each do its own job, noting that the CPU linker is always the last one we run. The CUDA <a href="classtf_1_1Runtime.html" class="m-doc">Runtime</a> API library is automatically linked when we use <code>nvcc</code> for linking, but we must explicitly link it (<code>-lcudart</code>) when using another linker.</aside></section></section>

</div>

</article></main>

<div>Tab / T to search, Esc to close</div>

</div>

<form>

</form>

Search for symbols, directories, files, pages or

modules. You can omit any prefix from the symbol or file path; adding a

<code>:</code> or <code>/</code> suffix lists all members of given symbol or

directory.

Use ↓

/ ↑ to navigate through the list,

Enter to go.

Tab autocompletes common prefix, you can

copy a link to the result using ⌘

L while ⌘

M produces a Markdown link.

</div>

<div id="search-notfound" class="m-text m-warning m-text-center">Sorry, nothing was found.</div>

</div>

Taskflow handbook is part of the <a href="https://taskflow.github.io">Taskflow project</a>, copyright © <a href="https://tsung-wei-huang.github.io/">Dr. Tsung-Wei Huang</a>, 2018–2025. Generated by <a href="https://doxygen.org/">Doxygen</a> 1.9.1 and <a href="https://mcss.mosra.cz/">m.css</a>.

</div>

</nav></footer>

</body>

</html>

taskflow/docs/CompileTaskflowWithCUDA.html at master · NcStudios/taskflow · GitHub

Expand file tree

Breadcrumbs

CompileTaskflowWithCUDA.html

Latest commit

History

Breadcrumbs

CompileTaskflowWithCUDA.html

File metadata and controls