12
$\begingroup$

This may be a duplicate (if so I will remove this), but I was having trouble finding the relevant bit of documentation to fix it. I noticed that my FrontEnd memory use was growing out of control when I was repeatedly using Image on data, even if the image was being deleted shortly after being generated.

As a minimal example:

Image[RandomReal[{0, 1}, {2000, 2000, 3}]]

Every time this line is executed, FrontEnd RAM use (as measured by both MemoryInUse[$FrontEnd] and an external profiler) jumps by 120MB, even though the previous image is deleted every time the line is re-executed. I assume this means the images are being invisibly stored somewhere inside the frontend, but I have been having trouble finding out exactly where, and as a result I keep having to quit and restart the application because memory use keeps ballooning out of control.

I glanced through $FrontEnd // Options but didn't see anything obviously related. A similar problem regarding Rasterize was discussed here; I don't know if that is related or not. In any case, my question is:

  • Where are the images being invisibly stored?

  • How do I turn off this behavior?

Edit: Belisarius says this does not occur on his WinXP Mathematica 9. I am using Mac OSX 10.6 Mathematica 10. Can anyone else chime in with OS, version number, and whether you observed the effect? Alexey Popkov has suggested that this may be from data storage introduced by V10's multiple undo feature.

Improve this question
$\endgroup$
5
  • 2
    $\begingroup$ In v.8.0.4 there are only 2 jumps, then the output of MemoryInUse[$FrontEnd] increases by 1 Mb or less. Probably it is a consequence of new-in-v10 UNDO functionality... $\endgroup$
    – Alexey Popkov
    Nov 6, 2014 at 16:56
  • 1
    $\begingroup$ @AlexeyPopkov: Brand New Mathematica V11 Feature: Single Undo™! Also, you're probably right. Hitting undo retrieves the old images. Is there an "undo length setting"? $\endgroup$
    – DumpsterDoofus
    Nov 6, 2014 at 17:00
  • 1
    $\begingroup$ I am also on OSX and MMa v10 and I am really annoyed to have noticed this now. $\endgroup$
    – gpap
    Nov 6, 2014 at 17:00
  • $\begingroup$ @DumpsterDoofus It looks like your question could be reformulated as: Is there a way to restrict the UNDO history lenght? $\endgroup$
    – Alexey Popkov
    Nov 6, 2014 at 17:04
  • 1
    $\begingroup$ On the plus side, I have found the 2014 equivalent of watching a computer defrag by running Dynamic[Refresh[MemoryInUse[$FrontEnd], UpdateInterval -> 1]] and re-evaluating your image code over and over and over while I watch the memory fade away byte by byte. "Will it ever stop?" I ask myself. $\endgroup$
    – gpap
    Nov 6, 2014 at 17:08

2 Answers 2

Reset to default
10
$\begingroup$

NOTE: I forgot about this. Apparently, the following should (presumably) be the way to change these settings, but the actual feature has not been implemented yet.

You can change this using UndoOptions. To go back to version 9 behavior, use this:

SetOptions[EvaluationNotebook[], UndoOptions -> {"MaxLength" -> 1, "RememberEvaluations" -> False}]

See the other options in the documentation for finer control.

Improve this answer
$\endgroup$
4
  • $\begingroup$ This is going to sound completely crazy, but even after restarting Mathematica, executing SetOptions[EvaluationNotebook[], UndoOptions -> {"MaxLength" -> 1, "RememberEvaluations" -> False}], and retrying the above random image generation, I still have multiple undo! It still remembers every evaluation output. Executing CurrentValue[ EvaluationNotebook[], {UndoOptions, "RememberEvaluations"}] yields False, so something seems very wrong. $\endgroup$
    – DumpsterDoofus
    Nov 6, 2014 at 17:40
  • $\begingroup$ @DumpsterDoofus See the note I added at the top. $\endgroup$
    – rm -rf ♦
    Nov 6, 2014 at 17:58
  • $\begingroup$ Oops, you're right. Hopefully this gets fixed in the next release. $\endgroup$
    – DumpsterDoofus
    Nov 6, 2014 at 18:57
  • $\begingroup$ Well, you asked for Undo didn't you? $\endgroup$
    – Dr. belisarius
    Nov 7, 2014 at 2:37
1
$\begingroup$

It doesn't seem to happen on Mma v9 WinXP. The Virtual size increases, but only once:

Initial state:

Mathematica graphics

After generating one image:

Mathematica graphics

After deleting the first image from the front end:

Mathematica graphics

After generating a second image:

Mathematica graphics

After deleting the second image:

Mathematica graphics

Improve this answer
$\endgroup$
4
  • $\begingroup$ Wow, that's weird. How about MemoryInUse[$FrontEnd]? Does that also stay the same? On my Mac OSX 10.6 V10, MemoryInUse[$FrontEnd] increases 120MB every time I execute the line and delete the resulting image (currently approaching 2GB). $\endgroup$
    – DumpsterDoofus
    Nov 6, 2014 at 16:15
  • $\begingroup$ @DumpsterDoofus Yup. Pretty much the same. But it's better to trust the OS tools :) $\endgroup$
    – Dr. belisarius
    Nov 6, 2014 at 16:21
  • 1
    $\begingroup$ @DumpsterDoofus Just an observation: executing MemoryInUse[$FrontEnd] actually frees memory. In fact all the memory the image had used. $\endgroup$
    – Dr. belisarius
    Nov 6, 2014 at 16:42
  • $\begingroup$ That's also weird. On mine, nothing happens (memory use stays at 2GB after executing it). $\endgroup$
    – DumpsterDoofus
    Nov 6, 2014 at 16:56

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.