How to Clear Adobe After Effects Disk Cache and Memory (RAM)People also askHow do I allocate more RAM to after effects?How do I speed up after effects?Where. After effects / Trapcode particular Ninja amongst us:) When im trying to make a bit more advanced particle systems with 'sprites' (bubbles that rise) After effects freeze. When this happens my RAM memory is eaten up. Starting from the initial load of about 27% and working it's way up until it reaches 100% and says it's out of memory.
In computer science, a memory leak is a type of resource leak that occurs when a computer program incorrectly manages memory allocations in a way that memory which is no longer needed is not released. A memory leak may also happen when an object is stored in memory but cannot be accessed by the running code.
In computer science, a memory leak is a type of resource leak that occurs when a computer program incorrectly manages memory allocations[1] in a way that memory which is no longer needed is not released. A memory leak may also happen when an object is stored in memory but cannot be accessed by the running code.[2] A memory leak has symptoms similar to a number of other problems and generally can only be diagnosed by a programmer with access to the programs' source code.
A space leak occurs when a computer program uses more memory than necessary. In contrast to memory leaks, where the leaked memory is never released, the memory consumed by a space leak is released, but later than expected. [3]
C++ Memory Leak
Because they can exhaust available system memory as an application runs, memory leaks are often the cause of or a contributing factor to software aging.
How To Find Memory Leaks
Consequences[edit]
A memory leak reduces the performance of the computer by reducing the amount of available memory. Eventually, in the worst case, too much of the available memory may become allocated and all or part of the system or device stops working correctly, the application fails, or the system slows down vastly due to thrashing.
Memory leaks may not be serious or even detectable by normal means. In modern operating systems, normal memory used by an application is released when the application terminates. This means that a memory leak in a program that only runs for a short time may not be noticed and is rarely serious.
Much more serious leaks include those:
- where the program runs for an extended time and consumes additional memory over time, such as background tasks on servers, but especially in embedded devices which may be left running for many years
- where new memory is allocated frequently for one-time tasks, such as when rendering the frames of a computer game or animated video
- where the program can request memory — such as shared memory — that is not released, even when the program terminates
- where memory is very limited, such as in an embedded system or portable device, or where the program requires a very large amount of memory to begin with, leaving little margin for leakage
- where the leak occurs within the operating system or memory manager
- when a system device driver causes the leak
- running on an operating system that does not automatically release memory on program termination.
An example of memory leak[edit]
The following example, written in pseudocode, is intended to show how a memory leak can come about, and its effects, without needing any programming knowledge. The program in this case is part of some very simple software designed to control an elevator. This part of the program is run whenever anyone inside the elevator presses the button for a floor.
The memory leak would occur if the floor number requested is the same floor that the elevator is on; the condition for releasing the memory would be skipped. Each time this case occurs, more memory is leaked.
Cases like this wouldn't usually have any immediate effects. People do not often press the button for the floor they are already on, and in any case, the elevator might have enough spare memory that this could happen hundreds or thousands of times. However, the elevator will eventually run out of memory. This could take months or years, so it might not be discovered despite thorough testing.
The consequences would be unpleasant; at the very least, the elevator would stop responding to requests to move to another floor (such as when an attempt is made to call the elevator or when someone is inside and presses the floor buttons). If other parts of the program need memory (a part assigned to open and close the door, for example), then nobody would be able to enter, and if someone happens to be inside, they will become trapped (assuming the doors cannot be opened manually).
The memory leak lasts until the system is reset. For example: if the elevator's power were turned off or in a power outage, the program would stop running. When power was turned on again, the program would restart and all the memory would be available again, but the slow process of memory leak would restart together with the program, eventually prejudicing the correct running of the system.
The leak in the above example can be corrected by bringing the 'release' operation outside of the conditional:
Programming issues[edit]
Memory leaks are a common error in programming, especially when using languages that have no built in automatic garbage collection, such as C and C++. Typically, a memory leak occurs because dynamically allocated memory has become unreachable. The prevalence of memory leak bugs has led to the development of a number of debuggingtools to detect unreachable memory. BoundsChecker, Deleaker, IBM Rational Purify, Valgrind, , Dr. Memory and memwatch are some of the more popular memory debuggers for C and C++ programs. 'Conservative' garbage collection capabilities can be added to any programming language that lacks it as a built-in feature, and libraries for doing this are available for C and C++ programs. A conservative collector finds and reclaims most, but not all, unreachable memory.
Although the memory manager can recover unreachable memory, it cannot free memory that is still reachable and therefore potentially still useful. Modern memory managers therefore provide techniques for programmers to semantically mark memory with varying levels of usefulness, which correspond to varying levels of reachability. The memory manager does not free an object that is strongly reachable. An object is strongly reachable if it is reachable either directly by a strong reference or indirectly by a chain of strong references. (A strong reference is a reference that, unlike a weak reference, prevents an object from being garbage collected.) To prevent this, the developer is responsible for cleaning up references after use, typically by setting the reference to null once it is no longer needed and, if necessary, by deregistering any event listeners that maintain strong references to the object.
In general, automatic memory management is more robust and convenient for developers, as they don't need to implement freeing routines or worry about the sequence in which cleanup is performed or be concerned about whether or not an object is still referenced. It is easier for a programmer to know when a reference is no longer needed than to know when an object is no longer referenced. However, automatic memory management can impose a performance overhead, and it does not eliminate all of the programming errors that cause memory leaks.
RAII[edit]
RAII, short for Resource Acquisition Is Initialization, is an approach to the problem commonly taken in C++, D, and Ada. It involves associating scoped objects with the acquired resources, and automatically releasing the resources once the objects are out of scope. Unlike garbage collection, RAII has the advantage of knowing when objects exist and when they do not. Compare the following C and C++ examples:
The C version, as implemented in the example, requires explicit deallocation; the array is dynamically allocated (from the heap in most C implementations), and continues to exist until explicitly freed.
The C++ version requires no explicit deallocation; it will always occur automatically as soon as the object array goes out of scope, including if an exception is thrown. This avoids some of the overhead of garbage collection schemes. And because object destructors can free resources other than memory, RAII helps to prevent the leaking of input and output resources accessed through a handle, which mark-and-sweep garbage collection does not handle gracefully. These include open files, open windows, user notifications, objects in a graphics drawing library, thread synchronisation primitives such as critical sections, network connections, and connections to the Windows Registry or another database.
However, using RAII correctly is not always easy and has its own pitfalls. For instance, if one is not careful, it is possible to create dangling pointers (or references) by returning data by reference, only to have that data be deleted when its containing object goes out of scope.
D uses a combination of RAII and garbage collection, employing automatic destruction when it is clear that an object cannot be accessed outside its original scope, and garbage collection otherwise.
Reference counting and cyclic references[edit]
More modern garbage collection schemes are often based on a notion of reachability – if you don't have a usable reference to the memory in question, it can be collected. Other garbage collection schemes can be based on reference counting, where an object is responsible for keeping track of how many references are pointing to it. If the number goes down to zero, the object is expected to release itself and allow its memory to be reclaimed. The flaw with this model is that it doesn't cope with cyclic references, and this is why nowadays most programmers are prepared to accept the burden of the more costly mark and sweep type of systems.
The following Visual Basic code illustrates the canonical reference-counting memory leak:
In practice, this trivial example would be spotted straight away and fixed. In most real examples, the cycle of references spans more than two objects, and is more difficult to detect.
A well-known example of this kind of leak came to prominence with the rise of AJAX programming techniques in web browsers in the lapsed listener problem. JavaScript code which associated a DOM element with an event handler, and failed to remove the reference before exiting, would leak memory (AJAX web pages keep a given DOM alive for a lot longer than traditional web pages, so this leak was much more apparent).
Effects[edit]
If a program has a memory leak and its memory usage is steadily increasing, there will not usually be an immediate symptom. Every physical system has a finite amount of memory, and if the memory leak is not contained (for example, by restarting the leaking program) it will eventually cause problems.
Most modern consumer desktop operating systems have both main memory which is physically housed in RAM microchips, and secondary storage such as a hard drive. Memory allocation is dynamic – each process gets as much memory as it requests. Active pages are transferred into main memory for fast access; inactive pages are pushed out to secondary storage to make room, as needed. When a single process starts consuming a large amount of memory, it usually occupies more and more of main memory, pushing other programs out to secondary storage – usually significantly slowing performance of the system. Even if the leaking program is terminated, it may take some time for other programs to swap back into main memory, and for performance to return to normal.
When all the memory on a system is exhausted (whether there is virtual memory or only main memory, such as on an embedded system) any attempt to allocate more memory will fail. This usually causes the program attempting to allocate the memory to terminate itself, or to generate a segmentation fault. Some programs are designed to recover from this situation (possibly by falling back on pre-reserved memory). The first program to experience the out-of-memory may or may not be the program that has the memory leak.
Some multi-tasking operating systems have special mechanisms to deal with an out-of-memory condition, such as killing processes at random (which may affect 'innocent' processes), or killing the largest process in memory (which presumably is the one causing the problem). Some operating systems have a per-process memory limit, to prevent any one program from hogging all of the memory on the system. The disadvantage to this arrangement is that the operating system sometimes must be re-configured to allow proper operation of programs that legitimately require large amounts of memory, such as those dealing with graphics, video, or scientific calculations.
If the memory leak is in the kernel, the operating system itself will likely fail. Computers without sophisticated memory management, such as embedded systems, may also completely fail from a persistent memory leak.
Publicly accessible systems such as web servers or routers are prone to denial-of-service attacks if an attacker discovers a sequence of operations which can trigger a leak. Such a sequence is known as an exploit.
A 'sawtooth' pattern of memory utilization may be an indicator of a memory leak within an application, particularly if the vertical drops coincide with reboots or restarts of that application. Care should be taken though because garbage collection points could also cause such a pattern and would show a healthy usage of the heap.
Other memory consumers[edit]
Note that constantly increasing memory usage is not necessarily evidence of a memory leak. Some applications will store ever increasing amounts of information in memory (e.g. as a cache). If the cache can grow so large as to cause problems, this may be a programming or design error, but is not a memory leak as the information remains nominally in use. In other cases, programs may require an unreasonably large amount of memory because the programmer has assumed memory is always sufficient for a particular task; for example, a graphics file processor might start by reading the entire contents of an image file and storing it all into memory, something that is not viable where a very large image exceeds available memory.
To put it another way, a memory leak arises from a particular kind of programming error, and without access to the program code, someone seeing symptoms can only guess that there might be a memory leak. It would be better to use terms such as 'constantly increasing memory use' where no such inside knowledge exists.
A simple example in C[edit]
The following C function deliberately leaks memory by losing the pointer to the allocated memory. The leak can be said to occur as soon as the pointer 'a' goes out of scope, i.e. when function_which_allocates() returns without freeing 'a'.
See also[edit]
- Plumbr is a popular memory leak detection tool for applications running on Java Virtual Machine
- nmon (short for Nigel's Monitor) is a popular system monitor tool for the AIX and Linux operating systems.
Erro Do After Effects String Memory Leak
References[edit]
- ^Crockford, Douglas. 'JScript Memory Leaks'. Archived from the original on 7 December 2012. Retrieved 6 November 2012.
- ^'Creating a memory leak with Java'. Stack Overflow. Retrieved 2013-06-14.
- ^Mitchell, Neil. 'Leaking Space'. Retrieved 27 May 2017.
External links[edit]
- Visual Leak Detector for Visual Studio, open source
- [http://valgrind.org/ Valgrin, open source
- Deleaker for Visual Studio, proprietary
- Detecting a Memory Leak (Using MFC Debugging Support)
- Article 'Memory Leak Detection in Embedded Systems' by Cal Erickson
Install Instructions
Window Installer(s)
The installer below is for use with all AE compatible products including After Effects and Premiere Pro. For Fusion, please use the OFX version instead.
To Download and install:
- Make sure you have one or more AE plug-in compatible applications on Windows.
If you have an older version of Sapphire Plug-ins, the new installation will replace it, and you do not need to un-install it first.
Quit AE or other host applications that may be running.
Download the 9.03 Windows installer (90 Mb).
Either run the installer program from its current location, or save it to disk and then execute it from wherever you saved it. Follow the instructions given by the installer.
- Restart your host application, and the new plug-ins should appear in your effects menu.
New in 9.03:
Temporarily disabled Expand Borders/Soft Borders in Premiere to fix a conflict with the HDR support introduced in Sapphire 9.02. This fixes rendering errors in effects such as Blur, Glow, and DropShadow. We are working on an improved fix that will reintroduce Expand Borders. Effects with Expand Borders/Soft Borders turned on may render slightly differently.
Improved loading of old v6 projects containing ZFogLinear and ZFogExponential when Z Near and Z Far were set their default values.
Fixed a crash in BokehLights with size set to zero and color fringing turned on.
Fixed a bug where S_Grain would go from color to monochrome after 524,000+ frames.
Fixed a memory leak in LensFlare, NightSky, and BokehLights when rendering on the GPU.
Fixed a bug that caused some presets for multi-effect plugins to be saved with the wrong effect.
Fixed a bug that caused interlaced frames to look squashed in the Preset Browser.
Fixed a bug that displayed an error message when opening the Preset Browser on an adjustment layer.
Fixed a bug in Effect Builder where moving a node to a disconnected edge does not work correctly.
Fixed a few bugs that could hang AE CC 2015.
Removed erroneous warnings about a missing Reprise directory.
Fixed a crash in background renders with no license.
Licenses can now be activated off-line using command line tools.
When activating licenses offline, support can now see which machines are activated.
Put the name of the license in use in the help dialog to help debug floating licenses with multiple licenses.
Fixed a bug that sometimes caused the “More Help” button in the help dialog to open the wrong documentation.
Removed uninstall shortcut from Windows 10 Start Menu due to unpredictable behavior, please use Add/Remove Programs in the Control Panel instead.
Fixed a bug that sometimes caused point params to shift when using S_Effect.
New in 9.021:
- Fixed a hang in Premiere CC 2015 when rendering on the GPU.
New in 9.02:
Fixed a bug that could cause multiple Preset Browsers to start.
Changed watermark to improve free trial experience.
Fixed a bug that sometimes caused the hotspot to be positioned incorrectly in the Flare Editor.
Fixed a bug that prevented some v8 presets from loading correctly in v9.
Fixed a bug that caused FreezeFrame and ReverseEdits to fail with “error: Unknown checkout id (78 :: 7)”.
Enable HDR (32-bit float) processing in Adobe Premiere.
Fixed a bug that caused Grunge to not render a stamp after its relative density was lowered to zero and then raised again.
Fixed a crash when certain clips were used as the Centers input of WarpDrops.
Fixed a bug that made Star Saturation in NightSky ineffective.
Improved Aurora documentation.
Fixed a few issues that stopped the Flare Editor from opening on systems set to use some non-English languages.
New in 9.01:
Fixed occasional problems starting the Preset Browser, Flare Editor, and Builder.
Fixed a bug that caused some background renders to be incorrect.
Fixed a rendering bug and improved performance in Gamma.
Added new presets.
To view on-line documentation after you install the software, go to Start -> All Programs -> GenArts Sapphire AE -> Online Help (HTML) or (PDF). You can also click on the “About” box while using any plug-in.
In general, you can load projects saved with Sapphire v1 or v2 or v6 or v7 or v8 effects and they should automatically convert to use Sapphire v9. Please visit the support page for more info on this.
If you require Sapphire v1 you can use the version 1.10 installer. If you require Sapphire v2 you can use the version 2.093 installer. If you already installed Sapphire v9 and want to go back to an earlier version you should first uninstall v9.
This software may use the Qt user interface framework. Qt is distributed under the terms of the Lesser GNU Public License (LGPL), Version 2.1; see http://www.gnu.org/licenses/lgpl-2.1.html for more details. The source code for Qt is available here.
Mac Installer(s)
The installer below is for use with all AE compatible products including After Effects and Premiere Pro.
For Final Cut Pro or Motion, please use the FxPlug version instead.
To Download and install:
- Make sure you have one or more AE plug-in compatible applications on a Mac with an Intel CPU and MacOS 10.5 or greater.
If you have an older version of Sapphire Plug-ins, the new installation will replace it, and you do not need to un-install it first.
Quit AE or other host applications that may be running.
Download the 9.03 Mac installer for 10.6 and above (162 Mb)
Run the installer. When it asks for your passphrase, enter your Mac user login password, and follow the instructions given by the installer.
Restart your host product, and the new plug-ins should appear in your effects menu.
To view on-line documentation after you install the software, go to the /Applications/GenArtsSapphireAE folder and double click on Online Help.html or Online Help.pdf. You can also click on the “About” box while using any plug-in.
In general, you can load projects saved with Sapphire v1 or v2 or v5 or v6 or v7 effects and they should automatically convert to use Sapphire v9. Please visit the support page for more info on this.
If you require Sapphire v1 you can use the version 1.10 installer. If you require Sapphire v2 you can use the version 2.093 installer. If you already installed Sapphire v9 and want to go back to an older version you should first uninstall v9.
New in 9.03:
Temporarily disabled Expand Borders/Soft Borders in Premiere to fix a conflict with the HDR support introduced in Sapphire 9.02. This fixes rendering errors in effects such as Blur, Glow, and DropShadow. We are working on an improved fix that will reintroduce Expand Borders. Effects with Expand Borders/Soft Borders turned on may render slightly differently.
Improved loading of old v6 projects containing ZFogLinear and ZFogExponential when Z Near and Z Far were set their default values.
Fixed a crash in BokehLights with size set to zero and color fringing turned on.
Fixed a bug where S_Grain would go from color to monochrome after 524,000+ frames.
Fixed a memory leak in LensFlare, NightSky, and BokehLights when rendering on the GPU.
Fixed a bug that caused some presets for multi-effect plugins to be saved with the wrong effect.
Fixed a bug that caused interlaced frames to look squashed in the Preset Browser.
Fixed a bug that displayed an error message when opening the Preset Browser on an adjustment layer.
Fixed a bug in Effect Builder where moving a node to a disconnected edge does not work correctly.
Fixed a few bugs that could hang AE CC 2015.
Removed erroneous warnings about a missing Reprise directory.
Fixed a crash in background renders with no license.
Licenses can now be activated off-line using command line tools.
When activating licenses offline, support can now see which machines are activated.
Put the name of the license in use in the help dialog to help debug floating licenses with multiple licenses.
Fixed a bug that sometimes caused the “More Help” button in the help dialog to open the wrong documentation.
Fixed a bug that sometimes caused point params to shift when using S_Effect.
New in 9.021:
- Fixed a hang in Premiere CC 2015 when rendering on the GPU.
New in 9.02:
Fixed a bug that could cause multiple Preset Browsers to start.
Changed watermark to improve free trial experience.
Fixed a bug that sometimes caused the hotspot to be positioned incorrectly in the Flare Editor.
Fixed a bug that prevented some v8 presets from loading correctly in v9.
Fixed a bug that caused FreezeFrame and ReverseEdits to fail with “error: Unknown checkout id (78 :: 7)”.
Enable HDR (32-bit float) processing in Adobe Premiere.
Fixed a bug that caused Grunge to not render a stamp after its relative density was lowered to zero and then raised again.
Fixed a crash when certain clips were used as the Centers input of WarpDrops.
Fixed a bug that made Star Saturation in NightSky ineffective.
Improved Aurora documentation.
Fixed a few issues that stopped the Flare Editor from opening on systems set to use some non-English languages.
New in 9.01:
Fixed occasional problems starting the Preset Browser, Flare Editor, and Builder.
Fixed a bug that caused some background renders to be incorrect.
Fixed a rendering bug and improved performance in Gamma.
Added new presets.
This software may use the Qt user interface framework. Qt is distributed under the terms of the Lesser GNU Public License (LGPL), Version 2.1; see http://www.gnu.org/licenses/lgpl-2.1.html for more details. The source code for Qt is available here.
Comments are closed.