Rename managed heap and immortals heap (case sensitive)

ApplicationDeveloperGuide/UI/MWT/how-to-debug.rst

@@ -200,7 +200,7 @@ A ``null`` entry means that the parameter is from the default style (thus set by
 
 This feature is used in the :ref:`HierarchyInspector <widget_library_debug_utilities_hierarchy>` of the Widget library.
 
-.. warning:: Beware that enabling that feature may downgrade the performances (more time to compute a style and more Managed heap used).
+.. warning:: Beware that enabling that feature may downgrade the performances (more time to compute a style and more Managed Heap used).
 
 .. note:: Available since MWT 3.6.0.
 

ApplicationDeveloperGuide/UI/MWT/mwt-examples.rst

@@ -115,7 +115,7 @@ When the joystick directions (up, down, left, right) are pressed, the focus chan
 This example shows how to create and use an immutable stylesheet.
 
 The immutable stylesheet resolves the style for a widget with the same algorithm as the `cascading stylesheet <https://repository.microej.com/javadoc/microej_5.x/apis/ej/mwt/stylesheet/cascading/CascadingStylesheet.html>`_.
-The difference is that the immutable stylesheet is described in an immutable file instead of Java code. Therefore, the style objects are allocated in flash instead of the Managed heap.
+The difference is that the immutable stylesheet is described in an immutable file instead of Java code. Therefore, the style objects are allocated in flash instead of the Managed Heap.
 
 |endTable|
 

ApplicationDeveloperGuide/UI/MicroUI/applicationOptions.rst

@@ -6,7 +6,7 @@ Application Options
 MicroUI libraries and its tools provide a set of options. 
 See :ref:`application_options` to have more information about the application options.
 
-.. note:: MicroUI implementation requires one thread (MicroUI Pump) and at least 100 bytes in  the :ref:`immortals heap <option_immortal_heap>`.
+.. note:: MicroUI implementation requires one thread (MicroUI Pump) and at least 100 bytes in  the :ref:`Immortals Heap <option_immortal_heap>`.
 
 
 .. include:: sectionArchitectureOptions.rst

ApplicationDeveloperGuide/UI/MicroUI/releaseNotes.rst

@@ -55,7 +55,7 @@ From 10.x to 12.x
 =================
 
 * In MicroEJ application launcher > ``Configuration`` tab > :ref:`MicroUI <section_ui_options_microui>`: check ``Use Flying Images`` when the application is using the flying images (property ``com.microej.library.microui.flyingimage.enabled``).
-* In MicroEJ application launcher, increase the :ref:`Managed heap <option_managed_heap>`: it now contains MicroUI images metadata (size, format, clip etc.). The icetea heap has been automatically decreased.
+* In MicroEJ application launcher, increase the :ref:`Managed Heap <option_managed_heap>`: it now contains MicroUI images metadata (size, format, clip etc.). The icetea heap has been automatically decreased.
 
 From 9.x to 10.x
 ================

ApplicationDeveloperGuide/UI/MicroVG/avdLoader.rst

@@ -97,7 +97,7 @@ Format Limitations
 The library only supports a subset of the `Vector Drawable specification <https://developer.android.com/reference/android/graphics/drawable/VectorDrawable>`_.
 
 The AVD Loader is designed to load AVDs at runtime on embedded devices.
-It minimizes Managed heap usage and CPU time for XML parsing, Path creation, and adds little code to the final executable.
+It minimizes Managed Heap usage and CPU time for XML parsing, Path creation, and adds little code to the final executable.
 The format is intentionally limited to reduce processing time and complexity while ensuring good performance, knowing that the :ref:`pre-processing step <section.avdloader.convert>` can convert any AVD into the compatible format. 
 
 Note that this limitation on the Android Vector Drawable format does not apply to AVDs loaded as :ref:`raw vector images <vectorimage_overview>`.
@@ -145,7 +145,7 @@ The resulting vector image can then be drawn on the display:
    The image must be provided as a raw resource of the application, either :ref:`internal or external <chapter.microej.applicationResources>`. For external resource loading, the BSP must implement the proper Abstraction Layer API (LLAPI), see :ref:`section_externalresourceloader` for more information on the implementation.
 
 .. warning::
-   The new image is a ``ResourceVectorImage``. In the current implementation, an image loaded with the ``AvdImageLoader`` is allocated in the Managed heap. To release memory, the application must close the image and remove any references to it.
+   The new image is a ``ResourceVectorImage``. In the current implementation, an image loaded with the ``AvdImageLoader`` is allocated in the Managed Heap. To release memory, the application must close the image and remove any references to it.
 
 Limitations
 -----------
@@ -198,7 +198,7 @@ This processes the input SVG ``originalImage.svg`` and outputs a Vector Drawable
 Memory Usage
 ~~~~~~~~~~~~
 
-The loading of a Vector Drawable at runtime uses Managed heap:
+The loading of a Vector Drawable at runtime uses Managed Heap:
 
 * for the working buffers and intermediate objects used during the loading phase. The XML parser is optimized to stream the data and uses as few heap as possible.
 * for the image data.

ApplicationDeveloperGuide/heapUsageMonitoring.rst

@@ -6,7 +6,7 @@ Heap Usage Monitoring
 Introduction
 ------------
 
-When building a :ref:`standalone_application`, the Managed heap size must be specified
+When building a :ref:`standalone_application`, the Managed Heap size must be specified
 as an :ref:`Application Option <application_options>` (see :ref:`option_managed_heap`).
 The value to set in this option depends on the maximum heap usage, and the 
 developer can estimate it by running the application.

ApplicationDeveloperGuide/javaTime.rst

@@ -338,7 +338,7 @@ TZDB Zone Rules Provider
 The library also defines a provider of zone rules for the time zones defined in the `IANA Time Zone Database <https://www.iana.org/time-zones>`_ (TZDB).
 
 The TZDB provider reads the zones and rules from a raw resource at runtime.
-Compared to the ``TzdbZoneRulesProvider`` of Java SE distributions, this implementation uses less Managed heap at runtime, making it more suitable for embedded devices.
+Compared to the ``TzdbZoneRulesProvider`` of Java SE distributions, this implementation uses less Managed Heap at runtime, making it more suitable for embedded devices.
 
 .. warning::
    The TZDB provider requires a target VEE Port that uses an architecture version ``8.1.1`` minimum (for ``8.x``), or ``7.20.5`` minimum (for ``7.x``).

ApplicationDeveloperGuide/limitations.rst

@@ -82,7 +82,7 @@ Please consult :ref:`architecture_changelog` for limitations changes on former v
    * - Number of methods and constructors calls
      - 500000000
      - unlimited
-   * - Number of Managed heap Garbage Collection
+   * - Number of Managed Heap Garbage Collection
      - 3000 [4]_
      - unlimited
    * - Number of Shielded Plug databases
@@ -104,7 +104,7 @@ Please consult :ref:`architecture_changelog` for limitations changes on former v
    time is defined by the :ref:`maximum number of monitors per thread Application option <option_maximum_number_of_monitors_per_thread>`.
 
 .. [4]
-   The Managed heap Garbage Collection limit may throw unexpected cascading `java.lang.OutOfMemoryError`_ exceptions before the Core Engine exits.
+   The Managed Heap Garbage Collection limit may throw unexpected cascading `java.lang.OutOfMemoryError`_ exceptions before the Core Engine exits.
 
 .. _java.lang.OutOfMemoryError: https://repository.microej.com/javadoc/microej_5.x/apis/java/lang/OutOfMemoryError.html
 

ApplicationDeveloperGuide/sectionArchitectureOptions.rst

@@ -111,7 +111,7 @@ Group: Heaps
 
 .. _option_managed_heap:
 
-Option(text): Managed heap size (in bytes)
+Option(text): Managed Heap size (in bytes)
 """"""""""""""""""""""""""""""""""""""""""
 
 *Option Name*: ``core.memory.javaheap.size``
@@ -120,25 +120,25 @@ Option(text): Managed heap size (in bytes)
 
 *Description*:
 
-Specifies the Managed heap size in bytes.
+Specifies the Managed Heap size in bytes.
 
-A Managed heap contains live objects. An OutOfMemory error can occur if the
+A Managed Heap contains live objects. An OutOfMemory error can occur if the
 heap is too small.
 
 .. _option_immortal_heap:
 
-Option(text): Immortal heap size (in bytes)
-"""""""""""""""""""""""""""""""""""""""""""
+Option(text): Immortals Heap size (in bytes)
+""""""""""""""""""""""""""""""""""""""""""""
 
 *Option Name*: ``core.memory.immortal.size``
 
 *Default value*: ``4096``
 
 *Description*:
 
-Specifies the Immortal heap size in bytes.
+Specifies the Immortals Heap size in bytes.
 
-The Immortal heap contains allocated Immortal objects. An OutOfMemory error can
+The Immortals Heap contains allocated Immortal objects. An OutOfMemory error can
 occur if the heap is too small.
 
 Group: Threads
@@ -807,14 +807,14 @@ output when Core Engine throws an OutOfMemoryError.
 
 .. _option_enable_heap_usage:
 
-Option(checkbox): Enable Managed heap usage monitoring
+Option(checkbox): Enable Managed Heap usage monitoring
 """"""""""""""""""""""""""""""""""""""""""""""""""""""
 
 *Option Name*: ``com.microej.runtime.debug.heap.monitoring.enabled``
 
 *Default value*: ``false``
 
-Option(text): Managed heap initial size
+Option(text): Managed Heap initial size
 """""""""""""""""""""""""""""""""""""""
 
 *Option Name*: ``com.microej.runtime.debug.heap.monitoring.init.size``
@@ -823,7 +823,7 @@ Option(text): Managed heap initial size
 
 *Description*:
 
-Specify the initial size (in bytes) of the Managed heap.
+Specify the initial size (in bytes) of the Managed Heap.
 
 Group: SOAR
 ^^^^^^^^^^^

ApplicationDeveloperGuide/sectionSimulatorOptions.rst

@@ -26,8 +26,8 @@ Option: Objects Heap Size
 *Description*:
 
 This memory area contains any kind of objects (regular, immortal and immutable objects). 
-If you get a ``java.lang.OutOfMemoryError`` exception but your Managed heap is not full, most likely you should augment this option.
-It must be greater than the sum of :ref:`Managed heap <option_managed_heap>` and :ref:`Immortal Heap <option_immortal_heap>`.
+If you get a ``java.lang.OutOfMemoryError`` exception but your Managed Heap is not full, most likely you should augment this option.
+It must be greater than the sum of :ref:`Managed Heap <option_managed_heap>` and :ref:`Immortals Heap <option_immortal_heap>`.
 
 Option: System Chars Size
 ^^^^^^^^^^^^^^^^^^^^^^^^^

ApplicationDeveloperGuide/standaloneApplication.rst

@@ -30,8 +30,8 @@ Standalone Application Options
 To run a Standalone Application on a VEE Port, a set of options
 must be defined. Options can be of different types:
 
-- Memory Allocation options (e.g., set the Managed heap size). These options are usually called link-time options.
-- Simulator & Debug options (e.g., enable periodic Managed heap dump).
+- Memory Allocation options (e.g., set the Managed Heap size). These options are usually called link-time options.
+- Simulator & Debug options (e.g., enable periodic Managed Heap dump).
 - Deployment options (e.g., copy ``microejapp.o`` to a suitable BSP location).
 - Foundation Library specific options (e.g., embed UTF-8 encoding).
 

ApplicationDeveloperGuide/trace.rst

@@ -160,7 +160,7 @@ A VEE Port can connect its own implementation by overriding the functions define
 MicroEJ Corp. provides an implementation that redirects the events to :ref:`systemview` tool, 
 the real-time recording and visualization tool from `Segger <https://www.segger.com/>`_. It is perfect for a finer understanding of the runtime behavior by showing events sequence and duration.
 
-A implementation example for the `NXP OM13098 development board <https://www.nxp.com/products/processors-and-microcontrollers/arm-microcontrollers/general-purpose-mcus/lpc54000-cortex-m4-/lpcxpresso54628-development-board:OM13098>`_ with SystemView support is available `here <https://developer.microej.com/packages/referenceimplementations/U3OER/2.0.1/OM13098-U3OER-fullPackaging-eval-2.0.1.zip>`__.
+A implementation example for the `NXP OM13098 development board <https://www.nxp.com/design/design-center/software/development-software/mcuxpresso-software-and-tools-/lpcxpresso-boards/lpcxpresso54628-development-board:OM13098>`_ with SystemView support is available `here <https://developer.microej.com/packages/referenceimplementations/U3OER/2.0.1/OM13098-U3OER-fullPackaging-eval-2.0.1.zip>`__.
 
 Please contact :ref:`our support team <get_support>` for more information about how to integrate this module.
 

KernelDeveloperGuide/kernelLink.rst

@@ -44,7 +44,7 @@ It produces a ``.kdat`` file that will be used to link the Sandboxed Application
 
    Kernel Metadata Generator
 
-The ``.kdat`` file is optimized for size. When linking a Sandboxed Application ``.fso`` file, only the required metadata will be loaded in Managed heap.
+The ``.kdat`` file is optimized for size. When linking a Sandboxed Application ``.fso`` file, only the required metadata will be loaded in Managed Heap.
 It will be loaded from a standard `InputStream`_,
 so that it can be stored to a memory that is not accessible from the CPU's address space.
 

KernelDeveloperGuide/kf.rst

@@ -728,9 +728,9 @@ The following APIs allow to configure the Managed Heap usage:
 
 Especially, allocations from Features will fail (throw an OutOfMemoryError):
 
-- when the feature-specific limit is reached, before the Managed heap is full;
-- when the Managed heap is full, before the feature-specific limit is reached;
-- when the allocation would exceed the amount of memory available to Features (i.e. Managed heap size minus memory reserved for the Kernel).
+- when the feature-specific limit is reached, before the Managed Heap is full;
+- when the Managed Heap is full, before the feature-specific limit is reached;
+- when the allocation would exceed the amount of memory available to Features (i.e. Managed Heap size minus memory reserved for the Kernel).
 
 The diagrams below illustrate a Kernel with two Features with various heap configuration scenarios. 
 Kernel reserved memory and Feature memory limits are depicted as contiguous blocks for simplicity.

SDK6UserGuide/heapAnalyzer.rst

@@ -8,7 +8,7 @@ Introduction
 
 Heap Dumper is a tool that allows to get a snapshot of the heap of an Application running on the Simulator or on a device. 
 
-The Heap Analyzer is a set of tools to help developers understand the contents of the Managed heap and find problems such as memory leaks.
+The Heap Analyzer is a set of tools to help developers understand the contents of the Managed Heap and find problems such as memory leaks.
 For its part, the Heap Analyzer IDE plugin is able to visualize dump files. 
 It helps you analyze their contents thanks to the following features:
 
@@ -76,7 +76,7 @@ Heap Dumper
 -----------
 
 The Heap Dumper generates ``.heap`` files. There are two implementations:
-- the one integrated to the Simulator: it directly dumps ``.heap`` files from the Managed heap. 
+- the one integrated to the Simulator: it directly dumps ``.heap`` files from the Managed Heap. 
 - the Heap Dumper tool: it generates ``.heap`` files from ``.hex`` files that must be manually retrieved from the device.
 
 The heap dump should be performed after a call to `System.gc()`_ to exclude discardable objects.

SDK6UserGuide/testProject.rst

@@ -521,7 +521,7 @@ The properties are:
   This property is only required if the VEE Port does not redirect execution traces.
 
 Any other property can be passed to the Test Engine by prefixing it by ``microej.testsuite.properties.``.
-For example, to set the the Immortal heap size:
+For example, to set the the Immortals Heap size:
 
 .. code-block::
 

SDKUserGuide/heapAnalyzer.rst

@@ -11,7 +11,7 @@ Heap Dumper is a tool that takes a snapshot of the heap. Generated files
 folder.
 
 The Heap Analyzer is a set of tools to help developers understand the
-contents of the Managed heap and find problems such as memory leaks.
+contents of the Managed Heap and find problems such as memory leaks.
 For its part, the Heap Analyzer plugin is able to open dump files. It
 helps you analyze their contents thanks to the following features:
 
@@ -90,7 +90,7 @@ Heap Dumper
 
 The Heap Dumper generates ``.heap`` files. There are two implementations:
 
-1. **Integrated with the Simulator**: Dumps ``.heap`` files directly from the Managed heap.
+1. **Integrated with the Simulator**: Dumps ``.heap`` files directly from the Managed Heap.
 2. **Heap Dumper Tool**: Generates ``.heap`` files from ``.hex`` files, which must be retrieved from the device using tools like GDB.
 
 Heap dumps should be performed after a call to `System.gc()`_ to exclude discardable objects.

SDKUserGuide/moduleNatures.rst

@@ -622,7 +622,7 @@ This plugin defines the following build options:
      - ``60``  
    * - microej.testsuite.properties.[name]
      - Inject an :ref:`Application Option <application_options>` named ``[name]`` for all tests.       
-       For example, declaring the build option ``microej.testsuite.properties.core.memory.javaheap.size`` will configure the Managed heap size of all tests.
+       For example, declaring the build option ``microej.testsuite.properties.core.memory.javaheap.size`` will configure the Managed Heap size of all tests.
      - Not applicable
    * - microej.testsuite.properties.launch.test.trace.file
      - Set this property to ``true`` if your :ref:`VEE Port Run script <bsp_connection_run_script>` redirects execution traces.

Trainings/trainingDebugHardfault.rst

@@ -122,7 +122,7 @@ The cause(s) of a memory corruption can be:
 * A device incorrectly initialized or misconfigured.
 * ...
 
-When the HardFault occurs in the Core Engine task, one of its internal structures may be corrupted (such as the Managed heap or Threads stacks).
+When the HardFault occurs in the Core Engine task, one of its internal structures may be corrupted (such as the Managed Heap or Threads stacks).
 Add ``LLMJVM_checkIntegrity`` call in checkpoints of the BSP code to identify the timeslot of the memory corruption.
 Typically, you can check a native with:
 
@@ -153,7 +153,7 @@ Determine which memory regions are affected and determine which components are r
 
     * What are the code sections for the BSP and the Application?
     * Where are the BSP stack and heap? What about the Application stack and heap?
-    * Where is the Java immortals heap?
+    * Where is the Java Immortals Heap?
     * Where are the Java strings?
     * Where is the MicroEJ UI buffer?
     * Besides the Java immortals, what are the other intersection point between the Java application and the BSP? (e.g., a temporary RAM buffer for JPEG decoder).
@@ -177,9 +177,9 @@ Attach an embedded debugger and get the following information:
     * the whole memory, if possible
     * otherwise, get the *hot sections* 
 
-        * BSP and Managed heap and stack
+        * BSP and Managed Heap and stack
         * UI buffer
-        * immortals heap
+        * Immortals Heap
         * sections where the Java application and BSP are working together
 
 * :ref:`vm_dump_debugger`