C++ attribute: optimize_for_synchronized(TM TS)

From cppreference.com

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros(C++20)
Language support library
Concepts library(C++20)
Diagnostics library
Memory management library
Metaprogramming library(C++11)
General utilities library
Containers library
Iterators library
Ranges library(C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library(C++17)
Concurrency support library(C++11)
Execution control library(C++26)
Technical specifications
Symbols index
External libraries

[edit]

C++ language

General topics

Preprocessor
Comments

Keywords
Escape sequences

Flow control

Conditional execution statements

if

switch

Iteration statements (loops)

`for`
range-`for`(C++11)

`while`
`do-while`

Jump statements

continue -break

goto -return

Functions

Function declaration

Lambda function expression

inline specifier

Dynamic exception specifications(until C++17*)

noexcept specifier(C++11)

Exceptions

`throw`-expression
`try` block


`catch` handler

Namespaces

Namespace declaration

Namespace aliases

Types

Fundamental types
Enumeration types
Function types

Class/struct types
Union types

Specifiers

`const`/`volatile`
`decltype`(C++11)
`auto`(C++11)

`constexpr`(C++11)
`consteval`(C++20)
`constinit`(C++20)

Storage duration specifiers

Initialization

Default-initialization
Value-initialization
Zero-initialization
Copy-initialization
Direct-initialization

Aggregate initialization
List-initialization(C++11)
Constant initialization
Reference initialization

Expressions

Value categories
Order of evaluation

Operators
Operator precedence

Alternative representations

Literals

Boolean -Integer -Floating-point

Character -String -nullptr(C++11)

User-defined(C++11)

Utilities

Attributes(C++11)

Types

typedef declaration

Type alias declaration(C++11)

Casts

Implicit conversions
`static_cast`
`const_cast`

Explicit conversions
`dynamic_cast`
`reinterpret_cast`

Memory allocation

new expression

delete expression

Classes

Class declaration
Constructors
`this` pointer

Access specifiers
`friend` specifier

Class-specific function properties

Virtual function
`override` specifier(C++11)
`final` specifier(C++11)

`explicit`(C++11)
`static`

Special member functions

Default constructor
Copy constructor
Move constructor(C++11)

Copy assignment
Move assignment(C++11)
Destructor

Templates

Class template
Function template

Template specialization
Parameter packs(C++11)

Miscellaneous

Overview
Declaration syntax
decl-specifier-seq
Declarator
Conflicting declarations
Specifiers
typedef
inline
virtual function specifier
explicit function specifier
friend
constexpr (C++11)
consteval (C++20)
constinit (C++20)
Storage class specifiers
Translation-unit-local(C++20)
class/struct
union
enum
decltype (C++11)
auto (C++11)
alignas (C++11)
constvolatile
Pack indexing specifier(C++26)
Elaborated type specifier
Attributes(C++11)

Declarators
Reference
Pointer
Array
Block declarations
Simple-declaration
→Structured binding declaration(C++17)
Alias declaration(C++11)
Namespace alias definition
using declaration
`using` directive
static_assert declaration(C++11)
asm declaration
Opaque enum declaration(C++11)
Other declarations
Namespace definition
Function declaration
Class template declaration
Function template declaration
Explicit template instantiation(C++11)
Explicit template specialization
Linkage specification
Attribute declaration(C++11)
Empty declaration

[edit]

Attributes

assume (C++23)
carries_dependency (C++11)(until C++26)
deprecated (C++14)
fallthrough (C++17)
indeterminate (C++26)
likely (C++20)
maybe_unused (C++17)
nodiscard (C++17)
noreturn (C++11)
no_unique_address (C++20)
optimize_for_synchronized (TM TS)
unlikely (C++20)

[edit]

Indicates that the function definition should be optimized for invocation from asynchronized statement.

[edit]Syntax


`[[optimize_for_synchronized]]`

[edit]Explanation

Applies to the name being declared in a function declaration, which must be the first declaration of the function.

Indicates that the function definition should be optimized for invocation from asynchronized statement. In particular, it avoids serializing synchronized blocks that make a call to a function that is transaction-safe for the majority of calls, but not for all calls.