Coverage Report

Created: 2026-07-25 15:41

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
be/src/util/once.h
Line
Count
Source
1
// Licensed to the Apache Software Foundation (ASF) under one
2
// or more contributor license agreements.  See the NOTICE file
3
// distributed with this work for additional information
4
// regarding copyright ownership.  The ASF licenses this file
5
// to you under the Apache License, Version 2.0 (the
6
// "License"); you may not use this file except in compliance
7
// with the License.  You may obtain a copy of the License at
8
//
9
//   http://www.apache.org/licenses/LICENSE-2.0
10
//
11
// Unless required by applicable law or agreed to in writing,
12
// software distributed under the License is distributed on an
13
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14
// KIND, either express or implied.  See the License for the
15
// specific language governing permissions and limitations
16
// under the License.
17
// This file is copied from
18
// https://github.com/apache/impala/blob/branch-2.9.0/be/src/util/once.h
19
// and modified by Doris
20
21
#pragma once
22
23
#include <atomic>
24
#include <mutex>
25
#include <stdexcept>
26
27
#include "common/exception.h"
28
#include "storage/olap_common.h"
29
30
namespace doris {
31
32
// Utility class for implementing thread-safe call-once semantics.
33
//
34
// call() will return stored result regardless of whether the first invocation
35
// returns a success status or not.
36
//
37
// Example:
38
//   class Resource {
39
//   public:
40
//     Status init() {
41
//       _init_once.call([this] { return _do_init(); });
42
//     }
43
//
44
//     bool is_inited() const {
45
//       return _init_once.has_called() && _init_once.stored_result().ok();
46
//     }
47
//   private:
48
//     Status _do_init() { /* init logic here */ }
49
//     DorisCallOnce<Status> _init_once;
50
//   };
51
template <typename ReturnType>
52
class DorisCallOnce {
53
public:
54
156k
    DorisCallOnce() : _has_called(false) {}
_ZN5doris13DorisCallOnceIN2tl8expectedINS_21EncryptionAlgorithmPBENS_6StatusEEEEC2Ev
Line
Count
Source
54
34.7k
    DorisCallOnce() : _has_called(false) {}
_ZN5doris13DorisCallOnceINS_6StatusEEC2Ev
Line
Count
Source
54
121k
    DorisCallOnce() : _has_called(false) {}
55
56
    // this method is not exception safe, it will core when exception occurs in
57
    // callback method. I have tested the code https://en.cppreference.com/w/cpp/thread/call_once.
58
    // If the underlying `once_flag` has yet to be invoked, invokes the provided
59
    // lambda and stores its return value. Otherwise, returns the stored Status.
60
    // template <typename Fn>
61
    // ReturnType call(Fn fn) {
62
    //     std::call_once(_once_flag, [this, fn] {
63
    //         _status = fn();
64
    //         _has_called.store(true, std::memory_order_release);
65
    //     });
66
    //     return _status;
67
    // }
68
69
    // If exception occurs in the function, the call flag is set, if user call
70
    // it again, the same exception will be thrown.
71
    // It is different from std::call_once. This is because if a method is called once
72
    // some internal state is changed, it maybe not called again although exception
73
    // occurred.
74
    template <typename Fn>
75
97.1k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
97.1k
        if (has_called()) {
78
61.8k
            if (_eptr) {
79
2
                std::rethrow_exception(_eptr);
80
2
            }
81
61.8k
            return _status;
82
61.8k
        }
83
35.3k
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
35.3k
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
35.3k
        try {
92
35.3k
            _status = fn();
93
35.3k
        } catch (...) {
94
            // Save the exception for next call.
95
6
            _eptr = std::current_exception();
96
6
            _has_called.store(true, std::memory_order_release);
97
6
            std::rethrow_exception(_eptr);
98
6
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
35.3k
        _has_called.store(true, std::memory_order_release);
102
35.3k
        return _status;
103
35.3k
    }
Unexecuted instantiation: _ZN5doris13DorisCallOnceIN2tl8expectedINS_21EncryptionAlgorithmPBENS_6StatusEEEE4callIZNS_10RowsetMeta24set_encryption_algorithmES3_EUlvE_EES5_T_
_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v212ColumnReader22set_dict_encoding_typeENS5_16DictEncodingTypeEEUlvE_EES1_T_
Line
Count
Source
75
66
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
66
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
66
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
66
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
66
        try {
92
66
            _status = fn();
93
66
        } catch (...) {
94
            // Save the exception for next call.
95
0
            _eptr = std::current_exception();
96
0
            _has_called.store(true, std::memory_order_release);
97
0
            std::rethrow_exception(_eptr);
98
0
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
66
        _has_called.store(true, std::memory_order_release);
102
66
        return _status;
103
66
    }
doris_callonce_test.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_33DorisCallOnceTest_TestNormal_Test8TestBodyEvE3$_0EES1_T_
Line
Count
Source
75
2
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
2
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
2
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
2
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
2
        try {
92
2
            _status = fn();
93
2
        } catch (...) {
94
            // Save the exception for next call.
95
0
            _eptr = std::current_exception();
96
0
            _has_called.store(true, std::memory_order_release);
97
0
            std::rethrow_exception(_eptr);
98
0
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
2
        _has_called.store(true, std::memory_order_release);
102
2
        return _status;
103
2
    }
doris_callonce_test.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_33DorisCallOnceTest_TestNormal_Test8TestBodyEvE3$_1EES1_T_
Line
Count
Source
75
2
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
2
        if (has_called()) {
78
2
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
2
            return _status;
82
2
        }
83
0
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
0
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
0
        try {
92
0
            _status = fn();
93
0
        } catch (...) {
94
            // Save the exception for next call.
95
0
            _eptr = std::current_exception();
96
0
            _has_called.store(true, std::memory_order_release);
97
0
            std::rethrow_exception(_eptr);
98
0
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
0
        _has_called.store(true, std::memory_order_release);
102
0
        return _status;
103
0
    }
doris_callonce_test.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_39DorisCallOnceTest_TestErrorHappens_Test8TestBodyEvE3$_0EES1_T_
Line
Count
Source
75
2
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
2
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
2
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
2
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
2
        try {
92
2
            _status = fn();
93
2
        } catch (...) {
94
            // Save the exception for next call.
95
0
            _eptr = std::current_exception();
96
0
            _has_called.store(true, std::memory_order_release);
97
0
            std::rethrow_exception(_eptr);
98
0
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
2
        _has_called.store(true, std::memory_order_release);
102
2
        return _status;
103
2
    }
doris_callonce_test.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_39DorisCallOnceTest_TestErrorHappens_Test8TestBodyEvE3$_1EES1_T_
Line
Count
Source
75
2
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
2
        if (has_called()) {
78
2
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
2
            return _status;
82
2
        }
83
0
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
0
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
0
        try {
92
0
            _status = fn();
93
0
        } catch (...) {
94
            // Save the exception for next call.
95
0
            _eptr = std::current_exception();
96
0
            _has_called.store(true, std::memory_order_release);
97
0
            std::rethrow_exception(_eptr);
98
0
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
0
        _has_called.store(true, std::memory_order_release);
102
0
        return _status;
103
0
    }
doris_callonce_test.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_43DorisCallOnceTest_TestExceptionHappens_Test8TestBodyEvE3$_0EES1_T_
Line
Count
Source
75
2
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
2
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
2
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
2
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
2
        try {
92
2
            _status = fn();
93
2
        } catch (...) {
94
            // Save the exception for next call.
95
2
            _eptr = std::current_exception();
96
2
            _has_called.store(true, std::memory_order_release);
97
2
            std::rethrow_exception(_eptr);
98
2
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
0
        _has_called.store(true, std::memory_order_release);
102
0
        return _status;
103
2
    }
doris_callonce_test.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_43DorisCallOnceTest_TestExceptionHappens_Test8TestBodyEvE3$_1EES1_T_
Line
Count
Source
75
2
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
2
        if (has_called()) {
78
2
            if (_eptr) {
79
2
                std::rethrow_exception(_eptr);
80
2
            }
81
0
            return _status;
82
2
        }
83
0
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
0
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
0
        try {
92
0
            _status = fn();
93
0
        } catch (...) {
94
            // Save the exception for next call.
95
0
            _eptr = std::current_exception();
96
0
            _has_called.store(true, std::memory_order_release);
97
0
            std::rethrow_exception(_eptr);
98
0
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
0
        _has_called.store(true, std::memory_order_release);
102
0
        return _status;
103
0
    }
doris_callonce_test.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_43DorisCallOnceTest_TestExceptionHappens_Test8TestBodyEvE3$_2EES1_T_
Line
Count
Source
75
2
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
2
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
2
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
2
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
2
        try {
92
2
            _status = fn();
93
2
        } catch (...) {
94
            // Save the exception for next call.
95
2
            _eptr = std::current_exception();
96
2
            _has_called.store(true, std::memory_order_release);
97
2
            std::rethrow_exception(_eptr);
98
2
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
0
        _has_called.store(true, std::memory_order_release);
102
0
        return _status;
103
2
    }
doris_callonce_test.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_43DorisCallOnceTest_TestExceptionHappens_Test8TestBodyEvE3$_3EES1_T_
Line
Count
Source
75
2
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
2
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
2
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
2
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
2
        try {
92
2
            _status = fn();
93
2
        } catch (...) {
94
            // Save the exception for next call.
95
2
            _eptr = std::current_exception();
96
2
            _has_called.store(true, std::memory_order_release);
97
2
            std::rethrow_exception(_eptr);
98
2
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
0
        _has_called.store(true, std::memory_order_release);
102
0
        return _status;
103
2
    }
bloom_filter_index_reader.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v222BloomFilterIndexReader4loadEbbPNS_20OlapReaderStatisticsEPKNS_2io9IOContextEE3$_0EES1_T_
Line
Count
Source
75
84
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
84
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
84
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
84
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
84
        try {
92
84
            _status = fn();
93
84
        } catch (...) {
94
            // Save the exception for next call.
95
0
            _eptr = std::current_exception();
96
0
            _has_called.store(true, std::memory_order_release);
97
0
            std::rethrow_exception(_eptr);
98
0
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
84
        _has_called.store(true, std::memory_order_release);
102
84
        return _status;
103
84
    }
ordinal_page_index.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v218OrdinalIndexReader4loadEbbPNS_20OlapReaderStatisticsEPKNS_2io9IOContextEE3$_0EES1_T_
Line
Count
Source
75
18.2k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
18.2k
        if (has_called()) {
78
1.43k
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
1.43k
            return _status;
82
1.43k
        }
83
16.8k
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
16.8k
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
16.8k
        try {
92
16.8k
            _status = fn();
93
16.8k
        } catch (...) {
94
            // Save the exception for next call.
95
0
            _eptr = std::current_exception();
96
0
            _has_called.store(true, std::memory_order_release);
97
0
            std::rethrow_exception(_eptr);
98
0
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
16.8k
        _has_called.store(true, std::memory_order_release);
102
16.8k
        return _status;
103
16.8k
    }
zone_map_index.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v218ZoneMapIndexReader4loadEbbPNS_20OlapReaderStatisticsEPKNS_2io9IOContextEE3$_0EES1_T_
Line
Count
Source
75
174
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
174
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
174
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
174
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
174
        try {
92
174
            _status = fn();
93
174
        } catch (...) {
94
            // Save the exception for next call.
95
0
            _eptr = std::current_exception();
96
0
            _has_called.store(true, std::memory_order_release);
97
0
            std::rethrow_exception(_eptr);
98
0
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
174
        _has_called.store(true, std::memory_order_release);
102
174
        return _status;
103
174
    }
beta_rowset.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10BetaRowset20get_segment_num_rowsEPSt6vectorIjSaIjEEbPNS_20OlapReaderStatisticsEPKNS_2io9IOContextEE3$_0EES1_T_
Line
Count
Source
75
996
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
996
        if (has_called()) {
78
84
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
84
            return _status;
82
84
        }
83
912
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
912
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
912
        try {
92
912
            _status = fn();
93
912
        } catch (...) {
94
            // Save the exception for next call.
95
0
            _eptr = std::current_exception();
96
0
            _has_called.store(true, std::memory_order_release);
97
0
            std::rethrow_exception(_eptr);
98
0
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
912
        _has_called.store(true, std::memory_order_release);
102
912
        return _status;
103
912
    }
beta_rowset_reader.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_16BetaRowsetReader19_init_iterator_onceEvE3$_0EES1_T_
Line
Count
Source
75
13.7k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
13.7k
        if (has_called()) {
78
12.9k
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
12.9k
            return _status;
82
12.9k
        }
83
708
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
708
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
708
        try {
92
708
            _status = fn();
93
708
        } catch (...) {
94
            // Save the exception for next call.
95
0
            _eptr = std::current_exception();
96
0
            _has_called.store(true, std::memory_order_release);
97
0
            std::rethrow_exception(_eptr);
98
0
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
708
        _has_called.store(true, std::memory_order_release);
102
708
        return _status;
103
708
    }
segment.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v27Segment21_load_pk_bloom_filterEPNS_20OlapReaderStatisticsEPKNS_2io9IOContextEE3$_0EES1_T_
Line
Count
Source
75
4
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
4
        if (has_called()) {
78
2
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
2
            return _status;
82
2
        }
83
2
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
2
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
2
        try {
92
2
            _status = fn();
93
2
        } catch (...) {
94
            // Save the exception for next call.
95
0
            _eptr = std::current_exception();
96
0
            _has_called.store(true, std::memory_order_release);
97
0
            std::rethrow_exception(_eptr);
98
0
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
2
        _has_called.store(true, std::memory_order_release);
102
2
        return _status;
103
2
    }
segment.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v27Segment21_load_pk_bloom_filterEPNS_20OlapReaderStatisticsEPKNS_2io9IOContextEE3$_1EES1_T_
Line
Count
Source
75
8
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
8
        if (has_called()) {
78
4
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
4
            return _status;
82
4
        }
83
4
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
4
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
4
        try {
92
4
            _status = fn();
93
4
        } catch (...) {
94
            // Save the exception for next call.
95
0
            _eptr = std::current_exception();
96
0
            _has_called.store(true, std::memory_order_release);
97
0
            std::rethrow_exception(_eptr);
98
0
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
4
        _has_called.store(true, std::memory_order_release);
102
4
        return _status;
103
4
    }
segment.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v27Segment10load_indexEPNS_20OlapReaderStatisticsEPKNS_2io9IOContextEE3$_0EES1_T_
Line
Count
Source
75
6.18k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
6.18k
        if (has_called()) {
78
124
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
124
            return _status;
82
124
        }
83
6.05k
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
6.05k
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
6.05k
        try {
92
6.05k
            _status = fn();
93
6.05k
        } catch (...) {
94
            // Save the exception for next call.
95
0
            _eptr = std::current_exception();
96
0
            _has_called.store(true, std::memory_order_release);
97
0
            std::rethrow_exception(_eptr);
98
0
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
6.05k
        _has_called.store(true, std::memory_order_release);
102
6.05k
        return _status;
103
6.05k
    }
segment.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v27Segment24_create_column_meta_onceEPNS_20OlapReaderStatisticsEPKNS_2io9IOContextEE3$_0EES1_T_
Line
Count
Source
75
49.8k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
49.8k
        if (has_called()) {
78
42.5k
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
42.5k
            return _status;
82
42.5k
        }
83
7.26k
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
7.26k
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
7.26k
        try {
92
7.26k
            _status = fn();
93
7.26k
        } catch (...) {
94
            // Save the exception for next call.
95
0
            _eptr = std::current_exception();
96
0
            _has_called.store(true, std::memory_order_release);
97
0
            std::rethrow_exception(_eptr);
98
0
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
7.26k
        _has_called.store(true, std::memory_order_release);
102
7.26k
        return _status;
103
7.26k
    }
segment.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v27Segment18new_index_iteratorERKNS_12TabletColumnEPKNS_11TabletIndexERKNS_18StorageReadOptionsEPSt10unique_ptrINS4_13IndexIteratorESt14default_deleteISG_EEE3$_0EES1_T_
Line
Count
Source
75
5.35k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
5.35k
        if (has_called()) {
78
3.87k
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
3.87k
            return _status;
82
3.87k
        }
83
1.48k
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
1.48k
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
1.48k
        try {
92
1.48k
            _status = fn();
93
1.48k
        } catch (...) {
94
            // Save the exception for next call.
95
0
            _eptr = std::current_exception();
96
0
            _has_called.store(true, std::memory_order_release);
97
0
            std::rethrow_exception(_eptr);
98
0
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
1.48k
        _has_called.store(true, std::memory_order_release);
102
1.48k
        return _status;
103
1.48k
    }
variant_external_meta_reader.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v225VariantExternalMetaReader13load_all_onceEPNS_14SubcolumnsTreeINS4_13SubcolumnMetaELb1EEEPNS4_17VariantStatisticsEPNS_20OlapReaderStatisticsEPKNS_2io9IOContextEE3$_0EES1_T_
Line
Count
Source
75
1.07k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
1.07k
        if (has_called()) {
78
484
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
484
            return _status;
82
484
        }
83
588
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
588
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
588
        try {
92
588
            _status = fn();
93
588
        } catch (...) {
94
            // Save the exception for next call.
95
0
            _eptr = std::current_exception();
96
0
            _has_called.store(true, std::memory_order_release);
97
0
            std::rethrow_exception(_eptr);
98
0
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
588
        _has_called.store(true, std::memory_order_release);
102
588
        return _status;
103
588
    }
tablet.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_6Tablet4initEvE3$_0EES1_T_
Line
Count
Source
75
1.38k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
1.38k
        if (has_called()) {
78
230
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
230
            return _status;
82
230
        }
83
1.15k
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
1.15k
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
1.15k
        try {
92
1.15k
            _status = fn();
93
1.15k
        } catch (...) {
94
            // Save the exception for next call.
95
0
            _eptr = std::current_exception();
96
0
            _has_called.store(true, std::memory_order_release);
97
0
            std::rethrow_exception(_eptr);
98
0
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
1.15k
        _has_called.store(true, std::memory_order_release);
102
1.15k
        return _status;
103
1.15k
    }
load_path_mgr.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_11LoadPathMgr12allocate_dirERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESC_PSA_lE3$_0EES1_T_
Line
Count
Source
75
4
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
4
        if (has_called()) {
78
2
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
2
            return _status;
82
2
        }
83
2
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
2
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
2
        try {
92
2
            _status = fn();
93
2
        } catch (...) {
94
            // Save the exception for next call.
95
0
            _eptr = std::current_exception();
96
0
            _has_called.store(true, std::memory_order_release);
97
0
            std::rethrow_exception(_eptr);
98
0
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
2
        _has_called.store(true, std::memory_order_release);
102
2
        return _status;
103
2
    }
ann_index_reader.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v214AnnIndexReader10load_indexEPNS_2io9IOContextEE3$_0EES1_T_
Line
Count
Source
75
6
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
6
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
6
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
6
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
6
        try {
92
6
            _status = fn();
93
6
        } catch (...) {
94
            // Save the exception for next call.
95
0
            _eptr = std::current_exception();
96
0
            _has_called.store(true, std::memory_order_release);
97
0
            std::rethrow_exception(_eptr);
98
0
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
6
        _has_called.store(true, std::memory_order_release);
102
6
        return _status;
103
6
    }
104
105
    // Has to pay attention to memory order
106
    // see https://en.cppreference.com/w/cpp/atomic/memory_order
107
    // Return whether `call` has been invoked or not.
108
133k
    bool has_called() const {
109
        // std::memory_order_acquire here and std::memory_order_release in
110
        // init(), taken together, mean that threads can safely synchronize on
111
        // _has_called.
112
133k
        return _has_called.load(std::memory_order_acquire);
113
133k
    }
Unexecuted instantiation: _ZNK5doris13DorisCallOnceIN2tl8expectedINS_21EncryptionAlgorithmPBENS_6StatusEEEE10has_calledEv
_ZNK5doris13DorisCallOnceINS_6StatusEE10has_calledEv
Line
Count
Source
108
133k
    bool has_called() const {
109
        // std::memory_order_acquire here and std::memory_order_release in
110
        // init(), taken together, mean that threads can safely synchronize on
111
        // _has_called.
112
133k
        return _has_called.load(std::memory_order_acquire);
113
133k
    }
114
115
    // Return the stored result. The result is only meaningful when `has_called() == true`.
116
406
    ReturnType stored_result() const {
117
406
        if (!has_called()) {
118
            // Could not return status if the method not called.
119
0
            throw doris::Exception(doris::ErrorCode::INTERNAL_ERROR,
120
0
                                   "calling stored_result while has not been called");
121
0
        }
122
406
        if (_eptr) {
123
2
            std::rethrow_exception(_eptr);
124
2
        }
125
404
        return _status;
126
406
    }
127
128
private:
129
    std::atomic<bool> _has_called;
130
    // std::once_flag _once_flag;
131
    std::mutex _flag_lock;
132
    std::exception_ptr _eptr;
133
    ReturnType _status;
134
};
135
136
} // namespace doris