mem_space: Implement {io,main}_mem_space

Author: avdgrinten

include/arch/aarch64/mem_space.hpp

@@ -168,6 +168,34 @@ namespace _detail {
 	};
 }
 
+template<typename B>
+struct io_mem_ops {
+    static B load(const B *p) {
+        auto v = _detail::mem_ops<B>::load_relaxed(p);
+        asm volatile("dmb oshld" ::: "memory");
+        return v;
+    }
+
+    static void store(B *p, B v) {
+        asm volatile("dmb osh" ::: "memory");
+        _detail::mem_ops<B>::store_relaxed(p, v);
+    }
+};
+
+template<typename B>
+struct main_mem_ops {
+    static B load(const B *p) {
+        auto v = _detail::mem_ops<B>::load_relaxed(p);
+        asm volatile("dmb ishld" ::: "memory");
+        return v;
+    }
+
+    static void store(B *p, B v) {
+        asm volatile("dmb ish" ::: "memory");
+        _detail::mem_ops<B>::store_relaxed(p, v);
+    }
+};
+
 using _detail::mem_ops;
 
 } // namespace arch

include/arch/arm/mem_space.hpp

@@ -123,6 +123,14 @@ namespace _detail {
 	};
 }
 
+// TODO: This is not correct.
+template<typename B>
+using io_mem_ops = mem_ops<B>;
+
+// TODO: This is not correct.
+template<typename B>
+using main_mem_ops = mem_ops<B>;
+
 using _detail::mem_ops;
 
 } // namespace arch

include/arch/mem_space.hpp

@@ -14,52 +14,59 @@
 
 namespace arch {
 
-struct mem_space {
-	constexpr mem_space()
+namespace _details {
+
+template<template<typename> typename Ops>
+struct base_mem_space {
+	constexpr base_mem_space()
 	: _base(0) { }
 
-	constexpr mem_space(uintptr_t base)
+	constexpr base_mem_space(uintptr_t base)
 	: _base(base) { }
 
-	mem_space(void *base)
+	base_mem_space(void *base)
 	: _base(reinterpret_cast<uintptr_t>(base)) { }
 
-	mem_space subspace(ptrdiff_t offset) const {
-		return mem_space(reinterpret_cast<void *>(_base + offset));
+	base_mem_space subspace(ptrdiff_t offset) const {
+		return base_mem_space(reinterpret_cast<void *>(_base + offset));
 	}
 
 	template<typename RT>
 	void store(RT r, typename RT::rep_type value) const {
 		auto p = reinterpret_cast<typename RT::bits_type *>(_base + r.offset());
 		auto v = static_cast<typename RT::bits_type>(value);
-		mem_ops<typename RT::bits_type>::store(p, v);
+		Ops<typename RT::bits_type>::store(p, v);
 	}
 
 	template<typename RT>
 	typename RT::rep_type load(RT r) const {
 		auto p = reinterpret_cast<const typename RT::bits_type *>(_base + r.offset());
-		auto b = mem_ops<typename RT::bits_type>::load(p);
+		auto b = Ops<typename RT::bits_type>::load(p);
 		return static_cast<typename RT::rep_type>(b);
 	}
 
 	template<typename RT>
 	void store_relaxed(RT r, typename RT::rep_type value) const {
 		auto p = reinterpret_cast<typename RT::bits_type *>(_base + r.offset());
 		auto v = static_cast<typename RT::bits_type>(value);
-		mem_ops<typename RT::bits_type>::store_relaxed(p, v);
+		Ops<typename RT::bits_type>::store_relaxed(p, v);
 	}
 
 	template<typename RT>
 	typename RT::rep_type load_relaxed(RT r) const {
 		auto p = reinterpret_cast<const typename RT::bits_type *>(_base + r.offset());
-		auto b = mem_ops<typename RT::bits_type>::load_relaxed(p);
+		auto b = Ops<typename RT::bits_type>::load_relaxed(p);
 		return static_cast<typename RT::rep_type>(b);
 	}
 
 private:
 	uintptr_t _base;
 };
 
+} // namespace _details
+
+using mem_space = _details::base_mem_space<mem_ops>;
+
 static constexpr mem_space global_mem{};
 
 } // namespace arch

include/arch/riscv64/mem_space.hpp

@@ -91,6 +91,36 @@ namespace _detail {
 	};
 }
 
+template<typename B>
+struct io_mem_ops {
+    static B load(const B *p) {
+        asm volatile("fence r, i" ::: "memory");
+        auto v = _detail::mem_ops<B>::load_relaxed(p);
+        asm volatile("fence i, rw" ::: "memory");
+        return v;
+    }
+
+    static void store(B *p, B v) {
+        asm volatile("fence rw, o" ::: "memory");
+        _detail::mem_ops<B>::store_relaxed(p, v);
+        asm volatile("fence o, w" ::: "memory");
+    }
+};
+
+template<typename B>
+struct main_mem_ops {
+    static B load(const B *p) {
+        auto v = _detail::mem_ops<B>::load_relaxed(p);
+        asm volatile("fence r, rw" ::: "memory");
+        return v;
+    }
+
+    static void store(B *p, B v) {
+        asm volatile("fence rw, w" ::: "memory");
+        _detail::mem_ops<B>::store_relaxed(p, v);
+    }
+};
+
 using _detail::mem_ops;
 
 } // namespace arch

include/arch/x86/mem_space.hpp

@@ -93,6 +93,14 @@ namespace _detail {
 	};
 }
 
+// x86 has TSO which is strong enough to not require barriers anywhere.
+
+template<typename B>
+using io_mem_ops = _detail::mem_ops<B>;
+
+template<typename B>
+using main_mem_ops = _detail::mem_ops<B>;
+
 using _detail::mem_ops;
 
 } // namespace arch