# 查看当前实例所有 Slab Class
echo "stats slabs" | nc localhost 11211 | grep -E "chunk_size|chunks_per_page"

# 更平缓的增长（factor=1.1）
memcached -f 1.1 -n 48 -m 64
# → 更多 Slab Class，更小的 chunk 大小差异，减少内部碎片

# 更陡峭的增长（factor=2.0）
memcached -f 2.0 -n 48 -m 64
# → 更少 Slab Class，chunk 大小差异大，可能浪费更多空间

# Slab 统计
echo "stats slabs" | nc localhost 11211

# STAT 1:chunk_size 96
# STAT 1:chunks_per_page 10922
# STAT 1:total_pages 5           ← 分配了 5 个 Page (5MB)
# STAT 1:total_chunks 54610      ← 总 chunk 数
# STAT 1:used_chunks 1234        ← 已使用 chunk 数
# STAT 1:free_chunks 53376       ← 空闲 chunk 数
# STAT 1:free_chunks_end 0       ← Page 末尾空闲 chunk
# STAT 1:mem_requested 114504    ← 用户请求的实际字节数
# STAT 1:get_hits 10000
# STAT 1:cmd_set 5000
# STAT 1:delete_hits 200
# STAT 1:incr_hits 100
# STAT 1:decr_hits 50
# STAT 1:cas_hits 30
# STAT 1:cas_badval 5

# 全局 Slab 统计
# STAT active_slabs 15           ← 活跃的 Slab Class 数
# STAT total_malloced 16777216   ← 总分配内存 (16MB)

# 理论内存 = total_chunks * chunk_size
# 实际使用 = mem_requested
# 利用率 = mem_requested / (total_chunks * chunk_size) * 100%

echo "stats slabs" | nc localhost 11211

#!/usr/bin/env python3
"""计算 Memcached 内存利用率"""
import socket

def get_slab_stats(host='localhost', port=11211):
    s = socket.socket()
    s.connect((host, port))
    s.send(b'stats slabs\r\n')
    data = b''
    while True:
        chunk = s.recv(4096)
        data += chunk
        if b'END\r\n' in chunk:
            break
    s.close()
    return data.decode()

def analyze():
    raw = get_slab_stats()
    slabs = {}
    for line in raw.split('\r\n'):
        if line.startswith('STAT ') and ':' in line:
            parts = line.split()
            key, value = parts[1], parts[2]
            class_id, prop = key.split(':', 1)
            if class_id not in slabs:
                slabs[class_id] = {}
            slabs[class_id][prop] = int(value)

    total_mem = 0
    total_requested = 0
    print(f"{'Class':>6} {'chunk':>8} {'pages':>6} {'used':>8} {'req(B)':>10} {'util%':>7}")
    print("-" * 55)
    for cid in sorted(slabs.keys(), key=int):
        s = slabs[cid]
        if 'chunk_size' not in s:
            continue
        cs = s['chunk_size']
        tp = s.get('total_pages', 0)
        uc = s.get('used_chunks', 0)
        mr = s.get('mem_requested', 0)
        alloc = tp * 1048576  # pages * 1MB
        util = (mr / alloc * 100) if alloc > 0 else 0
        total_mem += alloc
        total_requested += mr
        print(f"{cid:>6} {cs:>8} {tp:>6} {uc:>8} {mr:>10} {util:>6.1f}%")

    print("-" * 55)
    overall = (total_requested / total_mem * 100) if total_mem > 0 else 0
    print(f"{'Total':>6} {'':>8} {'':>6} {'':>8} {total_requested:>10} {overall:>6.1f}%")

if __name__ == '__main__':
    analyze()

# 查看默认参数下的 Slab 分配
memcached -h | grep -A 50 "slab"
# 或
slab calc  # 某些发行版提供的独立工具

#!/usr/bin/env python3
"""Slab Calculator - 预估 Slab 分配"""

def calc_slabs(factor=1.25, min_size=48, max_size=1048576, max_bytes=67108864):
    """
    计算 Slab Class 分配情况
    factor: 增长因子
    min_size: 最小 item 空间 (bytes)
    max_size: 最大 chunk (1MB)
    max_bytes: 总内存 (默认 64MB)
    """
    item_overhead = 48  # Item 头部开销
    align = 8           # 8 字节对齐

    # 计算 Slab Class 1 的 chunk 大小
    size = max(96, (min_size + item_overhead + align - 1) & ~(align - 1))

    classes = []
    while size <= max_size:
        chunks_per_page = max_size // size
        classes.append({
            'class': len(classes) + 1,
            'chunk_size': size,
            'chunks_per_page': chunks_per_page,
        })
        # 下一个 Slab Class 的 chunk 大小
        size = int(size * factor)
        size = (size + align - 1) & ~(align - 1)

    print(f"参数: factor={factor}, min_size={min_size}, total={max_bytes/1048576}MB")
    print(f"Slab Class 数量: {len(classes)}")
    print()
    print(f"{'Class':>6} {'chunk_size':>12} {'chunks/page':>12} {'适用 Value':>14}")
    print("-" * 50)

    for c in classes:
        cs = c['chunk_size']
        cpp = c['chunks_per_page']
        # 估算适用的 Value 大小范围
        max_val = cs - item_overhead
        print(f"{c['class']:>6} {cs:>10}B {cpp:>12} {max_val:>10}B")

# 不同 factor 对比
calc_slabs(factor=1.25)
print()
calc_slabs(factor=1.10)

# 启用 Slab 重分配
memcached -o slab_reassign,slab_automove

# 手动触发 Slab 迁移
# (通过 stats 命令不直接支持，需要通过 meta 协议或工具)

# 查看 Slab 迁移统计
echo "stats slabs" | nc localhost 11211 | grep -E "reassign|automove"
# STAT slab_reassign_running 0
# STAT slabs_moved 42        ← 已迁移的 Page 数

# 自动迁移（保守模式）
memcached -o slab_automove=1

# 自动迁移（激进模式，每次迁移更多 Page）
memcached -o slab_automove=2

# 好的做法：Value 大小集中在 1-2 个 Slab Class
# 例如：缓存的用户信息都在 200-250B 之间
# → 主要使用 Slab Class 5 (chunk=240B)

# 不好的做法：Value 大小差异极大
# 10B 到 500KB 随机分布
# → 大量 Slab Class，碎片严重

# Value 大小分布均匀时，使用较小的 factor
memcached -f 1.10 -m 4096

# Value 大小差异大时，保持默认
memcached -f 1.25 -m 4096

# 如果你的 Key 较长（如 UUID + 前缀）
# 计算最小 item 大小: 48(头部) + key_len + 8(后缀) + value_len
# 调整 -n 参数避免落入过大的 Slab Class

# 例: key 平均 40B, value 平均 20B → 总需 116B
# 使用 -n 68 使最小 chunk 覆盖此场景
memcached -n 68 -f 1.25

#!/bin/bash
# 监控 Slab 分布，发现碎片问题
while true; do
    echo "=== $(date) ==="
    echo "stats slabs" | nc localhost 11211 | grep -E "chunk_size|used_chunks|total_chunks|mem_requested"
    sleep 60
done

# 启用自动 Slab 迁移
memcached -o slab_automove,slab_reassign