dev/rosa
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

thesis version

Browse Source
This commit is contained in:
Alexis Pereda
2021-05-10 18:14:24 +02:00
commit caf2a692f9
281 changed files with 73182 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
inc/alsk/skeleton/bone/farm.h Normal file
View File

@ -0,0 +1,51 @@
#ifndef ALSK_ALSK_SKELETON_BONE_FARM_H
#define ALSK_ALSK_SKELETON_BONE_FARM_H
#include "../bonebase.h"
namespace alsk {
template<typename, typename> struct Farm;
template<
typename Signature,
typename Task_, typename TaskLinks_
>
struct Farm<Signature, tmp::Pack<Task_, TaskLinks_>>: SkeletonBase {
using Task = Task_;
using TaskLinks = TaskLinks_;
using Links = tmp::Pack<TaskLinks>;
using PackP = tmp::Parameters<Signature>;
using PackR = Returns<Links>;
using PackX = tmp::Pack<>;
using Packs = arg::Placeholders<PackP, PackR, PackX>;
Task task;
std::size_t n;
};
template<>
struct SkeletonTraits<Farm> {
static constexpr bool serial = false;
template<typename Skeleton, typename F, typename T>
static constexpr decltype(auto) traverse(std::size_t parDepth, Skeleton&& skeleton, F&& function, T&& init) {
using Traverser = SkeletonTraversal<typename std::decay_t<Skeleton>::Task>;
return function(parDepth, skeleton, Traverser::execute(parDepth+1, skeleton.task, function, std::forward<T>(init)));
}
template<typename Skeleton>
static constexpr std::size_t parallelizability(Skeleton&& skeleton) noexcept {
return std::forward<Skeleton>(skeleton).n;
}
};
template<typename... Args, typename F>
void skeletonTraversal(Farm<Args...> const& s, F&& f) {
std::forward<F>(f)(s.task, s.n);
}
}
#endif

60
inc/alsk/skeleton/bone/farmsel.h Normal file
View File

@ -0,0 +1,60 @@
#ifndef ALSK_ALSK_SKELETON_BONE_FARMSEL_H
#define ALSK_ALSK_SKELETON_BONE_FARMSEL_H
#include "../bonebase.h"
namespace alsk {
template<typename, typename, typename> struct FarmSel;
template<
typename Signature,
typename Task_, typename TaskLinks_,
typename Select_, typename SelectLinks_
>
struct FarmSel<Signature, tmp::Pack<Task_, TaskLinks_>, tmp::Pack<Select_, SelectLinks_>>: SkeletonBase {
using Task = Task_;
using Select = Select_;
using TaskLinks = TaskLinks_;
using SelectLinks = SelectLinks_;
using Links = tmp::Pack<TaskLinks, SelectLinks>;
using PackP = tmp::Parameters<Signature>;
using PackR = Returns<Links>;
using PackX = tmp::Pack<>;
using Packs = arg::Placeholders<PackP, PackR, PackX>;
Task task;
Select select;
std::size_t n;
};
template<>
struct SkeletonTraits<FarmSel> {
static constexpr bool serial = false;
template<typename Skeleton, typename F, typename T>
static constexpr decltype(auto) traverse(std::size_t parDepth, Skeleton&& skeleton, F&& function, T&& init) {
using TraverserTask = SkeletonTraversal<typename std::decay_t<Skeleton>::Task>;
using TraverserSelect = SkeletonTraversal<typename std::decay_t<Skeleton>::Select>;
return function(parDepth, skeleton,
TraverserTask::execute(parDepth+1, skeleton.task, function, std::forward<T>(init)),
TraverserSelect::execute(parDepth, skeleton.select, function, std::forward<T>(init))
);
}
template<typename Skeleton>
static constexpr std::size_t parallelizability(Skeleton&& skeleton) noexcept {
return std::forward<Skeleton>(skeleton).n;
}
};
template<typename... Args, typename F>
void skeletonTraversal(FarmSel<Args...> const& s, F f) {
f(s.task, s.n);
f(s.select, 1);
}
}
#endif

61
inc/alsk/skeleton/bone/itersel.h Normal file
View File

@ -0,0 +1,61 @@
#ifndef ALSK_ALSK_SKELETON_BONE_ITERSEL_H
#define ALSK_ALSK_SKELETON_BONE_ITERSEL_H
#include "../bonebase.h"
namespace alsk {
template<typename, typename, typename> struct IterSel;
template<
typename Signature,
typename Task_, typename TaskLinks_,
typename Select_, typename SelectLinks_
>
struct IterSel<Signature, tmp::Pack<Task_, TaskLinks_>, tmp::Pack<Select_, SelectLinks_>>: SkeletonBase {
using Task = Task_;
using TaskLinks = TaskLinks_;
using Select = Select_;
using SelectLinks = SelectLinks_;
using Links = tmp::Pack<TaskLinks, SelectLinks>;
using PackP = tmp::Parameters<Signature>;
using PackR = Returns<Links>;
using PackX = tmp::Pack<>;
using Packs = arg::Placeholders<PackP, PackR, PackX>;
Task task;
Select select;
std::size_t n;
};
template<>
struct SkeletonTraits<IterSel> {
static constexpr bool serial = true;
template<typename Skeleton, typename F, typename T>
static constexpr decltype(auto) traverse(std::size_t parDepth, Skeleton&& skeleton, F&& function, T&& init) {
using TraverserTask = SkeletonTraversal<typename std::decay_t<Skeleton>::Task>;
using TraverserSelect = SkeletonTraversal<typename std::decay_t<Skeleton>::Select>;
return function(parDepth, skeleton,
TraverserTask::execute(parDepth, skeleton.task, function, std::forward<T>(init)),
TraverserSelect::execute(parDepth, skeleton.select, function, std::forward<T>(init))
);
}
template<typename Skeleton>
static constexpr std::size_t parallelizability(Skeleton&&) noexcept {
return 1;
}
};
template<typename... Args, typename F>
void skeletonTraversal(IterSel<Args...> const& s, F f) {
f(s.task, 1);
f(s.select, 1);
}
}
#endif

51
inc/alsk/skeleton/bone/loop.h Normal file
View File

@ -0,0 +1,51 @@
#ifndef ALSK_ALSK_SKELETON_BONE_LOOP_H
#define ALSK_ALSK_SKELETON_BONE_LOOP_H
#include "../bonebase.h"
namespace alsk {
template<typename, typename> struct Loop;
template<
typename Signature,
typename Task_, typename TaskLinks_
>
struct Loop<Signature, tmp::Pack<Task_, TaskLinks_>>: SkeletonBase {
using Task = Task_;
using TaskLinks = TaskLinks_;
using Links = tmp::Pack<TaskLinks>;
using PackP = tmp::Parameters<Signature>;
using PackR = Returns<Links>;
using PackX = void;
using Packs = arg::Placeholders<PackP, PackR, PackX>;
Task task;
std::size_t n;
};
template<>
struct SkeletonTraits<Loop> {
static constexpr bool serial = true;
template<typename Skeleton, typename F, typename T>
static constexpr decltype(auto) traverse(std::size_t parDepth, Skeleton&& skeleton, F&& function, T&& init) {
using Traverser = SkeletonTraversal<typename std::decay_t<Skeleton>::Task>;
return function(parDepth, skeleton, Traverser::execute(parDepth, skeleton.task, function, std::forward<T>(init)));
}
template<typename Skeleton>
static constexpr std::size_t parallelizability(Skeleton&&) noexcept {
return 1;
}
};
template<typename... Args, typename F>
void skeletonTraversal(Loop<Args...> const& s, F&& f) {
std::forward<F>(f)(s.task, 1);
}
}
#endif

70
inc/alsk/skeleton/bone/serial.h Normal file
View File

@ -0,0 +1,70 @@
#ifndef ALSK_ALSK_SKELETON_BONE_SERIAL_H
#define ALSK_ALSK_SKELETON_BONE_SERIAL_H
#include "../bonebase.h"
namespace alsk {
template<typename, typename...> struct Serial;
template<typename Signature, typename... FunTypes, typename... LinksTypes>
struct Serial<Signature, tmp::Pack<FunTypes, LinksTypes>...>: SkeletonBase {
using Links = tmp::Pack<LinksTypes...>;
using PackP = tmp::Parameters<Signature>;
using PackR = Returns<Links>;
using PackX = tmp::Pack<>;
using Packs = arg::Placeholders<PackP, PackR, PackX>;
using TasksP = tmp::Pack<FunTypes...>;
using Tasks = std::tuple<FunTypes...>;
Tasks tasks;
template<std::size_t I>
constexpr auto const& task() const noexcept { return std::get<I>(tasks); }
template<std::size_t I>
constexpr auto& task() noexcept { return std::get<I>(tasks); }
};
template<>
struct SkeletonTraits<Serial> {
static constexpr bool serial = true;
template<typename Skeleton, typename F, typename T>
static constexpr decltype(auto) traverse(std::size_t parDepth, Skeleton&& skeleton, F&& function, T&& init) {
auto indices = std::make_index_sequence<std::tuple_size<decltype(skeleton.tasks)>{}>();
return _traverse(parDepth, std::forward<Skeleton>(skeleton), std::forward<F>(function), std::forward<T>(init), std::move(indices));
}
template<typename Skeleton, typename F, typename T, std::size_t... Is>
static constexpr decltype(auto) _traverse(std::size_t parDepth, Skeleton&& skeleton, F&& function, T&& init, std::index_sequence<Is...>) {
using Traversers = tmp::Pack<
SkeletonTraversal<std::tuple_element_t<Is, typename std::decay_t<Skeleton>::Tasks>>...
>;
return function(parDepth, skeleton, tmp::PackGet<Traversers, Is>::execute(parDepth, skeleton.template task<Is>(), function, init)...);
}
template<typename Skeleton>
static constexpr std::size_t parallelizability(Skeleton&&) noexcept {
return 1;
}
};
namespace impl {
template<typename Tuple, typename F, std::size_t... indices>
void skeletonTraversalSerial(Tuple const& tasks, F f, std::index_sequence<indices...>) {
using Expander = int[];
static_cast<void>(Expander{(f(std::get<indices>(tasks), 1), 0)...});
}
}
template<typename Signature, typename... Tasks, typename F>
void skeletonTraversal(Serial<Signature, Tasks...> const& s, F&& f) {
impl::skeletonTraversalSerial(s.tasks, std::forward<F>(f), std::make_index_sequence<sizeof...(Tasks)>());
}
}
#endif

63
inc/alsk/skeleton/bone/while.h Normal file
View File

@ -0,0 +1,63 @@
#ifndef ALSK_ALSK_SKELETON_BONE_WHILE_H
#define ALSK_ALSK_SKELETON_BONE_WHILE_H
#include "../bonebase.h"
namespace alsk {
template<typename, typename, typename> struct While;
template<
typename Signature,
typename Test_, typename TestLinks_,
typename Task_, typename TaskLinks_
>
struct While<Signature, tmp::Pack<Test_, TestLinks_>, tmp::Pack<Task_, TaskLinks_>>: SkeletonBase {
using Test = Test_;
using TestLinks = TestLinks_;
using Task = Task_;
using TaskLinks = TaskLinks_;
using Links = tmp::Pack<TestLinks_, TaskLinks_>;
using PackP = tmp::Parameters<Signature>;
using PackR = Returns<Links>;
using PackX = tmp::Pack<>;
using Packs = arg::Placeholders<PackP, PackR, PackX>;
Test test;
Task task;
~While() noexcept {}; // -Winline
};
template<>
struct SkeletonTraits<While> {
static constexpr bool serial = true;
template<typename Skeleton, typename F, typename T>
static constexpr decltype(auto) traverse(std::size_t parDepth, Skeleton&& skeleton, F&& function, T&& init) {
using TraverserTest = SkeletonTraversal<typename std::decay_t<Skeleton>::Test>;
using TraverserTask = SkeletonTraversal<typename std::decay_t<Skeleton>::Task>;
return function(parDepth,
skeleton,
TraverserTest::execute(parDepth, skeleton.task, function, std::forward<T>(init)),
TraverserTask::execute(parDepth, skeleton.task, function, std::forward<T>(init))
);
}
template<typename Skeleton>
static constexpr std::size_t parallelizability(Skeleton&&) noexcept {
return 1;
}
};
template<typename... Args, typename F>
void skeletonTraversal(While<Args...> const& s, F f) {
f(s.test, 1);
f(s.task, 1);
}
}
#endif