适用Linux下用于多进程的共享内存池

Shared-Cache Malloc

开发者：cyc-yzhzc

项目链接

https://gitee.com/yzhzc/scmalloc
（优化中）

项目简介

一个用于Linux环境下的共享内存池，专为多进程环境设计，提供快速且安全的共享内存管理以及智能的内存分配与回收机制。

功能特点

• 虚拟地址映射管理：无需关心不同进程下同一块共享内存映射的虚拟地址不同的问题。

• 自动申请和释放共享内存文件：系统自动申请所需的共享内存文件，无需用户手动管理，闲置的共享内存文件会自动被释放，节省系统资源。

• 按页管理共享内存文件：申请的共享内存文件以页为单位进行管理，提高内存利用率。

• 灵活分配内存块：多页或单页共享内存可以被切割成所需的小块内存供进程使用。

• 智能回收与合并内存块：回收的小块内存会自动管理和合并，当合并成整页时交给页管理器进行管理。

• 高级页管理：页管理器会将空闲的小块共享内存页合并成更大的页，并将闲置的最大页释放给系统，自动解除这块共享内存在进程中的映射。

项目优势

• 高效管理：通过智能分配和回收内存块，提高系统性能和资源利用率。
• 无缝集成：进程无需关心共享内存的复杂管理，简化了内存使用流程。
• 自动优化：自动管理内存的申请、释放和合并，确保系统的内存资源得到最优利用。

API

Shared Cache Malloc 提供了简单易用的API接口，适用于各种需要高效共享内存管理的应用场景。

server

需要启动这个服务，其他进程才能使用申请释放

#include <iostream>
#include "SharedServer.hpp"


int main()
{
    LOG_CYC(_DEBUG, "server", nullptr);

    SharedServer* svr = SharedServer::GetInstance(ShmService::SHM_CREATE);
    svr->Run();

    return 0;
}

client

#include <iostream>
#include <atomic>
#include <thread>
#include <chrono>
#include "SCAllocator.hpp"

const int iterations = 25;                // 每个线程的迭代次数
const int maxBlockSize = 128 * 1024 * 1024; // 64MB，最大申请大小
const int numThreads = 4;                 // 线程数

class buffer {
public:
    buffer(int64_t ID) : id(ID) {}
    int64_t id;
    char buf[1024];
};

void threadFunction(int threadId, std::atomic<int>& count) {
    std::srand(std::time(nullptr) + threadId);  // 每个线程设置不同的随机种子
    std::chrono::duration<double> allocTime(0);
    std::chrono::duration<double> deallocTime(0);

    buffer* bufs[iterations];
    void* ptrs[iterations];

    auto startAlloc = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < iterations; ++i) {
        int size = (std::rand() % maxBlockSize) + 1;  // 随机生成1到maxBlockSize之间的大小
        bufs[i] = SC::allocateMemory<buffer>(count);  // 分配内存
        ptrs[i] = SC::allocateMemory(size);
    }
    auto endAlloc = std::chrono::high_resolution_clock::now();
    allocTime += endAlloc - startAlloc;

    auto startDealloc = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < iterations; ++i) {
        SC::deallocateMemory(bufs[i]);
        SC::deallocateMemory(ptrs[i]);
    }
    auto endDealloc = std::chrono::high_resolution_clock::now();
    deallocTime += endDealloc - startDealloc;

    count += iterations;

    // 打印每个线程的分配和释放时间
    std::cout << "线程 " << threadId << " 分配时间: " << allocTime.count() << " 秒, 释放时间: " << deallocTime.count() << " 秒" << std::endl;
}

int main() {
    std::atomic<int> count(0);

    std::thread threads[numThreads];
    std::chrono::duration<double> totalTime(0);

    auto startTotal = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < numThreads; ++i) {
        threads[i] = std::thread(threadFunction, i, std::ref(count));
    }

    for (int i = 0; i < numThreads; ++i) {
        threads[i].join();
    }
    auto endTotal = std::chrono::high_resolution_clock::now();
    totalTime = endTotal - startTotal;

    std::cout << numThreads << " 个线程,每个线程执行最大随机 " << maxBlockSize/(1024*1024) << "MB " << iterations << " 次 "<< std::endl;
    std::cout << "总执行时间: " << totalTime.count() << " 秒" << std::endl;

    return 0;
}

执行结果

线程 0 分配时间: 0.0126348 秒, 释放时间: 0.000201596 秒
线程 2 分配时间: 0.0130916 秒, 释放时间: 0.000475594 秒
线程 1 分配时间: 0.0137269 秒, 释放时间: 0.00010405 秒
线程 3 分配时间: 0.0140054 秒, 释放时间: 0.000262698 秒
4 个线程,每个线程执行最大随机 128MB 25 次 
总执行时间: 0.0147795 秒

数据结构

开发中…，会首先提供一个多进程共享队列，实现进程交互共享内存块的数据；