#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

23.45

/libs/full/performance_counters/src/primary_namespace_counters.cpp

//  Copyright (c) 2011 Bryce Adelstein-Lelbach
//  Copyright (c) 2012-2020 Hartmut Kaiser
//  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)

#include <hpx/config.hpp>
#include <hpx/agas/addressing_service.hpp>
#include <hpx/agas/agas_fwd.hpp>
#include <hpx/agas_base/server/primary_namespace.hpp>
#include <hpx/assert.hpp>
#include <hpx/format.hpp>
#include <hpx/modules/errors.hpp>
#include <hpx/modules/functional.hpp>
#include <hpx/naming/credit_handling.hpp>
#include <hpx/performance_counters/agas_namespace_action_code.hpp>
#include <hpx/performance_counters/counter_creators.hpp>
#include <hpx/performance_counters/counters.hpp>
#include <hpx/performance_counters/manage_counter_type.hpp>
#include <hpx/performance_counters/primary_namespace_counters.hpp>
#include <hpx/performance_counters/server/primary_namespace_counters.hpp>

#include <cstddef>
#include <cstdint>
#include <string>

#include <hpx/config/warnings_prefix.hpp>

namespace hpx { namespace agas { namespace server {

    // register all performance counter types exposed by this component
    void primary_namespace_register_counter_types(error_code& ec)
    {
        performance_counters::create_counter_func creator(
            hpx::bind_back(&performance_counters::agas_raw_counter_creator,
                agas::server::primary_namespace_service_name));

        for (std::size_t i = 0;
            i != agas::detail::num_primary_namespace_services; ++i)
        {
            // global counters are handled elsewhere
            if (agas::detail::primary_namespace_services[i].code_ ==
                primary_ns_statistics_counter)
            {
                continue;
            }

            std::string name(agas::detail::primary_namespace_services[i].name_);
            std::string help;
            performance_counters::counter_type type;
            std::string::size_type p = name.find_last_of('/');
            HPX_ASSERT(p != std::string::npos);

            if (agas::detail::primary_namespace_services[i].target_ ==
                agas::detail::counter_target_count)
            {
                help = hpx::util::format("returns the number of invocations "
                                         "of the AGAS service '{}'",
                    name.substr(p + 1));
                type = performance_counters::counter_type::
                    monotonically_increasing;
            }
            else
            {
                help = hpx::util::format("returns the overall execution "
                                         "time of the AGAS service '{}'",
                    name.substr(p + 1));
                type = performance_counters::counter_type::elapsed_time;
            }

            performance_counters::install_counter_type(
                agas::performance_counter_basename + name, type, help, creator,
                &performance_counters::locality_counter_discoverer,
                HPX_PERFORMANCE_COUNTER_V1,
                agas::detail::primary_namespace_services[i].uom_, ec);
            if (ec)
            {
                return;
            }
        }
    }

    void primary_namespace_register_global_counter_types(error_code& ec)
    {
        performance_counters::create_counter_func creator(
            hpx::bind_back(&performance_counters::agas_raw_counter_creator,
                agas::server::primary_namespace_service_name));

        for (std::size_t i = 0;
            i != agas::detail::num_primary_namespace_services; ++i)
        {
            // local counters are handled elsewhere
            if (agas::detail::primary_namespace_services[i].code_ !=
                primary_ns_statistics_counter)
            {
                continue;
            }

            std::string help;
            performance_counters::counter_type type;
            if (agas::detail::primary_namespace_services[i].target_ ==
                agas::detail::counter_target_count)
            {
                help = "returns the overall number of invocations of all "
                       "primary AGAS services";
                type = performance_counters::counter_type::
                    monotonically_increasing;
            }
            else
            {
                help = "returns the overall execution time of all primary "
                       "AGAS services";
                type = performance_counters::counter_type::elapsed_time;
            }

            performance_counters::install_counter_type(
                std::string(agas::performance_counter_basename) +
                    agas::detail::primary_namespace_services[i].name_,
                type, help, creator,
                &performance_counters::locality_counter_discoverer,
                HPX_PERFORMANCE_COUNTER_V1,
                agas::detail::primary_namespace_services[i].uom_, ec);
            if (ec)
            {
                return;
            }
        }
    }

    ///////////////////////////////////////////////////////////////////////////
    naming::gid_type primary_namespace_statistics_counter(
        primary_namespace& service, std::string const& name)
    {    // statistics_counter implementation
        LAGAS_(info).format("primary_namespace_statistics_counter");

        hpx::error_code ec;

        performance_counters::counter_path_elements p;
        performance_counters::get_counter_path_elements(name, p, ec);
        if (ec)
        {
            return naming::invalid_gid;
        }

        if (p.objectname_ != "agas")
        {
            HPX_THROW_EXCEPTION(hpx::error::bad_parameter,
                "primary_namespace::statistics_counter",
                "unknown performance counter (unrelated to AGAS)");
        }

        namespace_action_code code = invalid_request;
        detail::counter_target target = agas::detail::counter_target_invalid;
        for (std::size_t i = 0;
            i != agas::detail::num_primary_namespace_services; ++i)
        {
            if (p.countername_ ==
                agas::detail::primary_namespace_services[i].name_)
            {
                code = agas::detail::primary_namespace_services[i].code_;
                target = agas::detail::primary_namespace_services[i].target_;
                break;
            }
        }

        if (code == invalid_request ||
            target == agas::detail::counter_target_invalid)
        {
            HPX_THROW_EXCEPTION(hpx::error::bad_parameter,
                "primary_namespace::statistics_counter",
                "unknown performance counter (unrelated to AGAS?)");
        }

        using cd = primary_namespace::counter_data;

        hpx::function<std::int64_t(bool)> get_data_func;
        if (target == agas::detail::counter_target_count)
        {
            switch (code)
            {
#if defined(HPX_HAVE_NETWORKING)
            case primary_ns_route:
                get_data_func = hpx::bind_front(
                    &cd::get_route_count, &service.counter_data_);
                service.counter_data_.route_.enabled_ = true;
                break;
#endif
            case primary_ns_bind_gid:
                get_data_func = hpx::bind_front(
                    &cd::get_bind_gid_count, &service.counter_data_);
                service.counter_data_.bind_gid_.enabled_ = true;
                break;
            case primary_ns_resolve_gid:
                get_data_func = hpx::bind_front(
                    &cd::get_resolve_gid_count, &service.counter_data_);
                service.counter_data_.resolve_gid_.enabled_ = true;
                break;
            case primary_ns_unbind_gid:
                get_data_func = hpx::bind_front(
                    &cd::get_unbind_gid_count, &service.counter_data_);
                service.counter_data_.unbind_gid_.enabled_ = true;
                break;
            case primary_ns_increment_credit:
                get_data_func = hpx::bind_front(
                    &cd::get_increment_credit_count, &service.counter_data_);
                service.counter_data_.increment_credit_.enabled_ = true;
                break;
            case primary_ns_decrement_credit:
                get_data_func = hpx::bind_front(
                    &cd::get_decrement_credit_count, &service.counter_data_);
                service.counter_data_.decrement_credit_.enabled_ = true;
                break;
            case primary_ns_allocate:
                get_data_func = hpx::bind_front(
                    &cd::get_allocate_count, &service.counter_data_);
                service.counter_data_.allocate_.enabled_ = true;
                break;
            case primary_ns_begin_migration:
                get_data_func = hpx::bind_front(
                    &cd::get_begin_migration_count, &service.counter_data_);
                service.counter_data_.begin_migration_.enabled_ = true;
                break;
            case primary_ns_end_migration:
                get_data_func = hpx::bind_front(
                    &cd::get_end_migration_count, &service.counter_data_);
                service.counter_data_.end_migration_.enabled_ = true;
                break;
            case primary_ns_statistics_counter:
                get_data_func = hpx::bind_front(
                    &cd::get_overall_count, &service.counter_data_);
                service.counter_data_.enable_all();
                break;
            default:
                HPX_THROW_EXCEPTION(hpx::error::bad_parameter,
                    "primary_namespace::statistics",
                    "bad action code while querying statistics");
            }
        }
        else
        {
            HPX_ASSERT(agas::detail::counter_target_time == target);
            switch (code)
            {
#if defined(HPX_HAVE_NETWORKING)
            case primary_ns_route:
                get_data_func = hpx::bind_front(
                    &cd::get_route_time, &service.counter_data_);
                service.counter_data_.route_.enabled_ = true;
                break;
#endif
            case primary_ns_bind_gid:
                get_data_func = hpx::bind_front(
                    &cd::get_bind_gid_time, &service.counter_data_);
                service.counter_data_.bind_gid_.enabled_ = true;
                break;
            case primary_ns_resolve_gid:
                get_data_func = hpx::bind_front(
                    &cd::get_resolve_gid_time, &service.counter_data_);
                service.counter_data_.resolve_gid_.enabled_ = true;
                break;
            case primary_ns_unbind_gid:
                get_data_func = hpx::bind_front(
                    &cd::get_unbind_gid_time, &service.counter_data_);
                service.counter_data_.unbind_gid_.enabled_ = true;
                break;
            case primary_ns_increment_credit:
                get_data_func = hpx::bind_front(
                    &cd::get_increment_credit_time, &service.counter_data_);
                service.counter_data_.increment_credit_.enabled_ = true;
                break;
            case primary_ns_decrement_credit:
                get_data_func = hpx::bind_front(
                    &cd::get_decrement_credit_time, &service.counter_data_);
                service.counter_data_.decrement_credit_.enabled_ = true;
                break;
            case primary_ns_allocate:
                get_data_func = hpx::bind_front(
                    &cd::get_allocate_time, &service.counter_data_);
                service.counter_data_.allocate_.enabled_ = true;
                break;
            case primary_ns_begin_migration:
                get_data_func = hpx::bind_front(
                    &cd::get_begin_migration_time, &service.counter_data_);
                service.counter_data_.begin_migration_.enabled_ = true;
                break;
            case primary_ns_end_migration:
                get_data_func = hpx::bind_front(
                    &cd::get_end_migration_time, &service.counter_data_);
                service.counter_data_.end_migration_.enabled_ = true;
                break;
            case primary_ns_statistics_counter:
                get_data_func = hpx::bind_front(
                    &cd::get_overall_time, &service.counter_data_);
                service.counter_data_.enable_all();
                break;
            default:
                HPX_THROW_EXCEPTION(hpx::error::bad_parameter,
                    "primary_namespace::statistics",
                    "bad action code while querying statistics");
            }
        }

        performance_counters::counter_info info;
        performance_counters::get_counter_type(name, info, ec);
        if (ec)
        {
            return naming::invalid_gid;
        }
        performance_counters::complement_counter_info(info, ec);
        if (ec)
        {
            return naming::invalid_gid;
        }
        using performance_counters::detail::create_raw_counter;
        naming::gid_type gid = create_raw_counter(info, get_data_func, ec);
        if (ec)
        {
            return naming::invalid_gid;
        }
        return naming::detail::strip_credits_from_gid(gid);
    }
}}}    // namespace hpx::agas::server

namespace hpx { namespace agas {

    // register performance counters for primary_namespace service
    void primary_namespace_register_counter_types(error_code& ec)
    {
        server::primary_namespace_register_counter_types(ec);
        if (!ec)
        {
            server::primary_namespace_register_global_counter_types(ec);
        }
    }

    // statistics_counter implementation
    naming::gid_type primary_namespace_statistics_counter(
        std::string const& name)
    {
        return server::primary_namespace_statistics_counter(
            naming::get_agas_client().get_local_primary_namespace_service(),
            name);
    }
}}    // namespace hpx::agas

HPX_REGISTER_ACTION_ID(hpx::agas::primary_namespace_statistics_counter_action,
    primary_namespace_statistics_counter_action,
    hpx::actions::primary_namespace_statistics_counter_action_id)

1	// Copyright (c) 2011 Bryce Adelstein-Lelbach
2	// Copyright (c) 2012-2020 Hartmut Kaiser
3	// Copyright (c) 2016 Thomas Heller
4	//
5	// SPDX-License-Identifier: BSL-1.0
6	// Distributed under the Boost Software License, Version 1.0. (See accompanying
7	// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
8
9	#include <hpx/config.hpp>
10	#include <hpx/agas/addressing_service.hpp>
11	#include <hpx/agas/agas_fwd.hpp>
12	#include <hpx/agas_base/server/primary_namespace.hpp>
13	#include <hpx/assert.hpp>
14	#include <hpx/format.hpp>
15	#include <hpx/modules/errors.hpp>
16	#include <hpx/modules/functional.hpp>
17	#include <hpx/naming/credit_handling.hpp>
18	#include <hpx/performance_counters/agas_namespace_action_code.hpp>
19	#include <hpx/performance_counters/counter_creators.hpp>
20	#include <hpx/performance_counters/counters.hpp>
21	#include <hpx/performance_counters/manage_counter_type.hpp>
22	#include <hpx/performance_counters/primary_namespace_counters.hpp>
23	#include <hpx/performance_counters/server/primary_namespace_counters.hpp>
24
25	#include <cstddef>
26	#include <cstdint>
27	#include <string>
28
29	#include <hpx/config/warnings_prefix.hpp>
30
31	namespace hpx { namespace agas { namespace server {
32
33	// register all performance counter types exposed by this component	32✔
34	void primary_namespace_register_counter_types(error_code& ec)
35	{
36	performance_counters::create_counter_func creator(
37	hpx::bind_back(&performance_counters::agas_raw_counter_creator,
38	agas::server::primary_namespace_service_name));
39		672✔
40	for (std::size_t i = 0;	672✔
41	i != agas::detail::num_primary_namespace_services; ++i)
42	{
43	// global counters are handled elsewhere	640✔
44	if (agas::detail::primary_namespace_services[i].code_ ==
45	primary_ns_statistics_counter)
46	{	64✔
47	continue;
48	}
49		576✔
50	std::string name(agas::detail::primary_namespace_services[i].name_);
51	std::string help;
52	performance_counters::counter_type type;
53	std::string::size_type p = name.find_last_of('/');
54	HPX_ASSERT(p != std::string::npos);
55		576✔
56	if (agas::detail::primary_namespace_services[i].target_ ==
57	agas::detail::counter_target_count)
58	{	576✔
59	help = hpx::util::format("returns the number of invocations "
60	"of the AGAS service '{}'",	864✔
61	name.substr(p + 1));
62	type = performance_counters::counter_type::
63	monotonically_increasing;
64	}
65	else
66	{	576✔
67	help = hpx::util::format("returns the overall execution "
68	"time of the AGAS service '{}'",	864✔
69	name.substr(p + 1));
70	type = performance_counters::counter_type::elapsed_time;
71	}
72		1,152✔
73	performance_counters::install_counter_type(	1,152✔
74	agas::performance_counter_basename + name, type, help, creator,	1,152✔
75	&performance_counters::locality_counter_discoverer,
76	HPX_PERFORMANCE_COUNTER_V1,	576✔
77	agas::detail::primary_namespace_services[i].uom_, ec);	576✔
78	if (ec)
79	{
80	return;
81	}
82	}
83	}
84		32✔
85	void primary_namespace_register_global_counter_types(error_code& ec)
86	{
87	performance_counters::create_counter_func creator(
88	hpx::bind_back(&performance_counters::agas_raw_counter_creator,
89	agas::server::primary_namespace_service_name));
90		672✔
91	for (std::size_t i = 0;	672✔
92	i != agas::detail::num_primary_namespace_services; ++i)
93	{
94	// local counters are handled elsewhere	640✔
95	if (agas::detail::primary_namespace_services[i].code_ !=
96	primary_ns_statistics_counter)
97	{	576✔
98	continue;
99	}
100
101	std::string help;
102	performance_counters::counter_type type;	64✔
103	if (agas::detail::primary_namespace_services[i].target_ ==
104	agas::detail::counter_target_count)
105	{
106	help = "returns the overall number of invocations of all "
107	"primary AGAS services";
108	type = performance_counters::counter_type::
109	monotonically_increasing;
110	}
111	else
112	{
113	help = "returns the overall execution time of all primary "
114	"AGAS services";
115	type = performance_counters::counter_type::elapsed_time;
116	}
117		128✔
118	performance_counters::install_counter_type(	64✔
119	std::string(agas::performance_counter_basename) +	128✔
120	agas::detail::primary_namespace_services[i].name_,
121	type, help, creator,	128✔
122	&performance_counters::locality_counter_discoverer,
123	HPX_PERFORMANCE_COUNTER_V1,	64✔
124	agas::detail::primary_namespace_services[i].uom_, ec);	64✔
125	if (ec)
126	{
127	return;
128	}
129	}
130	}
131
132	///////////////////////////////////////////////////////////////////////////	×
133	naming::gid_type primary_namespace_statistics_counter(
134	primary_namespace& service, std::string const& name)
135	{ // statistics_counter implementation	×
136	LAGAS_(info).format("primary_namespace_statistics_counter");
137
138	hpx::error_code ec;
139
140	performance_counters::counter_path_elements p;	×
141	performance_counters::get_counter_path_elements(name, p, ec);	×
142	if (ec)
143	{
144	return naming::invalid_gid;
145	}
146		×
147	if (p.objectname_ != "agas")
148	{	×
149	HPX_THROW_EXCEPTION(hpx::error::bad_parameter,
150	"primary_namespace::statistics_counter",
151	"unknown performance counter (unrelated to AGAS)");
152	}
153
154	namespace_action_code code = invalid_request;
155	detail::counter_target target = agas::detail::counter_target_invalid;	×
156	for (std::size_t i = 0;	×
157	i != agas::detail::num_primary_namespace_services; ++i)
158	{	×
159	if (p.countername_ ==	×
160	agas::detail::primary_namespace_services[i].name_)
161	{	×
162	code = agas::detail::primary_namespace_services[i].code_;	×
163	target = agas::detail::primary_namespace_services[i].target_;	×
164	break;
165	}
166	}
167		×
168	if (code == invalid_request \|\|	×
169	target == agas::detail::counter_target_invalid)
170	{	×
171	HPX_THROW_EXCEPTION(hpx::error::bad_parameter,
172	"primary_namespace::statistics_counter",
173	"unknown performance counter (unrelated to AGAS?)");
174	}
175
176	using cd = primary_namespace::counter_data;
177		×
178	hpx::function<std::int64_t(bool)> get_data_func;	×
179	if (target == agas::detail::counter_target_count)
180	{	×
181	switch (code)
182	{
183	#if defined(HPX_HAVE_NETWORKING)	×
184	case primary_ns_route:
185	get_data_func = hpx::bind_front(	×
186	&cd::get_route_count, &service.counter_data_);	×
187	service.counter_data_.route_.enabled_ = true;	×
188	break;
189	#endif	×
190	case primary_ns_bind_gid:
191	get_data_func = hpx::bind_front(	×
192	&cd::get_bind_gid_count, &service.counter_data_);	×
193	service.counter_data_.bind_gid_.enabled_ = true;	×
194	break;	×
195	case primary_ns_resolve_gid:
196	get_data_func = hpx::bind_front(	×
197	&cd::get_resolve_gid_count, &service.counter_data_);	×
198	service.counter_data_.resolve_gid_.enabled_ = true;	×
199	break;	×
200	case primary_ns_unbind_gid:
201	get_data_func = hpx::bind_front(	×
202	&cd::get_unbind_gid_count, &service.counter_data_);	×
203	service.counter_data_.unbind_gid_.enabled_ = true;	×
204	break;	×
205	case primary_ns_increment_credit:
206	get_data_func = hpx::bind_front(	×
207	&cd::get_increment_credit_count, &service.counter_data_);	×
208	service.counter_data_.increment_credit_.enabled_ = true;	×
209	break;	×
210	case primary_ns_decrement_credit:
211	get_data_func = hpx::bind_front(	×
212	&cd::get_decrement_credit_count, &service.counter_data_);	×
213	service.counter_data_.decrement_credit_.enabled_ = true;	×
214	break;	×
215	case primary_ns_allocate:
216	get_data_func = hpx::bind_front(	×
217	&cd::get_allocate_count, &service.counter_data_);	×
218	service.counter_data_.allocate_.enabled_ = true;	×
219	break;	×
220	case primary_ns_begin_migration:
221	get_data_func = hpx::bind_front(	×
222	&cd::get_begin_migration_count, &service.counter_data_);	×
223	service.counter_data_.begin_migration_.enabled_ = true;	×
224	break;	×
225	case primary_ns_end_migration:
226	get_data_func = hpx::bind_front(	×
227	&cd::get_end_migration_count, &service.counter_data_);	×
228	service.counter_data_.end_migration_.enabled_ = true;	×
229	break;	×
230	case primary_ns_statistics_counter:
231	get_data_func = hpx::bind_front(	×
232	&cd::get_overall_count, &service.counter_data_);	×
233	service.counter_data_.enable_all();
234	break;
235	default:	×
236	HPX_THROW_EXCEPTION(hpx::error::bad_parameter,
237	"primary_namespace::statistics",
238	"bad action code while querying statistics");
239	}
240	}
241	else
242	{
243	HPX_ASSERT(agas::detail::counter_target_time == target);	×
244	switch (code)
245	{
246	#if defined(HPX_HAVE_NETWORKING)	×
247	case primary_ns_route:
248	get_data_func = hpx::bind_front(	×
249	&cd::get_route_time, &service.counter_data_);	×
250	service.counter_data_.route_.enabled_ = true;	×
251	break;
252	#endif	×
253	case primary_ns_bind_gid:
254	get_data_func = hpx::bind_front(	×
255	&cd::get_bind_gid_time, &service.counter_data_);	×
256	service.counter_data_.bind_gid_.enabled_ = true;	×
257	break;	×
258	case primary_ns_resolve_gid:
259	get_data_func = hpx::bind_front(	×
260	&cd::get_resolve_gid_time, &service.counter_data_);	×
261	service.counter_data_.resolve_gid_.enabled_ = true;	×
262	break;	×
263	case primary_ns_unbind_gid:
264	get_data_func = hpx::bind_front(	×
265	&cd::get_unbind_gid_time, &service.counter_data_);	×
266	service.counter_data_.unbind_gid_.enabled_ = true;	×
267	break;	×
268	case primary_ns_increment_credit:
269	get_data_func = hpx::bind_front(	×
270	&cd::get_increment_credit_time, &service.counter_data_);	×
271	service.counter_data_.increment_credit_.enabled_ = true;	×
272	break;	×
273	case primary_ns_decrement_credit:
274	get_data_func = hpx::bind_front(	×
275	&cd::get_decrement_credit_time, &service.counter_data_);	×
276	service.counter_data_.decrement_credit_.enabled_ = true;	×
277	break;	×
278	case primary_ns_allocate:
279	get_data_func = hpx::bind_front(	×
280	&cd::get_allocate_time, &service.counter_data_);	×
281	service.counter_data_.allocate_.enabled_ = true;	×
282	break;	×
283	case primary_ns_begin_migration:
284	get_data_func = hpx::bind_front(	×
285	&cd::get_begin_migration_time, &service.counter_data_);	×
286	service.counter_data_.begin_migration_.enabled_ = true;	×
287	break;	×
288	case primary_ns_end_migration:
289	get_data_func = hpx::bind_front(	×
290	&cd::get_end_migration_time, &service.counter_data_);	×
291	service.counter_data_.end_migration_.enabled_ = true;	×
292	break;	×
293	case primary_ns_statistics_counter:
294	get_data_func = hpx::bind_front(	×
295	&cd::get_overall_time, &service.counter_data_);	×
296	service.counter_data_.enable_all();
297	break;
298	default:	×
299	HPX_THROW_EXCEPTION(hpx::error::bad_parameter,
300	"primary_namespace::statistics",
301	"bad action code while querying statistics");
302	}
303	}
304		×
305	performance_counters::counter_info info;	×
306	performance_counters::get_counter_type(name, info, ec);	×
307	if (ec)
308	{
309	return naming::invalid_gid;
310	}	×
311	performance_counters::complement_counter_info(info, ec);	×
312	if (ec)
313	{
314	return naming::invalid_gid;
315	}
316	using performance_counters::detail::create_raw_counter;	×
317	naming::gid_type gid = create_raw_counter(info, get_data_func, ec);	×
318	if (ec)
319	{
320	return naming::invalid_gid;
321	}
322	return naming::detail::strip_credits_from_gid(gid);	×
323	}
324	}}} // namespace hpx::agas::server
325
326	namespace hpx { namespace agas {
327
328	// register performance counters for primary_namespace service	32✔
329	void primary_namespace_register_counter_types(error_code& ec)
330	{	32✔
331	server::primary_namespace_register_counter_types(ec);	32✔
332	if (!ec)
333	{	32✔
334	server::primary_namespace_register_global_counter_types(ec);
335	}	32✔
336	}
337
338	// statistics_counter implementation	×
339	naming::gid_type primary_namespace_statistics_counter(
340	std::string const& name)
341	{
342	return server::primary_namespace_statistics_counter(	×
343	naming::get_agas_client().get_local_primary_namespace_service(),	×
344	name);
345	}
346	}} // namespace hpx::agas
347		192✔
348	HPX_REGISTER_ACTION_ID(hpx::agas::primary_namespace_statistics_counter_action,
349	primary_namespace_statistics_counter_action,
350	hpx::actions::primary_namespace_statistics_counter_action_id)

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