mu::detail Namespace Reference

Classes
struct	input_buffer_direction
struct	output_buffer_direction
struct	directional_pointer_traits_impl
struct	directional_pointer_traits_impl< mu::input_ptr< T > >
struct	directional_pointer_traits_impl< mu::output_ptr< T > >

Typedefs
template<typename T >
using	directional_pointer_traits = directional_pointer_traits_impl< std::remove_cv_t< std::remove_reference_t< T > >>

Functions
template<typename T >
T	loadArgumentSlot (const void *address)
template<typename Pointer >
Pointer	unpackKernelPointer (bool isNDArrayValue, const char *buffer)
template<typename Pointer >
void	storeKernelPointer (bool isNDArrayValue, char *buffer, Pointer value)
template<typename Param >
decltype(auto)	unpackKernelArgument (uint32_t mode, bool isNDArrayValue, char *buffer)

Variables
template<typename T >
constexpr bool	supported_directional_parameter_v

Typedef Documentation

directional_pointer_traits

template<typename T >

using mu::detail::directional_pointer_traits = typedef directional_pointer_traits_impl<std::remove_cv_t<std::remove_reference_t<T> >>

Definition at line 299 of file call_main_template.hpp.

Function Documentation

loadArgumentSlot()

template<typename T >

T mu::detail::loadArgumentSlot

(

const void *

address

)

Definition at line 28 of file call_main.hpp.

{
    std::remove_cv_t<T> value;
    std::memcpy(&value, address, sizeof(value));
    return value;
}

storeKernelPointer()

template<typename Pointer >

void mu::detail::storeKernelPointer	(	bool	isNDArrayValue,
		char *	buffer,
		Pointer	value
	)

Definition at line 50 of file call_main.hpp.

{
    auto parameterSlot = loadArgumentSlot<void*>(buffer);
    if (isNDArrayValue)
    {
        auto ndarray = loadArgumentSlot<mu::NDArray<char>*>(parameterSlot);
        ndarray->setData(reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(value)));
    }
    else
    {
        std::memcpy(parameterSlot, &value, sizeof(value));
    }
}

unpackKernelArgument()

template<typename Param >

decltype(auto) mu::detail::unpackKernelArgument	(	uint32_t	mode,
		bool	isNDArrayValue,
		char *	buffer
	)

Definition at line 65 of file call_main.hpp.

{
    if constexpr (directional_pointer_traits<Param>::value)
    {
        using adapter = directional_pointer_traits<Param>;
        using wire_type = typename adapter::wire_type;
        return adapter::fromWire(unpackKernelPointer<wire_type>(isNDArrayValue, buffer));
    }
    else if constexpr (is_pointer<Param>::value)
    {
        return unpackKernelPointer<Param>(isNDArrayValue, buffer);
    }
    else
    {
        Param* value = *reinterpret_cast<Param**>(buffer);
        if constexpr (is_ndarray_v<Param>)
        {
            void* argumentAddress = *reinterpret_cast<void**>(buffer);
            value = *reinterpret_cast<Param**>(argumentAddress);
        }
        else if (!isNormalMode(mode))
        {
            void* argumentAddress = *reinterpret_cast<void**>(buffer);
            if (isNDArrayValue)
            {
                auto ndarray = reinterpret_cast<mu::NDArray<char>*>(argumentAddress);
                void* dataPointer = ndarray->data();
                value = *reinterpret_cast<Param**>(dataPointer);
            }
            else
            {
                value = *reinterpret_cast<Param**>(argumentAddress);
            }
        }
        return static_cast<Param&>(*value);
    }
}

unpackKernelPointer()

template<typename Pointer >

Pointer mu::detail::unpackKernelPointer	(	bool	isNDArrayValue,
		const char *	buffer
	)

Definition at line 36 of file call_main.hpp.

{
    // The driver passes &taskCmd.param[i] in each argv slot. For NDArray,
    // param[i] points to the per-task descriptor, whose data() is the slice.
    auto parameterSlot = loadArgumentSlot<const void*>(buffer);
    if (isNDArrayValue)
    {
        auto ndarray = loadArgumentSlot<const mu::NDArray<char>*>(parameterSlot);
        return reinterpret_cast<Pointer>(const_cast<char*>(ndarray->data()));
    }
    return loadArgumentSlot<Pointer>(parameterSlot);
}

Variable Documentation

supported_directional_parameter_v

template<typename T >

constexpr bool mu::detail::supported_directional_parameter_v

inlineconstexpr

Initial value:

=
    !directional_pointer_traits<T>::value || !std::is_reference_v<T>

Definition at line 303 of file call_main_template.hpp.