Virtual xotira va sahifalash

#include <stdio.h>
#include <unistd.h>

int main(void) {
    long sahifa = sysconf(_SC_PAGESIZE);

    printf("Sahifa hajmi        : %ld bayt\n", sahifa);
    printf("Kilobaytda          : %ld KB\n", sahifa / 1024);
    printf("4096 baytmi?        : %s\n", sahifa == 4096 ? "ha" : "yo'q");

    /* Sahifa hajmi doim ikkining darajasi */
    printf("Ikkining darajasimi?: %s\n",
           (sahifa & (sahifa - 1)) == 0 ? "ha" : "yo'q");

    /* Manzilning ichki siljishini hisoblash */
    long manzil = 0x12345;
    printf("\n0x12345 manzili uchun:\n");
    printf("  Sahifa raqami : %ld\n", manzil / sahifa);
    printf("  Ichki siljish : %ld\n", manzil % sahifa);

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define SAHIFA   4096
#define SAHIFALAR 4096          /* 16 MB */
#define TAKROR   200

static double olchash(char *xotira, long qadam) {
    struct timespec b, o;
    volatile long yigindi = 0;

    clock_gettime(CLOCK_MONOTONIC, &b);

    for (int t = 0; t < TAKROR; t++) {
        for (long i = 0; i < (long) SAHIFALAR * SAHIFA; i += qadam) {
            yigindi += xotira[i];
        }
    }

    clock_gettime(CLOCK_MONOTONIC, &o);

    return (o.tv_sec - b.tv_sec) + (o.tv_nsec - b.tv_nsec) / 1e9;
}

int main(void) {
    size_t hajm = (size_t) SAHIFALAR * SAHIFA;
    char *xotira = malloc(hajm);

    if (xotira == NULL) {
        return 1;
    }

    for (size_t i = 0; i < hajm; i++) {
        xotira[i] = 1;
    }

    /* Ketma-ket: bitta sahifadan 64 marta o'qiladi */
    double ketma_ket = olchash(xotira, 64);

    /* Sakrab: har safar yangi sahifa - TLB doim yangilanadi */
    double sakrab = olchash(xotira, SAHIFA);

    /* Sakrab variantda 64 barobar kam o'qish bor,
       shunga qaramay u kutilganidek arzon emas */
    double nisbat = ketma_ket / sakrab;

    printf("Ketma-ket o'qish 64 barobar ko'p bayt o'qidi\n");
    printf("Lekin vaqti 64 barobar ko'p emas: %s\n",
           nisbat < 40.0 ? "ha" : "yo'q");
    printf("Sabab - sahifa bo'ylab sakrash TLB ni buzadi\n");

    free(xotira);

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static long rss_kb(void) {
    FILE *f = fopen("/proc/self/status", "r");
    char qator[256];
    long qiymat = -1;

    if (f == NULL) {
        return -1;
    }

    while (fgets(qator, sizeof qator, f) != NULL) {
        if (strncmp(qator, "VmRSS:", 6) == 0) {
            sscanf(qator + 6, "%ld", &qiymat);
            break;
        }
    }

    fclose(f);

    return qiymat;
}

int main(void) {
    long oldin = rss_kb();

    size_t hajm = 512L * 1024 * 1024;      /* 512 MB */
    char *katta = malloc(hajm);

    if (katta == NULL) {
        return 1;
    }

    long sorovdan_keyin = rss_kb();

    /* Endi haqiqatan tegib chiqamiz */
    for (size_t i = 0; i < hajm; i += 4096) {
        katta[i] = 1;
    }

    long tegishdan_keyin = rss_kb();

    printf("512 MB so'raldi, lekin hali tegilmadi:\n");
    printf("  RSS o'sishi 10 MB dan kammi? %s\n",
           sorovdan_keyin - oldin < 10 * 1024 ? "ha" : "yo'q");

    printf("Har bir sahifaga tegildi:\n");
    printf("  RSS o'sishi 400 MB dan ko'pmi? %s\n",
           tegishdan_keyin - sorovdan_keyin > 400 * 1024 ? "ha" : "yo'q");

    free(katta);

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <sys/resource.h>

int main(void) {
    struct rusage r;

    getrusage(RUSAGE_SELF, &r);
    long yumshoq_oldin = r.ru_minflt;
    long qattiq_oldin  = r.ru_majflt;

    size_t hajm = 64L * 1024 * 1024;       /* 64 MB */
    char *xotira = malloc(hajm);

    if (xotira == NULL) {
        return 1;
    }

    for (size_t i = 0; i < hajm; i += 4096) {
        xotira[i] = 1;
    }

    getrusage(RUSAGE_SELF, &r);
    long yumshoq_keyin = r.ru_minflt;
    long qattiq_keyin  = r.ru_majflt;

    long farq = yumshoq_keyin - yumshoq_oldin;
    long kutilgan = (long) (hajm / 4096);

    printf("64 MB ga tegildi = %ld ta sahifa\n", kutilgan);
    printf("Yumshoq sahifa xatolari kamida shuncha bo'ldimi? %s\n",
           farq >= kutilgan / 2 ? "ha" : "yo'q");
    printf("Bu yerda qattiq (diskli) xato bo'ldimi? %s\n",
           qattiq_keyin - qattiq_oldin > 0 ? "ha" : "yo'q");

    free(xotira);

    return 0;
}

/usr/bin/time -v ./dastur 2>&1 | grep -i faults

    Major (requiring I/O) page faults: 0
    Minor (reclaiming a frame) page faults: 16891

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

int main(void) {
    size_t hajm = 64L * 1024 * 1024;       /* 64 MB */
    char *xotira = malloc(hajm);

    if (xotira == NULL) {
        return 1;
    }

    memset(xotira, 'A', hajm);             /* haqiqatan RAM da */

    fflush(stdout);                        /* fork dan oldin shart! */

    pid_t bola = fork();

    if (bola < 0) {
        return 1;
    }

    if (bola == 0) {
        /* Bola faqat o'qiydi - nusxa olinmaydi */
        printf("Bola: birinchi belgi = %c\n", xotira[0]);

        /* Endi yozamiz - shu sahifaning nusxasi olinadi */
        xotira[0] = 'B';
        printf("Bola: o'zgartirdi -> %c\n", xotira[0]);

        fflush(stdout);                    /* _exit bufer tozalamaydi */
        _exit(0);
    }

    wait(NULL);

    printf("Ota: qiymat o'zgardimi? %s\n", xotira[0] == 'A' ? "yo'q" : "ha");
    printf("Ota: birinchi belgi = %c\n", xotira[0]);

    free(xotira);

    return 0;
}

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

int main(void) {
    /* MAP_SHARED - fork dan keyin ham umumiy qoladi */
    int *umumiy = mmap(NULL, 4096,
                       PROT_READ | PROT_WRITE,
                       MAP_SHARED | MAP_ANONYMOUS, -1, 0);

    /* MAP_PRIVATE - copy-on-write bo'ladi */
    int *shaxsiy = mmap(NULL, 4096,
                        PROT_READ | PROT_WRITE,
                        MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

    if (umumiy == MAP_FAILED || shaxsiy == MAP_FAILED) {
        return 1;
    }

    umumiy[0] = 100;
    shaxsiy[0] = 100;

    fflush(stdout);

    pid_t bola = fork();

    if (bola < 0) {
        return 1;
    }

    if (bola == 0) {
        umumiy[0] = 999;
        shaxsiy[0] = 999;
        _exit(0);
    }

    wait(NULL);

    printf("MAP_SHARED  qiymati : %d\n", umumiy[0]);
    printf("MAP_PRIVATE qiymati : %d\n", shaxsiy[0]);
    printf("Bola o'zgarishi ko'rindimi? shared=%s private=%s\n",
           umumiy[0] == 999 ? "ha" : "yo'q",
           shaxsiy[0] == 999 ? "ha" : "yo'q");

    munmap(umumiy, 4096);
    munmap(shaxsiy, 4096);

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <setjmp.h>
#include <sys/mman.h>
#include <unistd.h>

static sigjmp_buf sakrash;

static void segv_ishlovchi(int signal) {
    (void) signal;
    siglongjmp(sakrash, 1);
}

int main(void) {
    long sahifa = sysconf(_SC_PAGESIZE);

    char *xotira = mmap(NULL, (size_t) sahifa,
                        PROT_READ | PROT_WRITE,
                        MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

    if (xotira == MAP_FAILED) {
        return 1;
    }

    xotira[0] = 'X';
    printf("Yozish mumkin: %c\n", xotira[0]);

    /* Endi faqat o'qishga o'tkazamiz */
    mprotect(xotira, (size_t) sahifa, PROT_READ);

    printf("O'qish hali ham mumkin: %c\n", xotira[0]);

    signal(SIGSEGV, segv_ishlovchi);

    if (sigsetjmp(sakrash, 1) == 0) {
        xotira[0] = 'Y';                   /* SIGSEGV qo'zg'atadi */
        printf("Yozish o'tdi - kutilmagan\n");
    } else {
        printf("Yozishga urinish SIGSEGV berdi - himoya ishladi\n");
    }

    munmap(xotira, (size_t) sahifa);

    return 0;
}