Skip to content

Commit 7aa7238

Browse files
sbaldusbaldu
authored
Refactor setup functions as detail free functions (#308)
1 parent 549ae3f commit 7aa7238

File tree

4 files changed

+120
-92
lines changed

4 files changed

+120
-92
lines changed

‎include/CLUEstering/core/Clusterer.hpp‎

Lines changed: 8 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,8 @@
77
#include "CLUEstering/core/DistanceParameter.hpp"
88
#include "CLUEstering/core/ConvolutionalKernel.hpp"
99
#include "CLUEstering/core/detail/ClusteringKernels.hpp"
10+
#include "CLUEstering/core/detail/SetupFollowers.hpp"
11+
#include "CLUEstering/core/detail/SetupTiles.hpp"
1012
#include "CLUEstering/core/detail/defines.hpp"
1113
#include "CLUEstering/data_structures/AssociationMap.hpp"
1214
#include "CLUEstering/data_structures/PointsHost.hpp"
@@ -16,7 +18,9 @@
1618

1719
#include <array>
1820
#include <concepts>
21+
#include <cstddef>
1922
#include <cstdint>
23+
#include <optional>
2024

2125
namespace clue {
2226

@@ -50,17 +54,11 @@ namespace clue {
5054
void init_device(Queue& queue);
5155
void init_device(Queue& queue, TilesDevice* tile_buffer);
5256

53-
void setupTiles(Queue& queue, const PointsHost& h_points);
54-
void setupTiles(Queue& queue, const PointsDevice& d_points);
55-
56-
void setupFollowers(Queue& queue, int32_t n_points);
57-
58-
void setupPoints(const PointsHost& h_points, PointsDevice& dev_points, Queue& queue);
59-
6057
void setup(Queue& queue, const PointsHost& h_points, PointsDevice& dev_points) {
61-
setupTiles(queue, h_points);
62-
setupFollowers(queue, h_points.size());
63-
setupPoints(h_points, dev_points, queue);
58+
detail::setup_tiles(queue, m_tiles, h_points, m_pointsPerTile, m_wrappedCoordinates);
59+
detail::setup_followers(queue, m_followers, h_points.size());
60+
clue::copyToDevice(queue, dev_points, h_points);
61+
alpaka::memset(queue, *m_seeds, 0x00);
6462
}
6563

6664
template <concepts::convolutional_kernel Kernel>

‎include/CLUEstering/core/detail/Clusterer.hpp‎

Lines changed: 2 additions & 82 deletions
Original file line numberDiff line numberDiff line change
@@ -15,11 +15,9 @@
1515

1616
#include <alpaka/mem/view/Traits.hpp>
1717
#include <alpaka/vec/Vec.hpp>
18-
#include <cmath>
1918
#include <concepts>
2019
#include <cstdint>
2120
#include <ranges>
22-
#include <vector>
2321

2422
namespace clue {
2523

@@ -135,8 +133,8 @@ namespace clue {
135133
PointsDevice& dev_points,
136134
const Kernel& kernel,
137135
std::size_t block_size) {
138-
setupTiles(queue, dev_points);
139-
setupFollowers(queue, dev_points.size());
136+
detail::setup_tiles(queue, m_tiles, dev_points, m_pointsPerTile, m_wrappedCoordinates);
137+
detail::setup_followers(queue, m_followers, dev_points.size());
140138
alpaka::memset(queue, *m_seeds, 0x00);
141139
make_clusters_impl(dev_points, kernel, queue, block_size);
142140
alpaka::wait(queue);
@@ -178,84 +176,6 @@ namespace clue {
178176
m_tiles = *tile_buffer;
179177
}
180178

181-
template <std::size_t Ndim>
182-
void Clusterer<Ndim>::setupTiles(Queue& queue, const PointsHost& h_points) {
183-
// TODO: reconsider the way that we compute the number of tiles
184-
auto nTiles =
185-
static_cast<int32_t>(std::ceil(h_points.size() / static_cast<float>(m_pointsPerTile)));
186-
const auto nPerDim = static_cast<int32_t>(std::ceil(std::pow(nTiles, 1. / Ndim)));
187-
nTiles = static_cast<int32_t>(std::pow(nPerDim, Ndim));
188-
189-
if (!m_tiles.has_value()) {
190-
m_tiles = std::make_optional<TilesDevice>(queue, h_points.size(), nTiles);
191-
}
192-
// check if tiles are large enough for current data
193-
if (!(m_tiles->extents().values >= static_cast<std::size_t>(h_points.size())) or
194-
!(m_tiles->extents().keys >= static_cast<std::size_t>(nTiles))) {
195-
m_tiles->initialize(h_points.size(), nTiles, nPerDim, queue);
196-
} else {
197-
m_tiles->reset(h_points.size(), nTiles, nPerDim);
198-
}
199-
200-
auto min_max = clue::make_host_buffer<CoordinateExtremes>(queue);
201-
auto tile_sizes = clue::make_host_buffer<float[Ndim]>(queue);
202-
detail::compute_tile_size(min_max.data(), tile_sizes.data(), h_points, nPerDim);
203-
204-
alpaka::memcpy(queue, m_tiles->minMax(), min_max);
205-
alpaka::memcpy(queue, m_tiles->tileSize(), tile_sizes);
206-
alpaka::memcpy(
207-
queue, m_tiles->wrapped(), clue::make_host_view(m_wrappedCoordinates.data(), Ndim));
208-
}
209-
210-
template <std::size_t Ndim>
211-
void Clusterer<Ndim>::setupTiles(Queue& queue, const PointsDevice& d_points) {
212-
auto nTiles =
213-
static_cast<int32_t>(std::ceil(d_points.size() / static_cast<float>(m_pointsPerTile)));
214-
const auto nPerDim = static_cast<int32_t>(std::ceil(std::pow(nTiles, 1. / Ndim)));
215-
nTiles = static_cast<int32_t>(std::pow(nPerDim, Ndim));
216-
217-
if (!m_tiles.has_value()) {
218-
m_tiles = std::make_optional<TilesDevice>(queue, d_points.size(), nTiles);
219-
}
220-
// check if tiles are large enough for current data
221-
if (!(m_tiles->extents().values >= static_cast<std::size_t>(d_points.size())) or
222-
!(m_tiles->extents().keys >= static_cast<std::size_t>(nTiles))) {
223-
m_tiles->initialize(d_points.size(), nTiles, nPerDim, queue);
224-
} else {
225-
m_tiles->reset(d_points.size(), nTiles, nPerDim);
226-
}
227-
228-
auto min_max = clue::make_host_buffer<CoordinateExtremes>(queue);
229-
auto tile_sizes = clue::make_host_buffer<float[Ndim]>(queue);
230-
detail::compute_tile_size(min_max.data(), tile_sizes.data(), d_points, nPerDim);
231-
232-
alpaka::memcpy(queue, m_tiles->minMax(), min_max);
233-
alpaka::memcpy(queue, m_tiles->tileSize(), tile_sizes);
234-
alpaka::memcpy(
235-
queue, m_tiles->wrapped(), clue::make_host_view(m_wrappedCoordinates.data(), Ndim));
236-
}
237-
238-
template <std::size_t Ndim>
239-
void Clusterer<Ndim>::setupFollowers(Queue& queue, int32_t n_points) {
240-
if (!m_followers.has_value()) {
241-
m_followers = std::make_optional<FollowersDevice>(n_points, queue);
242-
}
243-
244-
if (!(m_followers->extents() >= n_points)) {
245-
m_followers->initialize(n_points, queue);
246-
} else {
247-
m_followers->reset(n_points);
248-
}
249-
}
250-
251-
template <std::size_t Ndim>
252-
void Clusterer<Ndim>::setupPoints(const PointsHost& h_points,
253-
PointsDevice& dev_points,
254-
Queue& queue) {
255-
clue::copyToDevice(queue, dev_points, h_points);
256-
alpaka::memset(queue, *m_seeds, 0x00);
257-
}
258-
259179
template <std::size_t Ndim>
260180
template <concepts::convolutional_kernel Kernel>
261181
void Clusterer<Ndim>::make_clusters_impl(PointsHost& h_points,

‎include/CLUEstering/core/detail/SetupFollowers.hpp‎

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
2+
#pragma once
3+
4+
#include "CLUEstering/detail/concepts.hpp"
5+
#include "CLUEstering/data_structures/internal/Followers.hpp"
6+
#include <cstddef>
7+
#include <cstdint>
8+
#include <optional>
9+
10+
namespace clue::detail {
11+
12+
template <concepts::queue TQueue,
13+
concepts::device TDev = decltype(alpaka::getDev(std::declval<TQueue>()))>
14+
void setup_followers(TQueue& queue, std::optional<Followers<TDev>>& followers, int32_t n_points) {
15+
if (!followers.has_value()) {
16+
followers = std::make_optional<Followers<TDev>>(n_points, queue);
17+
}
18+
19+
if (!(followers->extents() >= n_points)) {
20+
followers->initialize(n_points, queue);
21+
} else {
22+
followers->reset(n_points);
23+
}
24+
}
25+
26+
} // namespace clue::detail

‎include/CLUEstering/core/detail/SetupTiles.hpp‎

Lines changed: 84 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,84 @@
1+
2+
#pragma once
3+
4+
#include "CLUEstering/core/detail/ComputeTiles.hpp"
5+
#include "CLUEstering/data_structures/PointsHost.hpp"
6+
#include "CLUEstering/data_structures/PointsDevice.hpp"
7+
#include "CLUEstering/data_structures/internal/Tiles.hpp"
8+
#include "CLUEstering/detail/concepts.hpp"
9+
#include <array>
10+
#include <cmath>
11+
#include <cstddef>
12+
#include <cstdint>
13+
#include <optional>
14+
15+
namespace clue::detail {
16+
17+
template <concepts::queue TQueue,
18+
std::size_t Ndim,
19+
concepts::device TDev = decltype(alpaka::getDev(std::declval<TQueue>()))>
20+
void setup_tiles(TQueue& queue,
21+
std::optional<internal::Tiles<Ndim, TDev>>& tiles,
22+
const PointsHost<Ndim>& points,
23+
int points_per_tile,
24+
const std::array<uint8_t, Ndim>& wrapped_coordinates) {
25+
// TODO: reconsider the way that we compute the number of tiles
26+
auto ntiles =
27+
static_cast<int32_t>(std::ceil(points.size() / static_cast<float>(points_per_tile)));
28+
const auto n_per_dim = static_cast<int32_t>(std::ceil(std::pow(ntiles, 1. / Ndim)));
29+
ntiles = static_cast<int32_t>(std::pow(n_per_dim, Ndim));
30+
31+
if (!tiles.has_value()) {
32+
tiles = std::make_optional<internal::Tiles<Ndim, TDev>>(queue, points.size(), ntiles);
33+
}
34+
// check if tiles are large enough for current data
35+
if (!(tiles->extents().values >= static_cast<std::size_t>(points.size())) or
36+
!(tiles->extents().keys >= static_cast<std::size_t>(ntiles))) {
37+
tiles->initialize(points.size(), ntiles, n_per_dim, queue);
38+
} else {
39+
tiles->reset(points.size(), ntiles, n_per_dim);
40+
}
41+
42+
auto min_max = clue::make_host_buffer<internal::CoordinateExtremes<Ndim>>(queue);
43+
auto tile_sizes = clue::make_host_buffer<float[Ndim]>(queue);
44+
detail::compute_tile_size(min_max.data(), tile_sizes.data(), points, n_per_dim);
45+
46+
alpaka::memcpy(queue, tiles->minMax(), min_max);
47+
alpaka::memcpy(queue, tiles->tileSize(), tile_sizes);
48+
alpaka::memcpy(queue, tiles->wrapped(), clue::make_host_view(wrapped_coordinates.data(), Ndim));
49+
}
50+
51+
template <concepts::queue TQueue,
52+
std::size_t Ndim,
53+
concepts::device TDev = decltype(alpaka::getDev(std::declval<TQueue>()))>
54+
void setup_tiles(TQueue& queue,
55+
std::optional<internal::Tiles<Ndim, TDev>>& tiles,
56+
const PointsDevice<Ndim, TDev>& points,
57+
int points_per_tile,
58+
const std::array<uint8_t, Ndim>& wrapped_coordinates) {
59+
auto ntiles =
60+
static_cast<int32_t>(std::ceil(points.size() / static_cast<float>(points_per_tile)));
61+
const auto n_per_dim = static_cast<int32_t>(std::ceil(std::pow(ntiles, 1. / Ndim)));
62+
ntiles = static_cast<int32_t>(std::pow(n_per_dim, Ndim));
63+
64+
if (!tiles.has_value()) {
65+
tiles = std::make_optional<internal::Tiles<Ndim, TDev>>(queue, points.size(), ntiles);
66+
}
67+
// check if tiles are large enough for current data
68+
if (!(tiles->extents().values >= static_cast<std::size_t>(points.size())) or
69+
!(tiles->extents().keys >= static_cast<std::size_t>(ntiles))) {
70+
tiles->initialize(points.size(), ntiles, n_per_dim, queue);
71+
} else {
72+
tiles->reset(points.size(), ntiles, n_per_dim);
73+
}
74+
75+
auto min_max = clue::make_host_buffer<internal::CoordinateExtremes<Ndim>>(queue);
76+
auto tile_sizes = clue::make_host_buffer<float[Ndim]>(queue);
77+
detail::compute_tile_size(min_max.data(), tile_sizes.data(), points, n_per_dim);
78+
79+
alpaka::memcpy(queue, tiles->minMax(), min_max);
80+
alpaka::memcpy(queue, tiles->tileSize(), tile_sizes);
81+
alpaka::memcpy(queue, tiles->wrapped(), clue::make_host_view(wrapped_coordinates.data(), Ndim));
82+
}
83+
84+
} // namespace clue::detail

0 commit comments

Comments
 (0)