#862

Committed 10 Jan 2023 05:30PM UTC coverage: 86.582% (-0.05%) from 86.634%

Build # #862

Build Type

push

Committed by StellarBot

Commit Message

Merge #6130

6130: Remove the mutex lock in the critical path of get_partitioner. r=hkaiser a=JiakunYan

Remove the mutex lock in the critical path of hpx::resource::detail::get_partitioner.

The protected variable `partitioner_ref` is only set once during initialization.

Co-authored-by: Jiakun Yan <jiakunyan1998@gmail.com>

Run Details

6 of 6 new or added lines in 1 file covered. (100.0%)

174767 of 201851 relevant lines covered (86.58%)

2069816.07 hits per line

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

0.0

/libs/core/util/src/regex_from_pattern.cpp

//  Copyright (c) 2007-2017 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/modules/errors.hpp>
#include <hpx/util/regex_from_pattern.hpp>

#include <string>

namespace hpx::util {

    namespace detail {

        ///////////////////////////////////////////////////////////////////////
        inline std::string regex_from_character_set(
            std::string::const_iterator& it, std::string::const_iterator end,
            error_code& ec)
        {
            std::string::const_iterator start = it;
            std::string result(1, *it);    // copy '['
            if (++it != end)
            {
                if (*it == '!')
                {
                    result.append(1, '^');    // negated character set
                }
                else if (*it == ']')
                {
                    HPX_THROWS_IF(ec, hpx::error::bad_parameter,
                        "regex_from_character_set",
                        "Invalid pattern (empty character set) at: {}",
                        std::string(start, end));
                    return "";
                }
                else
                {
                    result.append(1, *it);    // append this character
                }
            }

            // copy while in character set
            while (++it != end)
            {
                result.append(1, *it);
                if (*it == ']')
                    break;
            }

            if (it == end || *it != ']')
            {
                HPX_THROWS_IF(ec, hpx::error::bad_parameter,
                    "regex_from_character_set",
                    "Invalid pattern (missing closing ']') at: {}",
                    std::string(start, end));
                return "";
            }

            return result;
        }
    }    // namespace detail

    std::string regex_from_pattern(std::string const& pattern, error_code& ec)
    {
        std::string result;
        std::string::const_iterator end = pattern.end();
        for (std::string::const_iterator it = pattern.begin(); it != end; ++it)
        {
            char c = *it;
            switch (c)
            {
            case '*':
                result.append(".*");
                break;

            case '?':
                result.append(1, '.');
                break;

            case '[':
            {
                std::string r = detail::regex_from_character_set(it, end, ec);
                if (ec)
                    return "";
                result.append(r);
            }
            break;

            case '\\':
                if (++it == end)
                {
                    HPX_THROWS_IF(ec, hpx::error::bad_parameter,
                        "regex_from_pattern", "Invalid escape sequence at: {}",
                        pattern);
                    return "";
                }
                result.append(1, *it);
                break;

            // escape regex special characters
            // NOLINTNEXTLINE(bugprone-branch-clone)
            case '+':
                [[fallthrough]];
            case '.':
                [[fallthrough]];
            case '(':
                [[fallthrough]];
            case ')':
                [[fallthrough]];
            case '{':
                [[fallthrough]];
            case '}':
                [[fallthrough]];
            case '^':
                [[fallthrough]];
            case '$':
                result.append("\\");
                [[fallthrough]];

            default:
                result.append(1, c);
                break;
            }
        }
        return result;
    }
}    // namespace hpx::util

1	// Copyright (c) 2007-2017 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/modules/errors.hpp>
9	#include <hpx/util/regex_from_pattern.hpp>
10
11	#include <string>
12
13	namespace hpx::util {
14
15	namespace detail {
16
17	///////////////////////////////////////////////////////////////////////
18	inline std::string regex_from_character_set(	×
19	std::string::const_iterator& it, std::string::const_iterator end,
20	error_code& ec)
21	{
22	std::string::const_iterator start = it;	×
23	std::string result(1, *it); // copy '['	×
24	if (++it != end)	×
25	{
26	if (*it == '!')	×
27	{
28	result.append(1, '^'); // negated character set	×
29	}	×
30	else if (*it == ']')	×
31	{
32	HPX_THROWS_IF(ec, hpx::error::bad_parameter,	×
33	"regex_from_character_set",
34	"Invalid pattern (empty character set) at: {}",
35	std::string(start, end));
36	return "";	×
37	}
38	else
39	{
40	result.append(1, *it); // append this character	×
41	}
42	}	×
43
44	// copy while in character set
45	while (++it != end)	×
46	{
47	result.append(1, *it);	×
48	if (*it == ']')	×
49	break;	×
50	}
51
52	if (it == end \|\| *it != ']')	×
53	{
54	HPX_THROWS_IF(ec, hpx::error::bad_parameter,	×
55	"regex_from_character_set",
56	"Invalid pattern (missing closing ']') at: {}",
57	std::string(start, end));
58	return "";	×
59	}
60
61	return result;	×
62	}	×
63	} // namespace detail
64
65	std::string regex_from_pattern(std::string const& pattern, error_code& ec)	×
66	{
67	std::string result;	×
68	std::string::const_iterator end = pattern.end();	×
69	for (std::string::const_iterator it = pattern.begin(); it != end; ++it)	×
70	{
71	char c = *it;	×
72	switch (c)	×
73	{
74	case '*':
75	result.append(".*");	×
76	break;	×
77
78	case '?':
79	result.append(1, '.');	×
80	break;	×
81
82	case '[':
83	{
84	std::string r = detail::regex_from_character_set(it, end, ec);	×
85	if (ec)	×
86	return "";	×
87	result.append(r);	×
88	}	×
89	break;	×
90
91	case '\\':
92	if (++it == end)	×
93	{
94	HPX_THROWS_IF(ec, hpx::error::bad_parameter,	×
95	"regex_from_pattern", "Invalid escape sequence at: {}",
96	pattern);
97	return "";	×
98	}
99	result.append(1, *it);	×
100	break;	×
101
102	// escape regex special characters
103	// NOLINTNEXTLINE(bugprone-branch-clone)
104	case '+':
105	[[fallthrough]];
106	case '.':
107	[[fallthrough]];
108	case '(':
109	[[fallthrough]];
110	case ')':
111	[[fallthrough]];
112	case '{':
113	[[fallthrough]];
114	case '}':
115	[[fallthrough]];
116	case '^':
117	[[fallthrough]];
118	case '$':
119	result.append("\\");	×
120	[[fallthrough]];
121
122	default:
123	result.append(1, c);	×
124	break;	×
125	}
126	}	×
127	return result;	×
128	}	×
129	} // namespace hpx::util

STEllAR-GROUP / hpx / #862

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