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 <cstddef>
#include <cstdint>

 
namespace peak
{
namespace ipl
{

struct Version_t
{
    std::uint32_t major{};    
    std::uint32_t minor{};    
 
    union
    {
        std::uint32_t patch{};
 
        PEAK_COMMON_DEPRECATED_MSG("Use patch instead")
        std::uint32_t subminor;
    };

    PEAK_IPL_NO_DISCARD std::string ToString() const
    {
        return std::to_string(major) + "." + std::to_string(minor) + "." + std::to_string(patch);
    }
};

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()
{
   Version_t version{};
 
   ExecuteAndMapReturnCodes([&] {
       return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Library_GetVersionMajor(&version.major);
   });
 
   ExecuteAndMapReturnCodes([&] {
       return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Library_GetVersionMinor(&version.minor);
   });
 
   ExecuteAndMapReturnCodes([&] {
       return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Library_GetVersionPatch(&version.patch);
   });
 
   return version;
}
 
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 */