#882

Committed 31 Aug 2023 07:44PM UTC coverage: 41.798% (-44.7%) from 86.546%

Build # #882

Build Type

push

Committed by

Commit Message

Run Details

19442 of 46514 relevant lines covered (41.8%)

126375.38 hits per line

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

0.0

/libs/full/performance_counters/src/server/action_invocation_counter.cpp

//  Copyright (c) 2007-2025 Hartmut Kaiser
//
//  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)

#include <hpx/config.hpp>
#include <hpx/actions_base/detail/invocation_count_registry.hpp>
#include <hpx/modules/errors.hpp>
#include <hpx/modules/functional.hpp>
#include <hpx/performance_counters/action_invocation_counter_discoverer.hpp>
#include <hpx/performance_counters/counter_creators.hpp>
#include <hpx/performance_counters/counters.hpp>

#include <cstdint>
#include <utility>

///////////////////////////////////////////////////////////////////////////////
namespace hpx::performance_counters {

    ///////////////////////////////////////////////////////////////////////////
    // Discoverer function for action invocation counters
    bool action_invocation_counter_discoverer(counter_info const& info,
        discover_counter_func const& f, discover_counters_mode mode,
        hpx::actions::detail::invocation_count_registry& registry,
        error_code& ec)
    {
        // compose the counter name templates
        performance_counters::counter_path_elements p;
        performance_counters::counter_status status =
            get_counter_path_elements(info.fullname_, p, ec);
        if (!status_is_valid(status))
            return false;

        bool result = action_invocation_counter_discoverer(
            registry, info, p, f, mode, ec);
        if (!result || ec)
            return false;

        if (&ec != &throws)
            ec = make_success_code();

        return true;
    }

    bool local_action_invocation_counter_discoverer(counter_info const& info,
        discover_counter_func const& f, discover_counters_mode mode,
        error_code& ec)
    {
        using hpx::actions::detail::invocation_count_registry;
        return action_invocation_counter_discoverer(
            info, f, mode, invocation_count_registry::local_instance(), ec);
    }

#if defined(HPX_HAVE_NETWORKING)
    bool remote_action_invocation_counter_discoverer(counter_info const& info,
        discover_counter_func const& f, discover_counters_mode mode,
        error_code& ec)
    {
        using hpx::actions::detail::invocation_count_registry;
        return action_invocation_counter_discoverer(
            info, f, mode, invocation_count_registry::remote_instance(), ec);
    }
#endif

    ///////////////////////////////////////////////////////////////////////////
    // Creation function for action invocation counter
    naming::gid_type action_invocation_counter_creator(counter_info const& info,
        hpx::actions::detail::invocation_count_registry& registry,
        error_code& ec)
    {
        if (info.type_ != counter_type::monotonically_increasing)
        {
            HPX_THROWS_IF(ec, hpx::error::bad_parameter,
                "action_invocation_counter_creator",
                "invalid counter type requested");
            return naming::invalid_gid;
        }

        counter_path_elements paths;
        get_counter_path_elements(info.fullname_, paths, ec);
        if (ec)
            return naming::invalid_gid;

        if (paths.parentinstance_is_basename_)
        {
            HPX_THROWS_IF(ec, hpx::error::bad_parameter,
                "action_invocation_counter_creator",
                "invalid action invocation counter name (instance name "
                "must not be a valid base counter name)");
            return naming::invalid_gid;
        }

        if (paths.parameters_.empty())
        {
            HPX_THROWS_IF(ec, hpx::error::bad_parameter,
                "action_invocation_counter_creator",
                "invalid action invocation counter parameter: must "
                "specify an action type");
            return naming::invalid_gid;
        }

        // ask registry
        hpx::function<std::int64_t(bool)> f =
            registry.get_invocation_counter(paths.parameters_);

        return detail::create_raw_counter(info, HPX_MOVE(f), ec);
    }

    naming::gid_type local_action_invocation_counter_creator(
        counter_info const& info, error_code& ec)
    {
        using hpx::actions::detail::invocation_count_registry;
        return action_invocation_counter_creator(
            info, invocation_count_registry::local_instance(), ec);
    }

#if defined(HPX_HAVE_NETWORKING)
    naming::gid_type remote_action_invocation_counter_creator(
        counter_info const& info, error_code& ec)
    {
        using hpx::actions::detail::invocation_count_registry;
        return action_invocation_counter_creator(
            info, invocation_count_registry::remote_instance(), ec);
    }
#endif
}    // namespace hpx::performance_counters

1	// Copyright (c) 2007-2025 Hartmut Kaiser
2	//
3	// SPDX-License-Identifier: BSL-1.0
4	// Distributed under the Boost Software License, Version 1.0. (See accompanying
5	// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6
7	#include <hpx/config.hpp>
8	#include <hpx/actions_base/detail/invocation_count_registry.hpp>
9	#include <hpx/modules/errors.hpp>
10	#include <hpx/modules/functional.hpp>
11	#include <hpx/performance_counters/action_invocation_counter_discoverer.hpp>
12	#include <hpx/performance_counters/counter_creators.hpp>
13	#include <hpx/performance_counters/counters.hpp>
14
15	#include <cstdint>
16	#include <utility>
17
18	///////////////////////////////////////////////////////////////////////////////
19	namespace hpx::performance_counters {
20
21	///////////////////////////////////////////////////////////////////////////
22	// Discoverer function for action invocation counters	×
23	bool action_invocation_counter_discoverer(counter_info const& info,
24	discover_counter_func const& f, discover_counters_mode mode,
25	hpx::actions::detail::invocation_count_registry& registry,
26	error_code& ec)
27	{
28	// compose the counter name templates
29	performance_counters::counter_path_elements p;
30	performance_counters::counter_status status =	×
31	get_counter_path_elements(info.fullname_, p, ec);	×
32	if (!status_is_valid(status))
33	return false;
34		×
35	bool result = action_invocation_counter_discoverer(
36	registry, info, p, f, mode, ec);	×
37	if (!result \|\| ec)
38	return false;
39		×
40	if (&ec != &throws)	×
41	ec = make_success_code();
42
43	return true;	×
44	}
45		×
46	bool local_action_invocation_counter_discoverer(counter_info const& info,
47	discover_counter_func const& f, discover_counters_mode mode,
48	error_code& ec)
49	{
50	using hpx::actions::detail::invocation_count_registry;	×
51	return action_invocation_counter_discoverer(	×
52	info, f, mode, invocation_count_registry::local_instance(), ec);
53	}
54
55	#if defined(HPX_HAVE_NETWORKING)	×
56	bool remote_action_invocation_counter_discoverer(counter_info const& info,
57	discover_counter_func const& f, discover_counters_mode mode,
58	error_code& ec)
59	{
60	using hpx::actions::detail::invocation_count_registry;	×
61	return action_invocation_counter_discoverer(	×
62	info, f, mode, invocation_count_registry::remote_instance(), ec);
63	}
64	#endif
65
66	///////////////////////////////////////////////////////////////////////////
67	// Creation function for action invocation counter	×
68	naming::gid_type action_invocation_counter_creator(counter_info const& info,
69	hpx::actions::detail::invocation_count_registry& registry,
70	error_code& ec)
71	{	×
72	if (info.type_ != counter_type::monotonically_increasing)
73	{
74	HPX_THROWS_IF(ec, hpx::error::bad_parameter,
75	"action_invocation_counter_creator",
76	"invalid counter type requested");	×
77	return naming::invalid_gid;	×
78	}
79
80	counter_path_elements paths;	×
81	get_counter_path_elements(info.fullname_, paths, ec);
82	if (ec)	×
83	return naming::invalid_gid;
84
85	if (paths.parentinstance_is_basename_)
86	{
87	HPX_THROWS_IF(ec, hpx::error::bad_parameter,
88	"action_invocation_counter_creator",
89	"invalid action invocation counter name (instance name "	×
90	"must not be a valid base counter name)");
91	return naming::invalid_gid;	×
92	}
93
94	if (paths.parameters_.empty())
95	{
96	HPX_THROWS_IF(ec, hpx::error::bad_parameter,
97	"action_invocation_counter_creator",
98	"invalid action invocation counter parameter: must "
99	"specify an action type");
100	return naming::invalid_gid;	×
101	}
102		×
103	// ask registry	×
104	hpx::function<std::int64_t(bool)> f =
105	registry.get_invocation_counter(paths.parameters_);
106
107	return detail::create_raw_counter(info, HPX_MOVE(f), ec);	×
108	}
109
110	naming::gid_type local_action_invocation_counter_creator(
111	counter_info const& info, error_code& ec)
112	{
113	using hpx::actions::detail::invocation_count_registry;
114	return action_invocation_counter_creator(	×
115	info, invocation_count_registry::local_instance(), ec);
116	}
117
118	#if defined(HPX_HAVE_NETWORKING)
119	naming::gid_type remote_action_invocation_counter_creator(	×
120	counter_info const& info, error_code& ec)
121	{
122	using hpx::actions::detail::invocation_count_registry;
123	return action_invocation_counter_creator(	×
124	info, invocation_count_registry::remote_instance(), ec);
125	}
126	#endif
127	} // namespace hpx::performance_counters

STEllAR-GROUP / hpx / #882

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