Exec Memory Allocation - Revision history

Costel Mincea: Text replacement - "" to ""

2025-01-26T19:21:07Z

Text replacement - "<syntaxhighlight>" to "<syntaxhighlight lang="C" line>"

Ryan Dixon: /* Program Address Space */

2024-12-08T02:54:28Z

Program Address Space

← Older revision		Revision as of 02:54, 8 December 2024
Line 57:		Line 57:
	}		}
	</pre>		</pre>

			The same applies for stack and heap allocated memory.

	=== Slab allocation ===		=== Slab allocation ===

Steven Solie at 16:02, 3 April 2024

2024-04-03T16:02:39Z

← Older revision		Revision as of 16:02, 3 April 2024
Line 310:		Line 310:
	A memory block allocated with AllocVecTags() or AllocVec() must be returned to the system pool with the FreeVec() function. This function uses the stored size in the allocation to free the memory block, so there is no need to specify the size of the memory block to free.		A memory block allocated with AllocVecTags() or AllocVec() must be returned to the system pool with the FreeVec() function. This function uses the stored size in the allocation to free the memory block, so there is no need to specify the size of the memory block to free.

	Any memory that is locked must be explicitly unlocked with UnlockMem() prior to freeing it. Failure to unlock memory will not cause any immediate problems but any pages which are locked cannot be moved or swapped out which can decrease system performance~~. Never unlock memory which has not been explicitly locked with LockMem() as it could lead to undefined behaviour~~.		Any memory that is locked must be explicitly unlocked with UnlockMem() prior to freeing it. Failure to unlock memory will not cause any immediate problems but any pages which are locked cannot be moved or swapped out which can decrease system performance.

	FreeVec() returns no status. However, if you attempt to free a memory block in the middle of a chunk that the system believes is already free, you will cause a system crash. It is also illegal to free the same memory block twice and this will lead to a system crash.		FreeVec() returns no status. However, if you attempt to free a memory block in the middle of a chunk that the system believes is already free, you will cause a system crash. It is also illegal to free the same memory block twice and this will lead to a system crash.

Ryan Dixon: Minor grammar

2023-11-25T16:02:56Z

Minor grammar

← Older revision		Revision as of 16:02, 25 November 2023
Line 13:		Line 13:
	It is important to remember that, just like in classic AmigaOS, a single address space is used for all programs. Sometimes the mention of an MMU can lead people to assume that each process on the Amiga will have its own personal, partitioned address space. The following two programs demonstrate that, even though they are separate processes, it is possible to read and write another's memory. The memory locations are the same virtual address and that virtual address maps onto the same physical address.		It is important to remember that, just like in classic AmigaOS, a single address space is used for all programs. Sometimes the mention of an MMU can lead people to assume that each process on the Amiga will have its own personal, partitioned address space. The following two programs demonstrate that, even though they are separate processes, it is possible to read and write another's memory. The memory locations are the same virtual address and that virtual address maps onto the same physical address.

		⚫	This program has a global variable. It prints out the virtual address of the global, the value at that address (which can be optionally specified), waits for a keypress and, finally, prints out the value at that same address again in case it has been externally updated (which is done by the subsequent program listing):
	The following demonstrates how it is possible to read/write memory that is "owned" by a different process:

⚫	This program has a global variable. It prints out the virtual address of the global, waits for a keypress and ~~then~~ prints out the address again in case it has been externally updated:
	<pre>		<pre>
	#include <stdlib.h>		#include <stdlib.h>
Line 36:		Line 34:
	</pre>		</pre>

	This program reads in an address as an argument and ~~reads~~ the value at that ~~location~~ even though it does not "own" the memory. By adding an additional argument, this program can also write to that "foreign" address:		This program reads in an address as an argument and prints the value at that address even though it does not "own" the memory. By adding an additional argument, this program can also write to that "foreign" address. After this program is complete, you can press a key on the previous program and see that the value changed:
	<pre>		<pre>
	#include <stdlib.h>		#include <stdlib.h>
Line 49:		Line 47:
	volatile char byte = (volatile char)strtol(argv[1],NULL,16);		volatile char byte = (volatile char)strtol(argv[1],NULL,16);
	printf("Selected Virtual Address : %p\n",(void*)byte);		printf("Selected Virtual Address : %p\n",(void*)byte);
	printf("~~Dereferencd~~ Value of Address: %d\n",*byte);		printf("Dereferenced Value of Address: %d\n",*byte);
	if(argc==3)		if(argc==3)
	{		{

Ryan Dixon: /* Program Address Space */

2023-11-04T15:13:45Z

Program Address Space

← Older revision		Revision as of 15:13, 4 November 2023
Line 20:		Line 20:
	#include <stdio.h>		#include <stdio.h>

	volatile char x = ~~128~~;		volatile char x = 127;

	/* Usage: a [VAL] */		/* Usage: a [VAL] */

Ryan Dixon at 15:13, 4 November 2023

2023-11-04T15:13:09Z

← Older revision		Revision as of 15:13, 4 November 2023
Line 20:		Line 20:
	#include <stdio.h>		#include <stdio.h>

	volatile char x = ~~255~~;		volatile char x = 128;

	/* Usage: a [VAL] */		/* Usage: a [VAL] */

Ryan Dixon: A mention on AmigaOS' Program Address Space

2023-11-04T15:08:59Z

A mention on AmigaOS' Program Address Space

← Older revision		Revision as of 15:08, 4 November 2023
Line 8:		Line 8:

	The "downside" is that the virtual address of a memory block is almost never identical to the physical address. This isn't much of a downside, since an application will never really need to care about it. If an application allocates a block of memory of n bytes, it will get a pointer back that points to at least n continuous addresses as expected. The pages that "fill" this memory block may come from different physical locations scattered throughout the physical memory but a program will never noticed that. For all intent and purpose, the application sees a single continuous block of memory.		The "downside" is that the virtual address of a memory block is almost never identical to the physical address. This isn't much of a downside, since an application will never really need to care about it. If an application allocates a block of memory of n bytes, it will get a pointer back that points to at least n continuous addresses as expected. The pages that "fill" this memory block may come from different physical locations scattered throughout the physical memory but a program will never noticed that. For all intent and purpose, the application sees a single continuous block of memory.

			=== Program Address Space ===

			It is important to remember that, just like in classic AmigaOS, a single address space is used for all programs. Sometimes the mention of an MMU can lead people to assume that each process on the Amiga will have its own personal, partitioned address space. The following two programs demonstrate that, even though they are separate processes, it is possible to read and write another's memory. The memory locations are the same virtual address and that virtual address maps onto the same physical address.

			The following demonstrates how it is possible to read/write memory that is "owned" by a different process:

			This program has a global variable. It prints out the virtual address of the global, waits for a keypress and then prints out the address again in case it has been externally updated:
			<pre>
			#include <stdlib.h>
			#include <stdio.h>

			volatile char x = 255;

			/* Usage: a [VAL] */
			int main(int argc, char *argv[])
			{
			if(argc==2)
			x = (char)atoi(argv[1]);

			printf("Virtual Address of `x': %p\n", (void*)&x);
			printf("Dereferenced Value of `x': %d\n", x);
			(void)getchar();
			printf("Final Value of `x': %d\n", x);
			return 0;
			}
			</pre>

			This program reads in an address as an argument and reads the value at that location even though it does not "own" the memory. By adding an additional argument, this program can also write to that "foreign" address:
			<pre>
			#include <stdlib.h>
			#include <stdio.h>

			/* Usage: b ADDR [VAL_TO_WRITE] */
			int main(int argc, char *argv[])
			{
			if(!(argc==2 \|\| argc==3))
			return 10;

			volatile char byte = (volatile char)strtol(argv[1],NULL,16);
			printf("Selected Virtual Address : %p\n",(void*)byte);
			printf("Dereferencd Value of Address: %d\n",*byte);
			if(argc==3)
			{
			printf("Writing Value `%d' to Address: %p\n",atoi(argv[2]),(void*)byte);
			*byte=(char)atoi(argv[2]);
			}

			return 0;
			}
			</pre>

	=== Slab allocation ===		=== Slab allocation ===

Steven Solie: /* Sample Code for Allocating Multiple Memory Blocks */

2016-10-04T16:22:04Z

Sample Code for Allocating Multiple Memory Blocks

← Older revision		Revision as of 16:22, 4 October 2016
Line 505:		Line 505:
	} memblocks; /* part of the same data structure */		} memblocks; /* part of the same data structure */

	~~VOID~~ main()		int main()
	{		{
	memblocks.mn_head.ml_NumEntries = 4; /* 4! Since the MemEntry starts at 1! */		memblocks.mn_head.ml_NumEntries = 4; /* 4! Since the MemEntry starts at 1! */
Line 533:		Line 533:
	IDOS->Printf("AllocTaskMemEntry succeeded - now freeing all allocated blocks\n");		IDOS->Printf("AllocTaskMemEntry succeeded - now freeing all allocated blocks\n");
	IExec->FreeEntry(memlist);		IExec->FreeEntry(memlist);

			return 0;
	}		}
	</syntaxhighlight>		</syntaxhighlight>

Steven Solie: /* Function Reference */

2014-08-28T18:27:30Z

Function Reference

← Older revision		Revision as of 18:27, 28 August 2014
Line 604:		Line 604:
	\|-		\|-
	\| AllocMem()		\| AllocMem()
	\| Allocate memory with specified attributes. This function is obsolete.		\| Allocate memory with specified attributes. '''This function is obsolete.'''
	\|-		\|-
	\| AllocAbs()		\| AllocAbs()

Steven Solie: /* Function Reference */

2014-08-28T18:26:16Z

Function Reference

← Older revision		Revision as of 18:26, 28 August 2014
Line 605:		Line 605:
	\| AllocMem()		\| AllocMem()
	\| Allocate memory with specified attributes. This function is obsolete.		\| Allocate memory with specified attributes. This function is obsolete.
	\|-
	\| AddMemList()
	\| Add memory to the system free pool.
	\|-		\|-
	\| AllocAbs()		\| AllocAbs()
	\| Allocate memory at a specified location.		\| Allocate memory at a specified location.
	\|-
	\| Allocate()
	\| Allocate memory from a private memory pool.
	\|-		\|-
	\| AllocTaskMemEntry()		\| AllocTaskMemEntry()
Line 632:		Line 626:
	\| CopyMemQuick()		\| CopyMemQuick()
	\| Copy aligned memory block.		\| Copy aligned memory block.
	\|-
	\| Deallocate()
	\| Return memory block allocated, with Allocate() to the private memory pool.
	\|-		\|-
	\| FreeEntry()		\| FreeEntry()