11
$\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.

$\endgroup$
  • 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 '14 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 '14 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 '14 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 '14 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 '14 at 17:08
9
$\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.

$\endgroup$
  • $\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 '14 at 17:40
  • $\begingroup$ @DumpsterDoofus See the note I added at the top. $\endgroup$ – rm -rf Nov 6 '14 at 17:58
  • $\begingroup$ Oops, you're right. Hopefully this gets fixed in the next release. $\endgroup$ – DumpsterDoofus Nov 6 '14 at 18:57
  • $\begingroup$ Well, you asked for Undo didn't you? $\endgroup$ – Dr. belisarius Nov 7 '14 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

$\endgroup$
  • $\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 '14 at 16:15
  • $\begingroup$ @DumpsterDoofus Yup. Pretty much the same. But it's better to trust the OS tools :) $\endgroup$ – Dr. belisarius Nov 6 '14 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 '14 at 16:42
  • $\begingroup$ That's also weird. On mine, nothing happens (memory use stays at 2GB after executing it). $\endgroup$ – DumpsterDoofus Nov 6 '14 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.