Skip to content

Commit b0cd34d

Browse files
rafbielsrafbiels
authored
Change clang-format style and add GitHub workflow (#381)
1 parent bb0c8c8 commit b0cd34d

File tree

41 files changed

+495
-479
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

41 files changed

+495
-479
lines changed

‎.clang-format

+18-8
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,18 @@
1-
Language: Cpp
2-
BasedOnStyle: LLVM
3-
AccessModifierOffset: -1
4-
BreakInheritanceList: BeforeComma
5-
BreakConstructorInitializers: BeforeComma
6-
Cpp11BracedListStyle: false
7-
PointerAlignment: Left
8-
SpaceBeforeCpp11BracedList: true
1+
BasedOnStyle: Google
2+
IncludeCategories:
3+
- Regex: '^<sycl/.*>$'
4+
Priority: 3
5+
SortPriority: 0
6+
CaseSensitive: false
7+
- Regex: '^<.*\.h>'
8+
Priority: 1
9+
SortPriority: 0
10+
CaseSensitive: false
11+
- Regex: '^<.*'
12+
Priority: 2
13+
SortPriority: 0
14+
CaseSensitive: false
15+
- Regex: '.*'
16+
Priority: 4
17+
SortPriority: 0
18+
CaseSensitive: false

‎.github/workflows/clang-format.yml

+17
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
name: clang-format check
2+
on: [push, pull_request]
3+
permissions:
4+
contents: read
5+
jobs:
6+
clang-format:
7+
name: clang-format check
8+
runs-on: ubuntu-latest
9+
steps:
10+
- uses: actions/checkout@v4
11+
- name: clang-format
12+
uses: jidicula/[email protected]
13+
with:
14+
clang-format-version: '19'
15+
check-path: 'Code_Exercises'
16+
fallback-style: 'Google'
17+
include-regex: '^.*\.(((c|C)(c|pp|xx|\+\+)?$)|((h|H)h?(pp|xx|\+\+)?$))$'

‎Code_Exercises/Advanced_Data_Flow/solution.cpp

+20-20
Original file line numberDiff line numberDiff line change
@@ -8,18 +8,18 @@
88
work. If not, see <http://creativecommons.org/licenses/by-sa/4.0/>.
99
*/
1010

11-
#include "../helpers.hpp"
1211
#include <sycl/sycl.hpp>
1312

13+
#include "../helpers.hpp"
14+
1415
class kernel_a_1;
1516
class kernel_b_1;
1617
class kernel_a_2;
1718
class kernel_b_2;
1819

1920
int usm_selector(const sycl::device& dev) {
2021
if (dev.has(sycl::aspect::usm_device_allocations)) {
21-
if (dev.has(sycl::aspect::gpu))
22-
return 2;
22+
if (dev.has(sycl::aspect::gpu)) return 2;
2323
return 1;
2424
}
2525
return -1;
@@ -35,31 +35,31 @@ void test_buffer() {
3535
}
3636

3737
try {
38-
auto gpuQueue = sycl::queue { sycl::gpu_selector_v };
38+
auto gpuQueue = sycl::queue{sycl::gpu_selector_v};
3939

40-
auto bufIn = sycl::buffer { in, sycl::range { dataSize } };
41-
auto bufInt = sycl::buffer<float> { sycl::range { dataSize } };
42-
auto bufOut = sycl::buffer<float> { sycl::range { dataSize } };
40+
auto bufIn = sycl::buffer{in, sycl::range{dataSize}};
41+
auto bufInt = sycl::buffer<float>{sycl::range{dataSize}};
42+
auto bufOut = sycl::buffer<float>{sycl::range{dataSize}};
4343

4444
bufIn.set_final_data(nullptr);
4545
bufOut.set_final_data(out);
4646

4747
gpuQueue.submit([&](sycl::handler& cgh) {
48-
sycl::accessor accIn { bufIn, cgh, sycl::read_only };
49-
sycl::accessor accOut { bufInt, cgh, sycl::write_only };
48+
sycl::accessor accIn{bufIn, cgh, sycl::read_only};
49+
sycl::accessor accOut{bufInt, cgh, sycl::write_only};
5050

51-
cgh.parallel_for<kernel_a_1>(
52-
sycl::range { dataSize },
53-
[=](sycl::id<1> idx) { accOut[idx] = accIn[idx] * 8.0f; });
51+
cgh.parallel_for<kernel_a_1>(sycl::range{dataSize}, [=](sycl::id<1> idx) {
52+
accOut[idx] = accIn[idx] * 8.0f;
53+
});
5454
});
5555

5656
gpuQueue.submit([&](sycl::handler& cgh) {
57-
sycl::accessor accIn { bufInt, cgh, sycl::read_only };
58-
sycl::accessor accOut { bufOut, cgh, sycl::write_only };
57+
sycl::accessor accIn{bufInt, cgh, sycl::read_only};
58+
sycl::accessor accOut{bufOut, cgh, sycl::write_only};
5959

60-
cgh.parallel_for<kernel_b_1>(
61-
sycl::range { dataSize },
62-
[=](sycl::id<1> idx) { accOut[idx] = accIn[idx] / 2.0f; });
60+
cgh.parallel_for<kernel_b_1>(sycl::range{dataSize}, [=](sycl::id<1> idx) {
61+
accOut[idx] = accIn[idx] / 2.0f;
62+
});
6363
});
6464

6565
gpuQueue.wait_and_throw();
@@ -82,7 +82,7 @@ void test_usm() {
8282
}
8383

8484
try {
85-
auto usmQueue = sycl::queue { usm_selector };
85+
auto usmQueue = sycl::queue{usm_selector};
8686

8787
auto devicePtrIn = sycl::malloc_device<float>(dataSize, usmQueue);
8888
auto devicePtrInt = sycl::malloc_device<float>(dataSize, usmQueue);
@@ -91,13 +91,13 @@ void test_usm() {
9191
auto e1 = usmQueue.memcpy(devicePtrIn, in, sizeof(float) * dataSize);
9292

9393
auto e2 = usmQueue.parallel_for<kernel_a_2>(
94-
sycl::range { dataSize }, e1, [=](sycl::id<1> idx) {
94+
sycl::range{dataSize}, e1, [=](sycl::id<1> idx) {
9595
auto globalId = idx[0];
9696
devicePtrInt[globalId] = devicePtrIn[globalId] * 8.0f;
9797
});
9898

9999
auto e3 = usmQueue.parallel_for<kernel_b_2>(
100-
sycl::range { dataSize }, e2, [=](sycl::id<1> idx) {
100+
sycl::range{dataSize}, e2, [=](sycl::id<1> idx) {
101101
auto globalId = idx[0];
102102
devicePtrOut[globalId] = devicePtrInt[globalId] / 2.0f;
103103
});

‎Code_Exercises/Asynchronous_Execution/solution.cpp

+55-55
Original file line numberDiff line numberDiff line change
@@ -8,9 +8,10 @@
88
work. If not, see <http://creativecommons.org/licenses/by-sa/4.0/>.
99
*/
1010

11-
#include "../helpers.hpp"
1211
#include <sycl/sycl.hpp>
1312

13+
#include "../helpers.hpp"
14+
1415
class vector_add_1;
1516
class vector_add_2;
1617
class vector_add_3;
@@ -20,8 +21,7 @@ class vector_add_6;
2021

2122
int usm_selector(const sycl::device& dev) {
2223
if (dev.has(sycl::aspect::usm_device_allocations)) {
23-
if (dev.has(sycl::aspect::gpu))
24-
return 2;
24+
if (dev.has(sycl::aspect::gpu)) return 2;
2525
return 1;
2626
}
2727
return -1;
@@ -38,26 +38,26 @@ void test_buffer_event_wait() {
3838
}
3939

4040
try {
41-
auto defaultQueue = sycl::queue {};
41+
auto defaultQueue = sycl::queue{};
4242

43-
auto bufA = sycl::buffer { a, sycl::range { dataSize } };
44-
auto bufB = sycl::buffer { b, sycl::range { dataSize } };
45-
auto bufR = sycl::buffer { r, sycl::range { dataSize } };
43+
auto bufA = sycl::buffer{a, sycl::range{dataSize}};
44+
auto bufB = sycl::buffer{b, sycl::range{dataSize}};
45+
auto bufR = sycl::buffer{r, sycl::range{dataSize}};
4646

4747
defaultQueue
4848
.submit([&](sycl::handler& cgh) {
49-
auto accA = sycl::accessor { bufA, cgh, sycl::read_only };
50-
auto accB = sycl::accessor { bufB, cgh, sycl::read_only };
51-
auto accR = sycl::accessor { bufR, cgh, sycl::write_only };
49+
auto accA = sycl::accessor{bufA, cgh, sycl::read_only};
50+
auto accB = sycl::accessor{bufB, cgh, sycl::read_only};
51+
auto accR = sycl::accessor{bufR, cgh, sycl::write_only};
5252

5353
cgh.parallel_for<vector_add_1>(
54-
sycl::range { dataSize },
54+
sycl::range{dataSize},
5555
[=](sycl::id<1> idx) { accR[idx] = accA[idx] + accB[idx]; });
5656
})
57-
.wait(); // Synchronize
57+
.wait(); // Synchronize
5858

5959
defaultQueue.throw_asynchronous();
60-
} catch (const sycl::exception& e) { // Copy back
60+
} catch (const sycl::exception& e) { // Copy back
6161
std::cout << "Exception caught: " << e.what() << std::endl;
6262
}
6363

@@ -77,24 +77,24 @@ void test_buffer_queue_wait() {
7777
}
7878

7979
try {
80-
auto defaultQueue = sycl::queue {};
80+
auto defaultQueue = sycl::queue{};
8181

82-
auto bufA = sycl::buffer { a, sycl::range { dataSize } };
83-
auto bufB = sycl::buffer { b, sycl::range { dataSize } };
84-
auto bufR = sycl::buffer { r, sycl::range { dataSize } };
82+
auto bufA = sycl::buffer{a, sycl::range{dataSize}};
83+
auto bufB = sycl::buffer{b, sycl::range{dataSize}};
84+
auto bufR = sycl::buffer{r, sycl::range{dataSize}};
8585

8686
defaultQueue.submit([&](sycl::handler& cgh) {
87-
auto accA = sycl::accessor { bufA, cgh, sycl::read_only };
88-
auto accB = sycl::accessor { bufB, cgh, sycl::read_only };
89-
auto accR = sycl::accessor { bufR, cgh, sycl::write_only };
87+
auto accA = sycl::accessor{bufA, cgh, sycl::read_only};
88+
auto accB = sycl::accessor{bufB, cgh, sycl::read_only};
89+
auto accR = sycl::accessor{bufR, cgh, sycl::write_only};
9090

9191
cgh.parallel_for<vector_add_2>(
92-
sycl::range { dataSize },
92+
sycl::range{dataSize},
9393
[=](sycl::id<1> idx) { accR[idx] = accA[idx] + accB[idx]; });
9494
});
9595

96-
defaultQueue.wait_and_throw(); // Synchronize
97-
} catch (const sycl::exception& e) { // Copy back
96+
defaultQueue.wait_and_throw(); // Synchronize
97+
} catch (const sycl::exception& e) { // Copy back
9898
std::cout << "Exception caught: " << e.what() << std::endl;
9999
}
100100

@@ -114,23 +114,23 @@ void test_buffer_buffer_destruction() {
114114
}
115115

116116
try {
117-
auto defaultQueue = sycl::queue {};
117+
auto defaultQueue = sycl::queue{};
118118

119119
{
120-
auto bufA = sycl::buffer { a, sycl::range { dataSize } };
121-
auto bufB = sycl::buffer { b, sycl::range { dataSize } };
122-
auto bufR = sycl::buffer { r, sycl::range { dataSize } };
120+
auto bufA = sycl::buffer{a, sycl::range{dataSize}};
121+
auto bufB = sycl::buffer{b, sycl::range{dataSize}};
122+
auto bufR = sycl::buffer{r, sycl::range{dataSize}};
123123

124124
defaultQueue.submit([&](sycl::handler& cgh) {
125-
auto accA = sycl::accessor { bufA, cgh, sycl::read_only };
126-
auto accB = sycl::accessor { bufB, cgh, sycl::read_only };
127-
auto accR = sycl::accessor { bufR, cgh, sycl::write_only };
125+
auto accA = sycl::accessor{bufA, cgh, sycl::read_only};
126+
auto accB = sycl::accessor{bufB, cgh, sycl::read_only};
127+
auto accR = sycl::accessor{bufR, cgh, sycl::write_only};
128128

129129
cgh.parallel_for<vector_add_3>(
130-
sycl::range { dataSize },
130+
sycl::range{dataSize},
131131
[=](sycl::id<1> idx) { accR[idx] = accA[idx] + accB[idx]; });
132132
});
133-
} // Synchronize and copy-back
133+
} // Synchronize and copy-back
134134

135135
defaultQueue.throw_asynchronous();
136136
} catch (const sycl::exception& e) {
@@ -153,32 +153,32 @@ void test_usm_event_wait() {
153153
}
154154

155155
try {
156-
auto usmQueue = sycl::queue { usm_selector };
156+
auto usmQueue = sycl::queue{usm_selector};
157157

158158
auto devicePtrA = sycl::malloc_device<float>(dataSize, usmQueue);
159159
auto devicePtrB = sycl::malloc_device<float>(dataSize, usmQueue);
160160
auto devicePtrR = sycl::malloc_device<float>(dataSize, usmQueue);
161161

162162
usmQueue.memcpy(devicePtrA, a,
163163
sizeof(float) * dataSize)
164-
.wait(); // Synchronize
164+
.wait(); // Synchronize
165165
usmQueue.memcpy(devicePtrB, b,
166166
sizeof(float) * dataSize)
167-
.wait(); // Synchronize
167+
.wait(); // Synchronize
168168

169169
usmQueue
170-
.parallel_for<vector_add_4>(sycl::range { dataSize },
170+
.parallel_for<vector_add_4>(sycl::range{dataSize},
171171
[=](sycl::id<1> idx) {
172172
auto globalId = idx[0];
173173
devicePtrR[globalId] =
174174
devicePtrA[globalId] +
175175
devicePtrB[globalId];
176176
})
177-
.wait(); // Synchronize
177+
.wait(); // Synchronize
178178

179179
usmQueue.memcpy(r, devicePtrR,
180180
sizeof(float) * dataSize)
181-
.wait(); // Synchronize and copy-back
181+
.wait(); // Synchronize and copy-back
182182

183183
sycl::free(devicePtrA, usmQueue);
184184
sycl::free(devicePtrB, usmQueue);
@@ -205,7 +205,7 @@ void test_usm_queue_wait() {
205205
}
206206

207207
try {
208-
auto usmQueue = sycl::queue { usm_selector };
208+
auto usmQueue = sycl::queue{usm_selector};
209209

210210
auto devicePtrA = sycl::malloc_device<float>(dataSize, usmQueue);
211211
auto devicePtrB = sycl::malloc_device<float>(dataSize, usmQueue);
@@ -214,21 +214,21 @@ void test_usm_queue_wait() {
214214
usmQueue.memcpy(devicePtrA, a, sizeof(float) * dataSize);
215215
usmQueue.memcpy(devicePtrB, b, sizeof(float) * dataSize);
216216

217-
usmQueue.wait(); // Synchronize
217+
usmQueue.wait(); // Synchronize
218218

219219
usmQueue.parallel_for<vector_add_5>(
220-
sycl::range { dataSize }, [=](sycl::id<1> idx) {
220+
sycl::range{dataSize}, [=](sycl::id<1> idx) {
221221
auto globalId = idx[0];
222222
devicePtrR[globalId] = devicePtrA[globalId] + devicePtrB[globalId];
223223
});
224224

225-
usmQueue.wait(); // Synchronize
225+
usmQueue.wait(); // Synchronize
226226

227227
usmQueue.memcpy(r, devicePtrR,
228228
sizeof(float) * dataSize)
229-
.wait(); // Copy-back
229+
.wait(); // Copy-back
230230

231-
usmQueue.wait(); // Synchronize
231+
usmQueue.wait(); // Synchronize
232232

233233
sycl::free(devicePtrA, usmQueue);
234234
sycl::free(devicePtrB, usmQueue);
@@ -255,34 +255,34 @@ void test_buffer_host_accessor() {
255255
}
256256

257257
try {
258-
auto defaultQueue = sycl::queue {};
258+
auto defaultQueue = sycl::queue{};
259259

260260
{
261-
auto bufA = sycl::buffer { a, sycl::range { dataSize } };
262-
auto bufB = sycl::buffer { b, sycl::range { dataSize } };
263-
auto bufR = sycl::buffer { r, sycl::range { dataSize } };
261+
auto bufA = sycl::buffer{a, sycl::range{dataSize}};
262+
auto bufB = sycl::buffer{b, sycl::range{dataSize}};
263+
auto bufR = sycl::buffer{r, sycl::range{dataSize}};
264264

265265
defaultQueue.submit([&](sycl::handler& cgh) {
266-
auto accA = sycl::accessor { bufA, cgh, sycl::read_only };
267-
auto accB = sycl::accessor { bufB, cgh, sycl::read_only };
268-
auto accR = sycl::accessor { bufR, cgh, sycl::write_only };
266+
auto accA = sycl::accessor{bufA, cgh, sycl::read_only};
267+
auto accB = sycl::accessor{bufB, cgh, sycl::read_only};
268+
auto accR = sycl::accessor{bufR, cgh, sycl::write_only};
269269

270270
cgh.parallel_for<vector_add_6>(
271-
sycl::range { dataSize },
271+
sycl::range{dataSize},
272272
[=](sycl::id<1> idx) { accR[idx] = accA[idx] + accB[idx]; });
273273
});
274274

275-
defaultQueue.wait(); // Synchronize
275+
defaultQueue.wait(); // Synchronize
276276

277277
{
278-
auto hostAccR = bufR.get_host_access(sycl::read_only); // Copy-to-host
278+
auto hostAccR = bufR.get_host_access(sycl::read_only); // Copy-to-host
279279

280280
for (int i = 0; i < dataSize; ++i) {
281281
SYCLACADEMY_ASSERT(hostAccR[i] == i * 2);
282282
}
283283
}
284284

285-
} // Copy-back
285+
} // Copy-back
286286

287287
defaultQueue.throw_asynchronous();
288288
} catch (const sycl::exception& e) {

0 commit comments

Comments
 (0)