Subversion Repositories forwardcom

/****************************  sumarray.as  ***********************************

* Author:        Agner Fog

* date created:  2018-02-24

* last modified: 2021-08-08

* Version:       1.11

* Project:       ForwardCom example, assembly code

* Description:   Calculates the sum of the numbers from 1 to 100

*

* This code will fill an array with the numbers from 1 to 100 and then

* calculate the sum. The purpose is to show how the variable-length vector

* instructions work.

* The expected result is the mean times the number: (1+100)*100/2 = 5050.

*

* Copyright 2018-2021 GNU General Public License http://www.gnu.org/licenses

*****************************************************************************/

%num = 100                                       // number of array elements

const section read ip                            // read-only data section

conclude: int8 "\nThe sum of numbers from 1 to %i is %i\n",0 // format string for printf

const end

bss section datap uninitialized                  // uninitialized read/write data section

int32 myarray[num]                               // array of 100 integers

int64 parlist[4]                                 // parameter list for printf

bss end

code section execute align = 4                   // code section

extern _printf: function                         // library function: formatted output to stdout

_main function public                            // program begins here

// Step 1: Fill myarray with numbers 1 .. 100

int64 r0 = num                                   // = 100

int32 v1 = make_sequence(r0, 1)                  // will be (1, 2, 3, ...) up to as much as the maximum vector length allows, or 100

int32 r1 = get_num(v1)                           // number of elements in vector

int64 r2 = r1 - 1                                // index to last element

int32 v2 = extract(v1, r2)                       // get last element and broadcast it

// A vector loop needs a pointer to the end of the array

int64 r2 = address [myarray+num*4]               // address of the end of myarray

int64 r1 = num * 4                               // total array size in bytes

// This loop will count down r1 with the maximum length until the array is filled

// The last iteration will automatically get fewer elements if the array size is not divisible by the maximum length

for (int32 v1 in [r2-r1]) {

   int32 [r2-r1, length = r1] = v1               // put as many elements into the array as the maximum length permits

   int32 v1 += v2                                // add up the vector of sequential numbers

}

// Step 2: Calculate the sum of all elements in the array

int32 v0 = replace(v1, 0)                        // make a vector of all zeroes and same length

int64 r1 = num * 4                               // total array size in bytes

// vector loop, counting down r1 with the maximum length until the array is filled

for (int32 v0 in [r2-r1]) {

   int32 v0 += [r2-r1, length = r1]              // add elements to vector

}

// Step 3: Calculate the horizontal sum of the elements in v0

int32 r1 = get_len(v0)                           // length of vector in bytes

// Round up the vector length to the nearest power of 2.

// The maximum vector length is known to be a power of 2,

// but the length may be 'num' elements, which is not a power of 2

int32 r1 = roundp2(r1, 1)                        // r1 is now a power of 2, not bigger than the maximum vector length

int32 v0 = set_len(v0, r1)                       // adjust vector length to nearest higher power of 2. Added elements will be zero

while (uint32+ r1 > 4) {                         // loop to calculate horizontal sum

   uint32+ r1 >>= 1                              // the vector length is halved

   int32 v1 = shift_reduce (v0, r1)              // get upper half of vector

   // Add upper half and lower half

   // The result vector has the length of the first operand, which will be halved each iteration

   int32 v0 = v1 + v0

}

// The sum is now a scalar in v0

// Step 4: Write the result

int64 r0 = address([conclude])                   // format string for printf

int64 r1 = address([parlist])                    // parameter list

int32 [r1] = num                                 // put number into parameter list

int32 [r1+8, scalar] = v0                        // put result into parameter list

call _printf                                     // printf("\nThe sum of numbers from 1 to %i is %i", num, v0)

// Return from main

int64 r0 = 0                                     // program return value

return                                           // return from main

_main end

code end