Как написать программу переменного тока, которая имеет большой раздел кода

Question

Мне нужна программа на C, имеющая большой размер сегмента кода (по крайней мере, несколько мегабайт). Я хочу проверить некоторые действия.

Вот сценарий:

Запуск двух процессов:

Процесс A: один с большим размером сегмента кода, находящийся в системной памяти

Процесс B: который просто пожирает системную память (простой malloc + memset).

Обратите внимание, уменьшается ли размер резидентного набора процесса A или некоторые его страницы удаляются или не удаляются до исчерпания памяти.Когда я пишу простую программу, размер сегмента кода остается в пределах 1 страницы (4 КБ).

Answer 1

Если это может быть сборка вместо C: (используя gnu as)

.text
.space 0x7FFFFFFF

хотя я бы не советовал идти таким большим

Answer 2

Почему вы хотите написать программу с большим сегментом кода, вы можете просто позаимствовать исходный код любого относительно большого программного обеспечения с открытым исходным кодом, он обязательно должен иметь приличный размер сегмента кода.

Answer 3

Вдохновленный метапрограммированием на C ++, я подумал, что просто генерирую большой исходный код на C из C-программы.Измените переменную «max» на то, сколько функций вы хотите.Когда вы скомпилируете и запустите этот код, он создаст программу на C с именем largefile.c.Скомпилируйте эту программу с выключенными оптимизациями.Это может быть хорошей идеей также удалить сгенерированные printfs, это зависит от того, что вы хотите сделать, я думаю.Удачи!

#include <stdio.h>

void writefunc(FILE *fp, int i)
{
    fprintf(fp, "void f%d()\n{\n\tprintf(\"%d\\n\");\n\tf%d();\n}\n", i, i, i+1);
}

int main(int argc, char** argv)
{
    FILE *fp = fopen("largecode.c", "w");
    int i;
    int max = 100;

    fprintf(fp, "#include<stdio.h>\n");

    fprintf(fp, "\nint f%d()\n{\n}\n", max + 1);

    for (i = max; i > 0; i--) {
        writefunc(fp, i);
    }

    fprintf(fp, "\nint main(int argc, char** argv){\n\tf1();\n}\n");

    fclose(fp);

    return 0;
}

Answer 4

В Linux и совместимых системах вы, вероятно, могли бы использовать <a href="http://linux.die.net/man/2/mmap" rel="nofollow">mmap()</a> для выделения некоторого кодового пространства, а затем заполнить его тем, что вам нравится (может быть, только 1 МБ <a href="http://en.wikipedia.org/wiki/NOP" rel="nofollow">NOP</a> с), а затем вызвать его, чтобы убедиться, что он действительно добавляется в ваше кодовое пространство.

Answer 5

Если вы пишете на C ++ - я могу посоветовать вам использовать шаблоны.

Например:

template <int i>
struct PlainOfCode
{
    template <int j>
    static int Worker(int x)
    {
        return j ^ (x + i) ^ Worker<j-1>(x+j);
    }

    template <>
    static int Worker<0>(int x) { return x; }

    static int Batch(int x)
    {
        return PlainOfCode<i-1>::Batch(x) ^ Worker<i*i>(x);
    }
};

template <>
struct PlainOfCode<0>
{
    static int Batch(int x)
    {
        return x;
    }
};

// main
int j = PlainOfCode<30>::Batch(GetTickCount());
if (25 != j)
    GetTickCount();

Это генерирует огромное количество неявных функций (и, следовательно, - размер кода).Отключить все оптимизации.

Answer 6

Возможно создание больших разделов повторяющегося кода с использованием макросов. Например, ниже приведена программа на C (также может быть скомпилирована с помощью компилятора c ++) с большим сегментом кода:

volatile int x; // "volatile" to forbid compiler optimization

#define DO_0 ++x;
#define DO_1 {DO_0; DO_0; DO_0; DO_0; DO_0; DO_0; DO_0; DO_0; DO_0; DO_0}
#define DO_2 {DO_1; DO_1; DO_1; DO_1; DO_1; DO_1; DO_1; DO_1; DO_1; DO_1}
#define DO_3 {DO_2; DO_2; DO_2; DO_2; DO_2; DO_2; DO_2; DO_2; DO_2; DO_2}
#define DO_4 {DO_3; DO_3; DO_3; DO_3; DO_3; DO_3; DO_3; DO_3; DO_3; DO_3}
#define DO_5 {DO_4; DO_4; DO_4; DO_4; DO_4; DO_4; DO_4; DO_4; DO_4; DO_4}
#define DO_6 {DO_5; DO_5; DO_5; DO_5; DO_5; DO_5; DO_5; DO_5; DO_5; DO_5}
#define DO_7 {DO_6; DO_6; DO_6; DO_6; DO_6; DO_6; DO_6; DO_6; DO_6; DO_6}
#define DO_8 {DO_7; DO_7; DO_7; DO_7; DO_7; DO_7; DO_7; DO_7; DO_7; DO_7}
#define DO_9 {DO_8; DO_8; DO_8; DO_8; DO_8; DO_8; DO_8; DO_8; DO_8; DO_8}

int main()
{
    DO_6; // do trivial stuff 1 million times
}

Это дает довольно точный контроль над размером сегмента кода. Например, в моей системе размер функции main составляет 15000006 байтов (каждый DO_0 генерирует 15 байтов).

P.S. Просто понял, вопрос был задан 3 года назад.