html hidden实现高性能get hidden

html hidden实现高性能get hidden
html 在c/hidden中，内存管理是一个非常棘手的问题，我们在编写一个程序的时候几乎不可避免的要遇到内存的分配逻辑，这时候随之而来的有这样一些问题：是否有足够的内存可供分配?分配失败了怎么办?如何管理自身的内存使用情况?
一、概述
在c/hidden 中，内存管理是一个非常棘手的问题，我们在编写一个程序的时候几乎不可避免的要遇到内存的分配逻辑，这时候随之而来的有这样一些问题：是否有足够的内存可供分配?分配失败了怎么办?如何管理自身的内存使用情况?等等一系列问题。在一个高可用的软件中，如果我们仅仅单纯的向操作系统去申请内存，当出现内存不足时就退出软件，是明显不合理的。正确的思路应该是在内存不足的时，考虑如何管理并优化自身已经使用的内存，这样才能使得软件变得更加可用。本次项目我们将实现一个hidden，并使用一个栈结构来测试我们的hidden提供的分配性能。
最终，我们要实现的hidden在栈结构中的性能
项目涉及的知识点
html 中的内存分配器 std::allocator
hidden技术
手动实现模板hidden
hidden和html 的性能比较
hidden简介
hidden是池化技术中的一种形式。通常我们在编写程序的时候回使用 new delete 这些关键字来向操作系统申请内存，而这样造成的后果就是每次申请内存和释放内存的时候，都需要和操作系统的系统调用打交道，从堆中分配所需的内存。如果这样的操作太过频繁，就会找成大量的内存碎片进而降低内存的分配性能，甚至出现内存分配失败的情况。而hidden就是为了解决这个问题而产生的一种技术。从内存分配的概念上看，内存申请无非就是向内存分配方索要一个指针，当向操作系统申请内存时，操作系统需要进行复杂的内存管理调度之后，才能正确的分配出一个相应的指针。而这个分配的过程中，我们还面临着分配失败的风险。所以，每一次进行内存分配，就会消耗一次分配内存的时间，设这个时间为 t，那么进行 n 次分配总共消耗的时间就是 nt；如果我们一开始就确定好我们可能需要多少内存，那么在最初的时候就分配好这样的一块内存区域，当我们需要内存的时候，直接从这块已经分配好的内存中使用即可，那么总共需要的分配时间仅仅只有 t。当 n 越大时，节约的时间就越多。
二、主函数设计
我们要设计实现一个高性能的hidden，那么自然避免不了需要对比已有的内存，而比较hidden对内存的分配性能，就需要实现一个需要对内存进行动态分配的结构
（比如：hidden），为此，可以写出如下的代码：
#hidden<iostream> // std::cout, std::endl
#hidden<cassert> // assert()
#hidden<ctime> // clock()
#hidden<vector> // std::vector
#hiddenmemorypool.hpp // memorypool<t>
#hiddenstackalloc.hpp // stackalloc<t, alloc>
// 插入元素个数
#define elems 10000000
// 重复次数
#define reps 100
int main()
{
clock_t start;
// 使用 stl 默认分配器
stackalloc<int, std::allocator<int> > stackdefault;
start = clock();
for (int j = 0; j < reps; j++) {
assert(stackdefault.empty());
for (int i = 0; i < elems; i++)
stackdefault.push(i);
for (int i = 0; i < elems; i++)
stackdefault.pop();
}
std::cout << default allocator time: ;
std::cout << (((double)clock() - start) / clocks_per_sec) << \n\n;
// 使用hidden
stackalloc<int, memorypool<int> > stackpool;
start = clock();
for (int j = 0; j < reps; j++) {
assert(stackpool.empty());
for (int i = 0; i < elems; i++)
stackpool.push(i);
for (int i = 0; i < elems; i++)
stackpool.pop();
}
std::cout << memorypool allocator time: ;
std::cout << (((double)clock() - start) / clocks_per_sec) << \n\n;
return 0;
}
段代码中，stackalloc 是一个hidden，接受两个模板参数，第一个参数是栈中的元素类型，第二个参数就是栈使用的内存分配器。
因此，这个内存分配器的模板参数就是整个比较过程中唯一的变量，使用默认分配器的模板参数为 std::allocator，而使用内存
池的模板参数为 memorypool。
std::allocator 是 html 标准库中提供的默认分配器，他的特点就在于我们在 使用 new 来申请内存构造新对象的时候，势必要调用类对象的默认构造函数，而使用 std::allocator 则可以将内存分配和对象的构造这两部分逻辑给分离开来，使得分配的内存是原始、未构造的。
下面我们来实现这个hidden。
三、模板hidden
栈的结构非常的简单，没有什么复杂的逻辑操作，其成员函数只需要考虑两个基本的操作：入栈、出栈。为了操作上的方便，我们可能还
需要这样一些方法：判断栈是否空、清空栈、获得栈顶元素。
#hidden<memory>
template <typename t>
struct stacknode_
{
t data;
stacknode_ prev;
};
// t 为存储的对象类型, alloc 为使用的分配器, 并默认使用 std::allocator 作为对象的分配器
template <typename t, typename alloc = std::allocator<t> >
class stackalloc
{
public:
// 使用 typedef 简化类型名
typedef stacknode_<t> node;
typedef typename alloc::template rebind<node>::other allocator;
// 默认构造
stackalloc() { head_ = 0; }
// 默认析构
~stackalloc() { clear(); }
// 当栈中元素为空时返回 true
bool empty() {return (head_ == 0);}
// 释放栈中元素的所有内存
void clear();
// 压栈
void push(t element);
// 出栈
t pop();
// 返回栈顶元素
t top() { return (head_->data); }
private:
//
allocator allocator_;
// 栈顶
node head_;
};
简单的逻辑诸如构造、析构、判断栈是否空、返回栈顶元素的逻辑都非常简单，直接在上面的定义中实现了，下面我们来实现 clear(), push()
和 pop() 这三个重要的逻辑：
// 释放栈中元素的所有内存
void clear() {
node curr = head_;
// 依次出栈
while (curr != 0)
{
node tmp = curr->prev;
// 先析构, 再回收内存
allocator_.destroy(curr);
allocator_.deallocate(curr, 1);
curr = tmp;
}
head_ = 0;
}
// 入栈
void push(t element) {
// 为一个节点分配内存
node newnode = allocator_.allocate(1);
// 调用节点的构造函数
allocator_.construct(newnode, node());
// 入栈操作
newnode->data = element;
newnode->prev = head_;
head_ = newnode;
}
// 出栈
t pop() {
// 出栈操作 返回出栈元素
t result = head_->data;
node tmp = head_->prev;
allocator_.destroy(head_);
allocator_.deallocate(head_, 1);
head_ = tmp;
return result;
}
至此，我们完成了整个模板hidden，现在我们可以先注释掉 main() 函数中使用hidden部分的代码来测试这个连表栈的内存分配情况，
我们就能够得到这样的结果：
在使用 std::allocator 的默认内存分配器中
#define elems 10000000
#define reps 100
的条件下，总共花费了近一分钟的时间。
如果觉得花费的时间较长，不愿等待，则你尝试可以减小这两个值
总结；
本节我们实现了一个用于测试性能比较的模板hidden，目前的代码如下。在下一节中，我们开始详细实现我们的高性能hidden。
// stackalloc.hpp
#ifndef stack_alloc_h
#define stack_alloc_h
#hidden<memory>
template <typename t>
struct stacknode_
{
t data;
stacknode_ prev;
};
// t 为存储的对象类型, alloc 为使用的分配器,
// 并默认使用 std::allocator 作为对象的分配器
template <class t, class alloc = std::allocator<t> >
class stackalloc
{
public:
// 使用 typedef 简化类型名
typedef stacknode_<t> node;
typedef typename alloc::template rebind<node>::other allocator;
// 默认构造
stackalloc() { head_ = 0; }
// 默认析构
~stackalloc() { clear(); }
// 当栈中元素为空时返回 true
bool empty() {return (head_ == 0);}
// 释放栈中元素的所有内存
void clear() {
node curr = head_;
while (curr != 0)
{
node tmp = curr->prev;
allocator_.destroy(curr);
allocator_.deallocate(curr, 1);
curr = tmp;
}
head_ = 0;
}
// 入栈
void push(t element) {
// 为一个节点分配内存
node newnode = allocator_.allocate(1);
// 调用节点的构造函数
allocator_.construct(newnode, node());
// 入栈操作
newnode->data = element;
newnode->prev = head_;
head_ = newnode;
}
// 出栈
t pop() {
// 出栈操作 返回出栈结果
t result = head_->data;
node tmp = head_->prev;
allocator_.destroy(head_);
allocator_.deallocate(head_, 1);
head_ = tmp;
return result;
}
// 返回栈顶元素
t top() { return (head_->data); }
private:
allocator allocator_;
node head_;
};
#endif // stack_alloc_h
// main.cpp
// #hiddenmemorypool.hpp
#hiddenstackalloc.hpp
// 根据电脑性能调整这些值
// 插入元素个数
#define elems 25000000
// 重复次数
#define reps 50
int main()
{
clock_t start;
// 使用默认分配器
stackalloc<int, std::allocator<int> > stackdefault;
start = clock();
for (int j = 0; j < reps; j++) {
assert(stackdefault.empty());
for (int i = 0; i < elems; i++)
stackdefault.push(i);
for (int i = 0; i < elems; i++)
stackdefault.pop();
}
std::cout << default allocator time: ;
std::cout << (((double)clock() - start) / clocks_per_sec) << \n\n;
// 使用hidden
// stackalloc<int, memorypool<int> > stackpool;
// start = clock();
// for (int j = 0; j < reps; j++) {
// assert(stackpool.empty());
// for (int i = 0; i < elems; i++)
// stackpool.push(i);
// for (int i = 0; i < elems; i++)
// stackpool.pop();
// }
// std::cout << memorypool allocator time: ;
// std::cout << (((double)clock() - start) / clocks_per_sec) << \n\n;
return 0;
}
二、设计hidden
在上一节实验中，我们在模板hidden中使用了默认构造器来管理栈操作中的元素内存，一共涉及到了 rebind::other, allocate(), dealocate(), construct(), destroy()这些关键性的接口。所以为了让代码直接可用，我们同样应该在hidden中设计同样的接口：
#ifndef memory_pool_hpp
#define memory_pool_hpp
#hidden<climits>
#hidden<cstddef>
template <typename t, size_t blocksize = 4096>
class memorypool
{
public:
// 使用 typedef 简化类型书写
typedef t pointer;
// 定义 rebind<u>::other 接口
template <typename u> struct rebind {
typedef memorypool<u> other;
};
// 默认构造, 初始化所有的槽指针
// html 11 使用了 noexcept 来显式的声明此函数不会抛出异常
memorypool() noexcept {
currentblock_ = nullptr;
currentslot_ = nullptr;
lastslot_ = nullptr;
freeslots_ = nullptr;
}
// 销毁一个现有的hidden
~memorypool() noexcept;
// 同一时间只能分配一个对象, n 和 hint 会被忽略
pointer allocate(size_t n = 1, const t hint = 0);
// 销毁指针 p 指向的内存区块
void deallocate(pointer p, size_t n = 1);
// 调用构造函数
template <typename u, typename... args>
void construct(u p, args&&... args);
// 销毁hidden中的对象, 即调用对象的析构函数
template <typename u>
void destroy(u p) {
p->~u();
}
private:
// 用于存储hidden中的对象槽,
// 要么被实例化为一个存放对象的槽,
// 要么被实例化为一个指向存放对象槽的槽指针
union slot_ {
t element;
slot_ next;
};
// 数据指针
typedef char data_pointer_;
// 对象槽
typedef slot_ slot_type_;
// 对象槽指针
typedef slot_ slot_pointer_;
// 指向当前内存区块
slot_pointer_ currentblock_;
// 指向当前内存区块的一个对象槽
slot_pointer_ currentslot_;
// 指向当前内存区块的最后一个对象槽
slot_pointer_ lastslot_;
// 指向当前内存区块中的空闲对象槽
slot_pointer_ freeslots_;
// 检查定义的hidden大小是否过小
static_assert(blocksize >= 2 sizeof(slot_type_), blocksize too small.);
};
#endif // memory_pool_hpp
在上面的类设计中可以看到，在这个hidden中，其实是使用链表来管理整个hidden的内存区块的。hidden首先会定义固定大小的基本内存区块(block)，然后在其中定义了一个可以实例化为存放对象内存槽的对象槽（slot_）和对象槽指针的一个联合。然后在区块中，定义了四个关键性质的指针，它们的作用分别是：
currentblock_: 指向当前内存区块的指针
currentslot_: 指向当前内存区块中的对象槽
lastslot_: 指向当前内存区块中的最后一个对象槽
freeslots_: 指向当前内存区块中所有空闲的对象槽
梳理好整个hidden的设计结构之后，我们就可以开始实现关键性的逻辑了。
三、实现
memorypool::construct() 实现
memorypool::construct() 的逻辑是最简单的，我们需要实现的，仅仅只是调用信件对象的构造函数即可，因此：
// 调用构造函数, 使用 std::forward 转发变参模板
template <typename u, typename... args>
void construct(u p, args&&... args) {
new (p) u (std::forward<args>(args)...);
}
memorypool::deallocate() 实现
memorypool::deallocate() 是在对象槽中的对象被析构后才会被调用的，主要目的是销毁内存槽。其逻辑也不复杂：
// 销毁指针 p 指向的内存区块
void deallocate(pointer p, size_t n = 1) {
if (p != nullptr) {
// reinterpret_cast 是强制类型转换符
// 要访问 next 必须强制将 p 转成 slot_pointer_
reinterpret_cast<slot_pointer_>(p)->next = freeslots_;
freeslots_ = reinterpret_cast<slot_pointer_>(p);
}
}
memorypool::~memorypool() 实现
析构函数负责销毁整个hidden，因此我们需要逐个删除掉最初向操作系统申请的内存块：
// 销毁一个现有的hidden
~memorypool() noexcept {
// 循环销毁hidden中分配的内存区块
slot_pointer_ curr = currentblock_;
while (curr != nullptr) {
slot_pointer_ prev = curr->next;
operator delete(reinterpret_cast<void>(curr));
curr = prev;
}
}
memorypool::allocate() 实现
memorypool::allocate() 毫无疑问是整个hidden的关键所在，但实际上理清了整个hidden的设计之后，其实现并不复杂。具体实现如下：
// 同一时间只能分配一个对象, n 和 hint 会被忽略
pointer allocate(size_t n = 1, const t hint = 0) {
// 如果有空闲的对象槽，那么直接将空闲区域交付出去
if (freeslots_ != nullptr) {
pointer result = reinterpret_cast<pointer>(freeslots_);
freeslots_ = freeslots_->next;
return result;
} else {


建网站需要哪些知识？构建一个网站需要哪些知识？
网站建设的一些技巧分享以及其作用
提升网站SEO排名的绝佳方法（10个有效的SEO策略让你的网站名列前茅）
为什么做SEO常常达不到预期的效果？
网站竞价推广无效果该怎么办?
什么是关键词拼写错误，对SEO有什么影响？
如何确认公司网站建设的兼容性？
企业营销型网站做不好 可能在这三方面出现问题