DeepSeek-671B纯CPU部署：配置选型、性能测试与量化对比

企业存储技术 · 公众号 · · 2025-03-18 18:40

正文

本文转载自腾讯玄武实验室，原文链接见文末。看到好东西分享给大家：）

私有化部署大模型能够有效保护数据隐私、便于开展大模型安全研究和知识蒸馏。目前主流部署方式包括纯 GPU、CPU/GPU 混合以及纯 CPU 三种部署方式。本文介绍了我们针对 DeepSeek 大模型纯 CPU 本地化部署的推理探索与实践方案。我们以约 3.8 万元的整体成本，基于 llama.cpp 框架，经过硬件选型与量化精度的综合考量，实现了 q8 精度下 7.17 tokens/s 的峰值输出速度。通过散热方案改进、BIOS 参数优化及系统内存带宽调优，我们在 q8 精度下取得了不小的性能提升，其中长文本生成速度提升约 25%、峰值输出速度提升约 15%、预填充速度提升约 20%。全文内容共分为《装机选型篇》《软硬件配置篇》《性能测试与量化对比篇》《性能优化分析篇》四个部分，本篇文章涵盖前三个部分，第四部分将在下一篇文章中详细展开。

0x01 装机选型篇

装机配置推荐清单：

主板：MZ73-LM1（7400 元，比较容易买到，双路当单路用）或 MZ33-AR1（5950 元）
CPU：单颗EPYC 9135(7900，比较容易买到) 或 EPYC 9115(5400 元)
内存：DDR5 5600MHz 64GB x 12 （22800 元）
硬盘：大于 1TB 的 SSD
电源：850W 电源
机箱：支持 ETAX 服务器主板的开放式机箱
散热：纯铜内存散热马甲，内存供电mos热管散热器
总成本：38000元(5200 美元) ± 5%

整机效果图：

选型思路分享：

预算投入的优先级为“内存带宽” > “CPU 核心数” > “SSD 读写速度”> “CPU 主频”
内存带宽直接影响生成速度
CPU 核心数影响预填充和并发输出速度，实测升级48及以上物理核心的CPU预填充速度可以达到50+tokens/s，最大并发输出速度可以达到40+tokens/s
SSD 读写速度硬性模型加载速度和prompt cache读写速度
CPU 主频对性能影响较小，可以选择同档次 CPU 里主频最低的获得最高性价比

若想改配置需要注意的事项：

不推荐双路 CPU 方案，因为双路 NUMA 节点的跨节点访问会导致内存带宽严重劣化，而所有优化 NUMA 访存的方案都会消耗宝贵的内存容量
12 个内存通道必须插满，以充分利用 CPU 所支持的全部带宽
单根内存条强烈建议选择64GB，因为 12 路 64GB 共 768GB 总容量装下q8 量化后的模型权重后，剩下的存储空间做为 kv cache 还能支持22K的模型上下文
主板选择的时候不要选择支持2DPC（2 DIMMs Per Channel）内存插槽的主板，即使使用这类主板也要确保每个通道只插一根内存，否则主板会对该通道进行降频如 5600MHz 降到 4800MHz，从而导致总体带宽大幅下降，使得生成速度下降 1 个 token 左右
CPU 和南桥的散热不重要，CPU使用风冷即可，但内存的散热非常重要，长时间内存过热可能会导致降频，内存降频后会损失高达 20% 的生成速度

功耗：

采用装机配置推荐清单中MZ73-LM1 + 9135的配置，测量在模型推理不同阶段的功耗如下：

上图中，左上为待机功耗，右上为模型加载阶段功耗，左下为模型预填充阶段功耗，右下为模型生成阶段功耗

0x02 软硬件配置篇

散热优化：

由于满载推理时内存一直高负荷运行，内存供电 mos 管和内存条本身的散热压力较大。实测给内存供电 mos 管换了热管散热器后可将 mos 管温度压制到 40 度左右，给内存条安装上纯铜散热马甲后内存颗粒表面温度可以从 70 多度的降至约60 度。散热优化后由于避免了内存过热而导致的自动降频，使得跑长文本输出时的速度得到20%的提升。散热优化后使用红外温枪测得的 mos 管温度和内存颗粒表面温度如下图所示：

BIOS优化：

由于CPU 和主板均支持 6000MHz，因此可以对内存进行小幅超频，获得保证系统稳定运行下的最大化性价比。将频率从默认频率 5600MHz 提升到 6000MHz。超频选择的入口位置：AMD CBS -> UMC Common Options -> Enforce PDR -> Memory Target Speed -> DDR6000，如下图所示。

超频后可小幅提高峰值生成速度约 0.2 个 token/s 左右。

系统优化：

下载 llama.cpp 源码：

1 2	git clone https://github.com/ggml-org/llama.cpp.git git checkout 20a9b8f5e1380243ed03aeb50ae1bf94b8d68501

用下面的代码替换掉 src 目录下的llama-mmap.cpp 文件里的内容

使用Hugepage大页代码如下

#include "llama-mmap.h"

#include "llama-impl.h"

#include "ggml.h"

#include 
#include 
#include 
#include 

#ifdef __has_include
    #if __has_include()
        #include 
        #if defined(_POSIX_MAPPED_FILES)
            #include 
            #include 
        #endif
        #if defined(_POSIX_MEMLOCK_RANGE)
            #include 




    

        #endif
    #endif
#endif

#if defined(_WIN32)
    #define WIN32_LEAN_AND_MEAN
    #ifndef NOMINMAX
        #define NOMINMAX
    #endif
    #include 
    #ifndef PATH_MAX
        #define PATH_MAX MAX_PATH
    #endif
    #include 
#endif

// TODO: consider moving to llama-impl.h if needed in more places
#if defined(_WIN32)
static std::string llama_format_win_err(DWORD err) {
    LPSTR buf;
    size_t size = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
                                 NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&buf, 0, NULL);
    if (!size) {
        return "FormatMessageA failed";
    }
    std::string ret(buf, size);
    LocalFree(buf);
    return ret;
}
#endif

// llama_file

struct llama_file::impl {
#if defined(_WIN32)
    HANDLE fp_win32;
    std::string GetErrorMessageWin32(DWORD error_code) const {
        std::string ret;
        LPSTR lpMsgBuf = NULL;
        DWORD bufLen = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&lpMsgBuf, 0, NULL);
        if (!bufLen) {
            ret = format("Win32 error code: %lx", error_code);
        } else {
            ret = lpMsgBuf;
            LocalFree(lpMsgBuf);
        }

        return ret;
    }

    impl(const char * fname, const char * mode) {
        fp = ggml_fopen(fname, mode);




    

        if (fp == NULL) {
            throw std::runtime_error(format("failed to open %s: %s", fname, strerror(errno)));
        }
        fp_win32 = (HANDLE) _get_osfhandle(_fileno(fp));
        seek(0, SEEK_END);
        size = tell();
        seek(0, SEEK_SET);
    }

    size_t tell() const {
        LARGE_INTEGER li;
        li.QuadPart = 0;
        BOOL ret = SetFilePointerEx(fp_win32, li, &li, FILE_CURRENT);
        if (!ret) {
            throw std::runtime_error(format("read error: %s", GetErrorMessageWin32(GetLastError()).c_str()));
        }

        return li.QuadPart;
    }

    void seek(size_t offset, int whence) const {
        static_assert(SEEK_SET == FILE_BEGIN, "SEEK_SET != FILE_BEGIN");
        static_assert(SEEK_CUR == FILE_CURRENT, "SEEK_CUR != FILE_CURRENT");
        static_assert(SEEK_END == FILE_END, "SEEK_END != FILE_END");

        LARGE_INTEGER li;
        li.QuadPart = offset;
        BOOL ret = SetFilePointerEx(fp_win32, li, NULL, whence);
        if (!ret) {
            throw std::runtime_error(format("read error: %s", GetErrorMessageWin32(GetLastError()).c_str()));
        }
    }

    void read_raw(void * ptr, size_t len) const {
        size_t bytes_read = 0;
        while (bytes_read < len) {
            size_t chunk_size = std::min<size_t>(len - bytes_read, 64*1024*1024);
            DWORD chunk_read = 0;
            BOOL result = ReadFile(fp_win32, reinterpret_cast<char*>(ptr) + bytes_read, chunk_size, &chunk_read, NULL);
            if (!result) {
                throw std::runtime_error(format("read error: %s", GetErrorMessageWin32(GetLastError()).c_str()));
            }
            if (chunk_read < chunk_size || chunk_read == 0) {
                throw std::runtime_error("unexpectedly reached end of file");
            }

            bytes_read += chunk_read;




    

        }
    }

    uint32_t read_u32() const {
        uint32_t val;
        read_raw(&val, sizeof(val));
        return val;
    }

    void write_raw(const void * ptr, size_t len) const {
        size_t bytes_written = 0;
        while (bytes_written < len) {
            size_t chunk_size = std::min<size_t>(len - bytes_written, 64*1024*1024);
            DWORD chunk_written = 0;
            BOOL result = WriteFile(fp_win32, reinterpret_cast<char const*>(ptr) + bytes_written, chunk_size, &chunk_written, NULL);
            if (!result) {
                throw std::runtime_error(format("write error: %s", GetErrorMessageWin32(GetLastError()).c_str()));
            }
            if (chunk_written < chunk_size || chunk_written == 0) {
                throw std::runtime_error("unexpectedly failed to write bytes");
            }

            bytes_written += chunk_written;
        }
    }

    void write_u32(uint32_t val) const {
        write_raw(&val, sizeof(val));
    }

    ~impl() {
        if (fp) {
            std::fclose(fp);
        }
    }
#else
    impl(const char * fname, const char * mode) {
        fp = ggml_fopen(fname, mode);
        if (fp == NULL) {
            throw std::runtime_error(format("failed to open %s: %s", fname, strerror(errno)));
        }
        seek(0, SEEK_END);
        size = tell();
        seek(0, SEEK_SET);
    }

    size_t tell() const {
// TODO: this ifdef is never true?
#ifdef _WIN32




    

        __int64 ret = _ftelli64(fp);
#else
        long ret = std::ftell(fp);
#endif
        if (ret == -1) {
            throw std::runtime_error(format("ftell error: %s", strerror(errno)));
        }

        return (size_t) ret;
    }

    void seek(size_t offset, int whence) const {
// TODO: this ifdef is never true?
#ifdef _WIN32
        int ret = _fseeki64(fp, (__int64) offset, whence);
#else
        int ret = std::fseek(fp, (long) offset, whence);
#endif
        if (ret != 0) {
            throw std::runtime_error(format("seek error: %s", strerror(errno)));
        }
    }

    void read_raw(void * ptr, size_t len) const {
        if (len == 0) {
            return;
        }
        errno = 0;
        std::size_t ret = std::fread(ptr, len, 1, fp);
        if (ferror(fp)) {
            throw std::runtime_error(format("read error: %s", strerror(errno)));
        }
        if (ret != 1) {
            throw std::runtime_error("unexpectedly reached end of file");
        }
    }

    uint32_t read_u32() const {
        uint32_t ret;
        read_raw(&ret, sizeof(ret));
        return ret;
    }

    void write_raw(const void * ptr, size_t len) const {
        if




    
 (len == 0) {
            return;
        }
        errno = 0;
        size_t ret = std::fwrite(ptr, len, 1, fp);
        if (ret != 1) {
            throw std::runtime_error(format("write error: %s", strerror(errno)));
        }
    }

    void write_u32(uint32_t val) const {
        write_raw(&val, sizeof(val));
    }

    ~impl() {
        if (fp) {
            std::fclose(fp);
        }
    }
#endif

    FILE * fp;
    size_t size;
};

llama_file::llama_file(const char * fname, const char * mode) : pimpl(std::make_unique(fname, mode)) {}
llama_file::~llama_file() = default;

size_t llama_file::tell() const { return pimpl->tell(); }
size_t llama_file::size() const { return pimpl->size; }

int llama_file::file_id() const {
#ifdef _WIN32
    return _fileno(pimpl->fp);
#else
#if defined(fileno)
    return fileno(pimpl->fp);
#else
    return ::fileno(pimpl->fp);
#endif
#endif
}

void llama_file::seek(size_t offset, int whence) const { pimpl->seek(offset, whence); }
void llama_file::read_raw(void * ptr, size_t len) const { pimpl->read_raw(ptr, len); }

uint32_t llama_file::read_u32() const { return pimpl->read_u32(); }

void llama_file::write_raw(const void * ptr, size_t len) const { pimpl->write_raw(ptr, len); }
void llama_file::write_u32(uint32_t val) const { pimpl->write_u32(val); }

// llama_mmap

struct llama_mmap::impl {
#ifdef _POSIX_MAPPED_FILES
    std::vector<