C++_项目高并发内存池结项——性能瓶颈分析与基数树进行性能突破，打包静态库

最新推荐文章于 2023-03-17 22:40:37 发布
最新推荐文章于 2023-03-17 22:40:37 发布
阅读量1.7k 收藏 6
点赞数 3
分类专栏： # C++高并发内存池 文章标签： c++ 哈希算法 散列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dodamce/article/details/123544066
版权
本文分析了内存管理中PageCache的性能瓶颈，提出使用基数树替代哈希映射以优化内存分配和释放。基数树通过预分配空间避免了加锁操作，提高了多线程环境下的性能。在32位系统中采用二层基数树，而在64位系统中使用三层基数树。通过确保所需页号的空间已分配，基数树能提供高效的映射访问，且在释放内存时保持线程安全。
摘要由CSDN通过智能技术生成

现在项目已经可以正常运行，但相比malloc来讲，在申请次数较少时性能比较差

每轮申请10000次内存
在这里插入图片描述

每轮申请100次

在这里插入图片描述

文章目录

1. 性能分析

VS2022下性能分析
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
其次是：

在这里插入图片描述
根据上图可知，消耗最大的是释放空间时合并Span到PageCache时锁消耗时间比较多，其次是通过页号找到对应的Span的哈希映射，加锁耗时比较大。

2. 使用基数树进行优化分析

为了解决PageCache访问页号与Span*的映射加锁耗费太多的时间问题，引出了基数树这种映射方法。

基数树的定义

直接定址法的基数树：

一层基数树映射保存页号和Span*

template <int BITS>
class TCMalloc_PageMap1 {
private:
	static const int LENGTH = 1 << BITS;
	void** array_;
}

BITS是保存了记录所有页所需要的比特位

假设一页8K，32位平台
2 ^ 32 / 2 ^ 13= 2 ^ 19
所以需要19位可以表示所有的页
BITS=19

在这里插入图片描述
如图数组大小仅为2MB所以对于32位可以直接将映射数组开辟出来。

如果是64位机器，不能之一这种方式，因为要开辟的数组太大。这个时候需要高层映射（基数树）

二层基数树

在这里插入图片描述
拿到一个页号，因为页号最大到19位，前面13位都是0可以不用管
在这里插入图片描述
eg：
给一个页号，先分离出后19为[A]，通过[A]前5位来找在第一层位置，再通过后14位来找第二层数组的位置。

template <int BITS>
class TCMalloc_PageMap2 {
private:
	// Put 32 entries in the root and (2^BITS)/32 entries in each leaf.
	static const int ROOT_BITS = 5;
	static const int ROOT_LENGTH = 1 << ROOT_BITS;//第一层数组的大小
	static const int LEAF_BITS = BITS - ROOT_BITS;
	static const int LEAF_LENGTH = 1 << LEAF_BITS;//第二层数组的大小
	// Leaf node
	struct Leaf {
			void* values[LEAF_LENGTH];
	};
	Leaf* root_[ROOT_LENGTH];//第一层数组的每个数组元素是一个数组
}

同理三层模型与二层基数树类型，这里不在赘述。

三层基数树

64位采用为了减少开辟数组的大小，选用三层的基数树。需要访问那个位置，再开辟数组，可以避免开始就开辟特别大的数组

// Three-level radix tree
template <int BITS>
class TCMalloc_PageMap3 {
private:
 // How many bits should we consume at each interior level
 static const int INTERIOR_BITS = (BITS + 2) / 3; // Round-up
 static const int INTERIOR_LENGTH = 1 << INTERIOR_BITS;
 // How many bits should we consume at leaf level
 static const int LEAF_BITS = BITS - 2 * INTERIOR_BITS;
 static const int LEAF_LENGTH = 1 << LEAF_BITS;
 // Interior node
 struct Node {
 Node* ptrs[INTERIOR_LENGTH];
 };
 // Leaf node
 struct Leaf {
 void* values[LEAF_LENGTH];
 };
 Node* root_;                          // Root of radix tree

3. C++使用二层基数树优化

这里不讨论64位（需要三层基数树），只看32位使用二层基数树。将PageCache中需要使用页号和Span*的哈希映射全部转化为基数树的映射即可。

一二三层基数树C++实现

#pragma once

#include"Common.h"
#include"ObjectPool.h"

// Single-level array
template <int BITS>
class TCMalloc_PageMap1 {
private:
	static const int LENGTH = 1 << BITS;
	void** array_;
public:
	typedef uintptr_t Number;
	explicit TCMalloc_PageMap1() {
		size_t size = sizeof(void*) << BITS;
		size_t AlignSize = SizeClass::_RoundUp(size, 1 << PAGESIZE);
		array_ = (void**)SystemAlloc(AlignSize >> PAGESIZE);//计算页数
		memset(array_, 0, sizeof(void*) << BITS);
	}
	// Return the current value for KEY. Returns NULL if not yet set,
	// or if k is out of range.
	void* get(Number k) const {
		if ((k >> BITS) > 0) {
			return NULL;
		}
		return array_[k];
	}
	// REQUIRES "k" is in range "[0,2^BITS-1]".
	// REQUIRES "k" has been ensured before.
	//
	// Sets the value 'v' for key 'k'.
	void set(Number k, void* v) {
		array_[k] = v;
	}
};
// Two-level radix tree
template <int BITS>
class TCMalloc_PageMap2 {
private:
	// Put 32 entries in the root and (2^BITS)/32 entries in each leaf.
	static const int ROOT_BITS = 5;
	static const int ROOT_LENGTH = 1 << ROOT_BITS;
	static const int LEAF_BITS = BITS - ROOT_BITS;
	static const int LEAF_LENGTH = 1 << LEAF_BITS;
	// Leaf node
	struct Leaf {
			void* values[LEAF_LENGTH];
	};
	Leaf* root_[ROOT_LENGTH];
	void* (*allocator_)(size_t);
public:
	typedef uintptr_t Number;
	explicit TCMalloc_PageMap2() {
		
		memset(root_, 0, sizeof(root_));
	}
	void* get(Number k) const {
		const Number i1 = k >> LEAF_BITS;
		const Number i2 = k & (LEAF_LENGTH - 1);
		if ((k >> BITS) > 0 || root_[i1] == NULL) {
			return NULL;
		}
		return root_[i1]->values[i2];
	}
	void set(Number k, void* v) {
		const Number i1 = k >> LEAF_BITS;
		const Number i2 = k & (LEAF_LENGTH - 1);
		ASSERT(i1 < ROOT_LENGTH);
		root_[i1]->values[i2] = v;
	}
	bool Ensure(Number start, size_t n) { //确保n页对应的每层数组的空间大小已经开辟完毕
		for (Number key = start; key <= start + n - 1;) {
			const Number i1 = key >> LEAF_BITS;
			// Check for overflow
			if (i1 >= ROOT_LENGTH)
				return false;
			// Make 2nd level node if necessary
			if (root_[i1] == NULL) {
				static ObjectPool<Leaf>LeafPool;//定长内存池
				Leaf* leaf = (Leaf*)LeafPool.New();
				memset(leaf, 0, sizeof(*leaf));
				root_[i1] = leaf;
			}
			// Advance key past whatever is covered by this leaf node
			key = ((key >> LEAF_BITS) + 1) << LEAF_BITS;
		}
		return true;
	}
	void PreallocateMoreMemory() {
		// Allocate enough to keep track of all possible pages
		Ensure(0, 1 << BITS);
	}
};

//#################################################################################三层基数树，适用64位，不讨论

// Three-level radix tree
template <int BITS>
class TCMalloc_PageMap3 {
private:
	// How many bits should we consume at each interior level
	static const int INTERIOR_BITS = (BITS + 2) / 3; // Round-up
	static const int INTERIOR_LENGTH = 1 << INTERIOR_BITS;
	// How many bits should we consume at leaf level
	static const int LEAF_BITS = BITS - 2 * INTERIOR_BITS;
	static const int LEAF_LENGTH = 1 << LEAF_BITS;
	// Interior node
	struct Node {
		Node* ptrs[INTERIOR_LENGTH];
	};
	// Leaf node
	struct Leaf {
		void* values[LEAF_LENGTH];
	};
	Node* root_;                           // Root of radix tree
	void* (*allocator_)(size_t);           // Memory allocator
	Node* NewNode() {
		Node* result = reinterpret_cast<Node*>((*allocator_)(sizeof(Node)));
		if (result != NULL) {
			memset(result, 0, sizeof(*result));
		}
		return result;
	}
public:
	typedef uintptr_t Number;
	explicit TCMalloc_PageMap3(void* (*allocator)(size_t)) {
		allocator_ = allocator;
		root_ = NewNode();
	}
	void* get(Number k) const {
		const Number i1 = k >> (LEAF_BITS + INTERIOR_BITS);
		const Number i2 = (k >> LEAF_BITS) & (INTERIOR_LENGTH - 1);
		const Number i3 = k & (LEAF_LENGTH - 1);
		if ((k >> BITS) > 0 ||
			root_->ptrs[i1] == NULL || root_->ptrs[i1]->ptrs[i2] == NULL) {
			return NULL;
		}
		return reinterpret_cast<Leaf*>(root_->ptrs[i1]->ptrs[i2])->values[i3];
	}
	void set(Number k, void* v) {
		ASSERT(k >> BITS == 0);
		const Number i1 = k >> (LEAF_BITS + INTERIOR_BITS);
		const Number i2 = (k >> LEAF_BITS) & (INTERIOR_LENGTH - 1);
		const Number i3 = k & (LEAF_LENGTH - 1);
	}
	bool Ensure(Number start, size_t n) {  //确保n页对应的每层数组的空间大小已经开辟完毕
		for (Number key = start; key <= start + n - 1;) {
			const Number i1 = key >> (LEAF_BITS + INTERIOR_BITS);
			const Number i2 = (key >> LEAF_BITS) & (INTERIOR_LENGTH - 1);
			// Check for overflow
			if (i1 >= INTERIOR_LENGTH || i2 >= INTERIOR_LENGTH)
				return false;
			// Make 2nd level node if necessary
			if (root_->ptrs[i1] == NULL) {
				Node* n = NewNode();
				if (n == NULL) return false;
				root_->ptrs[i1] = n;
			}
			// Make leaf node if necessary
			if (root_->ptrs[i1]->ptrs[i2] == NULL) {
				Leaf* leaf = reinterpret_cast<Leaf*>((*allocator_) (sizeof(Leaf)));
				if (leaf == NULL) return false;
				memset(leaf, 0, sizeof(*leaf));
				root_->ptrs[i1]->ptrs[i2] = reinterpret_cast<Node*>(leaf);
			}
			// Advance key past whatever is covered by this leaf node
			key = ((key >> LEAF_BITS) + 1) << LEAF_BITS;
		}
		return true;
	}
	void PreallocateMoreMemory() {
		//
	}
};

之前使用哈希表需要加锁的原因：

  • 线程在释放内存时，PageCache需要合并Span，修改映射。其他线程还可能插入映射或删除映射。这样会导致哈希结构底层的红黑树发生旋转等操作。所以为了保证线程安全，必须要加锁。

使用基数树映射不需要加锁的原因：

  • 基数树在需要建立映射的时候会提前根据你的页号创建出空间（无论是一层基数树还是三层基数树Ensure函数），开好后的空间无论是删除映射还是添加映射，这个空间不会像树结构那样发生旋转。结构不会改变
  • 修改基数树映射的时刻是，从系统申请的大空间切分挂到PageCache桶上时要添加映射。释放空间，小空间合并为大空间时需要添加映射
    在这里插入图片描述

在这里插入图片描述
而这两个位置在上层的时候就已经加锁了（同时一个是申请空间，一个是释放空间，根本不可能发生对同一块内存操作的问题），其他的操作都是访问映射，并不涉及修改操作，所以是线程安全的。在获取页号映射的函数中不需要加锁。效率提高。

注意：这里要使用一层基数树只能在32位下运行，64位需要三层基数树。
VS2022默认64位，如果你是VS2022下测试注意改为32位：
在这里插入图片描述

代码优化因为篇幅原因，放到链接下

Github
Gitee

优化后测试

在这里插入图片描述
Release
在这里插入图片描述

4.打包静态库

在这里插入图片描述

原tcmalloc项目链接

NUC_Dodamce
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++radix sort基数排序的实现算法之一(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-19 296
C++radix sort基数排序的实现算法C++radix sort基数排序的实现算法完整源码(定义，实现，main函数测试） C++radix sort基数排序的实现算法完整源码(定义，实现，main函数测试） #include <cmath> #include <cstdlib> #include <cstring> #include <iostream> void radixsort(int a[], int n) { int count[1
unodb:C ++中的自适应基数树
03-14
解散 介绍 Unodb是一种自适应的基数树实现，在我的操场上完成了各种C ++工具和构想。 我试图描述从中学到的一些知识。 要求 该代码使用SSE4.1内部函数（Nehalem和更高版本）。 这与仅需要SSE2的原始ART纸相反。 注意：由于这是我的个人项目，因此仅支持GCC 10和LLVM 11编译器。 如果您想尝试此操作并需要较低的受支持的编译器版本，请给我留言。 用法 所有声明都存在于unodb命名空间中，在以下内容unodb其省略。 当前唯一支持的密钥类型是std::uint64_t ，别名为key 。 但是，通过用所需的密钥类型实例化art_key类型并根据ART论文对art_key::make_binary_comparable进行特殊化，添加新的密钥类型应该相对容易。 值不透明地处理。 它们作为value_view非所有者对象value_view ，该对象是gsl::s
Radix-Tree:C + +模块使用字典为确定性有限自动机状态实现基数树
05-13
Radix Trie（有时称为Trie，数字树或前缀树）是树形的确定性自动机（DFA）。 这是一种serach trie，用于存储动态集或关联数组，其中键通常是字符串。 与二进制搜索不同，树中没有与特定关键字关联的节点。 相反，它的行为更像是状态机，您的当前值就是您在状态内所处的位置。 在确定有限的语言时，尝试遍历比遍历每种语言要有效得多。 例如，在英语中，有数百万个单词。 但是，只有26个字母。 每个单词都必须以字母开头。 因此，与其进行一百万次比较以查看单词是否与语言匹配，我们最多可以对第一个字母进行26次比较，然后对第二个字母进行比较，然后对第三个字母进行比较。 在此示例中，我们将字母存储在哈希中，因此有恒定的查找时间。 因此，将字母与语言匹配所需的最大时间仅进行n次迭代，其中n是字符串的长度。 入门 在src目录中运行make来创建您的二进制文件。 运行程序。 输入 查看ex
基数树的简单实现
lindorx的博客
12-07 2275
基数树是一种比较节省空间的树结构，下图展示了基数树的结构，其中key是树的构建方式，在这里，key是一个32位的整数，为了避免层数过深，所以使用两位代表子节点的索引，基数树就是依据二进制串来生成树结构。值value被储存在叶节点。 假设key=0X12345678，下图依据key来建立一棵树： 由与key是32位的，这里使用2个位用于建树，因此如果要查找一个值，最多只需要跳转16次就一定可...
RadixTree（基数树）
白杨的专栏
11-06 4486
1. 基数树概述 对于长整型数据的映射，如何解决Hash冲突和Hash表大小的设计是一个很头疼的问题。 radix树就是针对这种稀疏的长整型数据查找，能快速且节省空间地完成映射。借助于Radix树，我们可以实现对于长整型数据类型的路由。 利用radix树可以根据一个长整型（比如一个长ID）快速查找到其对应的对象指针。这比用hash映射来的简单，也更节省空间，使用hash映射hash函数难以设计，不恰
高并发内存池项目原始代码，开源项目
01-12
总结来说，这个开源项目提供了实现高并发内存池的框架，借鉴了tcmalloc的设计思想，利用基数树进行内存管理，并针对多线程环境进行了优化，旨在提高内存分配的效率和并发性能。对于想要深入理解内存管理、并发编程...
（牛客网C++课程）Linux 高并发Web服务器项目实战（带定时检测代码）
02-24
（牛客网C++课程）Linux 高并发Web服务器项目实战（带定时检测代码） 技术框架： 1. 线程池 + 非阻塞 socket + epoll + 事件处理的并发模型 2. 状态机解析HTTP请求 3. 心跳机制 4. 简易日志系统 主要内容： 1. ...
C++高效编程：内存与性能优化(pdf版）
09-11
C++高效编程：内存与性能优化(pdf版），深入C++经典好书！
基数树的简单实现-二
lindorx的博客
12-13 368
对之前的基数树做了修改，减少空间占用。 头文件： #pragma once #include<stdlib.h> #include<stdio.h> #define MEMPAGE 4096 #define INIT_POOL_SIZE (MEMPAGE*1) //初始内存池大小 #define RADIX_INSERT_VALUE_OCCUPY -1 //该节点...
radixtree基数树
06-12
基数树源码
复用tcmalloc源码中的基数树进行优化
qq_41420788的博客
10-15 543
基数树优化
基数树，赵元松+左儿子右兄弟版（白话文） .
Dwylkz
07-31 351
今日系我第一日种树兼第一日整一个类第一次做数据结构小扩展，真系好值得纪念｛^____^｝Y 首先介绍一下基数树，呢种树位于二叉查找树岛，生长系基数二叉树树林。基数树系一种有分类作用ge数据结构，我以呢种树为基础结构，以字母为关键字，加左统计域count实现字典查找。 总ge黎讲就系： 基础结构：基数树 增加域：count（统计包含【从某根到呢个...
基数树
fightinggg的博客
03-17 522
喜欢这篇文章吗？喜欢的话去看博主的置顶博客，即可依据分类找到此文章的原版得到更好的体验， 图片及代码显示的问题，笔者深感抱歉，想要更好的体验去原博文即可。 title: 基数树 mathjax: true date: 2020-03-16 16:19:30 categories: [myself_library,datastructure,tree,trie] tags: [myself_lib...
了解基数树
ych9527的博客
07-10 457
基数树 形态 性质 基数树其实就是多层哈希映射，解决整形与指针之间的映射关系 当某一层的位置有映射时，才选择多扩建一层哈希映射 可以根据需要开辟空间，而不是直接将空间开辟好 优点 提高访问的效率，不需要像哈希表一样进行内存 如果想要产生可以在一定 消耗 比如，有范围 1~200万范围的数据需要进行映射，如果用普通的一维数组进行哈希映射，那么在一开始，就需要开辟巨大的空间，如果采用基数树，则可以先开辟一段小的空间，当发生了冲突的时候，再选择开辟空间，进行二次映射 ...
算法10---二叉搜索树之基数树
weixin_34203832的博客
09-27 129
算法10---二叉搜索树之基数树 基数树是用来保存和排列字符串，关于字典序有两条规则： 算法导论中给出这样的图，我们结合图来看 1. 当字符串长度相同时，从左向右逐个字符比较，左边的比右边的小。如011 < 100。 2. 字符串长度不同时，长度长的在字典序中值更大。如100 < 1011。 因此，根结点 < 左子树结点 < 右子树...
C# 如何智能分析代码性能以及代码可唯护性
build2024
07-07 2102
visual Studio 2022 智能分析代码可维护及代码质量工具
Visual Studio 2022 发布了，我最爱的5大特性
热门推荐
Kinfey
11-08 1万+
编者语：架构这事就是经验，团队
面试问题之高并发内存池项目
最新发布
m0_72035301的博客
03-17 1426
高并发内存池的问答
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

NUC_Dodamce

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值