struct keep_apart{    alignas(std::hardware_destructive_interference_size)std::atomic<int> cat;    alignas(std::hardware_destructive_interference_size)std::atomic<int> dog;};

struct together{std::atomic<int> dog;int puppy;}; struct kennel{// Other data members...     alignas(sizeof(together)) together pack; // Other data members...}; static_assert(sizeof(together)<= std::hardware_constructive_interference_size);

#include <atomic>#include <chrono>#include <cstddef>#include <iomanip>#include <iostream>#include <mutex>#include <new>#include <thread> #ifdef __cpp_lib_hardware_interference_sizeusing std::hardware_constructive_interference_size;using std::hardware_destructive_interference_size;#else// 64 bytes on x86-64 │ L1_CACHE_BYTES │ L1_CACHE_SHIFT │ __cacheline_aligned │ ...constexprstd::size_t hardware_constructive_interference_size=64;constexprstd::size_t hardware_destructive_interference_size=64;#endif std::mutex cout_mutex; constexprint max_write_iterations{10'000'000};// the benchmark time tuning struct alignas(hardware_constructive_interference_size)OneCacheLiner// occupies one cache line{std::atomic_uint64_t x{};std::atomic_uint64_t y{};}oneCacheLiner; struct TwoCacheLiner// occupies two cache lines{    alignas(hardware_destructive_interference_size)std::atomic_uint64_t x{};    alignas(hardware_destructive_interference_size)std::atomic_uint64_t y{};}twoCacheLiner; inlineauto now()noexcept{returnstd::chrono::high_resolution_clock::now();} template<bool xy>void oneCacheLinerThread(){constauto start{now()}; for(uint64_t count{}; count!= max_write_iterations;++count)ifconstexpr(xy)            oneCacheLiner.x.fetch_add(1,std::memory_order_relaxed);else            oneCacheLiner.y.fetch_add(1,std::memory_order_relaxed); conststd::chrono::duration<double,std::milli> elapsed{now()- start};std::lock_guard lk{cout_mutex};std::cout<<"oneCacheLinerThread() spent "<< elapsed.count()<<" ms\n";ifconstexpr(xy)        oneCacheLiner.x= elapsed.count();else        oneCacheLiner.y= elapsed.count();} template<bool xy>void twoCacheLinerThread(){constauto start{now()}; for(uint64_t count{}; count!= max_write_iterations;++count)ifconstexpr(xy)            twoCacheLiner.x.fetch_add(1,std::memory_order_relaxed);else            twoCacheLiner.y.fetch_add(1,std::memory_order_relaxed); conststd::chrono::duration<double,std::milli> elapsed{now()- start};std::lock_guard lk{cout_mutex};std::cout<<"twoCacheLinerThread() spent "<< elapsed.count()<<" ms\n";ifconstexpr(xy)        twoCacheLiner.x= elapsed.count();else        twoCacheLiner.y= elapsed.count();} int main(){std::cout<<"__cpp_lib_hardware_interference_size "#   ifdef __cpp_lib_hardware_interference_size"= "<< __cpp_lib_hardware_interference_size<<'\n';#   else"is not defined, use "<< hardware_destructive_interference_size<<" as fallback\n";#   endif std::cout<<"hardware_destructive_interference_size == "<< hardware_destructive_interference_size<<'\n'<<"hardware_constructive_interference_size == "<< hardware_constructive_interference_size<<"\n\n"<<std::fixed<<std::setprecision(2)<<"sizeof( OneCacheLiner ) == "<< sizeof(OneCacheLiner)<<'\n'<<"sizeof( TwoCacheLiner ) == "<< sizeof(TwoCacheLiner)<<"\n\n"; constexprint max_runs{4}; int oneCacheLiner_average{0};for(auto i{0}; i!= max_runs;++i){std::thread th1{oneCacheLinerThread<0>};std::thread th2{oneCacheLinerThread<1>};        th1.join();        th2.join();        oneCacheLiner_average+= oneCacheLiner.x+ oneCacheLiner.y;}std::cout<<"Average T1 time: "<<(oneCacheLiner_average/ max_runs/2)<<" ms\n\n"; int twoCacheLiner_average{0};for(auto i{0}; i!= max_runs;++i){std::thread th1{twoCacheLinerThread<0>};std::thread th2{twoCacheLinerThread<1>};        th1.join();        th2.join();        twoCacheLiner_average+= twoCacheLiner.x+ twoCacheLiner.y;}std::cout<<"Average T2 time: "<<(twoCacheLiner_average/ max_runs/2)<<" ms\n\n"<<"Ratio T1/T2:~ "<<1.0* oneCacheLiner_average/ twoCacheLiner_average<<'\n';}

__cpp_lib_hardware_interference_size = 201703hardware_destructive_interference_size == 64hardware_constructive_interference_size == 64 sizeof( OneCacheLiner ) == 64sizeof( TwoCacheLiner ) == 128 oneCacheLinerThread() spent 517.83 msoneCacheLinerThread() spent 533.43 msoneCacheLinerThread() spent 527.36 msoneCacheLinerThread() spent 555.69 msoneCacheLinerThread() spent 574.74 msoneCacheLinerThread() spent 591.66 msoneCacheLinerThread() spent 555.63 msoneCacheLinerThread() spent 555.76 msAverage T1 time: 550 ms twoCacheLinerThread() spent 89.79 mstwoCacheLinerThread() spent 89.94 mstwoCacheLinerThread() spent 89.46 mstwoCacheLinerThread() spent 90.28 mstwoCacheLinerThread() spent 89.73 mstwoCacheLinerThread() spent 91.11 mstwoCacheLinerThread() spent 89.17 mstwoCacheLinerThread() spent 90.09 msAverage T2 time: 89 ms Ratio T1/T2:~ 6.16