Memory Management - Revision history

Suhridk: /* Competitive Mode */

2012-01-09T20:24:53Z

Competitive Mode

2012-01-09T20:13:03Z

Inheritance of Stacks

2012-01-09T19:39:18Z

Inheritance of Stacks

2012-01-09T19:34:47Z

Memory Stack Information

2012-01-09T19:26:14Z

Memory Stack Information

2012-01-09T19:25:08Z

Memory Stack Information

2012-01-09T19:04:39Z

Memory Assignment Rules

2012-01-09T16:15:53Z

Intro

2012-01-09T16:14:20Z

Intro

2012-01-09T15:12:36Z

Intro

@@ Line 421: / Line 421: @@
 == Competitive Mode ==
-* The goal is to maximize use of memory. For e.g. requirement may be to use only the amount of memory allocated to the scope at any given time.  So, a maximum of 1 SO can be active in a memory area at any given time. As usual, the memory is reclaimed when the SO leaves the area.
+* The goal is to maximize use of memory. For e.g. requirement may be to use only the amount of memory allocated to the scope at any given time.  So, a maximum of 1 SO can be active in a memory area at any given time. The intention is that the memory can be reclaimed when each of the schedulable objects leave the area.
 *** The ScopedMemory provides methods for competitive mode. e.g. join(), joinandenter().
 *** join() -  Make the SO wait until the reference count of this ScopedMemory goes down to zero.

@@ Line 412: / Line 412: @@
 ** If the  current active area is heap/immortal and childs initial memory area is heap/immortal and the, then the childs '''new''' stack will contain only heap/immortal area
 ** If the current active area is heap/immortal and childs initial memory area is other than the current active area (e.g. a scoped area), then the childs '''new''' stack will contain the heap/immortal + the other area.
-** If the current active area is scoped and childs ini mem area is the same scoped area, then the childs '''new''' stack will be the same as the parents stack.
+** If the current active area is scoped and childs ini mem area is the same scoped area, then the childs '''new''' stack will be the same as the parents stack up to and including the current memory area.
-** If the current active area is scoped and the childs ini mem area is a different scoped area, then the childs '''new''' stack will be the same as the parents stack and include the different scoped area.
+** If the current active area is scoped and the childs ini mem area is a different scoped area, then the childs '''new''' stack will be the same as the parents stack up to and including the current memory area and include the different scoped area.
 = Using scoped memory areas =

@@ Line 406: / Line 406: @@
 * When a SO is created, it's initial memory area can be set. For e.g. as a constructor parameter for RealtimeThread.
 * The memory stack of a created SO is determined by the value of the initial memory area and the current active memory area from where the SO is created.
 * For e.g. if SO1 (parent) is creating SO2 (child), then SO2's memory stack is determined by its initial area and the currently active memory area SO1 was executing in, when it created SO2.

← Older revision		Revision as of 19:34, 9 January 2012
Line 163:		Line 163:

	* OuterArea is heap - base of stack, because rt object was created in heap. If rt was created in Immortal, then the base of the stack would be immortal.		* OuterArea is heap - base of stack, because rt object was created in heap. If rt was created in Immortal, then the base of the stack would be immortal.
		+	* See below example, in this case since inner rt is created in immortal, its stack consists of only the immortal thread.
		+
		+	<syntaxhighlight lang="java5">
		+
		+	RealtimeThread outer = new RealtimeThread() {
		+	public void run() {
		+	imm.enter(new Runnable() {
		+	public void run() {
		+	RealtimeThread inner = new RealtimeThread() {
		+	public void run() {
		+	System.out.println("Current Area : " + RealtimeThread.getCurrentMemoryArea());
		+	System.out.println("Stack Depth : " + RealtimeThread.getMemoryAreaStackDepth());
		+	//Outer Area
		+	System.out.println("Outer Area : " + RealtimeThread.getOuterMemoryArea(RealtimeThread.getInitialMemoryAreaIndex()));
		+	}
		+	};
		+	inner.start();
		+	}
		+	});
		+	}
		+	};
		+
		+	outer.start();
		+
		+	/* Output:
		+
		+	Current Area : javax.realtime.ImmortalMemory@2055e9
		+	Stack Depth : 1
		+	Outer Area : javax.realtime.ImmortalMemory@2055e9
		+
		+	*/
		+	</syntaxhighlight>

	= MemoryArea ExecuteInArea =		= MemoryArea ExecuteInArea =

← Older revision		Revision as of 19:26, 9 January 2012
Line 161:		Line 161:

	</syntaxhighlight>		</syntaxhighlight>
		+
		+	* OuterArea is heap - base of stack, because rt object was created in heap. If rt was created in Immortal, then the base of the stack would be immortal.

	= MemoryArea ExecuteInArea =		= MemoryArea ExecuteInArea =

@@ Line 124: / Line 124: @@
 ** int getInitialMemoryAreaIndex() : This method returns the position in the memory area stack of the initial memory area. Memory area stacks may include inherited stacks from parent threads. The initial memory area for the current RealtimeThread or AsyncEventHandler is the memory area given as a parameter to the constructor.
 ** MemoryArea getOuterMemoryArea(int index) : Gets the instance of MemoryArea in the memory area stack at the index given. If the given index does not exist in the memory area scope stack then null is returned.
 = MemoryArea ExecuteInArea =

@@ Line 111: / Line 111: @@
 * To avoid this problem, the RTSJ requires that each '''scoped memory area''' (note: only scoped memory area) can only have a single parent.
-* The parent of an active scoped memory area can be:
+* The parent of an '''''active''''' scoped memory area can be:
 ** If scoped memory is the first  scoped area on the stack, then its parent is the primordial scope area.
 ** For others, the parent is the ''first scoped area'' below it on the stack.

@@ Line 5: / Line 5: @@
 * Assuming a time critical thread '''is using heap memory''', Running garbage collection can have an impact on its response time.
 * It is not safe to preempt GC because memory compaction might be happening.
-* Therefore, tt is necessary to provide memory that is not subject to GC.
+* There is a ''lack of confidence'' in Real time garbage collection. Therefore, it is necessary to provide memory that is not subject to GC.
 * The RTSJ provides two alternatives to traditional Java heap memory:
 ** Immortal Memory

@@ Line 3: / Line 3: @@
 * Many real time systems have constraints on amount of memory available. e.g. because of cost or size constraints.
 * It is necessary to control how this memory is allocated so that it can be used effectively. By doing this the program can increase its performance and predictability.
-* Assuming a time critical thread is using heap memory, Running garbage collection can have an impact on its response time.
+* Assuming a time critical thread '''is using heap memory''', Running garbage collection can have an impact on its response time.
 * Therefore, tt is necessary to provide memory that is not subject to GC.
 * The RTSJ provides two alternatives to traditional Java heap memory:
@@ Line 13: / Line 14: @@
 * Schedulable objects '''must explicitly indicate''' the MemoryArea to allocate objects from, otherwise the standard Java heap will be used.
 * When a memory area is entered by a SO, all object allocation is performed from within that memory area.
-* RTSJ requires that the garbage collector can be preempted by real-time threads and that there should be a bounded latency for preemption to take place.
+* RTSJ requires that the garbage collector can be preempted by real-time threads and that there should be a bounded latency for pre-emption to take place.
 = Heap Memory =