Exemplo n.º 1
0
    mask_type init_thread_affinity_mask(
        std::size_t num_thread
      , bool numa_sensitive
        )
    { // {{{
        std::size_t num_of_cores = hardware_concurrency();
        std::size_t affinity = num_thread % num_of_cores;

        ULONG numa_nodes = 1;
        if (GetNumaHighestNodeNumber(&numa_nodes))
            ++numa_nodes;

        std::size_t num_of_cores_per_numa_node = num_of_cores / numa_nodes;
        ULONGLONG node_affinity_mask = 0;
        ULONGLONG mask = 0x01LL;

        if (numa_sensitive) {
            UCHAR numa_node = UCHAR(affinity % numa_nodes);

            if (!GetNumaNodeProcessorMask(numa_node, &node_affinity_mask))
            {
                HPX_THROW_EXCEPTION(kernel_error
                  , "hpx::threads::windows_topology::init_thread_affinity_mask"
                  , boost::str(boost::format(
                        "failed to initialize thread %1% affinity mask")
                        % num_thread));
            }
            mask = least_significant_bit(node_affinity_mask) <<
                (affinity / numa_nodes);
        }
        else {
            UCHAR numa_node = UCHAR(get_numa_node_number(num_thread));

            if (!GetNumaNodeProcessorMask(numa_node, &node_affinity_mask))
            {
                HPX_THROW_EXCEPTION(kernel_error
                  , "hpx::threads::windows_topology::init_thread_affinity_mask"
                  , boost::str(boost::format(
                        "failed to initialize thread %1% affinity mask")
                        % num_thread));
            }
            mask = least_significant_bit(node_affinity_mask) <<
                (affinity % num_of_cores_per_numa_node);
        }

        while (!(mask & node_affinity_mask)) {
            mask <<= 1LL;
            if (0 == mask)
                mask = 0x01LL;
        }

        return static_cast<mask_type>(mask);
    } // }}}
Exemplo n.º 2
0
    mask_type init_numa_node_affinity_mask(
        std::size_t num_thread
      , bool numa_sensitive
        )
    { // {{{
        std::size_t num_of_cores = hardware_concurrency();
        UCHAR affinity = UCHAR(num_thread % num_of_cores);

        ULONG numa_nodes = 1;
        if (GetNumaHighestNodeNumber(&numa_nodes))
            ++numa_nodes;

        ULONGLONG mask = 0;
        if (numa_sensitive) {
            UCHAR numa_node = affinity % numa_nodes;
            if (!GetNumaNodeProcessorMask(numa_node, &mask))
            {
                HPX_THROW_EXCEPTION(kernel_error
                  , "hpx::threads::windows_topology::init_numa_node_affinity_mask"
                  , boost::str(boost::format(
                        "failed to initialize NUMA node affinity mask for "
                        "thread %1%")
                        % num_thread));
            }
            return static_cast<mask_type>(mask);
        }

        UCHAR numa_node = UCHAR(get_numa_node_number(num_thread));
        if (!GetNumaNodeProcessorMask(numa_node, &mask))
        {
            HPX_THROW_EXCEPTION(kernel_error
              , "hpx::threads::windows_topology::init_numa_node_affinity_mask"
              , boost::str(boost::format(
                    "failed to initialize NUMA node affinity mask for "
                    "thread %1%")
                    % num_thread));
        }

        return static_cast<mask_type>(mask);
    } // }}}
Exemplo n.º 3
0
 mask_type init_numa_node_affinity_mask(std::size_t num_thread) const
 {
     return init_numa_node_affinity_mask_from_numa_node(
         get_numa_node_number(num_thread));
 }