C++项目高并发内存池_PageCache设计 以及 项目申请内存联调

已于 2022-03-16 12:44:22 修改
阅读量624 收藏 2
点赞数 4
分类专栏： # C++高并发内存池 文章标签： c++ 链表 后端
于 2022-03-04 21:10:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dodamce/article/details/123258039
版权

紧跟CentralCache设计之后

文章目录

PageCache整体设计

PageCache结构也是哈希桶结构，每个桶的数据都是Span链表。

  • ThreadCache与CentralCache哈希桶的映射规律一致，PageCache哈希桶是根据页数分桶的。Span节点大小为一页的在哈希桶的第一个桶，Span大小为两页的在第二个桶依次类推
  • CentralCache中Span节点被切分成小内存块给ThreadCache使用，而PageCache中的Span不切块。CentralCache向Page Cache 申请内存时关注的是Span的大小，PageCache中Span内部空间不需要切块。需要Span的大小直接对应了PageCache哈希桶的桶位置

注意：
当CentralCache向PageCache申请内存时，PageCache先检查对应位置有没Span，如果没有则向更大页寻找一个Span，如果找到则分裂成两个。

比如：申请的是4页PageCache，4页PageCache后面没有挂Span，则向后面寻找更大的Span，假设在10页Page位置找到一个Span，则将10页PageCache Span分裂为一个4页Page Span和一个6页Page Span。
在这里插入图片描述
CentralCache向PageCache申请空间，CentralCache是被多线程访问的，PageCache也是被多线程访问，所以PageCache也需要加锁。
注意： PageCache不能再使用桶锁，因为PageCache还要负责CentralCache内存回收工作。PageCache申请一页Span时如果Span链表没有就向两页大小Span链表中拿，所以不能设计成桶锁。

流程
开始时Page Cache桶中没有挂任何Span，此时申请2页Span时先向大页的桶中找Span切分。当大页都找不到时会向系统申请一个128页的Span，将这块空间放到PageCache对应的桶上。将128页切分成2页和126页，2页SpanCentralCache,126页挂到126页对应的桶上。此后要是再申请3页的Span，会依次向下找直到找到126页的Span，将Span差分成小页给CentralCache。

同理当CentralCache收回空间时，PageCache会将空间再合并成页用哈希桶管理，
如果CentralCache Span中的use_cout==0代表这个Span已经没有线程在使用了，将这个Span归还到对应PageCache哈希桶对应的位置，PageCache通过页号查看前后相邻页是否空闲，是的话就合并成更大的页，解决内存碎片问题

这里先考虑申请空间的过程

PageCache也是只有一个，设计成单例模式

C++代码

1.公共资源头文件（Common.h）Windows下直接向堆申请空间VirtualAlloc

注意：PageCache如果调用new向堆申请空间会报非法访问空间的错误，这里只能用VirtualAlloc直接向堆申请空间

#pragma once

#include<iostream>
#include<vector>
#include<time.h>
#include<assert.h>
#include<thread>
#include<mutex>
#include<algorithm>

#include<windows.h>

// 直接去堆上按页申请空间
inline static void* SystemAlloc(size_t kpage)
{
#ifdef _WIN32
	void* ptr = VirtualAlloc(0, kpage << 13, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
#else
	// linux下brk mmap等
#endif

	if (ptr == nullptr)
		throw std::bad_alloc();

	return ptr;
}

using std::cout; using std::endl;

static const size_t MAX_BYTE = 126 * 1024;//如果线程申请超过126KB不能直接向ThreadCache申请空间

static const size_t NUMLIST = 208;//ThreadCache中哈希桶的个数

static const size_t NPAGE = 129;//PageCache中哈希桶的个数,0号桶空开从1号桶开始

static const size_t PAGESIZE = 13;//定义一页的大小为2^13（8K）

#ifdef _WIN64
typedef unsigned long long PAGE_ID;//64位下的页号
#elif _WIN32
typedef size_t PAGE_ID;
#else 
	//Linux
#endif // _WIN32


//获取自由链表下一个节点
static void*& NextObj(void* obj) {
	return *(void**)obj;
}

//管理切分好内存的自由链表
class FreeList {
public:
	FreeList() :_freeList(nullptr), MaxSize(1) {}
	void Push(void* obj) {
		//头插
		assert(obj);
		NextObj(obj) = _freeList;
		_freeList = obj;
	}

	void* Pop() {
		//头删
		assert(_freeList);
		void* obj = _freeList;
		_freeList = NextObj(obj);
		return obj;
	}

	void PushList(void* begin, void* end) {
		//头插链表
		NextObj(end) = _freeList;
		_freeList = begin;
	}

	bool Empty() { return _freeList == nullptr; }

	size_t& GetMaxSize() { return MaxSize; }
private:
	void* _freeList;
	size_t MaxSize;//记录freeList链表要向中心缓存层申请多少个内存节点
};

//计算ThreadCache中哈希桶的桶个数
class SizeClass {
public:
	static inline size_t RoundUp(size_t size) {
		if (size <= 128) return _RoundUp(size, 8);
		else if (size <= 1024) return _RoundUp(size, 16);
		else if (size <= 8 * 1024) return _RoundUp(size, 128);
		else if (size < 64 * 1024) return _RoundUp(size, 1024);
		else if (size < 256 * 1024) return _RoundUp(size, 8 * 1024);
		else{
			assert(false);
			return -1;
		}
	}
	//计算在哈希桶的那个位置
	static inline size_t Index(size_t size) {
		assert(size <= MAX_BYTE);
		static int Group[4] = { 16,56,56,56 };
		if (size <= 128) return _Index(size, 8);
		else if (size <= 1024) return _Index(size - 128, 16) + Group[0];
		else if (size <= 8 * 1024) return _Index(size - 1024, 128) + Group[1] + Group[0];
		else if (size < 64 * 1024) return _Index(size - 8 * 1024, 1024) + Group[2] + Group[1] + Group[0];
		else if (size < 256 * 1024) return _Index(size - 64 * 1024, 8 * 1024) + Group[3] + Group[2] + Group[1] + Group[0];
		else {
			assert(false);
			return -1;
		}
	}

	//ThreadCache一个Span中链表挂多少个空间节点
	static size_t ForMemory(size_t size) {
		assert(size > 0);
		size_t num = MAX_BYTE / size;
		if (num < 2) {
			num = 2;//如果对象很大，一次少给ThreadCache一些。
		}
		else if (num > 512) {//如果对象很小，一次多给ThreadCache一些
			num = 512;
		}
		return num;
	}

	//计算PageCache向系统申请页的数目
	static size_t NumForPage(size_t size) {
		size_t NumForMemory = ForMemory(size);//计算中心缓存层一个Span最多要多少节点

		size_t Byte = NumForMemory * size;//总共的字节数

		size_t NumPage = (Byte >> PAGESIZE);//计算申请几页
		if (NumPage == 0) {
			NumPage = 1;//至少给一页空间
		}
		return NumPage;
	}
private:
	static inline size_t _RoundUp(size_t size, size_t AlignNum) {
		size_t AligSize = size;
		if (size % AlignNum != 0) {
			AligSize = (size / AlignNum + 1) * AlignNum;
		}
		return AligSize;
	}
	static inline size_t _Index(size_t size, size_t AlignNum) {
		size_t Pos = 0;
		if (size % AlignNum == 0) {
			Pos = size / AlignNum - 1;
		}
		else {
			Pos = size / AlignNum;
		}
		return Pos;
	}
};

//管理以页为单位的大块空间结构
struct Span {
	PAGE_ID _PageID;//记录是第几页
	size_t _Num;//记录Span里面有多少页
	Span* _next;//双向链表
	Span* _prev;

	size_t use_count;//记录分配了多少个对象给ThreadCahce

	void* FreeList;//切好的小块内存空间

	Span() :_PageID(0), _Num(0), _next(nullptr), _prev(nullptr), use_count(0), FreeList(nullptr) {}
};

class SpanList {
private:
	Span* _head;
public:
	std::mutex _mtx;//桶锁
	SpanList() {//带头双向循环链表
		_head = new Span;
		_head->_next = _head;
		_head->_prev = _head;
	}

	void Insert(Span* pos, Span* NewSpan) {
		//pos位置前插入NewSpan
		assert(pos != nullptr && NewSpan != nullptr);
		Span* prev = pos->_prev;//前一个
		prev->_next = NewSpan;
		NewSpan->_prev = prev;
		NewSpan->_next = pos;
		pos->_prev = NewSpan;
	}

	Span* Pop() {
		Span* front = _head->_next;//带头双向循环链表
		Erase(_head->_next);
		return front;
	}

	void Erase(Span* pos) {//删除SpanList上的节点
		assert(pos != _head);
		Span* prev = pos->_prev;
		Span* next = pos->_next;
		prev->_next = next;
		next->_prev = prev;
	}

	Span* begin() { return _head->_next; }
	Span* end() { return _head; }

	bool Empty() { return _head->_next == _head; }
};

2.线程缓存层实现（ThreadCache.h）

#pragma once

#include"Common.h"
#include"CentralCache.h"

class ThreadCache {
private:
	FreeList _FreeList[NUMLIST];
public:
	//申请释放空间
	void* ApplySpace(size_t size) {
		assert(size <= MAX_BYTE);
		size_t AligSize = SizeClass::RoundUp(size);
		//计算桶位置
		size_t index = SizeClass::Index(AligSize);
		if (!_FreeList[index].Empty()) {
			return _FreeList[index].Pop();
		}
		else {
			//thread cache没有内存向central cache要空间
			return RequestFromCentralCache(index, AligSize);
		}
	}
	void ReleaseSpace(void* ptr, size_t size) {
		assert(size <= MAX_BYTE && ptr != nullptr);
		size_t index = SizeClass::Index(size);//找到第几个桶
		//将这个空间头插到自由链表上
		_FreeList[index].Push(ptr);
	}

	//向中心缓存申请空间
	void* RequestFromCentralCache(size_t index, size_t size) { 
		//慢开始调节算法
		size_t Num = min(SizeClass::ForMemory(size),_FreeList[index].GetMaxSize());//计算中心层给线程缓存多少个空间节点;
		if (Num == _FreeList[index].GetMaxSize()) {
			_FreeList[index].GetMaxSize() += 2;//慢增长,每次申请下次会多给ThreadCache空间
		}
		//依次递增SizeClass::ForMemory(size)是申请上限，一次申请数量不会比它还大
		void* begin = nullptr; void* end = nullptr;
		size_t actualNum = CentralCache::GetCentralCache()->GiveThreadCache(begin, end, Num, size);
		assert(actualNum >= 1);//至少会申请到一个空间节点。
		if (actualNum == 1) {//实际就获得了一个节点,直接将这个节点返回
			return begin;
		}
		else {
			//获得了多个节点，要把这些节点都插入到ThreadCache的哈希桶上
			_FreeList[index].PushList(NextObj(begin), end);//将链表的下一个节点插入桶中，头节点返回给ThreadCache
			return begin;
		}
	}
};

//每个线程都会拥有自己的ThreadCache
static __declspec(thread) ThreadCache* tls_threadcache = nullptr;//用static修饰只在当前文件可见

线程申请独立申请ThreadCache（ConcurrentAlloc.h）

#pragma once

#include"Common.h"
#include"ThreadCache.h"

//线程调用申请ThreadCache空间
static void* ConcurrentAlloc(size_t size) {
	//获取线程自己的ThreadCache
	if (tls_threadcache == nullptr) {
		tls_threadcache = new ThreadCache;
	}
	cout << std::this_thread::get_id()<<" "<<tls_threadcache<< endl;
	return tls_threadcache->ApplySpace(size);
}

static void ConcurrentFree(void* ptr, size_t size) {
	//释放时每个线程一定有tls_threadcache
	assert(tls_threadcache != nullptr);
	tls_threadcache->ReleaseSpace(ptr,size);
}

3.中心缓存层实现（CentralCache.h / CentralCache.cpp）

#pragma once

#include"Common.h"

//中心缓存只有一个，每个线程都可以看见，所以中心缓存类采用单例模式(饿汉模式)
class CentralCache {
private:
	SpanList _SpanList[NUMLIST];//与ThreadCache桶的大小相同
	CentralCache(const CentralCache&) = delete;
	static CentralCache _sInst;
public:
	CentralCache() {}
	static CentralCache* GetCentralCache() {
		return &_sInst;
	}

	//获取一个非空Span,需要向PageCache申请空间
	Span* GetSpan(SpanList& List, size_t size);

	size_t GiveThreadCache(void*& start, void*& end, size_t Num, size_t Size);
};

#include"CentralCache.h"
#include"PageCache.h"

CentralCache CentralCache::_sInst;//定义了一个对象

size_t CentralCache::GiveThreadCache(void*& start, void*& end, size_t Num, size_t size) {
	size_t index = SizeClass::Index(size);
	//要求num个内存节点，需要计Span中FreeList空节点个数
	_SpanList[index]._mtx.lock();//加锁

	Span* span = GetSpan(_SpanList[index], size);//解锁在这个函数中
	assert(span != nullptr && span->FreeList != nullptr);

	start = span->FreeList; end = start;
	//变量Num次，找Num个节点
	size_t actualNum = 1;//实际获得几个内存节点
	for (int i = 0; i < Num - 1; i++) {
		if (NextObj(end) == nullptr) break;//如果走到span中FreeList的空，说明span中内存不够Num个，这个时候有多少返回多少
		actualNum += 1;
		end = NextObj(end);
	}
	span->FreeList = NextObj(end);
	//为分出去的内存节点链表添加nullptr
	NextObj(end) = nullptr;
	span->use_count += actualNum;
	_SpanList[index]._mtx.unlock();
	return actualNum;
}

Span* CentralCache::GetSpan(SpanList& List, size_t size) {
	//在哈希桶对应位置Span链表中找是否有Span，没有就向PageCache申请空间

	//遍历桶的Span链表
	Span* it = List.begin();
	while (it != List.end()) {
		if (it->FreeList != nullptr) {
			return it;//这个Span有空间
		}
		else {
			//Span没有空间，继续找下一个链表Span
			it = it->_next;
		}
	}
	//先把CentralCache的桶锁解开，如果其他线程释放内存不会阻塞
	List._mtx.unlock();
	//没有空闲的Span只能找PageCache,需要加锁，PageCache只能由一个线程访问
	//size是单个对象的大小
	PageCache::GetInst()->_PageMtx.lock();
	Span* span=PageCache::GetInst()->NewSpan(SizeClass::NumForPage(size));
	PageCache::GetInst()->_PageMtx.unlock();

	//获得了一块大Span，这块Span这时被线程单独看到，不需要加锁（没有挂到桶上）
	//Span起始地址
	char* start = (char*)((span->_PageID) << PAGESIZE);
	size_t ByteSize = (span->_Num) << PAGESIZE;
	char* end = start + ByteSize;
	//把Span内部大块内存切成自由链表链接起来
	span->FreeList = start;
	start += size;//自由链表的头节点
	void* tail = span->FreeList;
	while (start < end) {
		NextObj(tail) = start;
		tail = NextObj(tail);
		start += size;
	}
	List._mtx.lock();
	List.Insert(List.begin(), span);//将Span挂到桶上，此时需要加桶锁
	return span;
}

4.页缓存实现过程（PageCache.h / PageCache.cpp）

#pragma once

#include"Common.h"

class PageCache {
private:
	SpanList _SpanList[NPAGE];
	static PageCache _sInst;

	PageCache() {}
public:
	std::mutex _PageMtx;

	PageCache(const PageCache&) = delete;

	static PageCache* GetInst() {
		return &_sInst;
	}

	//获取NumPage页的Span
	Span* NewSpan(size_t NumPage);
};

#include"PageCache.h"

PageCache PageCache::_sInst;

Span* PageCache::NewSpan(size_t NumPage) {//NumPage是页数
	assert(NumPage > 0 && NumPage < NPAGE);

	//看当前位置桶中是否有Span
	if (!_SpanList[NumPage].Empty()) {
		return _SpanList[NumPage].Pop();
	}
	//对应位置的桶是空，检查后面桶里有没有Span,将大Span切分成小Span
	for (size_t i = NumPage + 1; i < NPAGE; i++) {
		if (!_SpanList[i].Empty()) {//有一个桶存在，切分大Span成NumPage页Span和N-NumPage页的Span
			Span* NumPageSpan = new Span;
			Span* NSpan = _SpanList[i].Pop();
			//头切
			NumPageSpan->_PageID = NSpan->_PageID;
			NumPageSpan->_Num = NumPage;
			NSpan->_PageID += NumPage;
			NSpan->_Num -= NumPage;

			//将切下的Span挂到其他桶上
			_SpanList[NSpan->_Num].Insert(_SpanList[NSpan->_Num].begin(), NSpan);
			return NumPageSpan;
		}
	}
	//所有桶都没有Span,直接向堆中申请一大块空间，将这块空间挂到最后一个桶上
	Span* BigSpan = new Span;
	void* ptr = SystemAlloc(NPAGE - 1);
	BigSpan->_PageID = (PAGE_ID)ptr >> PAGESIZE;
	BigSpan->_Num = NPAGE - 1;
	_SpanList[BigSpan->_Num].Insert(_SpanList[BigSpan->_Num].begin(), BigSpan);
	//在调用自己向Central Cache发送空间
	return NewSpan(NumPage);
}

申请内存测试

#include"ConcurrentAlloc.h"

void TestConcurrentAlloc() {
	void* p1 = ConcurrentAlloc(6);
	void* p2 = ConcurrentAlloc(8);
	void* p3 = ConcurrentAlloc(1);
	void* p4 = ConcurrentAlloc(7);
	void* p5 = ConcurrentAlloc(18);

	cout << p1 << endl;
	cout << p2 << endl;
	cout << p3 << endl;
	cout << p4 << endl;
	cout << p5 << endl;
}
int main()
{
	TestConcurrentAlloc();
	return 0;
}

在这里插入图片描述

PageCache第二次申请128页空间测试

#include"ConcurrentAlloc.h"

void TestConcurrentAlloc() {
	void* p1 = ConcurrentAlloc(6);
	void* p2 = ConcurrentAlloc(8);
	void* p3 = ConcurrentAlloc(1);
	void* p4 = ConcurrentAlloc(7);
	void* p5 = ConcurrentAlloc(18);

	cout << p1 << endl;
	cout << p2 << endl;
	cout << p3 << endl;
	cout << p4 << endl;
	cout << p5 << endl;
}

void TestConcurrentAlloc2() {
	for (size_t i = 0; i < 1024; i++) {
		void* p1 = ConcurrentAlloc(6);
		cout << p1 << endl;
	}
	//第二次申请128页
	void* p2 = ConcurrentAlloc(6);
	cout << p2 << endl;
}

int main()
{
	//TestConcurrentAlloc();
	TestConcurrentAlloc2();
	return 0;
}

在这里插入图片描述
项目走到这里申请空间过程基本没有什么太大的问题了，接下来就是释放空间的过程

代码位置

Github
Gitee

NUC_Dodamce
关注
专栏目录
页高速缓存（page cache学习）
qq_22613757的博客
11-29 3248
最近要接触相关领域，学习一下共勉！！本文档使用linux为linux-4.4.4版本 磁盘高速缓存：是一种软件机制，它允许系统把通常存放在磁盘上的一些数据保留在RAM中，以便对那些数据的进一步访问不用再访问磁盘而能尽快得到满足。 一种对完整的数据页进行操作的磁盘高速缓存。 几乎所有的文件读和写操作都依赖于页高速缓存。只有在O_DIRECT标志被置位而进程打开文件的情况下才会出现例外：此时，IO数...
VirtualAlloc函数使用总结
热门推荐
04-16 2万+
如果我们的程序需要动态内存的话，则迟早会调用Win32函数VirtualAlloc。但是程序也可以不调用VirtualAlloc，而是直接调用Windows堆函数或者CRT堆函数。不过，知道VirtualAlloc如何工作，可以帮助我们更好地理解这些调用函数。     首先，必须知道保留(Reserved)内存和占用（Committed）内存的含义。当内存放保留时，一段连续虚拟地址空间被留出。例
在Linux中利用mmap模拟Windows的VirtualAlloc
手边笔记
06-18 5244
主要利用mmap中的匿名映射来实现。 VirtualAlloc的Linux实现如下： // 预留内存（相当于Windows-VirtualAlloc的MEM_RESERVE）。 // 用mmap映射一块private、anonymous、non-accessible的内存。 // 下面表示从0x10000000开始，预留1GB的内存 void* result1 = mma
C++项目——高并发内存池（4）--page cache
qq_68741368的博客
02-23 205
Span* CentralCache::GetOneSpan() 和 Span* PageCache::NewSpan( )的详细实现
C++项目 -- 高并发内存池（四）Page Cache
最新发布
kissland96166的博客
02-17 881
这样的设计方便以页为单位的分配和回收；
C++——高并发内存池（5）--ThreadCache、CentralCache、PageCache的释放内存代码及释放逻辑
qq_68741368的博客
02-23 291
详细介绍了thread cache 、central cache、 page cache的释放逻辑，阐明三者释放的逻辑关系。
高并发内存池详解（C/C++/Windows/Linux）
qq_42591783的博客
03-21 2135
待填
最最最简单的C++缓存实现
qq_21431111的专栏
12-03 1万+
最最最简单的C++缓存实现 在平常的后台开发中，通常中会用到缓存，一般会使用redis等内存数据库来实现，但是在很简单的程序中，其实没必要包含一些额外的依赖，通过C++的map即可实现。
C++系统编程之缓存
junnda的博客
03-28 2357
全文以SSD6 Exercise5为例。 首先明确任务目的，我们学习缓存原理的终极目的是利用其机制，来提高程序运行效率。 其中对编码最重要的一点是，充分利用时间空间局部性。 考虑这样一个循环，其实质是将一个图像逆时针旋转90度。 void rotate(int dim, pixel *src, pixel *dst) { int i, j; for(i=0; i < dim; i++) { for(j=0; j < dim; j++) { COPY(&dst[P
C++实现的高并发内存池
mz474920631的博客
06-08 3130
C/C++下内存管理是件很头疼的事，分配足够的内存、追踪内存的分配、在不需要的时候释放内存—这个任务很复杂。如果直接使用系统调用malloc/free、new/delete进行内存分配和释放，则会有以下弊端：内存池（memory pool)是代替直接调用malloc/free、new/delete进行内存管理的常用方法，当我们申请内存空间时，首先到我们的内存池中查找合适的内存块，而不是直接向操作系统申请，优势在于：现代很多的开发环境都是多核多线程，在申请内存的场景下，必然存在激烈的锁竞争问题。malloc本
Linux -- Pagecache 文件缓存特性
曦轩 技术茶话小屋
09-30 1万+
今天看@褚霸的博客，看到了几篇关于pagecache、slab的几篇好文章，转一下！ 原创文章，转载请注明： 转载自系统技术非业余研究 本文链接地址: Linux下谁在消耗我们的cache Linux下对文件的访问和设备的访问通常会被cache起来加快访问速度，这个是系统的默认行为。 而cache需要耗费我们的内存，虽然这个内存最后可以通过echo 3>/proc
Linux 内存中Page cache和buffer cache 的区别
haiross的专栏
09-23 7295
Page cache和buffer cache一直以来是两个比较容易混淆的概念，在网上也有很多人在争辩和猜想这两个cache到底有什么区别，讨论到最后也一直没有一个统一和正确的结论，在我工作的这一段时间，page cache和buffer cache的概念曾经困扰过我，但是仔细分析一下，这两个概念实际上非常的清晰。如果能够了解到这两个cache的本质，那么我们在分析io问题的时候可能会更加得心应手
Linux内核学习笔记（八）Page Cache与Page回写
胡LiuJia@BLOG
06-02 2万+
综述 Page cache是通过将磁盘中的数据缓存到内存中，从而减少磁盘I/O操作，从而提高性能。此外，还要确保在page cache中的数据更改时能够被同步到磁盘上，后者被称为page回写（page writeback）。一个inode对应一个page cache对象，一个page cache对象包含多个物理page。 对磁盘的数据进行缓存从而提高性能主要是基于两个因素：第一，磁盘访问的速度...
page cache简介
Cecilia3333的博客
12-31 8253
定义 中文名称：页高速缓冲存储器，简称页高缓。 单位：页。 大小：动态变化，因为操作系统会将所有未直接分配给应用程序的物理内存都用于页面缓存。 文件系统层级的缓存：page cache用于缓存文件的页数据，从磁盘中读取到的内容是存储在page cache里的。 结构 在 Linux 的实现中，文件 Cache 分为两个层面，一是 Page Cache，另一个是 Buf...
文件系统和裸块设备的page cache问题
去级得骨灰
04-28 944
原文地址：http://www.wowotech.net/filesystem/439.html 作者：阿克曼 注：本文代码基于linux-3.18.31，此版本中块缓存已经合入页缓存（两个缓存合并的意思是：这里）。 普通文件的address space 文件系统读取文件一般会使用do_generic_file_read()，mapping指向普通文件的address space。如果一个...
操作系统中的page cache机制
痞子龙3D编程
10-29 1万+
在现代计算机系统中，CPU，RAM，DISK的速度不相同，按速度高低排列为：CPU>RAM>DISK。CPU与RAM之间、RAM与DISK之间的速度差异常常是指数级。同时，它们之间的处理容量也不相同，其差异也是指数级。为了在速度和容量上折中，在CPU与RAM之间使用CPU cache以提高访存速度，在RAM与磁盘之间，操作系统使用page cache提高系统对文件的访问速度。 操作系统在
Page cache和buffer cache
jinking01的专栏
07-13 469
这一段要在文件系统中对文件的记录增加索引。实现思路是借鉴了i_zone的三级间接寻址方案。i_zone实际上代表了3层意思，第一层是i_zone这个数组本身，它是放在episode_inode中的，只要拿到了episode_inode的指针或者对象，就可以直接访问；第二层，i_zone[0]--i_zone[9]的内容（就是一个blockid）所代表的那9个block、i_zone[7]-i_zone[9]指向的block里面存储的blocksize/4个blockid所代表的那blocksize/4个bl
控制page cache的大小
kaikai_sk的博客
04-01 9374
控制Cache Memory/Page Cache Size 1 怎么样观察当前的cache memory的使用情况？ [root@gurkullinux ~]# free -m total used free shared buffers cached Mem: 15976 15195 781 0 167 9153 -/+ buffers/cache: 5874 101...
如何用C++实现一个LRU Cache
holybin的专栏
05-17 1449
转自：如何用C++实现一个LRU Cache
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

NUC_Dodamce

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

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

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

打赏作者

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

抵扣说明：

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

余额充值