Parallel array - Revision history

Frap: /* Pros and cons */

2024-12-17T21:52:20Z

Pros and cons

← Previous revision		Revision as of 21:52, 17 December 2024
Line 66:		Line 66:
	* Perhaps worst of all, they greatly raise the possibility of errors. Any insertion, deletion, or move must always be applied consistently to all of the arrays, or the arrays will no longer be synchronized with each other, leading to bizarre outcomes.		* Perhaps worst of all, they greatly raise the possibility of errors. Any insertion, deletion, or move must always be applied consistently to all of the arrays, or the arrays will no longer be synchronized with each other, leading to bizarre outcomes.

	The bad locality of reference can be alleviated in some cases: if a structure can be divided into groups of fields that are generally accessed together, an array can be constructed for each group, and its elements are records containing only these subsets of the larger structure's fields. (see [[data oriented design]]). This is a valuable way of speeding up access to very large structures with many members, while keeping the portions of the structure tied together. An alternative to tying them together using array indexes is to use [[Reference (computer science)\|reference]]s to tie the portions together, but this can be less efficient in time and space.		The bad locality of reference can be alleviated in some cases: if a structure can be divided into groups of fields that are generally accessed together, an array can be constructed for each group, and its elements are records containing only these subsets of the larger structure's fields. (see [[data-oriented design]]). This is a valuable way of speeding up access to very large structures with many members, while keeping the portions of the structure tied together. An alternative to tying them together using array indexes is to use [[Reference (computer science)\|reference]]s to tie the portions together, but this can be less efficient in time and space.

	Another alternative is to use a single array, where each entry is a record structure. Many language provide a way to declare actual records, and arrays of them. In other languages it may be feasible to simulate this by declaring an array of n*m size, where m is the size of all the fields together, packing the fields into what is effectively a record, even though the particular language lacks direct support for records. Some [[compiler optimization]]s, particularly for [[vector processor]]s, are able to perform this transformation automatically when arrays of structures are created in the program.{{Citation needed\|date=April 2012}}		Another alternative is to use a single array, where each entry is a record structure. Many language provide a way to declare actual records, and arrays of them. In other languages it may be feasible to simulate this by declaring an array of n*m size, where m is the size of all the fields together, packing the fields into what is effectively a record, even though the particular language lacks direct support for records. Some [[compiler optimization]]s, particularly for [[vector processor]]s, are able to perform this transformation automatically when arrays of structures are created in the program.{{Citation needed\|date=April 2012}}

2A00:79E0:2E3F:8:CD14:FDAA:58F1:51E1: Fix grammar

2024-12-12T02:44:21Z

Fix grammar

← Previous revision		Revision as of 02:44, 12 December 2024
Line 55:		Line 55:
	* They may allow efficient processing with [[SIMD instruction]]s in certain [[instruction set architecture]]s		* They may allow efficient processing with [[SIMD instruction]]s in certain [[instruction set architecture]]s

	Several of these ~~advantage~~ depend strongly on the particular programming language and implementation in use.		Several of these advantages depend strongly on the particular programming language and implementation in use.

	However, parallel arrays also have several strong disadvantages, which serves to explain why they are not generally preferred:		However, parallel arrays also have several strong disadvantages, which serves to explain why they are not generally preferred:

217.86.175.31: /* Pros and cons */

2022-09-09T09:40:08Z

Pros and cons

← Previous revision		Revision as of 09:40, 9 September 2022
Line 62:		Line 62:
	* They obscure the relationship between fields of a single record (e.g. no type information relates the index between them, an index may be used erroneously).		* They obscure the relationship between fields of a single record (e.g. no type information relates the index between them, an index may be used erroneously).
	* They have little direct language support (the language and its syntax typically express no relationship between the arrays in the parallel array, and cannot catch errors).		* They have little direct language support (the language and its syntax typically express no relationship between the arrays in the parallel array, and cannot catch errors).
	* Since the bundle of fields is not a "thing", passing it around it tedious and error-prone. For example, rather than calling a function to do something to one record (or structure or object), the function must take the fields as separate arguments. When a new field is added or changed, many parameter lists must change, where passing objects as whole would avoid such changes entirely.		* Since the bundle of fields is not a "thing", passing it around is tedious and error-prone. For example, rather than calling a function to do something to one record (or structure or object), the function must take the fields as separate arguments. When a new field is added or changed, many parameter lists must change, where passing objects as whole would avoid such changes entirely.
	* They are expensive to grow or shrink, since each of several arrays must be reallocated. Multi-level arrays can ameliorate this problem, but impacts performance due to the additional indirection needed to find the desired elements.		* They are expensive to grow or shrink, since each of several arrays must be reallocated. Multi-level arrays can ameliorate this problem, but impacts performance due to the additional indirection needed to find the desired elements.
	* Perhaps worst of all, they greatly raise the possibility of errors. Any insertion, deletion, or move must always be applied consistently to all of the arrays, or the arrays will no longer be synchronized with each other, leading to bizarre outcomes.		* Perhaps worst of all, they greatly raise the possibility of errors. Any insertion, deletion, or move must always be applied consistently to all of the arrays, or the arrays will no longer be synchronized with each other, leading to bizarre outcomes.

WikiLinuz: Reverted edits by WikiLinuz (talk) to last version by 205.175.106.193

2022-03-11T09:25:22Z

Reverted edits by WikiLinuz (talk) to last version by 205.175.106.193

← Previous revision		Revision as of 09:25, 11 March 2022
Line 83:		Line 83:
	[[Category:Articles with example Perl code]]		[[Category:Articles with example Perl code]]
	[[Category:Articles with example Python (programming language) code]]		[[Category:Articles with example Python (programming language) code]]
	[[Category:Data structures]]

WikiLinuz: added Category:Data structures using HotCat

2022-03-10T23:30:18Z

added Category:Data structures using HotCat

← Previous revision		Revision as of 23:30, 10 March 2022
Line 83:		Line 83:
	[[Category:Articles with example Perl code]]		[[Category:Articles with example Perl code]]
	[[Category:Articles with example Python (programming language) code]]		[[Category:Articles with example Python (programming language) code]]
			[[Category:Data structures]]

205.175.106.193: "Parallel arrays are simple to understand, particularly for beginners who may not fully understand records." - This is a very odd statement especially when comparing it against the list of cons. It also feels very biased to have in a pro and con list.

2021-08-09T15:53:07Z

"Parallel arrays are simple to understand, particularly for beginners who may not fully understand records." - This is a very odd statement especially when comparing it against the list of cons. It also feels very biased to have in a pro and con list.

← Previous revision		Revision as of 15:53, 9 August 2021
Line 50:		Line 50:

	Parallel arrays have a number of practical advantages over the normal approach:		Parallel arrays have a number of practical advantages over the normal approach:
	* Parallel arrays are simple to understand, particularly for beginners who may not fully understand records.
	* They can save a substantial amount of space in some cases by avoiding alignment issues. For example, some architectures work best if 4-byte integers are always stored beginning at memory locations that are multiple of 4. If the previous field was a single byte, 3 bytes might be wasted. Many modern compilers can automatically avoid such problems, though in the past some programmers would explicitly declare fields in order of decreasing alignment restrictions.		* They can save a substantial amount of space in some cases by avoiding alignment issues. For example, some architectures work best if 4-byte integers are always stored beginning at memory locations that are multiple of 4. If the previous field was a single byte, 3 bytes might be wasted. Many modern compilers can automatically avoid such problems, though in the past some programmers would explicitly declare fields in order of decreasing alignment restrictions.
	* If the number of items is small, array indices can occupy significantly less space than full pointers, particularly on some architectures.		* If the number of items is small, array indices can occupy significantly less space than full pointers, particularly on some architectures.

205.175.106.193: Remove that they are available in languages without C-like structs or objects since this is trivially true and the reader doesn't need this clutter. Arrays are available in most languages, an array of structures could be seens as an interleaved, falttened parallel array, so the same argument holds for arrays-of-structs as does this.

2021-08-09T15:48:08Z

Remove that they are available in languages without C-like structs or objects since this is trivially true and the reader doesn't need this clutter. Arrays are available in most languages, an array of structures could be seens as an interleaved, falttened parallel array, so the same argument holds for arrays-of-structs as does this.

← Previous revision		Revision as of 15:48, 9 August 2021
Line 50:		Line 50:

	Parallel arrays have a number of practical advantages over the normal approach:		Parallel arrays have a number of practical advantages over the normal approach:
	* They can be used in languages which support only arrays of primitive types and not of records (or perhaps don't support records at all).{{example needed\|date=January 2020}}
	* Parallel arrays are simple to understand, particularly for beginners who may not fully understand records.		* Parallel arrays are simple to understand, particularly for beginners who may not fully understand records.
	* They can save a substantial amount of space in some cases by avoiding alignment issues. For example, some architectures work best if 4-byte integers are always stored beginning at memory locations that are multiple of 4. If the previous field was a single byte, 3 bytes might be wasted. Many modern compilers can automatically avoid such problems, though in the past some programmers would explicitly declare fields in order of decreasing alignment restrictions.		* They can save a substantial amount of space in some cases by avoiding alignment issues. For example, some architectures work best if 4-byte integers are always stored beginning at memory locations that are multiple of 4. If the previous field was a single byte, 3 bytes might be wasted. Many modern compilers can automatically avoid such problems, though in the past some programmers would explicitly declare fields in order of decreasing alignment restrictions.

Artoria2e5: /* Pros and cons */

2021-05-03T05:04:03Z

Pros and cons

← Previous revision		Revision as of 05:04, 3 May 2021
Line 47:		Line 47:
	==Pros and cons==		==Pros and cons==
	{{no references\|section\|date=January 2018}}		{{no references\|section\|date=January 2018}}
			{{Pro and con list\|date=May 2021}}

	Parallel arrays have a number of practical advantages over the normal approach:		Parallel arrays have a number of practical advantages over the normal approach:

Ira Leviton: explictly->explicitly - Fix a typo in one click

2021-02-22T03:36:11Z

explictly->explicitly - Fix a typo in one click

← Previous revision		Revision as of 03:36, 22 February 2021
Line 51:		Line 51:
	* They can be used in languages which support only arrays of primitive types and not of records (or perhaps don't support records at all).{{example needed\|date=January 2020}}		* They can be used in languages which support only arrays of primitive types and not of records (or perhaps don't support records at all).{{example needed\|date=January 2020}}
	* Parallel arrays are simple to understand, particularly for beginners who may not fully understand records.		* Parallel arrays are simple to understand, particularly for beginners who may not fully understand records.
	* They can save a substantial amount of space in some cases by avoiding alignment issues. For example, some architectures work best if 4-byte integers are always stored beginning at memory locations that are multiple of 4. If the previous field was a single byte, 3 bytes might be wasted. Many modern compilers can automatically avoid such problems, though in the past some programmers would ~~explictly~~ declare fields in order of decreasing alignment restrictions.		* They can save a substantial amount of space in some cases by avoiding alignment issues. For example, some architectures work best if 4-byte integers are always stored beginning at memory locations that are multiple of 4. If the previous field was a single byte, 3 bytes might be wasted. Many modern compilers can automatically avoid such problems, though in the past some programmers would explicitly declare fields in order of decreasing alignment restrictions.
	* If the number of items is small, array indices can occupy significantly less space than full pointers, particularly on some architectures.		* If the number of items is small, array indices can occupy significantly less space than full pointers, particularly on some architectures.
	* Sequentially examining a single field of each record in the array is very fast on modern machines, since this amounts to a linear traversal of a single array, exhibiting ideal [[locality of reference]] and cache behaviour.		* Sequentially examining a single field of each record in the array is very fast on modern machines, since this amounts to a linear traversal of a single array, exhibiting ideal [[locality of reference]] and cache behaviour.

Frap: /* Examples */ code style Black

2020-11-02T13:28:00Z

Examples: code style Black

← Previous revision		Revision as of 13:28, 2 November 2020
Line 31:		Line 31:
	Or, in [[Python Programming Language\|Python]]:		Or, in [[Python Programming Language\|Python]]:
	<syntaxhighlight lang="python3">		<syntaxhighlight lang="python3">
	first_names = ['Joe', 'Bob', 'Frank', 'Hans' ]		first_names = ["Joe", "Bob", "Frank", "Hans" ]
	last_names = ['Smith','Seger','Sinatra','Schultze']		last_names = ["Smith","Seger","Sinatra","Schultze"]
	heights_in_cm = [169, 158, 201, 199 ]		heights_in_cm = [169, 158, 201, 199 ]

	for i in range(len(first_names)):		for i in range(len(first_names)):
	print("Name: %s %s" % (first_names[i], last_names[i]))		print("Name: %s %s" % (first_names[i], last_names[i]))
	print("Height in CM: %s" % heights_in_cm[i])		print("Height in cm: %s" % heights_in_cm[i])

	# Using zip:		# Using zip:
	for first_name, last_name, height_in_cm in zip(first_names, last_names, heights_in_cm):		for first_name, last_name, height_in_cm in zip(first_names, last_names, heights_in_cm):
	print(f"Name: {first_name} {last_name}")		print(f"Name: {first_name} {last_name}")
	print(f"Height in CM: {height_in_cm}")		print(f"Height in cm: {height_in_cm}")
	</syntaxhighlight>		</syntaxhighlight>