第42周：性能优化专项

字数统计: 3k字   |   阅读时长≈ 14分

第42周：性能优化专项

目标：系统掌握高性能网络编程的优化技巧：NUMA 亲和性、SIMD 指令、零拷贝技术，能够对负载均衡器的关键路径做极致优化。

1. NUMA 架构与亲和性

1.1 NUMA 基础

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
NUMA（Non-Uniform Memory Access）：

  现代多核 CPU 通常是 NUMA 架构：

  ┌─────────────────────────────────────────┐
  │            机器                            │
  │                                           │
  │  ┌─────────────────┐  ┌─────────────────┐│
  │  │  NUMA Node 0   │  │  NUMA Node 1   ││
  │  │  ┌────┐  ┌────┐ │  │  ┌────┐  ┌────┐││
  │  │  │CPU0│  │CPU1│ │  │  │CPU2│  │CPU3│││
  │  │  └─┬──┘  └─┬──┘ │  │  └─┬──┘  └─┬──┘││
  │  │    │  QPI/UPI │   │  │  │  QPI/UPI │  ││
  │  │    └────┬─────┘   │  │  └────┬─────┘  ││
  │  │    本地内存       │  │    本地内存       ││
  │  │    (DDR)         │  │    (DDR)         ││
  │  └─────────────────┘  └─────────────────┘│
  │         ↕ 互联 (QPI/UPI)                 │
  └─────────────────────────────────────────┘

访问特性：
  - 本地内存：~100ns
  - 远程内存：~140-200ns
  - 远程内存可降低 30-50% 性能

1.2 NUMA 感知编程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// numa_aware.c — NUMA 感知编程
#include <numa.h>
#include <numaif.h>

// === 初始化 NUMA 库 ===
if (numa_available() == -1) {
    fprintf(stderr, "NUMA not available\n");
    return 1;
}

// 获取 NUMA 拓扑
int num_nodes = numa_num_configured_nodes();
int num_cpus = numa_num_configured_cpus();

printf("System: %d NUMA nodes, %d CPUs\n", num_nodes, num_cpus);

// === 内存分配：本地 NUMA ===

// 方式 1：libnuma
void *p = numa_alloc_onnode(1024 * 1024, 0);  // 在 NUMA 0 分配 1MB
// ... 使用 ...
numa_free(p, 1024 * 1024);

// 方式 2：numa_run_on_node 绑定线程
numa_run_on_node(0);  // 限制线程到 NUMA 0

// 方式 3：mbind
unsigned long nodemask = 1UL << 0;  // NUMA 0
mbind(p, size, MPOL_BIND, &nodemask, max_nodes, MPOL_MF_MOVE);

1.3 DPDK 中的 NUMA

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// DPDK 中：所有 mbuf 池在本地 NUMA 分配

// 1. 获取当前 lcore 的 NUMA 节点
unsigned int socket_id = rte_socket_id();  // 当前 NUMA node

// 2. 在本地 NUMA 分配 mbuf 池
mbuf_pool = rte_pktmbuf_pool_create("MBUF", 8192, 256, 0,
                                      RTE_MBUF_DEFAULT_BUF_SIZE,
                                      socket_id);  // ← 本地 socket

// 3. 网卡可能在另一个 NUMA 节点
// 查看网卡所属 NUMA
cat /sys/class/net/<nic>/device/numa_node
// 0 或 1

1.4 跨 NUMA 访问的性能问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
跨 NUMA 访问场景：

  场景 1：CPU 0 处理包，但 mbuf pool 在 NUMA 1
    - 每次 mbuf 操作要跨 NUMA 访问内存
    - 性能下降 30-50%

  场景 2：CPU 0 处理包，但收包网卡在 NUMA 1
    - 网卡中断送到 CPU 0（不匹配）
    - 性能下降 20-30%

  优化：
    - mbuf 池在 mbuf 被使用的 NUMA 节点
    - 中断亲和性到使用网卡的 NUMA
    - 避免跨 NUMA 数据结构

2. SIMD 指令优化

2.1 SIMD 基础

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
SIMD（Single Instruction Multiple Data）：

  SSE（Streaming SIMD Extensions）：128-bit
    - XMM 寄存器 16 个
    - 整数/浮点

  AVX（Advanced Vector Extensions）：256-bit
    - YMM 寄存器

  AVX-512：512-bit
    - ZMM 寄存器
    - 掩码寄存器

  NEON（ARM）：128-bit

  在网络包处理中应用：
    - 校验和计算（XOR + 加法）
    - 内存拷贝（memcpy 加速）
    - 数据比较
    - 加密 / 解密
    - 哈希计算

2.2 SIMD 校验和

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
// simd_checksum.c — 使用 SSE/AVX 加速 IP 校验和
#include <immintrin.h>

// 传统实现
static uint16_t cksum_traditional(const void *data, int len) {
    const uint16_t *p = data;
    uint32_t sum = 0;
    for (int i = 0; i < len / 2; i++) {
        sum += p[i];
        if (sum > 0xFFFF)
            sum = (sum & 0xFFFF) + (sum >> 16);
    }
    if (len & 1) {
        sum += ((const uint8_t *)data)[len - 1];
    }
    return ~sum;
}

// SSE 优化版本
static uint16_t cksum_sse(const void *data, int len) {
    const __m128i *p = (const __m128i *)data;
    __m128i sum128 = _mm_setzero_si128();
    __m128i ones = _mm_set1_epi16(0xFFFF);

    int n128 = len / 16;
    for (int i = 0; i < n128; i++) {
        __m128i d = _mm_loadu_si128(&p[i]);
        // 8 个 16-bit 加法
        sum128 = _mm_add_epi16(sum128, d);
    }

    // 处理剩余
    int remaining = len % 16;
    const uint16_t *p16 = (const uint16_t *)((const uint8_t *)data + n128 * 16);
    while (remaining >= 2) {
        sum128 = _mm_add_epi16(sum128, _mm_cvtsi32_si128(*p16));
        p16++;
        remaining -= 2;
    }
    if (remaining) {
        sum128 = _mm_add_epi16(sum128, _mm_cvtsi32_si128(*(const uint8_t *)p16));
    }

    // 水平求和
    sum128 = _mm_add_epi16(sum128, _mm_srli_si128(sum128, 8));
    sum128 = _mm_add_epi16(sum128, _mm_srli_si128(sum128, 4));
    sum128 = _mm_add_epi16(sum128, _mm_srli_si128(sum128, 2));

    int sum = _mm_extract_epi16(sum128, 0);
    return ~((uint16_t)sum + (sum >> 16));
}

// AVX2 优化版本（处理 256-bit）
static uint16_t cksum_avx2(const void *data, int len) {
    const __m256i *p = (const __m256i *)data;
    __m256i sum256 = _mm256_setzero_si256();

    int n256 = len / 32;
    for (int i = 0; i < n256; i++) {
        __m256i d = _mm256_loadu_si256(&p[i]);
        sum256 = _mm256_add_epi16(sum256, d);
    }

    // ... 收尾 ...
}

2.3 SIMD 内存操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// SIMD 内存拷贝
static inline void *memcpy_simd(void *dst, const void *src, size_t n) {
    if (n >= 64) {
        // AVX-512 一次复制 64 字节
        while (n >= 64) {
            __m512i d = _mm512_loadu_si512((const __m512i *)src);
            _mm512_storeu_si512((__m512i *)dst, d);
            src = (const char *)src + 64;
            dst = (char *)dst + 64;
            n -= 64;
        }
    }

    // 尾部用普通 memcpy
    return memcpy(dst, src, n);
}

// SIMD 数据比较
static int memcmp_simd(const void *a, const void *b, size_t n) {
    const __m256i *va = (const __m256i *)a;
    const __m256i *vb = (const __m256i *)b;

    size_t n256 = n / 32;
    for (size_t i = 0; i < n256; i++) {
        __m256i xa = _mm256_loadu_si256(&va[i]);
        __m256i xb = _mm256_loadu_si256(&vb[i]);
        __m256i cmp = _mm256_cmpeq_epi8(xa, xb);
        int mask = _mm256_movemask_epi8(cmp);
        if (mask != 0xFFFFFFFF) return 1;  // 不等
    }
    return 0;
}

2.4 DPDK 校验和

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// DPDK 已经使用 SSE/AVX 优化

#include <rte_ip.h>

// IPv4 校验和（使用 SSE）
rte_ipv4_cksum(ip_hdr);

// TCP/UDP 校验和（使用 SSE）
rte_ipv4_udptcp_cksum(ip_hdr, l4_hdr);

// 查看 DPDK 是否启用 AVX/AVX2
cat /proc/cpuinfo | grep -E 'avx|avx2|avx512'

// 编译时优化
gcc -O3 -mavx2 -march=native ...

2.5 实践：CRC32 SIMD 优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
// CRC32 SIMD 加速
#include <immintrin.h>
#include <nmmintrin.h>  // SSE4.2 CRC32

// 使用硬件 CRC32C 指令
uint32_t crc32c_hw(uint32_t crc, const void *data, size_t len) {
    const uint8_t *p = (const uint8_t *)data;
    size_t i = 0;

    // 对齐到 8 字节
    while (len > 0 && (uintptr_t)(p + i) % 8 != 0) {
        crc = _mm_crc32_u8(crc, p[i]);
        i++;
        len--;
    }

    // 8 字节批量
    while (len >= 8) {
        uint64_t v = *(const uint64_t *)(p + i);
        crc = _mm_crc32_u64(crc, v);
        i += 8;
        len -= 8;
    }

    // 尾部
    while (len > 0) {
        crc = _mm_crc32_u8(crc, p[i]);
        i++;
        len--;
    }

    return crc;
}

// SSE4.2 CRC32 性能：10-20 GB/s
// 传统：1-2 GB/s
// 提升 10x

3. 零拷贝技术

3.1 零拷贝方法概览

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
常见零拷贝方法：

1. mmap + write
   - 用户空间 mmap 文件
   - 内核直接发送
   - 适合：文件传输

2. sendfile
   - 完全内核态
   - 文件 → socket
   - 适合：Web 服务器静态文件

3. splice
   - 内核管道
   - 文件 ↔ socket
   - 适合：代理

4. tee
   - 管道 ↔ 管道
   - 用于数据复制

5. MSG_ZEROCOPY
   - send/write 标志
   - 内核态完成数据发送
   - 减少用户态等待

6. io_uring
   - 异步 I/O
   - 零拷贝提交

7. DPDK memif / IVSHMEM
   - 大页共享内存
   - 进程间零拷贝

3.2 sendfile 实践

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// sendfile.c — 零拷贝文件传输
#include <sys/sendfile.h>

void send_file(int out_fd, int in_fd, off_t *offset, size_t count) {
    ssize_t sent;
    while (count > 0) {
        sent = sendfile(out_fd, in_fd, offset, count);
        if (sent < 0) {
            if (errno == EINTR) continue;  // 被信号打断
            if (errno == EAGAIN) continue;  // 非阻塞
            perror("sendfile");
            break;
        }
    }
}

// 使用
int file_fd = open("large_file.bin", O_RDONLY);
struct stat st;
fstat(file_fd, &st);
off_t offset = 0;
send_file(conn_fd, file_fd, &offset, st.st_size);

3.3 splice 实践

1
2
3
4
5
6
7
8
9
10
11
// splice.c — 用 splice 在两个 socket 间零拷贝
#include <fcntl.h>

// splice 旧式 API（已废弃但仍可用）
ssize_t splice(int fd_in, loff_t *off_in,
               int fd_out, loff_t *off_out,
               size_t len, unsigned int flags);

// 推荐：使用 sendfile 或 MSG_ZEROCOPY
ssize_t send(int sockfd, const void *buf, size_t len, int flags);
// flags = MSG_ZEROCOPY | MSG_MORE

3.4 MSG_ZEROCOPY 实践

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// zerocopy_send.c — 使用 MSG_ZEROCOPY
#include <sys/socket.h>

// 注册 zerocopy 通知
int enable_zerocopy(int fd) {
    int val = 1;
    if (setsockopt(fd, SOL_SOCKET, SO_ZEROCOPY, &val, sizeof(val)) < 0) {
        perror("SO_ZEROCOPY");
        return -1;
    }
    return 0;
}

// 发送
int send_zerocopy(int fd, const void *buf, size_t len) {
    ssize_t n;
    while (1) {
        n = send(fd, buf, len, MSG_ZEROCOPY);
        if (n < 0) {
            if (errno == EAGAIN) continue;
            if (errno == ENOBUFS) {
                // 等待通知
                sleep(1);
                continue;
            }
            return -1;
        }
        return n;
    }
}

// 必须读取通知
// 方式 1：epoll
// 方式 2：recvmsg with MSG_ERRQUEUE

3.5 DPDK memif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
DPDK memif（共享内存网络接口）：

  进程 A                    进程 B
  ┌─────────┐              ┌─────────┐
  │ DPDK    │              │ DPDK    │
  │ 应用    │              │ 应用    │
  └────┬────┘              └────┬────┘
       │                        │
  ┌────▼────────────────────────▼────┐
  │      共享 hugepage 内存            │
  │      (memif 协议)                  │
  └────────────────────────────────────┘

  - 零拷贝
  - 进程间通信
  - 高吞吐（100M+ pps）
1
2
3
4
5
6
7
8
9
10
11
12
// DPDK memif 客户端（使用 DPDK memif API）
struct rte_memif_socket_dev *dev;

// 初始化 memif socket
rte_memif_socket_init(&config, &socket, name);

// 连接到对端
rte_memif_connect(&dev, &socket, name, role);

// 收发包
rte_memif_rx_burst(dev, pkts, BURST_SIZE);
rte_memif_tx_burst(dev, pkts, BURST_SIZE);

4. 内存优化

4.1 Cache Line 对齐

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// cache_align.c
#define CACHE_LINE_SIZE 64

// 防止 false sharing
struct per_cpu_data {
    __attribute__((aligned(CACHE_LINE_SIZE)))
    uint64_t counter;
    char pad[CACHE_LINE_SIZE - sizeof(uint64_t)];
};

// 跨多个 cache line 分散不同 lcore 写
struct shared_state {
    char pad0[CACHE_LINE_SIZE];
    int lcore_0_data;
    char pad1[CACHE_LINE_SIZE - sizeof(int)];

    int lcore_1_data;
    char pad2[CACHE_LINE_SIZE - sizeof(int)];
};

4.2 预取优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// prefetch.c — 预取示例
#include <x86intrin.h>

// 在处理当前包时预取下一个包
void process_burst(struct rte_mbuf **pkts, int nb_pkts) {
    for (int i = 0; i < nb_pkts; i++) {
        // 预取下一个 mbuf 的数据到 L1
        if (i + 1 < nb_pkts) {
            rte_prefetch0(rte_pktmbuf_mtod(pkts[i+1], void *));
        }

        // 预取下下一个到 L2
        if (i + 2 < nb_pkts) {
            rte_prefetch1(rte_pktmbuf_mtod(pkts[i+2], void *));
        }

        // 处理当前包
        do_something(pkts[i]);
    }
}

4.3 内存池优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// 减少 malloc/free
// 使用对象池

struct mbuf_pool {
    void *free_list;  // 空闲对象链表
    int count;
    pthread_mutex_t lock;
};

void *pool_alloc(struct mbuf_pool *p) {
    pthread_mutex_lock(&p->lock);
    if (p->free_list == NULL) {
        pthread_mutex_unlock(&p->lock);
        return NULL;
    }
    void *obj = p->free_list;
    p->free_list = *(void **)obj;
    p->count--;
    pthread_mutex_unlock(&p->lock);
    return obj;
}

void pool_free(struct mbuf_pool *p, void *obj) {
    pthread_mutex_lock(&p->lock);
    *(void **)obj = p->free_list;
    p->free_list = obj;
    p->count++;
    pthread_mutex_unlock(&p->lock);
}

5. 锁优化

5.1 锁类型对比

锁类型 适用 性能
pthread_mutex 通用 中等
spinlock 短临界区 快（忙等）
rwlock 读多写少 读快写慢
seqlock 极少写 读极快
RCU 极少写多读 读无开销
lock-free 性能关键 最快但复杂

5.2 Per-CPU 计数器（无锁）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// per_cpu_counter.c
#include <rte_per_lcore.h>

struct counter {
    uint64_t value;  // 64-bit，写原子
} __rte_cache_aligned;

// Per-CPU 计数器
RTE_DEFINE_PER_LCORE(struct counter, my_counter);

void inc_local_counter(void) {
    RTE_PER_LCORE(my_counter).value++;
}

uint64_t get_total_counter(void) {
    uint64_t total = 0;
    unsigned int lcore_id;
    RTE_LCORE_FOREACH(lcore_id) {
        total += RTE_PER_LCORE(my_counter).value;
    }
    return total;
}

5.3 DPDK 无锁队列

1
2
3
4
5
6
7
8
9
10
// DPDK rte_ring 是无锁队列
// 多生产者/多消费者并发安全

// 入队（无锁 CAS）
int rte_ring_enqueue_bulk(struct rte_ring *r, void **objs,
                          unsigned int n);

// 出队
int rte_ring_dequeue_burst(struct rte_ring *r, void **objs,
                            unsigned int n);

6. 编译优化

6.1 GCC 优化选项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# === 编译选项 ===

# 基本优化
-O2          # 平衡（推荐）
-O3          # 更激进（可能导致意外）
-Ofast       # O3 + 不严格的标准

# 目标 CPU 优化
-march=native    # 当前 CPU 全部指令集
-march=skylake   # 指定架构
-mtune=native    # 调整代码以优化当前 CPU

# 数学/科学
-ffast-math      # 浮点优化

# 调试
-O0 -g         # 调试版本
-fno-omit-frame-pointer  # 保留栈帧指针（perf 必需）

# 优化
-funroll-loops      # 循环展开
-finline-functions  # 内联
-ffunction-sections # 每个函数单独段（链接器优化）
-fdata-sections
-Wl,--gc-sections   # 死代码消除

# 实际推荐
gcc -O3 -march=native -mtune=native \
    -funroll-loops -ffunction-sections -fdata-sections \
    -fno-omit-frame-pointer \
    -o lb lb.c -lpthread

6.2 链接时优化（LTO）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# === LTO：跨文件优化 ===

# 编译时
gcc -O3 -flto -c a.c
gcc -O3 -flto -c b.c

# 链接
gcc -O3 -flto -o prog a.o b.o

# 优点：
#   - 跨函数优化
#   - 内联跨文件
#   - 死代码消除

# DPDK 默认启用

6.3 Profile-Guided Optimization (PGO)

1
2
3
4
5
6
7
8
9
10
11
12
13
# === PGO：基于 profile 优化 ===

# 1. 编译插桩版本
gcc -O3 -fprofile-generate -o prog_inst prog.c

# 2. 运行典型负载
./prog_inst < workload
# 生成 *.gcda 文件

# 3. 用 profile 重新编译
gcc -O3 -fprofile-use -o prog_opt prog.c

# 收益：5-15% 性能提升

7. 性能调优清单

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# === CPU 调优 ===
# 隔离 CPU
isolcpus=2-7 nohz_full=2-7 rcu_nocbs=2-7

# 性能模式
cpupower frequency-set -g performance

# === 内存调优 ===
# 大页
echo 4096 > /proc/sys/vm/nr_hugepages
mount -t hugetlbfs none /mnt/huge

# NUMA 平衡
echo 0 > /proc/sys/kernel/numa_balancing

# === 网络调优 ===
# 队列
sysctl net.core.somaxconn=65535
sysctl net.ipv4.tcp_max_syn_backlog=65535

# 缓冲区
sysctl net.core.rmem_max=16777216
sysctl net.core.wmem_max=16777216

# 端口
sysctl net.ipv4.ip_local_port_range="1024 65535"

# TIME_WAIT
sysctl net.ipv4.tcp_tw_reuse=1
sysctl net.ipv4.tcp_fin_timeout=15

# === 网卡调优 ===
# ring buffer
ethtool -G eth0 rx 4096 tx 4096

# 巨型帧
ip link set eth0 mtu 9000

# 中断亲和性
echo 1 > /proc/irq/45/smp_affinity  # 网卡中断到 CPU 0

# Offload
ethtool -K eth0 tso on gso on gro on tx on rx on

8. 实战：AVX 加速 CRC 校验

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
// crc_simd.c — SSE4.2 CRC32C 加速（用于 iSCSI、NVMe、SCTP 等）
#include <nmmintrin.h>
#include <stdint.h>

uint32_t crc32c_sse42(uint32_t crc, const void *data, size_t len) {
    const uint8_t *p = (const uint8_t *)data;

    // 对齐到 8 字节
    while (len > 0 && ((uintptr_t)p & 7)) {
        crc = _mm_crc32_u8(crc, *p++);
        len--;
    }

    // 8 字节批量
    while (len >= 8) {
        uint64_t v;
        memcpy(&v, p, 8);
        crc = _mm_crc32_u64(crc, v);
        p += 8;
        len -= 8;
    }

    // 4 字节
    if (len >= 4) {
        uint32_t v;
        memcpy(&v, p, 4);
        crc = _mm_crc32_u32(crc, v);
        p += 4;
        len -= 4;
    }

    // 2 字节
    if (len >= 2) {
        uint16_t v;
        memcpy(&v, p, 2);
        crc = _mm_crc32_u16(crc, v);
        p += 2;
        len -= 2;
    }

    // 1 字节
    if (len > 0) {
        crc = _mm_crc32_u8(crc, *p);
    }

    return crc;
}

// 性能对比（单核）：
//   传统 CRC32: 1-2 GB/s
//   SSE4.2: 10-20 GB/s
//   提升 10x

9. 性能优化建议优先级

1
2
3
4
5
6
7
8
9
10
11
12
13
按收益从高到低：

1. CPU 隔离 + 大页 + 性能模式（30-50% 提升）
2. NUMA 本地化（20-30% 提升）
3. 批处理 burst size（10-20% 提升）
4. 缓存对齐 + 预取（10-15% 提升）
5. SIMD 优化（5-10% 提升）
6. 锁竞争优化（5-10% 提升）
7. 零拷贝（特定场景 50%+ 提升）
8. 编译器优化（3-5% 提升）
9. PGOLTO（5-10% 提升）

总收益：1.5-2x（从默认配置到完全优化）
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、Linux开发、
公众号开发、开源爱好者、Linux

联系QQ:562054870