This header is part of the atomic operations library.
Classes | |
(C++11) | atomic class template and specializations for bool, integral, and pointer types (class template) |
(C++11) | the lock-free boolean atomic type (class) |
(C++11) | defines memory ordering constraints for the given atomic operation (typedef) |
Typedefs | |
std::atomic_bool | std::atomic<bool> |
std::atomic_char | std::atomic<char> |
std::atomic_schar | std::atomic<signed char> |
std::atomic_uchar | std::atomic<unsigned char> |
std::atomic_short | std::atomic<short> |
std::atomic_ushort | std::atomic<unsigned short> |
std::atomic_int | std::atomic<int> |
std::atomic_uint | std::atomic<unsigned int> |
std::atomic_long | std::atomic<long> |
std::atomic_ulong | std::atomic<unsigned long> |
std::atomic_llong | std::atomic<long long> |
std::atomic_ullong | std::atomic<unsigned long long> |
std::atomic_char16_t | std::atomic<char16_t> |
std::atomic_char32_t | std::atomic<char32_t> |
std::atomic_wchar_t | std::atomic<wchar_t> |
std::atomic_int_least8_t | std::atomic<int_least8_t> |
std::atomic_uint_least8_t | std::atomic<uint_least8_t> |
std::atomic_int_least16_t | std::atomic<int_least16_t> |
std::atomic_uint_least16_t | std::atomic<uint_least16_t> |
std::atomic_int_least32_t | std::atomic<int_least32_t> |
std::atomic_uint_least32_t | std::atomic<uint_least32_t> |
std::atomic_int_least64_t | std::atomic<int_least64_t> |
std::atomic_uint_least64_t | std::atomic<uint_least64_t> |
std::atomic_int_fast8_t | std::atomic<int_fast8_t> |
std::atomic_uint_fast8_t | std::atomic<uint_fast8_t> |
std::atomic_int_fast16_t | std::atomic<int_fast16_t> |
std::atomic_uint_fast16_t | std::atomic<uint_fast16_t> |
std::atomic_int_fast32_t | std::atomic<int_fast32_t> |
std::atomic_uint_fast32_t | std::atomic<uint_fast32_t> |
std::atomic_int_fast64_t | std::atomic<int_fast64_t> |
std::atomic_uint_fast64_t | std::atomic<uint_fast64_t> |
std::atomic_intptr_t | std::atomic<intptr_t> |
std::atomic_uintptr_t | std::atomic<uintptr_t> |
std::atomic_size_t | std::atomic<size_t> |
std::atomic_ptrdiff_t | std::atomic<ptrdiff_t> |
std::atomic_intmax_t | std::atomic<intmax_t> |
std::atomic_uintmax_t | std::atomic<uintmax_t> |
Functions | |
(C++11) | checks if the atomic type's operations are lock-free (function template) |
(C++11)(C++11) | atomically replaces the value of the atomic object with a non-atomic argument (function template) |
(C++11)(C++11) | atomically obtains the value stored in an atomic object (function template) |
(C++11)(C++11) | atomically replaces the value of the atomic object with non-atomic argument and returns the old value of the atomic (function template) |
atomically compares the value of the atomic object with non-atomic argument and performs atomic exchange if equal or atomic load if not (function template) | |
(C++11)(C++11) | adds a non-atomic value to an atomic object and obtains the previous value of the atomic (function template) |
(C++11)(C++11) | subtracts a non-atomic value from an atomic object and obtains the previous value of the atomic (function template) |
(C++11)(C++11) | replaces the atomic object with the result of logical AND with a non-atomic argument and obtains the previous value of the atomic (function template) |
(C++11)(C++11) | replaces the atomic object with the result of logical OR with a non-atomic argument and obtains the previous value of the atomic (function template) |
(C++11)(C++11) | replaces the atomic object with the result of logical XOR with a non-atomic argument and obtains the previous value of the atomic (function template) |
(C++11)(C++11) | atomically sets the flag to true and returns its previous value (function) |
(C++11)(C++11) | atomically sets the value of the flag to false (function) |
(C++11) | non-atomic initialization of a default-constructed atomic object (function template) |
(C++11) | removes the specified object from the std::memory_order_consume dependency tree (function template) |
(C++11) | generic memory order-dependent fence synchronization primitive (function) |
(C++11) | fence between a thread and a signal handler executed in the same thread (function) |
Preprocessor macros | |
(C++11) | constant initialization of an atomic variable of static storage duration (function macro) |
(C++11) | initializes an std::atomic_flag to false (macro constant) |
Synopsis
namespace std { typedef enum memory_order { memory_order_relaxed, memory_order_consume, memory_order_acquire, memory_order_release, memory_order_acq_rel, memory_order_seq_cst } memory_order; template <class T> T kill_dependency(T y) noexcept; // lock-free property #define ATOMIC_BOOL_LOCK_FREE /*unspecified*/ #define ATOMIC_CHAR_LOCK_FREE /*unspecified*/ #define ATOMIC_CHAR16_T_LOCK_FREE /*unspecified*/ #define ATOMIC_CHAR32_T_LOCK_FREE /*unspecified*/ #define ATOMIC_WCHAR_T_LOCK_FREE /*unspecified*/ #define ATOMIC_SHORT_LOCK_FREE /*unspecified*/ #define ATOMIC_INT_LOCK_FREE /*unspecified*/ #define ATOMIC_LONG_LOCK_FREE /*unspecified*/ #define ATOMIC_LLONG_LOCK_FREE /*unspecified*/ #define ATOMIC_POINTER_LOCK_FREE /*unspecified*/ // generic atomic type template<class T> struct atomic; // specialization for integral types template<> struct atomic</*integral*/>; // specialization for pointers template<class T> struct atomic<T*>; // named typedefs typedef atomic<bool> atomic_bool; typedef atomic<char> atomic_char; typedef atomic<signed char> atomic_schar; typedef atomic<unsigned char> atomic_uchar; typedef atomic<short> atomic_short; typedef atomic<unsigned short> atomic_ushort; typedef atomic<int> atomic_int; typedef atomic<unsigned int> atomic_uint; typedef atomic<long> atomic_long; typedef atomic<unsigned long> atomic_ulong; typedef atomic<long long> atomic_llong; typedef atomic<unsigned long long> atomic_ullong; typedef atomic<char16_t> atomic_char16_t; typedef atomic<char32_t> atomic_char32_t; typedef atomic<wchar_t> atomic_wchar_t; typedef atomic<int_least8_t> atomic_int_least8_t; typedef atomic<uint_least8_t> atomic_uint_least8_t; typedef atomic<int_least16_t> atomic_int_least16_t; typedef atomic<uint_least16_t> atomic_uint_least16_t; typedef atomic<int_least32_t> atomic_int_least32_t; typedef atomic<uint_least32_t> atomic_uint_least32_t; typedef atomic<int_least64_t> atomic_int_least64_t; typedef atomic<uint_least64_t> atomic_uint_least64_t; typedef atomic<int_fast8_t> atomic_int_fast8_t; typedef atomic<uint_fast8_t> atomic_uint_fast8_t; typedef atomic<int_fast16_t> atomic_int_fast16_t; typedef atomic<uint_fast16_t> atomic_uint_fast16_t; typedef atomic<int_fast32_t> atomic_int_fast32_t; typedef atomic<uint_fast32_t> atomic_uint_fast32_t; typedef atomic<int_fast64_t> atomic_int_fast64_t; typedef atomic<uint_fast64_t> atomic_uint_fast64_t; typedef atomic<intptr_t> atomic_intptr_t; typedef atomic<uintptr_t> atomic_uintptr_t; typedef atomic<size_t> atomic_size_t; typedef atomic<ptrdiff_t> atomic_ptrdiff_t; typedef atomic<intmax_t> atomic_intmax_t; typedef atomic<uintmax_t> atomic_uintmax_t; // general operations on atomic types // /*atomic-type*/ is either atomic<T> or one of the typedefs // (if it's atomic<T>, then template<class T> is implied) bool atomic_is_lock_free(const volatile /*atomic-type*/ *) noexcept; bool atomic_is_lock_free(const /*atomic-type*/ *) noexcept; void atomic_init(volatile /*atomic-type*/ *, T) noexcept; void atomic_init(/*atomic-type*/ *, T) noexcept; void atomic_store(volatile /*atomic-type*/ *, T) noexcept; void atomic_store(/*atomic-type*/ *, T) noexcept; void atomic_store_explicit(volatile /*atomic-type*/ *, T, memory_order) noexcept; void atomic_store_explicit(/*atomic-type*/ *, T, memory_order) noexcept; T atomic_load(const volatile /*atomic-type*/ *) noexcept; T atomic_load(const /*atomic-type*/ *) noexcept; T atomic_load_explicit(const volatile /*atomic-type*/ *, memory_order) noexcept; T atomic_load_explicit(const /*atomic-type*/ *, memory_order) noexcept; T atomic_exchange(volatile /*atomic-type*/ *, T) noexcept; T atomic_exchange(/*atomic-type*/ *, T) noexcept; T atomic_exchange_explicit(volatile /*atomic-type*/ *, T, memory_order) noexcept; T atomic_exchange_explicit(/*atomic-type*/ *, T, memory_order) noexcept; bool atomic_compare_exchange_weak(volatile /*atomic-type*/ *, T*, T) noexcept; bool atomic_compare_exchange_weak(/*atomic-type*/ *, T*, T) noexcept; bool atomic_compare_exchange_strong(volatile /*atomic-type*/ *, T*, T) noexcept; bool atomic_compare_exchange_strong(/*atomic-type*/ *, T*, T) noexcept; bool atomic_compare_exchange_weak_explicit(volatile /*atomic-type*/ *, T*, T, memory_order, memory_order) noexcept; bool atomic_compare_exchange_weak_explicit(/*atomic-type*/ *, T*, T. memory_order, memory_order) noexcept; bool atomic_compare)exchange_strong_explicit(volatile /*atomic-type*/ *, T*, T, memory_order, memory_order) noexcept; bool atomic_compare_exchange_strong_explicit(/*atomic-type*/ *, T*, T, memory_order, memory_order) noexcept; // templated operations on atomic types (declared, but not defined) template <class T> T atomic_fetch_add(volatile atomic<T>*, T) noexcept; template <class T> T atomic_fetch_add(atomic<T>*, T) noexcept; template <class T> T atomic_fetch_add_explicit(volatile atomic<T>*, T, memory_order) noexcept; template <class T> T atomic_fetch_add_explicit(atomic<T>*, T, memory_order) noexcept; template <class T> T atomic_fetch_sub(volatile atomic<T>*, T) noexcept; template <class T> T atomic_fetch_sub(atomic<T>*, T) noexcept; template <class T> T atomic_fetch_sub_explicit(volatile atomic<T>*, T, memory_order) noexcept; template <class T> T atomic_fetch_sub_explicit(atomic<T>*, T, memory_order) noexcept; template <class T> T atomic_fetch_and(volatile atomic<T>*, T) noexcept; template <class T> T atomic_fetch_and(atomic<T>*, T) noexcept; template <class T> T atomic_fetch_and_explicit(volatile atomic<T>*, T, memory_order) noexcept; template <class T> T atomic_fetch_and_explicit(atomic<T>*, T, memory_order) noexcept; template <class T> T atomic_fetch_or(volatile atomic<T>*, T) noexcept; template <class T> T atomic_fetch_or(atomic<T>*, T) noexcept; template <class T> T atomic_fetch_or_explicit(volatile atomic<T>*, T, memory_order) noexcept; template <class T> T atomic_fetch_or_explicit(atomic<T>*, T, memory_order) noexcept; template <class T> T atomic_fetch_xor(volatile atomic<T>*, T) noexcept; template <class T> T atomic_fetch_xor(atomic<T>*, T) noexcept; template <class T> T atomic_fetch_xor_explicit(volatile atomic<T>*, T, memory_order) noexcept; template <class T> T atomic_fetch_xor_explicit(atomic<T>*, T, memory_order) noexcept; // arithmetic operations on atomic types // /*atomic-integral*/ is either atomic<T> or one of the typedefs // (if it's atomic<T>, then template<> is implied) /*integral*/ atomic_fetch_add(volatile /*atomic-integral*/ *, /*integral*/ ) noexcept; /*integral*/ atomic_fetch_add(/*atomic-integral*/ *, /*integral*/ ) noexcept; /*integral*/ atomic_fetch_add_explicit(volatile /*atomic-integral*/ *, /*integral*/, memory_order) noexcept; /*integral*/ atomic_fetch_add_explicit(/*atomic-integral*/ *, /*integral*/, memory_order) noexcept; /*integral*/ atomic_fetch_sub(volatile /*atomic-integral*/ *, /*integral*/ ) noexcept; /*integral*/ atomic_fetch_sub(/*atomic-integral*/ *, /*integral*/ ) noexcept; /*integral*/ atomic_fetch_sub_explicit(volatile /*atomic-integral*/ *, /*integral*/ , memory_order) noexcept; /*integral*/ atomic_fetch_sub_explicit(/*atomic-integral*/ *, /*integral*/ , memory_order) noexcept; /*integral*/ atomic_fetch_and(volatile /*atomic-integral*/ *, /*integral*/ ) noexcept; /*integral*/ atomic_fetch_and(/*atomic-integral*/ *, /*integral*/ ) noexcept; /*integral*/ atomic_fetch_and_explicit(volatile /*atomic-integral*/ *, /*integral*/ , memory_order) noexcept; /*integral*/ atomic_fetch_and_explicit(/*atomic-integral*/ *, /*integral*/ , memory_order) noexcept; /*integral*/ atomic_fetch_or(volatile /*atomic-integral*/ *, /*integral*/ ) noexcept; /*integral*/ atomic_fetch_or(/*atomic-integral*/ *, /*integral*/ ) noexcept; /*integral*/ atomic_fetch_or_explicit(volatile /*atomic-integral*/ *, /*integral*/ , memory_order) noexcept; /*integral*/ atomic_fetch_or_explicit(/*atomic-integral*/ *, /*integral*/ , memory_order) noexcept; /*integral*/ atomic_fetch_xor(volatile /*atomic-integral*/ *, /*integral*/ ) noexcept; /*integral*/ atomic_fetch_xor(/*atomic-integral*/ *, /*integral*/ ) noexcept; /*integral*/ atomic_fetch_xor_explicit(volatile /*atomic-integral*/ *, /*integral*/ , memory_order) noexcept; /*integral*/ atomic_fetch_xor_explicit(/*atomic-integral*/ *, /*integral*/ , memory_order) noexcept; // partial specializations for pointers template <class T> T* atomic_fetch_add(volatile atomic<T*>*, ptrdiff_t) noexcept; template <class T> T* atomic_fetch_add(atomic<T*>*, ptrdiff_t) noexcept; template <class T> T* atomic_fetch_add_explicit(volatile atomic<T*>*, ptrdiff_t, memory_order) noexcept; template <class T> T* atomic_fetch_add_explicit(atomic<T*>*, ptrdiff_t, memory_order) noexcept; template <class T> T* atomic_fetch_sub(volatile atomic<T*>*, ptrdiff_t) noexcept; template <class T> T* atomic_fetch_sub(atomic<T*>*, ptrdiff_t) noexcept; template <class T> T* atomic_fetch_sub_explicit(volatile atomic<T*>*, ptrdiff_t, memory_order) noexcept; template <class T> T* atomic_fetch_sub_explicit(atomic<T*>*, ptrdiff_t, memory_order) noexcept; // initialization #define ATOMIC_VAR_INIT(value) /*see description*/ // flag type and operations struct atomic_flag; bool atomic_flag_test_and_set(volatile atomic_flag*) noexcept; bool atomic_flag_test_and_set(atomic_flag*) noexcept; bool atomic_flag_test_and_set_explicit(volatile atomic_flag*, memory_order) noexcept; bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order) noexcept; void atomic_flag_clear(volatile atomic_flag*) noexcept; void atomic_flag_clear(atomic_flag*) noexcept; void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order) noexcept; void atomic_flag_clear_explicit(atomic_flag*, memory_order) noexcept; #define ATOMIC_FLAG_INIT /*see description*/ // fences extern "C" void atomic_thread_fence(memory_order) noexcept; extern "C" void atomic_signal_fence(memory_order) noexcept;
Class std::atomic
template <class T> struct atomic { bool is_lock_free() const volatile noexcept; bool is_lock_free() const noexcept; void store(T, memory_order = memory_order_seq_cst) volatile noexcept; void store(T, memory_order = memory_order_seq_cst) noexcept; T load(memory_order = memory_order_seq_cst) const volatile noexcept; T load(memory_order = memory_order_seq_cst) const noexcept; operator T() const volatile noexcept; operator T() const noexcept; T exchange(T, memory_order = memory_order_seq_cst) volatile noexcept; T exchange(T, memory_order = memory_order_seq_cst) noexcept; bool compare_exchange_weak(T&, T, memory_order, memory_order) volatile noexcept; bool compare_exchange_weak(T&, T, memory_order, memory_order) noexcept; bool compare_exchange_strong(T&, T, memory_order, memory_order) volatile noexcept; bool compare_exchange_strong(T&, T, memory_order, memory_order) noexcept; bool compare_exchange_weak(T&, T, memory_order = memory_order_seq_cst) volatile noexcept; bool compare_exchange_weak(T&, T, memory_order = memory_order_seq_cst) noexcept; bool compare_exchange_strong(T&, T, memory_order = memory_order_seq_cst) volatile noexcept; bool compare_exchange_strong(T&, T, memory_order = memory_order_seq_cst) noexcept; atomic() noexcept = default; constexpr atomic(T) noexcept; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; T operator=(T) volatile noexcept; T operator=(T) noexcept; };
Specialization of std::atomic
for integral types
template<> struct atomic</*integral*/> { bool is_lock_free() const volatile noexcept; bool is_lock_free() const noexcept; void store(/*integral*/, memory_order = memory_order_seq_cst) volatile noexcept; void store(/*integral*/, memory_order = memory_order_seq_cst) noexcept; /*integral*/ load(memory_order = memory_order_seq_cst) const volatile noexcept; /*integral*/ load(memory_order = memory_order_seq_cst) const noexcept; operator /*integral*/() const volatile noexcept; operator /*integral*/() const noexcept; /*integral*/ exchange(/*integral*/, memory_order = memory_order_seq_cst) volatile noexcept; /*integral*/ exchange(/*integral*/, memory_order = memory_order_seq_cst) noexcept; bool compare_exchange_weak(/*integral*/&, /*integral*/, memory_order, memory_order) volatile noexcept; bool compare_exchange_weak(/*integral*/&, /*integral*/, memory_order, memory_order) noexcept; bool compare_exchange_strong(/*integral*/&, /*integral*/, memory_order, memory_order) volatile noexcept; bool compare_exchange_strong(/*integral*/&, /*integral*/, memory_order, memory_order) noexcept; bool compare_exchange_weak(/*integral*/&, /*integral*/, memory_order = memory_order_seq_cst) volatile noexcept; bool compare_exchange_weak(/*integral*/&, /*integral*/, memory_order = memory_order_seq_cst) noexcept; bool compare_exchange_strong(/*integral*/&, /*integral*/, memory_order = memory_order_seq_cst) volatile noexcept; bool compare_exchange_strong(/*integral*/&, /*integral*/, memory_order = memory_order_seq_cst) noexcept; /*integral*/ fetch_add(/*integral*/, memory_order = memory_order_seq_cst) volatile noexcept; /*integral*/ fetch_add(/*integral*/, memory_order = memory_order_seq_cst) noexcept; /*integral*/ fetch_sub(/*integral*/, memory_order = memory_order_seq_cst) volatile noexcept; /*integral*/ fetch_sub(/*integral*/, memory_order = memory_order_seq_cst) noexcept; /*integral*/ fetch_and(/*integral*/, memory_order = memory_order_seq_cst) volatile noexcept; /*integral*/ fetch_and(/*integral*/, memory_order = memory_order_seq_cst) noexcept; /*integral*/ fetch_or(/*integral*/, memory_order = memory_order_seq_cst) volatile noexcept; /*integral*/ fetch_or(/*integral*/, memory_order = memory_order_seq_cst) noexcept; /*integral*/ fetch_xor(/*integral*/, memory_order = memory_order_seq_cst) volatile noexcept; /*integral*/ fetch_xor(/*integral*/, memory_order = memory_order_seq_cst) noexcept; atomic() noexcept = default; constexpr atomic(/*integral*/) noexcept; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; /*integral*/ operator=(/*integral*/) volatile noexcept; /*integral*/ operator=(/*integral*/) noexcept; /*integral*/ operator++(int) volatile noexcept; /*integral*/ operator++(int) noexcept; /*integral*/ operator--(int) volatile noexcept; /*integral*/ operator--(int) noexcept; /*integral*/ operator++() volatile noexcept; /*integral*/ operator++() noexcept; /*integral*/ operator--() volatile noexcept; /*integral*/ operator--() noexcept; /*integral*/ operator+=(/*integral*/) volatile noexcept; /*integral*/ operator+=(/*integral*/) noexcept; /*integral*/ operator-=(/*integral*/) volatile noexcept; /*integral*/ operator-=(/*integral*/) noexcept; /*integral*/ operator&=(/*integral*/) volatile noexcept; /*integral*/ operator&=(/*integral*/) noexcept; /*integral*/ operator|=(/*integral*/) volatile noexcept; /*integral*/ operator|=(/*integral*/) noexcept; /*integral*/ operator^=(/*integral*/) volatile noexcept; /*integral*/ operator^=(/*integral*/) noexcept; };
Specialization of std::atomic
for pointer types
template <class T> struct atomic<T*> { bool is_lock_free() const volatile noexcept; bool is_lock_free() const noexcept; void store(T*, memory_order = memory_order_seq_cst) volatile noexcept; void store(T*, memory_order = memory_order_seq_cst) noexcept; T* load(memory_order = memory_order_seq_cst) const volatile noexcept; T* load(memory_order = memory_order_seq_cst) const noexcept; operator T*() const volatile noexcept; operator T*() const noexcept; T* exchange(T*, memory_order = memory_order_seq_cst) volatile noexcept; T* exchange(T*, memory_order = memory_order_seq_cst) noexcept; bool compare_exchange_weak(T*&, T*, memory_order, memory_order) volatile noexcept; bool compare_exchange_weak(T*&, T*, memory_order, memory_order) noexcept; bool compare_exchange_strong(T*&, T*, memory_order, memory_order) volatile noexcept; bool compare_exchange_strong(T*&, T*, memory_order, memory_order) noexcept; bool compare_exchange_weak(T*&, T*, memory_order = memory_order_seq_cst) volatile noexcept; bool compare_exchange_weak(T*&, T*, memory_order = memory_order_seq_cst) noexcept; bool compare_exchange_strong(T*&, T*, memory_order = memory_order_seq_cst) volatile noexcept; bool compare_exchange_strong(T*&, T*, memory_order = memory_order_seq_cst) noexcept; T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile noexcept; T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) noexcept; T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile noexcept; T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) noexcept; atomic() noexcept = default; constexpr atomic(T*) noexcept; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; T* operator=(T*) volatile noexcept; T* operator=(T*) noexcept; T* operator++(int) volatile noexcept; T* operator++(int) noexcept; T* operator--(int) volatile noexcept; T* operator--(int) noexcept; T* operator++() volatile noexcept; T* operator++() noexcept; T* operator--() volatile noexcept; T* operator--() noexcept; T* operator+=(ptrdiff_t) volatile noexcept; T* operator+=(ptrdiff_t) noexcept; T* operator-=(ptrdiff_t) volatile noexcept; T* operator-=(ptrdiff_t) noexcept; };
Class std::atomic_flag
typedef struct atomic_flag { bool test_and_set(memory_order = memory_order_seq_cst) volatile noexcept; bool test_and_set(memory_order = memory_order_seq_cst) noexcept; void clear(memory_order = memory_order_seq_cst) volatile noexcept; void clear(memory_order = memory_order_seq_cst) noexcept; atomic_flag() noexcept = default; atomic_flag(const atomic_flag&) = delete; atomic_flag& operator=(const atomic_flag&) = delete; atomic_flag& operator=(const atomic_flag&) volatile = delete; } atomic_flag;
Please login to continue.