THUAI6/CAPI/cpp/grpc/include/google/protobuf/arenaz_sampler.h

// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.  All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#ifndef GOOGLE_PROTOBUF_SRC_GOOGLE_PROTOBUF_ARENAZ_SAMPLER_H__
#define GOOGLE_PROTOBUF_SRC_GOOGLE_PROTOBUF_ARENAZ_SAMPLER_H__

#include <atomic>
#include <cstddef>
#include <cstdint>

// Must be included last.
#include <google/protobuf/port_def.inc>

namespace google
{
    namespace protobuf
    {
        namespace internal
        {

#if defined(PROTOBUF_ARENAZ_SAMPLE)
            struct ThreadSafeArenaStats;
            void RecordResetSlow(ThreadSafeArenaStats* info);
            void RecordAllocateSlow(ThreadSafeArenaStats* info, size_t requested, size_t allocated, size_t wasted);
            // Stores information about a sampled thread safe arena.  All mutations to this
            // *must* be made through `Record*` functions below.  All reads from this *must*
            // only occur in the callback to `ThreadSafeArenazSampler::Iterate`.
            struct ThreadSafeArenaStats : public absl::profiling_internal::Sample<ThreadSafeArenaStats>
            {
                // Constructs the object but does not fill in any fields.
                ThreadSafeArenaStats();
                ~ThreadSafeArenaStats();

                // Puts the object into a clean state, fills in the logically `const` members,
                // blocking for any readers that are currently sampling the object.
                void PrepareForSampling() ABSL_EXCLUSIVE_LOCKS_REQUIRED(init_mu);

                // These fields are mutated by the various Record* APIs and need to be
                // thread-safe.
                std::atomic<int> num_allocations;
                std::atomic<int> num_resets;
                std::atomic<size_t> bytes_requested;
                std::atomic<size_t> bytes_allocated;
                std::atomic<size_t> bytes_wasted;
                // Records the largest size an arena ever had.  Maintained across resets.
                std::atomic<size_t> max_bytes_allocated;
                // Bit i when set to 1 indicates that a thread with tid % 63 = i accessed the
                // underlying arena.  The field is maintained across resets.
                std::atomic<uint64_t> thread_ids;

                // All of the fields below are set by `PrepareForSampling`, they must not
                // be mutated in `Record*` functions.  They are logically `const` in that
                // sense. These are guarded by init_mu, but that is not externalized to
                // clients, who can only read them during
                // `ThreadSafeArenazSampler::Iterate` which will hold the lock.
                static constexpr int kMaxStackDepth = 64;
                int32_t depth;
                void* stack[kMaxStackDepth];
                static void RecordAllocateStats(ThreadSafeArenaStats* info, size_t requested, size_t allocated, size_t wasted)
                {
                    if (PROTOBUF_PREDICT_TRUE(info == nullptr))
                        return;
                    RecordAllocateSlow(info, requested, allocated, wasted);
                }
            };

            ThreadSafeArenaStats* SampleSlow(int64_t* next_sample);
            void UnsampleSlow(ThreadSafeArenaStats* info);

            class ThreadSafeArenaStatsHandle
            {
            public:
                explicit ThreadSafeArenaStatsHandle() = default;
                explicit ThreadSafeArenaStatsHandle(ThreadSafeArenaStats* info) :
                    info_(info)
                {
                }

                ~ThreadSafeArenaStatsHandle()
                {
                    if (PROTOBUF_PREDICT_TRUE(info_ == nullptr))
                        return;
                    UnsampleSlow(info_);
                }

                ThreadSafeArenaStatsHandle(ThreadSafeArenaStatsHandle&& other) noexcept
                    :
                    info_(absl::exchange(other.info_, nullptr))
                {
                }

                ThreadSafeArenaStatsHandle& operator=(
                    ThreadSafeArenaStatsHandle&& other
                ) noexcept
                {
                    if (PROTOBUF_PREDICT_FALSE(info_ != nullptr))
                    {
                        UnsampleSlow(info_);
                    }
                    info_ = absl::exchange(other.info_, nullptr);
                    return *this;
                }

                void RecordReset()
                {
                    if (PROTOBUF_PREDICT_TRUE(info_ == nullptr))
                        return;
                    RecordResetSlow(info_);
                }

                ThreadSafeArenaStats* MutableStats()
                {
                    return info_;
                }

                friend void swap(ThreadSafeArenaStatsHandle& lhs, ThreadSafeArenaStatsHandle& rhs)
                {
                    std::swap(lhs.info_, rhs.info_);
                }

                friend class ThreadSafeArenaStatsHandlePeer;

            private:
                ThreadSafeArenaStats* info_ = nullptr;
            };

            using ThreadSafeArenazSampler =
                ::absl::profiling_internal::SampleRecorder<ThreadSafeArenaStats>;

            extern PROTOBUF_THREAD_LOCAL int64_t global_next_sample;

            // Returns an RAII sampling handle that manages registration and unregistation
            // with the global sampler.
            inline ThreadSafeArenaStatsHandle Sample()
            {
                if (PROTOBUF_PREDICT_TRUE(--global_next_sample > 0))
                {
                    return ThreadSafeArenaStatsHandle(nullptr);
                }
                return ThreadSafeArenaStatsHandle(SampleSlow(&global_next_sample));
            }

#else
            struct ThreadSafeArenaStats
            {
                static void RecordAllocateStats(ThreadSafeArenaStats*, size_t /*requested*/, size_t /*allocated*/, size_t /*wasted*/)
                {
                }
            };

            ThreadSafeArenaStats* SampleSlow(int64_t* next_sample);
            void UnsampleSlow(ThreadSafeArenaStats* info);

            class ThreadSafeArenaStatsHandle
            {
            public:
                explicit ThreadSafeArenaStatsHandle() = default;
                explicit ThreadSafeArenaStatsHandle(ThreadSafeArenaStats*)
                {
                }

                void RecordReset()
                {
                }

                ThreadSafeArenaStats* MutableStats()
                {
                    return nullptr;
                }

                friend void swap(ThreadSafeArenaStatsHandle&, ThreadSafeArenaStatsHandle&)
                {
                }

            private:
                friend class ThreadSafeArenaStatsHandlePeer;
            };

            class ThreadSafeArenazSampler
            {
            public:
                void Unregister(ThreadSafeArenaStats*)
                {
                }
                void SetMaxSamples(int32_t)
                {
                }
            };

            // Returns an RAII sampling handle that manages registration and unregistation
            // with the global sampler.
            inline ThreadSafeArenaStatsHandle Sample()
            {
                return ThreadSafeArenaStatsHandle(nullptr);
            }
#endif  // defined(PROTOBUF_ARENAZ_SAMPLE)

            // Returns a global Sampler.
            ThreadSafeArenazSampler& GlobalThreadSafeArenazSampler();

            // Enables or disables sampling for thread safe arenas.
            void SetThreadSafeArenazEnabled(bool enabled);

            // Sets the rate at which thread safe arena will be sampled.
            void SetThreadSafeArenazSampleParameter(int32_t rate);

            // Sets a soft max for the number of samples that will be kept.
            void SetThreadSafeArenazMaxSamples(int32_t max);

            // Sets the current value for when arenas should be next sampled.
            void SetThreadSafeArenazGlobalNextSample(int64_t next_sample);

        }  // namespace internal
    }      // namespace protobuf
}  // namespace google

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_SRC_PROTOBUF_ARENAZ_SAMPLER_H__