From 9bede4eeed523f9707a989f1297279c006086e76 Mon Sep 17 00:00:00 2001 From: Fernando Sahmkow Date: Thu, 18 Jul 2019 18:15:53 -0400 Subject: VM_Manager: Align allocated memory to 256bytes This commit ensures that all backing memory allocated for the Guest CPU is aligned to 256 bytes. This due to how gpu memory works and the heavy constraints it has in the alignment of physical memory. --- src/common/alignment.h | 79 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 79 insertions(+) (limited to 'src/common') diff --git a/src/common/alignment.h b/src/common/alignment.h index 617b14d9b..b3fbdfe20 100644 --- a/src/common/alignment.h +++ b/src/common/alignment.h @@ -3,7 +3,10 @@ #pragma once #include +#include #include +#include +#include namespace Common { @@ -37,4 +40,80 @@ constexpr bool IsWordAligned(T value) { return (value & 0b11) == 0; } +template +class AlignmentAllocator { +public: + typedef T value_type; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + + typedef T* pointer; + typedef const T* const_pointer; + + typedef T& reference; + typedef const T& const_reference; + +public: + inline AlignmentAllocator() throw() {} + + template + inline AlignmentAllocator(const AlignmentAllocator&) throw() {} + + inline ~AlignmentAllocator() throw() {} + + inline pointer adress(reference r) { + return &r; + } + + inline const_pointer adress(const_reference r) const { + return &r; + } + +#if (defined _MSC_VER) + inline pointer allocate(size_type n) { + return (pointer)_aligned_malloc(n * sizeof(value_type), Align); + } + + inline void deallocate(pointer p, size_type) { + _aligned_free(p); + } +#else + inline pointer allocate(size_type n) { + return (pointer)std::aligned_alloc(Align, n * sizeof(value_type)); + } + + inline void deallocate(pointer p, size_type) { + std::free(p); + } +#endif + + inline void construct(pointer p, const value_type& wert) { + new (p) value_type(wert); + } + + inline void destroy(pointer p) { + p->~value_type(); + } + + inline size_type max_size() const throw() { + return size_type(-1) / sizeof(value_type); + } + + template + struct rebind { + typedef AlignmentAllocator other; + }; + + bool operator!=(const AlignmentAllocator& other) const { + return !(*this == other); + } + + // Returns true if and only if storage allocated from *this + // can be deallocated from other, and vice versa. + // Always returns true for stateless allocators. + bool operator==(const AlignmentAllocator& other) const { + return true; + } +}; + } // namespace Common -- cgit v1.2.3 From 0901c3375337c05ab41b435fb57b5bf7f1b2216e Mon Sep 17 00:00:00 2001 From: Fernando Sahmkow Date: Fri, 19 Jul 2019 11:11:42 -0400 Subject: Common: Correct alignment allocator to work on C++14 or higher. --- src/common/alignment.h | 56 +++++++++++++++++--------------------------------- 1 file changed, 19 insertions(+), 37 deletions(-) (limited to 'src/common') diff --git a/src/common/alignment.h b/src/common/alignment.h index b3fbdfe20..da2e61e10 100644 --- a/src/common/alignment.h +++ b/src/common/alignment.h @@ -3,10 +3,8 @@ #pragma once #include -#include +#include #include -#include -#include namespace Common { @@ -43,59 +41,43 @@ constexpr bool IsWordAligned(T value) { template class AlignmentAllocator { public: - typedef T value_type; - typedef std::size_t size_type; - typedef std::ptrdiff_t difference_type; + using value_type = T; + using size_type = std::size_t; + using difference_type = std::ptrdiff_t; - typedef T* pointer; - typedef const T* const_pointer; + using pointer = T*; + using const_pointer = const T*; - typedef T& reference; - typedef const T& const_reference; + using reference = T&; + using const_reference = const T&; public: - inline AlignmentAllocator() throw() {} - template - inline AlignmentAllocator(const AlignmentAllocator&) throw() {} - - inline ~AlignmentAllocator() throw() {} - - inline pointer adress(reference r) { - return &r; + pointer address(reference r) { + return std::addressof(r); } - inline const_pointer adress(const_reference r) const { - return &r; + const_pointer address(const_reference r) const { + return std::addressof(r); } -#if (defined _MSC_VER) - inline pointer allocate(size_type n) { - return (pointer)_aligned_malloc(n * sizeof(value_type), Align); - } - - inline void deallocate(pointer p, size_type) { - _aligned_free(p); - } -#else - inline pointer allocate(size_type n) { - return (pointer)std::aligned_alloc(Align, n * sizeof(value_type)); + pointer allocate(size_type n) { + return static_cast(::operator new(n, std::align_val_t{Align})); } - inline void deallocate(pointer p, size_type) { - std::free(p); + void deallocate(pointer p, size_type) { + ::operator delete(p, std::align_val_t{Align}); } -#endif - inline void construct(pointer p, const value_type& wert) { + void construct(pointer p, const value_type& wert) { new (p) value_type(wert); } - inline void destroy(pointer p) { + void destroy(pointer p) { p->~value_type(); } - inline size_type max_size() const throw() { + size_type max_size() const noexcept { return size_type(-1) / sizeof(value_type); } -- cgit v1.2.3 From 024b5fe91ad89820f64011ef2d37c8b956c94386 Mon Sep 17 00:00:00 2001 From: Fernando Sahmkow Date: Fri, 19 Jul 2019 11:14:47 -0400 Subject: Kernel: Address Feedback --- src/common/alignment.h | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) (limited to 'src/common') diff --git a/src/common/alignment.h b/src/common/alignment.h index da2e61e10..0ce218c60 100644 --- a/src/common/alignment.h +++ b/src/common/alignment.h @@ -52,7 +52,6 @@ public: using const_reference = const T&; public: - pointer address(reference r) { return std::addressof(r); } @@ -62,11 +61,11 @@ public: } pointer allocate(size_type n) { - return static_cast(::operator new(n, std::align_val_t{Align})); + return static_cast(::operator new (n, std::align_val_t{Align})); } void deallocate(pointer p, size_type) { - ::operator delete(p, std::align_val_t{Align}); + ::operator delete (p, std::align_val_t{Align}); } void construct(pointer p, const value_type& wert) { -- cgit v1.2.3 From febb88efc43ae171cc2880651b0665614c586504 Mon Sep 17 00:00:00 2001 From: Fernando Sahmkow Date: Fri, 19 Jul 2019 21:49:54 -0400 Subject: Common/Alignment: Add noexcept where required. --- src/common/alignment.h | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'src/common') diff --git a/src/common/alignment.h b/src/common/alignment.h index 0ce218c60..88d5d3a65 100644 --- a/src/common/alignment.h +++ b/src/common/alignment.h @@ -52,11 +52,11 @@ public: using const_reference = const T&; public: - pointer address(reference r) { + pointer address(reference r) noexcept { return std::addressof(r); } - const_pointer address(const_reference r) const { + const_pointer address(const_reference r) const noexcept { return std::addressof(r); } @@ -82,17 +82,17 @@ public: template struct rebind { - typedef AlignmentAllocator other; + using other = AlignmentAllocator; }; - bool operator!=(const AlignmentAllocator& other) const { + bool operator!=(const AlignmentAllocator& other) const noexcept { return !(*this == other); } // Returns true if and only if storage allocated from *this // can be deallocated from other, and vice versa. // Always returns true for stateless allocators. - bool operator==(const AlignmentAllocator& other) const { + bool operator==(const AlignmentAllocator& other) const noexcept { return true; } }; -- cgit v1.2.3