Coverage Report

Created: 2025-07-25 21:23

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/root/doris/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 "olap/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
247k
    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
143k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
143k
        if (has_called()) {
78
93.1k
            if (_eptr) {
79
2
                std::rethrow_exception(_eptr);
80
2
            }
81
93.1k
            return _status;
82
93.1k
        }
83
50.5k
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
50.5k
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
50.5k
        try {
92
50.5k
            _status = fn();
93
50.5k
        } 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
50.5k
        _has_called.store(true, std::memory_order_release);
102
50.5k
        return _status;
103
50.5k
    }
Unexecuted instantiation: _ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v212ColumnReader22set_dict_encoding_typeENS5_16DictEncodingTypeEEUlvE_EES1_T_
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
    }
beta_rowset.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10BetaRowset20get_segment_num_rowsEPSt6vectorIjSaIjEEE3$_0EES1_T_
Line
Count
Source
75
958
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
958
        if (has_called()) {
78
82
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
82
            return _status;
82
82
        }
83
876
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
876
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
876
        try {
92
876
            _status = fn();
93
876
        } 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
876
        _has_called.store(true, std::memory_order_release);
102
876
        return _status;
103
876
    }
beta_rowset_reader.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_16BetaRowsetReader19_init_iterator_onceEvE3$_0EES1_T_
Line
Count
Source
75
13.4k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
13.4k
        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
494
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
494
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
494
        try {
92
494
            _status = fn();
93
494
        } 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
494
        _has_called.store(true, std::memory_order_release);
102
494
        return _status;
103
494
    }
bitmap_index_reader.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v217BitmapIndexReader4loadEbbE3$_0EES1_T_
Line
Count
Source
75
8
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
8
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
8
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
8
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
8
        try {
92
8
            _status = fn();
93
8
        } 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
8
        _has_called.store(true, std::memory_order_release);
102
8
        return _status;
103
8
    }
bloom_filter_index_reader.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v222BloomFilterIndexReader4loadEbbPNS_20OlapReaderStatisticsEE3$_0EES1_T_
Line
Count
Source
75
74
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
74
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
74
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
74
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
74
        try {
92
74
            _status = fn();
93
74
        } 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
74
        _has_called.store(true, std::memory_order_release);
102
74
        return _status;
103
74
    }
ordinal_page_index.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v218OrdinalIndexReader4loadEbbPNS_20OlapReaderStatisticsEE3$_0EES1_T_
Line
Count
Source
75
25.8k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
25.8k
        if (has_called()) {
78
1.03k
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
1.03k
            return _status;
82
1.03k
        }
83
24.7k
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
24.7k
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
24.7k
        try {
92
24.7k
            _status = fn();
93
24.7k
        } 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
24.7k
        _has_called.store(true, std::memory_order_release);
102
24.7k
        return _status;
103
24.7k
    }
segment.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v27Segment21_load_pk_bloom_filterEPNS_20OlapReaderStatisticsEE3$_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_20OlapReaderStatisticsEE3$_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_20OlapReaderStatisticsEE3$_0EES1_T_
Line
Count
Source
75
11.1k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
11.1k
        if (has_called()) {
78
124
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
124
            return _status;
82
124
        }
83
11.0k
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
11.0k
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
11.0k
        try {
92
11.0k
            _status = fn();
93
11.0k
        } 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
11.0k
        _has_called.store(true, std::memory_order_release);
102
11.0k
        return _status;
103
11.0k
    }
segment.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v27Segment27_create_column_readers_onceEPNS_20OlapReaderStatisticsEE3$_0EES1_T_
Line
Count
Source
75
85.5k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
85.5k
        if (has_called()) {
78
74.6k
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
74.6k
            return _status;
82
74.6k
        }
83
10.9k
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
10.9k
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
10.9k
        try {
92
10.9k
            _status = fn();
93
10.9k
        } 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
10.9k
        _has_called.store(true, std::memory_order_release);
102
10.9k
        return _status;
103
10.9k
    }
segment.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v27Segment18new_index_iteratorERKNS_12TabletColumnEPKNS_11TabletIndexERKNS_18StorageReadOptionsEPSt10unique_ptrINS4_13IndexIteratorESt14default_deleteISG_EEE3$_0EES1_T_
Line
Count
Source
75
5.10k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
5.10k
        if (has_called()) {
78
3.80k
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
3.80k
            return _status;
82
3.80k
        }
83
1.29k
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
1.29k
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
1.29k
        try {
92
1.29k
            _status = fn();
93
1.29k
        } 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.29k
        _has_called.store(true, std::memory_order_release);
102
1.29k
        return _status;
103
1.29k
    }
zone_map_index.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_10segment_v218ZoneMapIndexReader4loadEbbPNS_20OlapReaderStatisticsEE3$_0EES1_T_
Line
Count
Source
75
8
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
8
        if (has_called()) {
78
0
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
0
            return _status;
82
0
        }
83
8
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
8
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
8
        try {
92
8
            _status = fn();
93
8
        } 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
8
        _has_called.store(true, std::memory_order_release);
102
8
        return _status;
103
8
    }
tablet.cpp:_ZN5doris13DorisCallOnceINS_6StatusEE4callIZNS_6Tablet4initEvE3$_0EES1_T_
Line
Count
Source
75
1.49k
    ReturnType call(Fn fn) {
76
        // Avoid lock to improve performance
77
1.49k
        if (has_called()) {
78
454
            if (_eptr) {
79
0
                std::rethrow_exception(_eptr);
80
0
            }
81
454
            return _status;
82
454
        }
83
1.03k
        std::lock_guard l(_flag_lock);
84
        // should check again because maybe another thread call successfully.
85
1.03k
        if (has_called()) {
86
0
            if (_eptr) {
87
0
                std::rethrow_exception(_eptr);
88
0
            }
89
0
            return _status;
90
0
        }
91
1.03k
        try {
92
1.03k
            _status = fn();
93
1.03k
        } 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.03k
        _has_called.store(true, std::memory_order_release);
102
1.03k
        return _status;
103
1.03k
    }
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
    }
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
195k
    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
195k
        return _has_called.load(std::memory_order_acquire);
113
195k
    }
114
115
    // Return the stored result. The result is only meaningful when `has_called() == true`.
116
694
    ReturnType stored_result() const {
117
694
        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
694
        if (_eptr) {
123
2
            std::rethrow_exception(_eptr);
124
2
        }
125
692
        return _status;
126
694
    }
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