talezero/integration
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

More work on moving engine into dlmalloc heap

Browse Source
This commit is contained in:
jyelon
2022-02-25 19:57:23 -05:00
parent 08f6aa2092
commit ff932dba10
52 changed files with 351 additions and 484 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
luprex/core/wrap/mkstub.py
View File

@@ -16,7 +16,4 @@ with open(f"wrap-{dash}.hpp", "w") as f:
print("namespace eng {", file=f)
print("} // namespace eng", file=f)
print("", file=f)
print("namespace drv {", file=f)
print("} // namespace drv", file=f)
print("", file=f)
print(f"#endif // WRAP_{ubase}_HPP", file=f)

13
luprex/core/wrap/wrap-algorithm.hpp
View File

@@ -1,13 +0,0 @@
#ifndef WRAP_ALGORITHM_HPP
#define WRAP_ALGORITHM_HPP
#include "two-mallocs.hpp"
#include <algorithm>
namespace eng {
} // namespace eng
namespace drv {
} // namespace drv
#endif // WRAP_ALGORITHM_HPP

7
luprex/core/wrap/wrap-deque.hpp
View File

@@ -6,12 +6,7 @@
namespace eng {
template<class T>
using deque = std::deque<T, EngAllocator<T>>;
using deque = std::deque<T, eng::allocator<T>>;
} // namespace eng
namespace drv {
template<class T>
using deque = std::deque<T, DrvAllocator<T>>;
} // namespace drv
#endif // WRAP_DEQUE_HPP

15
luprex/core/wrap/wrap-map.hpp
View File

@@ -5,21 +5,8 @@
#include <map>
namespace eng {
template<class T>
using less = std::less<T>;
template<class A, class B>
using pair = std::pair<A, B>;
template<class K, class V, class C=std::less<K>>
using map = std::map<K, V, C, EngAllocator<std::pair<const K, V>>>;
using map = std::map<K, V, C, eng::allocator<std::pair<const K, V>>>;
} // namespace eng
namespace drv {
template<class T>
using less = std::less<T>;
template<class A, class B>
using pair = std::pair<A, B>;
template<class K, class V, class C=std::less<K>>
using map = std::map<K, V, C, DrvAllocator<std::pair<const K, V>>>;
} // namespace drv
#endif // WRAP_MAP_HPP

21
luprex/core/wrap/wrap-memory.hpp
View File

@@ -1,21 +0,0 @@
#ifndef WRAP_MEMORY_HPP
#define WRAP_MEMORY_HPP
#include "two-mallocs.hpp"
#include <memory>
namespace eng {
template<class T, class D=std::default_delete<T>>
using unique_ptr = std::unique_ptr<T, D>;
template<class T>
using shared_ptr = std::shared_ptr<T>;
} // namespace eng
namespace drv {
template<class T, class D=std::default_delete<T>>
using unique_ptr = std::unique_ptr<T, D>;
template<class T>
using shared_ptr = std::shared_ptr<T>;
} // namespace drv
#endif // WRAP_MEMORY_HPP

15
luprex/core/wrap/wrap-ostream.hpp
View File

@@ -1,15 +0,0 @@
#ifndef WRAP_OSTREAM_HPP
#define WRAP_OSTREAM_HPP
#include "two-mallocs.hpp"
#include <ostream>
namespace eng {
using ostream = std::ostream;
} // namespace eng
namespace drv {
using ostream = std::ostream;
} // namespace drv
#endif // WRAP_OSTREAM_HPP

11
luprex/core/wrap/wrap-set.hpp
View File

@@ -5,17 +5,8 @@
#include <set>
namespace eng {
template<class T>
using less = std::less<T>;
template<class K, class C=std::less<K>>
using set = std::set<K, C, EngAllocator<K>>;
using set = std::set<K, C, eng::allocator<K>>;
} // namespace eng
namespace drv {
template<class T>
using less = std::less<T>;
template<class K, class C=std::less<K>>
using set = std::set<K, C, DrvAllocator<K>>;
} // namespace drv
#endif // WRAP_SET_HPP

8
luprex/core/wrap/wrap-sstream.hpp
View File

@@ -6,14 +6,8 @@
namespace eng {
template<class C, class T=std::char_traits<C>>
using basic_ostringstream = std::basic_ostringstream<C, T, EngAllocator<C>>;
using basic_ostringstream = std::basic_ostringstream<C, T, eng::allocator<C>>;
using ostringstream = basic_ostringstream<char>;
} // namespace eng
namespace drv {
template<class C, class T=std::char_traits<C>>
using basic_ostringstream = std::basic_ostringstream<C, T, DrvAllocator<C>>;
using ostringstream = basic_ostringstream<char>;
} // namespace drv
#endif // WRAP_SSTREAM_HPP

8
luprex/core/wrap/wrap-string.hpp
View File

@@ -6,14 +6,8 @@
namespace eng {
template<class C, class T=std::char_traits<C>>
using basic_string = std::basic_string<C, T, EngAllocator<C>>;
using basic_string = std::basic_string<C, T, eng::allocator<C>>;
using string = basic_string<char>;
} // namespace eng
namespace drv {
template<class C, class T=std::char_traits<C>>
using basic_string = std::basic_string<C, T, DrvAllocator<C>>;
using string = basic_string<char>;
} // namespace drv
#endif // WRAP_STRING_HPP

19
luprex/core/wrap/wrap-unordered-map.hpp
View File

@@ -5,25 +5,8 @@
#include <unordered_map>
namespace eng {
template<class T>
using hash = std::hash<T>;
template<class T>
using equal_to = std::equal_to<T>;
template<class A, class B>
using pair = std::pair<A, B>;
template<class K, class V, class H=std::hash<K>, class E=std::equal_to<K>>
using unordered_map = std::unordered_map<K, V, H, E, EngAllocator<std::pair<const K, V>>>;
using unordered_map = std::unordered_map<K, V, H, E, eng::allocator<std::pair<const K, V>>>;
} // namespace eng
namespace drv {
template<class T>
using hash = std::hash<T>;
template<class T>
using equal_to = std::equal_to<T>;
template<class A, class B>
using pair = std::pair<A, B>;
template<class K, class V, class H=std::hash<K>, class E=std::equal_to<K>>
using unordered_map = std::unordered_map<K, V, H, E, DrvAllocator<std::pair<const K, V>>>;
} // namespace drv
#endif // WRAP_UNORDERED_MAP_HPP

15
luprex/core/wrap/wrap-unordered-set.hpp
View File

@@ -5,21 +5,8 @@
#include <unordered_set>
namespace eng {
template<class T>
using hash = std::hash<T>;
template<class T>
using equal_to = std::equal_to<T>;
template<class K, class H=std::hash<K>, class E=std::equal_to<K>>
using unordered_set = std::unordered_set<K, H, E, EngAllocator<K>>;
using unordered_set = std::unordered_set<K, H, E, eng::allocator<K>>;
} // namespace eng
namespace drv {
template<class T>
using hash = std::hash<T>;
template<class T>
using equal_to = std::equal_to<T>;
template<class K, class H=std::hash<K>, class E=std::equal_to<K>>
using unordered_set = std::unordered_set<K, H, E, DrvAllocator<K>>;
} // namespace drv
#endif // WRAP_UNORDERED_SET_HPP

21
luprex/core/wrap/wrap-utility.hpp
View File

@@ -1,21 +0,0 @@
#ifndef WRAP_UTILITY_HPP
#define WRAP_UTILITY_HPP
#include "two-mallocs.hpp"
#include <utility>
namespace eng {
template<class A, class B>
using pair = std::pair<A, B>;
template< class T1, class T2 >
constexpr std::pair<T1,T2> make_pair( T1&& t, T2&& u ) { return std::make_pair(t,u); }
} // namespace eng
namespace drv {
template<class A, class B>
using pair = std::pair<A, B>;
template< class T1, class T2 >
constexpr std::pair<T1,T2> make_pair( T1&& t, T2&& u ) { return std::make_pair(t,u); }
} // namespace drv
#endif // WRAP_UTILITY_HPP

7
luprex/core/wrap/wrap-vector.hpp
View File

@@ -6,12 +6,7 @@
namespace eng {
template<class T>
using vector = std::vector<T, EngAllocator<T>>;
using vector = std::vector<T, eng::allocator<T>>;
} // namespace eng
namespace drv {
template<class T>
using vector = std::vector<T, DrvAllocator<T>>;
} // namespace drv
#endif // WRAP_VECTOR_HPP