手写Nginx内存池移植项目 |施磊C++ | 项目实战

已于 2024-10-28 19:36:19 修改
阅读量519 收藏 8
点赞数 5
分类专栏： C++ 项目 后端组件 文章标签： nginx c++ 施磊 内存池 项目实战 开发语言 笔记
于 2024-10-28 12:04:50 首次发布

手写Nginx内存池移植项目

可配合这篇博客一起学习
剖析Nginx的内存池源码 | 施磊 | C++项目实战-优快云博客

注意点

1.所有需要传入内存池入口指针(pool)的地方都不用传入了，因为私有变量pool_存储的就是内存池入口指针

2.在C++中，void* 指针是一个通用指针类型，它可以指向任何类型的数据。然而，由于C++是一种类型安全的语言，直接将 void* 转换为其他类型的指针（或反之）而不进行显式转换（即“强转”）通常是不被允许的，或者至少是不被推荐的。

文章目录

0.预编译文件

//pch.h
#pragma once
#ifndef PCH_H
#define PCH_H

#endif

//pch.cpp
#include"pch.h"

1.ngx_mem_pool.h 变量和接口函数定义

#pragma once
#include<stdlib.h>
#include<memory.h>
/*
移植nginx内存池的代码，用oop来实现
*/

//类型重定义
using u_char = unsigned char;
using ngx_uint_t = unsigned int;

//类型前置声明
struct ngx_pool_s;

//清理函数类型
typedef void (*ngx_pool_cleanup_pt)(void* data); 
// 清理操作的类型定义，包括一个清理回调函数，传给回调函数的数据和下一个清理操作的地址
struct ngx_pool_cleanup_s {
	ngx_pool_cleanup_pt handler; // 定义一个函数指针，保存清理回调函数
	void* data; // 传递给回调函数的参数
	ngx_pool_cleanup_s* next; // 指向下一个清理操作
};

//大块内存的头部信息
struct ngx_pool_large_s {
	ngx_pool_large_s* next;//所有的大块内存分配被串在一条链表上
	void* alloc;//保存分配出去的大块内存的起始地址
};

//分配小块内存的内存池的头部数据信息
struct ngx_pool_data_t {
	u_char* last; // 小块内存池可分配内存开始位置
	u_char* end; // 可分配内存末尾位置
	ngx_pool_s* next; // 保存下一个小块内存池的地址
	ngx_uint_t failed; // 记录当前内存池分配失败的次数
} ;

// nginx内存池头部信息和管理成员信息
struct ngx_pool_s {
	ngx_pool_data_t d;  // 存储的是当前小块内存池的使用情况
	size_t max;  // 小块内存分配的最大值 小块和大块内存的分界线
	ngx_pool_s* current;  // 小块内存池入口指针 指向第一个可以分配的小块内存池，每次分配都是从这个指针所指的内存池开始分配的
	ngx_pool_large_s* large; // 大块内存的入口地址（大块也在一条链表上）
	ngx_pool_cleanup_s* cleanup;
	/*指向所有预置的清理函数handler回调函数的入口（串在一条链表上） 用户可以设置回调函数，
	在内存池释放之前，可以对内存池上的数据进行一个释放操作。相当于析构函数的角色。
	*/	
};
//把d调整到邻近的a的倍数上
#define ngx_align(d, a)     (((d) + (a - 1)) & ~(a - 1))
//小块内存分配考虑字节对齐时的单位
#define NGX_ALIGNMENT   sizeof(unsigned long)
//把指针p调整到a邻近的倍数
#define ngx_align_ptr(p, a)                                                   \
    (u_char *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))
//buf缓冲区清0（初始化为0）
#define ngx_memzero(buf, n)       (void) memset(buf, 0, n)

const int ngx_pagesize = 4096;
/*能从内存池分配到的最大内存 4096-1=4095(4k) 就是32位操作系统一个页面的大小
这是nginx内存池区分大小块内存的一个分界线，比SGI STL内存池的128字节要大得多，在SGI STL中，只要比128字节大就去调用malloc而不是内存池
*/
const int NGX_MAX_ALLOC_FROM_POOL = ngx_pagesize - 1;
//默认的内存池的大小最大为 16k
const int NGX_DEFAULT_POOL_SIZE = 16 * 1024;
//小块内存池大小按照16字节进行对齐
const int NGX_POOL_ALIGNMENT = 16;
//小块内存池最小的大小   gnx_align是把数字调整到邻近的16的倍数上
const int NGX_MIN_POOL_SIZE = 
		ngx_align((sizeof(ngx_pool_s) + 2 * sizeof(ngx_pool_large_s)),
			NGX_POOL_ALIGNMENT);

class ngx_mem_pool
{
public:
	//创建指定size大小的内存池，但小块内存池不超过一个页面的大小
	void* ngx_create_pool(size_t size);
	//考虑内存字节对齐，从内存池申请size大小的内存
	void* ngx_palloc(size_t size);
	//和上面的函数一样，不考虑内存字节对齐
	void* ngx_pnalloc(size_t size);
	//调用的是ngx_palloc实现内存分配，但是会初始化0
	void* ngx_pcalloc(size_t size);
	//释放大块内存
	void ngx_pfree(void* p);
	//内存重置函数
	void ngx_reset_pool();
	//内存池的销毁函数
	void ngx_destroy_pool();
	//添加回调清理操作函数
	ngx_pool_cleanup_s* ngx_pool_cleanup_add(size_t size);
private:
	//指向ngx内存池的入口指针
	ngx_pool_s* pool;
	//小块内存分配
	void* ngx_palloc_small(size_t size, ngx_uint_t align);
	//分配新的小块内存池
	void* ngx_palloc_block(size_t size);
	//分配大块内存池
	void* ngx_palloc_large(size_t size);
};

2.ngx_mem_pool.cpp 接口具体实现

#include"pch.h"
#include"ngx_mem_pool.h"


//创建指定size大小的内存池，但小块内存池不超过一个页面的大小
void* ngx_mem_pool::ngx_create_pool(size_t size)
{
    ngx_pool_s* p;
    //根据用户指定的大小开辟内存 根据不同的平台调用不同的API 如果没有指定平台，那调用的就是malloc函数
    p = (ngx_pool_s*)malloc(size);
    //申请失败 退出
    if (p == nullptr) {
        return nullptr;
    }
    //last指向的是用户可以使用的内存空间的首地址（除了内存池的头结构体部分的其他内容） end指向的是这块的末尾地址 size是传入的要申请的大小 在图中表示为log末尾到内存池末尾这一块
    p->d.last = (u_char*)p + sizeof(ngx_pool_s);
    p->d.end = (u_char*)p + size;
    //初始化
    p->d.next = nullptr;
    p->d.failed = 0;
    //这个size是我们用户实际上可以使用的大小 申请的大小减去内存池记录信息所用的数据头的大小
    size = size - sizeof(ngx_pool_s);
    //如果比一个页面小，那就用size，否则就用一个页面的大小
    p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL;
    //初始化
    p->current = p;//指向本内存池的起始地址
    p->large = nullptr;
    p->cleanup = nullptr;

    pool = p;//封装后对私有变量要赋值的

    return p;
}


//考虑内存字节对齐，从内存池申请size大小的内存
void* ngx_mem_pool::ngx_palloc(size_t size)
{
    if (size <= pool->max) {
        return ngx_palloc_small(size, 1);
    }
    return ngx_palloc_large(size);
}
//和上面的函数一样，不考虑内存字节对齐
void* ngx_mem_pool::ngx_pnalloc(size_t size)
{
    if (size <= pool->max) {
        return ngx_palloc_small(size, 0);
    }
    return ngx_palloc_large(size);
}
//调用的是ngx_palloc实现内存分配，但是会初始化0
void* ngx_mem_pool::ngx_pcalloc(size_t size)
{
    void* p;

    p = ngx_palloc(size);
    if (p) {
        ngx_memzero(p, size);
    }

    return p;
}


//小块内存分配
void* ngx_mem_pool::ngx_palloc_small(size_t size, ngx_uint_t align)
{
    u_char* m;
    ngx_pool_s* p;

    //p指向传入内存池的起始地址
    p = pool->current;

    do {
        //指向可分配内存的起始地址
        m = p->d.last;
        //考虑内存对齐
        if (align) {
            //根据平台调整字节对齐，调整到4或8字节的倍数上去
            m = ngx_align_ptr(m, NGX_ALIGNMENT);
        }
        //目前可分配内存（空闲内存）比要申请的内存要大 就可以分配 然后更新last即空闲内存起始地址
        if ((size_t)(p->d.end - m) >= size) {
            p->d.last = m + size;

            return m;//m是已经分配好的内存空间的首地址 返回这个指针给用户
        }

        p = p->d.next;//这个内存池大小不够就去下一个，没有下一个内存池的话就会退出循环

    } while (p);
    //没有分配成功就会进入这个函数
    return ngx_palloc_block(size);
}
//分配新的小块内存池
void* ngx_mem_pool::ngx_palloc_block(size_t size)
{
    u_char* m;
    size_t       psize;
    ngx_pool_s* p, * newpool;
    //计算当前整个内存池的大小
    psize = (size_t)(pool->d.end - (u_char*)pool);
    //再开辟另一块大小一模一样的内存池
    m =(u_char*)malloc(psize);
    if (m == nullptr) {
        return nullptr;
    }
    //记录内存池起始地址
    newpool = (ngx_pool_s*)m;
    /*初始化内存池结构体
    从第二块内存池开始 只需要ngx_pool_data_t里面的四个指针来管理，从max到log全都不需要了，存在第一块内存池里面就行了，剩下的只要这四个必要的指针就行
    */
    newpool->d.end = m + psize;
    newpool->d.next = nullptr;//这是新创建的，就相当于链表最后一个结点，next域就是nullptr
    newpool->d.failed = 0;

    m += sizeof(ngx_pool_data_t);
    //字节对齐 调整到4或8的倍数
    m = ngx_align_ptr(m, NGX_ALIGNMENT);
    newpool->d.last = m + size;//更新内存池的last指针，指向可用内存空间（空闲内存）的首地址

    for (p = pool->current; p->d.next; p = p->d.next) {
        if (p->d.failed++ > 4) {
            pool->current = p->d.next;
        }
    }

    p->d.next = newpool;

    return m;
}
//分配大块内存池
void* ngx_mem_pool::ngx_palloc_large(size_t size)
{
    void* p;
    ngx_uint_t         n;
    ngx_pool_large_s* large;
    //直接调用malloc开辟内存
    p = malloc(size);
    if (p == nullptr) {
        return nullptr;
    }

    n = 0;
    //先看下面的pfree函数再看这个，遍历大块内存池链表，找到alloc是空的，把新分配的这块给安置到这里
    for (large = pool->large; large; large = large->next) {
        if (large->alloc == nullptr) {
            large->alloc = p;
            return p;
        }
        //找了三次还没找到空的，那就算了，太浪费时间了，直接在小块内存池里面把内存头结构体放进去
        if (n++ > 3) {
            break;
        }
    }
    //把大块内存的内存头 上面那个结构体给放到小块内存的内存池里面去了
    large = (ngx_pool_large_s*)ngx_palloc_small(sizeof(ngx_pool_large_s), 1);
    //开辟失败直接把大的内释放掉
    if (large == nullptr) {
        free(p);
        return nullptr;
    }
    //记录大块内存的起始地址
    large->alloc = p;
    large->next = pool->large;
    pool->large = large;

    return p;
}
//大块内存释放
void ngx_mem_pool::ngx_pfree(void* p)
{
    ngx_pool_large_s* l;

    for (l = pool->large; l; l = l->next) {
        if (p == l->alloc) {
            free(l->alloc);
            l->alloc = NULL;
            return ;
        }
    }
}


//内存重置函数
void ngx_mem_pool::ngx_reset_pool()
{
    ngx_pool_s* p;
    ngx_pool_large_s* l;
    //遍历大块内存
    for (l = pool->large; l; l = l->next) {
        if (l->alloc) {
            free(l->alloc);
        }
    }
    /*遍历小块内存 这个处理的不太好，因为除了第一块结构体是完整的（从开始到log），
    剩下的内存池结构体那块都是只有四个指针 这样释放内存相当于多释放了除开四个指针的多余部分。表现就是从第二块开始的内存池有一小部分不能使用，但是可以使用，不会报错。
    
    for (p = pool; p; p = p->d.next) {
        p->d.last = (u_char*)p + sizeof(ngx_pool_t);
        p->d.failed = 0;
    }*/

    //修改后的版本
    p = pool;
    //处理第一个内存池
    p->d.last = (u_char*)p + sizeof(ngx_pool_s);
    p->d.failed = 0;

    //从第二个开始循环到最后一个 只需要释放那四个指针，即ngx_pool_data_t就行
    for (p = pool; p; p = p->d.next) {
        p->d.last = (u_char*)p + sizeof(ngx_pool_data_t);
        p->d.failed = 0;
    }

    pool->current = pool;
    pool->large = nullptr;
}
//内存池的销毁函数
void ngx_mem_pool::ngx_destroy_pool()
{
    ngx_pool_s* p, * n;
    ngx_pool_large_s* l;
    ngx_pool_cleanup_s* c;
    //1.回调函数不为空先调回调函数 这样就把外部资源释放掉了
    for (c = pool->cleanup; c; c = c->next) {
        if (c->handler) {
            c->handler(c->data);
        }
    }
    //2.大块
    for (l = pool->large; l; l = l->next) {
        if (l->alloc) {
            free(l->alloc);
        }
    }
    //3.小块
    for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
        free(p);

        if (n == nullptr) {
            break;
        }
    }
}
//添加回调清理操作函数
ngx_pool_cleanup_s* ngx_mem_pool::ngx_pool_cleanup_add(size_t size)
{
    ngx_pool_cleanup_s* c;
    //把结构体存储在小块内存内存池
    c = (ngx_pool_cleanup_s*)ngx_palloc(sizeof(ngx_pool_cleanup_s));
    if (c == nullptr) {
        return nullptr;
        }
    //如果预置的回调函数不需要参数，那就写0，如果有参数就写需要的内存大小，然后再开辟相应的内存，然后data指向它，如果不需要参数那就是nullptr
    if (size) {
        c->data = ngx_palloc(size);
        if (c->data == nullptr) {
            return nullptr;
        }

    }
    else {
        c->data = nullptr;
    }
    //暂时置为空，还没有具体的值
    c->handler = nullptr;
    //链表的连接动作，把新创建的cleanup连接到链表上（next指向的是下一个清理操作）
    c->next = pool->cleanup;

    pool->cleanup = c;
    return c;
}

3.textNginxPool.cpp 测试文件

#include"pch.h"
#include"ngx_mem_pool.h"
#include<stdio.h>
#include<string.h>

//大块内存池里面放了两个指针将要指向外部资源
typedef struct Data stData;
struct Data
{
    char* ptr;
    FILE* pfile;
};
//两个回调函数 堆内存资源和文件资源
void func1(void* p1)
{
    char* p = (char*)p1;
    printf("free ptr mem!");
    free(p);
}
void func2(FILE* pf1)
{
    FILE *pf=(FILE*) pf1;
    printf("close file!");
    fclose(pf);
}
int main()
{
    // 最大值设置为512 create_pool可以直接实现在mempool的构造函数
    ngx_mem_pool mempool;

    if (mempool.ngx_create_pool(512) == nullptr)
    {
        printf("ngx_create_pool fail...");
        return -1;
    }

    void* p1 = mempool.ngx_palloc(128); // 从小块内存池分配的
    if (p1 == nullptr)
    {
        printf("ngx_palloc 128 bytes fail...");
        return -1;
    }

    stData* p2 =(stData*) mempool.ngx_palloc(512); // 从大块内存池分配的
    if (p2 == nullptr)
    {
        printf("ngx_palloc 512 bytes fail...");
        return -1;
    }
    p2->ptr = (char*)malloc(12);
    strcpy(p2->ptr, "hello world");
    p2->pfile = fopen("data.txt", "w");

    ngx_pool_cleanup_s* c1 = mempool.ngx_pool_cleanup_add(sizeof(char*));
    c1->handler = func1;
    c1->data = p2->ptr;

    ngx_pool_cleanup_s* c2 = mempool.ngx_pool_cleanup_add(sizeof(FILE*));
    c2->handler = (ngx_pool_cleanup_pt)func2;
    c2->data = p2->pfile;

    //可以直接实现在mempool的析构函数
    mempool.ngx_destroy_pool(); // 1.调用所有的预置的清理函数 2.释放大块内存 3.释放小块内存池所有内存

    return 0;
}

4.改进

1.可以将create_pool放在构造函数中，将destroy_pool放在析构函数中，进一步进行封装

2.回调函数部分可以用bind绑定器或者function函数对象来实现

笔者只实现了第一点，实现第二点时，老是报错（读取访问权限冲突。 std::_Func_class<void,void * __ptr64>::_Getimpl(…) 返回 0xFFFFFFFFFFFFFFFF。完了写好之后再更新此文章）

pool.h

//pool.h
#pragma once
#include<stdlib.h>
#include<memory.h>
#include<iostream>
using namespace std;
/*
移植nginx内存池的代码，用oop来实现
*/

//类型重定义
using u_char = unsigned char;
using ngx_uint_t = unsigned int;

//类型前置声明
struct ngx_pool_s;

//清理函数类型
typedef void (*ngx_pool_cleanup_pt)(void* data); 
// 清理操作的类型定义，包括一个清理回调函数，传给回调函数的数据和下一个清理操作的地址
struct ngx_pool_cleanup_s {
	ngx_pool_cleanup_pt handler; // 定义一个函数指针，保存清理回调函数
	void* data; // 传递给回调函数的参数
	ngx_pool_cleanup_s* next; // 指向下一个清理操作
};

//大块内存的头部信息
struct ngx_pool_large_s {
	ngx_pool_large_s* next;//所有的大块内存分配被串在一条链表上
	void* alloc;//保存分配出去的大块内存的起始地址
};

//分配小块内存的内存池的头部数据信息
struct ngx_pool_data_t {
	u_char* last; // 小块内存池可分配内存开始位置
	u_char* end; // 可分配内存末尾位置
	ngx_pool_s* next; // 保存下一个小块内存池的地址
	ngx_uint_t failed; // 记录当前内存池分配失败的次数
} ;

// nginx内存池头部信息和管理成员信息
struct ngx_pool_s {
	ngx_pool_data_t d;  // 存储的是当前小块内存池的使用情况
	size_t max;  // 小块内存分配的最大值 小块和大块内存的分界线
	ngx_pool_s* current;  // 小块内存池入口指针 指向第一个可以分配的小块内存池，每次分配都是从这个指针所指的内存池开始分配的
	ngx_pool_large_s* large; // 大块内存的入口地址（大块也在一条链表上）
	ngx_pool_cleanup_s* cleanup;
	/*指向所有预置的清理函数handler回调函数的入口（串在一条链表上） 用户可以设置回调函数，
	在内存池释放之前，可以对内存池上的数据进行一个释放操作。相当于析构函数的角色。
	*/	
};
//把d调整到邻近的a的倍数上
#define ngx_align(d, a)     (((d) + (a - 1)) & ~(a - 1))
//小块内存分配考虑字节对齐时的单位
#define NGX_ALIGNMENT   sizeof(unsigned long)
//把指针p调整到a邻近的倍数
#define ngx_align_ptr(p, a)                                                   \
    (u_char *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))
//buf缓冲区清0（初始化为0）
#define ngx_memzero(buf, n)       (void) memset(buf, 0, n)

const int ngx_pagesize = 4096;
/*能从内存池分配到的最大内存 4096-1=4095(4k) 就是32位操作系统一个页面的大小
这是nginx内存池区分大小块内存的一个分界线，比SGI STL内存池的128字节要大得多，在SGI STL中，只要比128字节大就去调用malloc而不是内存池
*/
const int NGX_MAX_ALLOC_FROM_POOL = ngx_pagesize - 1;
//默认的内存池的大小最大为 16k
const int NGX_DEFAULT_POOL_SIZE = 16 * 1024;
//小块内存池大小按照16字节进行对齐
const int NGX_POOL_ALIGNMENT = 16;
//小块内存池最小的大小   gnx_align是把数字调整到邻近的16的倍数上
const int NGX_MIN_POOL_SIZE = 
		ngx_align((sizeof(ngx_pool_s) + 2 * sizeof(ngx_pool_large_s)),
			NGX_POOL_ALIGNMENT);

class ngx_mem_pool
{
public:
	ngx_mem_pool(size_t size)
	{

		if (this->ngx_create_pool(size) == nullptr)
		{
			cout << "ngx_create_pool fail..." << endl;
			exit(0);
		}
	}
	//考虑内存字节对齐，从内存池申请size大小的内存
	void* ngx_palloc(size_t size);
	//和上面的函数一样，不考虑内存字节对齐
	void* ngx_pnalloc(size_t size);
	//调用的是ngx_palloc实现内存分配，但是会初始化0
	void* ngx_pcalloc(size_t size);
	//释放大块内存
	void ngx_pfree(void* p);
	//内存重置函数
	void ngx_reset_pool();

	//添加回调清理操作函数
	ngx_pool_cleanup_s* ngx_pool_cleanup_add(size_t size);

	~ngx_mem_pool()
	{
		this->ngx_destroy_pool();
	}
private:
	//指向ngx内存池的入口指针
	ngx_pool_s* pool;
	//小块内存分配
	void* ngx_palloc_small(size_t size, ngx_uint_t align);
	//分配新的小块内存池
	void* ngx_palloc_block(size_t size);
	//分配大块内存池
	void* ngx_palloc_large(size_t size);
	//创建指定size大小的内存池，但小块内存池不超过一个页面的大小
	void* ngx_create_pool(size_t size);
	//内存池的销毁函数
	void ngx_destroy_pool();
};

pool.cpp

这个没改动

text.cpp

#include"pch.h"
#include"ngx_mem_pool.h"
#include<stdio.h>
#include<string.h>

//大块内存池里面放了两个指针将要指向外部资源
typedef struct Data stData;
struct Data
{
    char* ptr;
    FILE* pfile;
};
//两个回调函数 堆内存资源和文件资源
void func1(void* p1)
{
    char* p = (char*)p1;
    printf("free ptr mem!");
    free(p);
}
void func2(FILE* pf1)
{
    FILE* pf = (FILE*)pf1;
    printf("close file!");
    fclose(pf);
}
int main()
{
    // 最大值设置为512 create_pool可以直接实现在mempool的构造函数
    ngx_mem_pool mempool(512);

    void* p1 = mempool.ngx_palloc(128); // 从小块内存池分配的
    if (p1 == nullptr)
    {
        printf("ngx_palloc 128 bytes fail...");
        return -1;
    }

    stData* p2 = (stData*)mempool.ngx_palloc(512); // 从大块内存池分配的
    if (p2 == nullptr)
    {
        printf("ngx_palloc 512 bytes fail...");
        return -1;
    }
    p2->ptr = (char*)malloc(12);
    strcpy(p2->ptr, "hello world");
    p2->pfile = fopen("data.txt", "w");

    ngx_pool_cleanup_s* c1 = mempool.ngx_pool_cleanup_add(sizeof(char*));
    c1->handler = func1;
    c1->data = p2->ptr;

    ngx_pool_cleanup_s* c2 = mempool.ngx_pool_cleanup_add(sizeof(FILE*));
    c2->handler = (ngx_pool_cleanup_pt)func2;
    c2->data = p2->pfile;

    return 0;
}

bind和function的改进还没完成（笔者标注一下不要在意）

《C/C++实战专栏》介绍
dvlinker的技术专栏
07-31 15万+
本文详细介绍《C/C++实战专栏》的主体内容构成。
【运维项目经历|003】：Nginx集群化运维升级项目
小鹏linux的博客
05-14 6943
项目背景 随着公司业务的发展和用户量的不断增长，现有的Nginx服务器集群已逐渐无法满足高性能、高可用的要求。同时，老旧的Nginx版本存在安全隐患和性能瓶颈，需要进行升级和优化。因此，公司决定启动"ScaleUp Nginx"项目，对Nginx集群进行全面的升级和改造。
NGINX内存池C代码移植项目
qq_45132647的博客
04-22 365
nginx是一个高性能的HTTP和反向代理web服务器，是由伊戈尔·塞索耶夫为俄罗斯网站开发的，是一个开源的软件，底层由C语言编写完成，但经过提炼后，是可以将其按照面向对象的思想重新组织一下的，也相当于一个小项目吧。 涉及思路是将源文件中的几个主要函数实现成为类的成员方法，成员变量则只设置一个内存池对象即可。因为nginx内存池的结构比较复杂，涉及很多网络相关的东西，我们在本地编译器上对这些变量做...
nginx内存池代码移植
weixin_43725202的博客
04-19 692
文章目录源码移植头文件类型定义辅助函数以及全局变量内存池类源文件创建内存池销毁内存池内存重置函数内存开辟内存释放（大块内存）添加清理回调操作函数小块内存分配分配新的小块内存池大块内存分配测试代码 通过对nginx内存池源码的学习，学习到了nginx内存池的精妙处理以及对于代码的运用。由于nginx是通过C语言实现的，本篇文章将使用C++对内存池进行一个简单的封装。 源码移植 头文件 因为本篇博客着...
nginx内存池实现原理
囧囧有神的专栏
01-03 9092
Nginx以高效，节省内存著称。到底如何高效，如何节省内存，这个得真正了解其设计原理才能知道，分析源码是了解其原理最直接的方法。Nginx对非常多的基础设施（红黑树 内存池 连接池 hash表）都重复造了轮子，我们来看看为什么要这么做。     对于c系统，最难的常常是内存管理，随着系统复杂度的提高，各种内存问题都出来了，很难管理，对于系统的长期稳定运行构成影响。我们生产线上的nginx常年稳定
Nginx内存池源码移植项目
孤傲小二~阿沐的博客
08-21 438
2019年8月21日16:28:21 本章重点：Nginx内存池是由C语言开发而成，此次项目移植。我们就是要在其上，进行一层OOP的封装。 在上一节的学习解剖中： Nginx内存池的相关函数都是依赖于一个： typedef struct ngx_pool_s ngx_pool_t;类型的参数。用typedef 将struct ngx_pool_s类型 起了一个短一点的名字ng...
Nginx：移植Nginx内存池 | 附测试用例
Sauron7i的博客
06-28 701
ngx_mem_pool.cpp 创建内存池和销毁内存池可以放在内存池的构造函数和析构函数中，这里没有放，所以在创建过程中把地址赋给内存池成员pool。
Nginx 部署前端 Vue 项目实战指南
四楼没电梯的专栏
09-02 2736
在执行此命令之前，需要确保路由配置中的模式正确。修改完成后，保存配置文件，并在命令行中执行相应命令重启 Nginx 服务。您可以从 Nginx 官方网站下载安装包，然后按照安装向导进行安装。，回车，即可启动 Nginx 服务。可以在任务管理器的进程中看到启动的 Nginx 服务。从 Nginx 官方网站下载安装包，按照安装向导进行安装。另外，还需要对项目中的一些配置文件进行修改，比如在。要修改 Nginx 的配置文件，例如修改端口，可在。指令，将默认的 80 端口修改为您想要的端口，如。
项目实战 | 基于RK3566开发板实现USB摄像头推流（ffmpeg+nginx）
Mculover666的博客（嵌入式）
10-02 3937
推流这个词一般用于直播中，是指客户端接入后，系统可以将数据（画面、音频等）推送给客户端。
nginx服务器 java项目,服务器使用Nginx如何部署Springboot项目
weixin_36062835的博客
08-06 4165
服务器使用Nginx如何部署Springboot项目发布时间：2020-07-02 14:46:28来源：亿速云阅读：136作者：清晨这篇文章将为大家详细讲解有关服务器使用Nginx如何部署Springboot项目，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。1,将java项目打成jar包这里我用到的是maven工具这里有两个项目，打包完成后一个为demo.ja...
Nginx的内存池vc代码的例子
01-26
完全copy的nginx的内存池vc++例子
Nginx内存池移植为C++版本
qq_42120843的博客
05-17 242
这个项目是在阅读nginx内存池源码后，将其代码重新用C++面向对象的方式实现，大体与源码相同，旨在加深对nginx内存池的理解。// 内存池实际的可分配内存空间 p -> max =(size < NGX_MAX_ALLOC_FROM_POOL)?pool = p;return p;u_char * m;// 到下一个小块内存池尝试 } while(p);u_char * m;
Nginx 内存池浅析&移植使用
Peace
04-18 277
1.基本数据结构 1）最顶层 \src\core\ngx_palloc.h中 ngx_pool_s --内存池基本数据结构，整个内存池是由该结构构成的链表 struct ngx_pool_s { ngx_pool_data_t d; size_t max; ngx_pool_t *current; ngx_chain_t *chain; ngx_pool_large_t
SGI STL二级空间配置器内存池的源码移植项目
孤傲小二~阿沐的博客
08-22 358
2019年8月21日23:39:54 首先SGI STL二级空间配置器内存池的源码解剖可以 详见我的博客： SGI STL二级空间配置器内存池的源码解剖 源码移植实现空间配置器是用模板实现的，因此代码只能放在头文件里面了。（不可以把类和方法声明写在头文件里面，然后在源文件里面去实现模板方法）而且这里也是需要考虑一下：多线程环境下的线程安全问题。毕竟空间配置器是给容器使用的，而容器产生的对象是 很有...
Nginx源码剖析之内存池，与内存管理
weixin_33923762的博客
12-04 419
Nginx源码剖析之内存池，与内存管理作者：July、dreamice、阿波、yixiao。出处：http://blog.youkuaiyun.com/v_JULY_v/。引言        Nginx（发音同 engine x）是一款轻量级的Web 服务器/反向代理服务器及电子邮件（IMAP/POP3）代理服务器，并在一个BSD-like 协议下发行。由俄罗斯的程序设计师Igor Sysoev所开发，最初供...
C++实现Nginx中的内存池
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-30 409
头文件 //将Nginx中的内存池实现移植到c++,通过面向对象的方式实现 #ifndef MEMORYPOOL_NGINXMEMORYPOOL_H #define MEMORYPOOL_NGINXMEMORYPOOL_H #include<cstdlib> #include<cstdio> #include<memory.h> using u_char = unsigned char; using ngx_uint_t = unsigned int; using ngx
施磊C++ | 项目实战 | SGI STL二级空间配置器源码剖析
最新发布
m0_74795952的博客
10-25 1085
C++SGI STL 内存池二级空间配置器源码剖析
施磊C++项目-【高级】集群聊天服务器-软件分层设计和高性能服务开发
IS_MOKE的博客
08-31 1581
5、负载均衡中，每个服务器有不同的人进行注册，不同服务器上的用户要进行通信的话，主要引入了redis的发布订阅作为MQ消息队列的功能，实现跨服务器的消息通信。4、单机下并发能力有限，要多机扩展，挂一个nginx的负载均衡，基于tcp的cs通信，是一个长连接（客户端给服务器发消息，服务端给客户端推消息）压力测试：单机到5、6千，是跟服务器的fd有关的，所以可以更改fd的最大上限，可以让单机达到两万的并发量。2、服务层map和绑定器，做了一个消息的fd，从消息解析到json，得到消息的id，通过回调处理消息。
Nginx基础知识. Nginx内存池分析
博客
08-29 470
Nginx内存池 1. 内存池结构定义 struct ngx_pool_s {     ngx_pool_data_t       d;             //内存池的数据部分     size_t                max;           //内存池中, 每个内存块的最大数据容纳量     ngx_pool_t           *current;
深入理解C++ Nginx内存池的源码实现与应用
在C++项目中使用Nginx内存池可以按照以下步骤进行： 1. 首先，需要包含Nginx内存池相关的头文件。由于Nginx是用C语言编写的，因此我们需要包含相应的C头文件。 ```cpp #include "nginx.h" #include "ngx_palloc.h...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值