KSM_Testing/process.c at main · parismita/KSM_Testing · GitHub

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h> // For sysconf
#include <string.h> // For memset
#include <sys/mman.h>
#include <signal.h>
#include <x86intrin.h>
enum TEST_TYPE
{
    ZERO,         // ZERO page
    FIXED,        // complete memory block will made up of fixed character
    FIXED_RANDOM, // every page will have differnt character
    RANDOM        // every char is different allows for minimum page merging
};
volatile sig_atomic_t stop_flag = 0;
void handle_sigint(int signum)
{
    stop_flag = 1;
}
int main(int argc, char **argv)
{
    if (argc < 4)
    {
        printf("Usage: ./process NUM_PAGES NUM_ROUNDS ROUND_WAIT_TIME\n");
        exit(1);
    }

    signal(SIGINT, handle_sigint);

    int NUM_PAGES = atoi(argv[1]);
    int NUM_ROUNDS = atoi(argv[2]);
    int WAIT_TIME = atoi(argv[3]);

    long page_size = sysconf(_SC_PAGESIZE); // Get the system's page size
    if (page_size == -1)
    {
        perror("sysconf");
        return 1;
    }

    size_t pages = NUM_PAGES;
    size_t length = pages * page_size;

    char *addr = (char *)mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (addr == MAP_FAILED)
    {
        perror("mmap");
        return 1;
    }
    // printf("Allocated memory of size %zu bytes (%zu pages)\n", length, pages);

    if (madvise(addr, length, MADV_MERGEABLE) == -1)
    {
        perror("madvise");
        return 1;
    }

    /*
    Fork Multiple Processes here of these kinds, define a memory usage pattern here and check KSM stats.
    */

    int round = 0;
    char c;
    while (!stop_flag && round != NUM_ROUNDS)
    {
        srand(__rdtsc());
        int test_type = RANDOM;
        switch (test_type)
        {
        case ZERO:
            memset(addr, 0, length);
            break;

        case FIXED:
            srand(__rdtsc());
            c = 'A' + rand() % 26;
            memset(addr, c, length);
            break;

        case FIXED_RANDOM:
            srand(__rdtsc());
            // printf("FIXED_RANDOM: ");
            for (int p = 0; p < pages; p++)
            {
                c = 'A' + rand() % 26;
                for (int b = 0; b < page_size; b++)
                {
                    addr[page_size * p + b] = c;
                }
            }
            break;

        case RANDOM:
            // printf("RANDOM: ");
            srand(__rdtsc());
            for (int p = 0; p < pages; p++)
            {
                for (int b = 0; b < page_size; b++)
                {
                    c = 'A' + rand() % 26;
                    addr[page_size * p + b] = c;
                }
            }
            break;
        default:
            break;
        }
        // for (int p = 0; p < 1; p++)
        // {
        //     for (int b = 0; b < 100; b++)
        //     {
        //         printf("%c", addr[page_size * p + b]);
        //     }
        //     printf("\n");
        // }

        sleep(WAIT_TIME);
        round++;
    }
    munmap(addr, length);
    return 0;
}