Question

我需要一个具有大代码段大小的C程序（至少一些MB）我想查看一些行为。

以下是该方案：

运行两个流程：

进程A：具有较大代码段大小的进程在系统RAM中

进程B：它只占用系统RAM（一个简单的malloc + memset）。

注意在内存耗尽之前，进程A的驻留集大小是否减少，或者某些页面是否被刷掉。当我编写一个简单的程序时，代码段大小保持在1页（4KB）的边界内。

Answer 1

如果它可以是汇编而不是C :(使用gnu as）

.text
.space 0x7FFFFFFF

虽然我不建议去那么大

Answer 2

如果你用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 3

在Linux和兼容系统上，你可以使用mmap()来分配一些代码空间，然后用你想要的任何东西填充它（可能只有1 MB NOP s），然后调用它确保它真的被添加到你的代码空间。

Answer 4

受C ++元编程的启发，我想，只需从C程序生成一个大的C源代码。将“max”变量更改为您想要的函数数量。编译并运行此代码时，它将创建一个名为largefile.c的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 5

为什么要编写一个包含大代码段的程序，你可以只借用任何相对较大的开源软件的源代码，它必然会有不错的代码段大小。

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年前提出来的。

如何编写具有大代码段的c程序

6 个答案: