void decode_scatter_distribution(hwloc_topology& t,
        std::vector<mask_type>& affinities, error_code& ec)
    {
        std::size_t num_threads = affinities.size();
        std::size_t num_cores = t.get_number_of_cores();

        std::vector<std::size_t> num_pus_cores(num_cores, 0);
        for (std::size_t num_thread = 0; num_thread != num_threads; /**/)
        {
            for(std::size_t num_core = 0; num_core != num_cores; ++num_core)
            {
                if (any(affinities[num_thread]))
                {
                    HPX_THROWS_IF(ec, bad_parameter, "decode_scatter_distribution",
                        boost::str(boost::format("affinity mask for thread %1% has "
                            "already been set") % num_thread));
                    return;
                }

                // Check if we exceed the number of PUs on the current core.
                // If yes, we need to proceed with the next one.
                std::size_t num_pus_core = t.get_number_of_core_pus(num_core);
                if(num_pus_cores[num_core] == num_pus_core) continue;

                affinities[num_thread] = t.init_thread_affinity_mask(
                    num_core, num_pus_cores[num_core]++);

                if(++num_thread == num_threads)
                    return;
            }
        }
    }

    void decode_scatter_distribution(hwloc_topology& t,
        std::vector<mask_type>& affinities,
        std::size_t used_cores, std::size_t max_cores,
        std::vector<std::size_t>& num_pus, error_code& ec)
    {
        std::size_t num_threads = affinities.size();
        std::size_t num_cores = (std::min)(max_cores, t.get_number_of_cores());

        std::vector<std::size_t> num_pus_cores(num_cores, 0);
        num_pus.resize(num_threads);

        for (std::size_t num_thread = 0; num_thread != num_threads; /**/)
        {
            for(std::size_t num_core = 0; num_core != num_cores; ++num_core)
            {
                if (any(affinities[num_thread]))
                {
                    HPX_THROWS_IF(ec, bad_parameter, "decode_scatter_distribution",
                        boost::str(boost::format("affinity mask for thread %1% has "
                            "already been set") % num_thread));
                    return;
                }

                num_pus[num_thread] = t.get_pu_number(num_core + used_cores,
                    num_pus_cores[num_core]);
                affinities[num_thread] = t.init_thread_affinity_mask(
                    num_core + used_cores, num_pus_cores[num_core]++);

                if(++num_thread == num_threads)
                    return;
            }
        }
    }

    mask_type decode_mapping_numanode(hwloc_topology const& t,
        mapping_type& m, std::size_t size, std::size_t thread_index,
        error_code& ec)
    {
        bounds_type b = extract_bounds(m[0], size, ec);
        if (ec) return 0;

        std::size_t index = std::size_t(-1);
        if (m[1].type_ == spec_type::unknown &&
            m[2].type_ == spec_type::unknown &&
            b.size() > 1)
        {
            index = thread_index;
        }

        mask_type mask = 0;
        std::size_t node_index = 0;
        for (bounds_type::const_iterator it = b.begin(); it != b.end(); ++it, ++node_index)
        {
            if (index == std::size_t(-1) || node_index == index)
                mask |= t.init_numa_node_affinity_mask_from_numa_node(*it);
        }

        std::size_t node_base_index = *b.begin();
        if (thread_index != std::size_t(-1) && b.size() > 1)
            node_base_index += thread_index;

        std::size_t base_index = 0;
        for (std::size_t i = 0; i != node_base_index; ++i)
            base_index += t.get_number_of_numa_node_cores(i);

        return decode_mapping0_unknown(t, m, size, mask, base_index,
            thread_index, ec);
    }

    mask_type decode_mapping_core(hwloc_topology const& t,
        mapping_type& m, std::size_t size, mask_type mask,
        std::size_t core_base_index, std::size_t thread_index, error_code& ec)
    {
        bounds_type b = extract_bounds(m[1], size, ec);
        if (ec) return 0;

        // We have to account for the thread index at this level if there are
        // no specifications related to processing units.
        std::size_t index = std::size_t(-1);
        if (m[2].type_ == spec_type::unknown && b.size() > 1)
            index = thread_index;

        mask_type core_mask = 0;
        std::size_t core_index = 0;
        for (bounds_type::const_iterator it = b.begin(); it != b.end(); ++it, ++core_index)
        {
            if (index == std::size_t(-1) || core_index == index)
            {
                core_mask |= t.init_core_affinity_mask_from_core(
                    *it+core_base_index, 0);
            }
        }

        core_base_index += *b.begin();
        if (thread_index != std::size_t(-1) && b.size() > 1)
            core_base_index += thread_index;

        std::size_t base_index = 0;
        for (std::size_t i = 0; i != core_base_index; ++i)
            base_index += t.get_number_of_core_pus(i);

        return decode_mapping1_unknown(t, m, size, mask & core_mask,
            base_index, thread_index, ec);
    }

    std::vector<mask_info>
    extract_core_masks(hwloc_topology const& t, spec_type const& s,
        std::size_t socket, mask_cref_type socket_mask, error_code& ec)
    {
        std::vector<mask_info> masks;

        switch (s.type_)
        {
        case spec_type::core:
            {
                std::size_t base = 0;
                std::size_t num_cores = 0;

                if (socket != std::size_t(-1))
                {
                    for (std::size_t i = 0; i != socket; ++i)
                        base += t.get_number_of_socket_cores(i);
                    num_cores = t.get_number_of_socket_cores(socket);
                }
                else
                {
                    num_cores = t.get_number_of_cores();
                }

                bounds_type bounds = extract_bounds(s, num_cores, ec);
                if (ec) break;

                for (std::int64_t index : bounds)
                {
                    mask_type mask =
                        t.init_core_affinity_mask_from_core(index + base);
                    masks.push_back(util::make_tuple(index, mask & socket_mask));
                }
            }
            break;

        case spec_type::unknown:
            {
                mask_type mask = extract_machine_mask(t, ec);
                masks.push_back(util::make_tuple(
                    std::size_t(-1), mask & socket_mask
                ));
            }
            break;

        default:
            HPX_THROWS_IF(ec, bad_parameter, "extract_core_mask",
                boost::str(boost::format(
                    "unexpected specification type %s"
                ) % spec_type::type_name(s.type_)));
            break;
        }

        return masks;
    }

    void decode_balanced_distribution(hwloc_topology& t,
        std::vector<mask_type>& affinities,
        std::size_t used_cores, std::size_t max_cores,
        std::vector<std::size_t>& num_pus, error_code& ec)
    {
        std::size_t num_threads = affinities.size();
        std::size_t num_cores = (std::min)(max_cores, t.get_number_of_cores());

        std::vector<std::size_t> num_pus_cores(num_cores, 0);
        num_pus.resize(num_threads);

        // At first, calculate the number of used pus per core.
        // This needs to be done to make sure that we occupy all the available
        // cores
        for (std::size_t num_thread = 0; num_thread != num_threads; /**/)
        {
            for(std::size_t num_core = 0; num_core != num_cores; ++num_core)
            {
                num_pus_cores[num_core]++;
                if(++num_thread == num_threads)
                    break;
            }
        }

        // Iterate over the cores and assigned pus per core. this additional
        // loop is needed so that we have consecutive worker thread numbers
        std::size_t num_thread = 0;
        for(std::size_t num_core = 0; num_core != num_cores; ++num_core)
        {
            for(std::size_t num_pu = 0; num_pu != num_pus_cores[num_core]; ++num_pu)
            {
                if (any(affinities[num_thread]))
                {
                    HPX_THROWS_IF(ec, bad_parameter,
                        "decode_balanced_distribution",
                        boost::str(boost::format(
                            "affinity mask for thread %1% has "
                            "already been set"
                        ) % num_thread));
                    return;
                }
                num_pus[num_thread] = t.get_pu_number(num_core + used_cores, num_pu);
                affinities[num_thread] = t.init_thread_affinity_mask(
                    num_core + used_cores, num_pu);
                ++num_thread;
            }
        }
    }

    mask_type decode_mapping(hwloc_topology const& t,
        mapping_type& m, std::vector<mask_type>& affinities,
        std::size_t thread_index, error_code& ec)
    {
        std::size_t size = affinities.size();
        mask_type mask;
        switch (m[0].type_) {
        case spec_type::socket:
            // requested top level is a socket
            mask = decode_mapping_socket(t, m, size, thread_index, ec);
            break;

        case spec_type::numanode:
            // requested top level is a NUMA node
            mask = decode_mapping_numanode(t, m, size, thread_index, ec);
            break;

        case spec_type::unknown:
            // no top level is requested
            mask = decode_mapping0_unknown(t, m, size,
                t.get_machine_affinity_mask(), 0, thread_index, ec);
            break;

        default:
            HPX_THROWS_IF(ec, bad_parameter, "decode_mapping",
                boost::str(boost::format("unexpected specification type at "
                    "index zero: %x (%s)") %
                        static_cast<unsigned>(m[0].type_) %
                        spec_type::type_name(m[0].type_)));
            return mask_type();
        }
        return mask;
    }

    mask_type decode_mapping0_unknown(hwloc_topology const& t,
        mapping_type& m, std::size_t size, mask_type mask,
        std::size_t core_base_index, std::size_t thread_index, error_code& ec)
    {
        switch (m[1].type_) {
        case spec_type::core:
            mask = decode_mapping_core(t, m, size, mask, core_base_index,
                thread_index, ec);
            break;

        case spec_type::unknown:
            {
                std::size_t base_index = 0;
                for (std::size_t i = 0; i != core_base_index; ++i)
                    base_index += t.get_number_of_core_pus(i);

                mask = decode_mapping1_unknown(t, m, size, mask, base_index,
                    thread_index, ec);
            }
            break;

        default:
            HPX_THROWS_IF(ec, bad_parameter, "decode_mapping0_unknown",
                boost::str(boost::format("unexpected specification type at "
                    "index one: %x (%s)") %
                        static_cast<unsigned>(m[1].type_) %
                        spec_type::type_name(m[1].type_)));
            break;
        }
        return mask;
    }

    void decode_balanced_distribution(hwloc_topology& t,
        std::vector<mask_type>& affinities, error_code& ec)
    {
        std::size_t num_threads = affinities.size();
        std::size_t num_cores = t.get_number_of_cores();

        std::vector<std::size_t> num_pus_cores(num_cores, 0);
        // At first, calculate the number of used pus per core.
        // This needs to be done to make sure that we occupy all the available cores
        for (std::size_t num_thread = 0; num_thread != num_threads; /**/)
        {
            for(std::size_t num_core = 0; num_core != num_cores; ++num_core)
            {
                // Check if we exceed the number of PUs on the current core.
                // If yes, we need to proceed with the next one.
                std::size_t num_pus_core = t.get_number_of_core_pus(num_core);
                if(num_pus_cores[num_core] == num_pus_core) continue;

                num_pus_cores[num_core]++;
                if(++num_thread == num_threads)
                    break;
            }
        }
        // Iterate over the cores and assigned pus per core. this additional loop
        // is needed so that we have consecutive worker thread numbers
        std::size_t num_thread = 0;
        for(std::size_t num_core = 0; num_core != num_cores; ++num_core)
        {
            for(std::size_t num_pu = 0; num_pu != num_pus_cores[num_core]; ++num_pu)
            {
                if (any(affinities[num_thread]))
                {
                    HPX_THROWS_IF(ec, bad_parameter, "decode_balanced_distribution",
                        boost::str(boost::format("affinity mask for thread %1% has "
                            "already been set") % num_thread));
                    return;
                }
                affinities[num_thread] = t.init_thread_affinity_mask(
                    num_core, num_pu);
                ++num_thread;
            }
        }
    }

    std::vector<mask_info>
    extract_socket_or_numanode_masks(hwloc_topology const& t,
        spec_type const& s, error_code& ec)
    {
        switch (s.type_)
        {
        case spec_type::socket:
            // requested top level is a socket
            {
                std::size_t num_sockets = t.get_number_of_sockets();
                return extract_socket_masks(
                    t, extract_bounds(s, num_sockets, ec));
            }

        case spec_type::numanode:
            // requested top level is a NUMA node
            {
                std::size_t num_numanodes = t.get_number_of_numa_nodes();
                return extract_numanode_masks(
                    t, extract_bounds(s, num_numanodes, ec));
            }

        case spec_type::unknown:
            {
                std::vector<mask_info> masks;
                masks.push_back(util::make_tuple(
                    std::size_t(-1), extract_machine_mask(t, ec)
                ));
                return masks;
            }

        default:
            HPX_THROWS_IF(ec, bad_parameter, "extract_socket_or_numanode_mask",
                boost::str(boost::format(
                    "unexpected specification type %s"
                ) % spec_type::type_name(s.type_)));
            break;
        }

        return std::vector<mask_info>();
    }

 std::vector<mask_info>
 extract_numanode_masks(hwloc_topology const& t, bounds_type const& b)
 {
     std::vector<mask_info> masks;
     for (std::int64_t index : b)
     {
         masks.push_back(util::make_tuple(
             index, t.init_numa_node_affinity_mask_from_numa_node(index)
         ));
     }
     return masks;
 }

 void decode_compact_distribution(hwloc_topology& t,
     std::vector<mask_type>& affinities, error_code& ec)
 {
     std::size_t num_threads = affinities.size();
     for(std::size_t i = 0; i != num_threads; ++i)
     {
         if (any(affinities[i]))
         {
             HPX_THROWS_IF(ec, bad_parameter, "decode_compact_distribution",
                 boost::str(boost::format("affinity mask for thread %1% has "
                     "already been set") % i));
             return;
         }
         affinities[i] = t.init_thread_affinity_mask(i);
     }
 }

    mask_type decode_mapping_pu(hwloc_topology const& t,
        mapping_type& m, std::size_t size, mask_type mask,
        std::size_t pu_base_index, std::size_t thread_index, error_code& ec)
    {
        bounds_type b = extract_bounds(m[2], size, ec);
        if (ec) return 0;

        std::size_t index = std::size_t(-1);
        if (b.size() > 1)
            index = thread_index;

        mask_type pu_mask = 0;
        std::size_t pu_index = 0;
        for (bounds_type::const_iterator it = b.begin(); it != b.end(); ++it, ++pu_index)
        {
            if (index == std::size_t(-1) || pu_index == index)
                pu_mask |= t.init_thread_affinity_mask(*it+pu_base_index);
        }

        return mask & pu_mask;
    }

    std::vector<mask_info>
    extract_pu_masks(hwloc_topology const& t, spec_type const& s,
        std::size_t socket, std::size_t core, mask_cref_type core_mask,
        error_code& ec)
    {
        std::vector<mask_info> masks;

        switch (s.type_)
        {
        case spec_type::pu:
            {
                std::size_t num_pus = 0;
                std::size_t socket_base = 0;
                if (std::size_t(-1) != socket)
                {
                    // core number is relative to socket
                    for (std::size_t i = 0; i != socket; ++i)
                        socket_base += t.get_number_of_socket_cores(i);
                }

                if (std::size_t(-1) != core)
                {
                    num_pus = t.get_number_of_core_pus(core);
                }
                else
                {
                    num_pus = t.get_number_of_pus();
                }

                bounds_type bounds = extract_bounds(s, num_pus, ec);
                if (ec) break;

                std::size_t num_cores = t.get_number_of_cores();
                for (std::int64_t index : bounds)
                {
                    std::size_t base_core = socket_base;
                    if (std::size_t(-1) != core)
                    {
                        base_core += core;
                    }
                    else
                    {
                        // find core the given pu belongs to
                        std::size_t base = 0;
                        for (/**/; base_core < num_cores; ++base_core)
                        {
                            std::size_t num_core_pus =
                                t.get_number_of_core_pus(base_core);
                            if (base + num_core_pus > std::size_t(index))
                                break;
                            base += num_core_pus;
                        }
                    }

                    mask_type mask = t.init_thread_affinity_mask(base_core, index);
                    masks.push_back(util::make_tuple(index, mask & core_mask));
                }
            }
            break;

        case spec_type::unknown:
            {
                mask_type mask = extract_machine_mask(t, ec);
                masks.push_back(util::make_tuple(
                    std::size_t(-1), mask & core_mask
                ));
            }
            break;

        default:
            HPX_THROWS_IF(ec, bad_parameter, "extract_pu_mask",
                boost::str(boost::format(
                    "unexpected specification type %s"
                ) % spec_type::type_name(s.type_)));
            break;
        }

        return masks;
    }

 mask_cref_type extract_machine_mask(hwloc_topology const& t, error_code& ec)
 {
     return t.get_machine_affinity_mask(ec);
 }