#848

Committed 07 Dec 2022 11:00PM UTC coverage: 86.456% (+0.6%) from 85.835%

Build # #848

Build Type

push

Committed by StellarBot

Commit Message

Merge #6096

6096: Forking Boost.Tokenizer r=hkaiser a=hkaiser

- flyby: remove more Boost headers that are not needed anymore

Working towards #3440 

Co-authored-by: Hartmut Kaiser <hartmut.kaiser@gmail.com>

Run Details

525 of 525 new or added lines in 20 files covered. (100.0%)

173087 of 200202 relevant lines covered (86.46%)

1845223.38 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

38.46

/libs/full/compute/include/hpx/compute/host/distributed_target.hpp

///////////////////////////////////////////////////////////////////////////////
//  Copyright (c) 2016 Thomas Heller
//
//  SPDX-License-Identifier: BSL-1.0
//  Distributed under the Boost Software License, Version 1.0. (See accompanying
//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
///////////////////////////////////////////////////////////////////////////////

#pragma once

#include <hpx/config.hpp>
#include <hpx/compute_local/host/target.hpp>

#if defined(HPX_HAVE_DISTRIBUTED_RUNTIME)
#include <hpx/compute/host/get_targets.hpp>
#include <hpx/futures/future.hpp>
#include <hpx/runtime_distributed/find_here.hpp>
#include <hpx/serialization/serialization_fwd.hpp>
#include <hpx/topology/topology.hpp>

#include <cstddef>
#include <utility>
#include <vector>

#include <hpx/config/warnings_prefix.hpp>

namespace hpx::compute::host::distributed {

    struct HPX_EXPORT target : hpx::compute::host::target
    {
    public:
        // Constructs default target
        target()
          : hpx::compute::host::target()
          , locality_(hpx::find_here())
        {
        }

        // Constructs target from a given mask of processing units
        explicit target(hpx::threads::mask_type mask)
          : hpx::compute::host::target(mask)
          , locality_(hpx::find_here())
        {
        }

        explicit target(hpx::id_type const& locality)
          : hpx::compute::host::target()
          , locality_(locality)
        {
        }

        target(hpx::id_type const& locality, hpx::threads::mask_type mask)
          : hpx::compute::host::target(mask)
          , locality_(locality)
        {
        }

        explicit target(hpx::compute::host::target const& target)
          : hpx::compute::host::target(target)
          , locality_(hpx::find_here())
        {
        }

        hpx::id_type const& get_locality() const noexcept
        {
            return locality_;
        }

        static hpx::future<std::vector<target>> get_targets(
            hpx::id_type const& locality)
        {
            return host::distributed::get_targets(locality);
        }

        friend bool operator==(target const& lhs, target const& rhs)
        {
            return static_cast<hpx::compute::host::target>(lhs) ==
                static_cast<hpx::compute::host::target>(rhs) &&
                lhs.locality_ == rhs.locality_;
        }

    private:
        friend class hpx::serialization::access;

        void serialize(serialization::input_archive& ar, unsigned int);
        void serialize(serialization::output_archive& ar, unsigned int);

        hpx::id_type locality_;
    };
}    // namespace hpx::compute::host::distributed

#include <hpx/config/warnings_suffix.hpp>

#endif

1	///////////////////////////////////////////////////////////////////////////////
2	// Copyright (c) 2016 Thomas Heller
3	//
4	// SPDX-License-Identifier: BSL-1.0
5	// Distributed under the Boost Software License, Version 1.0. (See accompanying
6	// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7	///////////////////////////////////////////////////////////////////////////////
8
9	#pragma once
10
11	#include <hpx/config.hpp>
12	#include <hpx/compute_local/host/target.hpp>
13
14	#if defined(HPX_HAVE_DISTRIBUTED_RUNTIME)
15	#include <hpx/compute/host/get_targets.hpp>
16	#include <hpx/futures/future.hpp>
17	#include <hpx/runtime_distributed/find_here.hpp>
18	#include <hpx/serialization/serialization_fwd.hpp>
19	#include <hpx/topology/topology.hpp>
20
21	#include <cstddef>
22	#include <utility>
23	#include <vector>
24
25	#include <hpx/config/warnings_prefix.hpp>
26
27	namespace hpx::compute::host::distributed {
28
29	struct HPX_EXPORT target : hpx::compute::host::target	×
30	{
31	public:
32	// Constructs default target
33	target()
34	: hpx::compute::host::target()
35	, locality_(hpx::find_here())
36	{
37	}
38
39	// Constructs target from a given mask of processing units
40	explicit target(hpx::threads::mask_type mask)
41	: hpx::compute::host::target(mask)
42	, locality_(hpx::find_here())
43	{
44	}
45
46	explicit target(hpx::id_type const& locality)
47	: hpx::compute::host::target()
48	, locality_(locality)
49	{
50	}
51
52	target(hpx::id_type const& locality, hpx::threads::mask_type mask)
53	: hpx::compute::host::target(mask)
54	, locality_(locality)
55	{
56	}
57
58	explicit target(hpx::compute::host::target const& target)	20✔
59	: hpx::compute::host::target(target)	20✔
60	, locality_(hpx::find_here())	20✔
61	{	20✔
62	}	20✔
63
64	hpx::id_type const& get_locality() const noexcept	×
65	{
66	return locality_;	×
67	}
68
69	static hpx::future<std::vector<target>> get_targets(
70	hpx::id_type const& locality)
71	{
72	return host::distributed::get_targets(locality);
73	}
74
75	friend bool operator==(target const& lhs, target const& rhs)	×
76	{
77	return static_cast<hpx::compute::host::target>(lhs) ==	×
78	static_cast<hpx::compute::host::target>(rhs) &&	×
79	lhs.locality_ == rhs.locality_;	×
80	}	×
81
82	private:
83	friend class hpx::serialization::access;
84
85	void serialize(serialization::input_archive& ar, unsigned int);
86	void serialize(serialization::output_archive& ar, unsigned int);
87
88	hpx::id_type locality_;
89	};
90	} // namespace hpx::compute::host::distributed
91
92	#include <hpx/config/warnings_suffix.hpp>
93
94	#endif

STEllAR-GROUP / hpx / #848

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous