CODEWITHSUNDEEP
c
Ashish
Ashish

Reputation: 569

How to write a c program which has a large code section

I need to have a C program having a large code segment size (at least some MB) I want to check out some behavior.

Here is the scenario :

Run two processes:

Process A: One having a large code segment size resided in the system RAM

Process B: which just eats up the system RAM ( a simple malloc+memset ).

Notice whether the resident set size of the process A decreases or some of its pages are swiped out or not before the exhaustion of the memory. When I write a simple program the code segment size remains within the boundary of 1 page (4KB).

Upvotes: 2

Views: 1347

Answers (6)

anatolyg
anatolyg

Reputation: 28279

It is possible to generate large sections of repetitive code using macros. For example, the following is a C program (can also be compiled with a c++ compiler) with a large code segment:

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
}

This gives a pretty precise control on the size of the code segment. For example, on my system the size of the main function is 15000006 bytes (each DO_0 generates 15 bytes).

P.S. Just realized the question was asked 3 years ago.

Upvotes: 0

Saurabh
Saurabh

Reputation: 1069

Why do you want to write a program with large code segment, you can just borrow source code of any relatively large open source software, it is bound to have decent code segment size.

Upvotes: 1

cthom06
cthom06

Reputation: 9635

If it can be assembly instead of C: (using gnu as)

.text
.space 0x7FFFFFFF

though i wouldn't recommend going quite so large

Upvotes: 2

Prof. Falken
Prof. Falken

Reputation: 24897

Inspired by the C++ meta programming, I figured, just generate a large C source code from a C program. Change the "max" variable to how many functions you want. When you compile and run this code, it will create a C program called largefile.c. Compile this program, with optimizations turned off. It might be a good idea to remove the generated printfs too, it depends on what you want to do I guess. Good luck!

#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;
}

Upvotes: 1

unwind
unwind

Reputation: 399949

On Linux and compatible systems, you could probably use mmap() to allocate some code-space, and then fill it with whatever you feel like (maybe just 1 MB of NOPs), then call it to make sure it really gets added to your code space.

Upvotes: 1

valdo
valdo

Reputation: 12943

If you write in C++ - I can advise you using templates.

For example:

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();

This generates enormous implicit function count (and hence - code size). Disable all the optimizations.

Upvotes: 1

Related Questions