Parallel array

From Wikipedia, the free encyclopedia
Jump to navigation Jump to search

In computing, a group of parallel arrays (also known as structure of arrays or SoA) is a form of implicit data structure that uses multiple arrays to represent a singular array of records. It keeps a separate, homogeneous data array for each field of the record, each having the same number of elements. Then, objects located at the same index in each array are implicitly the fields of a single record. Pointers from one object to another are replaced by array indices. This contrasts with the normal approach of storing all fields of each record together in memory (also known as array of structures or AoS). For example, one might declare an array of 100 names, each a string, and 100 ages, each an integer, associating each name with the age that has the same index.

An example in C using parallel arrays:

int  ages[]   = {0,          17,        2,          52,         25};
char *names[] = {"None",     "Mike",    "Billy",    "Tom",      "Stan"};
int  parent[] = {0 /*None*/, 3 /*Tom*/, 1 /*Mike*/, 0 /*None*/, 3 /*Tom*/};

for(i = 1; i <= 4; i++) {
    printf("Name: %s, Age: %d, Parent: %s \n",
           names[i], ages[i], names[parent[i]]);

in Perl (using a hash of arrays to hold references to each array):

my %data = (
    first_name   => ['Joe',  'Bob',  'Frank',  'Hans'    ],
    last_name    => ['Smith','Seger','Sinatra','Schultze'],
    height_in_cm => [169,     158,    201,      199      ]);

for $i (0..$#{$data{first_name}}) {
    printf "Name: %s %s\n", $data{first_name}[$i], $data{last_name}[$i];
    printf "Height in CM: %i\n", $data{height_in_cm}[$i];

Or, in Python:

first_names   = ['Joe',  'Bob',  'Frank',  'Hans'    ]
last_names    = ['Smith','Seger','Sinatra','Schultze']
heights_in_cm = [169,     158,    201,      199      ]

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

# Using zip:
for first_name, last_name, height in zip(first_names, last_names, heights_in_cm):
    print "Name: %s %s" % (first_name, last_name)
    print "Height in CM: %s" % height_in_cm

Pros and cons[edit]

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).
  • Parallel arrays are simple to understand and use, and are often used where declaring a record is more trouble than it's worth.
  • They can save a substantial amount of space in some cases by avoiding alignment issues. For example, one of the fields of the record can be a single bit, and its array would only need to reserve one bit for each record, whereas in the normal approach many more bits would "pad" the field so that it consumes an entire byte or a word.
  • If the number of items is small, array indices can occupy significantly less space than full pointers, particularly on architectures with large words.
  • 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.
  • They may allow efficient processing with SIMD instructions in certain instruction set architectures

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

  • They have significantly worse locality of reference when visiting the records non-sequentially and examining multiple fields of each record.
  • 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).
  • 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.

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 references to tie the portions together, but this can be less efficient in time and space. Another alternative is to mock up a record structure in a single-dimensional array by declaring an array of n*m size and referring to the r-th field in record i as element as array(m*i+r). Some compiler optimizations, particularly for vector processors, are able to perform this transformation automatically when arrays of structures are created in the program.[citation needed]

See also[edit]