#853

Committed 19 Dec 2022 01:01AM UTC coverage: 86.287% (+0.4%) from 85.912%

Build # #853

Build Type

push

Committed by StellarBot

Commit Message

Merge #6109

6109: Modernize serialization module r=hkaiser a=hkaiser

- flyby separate serialization of Boost types

working towards https://github.com/STEllAR-GROUP/hpx/issues/5497

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

Run Details

53 of 53 new or added lines in 6 files covered. (100.0%)

173939 of 201582 relevant lines covered (86.29%)

1931657.12 hits per line

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

56.25

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

//  Copyright (c) 2007-2021 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/transfer_action.hpp>
#include <hpx/actions_base/component_action.hpp>
#include <hpx/async_distributed/base_lco_with_value.hpp>
#include <hpx/async_distributed/transfer_continuation_action.hpp>
#include <hpx/components_base/component_type.hpp>
#include <hpx/components_base/server/component.hpp>
#include <hpx/modules/errors.hpp>
#include <hpx/performance_counters/counters.hpp>
#include <hpx/performance_counters/performance_counter_base.hpp>
#include <hpx/performance_counters/server/base_performance_counter.hpp>
#include <hpx/thread_support/atomic_count.hpp>

HPX_DEFINE_GET_COMPONENT_TYPE(hpx::components::component<
    hpx::performance_counters::server::base_performance_counter>)

///////////////////////////////////////////////////////////////////////////////
namespace hpx { namespace performance_counters { namespace server {

    void base_performance_counter::reset_counter_value()
    {
        HPX_THROW_EXCEPTION(hpx::error::invalid_status, "reset_counter_value",
            "reset_counter_value is not implemented for this counter");
    }

    void base_performance_counter::set_counter_value(
        counter_value const& /*value*/)
    {
        HPX_THROW_EXCEPTION(hpx::error::invalid_status, "set_counter_value",
            "set_counter_value is not implemented for this counter");
    }

    counter_value base_performance_counter::get_counter_value(bool /*reset*/)
    {
        HPX_THROW_EXCEPTION(hpx::error::invalid_status, "get_counter_value",
            "get_counter_value is not implemented for this counter");
        return {};
    }

    counter_values_array base_performance_counter::get_counter_values_array(
        bool /*reset*/)
    {
        HPX_THROW_EXCEPTION(hpx::error::invalid_status,
            "get_counter_values_array",
            "get_counter_values_array is not implemented for this "
            "counter");
        return {};
    }

    bool base_performance_counter::start()
    {
        return false;    // nothing to do
    }

    bool base_performance_counter::stop()
    {
        return false;    // nothing to do
    }

    void base_performance_counter::reinit(bool /*reset*/) {}

    counter_info base_performance_counter::get_counter_info() const
    {
        return info_;
    }

    base_performance_counter::base_performance_counter()
      : invocation_count_(0)
    {
    }

    base_performance_counter::base_performance_counter(counter_info const& info)
      : info_(info)
      , invocation_count_(0)
    {
    }

    ///////////////////////////////////////////////////////////////////////
    counter_info base_performance_counter::get_counter_info_nonvirt() const
    {
        return this->get_counter_info();
    }

    counter_value base_performance_counter::get_counter_value_nonvirt(
        bool reset)
    {
        return this->get_counter_value(reset);
    }

    counter_values_array
    base_performance_counter::get_counter_values_array_nonvirt(bool reset)
    {
        return this->get_counter_values_array(reset);
    }

    void base_performance_counter::set_counter_value_nonvirt(
        counter_value const& info)
    {
        this->set_counter_value(info);
    }

    void base_performance_counter::reset_counter_value_nonvirt()
    {
        this->reset_counter_value();
    }

    bool base_performance_counter::start_nonvirt()
    {
        return this->start();
    }

    bool base_performance_counter::stop_nonvirt()
    {
        return this->stop();
    }

    void base_performance_counter::reinit_nonvirt(bool reset)
    {
        reinit(reset);
    }
}}}    // namespace hpx::performance_counters::server

1	// Copyright (c) 2007-2021 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/transfer_action.hpp>
9	#include <hpx/actions_base/component_action.hpp>
10	#include <hpx/async_distributed/base_lco_with_value.hpp>
11	#include <hpx/async_distributed/transfer_continuation_action.hpp>
12	#include <hpx/components_base/component_type.hpp>
13	#include <hpx/components_base/server/component.hpp>
14	#include <hpx/modules/errors.hpp>
15	#include <hpx/performance_counters/counters.hpp>
16	#include <hpx/performance_counters/performance_counter_base.hpp>
17	#include <hpx/performance_counters/server/base_performance_counter.hpp>
18	#include <hpx/thread_support/atomic_count.hpp>
19
20	HPX_DEFINE_GET_COMPONENT_TYPE(hpx::components::component<	×
21	hpx::performance_counters::server::base_performance_counter>)
22
23	///////////////////////////////////////////////////////////////////////////////
24	namespace hpx { namespace performance_counters { namespace server {
25
26	void base_performance_counter::reset_counter_value()	×
27	{
28	HPX_THROW_EXCEPTION(hpx::error::invalid_status, "reset_counter_value",	×
29	"reset_counter_value is not implemented for this counter");
30	}	×
31
32	void base_performance_counter::set_counter_value(	×
33	counter_value const& /value/)
34	{
35	HPX_THROW_EXCEPTION(hpx::error::invalid_status, "set_counter_value",	×
36	"set_counter_value is not implemented for this counter");
37	}	×
38
39	counter_value base_performance_counter::get_counter_value(bool /reset/)	×
40	{
41	HPX_THROW_EXCEPTION(hpx::error::invalid_status, "get_counter_value",	×
42	"get_counter_value is not implemented for this counter");
43	return {};
44	}	×
45
46	counter_values_array base_performance_counter::get_counter_values_array(	×
47	bool /reset/)
48	{
49	HPX_THROW_EXCEPTION(hpx::error::invalid_status,	×
50	"get_counter_values_array",
51	"get_counter_values_array is not implemented for this "
52	"counter");
53	return {};
54	}	×
55
56	bool base_performance_counter::start()	10✔
57	{
58	return false; // nothing to do	10✔
59	}
60
61	bool base_performance_counter::stop()	10✔
62	{
63	return false; // nothing to do	10✔
64	}
65
66	void base_performance_counter::reinit(bool /reset/) {}	×
67
68	counter_info base_performance_counter::get_counter_info() const	67✔
69	{
70	return info_;	67✔
71	}
72
73	base_performance_counter::base_performance_counter()	×
74	: invocation_count_(0)	×
75	{	×
76	}	×
77
78	base_performance_counter::base_performance_counter(counter_info const& info)	63✔
79	: info_(info)	63✔
80	, invocation_count_(0)	63✔
81	{	126✔
82	}	63✔
83
84	///////////////////////////////////////////////////////////////////////
85	counter_info base_performance_counter::get_counter_info_nonvirt() const	67✔
86	{
87	return this->get_counter_info();	67✔
88	}
89
90	counter_value base_performance_counter::get_counter_value_nonvirt(	81✔
91	bool reset)
92	{
93	return this->get_counter_value(reset);	81✔
94	}
95
96	counter_values_array
97	base_performance_counter::get_counter_values_array_nonvirt(bool reset)	20✔
98	{
99	return this->get_counter_values_array(reset);	20✔
100	}
101
102	void base_performance_counter::set_counter_value_nonvirt(	×
103	counter_value const& info)
104	{
105	this->set_counter_value(info);	×
106	}	×
107
108	void base_performance_counter::reset_counter_value_nonvirt()	1✔
109	{
110	this->reset_counter_value();	1✔
111	}	1✔
112
113	bool base_performance_counter::start_nonvirt()	13✔
114	{
115	return this->start();	13✔
116	}
117
118	bool base_performance_counter::stop_nonvirt()	13✔
119	{
120	return this->stop();	13✔
121	}
122
123	void base_performance_counter::reinit_nonvirt(bool reset)	10✔
124	{
125	reinit(reset);	10✔
126	}	10✔
127	}}} // namespace hpx::performance_counters::server

STEllAR-GROUP / hpx / #853

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