+-------------------------------+ 0xFFFFFFFFFFFFFFFF (64-bit)
|       Kernel Space            |  內(nèi)核空間，用于操作系統(tǒng)內(nèi)核和內(nèi)核模塊
+-------------------------------+ 0x00007FFFFFFFFFFF
|       User Space              |  用戶空間進程的虛擬地址空間
|       Shared Libraries        |  動態(tài)加載的共享庫 (.so 文件)
+-------------------------------+ 0x00007FFFC0000000
|       Heap                    |  動態(tài)內(nèi)存分配區(qū)域 (malloc, calloc, realloc)
|       (malloc, etc.)          |  堆的大小可以動態(tài)增長或收縮
+-------------------------------+ 0x00007FFFB0000000
|       BSS Segment             |  未初始化的全局變量和靜態(tài)變量
|       (Uninitialized Data)    |  在程序啟動時被初始化為零
+-------------------------------+ 0x00007FFFA0000000
|       Data Segment            |  已初始化的全局變量和靜態(tài)變量
|       (Initialized Data)      |  在程序啟動時被初始化為特定的值
+-------------------------------+ 0x00007FFF90000000
|       Text Segment            |  可執(zhí)行代碼段
|       (Code)                  |  通常是只讀的，以防止代碼被意外修改
+-------------------------------+ 0x00007FFF80000000
|       Stack                   |  用于存儲函數(shù)調(diào)用的局部變量、參數(shù)和返回地址
|                               |  棧通常從高地址向低地址增長
+-------------------------------+ 0x0000000000000000

+-------------------------------+
| task_struct (/bin/gonzo)      |
|                               |
|   mm                          |
|   |                           |
|   v                           |
| +---------------------------+ |
| | mm_struct                 | |
| |                           | |
| |   mmap                    | |
| |   |                       | |
| |   v                       | |
| | +-----------------------+ | |
| | | vm_area_struct        | | |
| | | VM_READ | VM_EXEC     | | |
| | |-----------------------| | |
| | | Text (file-backed)    | | |
| | +-----------------------+ | |
| |   |                       | |
| |   v                       | |
| | +-----------------------+ | |
| | | vm_area_struct        | | |
| | | VM_READ | VM_WRITE    | | |
| | |-----------------------| | |
| | | Data (file-backed)    | | |
| | +-----------------------+ | |
| |   |                       | |
| |   v                       | |
| | +-----------------------+ | |
| | | vm_area_struct        | | |
| | | VM_READ | VM_WRITE    | | |
| | |-----------------------| | |
| | | BSS (anonymous)       | | |
| | +-----------------------+ | |
| |   |                       | |
| |   v                       | |
| | +-----------------------+ | |
| | | vm_area_struct        | | |
| | | VM_READ | VM_WRITE    | | |
| | |-----------------------| | |
| | | Heap (anonymous)      | | |
| | +-----------------------+ | |
| |   |                       | |
| |   v                       | |
| | +-----------------------+ | |
| | | vm_area_struct        | | |
| | | VM_READ | VM_EXEC     | | |
| | |-----------------------| | |
| | | Memory mapping        | | |
| | +-----------------------+ | |
| |   |                       | |
| |   v                       | |
| | +-----------------------+ | |
| | | vm_area_struct        | | |
| | | VM_READ | VM_WRITE    | | |
| | | VM_GROWS_DOWN         | | |
| | |-----------------------| | |
| | | Stack (anonymous)     | | |
| | +-----------------------+ | |
| +---------------------------+ |+-------------------------------+

#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/resource.h>
#include <stdio.h>
#include <time.h>

const int64_t GB = 1024 * 1024 * 1024; 
const int64_t MB = 1024 * 1024; 
const int64_t KB = 1024; 

void max_rss() {
    struct rusage r_usage;
    getrusage(RUSAGE_SELF, &r_usage);
    printf("Current max rss %ld kb, pagefault minor %ld, major %ld\n", 
        r_usage.ru_maxrss, r_usage.ru_minflt, r_usage.ru_majflt);
}

int main() {
    printf("Pid %lu\n", getpid());
    int number = 128;
    void *ptr =  malloc(number * MB);
    if (ptr == 0) {
        printf("Out of memory\n");
        exit(EXIT_FAILURE);
    }
    printf("Allocated %d MB memory by malloc(3), ptr %p\n", number, ptr);
    max_rss();
    sleep(60);
    memset(ptr, 0, number * MB);
    printf("Used %d MB memory by memset(3)\n", number);
    max_rss();
    sleep(60);
    free(ptr);
    printf("Memory ptr %p freed by free(3)\n", ptr);
    max_rss();
    sleep(60);
    return 0;
}

Pid 932451
Allocated 128 MB memory by malloc(3), ptr 0x7f3e6cdff010
Current max rss 3800 kb, pagefault minor 122, major 0
Used 128 MB memory by memset(3)
Current max rss 132732 kb, pagefault minor 187, major 0
Memory ptr 0x7f3e6cdff010 freed by free(3)Current max rss 132732 kb, pagefault minor 187, major 0

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/shm.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

#define FILE_SIZE (4 * 1024 * 1024) // 4 MiB
#define ANON_SIZE (8 * 1024 * 1024) // 8 MiB
#define SHM_SIZE (10 * 1024 * 1024) // 10 MiB

void allocate_filepages() {
    int fd = open("tempfile", O_RDWR | O_CREAT | O_TRUNC, 0600);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    if (ftruncate(fd, FILE_SIZE) == -1) {
        perror("ftruncate");
        close(fd);
        exit(EXIT_FAILURE);
    }

    void *file_mem = mmap(NULL, FILE_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (file_mem == MAP_FAILED) {
        perror("mmap");
        close(fd);
        exit(EXIT_FAILURE);
    }

    memset(file_mem, 0, FILE_SIZE); // 使用內(nèi)存

    printf("Allocated %d MiB of file-mapped memory\n", FILE_SIZE / (1024 * 1024));

    // 保持映射，直到程序結(jié)束
    // munmap(file_mem, FILE_SIZE);
    // close(fd);
    // unlink("tempfile");
}

void allocate_anonpages() {
    void *anon_mem = malloc(ANON_SIZE);
    if (anon_mem == NULL) {
        perror("malloc");
        exit(EXIT_FAILURE);
    }

    memset(anon_mem, 0, ANON_SIZE); // 使用內(nèi)存

    printf("Allocated %d MiB of anonymous memory\n", ANON_SIZE / (1024 * 1024));
  // free(anno_mem);
}

void allocate_shmempages() {
    int shmid = shmget(IPC_PRIVATE, SHM_SIZE, IPC_CREAT | 0600);
    if (shmid == -1) {
        perror("shmget");
        exit(EXIT_FAILURE);
    }

    void *shm_mem = shmat(shmid, NULL, 0);
    if (shm_mem == (void *)-1) {
        perror("shmat");
        shmctl(shmid, IPC_RMID, NULL);
        exit(EXIT_FAILURE);
    }

    memset(shm_mem, 0, SHM_SIZE); // 使用內(nèi)存
    printf("Allocated %d MiB of shared memory\n", SHM_SIZE / (1024 * 1024));

    // 保持映射，直到程序結(jié)束
    // shmdt(shm_mem);
    // shmctl(shmid, IPC_RMID, NULL);
}

int main() {
    printf("Process %d\n", getpid());

    allocate_filepages();
    allocate_anonpages();
    allocate_shmempages();

    sleep(3600);

    return 0;
}

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND                                                                   
3881259 root      20   0   28540  24184  15872 S   0.0   0.1   0:00.01 a.out

....
VmRSS:       24184 kB
RssAnon:            8312 kB
RssFile:            5632 kB
RssShmem:          10240 kB
VmData:     8436 kB
VmStk:       132 kB
VmExe:         4 kB
VmLib:      1576 kB
VmPTE:       100 kB
VmSwap:        0 kB
....

/sys/fs/cgroup/memory/kubepods/burstable/pod<uid>/<container-id>

/memory/kubepods/besteffort/pod<uid>/<container-id>

/sys/fs/cgroup/memory/kubepods/pod<uid>/<container-id>

root@memory-0:~# ls /sys/fs/cgroup/memory/kubepods/burstable/pod2d08e58b-50f7-41fa-bd42-946402c34646/b366c08f2ecedd6acdb38e4ec24913aea0ca3babeed297abbcfafafa4e8027de
cgroup.clone_children         memory.bind_blkio               memory.kmem.tcp.max_usage_in_bytes  memory.memsw.max_usage_in_bytes  memory.pressure              memory.usage_in_bytes
cgroup.event_control          memory.failcnt                  memory.kmem.tcp.usage_in_bytes      memory.memsw.usage_in_bytes      memory.pressure_level        memory.use_hierarchy
cgroup.priority               memory.force_empty              memory.kmem.usage_in_bytes          memory.move_charge_at_immigrate  memory.priority_wmark_ratio  memory.use_priority_oom
cgroup.procs                  memory.kmem.failcnt             memory.limit_in_bytes               memory.numa_stat                 memory.sli                   memory.vmstat
memory.alloc_bps              memory.kmem.limit_in_bytes      memory.max_usage_in_bytes           memory.oom.group                 memory.sli_max               notify_on_release
memory.async_distance_factor  memory.kmem.max_usage_in_bytes  memory.meminfo                      memory.oom_control               memory.soft_limit_in_bytes   tasks
memory.async_high             memory.kmem.slabinfo            memory.meminfo_recursive            memory.pagecache.current         memory.stat
memory.async_low              memory.kmem.tcp.failcnt         memory.memsw.failcnt                memory.pagecache.max_ratio       memory.swappiness
memory.async_ratio            memory.kmem.tcp.limit_in_bytes  memory.memsw.limit_in_bytes         memory.pagecache.reclaim_ratio   memory.sync

static const unsigned int memcg1_stats[] = {
  MEMCG_CACHE,
  MEMCG_RSS,
  MEMCG_RSS_HUGE,
  NR_SHMEM,
  NR_FILE_MAPPED,
  NR_FILE_DIRTY,
  NR_WRITEBACK,
  MEMCG_SWAP,
};

static void mem_cgroup_charge_statistics(struct mem_cgroup *memcg,
           struct page *page,
           bool compound, int nr_pages)
{
  /*
   * Here, RSS means 'mapped anon' and anon's SwapCache. Shmem/tmpfs is
   * counted as CACHE even if it's on ANON LRU.
   */
  if (PageAnon(page))
    __mod_memcg_state(memcg, MEMCG_RSS, nr_pages);
  else {
    __mod_memcg_state(memcg, MEMCG_CACHE, nr_pages);
    if (PageSwapBacked(page))
      __mod_memcg_state(memcg, NR_SHMEM, nr_pages);
  }
  ....
}

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>

#define BUFFER_SIZE 4096
#define FILE_SIZE_MB 100

void generate_page_cache(const char *filename) {
    int fd;
    char buffer[BUFFER_SIZE];
    ssize_t bytes_written, bytes_read;
    size_t total_bytes_written = 0;

    // 初始化緩沖區(qū)
    for (int i = 0; i < BUFFER_SIZE; i++) {
        buffer[i] = 'A' + (i % 26); // 填充緩沖區(qū)以生成一些數(shù)據(jù)
    }

    // 打開文件進行寫操作
    fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    // 寫入文件，直到文件大小達到 FILE_SIZE_MB
    while (total_bytes_written < FILE_SIZE_MB * 1024 * 1024) {
        bytes_written = write(fd, buffer, BUFFER_SIZE);
        if (bytes_written == -1) {
            perror("write");
            close(fd);
            exit(EXIT_FAILURE);
        }
        total_bytes_written += bytes_written;
    }

    // 關(guān)閉文件
    close(fd);
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <filename>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    generate_page_cache(argv[1]);

    printf("Page cache generated for file: %s\n", argv[1]);

    return 0;
}

 # sync && echo 3 > /proc/sys/vm/drop_caches

# free -m
               total        used        free      shared  buff/cache   available
Mem:           32096        2470       29742         872        1152       29626
Swap:              0           0           0
# cat /proc/meminfo
...
Buffers:            4760 kB
Cached:          1096448 kB
SwapCached:            0 kB
Active:           766032 kB
Inactive:        1263964 kB
Active(anon):     590144 kB
Inactive(anon):  1231776 kB
Active(file):     175888 kB
Inactive(file):    32188 kB

# ./a.out cache.txt 
Page cache generated for file: cache.txt
# free -m
               total        used        free      shared  buff/cache   available
Mem:           32096        2469       29640         872        1256       29627
Swap:              0           0           0

# cat /proc/meminfo 
Buffers:            5116 kB
Cached:          1199444 kB
SwapCached:            0 kB
Active:           766652 kB
Inactive:        1366800 kB
Active(anon):     590216 kB
Inactive(anon):  1231776 kB
Active(file):     176436 kB
Inactive(file):   135024 kB

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <string.h>

#define FILE_SIZE (100 * 1024 * 1024) // 100 MiB

void read_file(const char *filename) {
    int fd = open(filename, O_RDONLY);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    char *buffer = malloc(FILE_SIZE);
    if (buffer == NULL) {
        perror("malloc");
        close(fd);
        exit(EXIT_FAILURE);
    }

    ssize_t bytes_read = read(fd, buffer, FILE_SIZE);
    if (bytes_read == -1) {
        perror("read");
        free(buffer);
        close(fd);
        exit(EXIT_FAILURE);
    }

    printf("Read %zd bytes from file\n", bytes_read);

    free(buffer);
    close(fd);
}

int main() {
    const char *filename = "testfile";

    // 創(chuàng)建一個測試文件
    int fd = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0600);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    if (ftruncate(fd, FILE_SIZE) == -1) {
        perror("ftruncate");
        close(fd);
        exit(EXIT_FAILURE);
    }

    char *file_mem = mmap(NULL, FILE_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (file_mem == MAP_FAILED) {
        perror("mmap");
        close(fd);
        exit(EXIT_FAILURE);
    }

    memset(file_mem, 'A', FILE_SIZE); // 初始化文件內(nèi)容
    munmap(file_mem, FILE_SIZE);
    close(fd);

    // 第一次讀取文件內(nèi)容
    read_file(filename);

    // 第二次讀取文件內(nèi)容
    read_file(filename);

    return 0;
}

# cat /proc/meminfo 
Buffers:            4000 kB
Cached:          1108280 kB
SwapCached:            0 kB
Active:           778248 kB
Inactive:        1274056 kB
Active(anon):     599416 kB
Inactive(anon):  1241900 kB
Active(file):     178832 kB
Inactive(file):    32156 kB

# ./a.out
Read 104857600 bytes from file
Read 104857600 bytes from file
# cat /proc/meminfo 
Buffers:            6340 kB
Cached:          1215868 kB
SwapCached:            0 kB
Active:           884284 kB
Inactive:        1277620 kB
Active(anon):     599088 kB
Inactive(anon):  1241900 kB
Active(file):     285196 kB
Inactive(file):    35720 kB

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>

#define ONE_GIB (1024 * 1024 * 1024)
#define EIGHT_TENTHS_GIB (0.8 * ONE_GIB)
#define ONE_HUNDRED_MIB (100 * 1024 * 1024)
#define ONE_FIFTY_MIB (150 * 1024 * 1024)
#define FILE_PATH "/root/test.txt"

void allocate_memory(size_t size) {
    char *buffer = (char *)malloc(size);
    if (buffer == NULL) {
        perror("malloc");
        exit(EXIT_FAILURE);
    }
    memset(buffer, 0, size);
}

void create_file(const char *filename, size_t size) {
    int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    char *buffer = (char *)malloc(size);
    if (buffer == NULL) {
        perror("malloc");
        close(fd);
        exit(EXIT_FAILURE);
    }

    // Fill the buffer with random data
    for (size_t i = 0; i < size; i++) {
        buffer[i] = rand() % 256;
    }

    if (write(fd, buffer, size) != size) {
        perror("write");
        free(buffer);
        close(fd);
        exit(EXIT_FAILURE);
    }

    free(buffer);
    close(fd);
}

void read_file(const char *filename, size_t size) {
    FILE *file = fopen(filename, "r");
    if (file == NULL) {
        perror("fopen");
        exit(EXIT_FAILURE);
    }

    char *buffer = (char *)malloc(size);
    if (buffer == NULL) {
        perror("malloc");
        fclose(file);
        exit(EXIT_FAILURE);
    }

    fread(buffer, 1, size, file);
    fclose(file);
    free(buffer);
}

int main() {
    printf("Allocating 0.8 GiB of RSS memory...\n");
    allocate_memory(EIGHT_TENTHS_GIB);
    printf("Waiting for 3 minutes...\n");
    sleep(180);

    printf("Creating a 100 MiB file with random data...\n");
    create_file(FILE_PATH, ONE_HUNDRED_MIB);
    printf("Waiting for 3 minutes...\n");
    sleep(180);

    printf("Reading 100 MiB from the file to generate pagecache...\n");
    read_file(FILE_PATH, ONE_HUNDRED_MIB);

    printf("Waiting for 3 minutes...\n");
    sleep(180);

    printf("Trying to allocate 150 MiB of memory...\n");
    allocate_memory(ONE_FIFTY_MIB);
    printf("Successfully allocated 150 MiB of memory.\n");

    sleep(3600);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>

#define FILE_PATH "/root/test.txt"
#define FILE_SIZE (100 * 1024 * 1024) // 100 MiB

void create_file(const char *filename, size_t size) {
    int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    char *buffer = (char *)malloc(size);
    if (buffer == NULL) {
        perror("malloc");
        close(fd);
        exit(EXIT_FAILURE);
    }

    // Fill the buffer with 'A'
    memset(buffer, 'A', size);

    if (write(fd, buffer, size) != size) {
        perror("write");
        free(buffer);
        close(fd);
        exit(EXIT_FAILURE);
    }

    free(buffer);
    close(fd);
}

int main() {
    // Step 1: Create a 100 MiB file with 'A'
    printf("Creating a 100 MiB file with 'A'...\n");
    create_file(FILE_PATH, FILE_SIZE);

    // Step 2: Open the file for reading and writing
    int fd = open(FILE_PATH, O_RDWR);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    // Step 3: Memory-map the file
    char *mapped = (char *)mmap(NULL, FILE_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (mapped == MAP_FAILED) {
        perror("mmap");
        close(fd);
        exit(EXIT_FAILURE);
    }
    // Step 4: Modify the file content through the memory-mapped region
    printf("Modifying the file content to 'B'...\n");
    memset(mapped, 'B', FILE_SIZE);
    printf("File content successfully modified to 'B'.\n");

    sleep(240);
    // Step 5: Clean up
    if (munmap(mapped, FILE_SIZE) == -1) {
        perror("munmap");
    }
    close(fd);

    return 0;
}

...
VmRSS:    103932 kB
...

struct vm_area_struct {
    struct file * vm_file;      /* File we map to (can be NULL). */
    unsigned long vm_pgoff;     /* Offset (within vm_file) in PAGE_SIZE */
}

# df -h
Filesystem                Size      Used Available Use% Mounted on
overlay                  49.1G      2.7G     46.4G   5% /
tmpfs                     8.0G         0      8.0G   0% /data

#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>

#define SHM_SIZE 36 * 1024 * 1024  // 36 MiB

int main() {
    key_t key = ftok("shmfile", 65);  // 生成一個唯一的key
    int shmid = shmget(key, SHM_SIZE, 0666 | IPC_CREAT);  // 創(chuàng)建共享內(nèi)存段

    if (shmid == -1) {
        perror("shmget failed");
        exit(1);
    }

    char *data = (char *)shmat(shmid, (void *)0, 0);  // 連接到共享內(nèi)存段

    if (data == (char *)(-1)) {
        perror("shmat failed");
        exit(1);
    }

    // 寫入數(shù)據(jù)到共享內(nèi)存
    strcpy(data, "Hello, this is a message from the writer process!");

    printf("Data written to shared memory: %s\n", data);

    sleep(3600); 

    // 斷開連接
    if (shmdt(data) == -1) {
        perror("shmdt failed");
        exit(1);
    }

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>

#define SHM_SIZE 36 * 1024 * 1024  // 36 MiB

int main() {
    key_t key = ftok("shmfile", 65);  // 生成一個唯一的key
    int shmid = shmget(key, SHM_SIZE, 0666);  // 獲取共享內(nèi)存段

    if (shmid == -1) {
        perror("shmget failed");
        exit(1);
    }

    char *data = (char *)shmat(shmid, (void *)0, 0);  // 連接到共享內(nèi)存段

    if (data == (char *)(-1)) {
        perror("shmat failed");
        exit(1);
    }

    // 讀取共享內(nèi)存中的數(shù)據(jù)
    printf("Data read from shared memory: %s\n", data);

    sleep(3600); 
    // 斷開連接
    if (shmdt(data) == -1) {
        perror("shmdt failed");
        exit(1);
    }

    // 刪除共享內(nèi)存段
    if (shmctl(shmid, IPC_RMID, NULL) == -1) {
        perror("shmctl failed");
        exit(1);
    }

    return 0;
}

# ipcs -m
------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
...
0xffffffff 7          root       666        37748736   2

package main

import (
        "fmt"
        "syscall"
        "time"
)

func main() {
        // 調(diào)用 getrusage 系統(tǒng)調(diào)用
        var usage syscall.Rusage
        err := syscall.Getrusage(syscall.RUSAGE_SELF, &usage)
        if err != nil {
                fmt.Printf("Error getting resource usage: %v\n", err)
                return
        }

        // 打印資源使用情況
        fmt.Printf("User CPU time used: %+v \n", usage.Utime)
        fmt.Printf("System CPU time used: %+v \n", usage.Stime)
        fmt.Printf("Maximum resident set size: %v \n", usage.Maxrss)
        fmt.Printf("Integral shared memory size: %v \n", usage.Ixrss)
        fmt.Printf("Integral unshared data size: %v \n", usage.Idrss)
        fmt.Printf("Integral unshared stack size: %v \n", usage.Isrss)
        fmt.Printf("Page reclaims (soft page faults): %v\n", usage.Minflt)
        fmt.Printf("Page faults (hard page faults): %v\n", usage.Majflt)
        fmt.Printf("Swaps: %v\n", usage.Nswap)
        fmt.Printf("Block input operations: %v\n", usage.Inblock)
        fmt.Printf("Block output operations: %v\n", usage.Oublock)
        fmt.Printf("IPC messages sent: %v\n", usage.Msgsnd)
        fmt.Printf("IPC messages received: %v\n", usage.Msgrcv)
        fmt.Printf("Signals received: %v\n", usage.Nsignals)
        fmt.Printf("Voluntary context switches: %v\n", usage.Nvcsw)
        fmt.Printf("Involuntary context switches: %v\n", usage.Nivcsw)

        // 模擬一些 CPU 負載
        for i := 0; i < 1e8; i++ {
                _ = i * i
        }

        time.Sleep(2 * time.Second)

        // 再次調(diào)用 getrusage 系統(tǒng)調(diào)用
        err = syscall.Getrusage(syscall.RUSAGE_SELF, &usage)
        if err != nil {
                fmt.Printf("Error getting resource usage: %v\n", err)
                return
        }

        // 打印資源使用情況
        fmt.Printf("\nAfter sleep:\n")
        fmt.Printf("User CPU time used: %+v \n", usage.Utime)
        fmt.Printf("System CPU time used: %+v \n", usage.Stime)
        fmt.Printf("Maximum resident set size: %v \n", usage.Maxrss)
        fmt.Printf("Integral shared memory size: %v \n", usage.Ixrss)
        fmt.Printf("Integral unshared data size: %v \n", usage.Idrss)
        fmt.Printf("Integral unshared stack size: %v \n", usage.Isrss)
        fmt.Printf("Page reclaims (soft page faults): %v\n", usage.Minflt)
        fmt.Printf("Page faults (hard page faults): %v\n", usage.Majflt)
        fmt.Printf("Swaps: %v\n", usage.Nswap)
        fmt.Printf("Block input operations: %v\n", usage.Inblock)
        fmt.Printf("Block output operations: %v\n", usage.Oublock)
        fmt.Printf("IPC messages sent: %v\n", usage.Msgsnd)
        fmt.Printf("IPC messages received: %v\n", usage.Msgrcv)
        fmt.Printf("Signals received: %v\n", usage.Nsignals)
        fmt.Printf("Voluntary context switches: %v\n", usage.Nvcsw)
        fmt.Printf("Involuntary context switches: %v\n", usage.Nivcsw)
}

100 * container_memory_working_set_bytes{container="$container", pod="$pod", namespace="$namespace"}
/ kube_pod_container_resource_limits{resource="memory", container="$container", pod="$pod", namespace="$namespace"} %

workingSet := ret.Memory.Usage
if v, ok := s.MemoryStats.Stats[inactiveFileKeyName]; ok {
    ret.Memory.TotalInactiveFile = v
    if workingSet < v {
       workingSet = 0
    } else {
       workingSet -= v
    }
}
ret.Memory.WorkingSet = workingSet