peak_ipl_library.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_ipl/backend/peak_ipl_backend.h>
#include <peak_ipl/exception/peak_ipl_exception.hpp>
#include <peak_ipl/types/peak_ipl_simple_types.hpp>
 
#include <cstddef>
#include <cstdint>
 
namespace peak
{
namespace ipl
{
 
struct Version_t
{
    std::uint32_t major;    
    std::uint32_t minor;    
    std::uint32_t subminor; 
 
    PEAK_IPL_NO_DISCARD std::string ToString() const
    {
        return std::to_string(major) + "." + std::to_string(minor) + "." + std::to_string(subminor);
    }
};
 
class Library final
{
public:
    Library() = delete;
    ~Library() = delete;
 
    Library(const Library&) = delete;
    Library(Library&&) = delete;
 
    Library& operator=(const Library&) = delete;
    Library& operator=(Library&&) = delete;
 
    PEAK_IPL_NO_DISCARD static Version_t Version();
 
    PEAK_IPL_NO_DISCARD static size_t MaxConcurrentThreads();
 
    static void SetMaxConcurrentThreads(size_t concurrentThreads);
 
    PEAK_IPL_NO_DISCARD static bool MultiThreadingEnabled();
 
    static void SetMultiThreadingEnabled(bool enabled);
 
    PEAK_IPL_NO_DISCARD static bool SIMDEnabled();
 
    static void SetSIMDEnabled(bool enabled);
};
 
inline Version_t Library::Version()
{
   uint32_t majorVersion{};
   uint32_t minorVersion{};
   uint32_t subminorVersion{};
 
   ExecuteAndMapReturnCodes([&] {
       return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Library_GetVersionMajor(&majorVersion);
   });
 
   ExecuteAndMapReturnCodes([&] {
       return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Library_GetVersionMinor(&minorVersion);
   });
 
   ExecuteAndMapReturnCodes([&] {
       return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Library_GetVersionSubminor(&subminorVersion);
   });
 
   return Version_t{majorVersion, minorVersion, subminorVersion};
}
 
inline size_t Library::MaxConcurrentThreads()
{
   size_t maxConcurrentThreads = 0;
 
   ExecuteAndMapReturnCodes([&] {
       return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Library_GetMaxConcurrentThreads(
           &maxConcurrentThreads);
   });
 
   return maxConcurrentThreads;
}
 
inline void Library::SetMaxConcurrentThreads(size_t concurrentThreads)
{
   ExecuteAndMapReturnCodes([&] {
       return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Library_SetMaxConcurrentThreads(concurrentThreads);
   });
}
 
inline bool Library::MultiThreadingEnabled()
{
   PEAK_IPL_BOOL8 multiThreadingEnabled{};
 
   ExecuteAndMapReturnCodes([&] {
       return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Library_GetMultiThreadingEnabled(&multiThreadingEnabled);
   });
 
   return multiThreadingEnabled != 0;
}
 
inline void Library::SetMultiThreadingEnabled(bool enabled)
{
   ExecuteAndMapReturnCodes([&] {
       return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Library_SetMultiThreadingEnabled(enabled ? 1 : 0);
   });
}
 
inline bool Library::SIMDEnabled()
{
   PEAK_IPL_BOOL8 simdEnabled{};
 
   ExecuteAndMapReturnCodes([&] {
       return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Library_GetSIMDEnabled(&simdEnabled);
   });
 
   return simdEnabled != 0;
}
 
inline void Library::SetSIMDEnabled(bool enabled)
{
   ExecuteAndMapReturnCodes([&] {
       return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Library_SetSIMDEnabled(enabled ? 1 : 0);
   });
}
 
} /* namespace ipl */
} /* namespace peak */