Coverage Report

Created: 2026-08-18 15:11

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
100k
    DorisCallOnce() : _has_called(false) {}
_ZN5doris13DorisCallOnceIN2tl8expectedINS_21EncryptionAlgorithmPBENS_6StatusEEEEC2Ev
Line
Count
Source
54
18.2k
    DorisCallOnce() : _has_called(false) {}
_ZN5doris13DorisCallOnceINS_6StatusEEC2Ev
Line
Count
Source
54
81.8k
    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
64.6k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
64.6k
        if (has_called()) {
78
39.2k
            if (_eptr) {
79
1
                std::rethrow_exception(_eptr);
80
1
            }
81
39.2k
            return _status;
82
39.2k
        }
83
25.4k
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
25.4k
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
25.4k
        try {
92
25.4k
            _status = fn();
93
25.4k
        } catch (...) {
94
            // Save the exception for next call.
95
3
            _eptr = std::current_exception();
96
3
            _has_called.store(true, std::memory_order_release);
97
3
            std::rethrow_exception(_eptr);
98
3
        }
99
        // This memory order make sure both status and eptr is set
100
        // and will be seen in another thread.
101
25.4k
        _has_called.store(true, std::memory_order_release);
102
25.4k
        return _status;
103
25.4k
    }
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
41
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
41
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
41
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
41
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
41
        try {
92
41
            _status = fn();
93
41
        } 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
41
        _has_called.store(true, std::memory_order_release);
102
41
        return _status;
103
41
    }
doris_callonce_test.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_33DorisCallOnceTest_TestNormal_Test8TestBodyEvE3$_0EES1_T_
Line
Count
Source
75
1
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
1
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
1
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
1
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
1
        try {
92
1
            _status = fn();
93
1
        } 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
        _has_called.store(true, std::memory_order_release);
102
1
        return _status;
103
1
    }
doris_callonce_test.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_33DorisCallOnceTest_TestNormal_Test8TestBodyEvE3$_1EES1_T_
Line
Count
Source
75
1
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
1
        if (has_called()) {
78
1
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
1
            return _status;
82
1
        }
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
1
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
1
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
1
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
1
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
1
        try {
92
1
            _status = fn();
93
1
        } 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
        _has_called.store(true, std::memory_order_release);
102
1
        return _status;
103
1
    }
doris_callonce_test.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_39DorisCallOnceTest_TestErrorHappens_Test8TestBodyEvE3$_1EES1_T_
Line
Count
Source
75
1
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
1
        if (has_called()) {
78
1
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
1
            return _status;
82
1
        }
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
1
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
1
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
1
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
1
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
1
        try {
92
1
            _status = fn();
93
1
        } catch (...) {
94
            // Save the exception for next call.
95
1
            _eptr = std::current_exception();
96
1
            _has_called.store(true, std::memory_order_release);
97
1
            std::rethrow_exception(_eptr);
98
1
        }
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
1
    }
doris_callonce_test.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_43DorisCallOnceTest_TestExceptionHappens_Test8TestBodyEvE3$_1EES1_T_
Line
Count
Source
75
1
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
1
        if (has_called()) {
78
1
            if (_eptr) {
79
1
                std::rethrow_exception(_eptr);
80
1
            }
81
0
            return _status;
82
1
        }
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
1
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
1
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
1
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
1
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
1
        try {
92
1
            _status = fn();
93
1
        } catch (...) {
94
            // Save the exception for next call.
95
1
            _eptr = std::current_exception();
96
1
            _has_called.store(true, std::memory_order_release);
97
1
            std::rethrow_exception(_eptr);
98
1
        }
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
1
    }
doris_callonce_test.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_43DorisCallOnceTest_TestExceptionHappens_Test8TestBodyEvE3$_3EES1_T_
Line
Count
Source
75
1
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
1
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
1
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
1
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
1
        try {
92
1
            _status = fn();
93
1
        } catch (...) {
94
            // Save the exception for next call.
95
1
            _eptr = std::current_exception();
96
1
            _has_called.store(true, std::memory_order_release);
97
1
            std::rethrow_exception(_eptr);
98
1
        }
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
1
    }
unity_24_cxx.cxx:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v225VariantExternalMetaReader13load_all_onceEPNS_14SubcolumnsTreeINS4_13SubcolumnMetaELb1EEEPNS4_17VariantStatisticsEPNS_20OlapReaderStatisticsEPKNS_2io9IOContextEE3$_0EES1_T_
Line
Count
Source
75
601
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
601
        if (has_called()) {
78
276
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
276
            return _status;
82
276
        }
83
325
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
325
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
325
        try {
92
325
            _status = fn();
93
325
        } 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
325
        _has_called.store(true, std::memory_order_release);
102
325
        return _status;
103
325
    }
unity_22_cxx.cxx:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v27Segment21_load_pk_bloom_filterEPNS_20OlapReaderStatisticsEPKNS_2io9IOContextEE3$_0EES1_T_
Line
Count
Source
75
2
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
2
        if (has_called()) {
78
1
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
1
            return _status;
82
1
        }
83
1
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
1
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
1
        try {
92
1
            _status = fn();
93
1
        } 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
        _has_called.store(true, std::memory_order_release);
102
1
        return _status;
103
1
    }
unity_22_cxx.cxx:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v27Segment21_load_pk_bloom_filterEPNS_20OlapReaderStatisticsEPKNS_2io9IOContextEE3$_1EES1_T_
Line
Count
Source
75
662
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
662
        if (has_called()) {
78
499
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
499
            return _status;
82
499
        }
83
163
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
163
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
163
        try {
92
163
            _status = fn();
93
163
        } 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
163
        _has_called.store(true, std::memory_order_release);
102
163
        return _status;
103
163
    }
unity_22_cxx.cxx:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v27Segment10load_indexEPNS_20OlapReaderStatisticsEPKNS_2io9IOContextEE3$_0EES1_T_
Line
Count
Source
75
5.14k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
5.14k
        if (has_called()) {
78
601
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
601
            return _status;
82
601
        }
83
4.54k
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
4.54k
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
4.54k
        try {
92
4.54k
            _status = fn();
93
4.54k
        } 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.54k
        _has_called.store(true, std::memory_order_release);
102
4.54k
        return _status;
103
4.54k
    }
unity_22_cxx.cxx:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v27Segment24_create_column_meta_onceEPNS_20OlapReaderStatisticsEPKNS_2io9IOContextEE3$_0EES1_T_
Line
Count
Source
75
33.6k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
33.6k
        if (has_called()) {
78
28.3k
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
28.3k
            return _status;
82
28.3k
        }
83
5.26k
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
5.26k
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
5.26k
        try {
92
5.26k
            _status = fn();
93
5.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
5.26k
        _has_called.store(true, std::memory_order_release);
102
5.26k
        return _status;
103
5.26k
    }
unity_22_cxx.cxx:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v27Segment18new_index_iteratorERKNS_12TabletColumnEPKNS_11TabletIndexERKNS_18StorageReadOptionsEPSt10unique_ptrINS4_13IndexIteratorESt14default_deleteISG_EEE3$_0EES1_T_
Line
Count
Source
75
2.72k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
2.72k
        if (has_called()) {
78
1.95k
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
1.95k
            return _status;
82
1.95k
        }
83
771
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
771
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
771
        try {
92
771
            _status = fn();
93
771
        } 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
771
        _has_called.store(true, std::memory_order_release);
102
771
        return _status;
103
771
    }
unity_19_cxx.cxx:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10BetaRowset20get_segment_num_rowsEPSt6vectorIjSaIjEEbPNS_20OlapReaderStatisticsEPKNS_2io9IOContextEE3$_0EES1_T_
Line
Count
Source
75
510
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
510
        if (has_called()) {
78
44
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
44
            return _status;
82
44
        }
83
466
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
466
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
466
        try {
92
466
            _status = fn();
93
466
        } 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
466
        _has_called.store(true, std::memory_order_release);
102
466
        return _status;
103
466
    }
unity_19_cxx.cxx:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_16BetaRowsetReader19_init_iterator_onceEvE3$_0EES1_T_
Line
Count
Source
75
7.01k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
7.01k
        if (has_called()) {
78
6.60k
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
6.60k
            return _status;
82
6.60k
        }
83
402
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
402
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
402
        try {
92
402
            _status = fn();
93
402
        } 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
402
        _has_called.store(true, std::memory_order_release);
102
402
        return _status;
103
402
    }
unity_10_cxx.cxx:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v218OrdinalIndexReader4loadEbbPNS_20OlapReaderStatisticsEPKNS_2io9IOContextEE3$_0EES1_T_
Line
Count
Source
75
13.1k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
13.1k
        if (has_called()) {
78
796
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
796
            return _status;
82
796
        }
83
12.3k
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
12.3k
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
12.3k
        try {
92
12.3k
            _status = fn();
93
12.3k
        } 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
12.3k
        _has_called.store(true, std::memory_order_release);
102
12.3k
        return _status;
103
12.3k
    }
unity_1_cxx.cxx:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v222BloomFilterIndexReader4loadEbbPNS_20OlapReaderStatisticsEPKNS_2io9IOContextEE3$_0EES1_T_
Line
Count
Source
75
243
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
243
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
243
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
243
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
243
        try {
92
243
            _status = fn();
93
243
        } 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
243
        _has_called.store(true, std::memory_order_release);
102
243
        return _status;
103
243
    }
zone_map_index.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v218ZoneMapIndexReader4loadEbbPNS_20OlapReaderStatisticsEPKNS_2io9IOContextEE3$_0EES1_T_
Line
Count
Source
75
95
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
95
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
95
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
95
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
95
        try {
92
95
            _status = fn();
93
95
        } 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
95
        _has_called.store(true, std::memory_order_release);
102
95
        return _status;
103
95
    }
tablet.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_6Tablet4initEvE3$_0EES1_T_
Line
Count
Source
75
824
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
824
        if (has_called()) {
78
136
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
136
            return _status;
82
136
        }
83
688
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
688
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
688
        try {
92
688
            _status = fn();
93
688
        } 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
688
        _has_called.store(true, std::memory_order_release);
102
688
        return _status;
103
688
    }
unity_1_cxx.cxx:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_11LoadPathMgr12allocate_dirERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESC_PSA_lE3$_0EES1_T_
Line
Count
Source
75
2
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
2
        if (has_called()) {
78
1
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
1
            return _status;
82
1
        }
83
1
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
1
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
1
        try {
92
1
            _status = fn();
93
1
        } 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
        _has_called.store(true, std::memory_order_release);
102
1
        return _status;
103
1
    }
unity_0_cxx.cxx:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v214AnnIndexReader10load_indexEPNS_2io9IOContextEE3$_0EES1_T_
Line
Count
Source
75
20
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
20
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
20
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
20
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
20
        try {
92
20
            _status = fn();
93
20
        } 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
20
        _has_called.store(true, std::memory_order_release);
102
20
        return _status;
103
20
    }
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
90.6k
    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
90.6k
        return _has_called.load(std::memory_order_acquire);
113
90.6k
    }
Unexecuted instantiation: _ZNK5doris13DorisCallOnceIN2tl8expectedINS_21EncryptionAlgorithmPBENS_6StatusEEEE10has_calledEv
_ZNK5doris13DorisCallOnceINS_6StatusEE10has_calledEv
Line
Count
Source
108
90.6k
    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
90.6k
        return _has_called.load(std::memory_order_acquire);
113
90.6k
    }
114
115
    // Return the stored result. The result is only meaningful when `has_called() == true`.
116
293
    ReturnType stored_result() const {
117
293
        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
293
        if (_eptr) {
123
1
            std::rethrow_exception(_eptr);
124
1
        }
125
292
        return _status;
126
293
    }
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