// Licensed to the Apache Software Foundation (ASF) under one

// or more contributor license agreements.  See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership.  The ASF licenses this file

// to you under the Apache License, Version 2.0 (the

// "License"); you may not use this file except in compliance

// with the License.  You may obtain a copy of the License at

//

//   http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing,

// software distributed under the License is distributed on an

// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

// KIND, either express or implied.  See the License for the

// specific language governing permissions and limitations

// under the License.

// This file is copied from

// https://github.com/ClickHouse/ClickHouse/blob/master/src/Common/MultiVersion.h

// and modified by Doris

#pragma once

#include <atomic>

#include <memory>

#ifdef USE_LIBCPP

#include "common/atomic_shared_ptr.h"

#endif

/** Allow to store and read-only usage of an object in several threads,

  *  and to atomically replace an object in another thread.

  * The replacement is atomic and reading threads can work with different versions of an object.

  *

  * Usage:

  *  MultiVersion<T> x;

  * - on data update:

  *  x.set(new value);

  * - on read-only usage:

  * {

  *     MultiVersion<T>::Version current_version = x.get();

  *     // use *current_version

  * }   // now we finish own current version; if the version is outdated and no one else is using it - it will be destroyed.

  *

  * All methods are thread-safe.

  */

template <typename T>

class MultiVersion {

public:

    /// Version of object for usage. shared_ptr manage lifetime of version.

    using Version = std::shared_ptr<const T>;

    /// Default initialization - by nullptr.

    MultiVersion() = default;

    explicit MultiVersion(std::unique_ptr<const T>&& value) : current_version(std::move(value)) {}

    /// Obtain current version for read-only usage. Returns shared_ptr, that manages lifetime of version.

    Version get() const { return current_version.load(); }

_ZNK12MultiVersionIN5doris14RuntimeProfileEE3getEv

Line

Count

Source

58

16

    Version get() const { return current_version.load(); }

_ZNK12MultiVersionIN5doris11SymbolIndexEE3getEv

Line

Count

Source

58

171k

    Version get() const { return current_version.load(); }

    /// Update an object with new version.

    void set(std::unique_ptr<const T>&& value) {

        current_version.store(Version {std::move(value)});

    }

_ZN12MultiVersionIN5doris14RuntimeProfileEE3setEOSt10unique_ptrIKS1_St14default_deleteIS4_EE

Line

Count

Source

61

2.69k

    void set(std::unique_ptr<const T>&& value) {

62

2.69k

        current_version.store(Version {std::move(value)});

63

2.69k

    }

Unexecuted instantiation: _ZN12MultiVersionIN5doris11SymbolIndexEE3setEOSt10unique_ptrIKS1_St14default_deleteIS4_EE

private:

#ifdef USE_LIBCPP

    doris::atomic_shared_ptr<const T> current_version;

#else

    std::atomic<Version> current_version;

#endif

};