AmiWest Lesson 2 - Revision history

Costel Mincea: Text replacement - "" to ""

2025-01-26T19:12:08Z

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

← Older revision		Revision as of 19:12, 26 January 2025
Line 62:		Line 62:
	The different between static and dynamic linking can best be explained with an example.		The different between static and dynamic linking can best be explained with an example.

	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	#include <stdio.h>		#include <stdio.h>

Line 103:		Line 103:

	The following code can be used to open interfaces:		The following code can be used to open interfaces:
	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	struct Interface* try_open_iface_name(CONST_STRPTR libname, uint32 libver, CONST_STRPTR ifacename)		struct Interface* try_open_iface_name(CONST_STRPTR libname, uint32 libver, CONST_STRPTR ifacename)
	{		{
Line 138:		Line 138:

	The following code can be used to close an interface and the corresponding library:		The following code can be used to close an interface and the corresponding library:
	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	void close_iface(struct Interface* iface)		void close_iface(struct Interface* iface)
	{		{
Line 160:		Line 160:

	Notice how the first argument to the function call is 'hidden' when using the modified GNU GCC compiler. This becomes especially important when trying to understand error messages from the compiler. For example, the following code is invalid:		Notice how the first argument to the function call is 'hidden' when using the modified GNU GCC compiler. This becomes especially important when trying to understand error messages from the compiler. For example, the following code is invalid:
	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	#include <proto/exec.h>		#include <proto/exec.h>

Line 187:		Line 187:

	To create a new Process, DOS provides the following function:		To create a new Process, DOS provides the following function:
	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	struct Process *proc = CreateNewProcTags(uint32 Tag1, ...);		struct Process *proc = CreateNewProcTags(uint32 Tag1, ...);
	</syntaxhighlight>		</syntaxhighlight>

Steven Solie: /* Tasks and Processes */

2017-12-05T19:56:08Z

Tasks and Processes

← Older revision		Revision as of 19:56, 5 December 2017
Line 180:		Line 180:
	AmigaOS has two basic threads of control: Tasks and Processes. The following class diagram illustrates their relationship to each other:		AmigaOS has two basic threads of control: Tasks and Processes. The following class diagram illustrates their relationship to each other:

			[[File:ProcessTaskClassDiagram.png\|frame\|center]]
	<classdiagram type="orderly">
	[Process]-^[Task]
	</classdiagram>

	Tasks are created by Exec (exec.library) while Processes are created by DOS (dos.library). A Process includes more overhead than a Task. This is primarily because a Process can access all the facilities offered by DOS such as file handling and input and output streams.		Tasks are created by Exec (exec.library) while Processes are created by DOS (dos.library). A Process includes more overhead than a Task. This is primarily because a Process can access all the facilities offered by DOS such as file handling and input and output streams.

Steven Solie: /* Shared Objects */

2012-10-16T21:32:02Z

Shared Objects

← Older revision		Revision as of 21:32, 16 October 2012
Line 213:		Line 213:
	== Shared Objects ==		== Shared Objects ==

	Shared objects are an idea directly lifted from the Unix world. The main reason shared objects were added to AmigaOS is to enable much simpler porting of complex applications. For example, Amiga Python was implemented using shared objects which makes it very easy to maintain. It is up to each programmer to determine whether they want to use traditional Amiga shared libraries or shared objects for their particular ~~probject~~. For a discussion of the pros and cons see [[The_Right_Tool_for_the_Job_(Shared_Objects)\|The Right Tool for the Job]].		Shared objects are an idea directly lifted from the Unix world. The main reason shared objects were added to AmigaOS is to enable much simpler porting of complex applications. For example, Amiga Python was implemented using shared objects which makes it very easy to maintain. It is up to each programmer to determine whether they want to use traditional Amiga shared libraries or shared objects for their particular project. For a discussion of the pros and cons see [[The_Right_Tool_for_the_Job_(Shared_Objects)\|The Right Tool for the Job]].

Steven Solie: /* Shared Objects */

2012-10-16T21:31:18Z

Shared Objects

← Older revision		Revision as of 21:31, 16 October 2012
Line 212:		Line 212:

	== Shared Objects ==		== Shared Objects ==

			Shared objects are an idea directly lifted from the Unix world. The main reason shared objects were added to AmigaOS is to enable much simpler porting of complex applications. For example, Amiga Python was implemented using shared objects which makes it very easy to maintain. It is up to each programmer to determine whether they want to use traditional Amiga shared libraries or shared objects for their particular probject. For a discussion of the pros and cons see [[The_Right_Tool_for_the_Job_(Shared_Objects)\|The Right Tool for the Job]].

Steven Solie: /* Synchronization Primitives */

2012-10-16T21:26:15Z

Synchronization Primitives

← Older revision		Revision as of 21:26, 16 October 2012
Line 201:		Line 201:
	When two or more Tasks and/or Processes want to share common data with each other then synchronization primitives are likely to be required.		When two or more Tasks and/or Processes want to share common data with each other then synchronization primitives are likely to be required.

	Signals are the most basic way for two processes to communicate with each other. A signal is a single bit which is either 1 or 0. There are 16 user signals available and many system signals. See [[Exec_Signals\|Signals]] for more details.		* Signals are the most basic way for two processes to communicate with each other. A signal is a single bit which is either 1 or 0. There are 16 user signals available and many system signals. See [[Exec_Signals\|Signals]] for more details.

	~~One of the most basic services AmigaOS provides is that of message ports.~~ Message ports are used to transfer messages between two processes. The message can be sent one way or it can be sent and replied. Message data is always shared and not copied so it is critical that message passing protocols are followed. See [[Exec_Messages_and_Ports\|Messages and Ports]] for more details.		* Message ports are used to transfer messages between two processes. The message can be sent one way or it can be sent and replied. Message data is always shared and not copied so it is critical that message passing protocols are followed. See [[Exec_Messages_and_Ports\|Messages and Ports]] for more details.

	Semaphores provide a rich interface for sharing resources between processes. Sempahores can be shared so that multiple processes can wait on a single semaphore simultaneously. See [[Exec_Semaphores\|Semaphores]] for more details.		* Semaphores provide a rich interface for sharing resources between processes. Sempahores can be shared so that multiple processes can wait on a single semaphore simultaneously. See [[Exec_Semaphores\|Semaphores]] for more details.

	Mutexes provide a simple high speed interface for sharing resources between processes. Mutexes are exclusive and cannot be shared. Mutexes can also be recursive or not depending on the application. See [[Exec_Mutexes\|Mutexes]] for more details.		* Mutexes provide a simple high speed interface for sharing resources between processes. Mutexes are exclusive and cannot be shared. Mutexes can also be recursive or not depending on the application. See [[Exec_Mutexes\|Mutexes]] for more details.

	{{Note\|If you are sharing memory between two entities that memory must be marked as MEMF_SHARED. Failure to comply with this requirement will result in problems when AmigaOS starts to enforce MEMF_PRIVATE memory semantics.}}		{{Note\|If you are sharing memory between two entities that memory must be marked as MEMF_SHARED. Failure to comply with this requirement will result in problems when AmigaOS starts to enforce MEMF_PRIVATE memory semantics.}}

Steven Solie: /* Synchronization Primitives */

2012-10-16T21:25:37Z

Synchronization Primitives

← Older revision		Revision as of 21:25, 16 October 2012
Line 199:		Line 199:
	=== Synchronization Primitives ===		=== Synchronization Primitives ===

	When two or more Tasks and/or Processes want to share common data with each other synchronization primitives are likely to be required.		When two or more Tasks and/or Processes want to share common data with each other then synchronization primitives are likely to be required.

	Signals are the most basic way for two processes to communicate with each other. A signal is a single bit which is either 1 or 0. There are 16 user signals available and many system signals. See [[Exec_Signals\|Signals]] for more details.		Signals are the most basic way for two processes to communicate with each other. A signal is a single bit which is either 1 or 0. There are 16 user signals available and many system signals. See [[Exec_Signals\|Signals]] for more details.
Line 205:		Line 205:
	One of the most basic services AmigaOS provides is that of message ports. Message ports are used to transfer messages between two processes. The message can be sent one way or it can be sent and replied. Message data is always shared and not copied so it is critical that message passing protocols are followed. See [[Exec_Messages_and_Ports\|Messages and Ports]] for more details.		One of the most basic services AmigaOS provides is that of message ports. Message ports are used to transfer messages between two processes. The message can be sent one way or it can be sent and replied. Message data is always shared and not copied so it is critical that message passing protocols are followed. See [[Exec_Messages_and_Ports\|Messages and Ports]] for more details.

	Semaphores provide a rich interface for sharing resources between processes. See [[Exec_Semaphores\|Semaphores]] for more details.		Semaphores provide a rich interface for sharing resources between processes. Sempahores can be shared so that multiple processes can wait on a single semaphore simultaneously. See [[Exec_Semaphores\|Semaphores]] for more details.

			Mutexes provide a simple high speed interface for sharing resources between processes. Mutexes are exclusive and cannot be shared. Mutexes can also be recursive or not depending on the application. See [[Exec_Mutexes\|Mutexes]] for more details.

	{{Note\|If you are sharing memory between two entities that memory must be marked as MEMF_SHARED. Failure to comply with this requirement will result in problems when AmigaOS starts to enforce MEMF_PRIVATE memory semantics.}}		{{Note\|If you are sharing memory between two entities that memory must be marked as MEMF_SHARED. Failure to comply with this requirement will result in problems when AmigaOS starts to enforce MEMF_PRIVATE memory semantics.}}

Steven Solie at 21:21, 16 October 2012

2012-10-16T21:21:52Z

← Older revision		Revision as of 21:21, 16 October 2012
Line 200:		Line 200:

	When two or more Tasks and/or Processes want to share common data with each other synchronization primitives are likely to be required.		When two or more Tasks and/or Processes want to share common data with each other synchronization primitives are likely to be required.

			Signals are the most basic way for two processes to communicate with each other. A signal is a single bit which is either 1 or 0. There are 16 user signals available and many system signals. See [[Exec_Signals\|Signals]] for more details.

			One of the most basic services AmigaOS provides is that of message ports. Message ports are used to transfer messages between two processes. The message can be sent one way or it can be sent and replied. Message data is always shared and not copied so it is critical that message passing protocols are followed. See [[Exec_Messages_and_Ports\|Messages and Ports]] for more details.

			Semaphores provide a rich interface for sharing resources between processes. See [[Exec_Semaphores\|Semaphores]] for more details.

			{{Note\|If you are sharing memory between two entities that memory must be marked as MEMF_SHARED. Failure to comply with this requirement will result in problems when AmigaOS starts to enforce MEMF_PRIVATE memory semantics.}}

	== Shared Objects ==		== Shared Objects ==

Steven Solie: /* Synchronization Primitives */

2012-10-16T20:44:19Z

Synchronization Primitives

← Older revision		Revision as of 20:44, 16 October 2012
Line 198:		Line 198:

	=== Synchronization Primitives ===		=== Synchronization Primitives ===

			When two or more Tasks and/or Processes want to share common data with each other synchronization primitives are likely to be required.

	== Shared Objects ==		== Shared Objects ==

Steven Solie: /* Tasks and Processes */

2012-10-13T01:37:29Z

Tasks and Processes

← Older revision		Revision as of 01:37, 13 October 2012
Line 195:		Line 195:
	There are many tags which can be used to customize the way in which the new Process is created which are fully explained in the dos.doc AutoDoc.		There are many tags which can be used to customize the way in which the new Process is created which are fully explained in the dos.doc AutoDoc.

	Library base pointers (struct Library) may be global and shared between Processes. Interface pointers must not be shared between Processes unless this is explicitly allowed. The reason for this is because an Exec Interface may allocate resources which are bound to the context of the caller. That means if your parent Process calls GetInterface() then it allocates resources only for that Process. A child Process must call GetInterface() as well to allocate resources for that child Process.		Library base pointers (struct Library*) may be global and shared between Processes. Interface pointers must not be shared between Processes unless this is explicitly allowed. The reason for this is because an Exec Interface may allocate resources which are bound to the context of the caller. That means if your parent Process calls GetInterface() then it allocates resources only for that Process. A child Process must call GetInterface() as well to allocate resources for that child Process.

	Code to display Tasks and Processes.

	=== Synchronization Primitives ===		=== Synchronization Primitives ===

Steven Solie: /* Tasks and Processes */

2012-10-13T01:35:48Z

Tasks and Processes

← Older revision		Revision as of 01:35, 13 October 2012
Line 191:		Line 191:
	<syntaxhighlight>		<syntaxhighlight>
	struct Process *proc = CreateNewProcTags(uint32 Tag1, ...);		struct Process *proc = CreateNewProcTags(uint32 Tag1, ...);
	<syntaxhighlight>		</syntaxhighlight>

			There are many tags which can be used to customize the way in which the new Process is created which are fully explained in the dos.doc AutoDoc.

			Library base pointers (struct Library) may be global and shared between Processes. Interface pointers must not be shared between Processes unless this is explicitly allowed. The reason for this is because an Exec Interface may allocate resources which are bound to the context of the caller. That means if your parent Process calls GetInterface() then it allocates resources only for that Process. A child Process must call GetInterface() as well to allocate resources for that child Process.

	Code to display Tasks and Processes.		Code to display Tasks and Processes.

← Older revision		Revision as of 21:26, 16 October 2012
Line 201:		Line 201:
	When two or more Tasks and/or Processes want to share common data with each other then synchronization primitives are likely to be required.		When two or more Tasks and/or Processes want to share common data with each other then synchronization primitives are likely to be required.

	Signals are the most basic way for two processes to communicate with each other. A signal is a single bit which is either 1 or 0. There are 16 user signals available and many system signals. See [[Exec_Signals\|Signals]] for more details.		* Signals are the most basic way for two processes to communicate with each other. A signal is a single bit which is either 1 or 0. There are 16 user signals available and many system signals. See [[Exec_Signals\|Signals]] for more details.

	~~One of the most basic services AmigaOS provides is that of message ports.~~ Message ports are used to transfer messages between two processes. The message can be sent one way or it can be sent and replied. Message data is always shared and not copied so it is critical that message passing protocols are followed. See [[Exec_Messages_and_Ports\|Messages and Ports]] for more details.		* Message ports are used to transfer messages between two processes. The message can be sent one way or it can be sent and replied. Message data is always shared and not copied so it is critical that message passing protocols are followed. See [[Exec_Messages_and_Ports\|Messages and Ports]] for more details.

	Semaphores provide a rich interface for sharing resources between processes. Sempahores can be shared so that multiple processes can wait on a single semaphore simultaneously. See [[Exec_Semaphores\|Semaphores]] for more details.		* Semaphores provide a rich interface for sharing resources between processes. Sempahores can be shared so that multiple processes can wait on a single semaphore simultaneously. See [[Exec_Semaphores\|Semaphores]] for more details.

	Mutexes provide a simple high speed interface for sharing resources between processes. Mutexes are exclusive and cannot be shared. Mutexes can also be recursive or not depending on the application. See [[Exec_Mutexes\|Mutexes]] for more details.		* Mutexes provide a simple high speed interface for sharing resources between processes. Mutexes are exclusive and cannot be shared. Mutexes can also be recursive or not depending on the application. See [[Exec_Mutexes\|Mutexes]] for more details.

	{{Note\|If you are sharing memory between two entities that memory must be marked as MEMF_SHARED. Failure to comply with this requirement will result in problems when AmigaOS starts to enforce MEMF_PRIVATE memory semantics.}}		{{Note\|If you are sharing memory between two entities that memory must be marked as MEMF_SHARED. Failure to comply with this requirement will result in problems when AmigaOS starts to enforce MEMF_PRIVATE memory semantics.}}