Memory usage doesn't depend on the length of the data.
Try this code:
<?php
var_dump(memory_get_usage()); 
$input = str_pad("", 50000, "foo");
var_dump(memory_get_usage()); 
$input = preg_replace(";foo;", "", $input); 
unset($input); // <------------ !!
var_dump(memory_get_usage());
?>

Your answer is interesting. If I take your example and insert another var_dump() before the unset() command, like this:

<?php
        var_dump(memory_get_usage());
        $input = str_pad("", 50000, "foo");
        var_dump(memory_get_usage());
        $input = preg_replace(";foo;", "", $input);
        var_dump(memory_get_usage());
        unset($input); // <------------ !!
        var_dump(memory_get_usage());


I get these numbers:

$ php test.php
int(15496)
int(65600)
int(115632)
int(15624)

However, there is not benefit in unsetting the return value from preg_replace else I could remove the call to it anyway.

But maybe the example was bad. Take for example, I want to replace 'foo' with 'bar':

<?php
        var_dump(memory_get_usage());
        $input = str_pad("", 50000, "foo");
        var_dump(memory_get_usage());
        $input = preg_replace(";foo;", "bar", $input);
        var_dump(memory_get_usage());


$ php test.php
int(15208)
int(65312)
int(115352)

If I want to further work with the value I have no way of saving memory (I can't really unset the value when I need it).

I also don't quite understand the statement "memory usage doesn't depend on the length of the data". The numbers are certainly different when I use small strings.

This is the same issue as all the other "PHP does not release  memory" reports. The memory reserved is never released during script run. It's released during shutdown.

No doubt. However, the ereg* family of functions does not consume memory in the way the preg* family of functions does. So this is actually a documentation problem it seems, re-cateogrizing.

The pcre extension API (used by preg_*() functions, the new filter extension,..) cache compiled regexes, but since PHP xx (I don't remember the version.. :) ), that cache has a limit.
So memory usage won't grow indefinetely, it will "just" cache 4096 regexes (by default).

I don't think this should be documented. PHP users don't really want to know about internal stuff.

I think PHP users definitely want to now about this. Why should they not want to know? I think it's important to know that the preg_* functions cache the regular expression while ereg don't. Because that means that preg* over ereg* consumes memory in the long term, which, as I i've seen it in real live, became an issue. Since I had this spontanous memory problems I consulted the preg* manual page but nowwhere it wasn't mentioned and I hat to find it out myself which took some time.

Why not shorten other peoples time by documenting it?

This bug has been fixed in the documentation's XML sources. Since the
online and downloadable versions of the documentation need some time
to get updated, we would like to ask you to be a bit patient.

Thank you for the report, and for helping us make our documentation better.