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 */