Shortest program that continuously allocates memory

Question

Write a program which runs forever and allocates more and more memory on the heap the longer it runs, at least until you reach the limit of the operating system on the amount of memory that can be allocated.

Many kernels won't actually reserve memory you allocate until you use it for something, so if your program is in C or some other low level language you'll have to make sure you write something to each page. If you're using an interpreted language, you're probably not going to have to worry about this.

Shortest code wins.

Answer 1

PHP, 14 13 bytes

Saved a byte thanks to Alex Howansky

while($a.=1);

Indefinitely builds a string of 111111111111...

Answer 2

Python REPL, 13 bytes

9
while 1:_*9

The first line, 9, sets the built-in _ (last-integer) variable to 9. The infinite loop then keeps setting this to itself multiplied by 9.

Python integers have no upper limit, so this will keep growing until MemoryError.

This only works in the shell, where the _ variable is available. This is allowed by meta.

Answer 3

Mathematica, 16 bytes

For[i=0,0<1,i++]

Endlessly adds 1 to an arbitrary precision integer, causing its representation in memory to slowly grow.

Might also be the slowest submission since memory allocated only grows logarithmically with time. In fact, I've only let it run to several hundred billion, which barely alters allocated memory. So how do I know it grows without bound? Try the variant

For[i = 1, 0 < 1, i += i]

so that the memory usage is now linear in time... (If you want to watch i,

Monitor[For[i = 1, 0 < 1, i += i], i]

and notice, for instance, that the front end is allocating memory to hold the displayed values faster than the kernel is, because the binary representation is much less fluffy that the decimal representation and resulting graphical object. I suppose one could stress test one's 2D video acceleration by switching to the console interface and running the Monitor[] there... Heh.)

Answer 4

BASH, 2 bytes

$0

Parameter $0 is the filename of the script, so it will call itself forever.

Answer 5

WinDbg, 9 bytes

as/c a z1

This works by creating a string of infinite length. as /c Sets an alias (here called a) to the result of the following command(s): z 1 is an infinite do while loop that also prints a line when the while condition is true: redo [###] {redone_code}. So a will be set to a string like:

redo [1] z1
redo [2] z1
redo [3] z1
.
.
.
redo [23489723984] z1
.
.
.

Answer 6

Actually, 3 bytes

1W1

Try it online!

This is an infinite loop that pushes a 1 to the stack each time it runs. Actually is implemented in Python, and its stack is a deque, so, despite the name, all memory is dynamically allocated on the heap.

Answer 7

Microscript II, 3 bytes

1[s

Rough translation:

x=1
while x
  push x

Answer 8

SAS, 75 19

SAS doesn't really lend itself to golfing but I thought I'd have a go, and at least it beats Java some of the Java answers quite a lot of stuff, actually.

Original submission:

data;dcl hash h();h.definekey('i');h.definedone();a:i+1;h.add();goto a;run;

This creates a hash object and keeps adding new values to it until SAS runs out of memory. None of the hash operations fail prior to that point, so no need to capture any pesky return codes for them. SAS does have do loops, but goto saves a few characters.

New submission:

%macro a;%a%mend;%a

Much simpler - a trivial recursive macro. If left running for long enough, it eventually fails with an out of memory error. Both submissions assume that SAS was invoked with option memsize = 0, otherwise it will instead fail when it hits that limit if it is lower than the available system memory.

Answer 9

Ceylon, 55 54 35 bytes

shared void r(){variable Object x=0;while(0<1){x=[x];}}

This is a simple while loop, which creates a one-element tuple containing the previous value, i.e. an ever-growing linked list.

I get an OutOfMemoryError (with the default JVM settings on my computer) after:

real    5m42.727s
user    21m31.200s
sys     0m3.472s

5m42s (using 21 minutes of processor time, says time).

Even shorter is the "functional" approach (which in effect does exactly the same):

shared void r(){loop<Object>(0)((x)=>[x]).each(noop);}

Unfortunately I need the type parameter here, otherwise Ceylon assumes Integer (which is the type of 0) and complains that [0] is not an Integer.

The second version is much slower (I've let it run overnight):

real    197m26.677s
user    770m9.300s
sys     1m23.744s

A different approach is just filling a really big sequence of integers:

shared void r(){max((1:9^9)*.not);}

1:9^9 is a Measure<Integer> (an Iterable containing 9^9 elements, starting with 1), by itself not having lots of memory (just the two numbers). But the *.not attribute spread creates a big ArraySequence with the value of i.not for each element of the Iterable. We need to do something with the result (otherwise the compiler complains that this is not a statement), therefore the max(...). The max function is never called here, because this gives an OutOfMemoryError (with "GC overhead limit exceeded") after 6 minutes while trying to build and fill the array:

real    6m23.948s
user    23m46.956s
sys     0m5.200s

Answer 10

Labyrinth, 1 byte

_

This keeps pushing a 0 to the stack.

Answer 11

Brain-Flak, 10 bytes

(()){(())}

Try it online!

Answer 12

V, 2 bytes

òé

You can try it online, even though it won't output anything.

This simply fills up the interal "buffer" with the ÿ character (0xFF) until the end of time.

Answer 13

C#, 109 bytes

public class P{static void Main({for(;;)System.Xml.Serialization.XmlSerializer.FromTypes(new[]{typeof(P)});}}

Cross posted from here because it answers this question nicely as well.

We found the idea behind this leak in production code and researching it leads to this article. The main problem is in this long quote from the article (read it for more info):

Searching my code for PurchaseOrder, I find this line of code in page_load of one of my pages XmlSerializer serializer = new XmlSerializer(typeof(PurchaseOrder), new XmlRootAttribute(“”));

This would seem like a pretty innocent piece of code. We create an XMLSerializer for PurchaseOrder. But what happens under the covers?

If we take a look at the XmlSerializer constructor with Reflector we find that it calls this.tempAssembly = XmlSerializer.GenerateTempAssembly(this.mapping, type, defaultNamespace, location, evidence); which generates a temp (dynamic) assembly. So every time this code runs (i.e. every time the page is hit) it will generate a new assembly.

The reason it generates an assembly is that it needs to generate functions for serializing and deserializing and these need to reside somewhere.

Ok, fine… it creates an assembly, so what? When we’re done with it, it should just disappear right?

Well… an assembly is not an object on the GC Heap, the GC is really unaware of assemblies, so it won’t get garbage collected. The only way to get rid of assemblies in 1.0 and 1.1 is to unload the app domain in which it resides.

And therein lies the problem Dr Watson.

Running from the compiler in Visual Studio 2015 and using the Diagnostic Tools Window shows the following results after about 38 seconds. Note the Process memory is steadily climbing and the Garbage Collector (GC) keeps running but can't collect anything.

Answer 14

SMBF, 5 bytes

Although the brainfuck solution also works in SMBF, I decided to create a solution that only works in SMBF.

<[>+]

Since the source is placed on the tape to the left of the pointer, < will move the pointer to point at ], and then we loop, traveling forever on the tape.

Answer 15

Pushy, 3 bytes

1$a

Just keeps pushing to the stack...

1     % Push 1
$     % While last item != 0 (forever):
a     %   Push char-codes of the lowercase alphabet

This is just one example: several 3 byte solutions exist, such as 1$1, 1$&, 9$9, etc - anything that will "infinitely" push to the stack.

Answer 16

tinylisp repl, 12 bytes

(d f(q(L(f L

Defines a function f that will keep allocating memory when called. If submissions must be full programs, here's a 15-byte solution:

((v(d f(q(L(f L

Explanation

The repl supplies missing parens at the end of the line, so the code is really (d f(q(L(f L)))).

(d f(q(...))) defines f to be the unevaluated list (...). In tinylisp, functions are simply two-element lists. The first element is the parameter list and the second is the function body. Here, the first element is L, which (because it's not wrapped in parentheses) makes this a variadic function in which the entire argument list is assigned to L. The function body (f L) simply calls f again with L as its argument.

This is tail recursion, so the call stack doesn't come into play. But notice what happens to L on successive calls:

(f)        Called with no arguments; L gets empty list ()
(f ())     Called with one argument, empty list; L gets (())
(f (()))   Called with one argument, (()); L gets ((()))

And so on, wrapping the argument in another layer of list each time.

Answer 17

Fission, 3 bytes

RX+

Continuously creates atoms and increments its mass.

Try it online!

R                 creates an atom moving right
 X                clones atom, one keeps moving to the right, the other gets reflected left
  +               increment the atom's mass

Because of wrapping, this program will continuously create atoms with non-negative mass

Another alternative:

RX'

R and X works like you expect it to, and ' sets the atom's mass to the ASCII value of the next character it hits, ie 'R' (because of wrapping). Thus, this continuously creates atoms with the ASCII value of 'R'.

Answer 18

Java, 127+19=146

Golfed:

import java.util.*;class A{public static void main(String[]q){List l=new LinkedList();for(;;){String s="";for(int i=0;i>-1;++i)s+=' ';l.add(s);}}}

Ungolfed:

import java.util.*;

public class A {
  public static void main(String[] args) {
    List<String> l = new LinkedList<>();
    for (;;) {
      String s = new String();
      for (int i = 0; i > -1; ++i) {
        s += ' ';
      }
      l.add(s);
    }
  }
}

This program does not rely on the garbage collector or finalize() method like the other Java answers do. Java only interns and merges strings that are constructed from literals, unless specifically interned. That means this program will end up creating strings of size 2³¹ essentially forever, assuming LinkedList works as expected.

Answer 19

PowerShell, 14 bytes

for(){$i+="z"}

Infinite loop creates a variable(string) and appends new characters to the end. Unbearably slow, took over an hour to consume two megabytes. Verified it would consume all the RAM available using something a bit faster: for(){$i+=("z"*9MB)}

Answer 20

Dyalog APL, 4 bytes

⊂⍣≡⍬

⊂ enclose

⍣ until

≡ identical to the previous iteration (i.e. never, as each iteration has one more level of enclosure)

⍬ empty (numeric) list

The program starts as follows:

[], enclose that, yielding

[[]]. Is that identical to []? No, so we enclose that, yielding

[[[]]]. Is that identical to [[]]? No, so we enclose that...

Since each enclosure needs a new pointer, memory usage will slowly increase until WORKSPACE FULL.

Answer 21

SmileBASIC, 18 bytes

@L
A$=A$+@A
GOTO@L

Keeps creating strings consisting of @A@A@A.... It would be much faster to use PUSH to modify the original string, but that would use more characters.

Answer 22

√ å ı ¥ ® Ï Ø ¿ , 3 bytes

(1)

Explanation

(   › Start an infinite loop
 1  › Push 1 to the stack
  ) › End an infinite loop

Answer 23

OIL, 12 bytes

Here in annotated form (remove anything but numbers to run):

1 # copy
-1 # from line -1 (containing, by default, a 0)
6 # to line 6 (the first line after the last line) %
8 # increment
2 # line 2 (marked with %)
6 # goto (since the next line will now be 0, go to line 0)

Even though seemingly nothing changes (lines are 0 by default and are being set to 0), internally, there's a difference between an unallocated line and a line with an explicit 0 in it.

Answer 24

C, 10 bytes

f(x){f();}

The x is needed for memory to be used in addition to stack space. This will endlessly make calls to itself each time taking ~32bits to store x.

Answer 25

Aceto, 2 bytes

e>

Pushes e (2.71..) on the stack, and moves the IP back to the first cell.

There are of course many 2-byte solutions in Aceto, (any single character literal (1234567890ePR'), followed by a command that makes the thing infinite (I can think of <>O, but there might be more), but I chose e> because it looks a bit like a heart (<3 sadly doesn't work).

Answer 26

asm2bf - 15 bytes

@l
psh 1
jmp %l

Will push 1 until the interpreter/system runs out of memory.

Answer 27

Rust, 35 31 bytes

-4 bytes thanks to madlaina (into_raw -> leak)

||loop{Box::leak(Box::new(0));}

Try it online

Full program, 40 bytes

fn main(){loop{Box::leak(Box::new(0));}}

Try it online

Unlike the other Rust solution, this uses Box::leak to leak the boxed value, turning it into a &'static mut i32.

Answer 28

Kotlin, 27 bytes

var o=Any()
while(1>0)o={o}

Stacking functions returning functions.

54 bytes if no .kts: fun main(a:Array<String>){var o=Any();while(1>0)o={o}}

Answer 29

F#, 22 bytes

let rec f x=f(1::x);()

Call it in F# interactive passing an empty list: f []

The function recursively calls itself, adding elements to the list. The tuple at the end is there so that the type inference can determine that the function return type is unit.

Answer 30

BotEngine, 2x3=6

ve<
>e^

Rough translation:

forever:
  enqueue 'e'
  enqueue 'e'