#include <iostream>
#include <iostream>
#include <atomic>
#include <thread>

struct mre_example {
  struct data_t {
    alignas(std::hardware_destructive_interference_size) std::atomic<int64_t> atomical{0};
  };
  data_t* data_ptr;
  std::thread reader_thread;
  std::thread writer_thread;

mre_example() {
    data_ptr = static_cast<data_t *>(_aligned_malloc(sizeof(data_t), 1024));
    new (data_ptr) data_t;
    reader_thread = std::thread(&reader, data_ptr);
    writer_thread = std::thread(&writer, data_ptr);
  }

~mre_example() {
    reader_thread.join();
    writer_thread.join();
    _aligned_free(data_ptr);
  }

static void writer(data_t* data_ptr) {
    auto& data = *data_ptr;
    int64_t my_local = 0;
    while (true) {
      my_local += 100;
      if ((my_local % 100) != 0) {
        std::cout << "my_local is somehow broken: " << my_local << std::endl;
        my_local = 0;
      }
      data.atomical.store(my_local, std::memory_order_release);
    }
  }

static void reader(data_t* data_ptr) {
    auto& data = *data_ptr;
    while (true) {
      auto red_atomical = data.atomical.load(std::memory_order_acquire);
      if ((red_atomical % 100) != 0) {
        std::cout << "red_atomical is broken: " << red_atomical << std::endl;
        std::terminate();
      }
    }
  }
};

int main() {
  mre_example m1;
  mre_example m2;
  mre_example m3;

return 0;
}