Klagarge/MSE-GPU-Cuda
1
0
Fork 0
Code Issues Pull Requests Releases Activity

feat(rippling): add lab Image Rippling 2D

Browse Source 
- Full compute - Demi compute (optimisation)
This commit is contained in:
Rémi Heredero
2025-11-14 12:34:05 +01:00
parent 3cc8fef087
commit 2daed2f9eb
27 changed files with 493 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
Student_Cuda_Image/.clangd Normal file
View File

@@ -0,0 +1,7 @@
CompileFlags:
Add:
- "-I/home/mse15/CUDA/toStudent/code/WCudaStudent/Student_Cuda_Image/INC_SYMLINK/EXT"
- "-I/home/mse15/CUDA/toStudent/code/WCudaStudent/Student_Cuda_Image/INC_SYMLINK/PROJECT"
---
Diagnostics:
Suppress: "*"

17
Student_Cuda_Image/.zed/tasks.json Normal file
View File

@@ -0,0 +1,17 @@
// Project tasks configuration. See https://zed.dev/docs/tasks for documentation.
//
// Example:
[
{
"label": "Run",
"command": "cbicc cuda clean jall runGL",
"use_new_terminal": false,
"allow_concurrent_runs": false,
"reveal": "always",
"reveal_target": "dock",
"hide": "never",
"shell": "system",
"show_summary": true,
"show_command": true
}
]

2
Student_Cuda_Image/INC_SYMLINK/PROJECT/Mandelbrot.h
View File

@@ -1 +1 @@
/home/bilat/CBI/Dropbox/02_CBI_LINUX/CoursCuda/toStudent/code/WCudaStudent/Student_Cuda_Image/src/core/01_student/02_Mandelbrot/host/Mandelbrot.h /home/mse15/CUDA/toStudent/code/WCudaStudent/Student_Cuda_Image/src/core/01_student/02_Mandelbrot/host/Mandelbrot.h

2
Student_Cuda_Image/INC_SYMLINK/PROJECT/MandelbrotMath.cu.h
View File

@@ -1 +1 @@
/home/bilat/CBI/Dropbox/02_CBI_LINUX/CoursCuda/toStudent/code/WCudaStudent/Student_Cuda_Image/src/core/01_student/02_Mandelbrot/device/math/MandelbrotMath.cu.h /home/mse15/CUDA/toStudent/code/WCudaStudent/Student_Cuda_Image/src/core/01_student/02_Mandelbrot/device/math/MandelbrotMath.cu.h

2
Student_Cuda_Image/INC_SYMLINK/PROJECT/Mandelbrot_BestGrid.h
View File

@@ -1 +1 @@
/home/bilat/CBI/Dropbox/02_CBI_LINUX/CoursCuda/toStudent/code/WCudaStudent/Student_Cuda_Image/src/core/01_student/02_Mandelbrot/host/Mandelbrot_BestGrid.h /home/mse15/CUDA/toStudent/code/WCudaStudent/Student_Cuda_Image/src/core/01_student/02_Mandelbrot/host/Mandelbrot_BestGrid.h

2
Student_Cuda_Image/INC_SYMLINK/PROJECT/Raytracing.h
View File

@@ -1 +1 @@
/home/bilat/CBI/Dropbox/02_CBI_LINUX/CoursCuda/toStudent/code/WCudaStudent/Student_Cuda_Image/src/core/01_student/03_RayTracing/host/Raytracing.h /home/mse15/CUDA/toStudent/code/WCudaStudent/Student_Cuda_Image/src/core/01_student/03_RayTracing/host/Raytracing.h

2
Student_Cuda_Image/INC_SYMLINK/PROJECT/RaytracingMath.cu.h
View File

@@ -1 +1 @@
/home/bilat/CBI/Dropbox/02_CBI_LINUX/CoursCuda/toStudent/code/WCudaStudent/Student_Cuda_Image/src/core/01_student/03_RayTracing/device/math/RaytracingMath.cu.h /home/mse15/CUDA/toStudent/code/WCudaStudent/Student_Cuda_Image/src/core/01_student/03_RayTracing/device/math/RaytracingMath.cu.h

2
Student_Cuda_Image/INC_SYMLINK/PROJECT/Raytracing_BestGrid.h
View File

@@ -1 +1 @@
/home/bilat/CBI/Dropbox/02_CBI_LINUX/CoursCuda/toStudent/code/WCudaStudent/Student_Cuda_Image/src/core/01_student/03_RayTracing/host/Raytracing_BestGrid.h /home/mse15/CUDA/toStudent/code/WCudaStudent/Student_Cuda_Image/src/core/01_student/03_RayTracing/host/Raytracing_BestGrid.h

2
Student_Cuda_Image/INC_SYMLINK/PROJECT/Rippling.h
View File

@@ -1 +1 @@
/home/bilat/CBI/Dropbox/02_CBI_LINUX/CoursCuda/toStudent/code/WCudaStudent/Student_Cuda_Image/src/core/01_student/01_Rippling/host/Rippling.h /home/mse15/CUDA/toStudent/code/WCudaStudent/Student_Cuda_Image/src/core/01_student/01_Rippling/host/Rippling.h

2
Student_Cuda_Image/INC_SYMLINK/PROJECT/RipplingMath.cu.h
View File

@@ -1 +1 @@
/home/bilat/CBI/Dropbox/02_CBI_LINUX/CoursCuda/toStudent/code/WCudaStudent/Student_Cuda_Image/src/core/01_student/01_Rippling/device/math/RipplingMath.cu.h /home/mse15/CUDA/toStudent/code/WCudaStudent/Student_Cuda_Image/src/core/01_student/01_Rippling/device/math/RipplingMath.cu.h

2
Student_Cuda_Image/INC_SYMLINK/PROJECT/Rippling_BestGrid.h
View File

@@ -1 +1 @@
/home/bilat/CBI/Dropbox/02_CBI_LINUX/CoursCuda/toStudent/code/WCudaStudent/Student_Cuda_Image/src/core/01_student/01_Rippling/host/Rippling_BestGrid.h /home/mse15/CUDA/toStudent/code/WCudaStudent/Student_Cuda_Image/src/core/01_student/01_Rippling/host/Rippling_BestGrid.h

2
Student_Cuda_Image/INC_SYMLINK/PROJECT/real_mandelbrot.h
View File

@@ -1 +1 @@
/home/bilat/CBI/Dropbox/02_CBI_LINUX/CoursCuda/toStudent/code/WCudaStudent/Student_Cuda_Image/src/core/01_student/02_Mandelbrot/real_mandelbrot.h /home/mse15/CUDA/toStudent/code/WCudaStudent/Student_Cuda_Image/src/core/01_student/02_Mandelbrot/real_mandelbrot.h

140
Student_Cuda_Image/out/Rippling_justesse.html Normal file
View File

@@ -0,0 +1,140 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<meta http-equiv="content-type" content="text/html; charset=utf-8" />
<meta name="generator" content="CppTest - https://github.com/cpptest/cpptest" />
<title>Rippling_justesse </title>
<style type="text/css" media="screen">
<!--
hr {
width: 100%;
border-width: 0px;
height: 1px;
color: #cccccc;
background-color: #cccccc;
padding: 0px;
}
table {
width:100%;
border-collapse:separate;
border-spacing: 2px;
border:0px;
}
tr {
margin:0px;
padding:0px;
}
td {
margin:0px;
padding:1px;
}
.table_summary {
}
.table_suites {
}
.table_suite {
}
.table_result {
margin: 0px 0px 1em 0px;
}
.tablecell_title {
background-color: #a5cef7;
font-weight: bold;
}
.tablecell_success {
background-color: #efefe7;
}
.tablecell_error {
color: #ff0808;
background-color: #efefe7;
font-weight: bold;
}
p.spaced {
margin: 0px;
padding: 1em 0px 2em 0px;
}
p.unspaced {
margin: 0px;
padding: 0px 0px 2em 0px;
}
-->
</style>
</head>
<body>
<h1><a name="top"></a>Rippling_justesse </h1>
<div style="text-align:right">
Designed by <a href="https://github.com/cpptest/cpptest">CppTest</a>
</div>
<hr />
<h2>Summary</h2>
<table summary="Summary of test results" class="table_summary">
<tr>
<td style="width:30%" class="tablecell_title">Tests</td>
<td style="width:30%" class="tablecell_title">Errors</td>
<td style="width:30%" class="tablecell_title">Success</td>
<td style="width:10%" class="tablecell_title">Time (s)</td>
</tr>
<tr>
<td style="width:30%" class="tablecell_success">1</td>
<td style="width:30%" class="tablecell_success">0</td>
<td style="width:30%" class="tablecell_success">100%</td>
<td style="width:10%" class="tablecell_success">1.000000</td>
</tr>
</table>
<hr />
<h2>Test suites</h2>
<table summary="Test Suites" class="table_suites">
<tr>
<td class="tablecell_title">Name</td>
<td style="width:10%" class="tablecell_title">Tests</td>
<td style="width:10%" class="tablecell_title">Errors</td>
<td style="width:10%" class="tablecell_title">Success</td>
<td style="width:10%" class="tablecell_title">Time (s)</td>
</tr>
<tr>
<td class="tablecell_success"><a href="#TestImageCuda">TestImageCuda</a></td>
<td style="width:10%" class="tablecell_success">1</td>
<td style="width:10%" class="tablecell_success">0</td>
<td style="width:10%" class="tablecell_success">100%</td>
<td style="width:10%" class="tablecell_success">1.000000</td>
</tr>
</table>
<hr />
<h3><a name="TestImageCuda"></a>Suite: TestImageCuda</h3>
<table summary="Details for suite TestImageCuda" class="table_suite">
<tr>
<td class="tablecell_title">Name</td>
<td style="width:10%" class="tablecell_title">Errors</td>
<td style="width:10%" class="tablecell_title">Success</td>
<td style="width:10%" class="tablecell_title">Time (s)</td>
</tr>
<tr>
<td class="tablecell_success">allTests</td>
<td class="tablecell_success">0</td>
<td class="tablecell_success">true</td>
<td class="tablecell_success">1.000000</td>
</tr>
</table>
<p class="spaced"><a href="#top">Back to top</a>
</p>
<hr />
<p>
<a href="http://validator.w3.org/#validate-by-upload">
Valid XHTML 1.0 Strict
</a>
</p>
</body>
</html>

140
Student_Cuda_Image/out/Rippling_performance.html Normal file
View File

@@ -0,0 +1,140 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<meta http-equiv="content-type" content="text/html; charset=utf-8" />
<meta name="generator" content="CppTest - https://github.com/cpptest/cpptest" />
<title>Rippling_performance </title>
<style type="text/css" media="screen">
<!--
hr {
width: 100%;
border-width: 0px;
height: 1px;
color: #cccccc;
background-color: #cccccc;
padding: 0px;
}
table {
width:100%;
border-collapse:separate;
border-spacing: 2px;
border:0px;
}
tr {
margin:0px;
padding:0px;
}
td {
margin:0px;
padding:1px;
}
.table_summary {
}
.table_suites {
}
.table_suite {
}
.table_result {
margin: 0px 0px 1em 0px;
}
.tablecell_title {
background-color: #a5cef7;
font-weight: bold;
}
.tablecell_success {
background-color: #efefe7;
}
.tablecell_error {
color: #ff0808;
background-color: #efefe7;
font-weight: bold;
}
p.spaced {
margin: 0px;
padding: 1em 0px 2em 0px;
}
p.unspaced {
margin: 0px;
padding: 0px 0px 2em 0px;
}
-->
</style>
</head>
<body>
<h1><a name="top"></a>Rippling_performance </h1>
<div style="text-align:right">
Designed by <a href="https://github.com/cpptest/cpptest">CppTest</a>
</div>
<hr />
<h2>Summary</h2>
<table summary="Summary of test results" class="table_summary">
<tr>
<td style="width:30%" class="tablecell_title">Tests</td>
<td style="width:30%" class="tablecell_title">Errors</td>
<td style="width:30%" class="tablecell_title">Success</td>
<td style="width:10%" class="tablecell_title">Time (s)</td>
</tr>
<tr>
<td style="width:30%" class="tablecell_success">1</td>
<td style="width:30%" class="tablecell_success">0</td>
<td style="width:30%" class="tablecell_success">100%</td>
<td style="width:10%" class="tablecell_success">8.000000</td>
</tr>
</table>
<hr />
<h2>Test suites</h2>
<table summary="Test Suites" class="table_suites">
<tr>
<td class="tablecell_title">Name</td>
<td style="width:10%" class="tablecell_title">Tests</td>
<td style="width:10%" class="tablecell_title">Errors</td>
<td style="width:10%" class="tablecell_title">Success</td>
<td style="width:10%" class="tablecell_title">Time (s)</td>
</tr>
<tr>
<td class="tablecell_success"><a href="#TestPerformance_RunnableGPU_A">TestPerformance_RunnableGPU_A</a></td>
<td style="width:10%" class="tablecell_success">1</td>
<td style="width:10%" class="tablecell_success">0</td>
<td style="width:10%" class="tablecell_success">100%</td>
<td style="width:10%" class="tablecell_success">8.000000</td>
</tr>
</table>
<hr />
<h3><a name="TestPerformance_RunnableGPU_A"></a>Suite: TestPerformance_RunnableGPU_A</h3>
<table summary="Details for suite TestPerformance_RunnableGPU_A" class="table_suite">
<tr>
<td class="tablecell_title">Name</td>
<td style="width:10%" class="tablecell_title">Errors</td>
<td style="width:10%" class="tablecell_title">Success</td>
<td style="width:10%" class="tablecell_title">Time (s)</td>
</tr>
<tr>
<td class="tablecell_success">performanceOnly</td>
<td class="tablecell_success">0</td>
<td class="tablecell_success">true</td>
<td class="tablecell_success">8.000000</td>
</tr>
</table>
<p class="spaced"><a href="#top">Back to top</a>
</p>
<hr />
<p>
<a href="http://validator.w3.org/#validate-by-upload">
Valid XHTML 1.0 Strict
</a>
</p>
</body>
</html>

10
Student_Cuda_Image/out/bruteforce/Rippling-Cuda-uchar4_db.csv Normal file
View File

@@ -0,0 +1,10 @@
64,128,192,256,320,384,448,512,576,640,704,768,832,896,960,1024
64,128,192,256,320,384,448,512,576,640,704,768,832,896,960,1024
64,128,192,256,320,384,448,512,576,640,704,768,832,896,960,1024
64,128,192,256,320,384,448,512,576,640,704,768,832,896,960,1024
64,128,192,256,320,384,448,512,576,640,704,768,832,896,960,1024
64,128,192,256,320,384,448,512,576,640,704,768,832,896,960,1024
64,128,192,256,320,384,448,512,576,640,704,768,832,896,960,1024
64,128,192,256,320,384,448,512,576,640,704,768,832,896,960,1024
64,128,192,256,320,384,448,512,576,640,704,768,832,896,960,1024
64,128,192,256,320,384,448,512,576,640,704,768,832,896,960,1024
1 64 128 192 256 320 384 448 512 576 640 704 768 832 896 960 1024
2 64 128 192 256 320 384 448 512 576 640 704 768 832 896 960 1024
3 64 128 192 256 320 384 448 512 576 640 704 768 832 896 960 1024
4 64 128 192 256 320 384 448 512 576 640 704 768 832 896 960 1024
5 64 128 192 256 320 384 448 512 576 640 704 768 832 896 960 1024
6 64 128 192 256 320 384 448 512 576 640 704 768 832 896 960 1024
7 64 128 192 256 320 384 448 512 576 640 704 768 832 896 960 1024
8 64 128 192 256 320 384 448 512 576 640 704 768 832 896 960 1024
9 64 128 192 256 320 384 448 512 576 640 704 768 832 896 960 1024
10 64 128 192 256 320 384 448 512 576 640 704 768 832 896 960 1024

10
Student_Cuda_Image/out/bruteforce/Rippling-Cuda-uchar4_dg.csv Normal file
View File

@@ -0,0 +1,10 @@
68,68,68,68,68,68,68,68,68,68,68,68,68,68,68,68
136,136,136,136,136,136,136,136,136,136,136,136,136,136,136,136
204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204
272,272,272,272,272,272,272,272,272,272,272,272,272,272,272,272
340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,340
408,408,408,408,408,408,408,408,408,408,408,408,408,408,408,408
476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476
544,544,544,544,544,544,544,544,544,544,544,544,544,544,544,544
612,612,612,612,612,612,612,612,612,612,612,612,612,612,612,612
680,680,680,680,680,680,680,680,680,680,680,680,680,680,680,680
1 68 68 68 68 68 68 68 68 68 68 68 68 68 68 68 68
2 136 136 136 136 136 136 136 136 136 136 136 136 136 136 136 136
3 204 204 204 204 204 204 204 204 204 204 204 204 204 204 204 204
4 272 272 272 272 272 272 272 272 272 272 272 272 272 272 272 272
5 340 340 340 340 340 340 340 340 340 340 340 340 340 340 340 340
6 408 408 408 408 408 408 408 408 408 408 408 408 408 408 408 408
7 476 476 476 476 476 476 476 476 476 476 476 476 476 476 476 476
8 544 544 544 544 544 544 544 544 544 544 544 544 544 544 544 544
9 612 612 612 612 612 612 612 612 612 612 612 612 612 612 612 612
10 680 680 680 680 680 680 680 680 680 680 680 680 680 680 680 680

10
Student_Cuda_Image/out/bruteforce/Rippling-Cuda-uchar4_fps.csv Normal file
View File

@@ -0,0 +1,10 @@
144555,220822,213172,232589,222368,222022,221525,218740,215112,220198,212562,211353,203128,207854,210719,208961
178200,227914,225423,225667,225283,223689,214874,217351,189550,187027,176077,174967,175908,173784,170924,182629
212976,225907,222606,224129,213339,213864,204105,204116,170180,174156,180857,200021,186592,189103,180464,178768
220934,223204,216938,218089,214767,210852,205644,204681,182606,186172,175972,178235,171769,171199,162172,162394
212311,227349,214553,217104,211690,204241,202456,209851,166727,167536,161323,164796,154234,155004,147491,147138
198643,222201,217982,217089,212032,203211,198104,196038,154107,155668,149685,148698,142482,142935,134505,133011
216171,220305,209239,214638,200728,193354,184005,187582,144618,145480,136990,136957,131445,130896,123050,125646
209897,217355,213187,210719,199503,185380,179740,178260,132461,134694,129448,129059,121525,123736,116539,123906
206870,215563,213613,212218,194167,175278,170315,167466,125147,125812,119401,120362,114225,119599,114065,119403
205266,207631,213265,202704,185616,170020,163365,159203,116459,118558,112154,116339,113771,115710,113130,115851
1 144555 220822 213172 232589 222368 222022 221525 218740 215112 220198 212562 211353 203128 207854 210719 208961
2 178200 227914 225423 225667 225283 223689 214874 217351 189550 187027 176077 174967 175908 173784 170924 182629
3 212976 225907 222606 224129 213339 213864 204105 204116 170180 174156 180857 200021 186592 189103 180464 178768
4 220934 223204 216938 218089 214767 210852 205644 204681 182606 186172 175972 178235 171769 171199 162172 162394
5 212311 227349 214553 217104 211690 204241 202456 209851 166727 167536 161323 164796 154234 155004 147491 147138
6 198643 222201 217982 217089 212032 203211 198104 196038 154107 155668 149685 148698 142482 142935 134505 133011
7 216171 220305 209239 214638 200728 193354 184005 187582 144618 145480 136990 136957 131445 130896 123050 125646
8 209897 217355 213187 210719 199503 185380 179740 178260 132461 134694 129448 129059 121525 123736 116539 123906
9 206870 215563 213613 212218 194167 175278 170315 167466 125147 125812 119401 120362 114225 119599 114065 119403
10 205266 207631 213265 202704 185616 170020 163365 159203 116459 118558 112154 116339 113771 115710 113130 115851

56
Student_Cuda_Image/src/core/01_student/01_Rippling/device/math/RipplingMath.cu.h
View File

@@ -13,26 +13,24 @@
|* Public *| |* Public *|
\*-------------------------------------*/ \*-------------------------------------*/
class RipplingMath class RipplingMath {
{
/*--------------------------------------*\ /*--------------------------------------*\
|* Constructeur *| |* Constructeur *|
\*-------------------------------------*/ \*-------------------------------------*/
public: public:
__device__ RipplingMath(uint w , uint h , float t) : __device__
RipplingMath(uint w , uint h , float t) :
dim2(w / 2), // dim2(w / 2), //
t(t) t(t) {
{ // rien
// rien
} }
__device__ __device__
virtual ~RipplingMath() virtual ~RipplingMath() {
{
// rien // rien
} }
/*--------------------------------------*\ /*--------------------------------------*\
|* Methode *| |* Methode *|
@@ -41,8 +39,7 @@ class RipplingMath
public: public:
__device__ __device__
void colorIJ(uchar4* ptrColorIJ , int i , int j) void colorIJ(uchar4* ptrColorIJ , int i , int j) {
{
uchar levelGris = levelGray(i, j); // update levelGris uchar levelGris = levelGray(i, j); // update levelGris
ptrColorIJ->x = levelGris; ptrColorIJ->x = levelGris;
@@ -58,13 +55,13 @@ class RipplingMath
// Etape 2: Puis une fois que l'image grise est valider, attaquer rippling // Etape 2: Puis une fois que l'image grise est valider, attaquer rippling
// debug temp // debug temp
// { // {
// ptrColorIJ->x = 128; // ptrColorIJ->x = 128;
// ptrColorIJ->y = 128; // ptrColorIJ->y = 128;
// ptrColorIJ->z = 128; // ptrColorIJ->z = 128;
// ptrColorIJ->w = 255; // opacity facultatif // ptrColorIJ->w = 255; // opacity facultatif
// } // }
} }
private: private:
@@ -74,24 +71,31 @@ class RipplingMath
__inline__ __inline__
__device__ __device__
uchar levelGray(int i , int j ) uchar levelGray(int i , int j ) {
{
float result; float result;
dij(i, j, &result); // warning : dij return void. Ne peut pas etre "imbriquer dans une fonction" dij(i, j, &result); // warning : dij return void. Ne peut pas etre "imbriquer dans une fonction"
result = result / 10.f; result = result / 10.f;
result = 128.f + 127.f * cosf(result - (t / 7.f)) / (result + 1.f);
return (uchar)result;
// TODO Rippling GPU : cf formules math rippling.pdf (attribut dim2 = dim/2 // TODO Rippling GPU : cf formules math rippling.pdf (attribut dim2 = dim/2
} }
__inline__ __inline__
__device__ __device__
void dij(int i , int j , float* ptrResult) void dij(int i , int j , float* ptrResult) {
{
//TODO Rippling GPU cf fonction math pdf //TODO Rippling GPU cf fonction math pdf
float fi = i - dim2;
float fj = j - dim2;
float d = sqrtf(fi * fi + fj * fj);
*ptrResult = d;
// Ne pas utiliser la fonction pow pour elever au carrer ! // Ne pas utiliser la fonction pow pour elever au carrer !
// Utiliser l'opérateur * // Utiliser l'opérateur *
} }
/*--------------------------------------*\ /*--------------------------------------*\
|* Attribut *| |* Attribut *|
@@ -103,7 +107,7 @@ class RipplingMath
int dim2; // dim2=dim/2 int dim2; // dim2=dim/2
float t; float t;
}; };
/*----------------------------------------------------------------------*\ /*----------------------------------------------------------------------*\
|* End *| |* End *|

61
Student_Cuda_Image/src/core/01_student/01_Rippling/device/ripplingDevice.cu
View File

@@ -18,12 +18,11 @@ static __device__ void ripplingQuart(uchar4* tabPixelsGM , uint w , uint h , flo
|* Implementation *| |* Implementation *|
\*---------------------------------------------------------------------*/ \*---------------------------------------------------------------------*/
__global__ void rippling(uchar4* tabPixelsGM , uint w , uint h , float t) __global__ void rippling(uchar4* tabPixelsGM , uint w , uint h , float t) {
{ // ripplingBaseline(tabPixelsGM, w, h, t);
ripplingBaseline(tabPixelsGM, w, h, t); ripplingDemi(tabPixelsGM, w, h, t);
// ripplingDemi(tabPixelsGM, w, h, t);
// ripplingQuart(tabPixelsGM, w, h, t); // ripplingQuart(tabPixelsGM, w, h, t);
} }
/*----------------------------------------------------------------------*\ /*----------------------------------------------------------------------*\
|* private *| |* private *|
@@ -33,23 +32,36 @@ __global__ void rippling(uchar4* tabPixelsGM , uint w , uint h , float t)
* v1 * v1
*/ */
__inline__ __inline__
__device__ void ripplingBaseline(uchar4* tabPixelsGM , uint w , uint h , float t) __device__
{ void ripplingBaseline(uchar4* tabPixelsGM , uint w , uint h , float t) {
// TODO instacier RipplingMath // TODO instacier RipplingMath
RipplingMath rgM = RipplingMath(w, h, t);
const int TID = Thread2D::tid(); const int TID = Thread2D::tid();
const int NB_THREAD = Thread2D::nbThread(); const int NB_THREAD = Thread2D::nbThread();
const int WH = w * h; const int WH = w * h;
// TODO Rippling GPU pattern entrelacement // TODO Rippling GPU pattern entrelacement
int s = TID;
while(s < WH) {
int i = s / w;
int j = s % w;
uchar4 color;
rgM.colorIJ(&color, i, j);
tabPixelsGM[s] = color;
s += NB_THREAD;
} }
}
/** /**
* v2 : optimisation * v2 : optimisation
*/ */
__inline__ __inline__
__device__ void ripplingDemi(uchar4* tabPixelsGM , uint w , uint h , float t) __device__
{ void ripplingDemi(uchar4* tabPixelsGM , uint w , uint h , float t) {
// Indication: // Indication:
// (I1) Utiliser la symetrie horizontale de l'image // (I1) Utiliser la symetrie horizontale de l'image
// (I2) Calculer que la demi partie superieur // (I2) Calculer que la demi partie superieur
@@ -57,14 +69,36 @@ __device__ void ripplingDemi(uchar4* tabPixelsGM , uint w , uint h , float t)
// Partez de la fin de l'image, peut-etre // Partez de la fin de l'image, peut-etre
// TODO Rippling GPU // TODO Rippling GPU
RipplingMath rgM = RipplingMath(w, h, t);
const int TID = Thread2D::tid();
const int NB_THREAD = Thread2D::nbThread();
const int WH = w * h;
const int WH2 = (WH / 2) + 1;
int s = TID;
while(s < WH2) {
int i = s / w;
int j = s % w;
uchar4 color;
rgM.colorIJ(&color, i, j);
tabPixelsGM[s] = color;
// Miroir
int si = WH - s - 1;
tabPixelsGM[si] = color;
s += NB_THREAD;
} }
}
/** /**
* v3 : optimsation : defi (difficile) (pas necessaire pour test performance) * v3 : optimsation : defi (difficile) (pas necessaire pour test performance)
*/ */
__inline__ __inline__
__device__ void ripplingQuart(uchar4* tabPixelsGM , uint w , uint h , float t) __device__
{ void ripplingQuart(uchar4* tabPixelsGM , uint w , uint h , float t) {
// Indication: // Indication:
// (I1) Utiliser la symetrie horizontale et verticale de l'image // (I1) Utiliser la symetrie horizontale et verticale de l'image
// (I2) Calculer que le quart en huat a gauche // (I2) Calculer que le quart en huat a gauche
@@ -76,9 +110,8 @@ __device__ void ripplingQuart(uchar4* tabPixelsGM , uint w , uint h , float t)
// (C1) Utiliser toujours le pattern d'entrelacement // (C1) Utiliser toujours le pattern d'entrelacement
// TODO Rippling GPU // TODO Rippling GPU
} }
/*----------------------------------------------------------------------*\ /*----------------------------------------------------------------------*\
|* End *| |* End *|
\*---------------------------------------------------------------------*/ \*---------------------------------------------------------------------*/

23
Student_Cuda_Image/src/core/01_student/01_Rippling/host/Rippling.cu
View File

@@ -24,19 +24,17 @@ extern __global__ void rippling(uchar4* tabPixelsGM,uint w, uint h,float t);
\*-------------------------*/ \*-------------------------*/
Rippling::Rippling(const Grid& grid , uint w , uint h , float dt , bool isVerbose) : Rippling::Rippling(const Grid& grid , uint w , uint h , float dt , bool isVerbose) :
Animable_I<uchar4>(grid, w, h, "Rippling-Cuda-uchar4", isVerbose) // super classe Animable_I<uchar4>(grid, w, h, "Rippling-Cuda-uchar4", isVerbose) { // super classe
{
assert(w == h); // specific rippling assert(w == h); // specific rippling
// Animation // Animation
this->dt = dt; this->dt = dt;
this->t = 0; // protected dans Animable this->t = 0; // protected dans Animable
} }
Rippling::~Rippling() Rippling::~Rippling() {
{
// rien // rien
} }
/*-------------------------*\ /*-------------------------*\
|* Methode *| |* Methode *|
@@ -48,25 +46,22 @@ Rippling::~Rippling()
* *
* Note : domaineMath pas use car image pas zoomable * Note : domaineMath pas use car image pas zoomable
*/ */
void Rippling::process(uchar4* tabPixelsGM , uint w , uint h , const DomaineMath& domaineMath) void Rippling::process(uchar4* tabPixelsGM , uint w , uint h , const DomaineMath& domaineMath) {
{
// TODO Rippling // TODO Rippling
// lancer le kernel avec <<<dg,db>>> // lancer le kernel avec <<<dg,db>>>
// le kernel est importer ci-dessus (ligne 19) // le kernel est importer ci-dessus (ligne 19)
assert(false); // to delete once implement rippling<<<dg,db>>>(tabPixelsGM,w,h,t);
} }
/** /**
* Override * Override
* Call periodicly by the API * Call periodicly by the API
*/ */
void Rippling::animationStep() void Rippling::animationStep() {
{
t += dt; t += dt;
} }
/*----------------------------------------------------------------------*\ /*----------------------------------------------------------------------*\
|* End *| |* End *|
\*---------------------------------------------------------------------*/ \*---------------------------------------------------------------------*/

5
Student_Cuda_Image/src/core/01_student/01_Rippling/host/Rippling.h
View File

@@ -10,8 +10,7 @@
|* Declaration *| |* Declaration *|
\*---------------------------------------------------------------------*/ \*---------------------------------------------------------------------*/
class Rippling: public Animable_I<uchar4> class Rippling: public Animable_I<uchar4> {
{
/*--------------------------------------*\ /*--------------------------------------*\
|* Constructor *| |* Constructor *|
\*-------------------------------------*/ \*-------------------------------------*/
@@ -50,7 +49,7 @@ class Rippling: public Animable_I<uchar4>
// Inputs // Inputs
float dt; float dt;
}; };
/*----------------------------------------------------------------------*\ /*----------------------------------------------------------------------*\
|* End *| |* End *|

21
Student_Cuda_Image/src/core/01_student/01_Rippling/host/Rippling_BestGrid.h
View File

@@ -11,30 +11,27 @@
|* Impelmentation *| |* Impelmentation *|
\*---------------------------------------------------------------------*/ \*---------------------------------------------------------------------*/
namespace rippling namespace rippling {
{
class BestGrid class BestGrid {
{
public: public:
static Grid get() static Grid get() {
{
const int MP = Hardware::getMPCount(); const int MP = Hardware::getMPCount();
const int CORE_MP = Hardware::getCoreCountMP(); const int CORE_MP = Hardware::getCoreCountMP();
// TODO Rippling // TODO Rippling
dim3 dg(MP, 1, 1);
dim3 db(CORE_MP, 4, 1);
Grid grid(dg, db);
return grid;
// to remove once coded
{
Couts::redln("aie aie aie, your best grid won t build itself");
assert(false);
}
} }
}; };
} }
/*----------------------------------------------------------------------*\ /*----------------------------------------------------------------------*\
|* End *| |* End *|

26
Student_Cuda_Image/src/main/main.cpp
View File

@@ -24,34 +24,32 @@ extern int mainTest();
|* Implementation *| |* Implementation *|
\*---------------------------------------------------------------------*/ \*---------------------------------------------------------------------*/
int main(int argc , char** argv) int main(int argc , char** argv) {
{
CudaContextImage cudaContext; CudaContextImage cudaContext;
// public // public
{ {
cudaContext.deviceId = 2; // in [0,2] width Server Cuda3 cudaContext.deviceId = 2; // in [0,2] width Server Cuda3
cudaContext.launchMode = LaunchModeImage::IMAGE; // IMAGE BENCHMARKING BRUTFORCE TESTING cudaContext.launchMode = LaunchModeImage::TESTING; // IMAGE BENCHMARKING BRUTFORCE TESTING
cudaContext.deviceDriver = DeviceDriver::LOAD_CURRENT; // LOAD_CURRENT LOAD_ALL cudaContext.deviceDriver = DeviceDriver::LOAD_CURRENT; // LOAD_CURRENT LOAD_ALL
cudaContext.deviceInfo = DeviceInfo::ALL_SIMPLE; // NONE ALL ALL_SIMPLE CURRENT cudaContext.deviceInfo = DeviceInfo::ALL_SIMPLE; // NONE ALL ALL_SIMPLE CURRENT
} }
// private // private
{ {
cudaContext.args.argc = argc; cudaContext.args.argc = argc;
cudaContext.args.argv = argv; cudaContext.args.argv = argv;
cudaContext.mainImage = mainImage; cudaContext.mainImage = mainImage;
cudaContext.mainBenchmark = mainBenchmark; cudaContext.mainBenchmark = mainBenchmark;
cudaContext.mainBrutforce = mainBrutforce; cudaContext.mainBrutforce = mainBrutforce;
cudaContext.mainTest = mainTest; cudaContext.mainTest = mainTest;
} }
return cudaContext.process(); return cudaContext.process();
} }
/*----------------------------------------------------------------------*\ /*----------------------------------------------------------------------*\
|* End *| |* End *|
\*---------------------------------------------------------------------*/ \*---------------------------------------------------------------------*/

36
Student_Cuda_Image/src/main/mainBenchmark.cpp
View File

@@ -32,8 +32,7 @@ static void raytracingCM2SM();
|* Implementation *| |* Implementation *|
\*---------------------------------------------------------------------*/ \*---------------------------------------------------------------------*/
int mainBenchmark() int mainBenchmark() {
{
// Please, un a la fois! // Please, un a la fois!
rippling(); rippling();
// mandelbrot(); // Conseil : use nFixe (by example nMin=nMax=80) // mandelbrot(); // Conseil : use nFixe (by example nMin=nMax=80)
@@ -44,67 +43,60 @@ int mainBenchmark()
// raytracingCM2SM(); // raytracingCM2SM();
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
/*--------------------------------------*\ /*--------------------------------------*\
|* Private *| |* Private *|
\*-------------------------------------*/ \*-------------------------------------*/
void rippling() void rippling() {
{
const double DURATION_MAX_S = 8; const double DURATION_MAX_S = 8;
RipplingProvider provider; RipplingProvider provider;
BenchmarkImage<uchar4>::run(&provider, DURATION_MAX_S); BenchmarkImage<uchar4>::run(&provider, DURATION_MAX_S);
} }
void mandelbrot() void mandelbrot() {
{
const double DURATION_MAX_S = 8; const double DURATION_MAX_S = 8;
MandelbrotProvider provider; MandelbrotProvider provider;
BenchmarkImage<uchar4>::run(&provider, DURATION_MAX_S); BenchmarkImage<uchar4>::run(&provider, DURATION_MAX_S);
} }
void raytracingGM() void raytracingGM() {
{
const double DURATION_MAX_S = 8; const double DURATION_MAX_S = 8;
RaytracingProviderGM provider; RaytracingProviderGM provider;
BenchmarkImage<uchar4>::run(&provider, DURATION_MAX_S); BenchmarkImage<uchar4>::run(&provider, DURATION_MAX_S);
} }
void raytracingCM() void raytracingCM() {
{
const double DURATION_MAX_S = 8; const double DURATION_MAX_S = 8;
RaytracingProviderCM provider; RaytracingProviderCM provider;
BenchmarkImage<uchar4>::run(&provider, DURATION_MAX_S); BenchmarkImage<uchar4>::run(&provider, DURATION_MAX_S);
} }
void raytracingSM() void raytracingSM() {
{
const double DURATION_MAX_S = 8; const double DURATION_MAX_S = 8;
RaytracingProviderSM provider; RaytracingProviderSM provider;
BenchmarkImage<uchar4>::run(&provider, DURATION_MAX_S); BenchmarkImage<uchar4>::run(&provider, DURATION_MAX_S);
} }
void raytracingCM2SM() void raytracingCM2SM() {
{
const double DURATION_MAX_S = 8; const double DURATION_MAX_S = 8;
RaytracingProviderCM2SM provider; RaytracingProviderCM2SM provider;
BenchmarkImage<uchar4>::run(&provider, DURATION_MAX_S); BenchmarkImage<uchar4>::run(&provider, DURATION_MAX_S);
} }
/*----------------------------------------------------------------------*\ /*----------------------------------------------------------------------*\
|* End *| |* End *|
\*---------------------------------------------------------------------*/ \*---------------------------------------------------------------------*/

40
Student_Cuda_Image/src/main/mainBruteforce.cpp
View File

@@ -40,8 +40,7 @@ static void bruteForce(ProviderUse_I* ptrProviderUse , Matlab* ptrMatlab , const
|* Implementation *| |* Implementation *|
\*---------------------------------------------------------------------*/ \*---------------------------------------------------------------------*/
int mainBrutforce() int mainBrutforce() {
{
Matlab matlab; Matlab matlab;
// Please, un a la fois! // Please, un a la fois!
@@ -55,73 +54,66 @@ int mainBrutforce()
matlab.play(); matlab.play();
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
/*--------------------------------------*\ /*--------------------------------------*\
|* Private *| |* Private *|
\*-------------------------------------*/ \*-------------------------------------*/
void rippling(Matlab* ptrMatlab) void rippling(Matlab* ptrMatlab) {
{
const double DURATION_MAX_S = 0.01; // 0.9 1 grid const double DURATION_MAX_S = 0.01; // 0.9 1 grid
const PlotType PLOT_TYPE = PlotType::ALL_GRAPHE; const PlotType PLOT_TYPE = PlotType::ALL_GRAPHE;
RipplingProvider provider; RipplingProvider provider;
bruteForce<uchar4>((ProviderUse_I*)&provider, ptrMatlab, PLOT_TYPE, DURATION_MAX_S); bruteForce<uchar4>((ProviderUse_I*)&provider, ptrMatlab, PLOT_TYPE, DURATION_MAX_S);
} }
void mandelbrot(Matlab* ptrMatlab) void mandelbrot(Matlab* ptrMatlab) {
{
const double DURATION_MAX_S = 0.4; // 1 grid const double DURATION_MAX_S = 0.4; // 1 grid
const PlotType PLOT_TYPE = PlotType::ALL_GRAPHE; const PlotType PLOT_TYPE = PlotType::ALL_GRAPHE;
MandelbrotProvider provider; MandelbrotProvider provider;
bruteForce<uchar4>((ProviderUse_I*)&provider, ptrMatlab, PLOT_TYPE, DURATION_MAX_S); bruteForce<uchar4>((ProviderUse_I*)&provider, ptrMatlab, PLOT_TYPE, DURATION_MAX_S);
} }
void raytracingGM(Matlab* ptrMatlab) void raytracingGM(Matlab* ptrMatlab) {
{
const double DURATION_MAX_S = 0.9; // 1 grid const double DURATION_MAX_S = 0.9; // 1 grid
const PlotType PLOT_TYPE = PlotType::ALL_GRAPHE; const PlotType PLOT_TYPE = PlotType::ALL_GRAPHE;
RaytracingProviderGM provider; RaytracingProviderGM provider;
bruteForce<uchar4>((ProviderUse_I*)&provider, ptrMatlab, PLOT_TYPE, DURATION_MAX_S); bruteForce<uchar4>((ProviderUse_I*)&provider, ptrMatlab, PLOT_TYPE, DURATION_MAX_S);
} }
void raytracingSM(Matlab* ptrMatlab) void raytracingSM(Matlab* ptrMatlab) {
{
const double DURATION_MAX_S = 0.9; // 1 grid const double DURATION_MAX_S = 0.9; // 1 grid
const PlotType PLOT_TYPE = PlotType::ALL_GRAPHE; const PlotType PLOT_TYPE = PlotType::ALL_GRAPHE;
RaytracingProviderSM provider; RaytracingProviderSM provider;
bruteForce<uchar4>((ProviderUse_I*)&provider, ptrMatlab, PLOT_TYPE, DURATION_MAX_S); bruteForce<uchar4>((ProviderUse_I*)&provider, ptrMatlab, PLOT_TYPE, DURATION_MAX_S);
} }
void raytracingCM(Matlab* ptrMatlab) void raytracingCM(Matlab* ptrMatlab) {
{
const double DURATION_MAX_S = 0.9; // 1 grid const double DURATION_MAX_S = 0.9; // 1 grid
const PlotType PLOT_TYPE = PlotType::ALL_GRAPHE; const PlotType PLOT_TYPE = PlotType::ALL_GRAPHE;
RaytracingProviderCM provider; RaytracingProviderCM provider;
bruteForce<uchar4>((ProviderUse_I*)&provider, ptrMatlab, PLOT_TYPE, DURATION_MAX_S); bruteForce<uchar4>((ProviderUse_I*)&provider, ptrMatlab, PLOT_TYPE, DURATION_MAX_S);
} }
void raytracingCM2SM(Matlab* ptrMatlab) void raytracingCM2SM(Matlab* ptrMatlab) {
{
const double DURATION_MAX_S = 0.9; // 1 grid const double DURATION_MAX_S = 0.9; // 1 grid
const PlotType PLOT_TYPE = PlotType::ALL_GRAPHE; const PlotType PLOT_TYPE = PlotType::ALL_GRAPHE;
RaytracingProviderCM2SM provider; RaytracingProviderCM2SM provider;
bruteForce<uchar4>((ProviderUse_I*)&provider, ptrMatlab, PLOT_TYPE, DURATION_MAX_S); bruteForce<uchar4>((ProviderUse_I*)&provider, ptrMatlab, PLOT_TYPE, DURATION_MAX_S);
} }
/*--------------------------------------*\ /*--------------------------------------*\
|* Tools *| |* Tools *|
\*-------------------------------------*/ \*-------------------------------------*/
template<typename T> template<typename T>
void bruteForce(ProviderUse_I* ptrProviderUse , Matlab* ptrMatlab , const PlotType& plotType , double durationMaxS) void bruteForce(ProviderUse_I* ptrProviderUse , Matlab* ptrMatlab , const PlotType& plotType , double durationMaxS) {
{
// Hardware // Hardware
const int MP = Hardware::getMPCount(); const int MP = Hardware::getMPCount();
const int CORE_MP = Hardware::getCoreCountMP(); const int CORE_MP = Hardware::getCoreCountMP();
@@ -140,7 +132,7 @@ void bruteForce(ProviderUse_I* ptrProviderUse , Matlab* ptrMatlab , const PlotTy
GridMaillage gridMaillage(iteratorDGx, iteratorDBx); GridMaillage gridMaillage(iteratorDGx, iteratorDBx);
BruteForce::run(ptrProviderUse, &gridMaillage, ptrMatlab, plotType, durationMaxS); BruteForce::run(ptrProviderUse, &gridMaillage, ptrMatlab, plotType, durationMaxS);
} }
/*----------------------------------------------------------------------*\ /*----------------------------------------------------------------------*\
|* End *| |* End *|

6
Student_Cuda_Image/src/main/mainImage.cpp
View File

@@ -24,8 +24,7 @@ using std::string;
|* Implementation *| |* Implementation *|
\*---------------------------------------------------------------------*/ \*---------------------------------------------------------------------*/
int mainImage(const Args& args) int mainImage(const Args& args) {
{
gpu::GLUTImageViewers::init(args.argc, args.argv); //only once gpu::GLUTImageViewers::init(args.argc, args.argv); //only once
// ImageOption : (boolean,boolean) : (isSelection ,isAnimation,isOverlay,isShowHelp) // ImageOption : (boolean,boolean) : (isSelection ,isAnimation,isOverlay,isShowHelp)
@@ -43,9 +42,8 @@ int mainImage(const Args& args)
gpu::GLUTImageViewers::runALL(); // Bloquant, Tant qu'une fenetre est ouverte gpu::GLUTImageViewers::runALL(); // Bloquant, Tant qu'une fenetre est ouverte
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
/*----------------------------------------------------------------------*\ /*----------------------------------------------------------------------*\
|* End *| |* End *|
\*---------------------------------------------------------------------*/ \*---------------------------------------------------------------------*/

21
Student_Cuda_Image/src/main/mainTest.cpp
View File

@@ -31,8 +31,7 @@ static void raytracing();
|* Public *| |* Public *|
\*-------------------------------------*/ \*-------------------------------------*/
int mainTest() int mainTest() {
{
// activer ci-dessous seulement le TP voulu (pas tous) // activer ci-dessous seulement le TP voulu (pas tous)
rippling(); rippling();
@@ -40,36 +39,33 @@ int mainTest()
//raytracing(); // voir code ci-dessous pour activer la version voulue //raytracing(); // voir code ci-dessous pour activer la version voulue
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
/*--------------------------------------*\ /*--------------------------------------*\
|* private *| |* private *|
\*-------------------------------------*/ \*-------------------------------------*/
void rippling() void rippling() {
{
VTRippling test1; VTRippling test1;
test1.run(); test1.run();
} }
/** /**
* fp16 only * fp16 only
*/ */
void mandelbrot() void mandelbrot() {
{
assert(mandelbrotReal::isFp16()); assert(mandelbrotReal::isFp16());
VTMandelbrot test1; VTMandelbrot test1;
test1.run(); test1.run();
} }
/** /**
* activer ci-dessous la version souhaiter * activer ci-dessous la version souhaiter
*/ */
void raytracing() void raytracing() {
{
VTRaytracingGM test1; VTRaytracingGM test1;
VTRaytracingSM test2; VTRaytracingSM test2;
VTRaytracingCM test3; VTRaytracingCM test3;
@@ -79,9 +75,8 @@ void raytracing()
// test2.run(); // test2.run();
// test3.run(); // test3.run();
// test4.run(); // test4.run();
} }
/*----------------------------------------------------------------------*\ /*----------------------------------------------------------------------*\
|* End *| |* End *|
\*---------------------------------------------------------------------*/ \*---------------------------------------------------------------------*/