#include "combine.h"

/* Combining functions */

char combine1_descr[] = "combine1: Maximum use of data abstraction";

/* $begin combine1 */

/* Implementation with maximum use of data abstraction */

void combine1(vec_ptr v, data_t *dest)

{

long int i;

*dest = IDENT;

for (i = 0; i < vec_length(v); i++) {

data_t val;

get_vec_element(v, i, &val);

/* $begin combineline */

*dest = *dest OP val;

/* $end combineline */

}

}

/* $end combine1 */

char combine2_descr[] = "combine2: Take vec_length() out of loop";

/* $begin combine2 */

/* Move call to vec_length out of loop */

void combine2(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

*dest = IDENT;

for (i = 0; i < length; i++) {

data_t val;

get_vec_element(v, i, &val);

*dest = *dest OP val;

}

}

/* $end combine2 */

char combine3_descr[] = "combine3: Array reference to vector data";

/* $begin combine3 */

/* Direct access to vector data */

void combine3(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

data_t *data = get_vec_start(v);

*dest = IDENT;

for (i = 0; i < length; i++) {

*dest = *dest OP data[i];

}

}

/* $end combine3 */

char combine3w_descr[] = "combine3w: Update *dest within loop only with write";

/* $begin combine3w */

/* Make sure dest updated on each iteration */

void combine3w(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

data_t *data = get_vec_start(v);

data_t acc = IDENT;

/* Initialize in event length <= 0 */

*dest = acc;

for (i = 0; i < length; i++) {

acc = acc OP data[i];

*dest = acc;

}

}

/* $end combine3w */

char combine4_descr[] = "combine4: Array reference, accumulate in temporary";

/* $begin combine4 */

/* Accumulate result in local variable */

void combine4(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

data_t *data = get_vec_start(v);

data_t acc = IDENT;

for (i = 0; i < length; i++) {

acc = acc OP data[i];

}

*dest = acc;

}

/* $end combine4 */

char combine4b_descr[] = "combine4b: Include bonds check in loop";

/* $begin combine4b */

/* Include bounds check in loop */

void combine4b(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

data_t acc = IDENT;

for (i = 0; i < length; i++) {

if (i >= 0 && i < v->len) {

acc = acc OP v->data[i];

}

}

*dest = acc;

}

/* $end combine4b */

char combine4p_descr[] = "combine4p: Pointer reference, accumulate in temporary";

/* $begin combine4p */

/* Accumulate in local variable, pointer version */

void combine4p(vec_ptr v, data_t *dest)

{

long int length = vec_length(v);

data_t *data = get_vec_start(v);

data_t *dend = data+length;

data_t acc = IDENT;

for (; data < dend; data++)

acc = acc OP *data;

*dest = acc;

}

/* $end combine4p */

char combine5_descr[] = "combine5: Array code, unrolled by 2";

/* $begin combine5 */

/* Unroll loop by 2 */

void combine5(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-1;

data_t *data = get_vec_start(v);

data_t acc = IDENT;

/* Combine 2 elements at a time */

for (i = 0; i < limit; i+=2) {

/* $begin combine5-update */

acc = (acc OP data[i]) OP data[i+1];

/* $end combine5-update */

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc = acc OP data[i];

}

*dest = acc;

}

/* $end combine5 */

char unroll3a_descr[] = "unroll3a: Array code, unrolled by 3";

void unroll3a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-2;

data_t *data = get_vec_start(v);

data_t acc = IDENT;

/* Combine 3 elements at a time */

for (i = 0; i < limit; i+=3) {

acc = acc OP data[i];

acc = acc OP data[i+1];

acc = acc OP data[i+2];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc = acc OP data[i];

}

*dest = acc;

}

char combine5p_descr[] = "combine5p: Pointer code, unrolled by 2, for loop";

/* $begin combine5p */

/* Unroll loop by 2, pointer version */

void combine5p(vec_ptr v, data_t *dest)

{

data_t *data = get_vec_start(v);

data_t *dend = data+vec_length(v);

data_t *dlimit = dend-1;

data_t acc = IDENT;

/* Combine 3 elements at a time */

for (; data < dlimit; data += 2) {

acc = acc OP data[0] OP data[1];

}

/* Finish any remaining elements */

for (; data < dend; data++) {

acc = acc OP data[0];

}

*dest = acc;

}

/* $end combine5p */

char unroll2aw_descr[] = "unroll2aw: Array code, unrolled by 2, while loop";

void unroll2aw_combine(vec_ptr v, data_t *dest)

{

long int i = 0;

long int length = vec_length(v);

long int limit = length-1;

data_t *data = get_vec_start(v);

data_t acc = IDENT;

/* Combine 2 elements at a time */

while (i < limit) {

acc = acc OP data[i];

i+= 2;

acc = acc OP data[i-1];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc = acc OP data[i];

}

*dest = acc;

}

char unroll4a_descr[] = "unroll4a: Array code, unrolled by 4";

void unroll4a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-3;

data_t *data = get_vec_start(v);

data_t acc = IDENT;

/* Combine 4 elements at a time */

for (i = 0; i < limit; i+=4) {

acc = acc OP data[i] OP data[i+1];

acc = acc OP data[i+2] OP data[i+3];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc = acc OP data[i];

}

*dest = acc;

}

char unroll5a_descr[] = "unroll5a: Array code, unrolled by 5";

#if 0

/* $begin unroll5 */

void unroll5(vec_ptr v, data_t *dest)

/* $end unroll5 */

#else

void unroll5a_combine(vec_ptr v, data_t *dest)

#endif

/* $begin unroll5 */

{

long int i;

long int length = vec_length(v);

long int limit = length-4;

data_t *data = get_vec_start(v);

data_t acc = IDENT;

/* Combine 5 elements at a time */

for (i = 0; i < limit; i+=5) {

acc = acc OP data[i] OP data[i+1];

acc = acc OP data[i+2] OP data[i+3];

acc = acc OP data[i+4];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc = acc OP data[i];

}

*dest = acc;

}

/* $end unroll5 */

char unroll6a_descr[] = "unroll6a: Array code, unrolled by 6";

void unroll6a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-5;

data_t *data = get_vec_start(v);

data_t acc = IDENT;

/* Combine 6 elements at a time */

for (i = 0; i < limit; i+=6) {

acc = acc OP data[i] OP data[i+1];

acc = acc OP data[i+2] OP data[i+3];

acc = acc OP data[i+4] OP data[i+5];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc = acc OP data[i];

}

*dest = acc;

}

char unroll7a_descr[] = "unroll7a: Array code, unrolled by 7";

void unroll7a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-6;

data_t *data = get_vec_start(v);

data_t acc = IDENT;

/* Combine 7 elements at a time */

for (i = 0; i < limit; i+=7) {

acc = acc OP data[i] OP data[i+1];

acc = acc OP data[i+2] OP data[i+3];

acc = acc OP data[i+4] OP data[i+5];

acc = acc OP data[i+6];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc = acc OP data[i];

}

*dest = acc;

}

char unroll8a_descr[] = "unroll8a: Array code, unrolled by 8";

void unroll8a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-7;

data_t *data = get_vec_start(v);

data_t acc = IDENT;

/* Combine 8 elements at a time */

for (i = 0; i < limit; i+=8) {

acc = acc OP data[i] OP data[i+1];

acc = acc OP data[i+2] OP data[i+3];

acc = acc OP data[i+4] OP data[i+5];

acc = acc OP data[i+6] OP data[i+7];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc = acc OP data[i];

}

*dest = acc;

}

char unroll9a_descr[] = "unroll9a: Array code, unrolled by 9";

void unroll9a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-8;

data_t *data = get_vec_start(v);

data_t acc = IDENT;

/* Combine 9 elements at a time */

for (i = 0; i < limit; i+=9) {

acc = acc OP data[i] OP data[i+1];

acc = acc OP data[i+2] OP data[i+3];

acc = acc OP data[i+4] OP data[i+5];

acc = acc OP data[i+6] OP data[i+7];

acc = acc OP data[i+8];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc = acc OP data[i];

}

*dest = acc;

}

char unroll10a_descr[] = "unroll10a: Array code, unrolled by 10";

void unroll10a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-9;

data_t *data = get_vec_start(v);

data_t acc = IDENT;

/* Combine 10 elements at a time */

for (i = 0; i < limit; i+=10) {

acc = acc OP data[i] OP data[i+1];

acc = acc OP data[i+2] OP data[i+3];

acc = acc OP data[i+4] OP data[i+5];

acc = acc OP data[i+6] OP data[i+7];

acc = acc OP data[i+8] OP data[i+9];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc = acc OP data[i];

}

*dest = acc;

}

char unroll16a_descr[] = "unroll16a: Array code, unrolled by 16";

void unroll16a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-15;

data_t *data = get_vec_start(v);

data_t acc = IDENT;

/* Combine 16 elements at a time */

for (i = 0; i < limit; i+=16) {

acc = acc OP data[i] OP data[i+1];

acc = acc OP data[i+2] OP data[i+3];

acc = acc OP data[i+4] OP data[i+5];

acc = acc OP data[i+6] OP data[i+7];

acc = acc OP data[i+8] OP data[i+9];

acc = acc OP data[i+10] OP data[i+11];

acc = acc OP data[i+12] OP data[i+13];

acc = acc OP data[i+14] OP data[i+15];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc = acc OP data[i];

}

*dest = acc;

}

char unroll2_descr[] = "unroll2: Pointer code, unrolled by 2";

void unroll2_combine(vec_ptr v, data_t *dest)

{

long int length = vec_length(v);

data_t *data = get_vec_start(v);

int over = length%2;

data_t *dend = data+length-over;

data_t acc = IDENT;

while (data < dend) {

acc = acc OP data[0];

acc = acc OP data[1];

data += 2;

}

dend += over;

while (data < dend) {

acc = acc OP *data;

data ++;

}

*dest = acc;

}

char unroll3_descr[] = "unroll3: Pointer code, unrolled by 3";

void unroll3_combine(vec_ptr v, data_t *dest)

{

long int length = vec_length(v);

data_t *data = get_vec_start(v);

data_t *dend = data+length-2;

data_t acc = IDENT;

while (data < dend) {

acc = acc OP data[0];

acc = acc OP data[1];

acc = acc OP data[2];

data += 3;

}

dend += 2;

while (data < dend) {

acc = acc OP *data;

data ++;

}

*dest = acc;

}

char unroll4_descr[] = "unroll4: Pointer code, unrolled by 4";

void unroll4_combine(vec_ptr v, data_t *dest)

{

long int length = vec_length(v);

data_t *data = get_vec_start(v);

data_t *dend = data+length-3;

data_t acc = IDENT;

while (data < dend) {

acc = acc OP data[0];

acc = acc OP data[1];

acc = acc OP data[2];

acc = acc OP data[3];

data += 4;

}

dend += 3;

while (data < dend) {

acc = acc OP *data;

data ++;

}

*dest = acc;

}

char unroll8_descr[] = "unroll8: Pointer code, unrolled by 8";

void unroll8_combine(vec_ptr v, data_t *dest)

{

long int length = vec_length(v);

data_t *data = get_vec_start(v);

int over = length%8;

data_t *dend = data+length-over;

data_t acc = IDENT;

while (data < dend) {

acc = acc OP data[0];

acc = acc OP data[1];

acc = acc OP data[2];

acc = acc OP data[3];

acc = acc OP data[4];

acc = acc OP data[5];

acc = acc OP data[6];

acc = acc OP data[7];

data += 8;

}

dend += over;

while (data < dend) {

acc = acc OP *data;

data ++;

}

*dest = acc;

}

char unroll16_descr[] = "unroll16: Pointer code, unrolled by 16";

void unroll16_combine(vec_ptr v, data_t *dest)

{

long int length = vec_length(v);

data_t *data = get_vec_start(v);

int over = length%16;

data_t *dend = data+length-over;

data_t acc = IDENT;

while (data < dend) {

acc = acc OP data[0];

acc = acc OP data[1];

acc = acc OP data[2];

acc = acc OP data[3];

acc = acc OP data[4];

acc = acc OP data[5];

acc = acc OP data[6];

acc = acc OP data[7];

acc = acc OP data[8];

acc = acc OP data[9];

acc = acc OP data[10];

acc = acc OP data[11];

acc = acc OP data[12];

acc = acc OP data[13];

acc = acc OP data[14];

acc = acc OP data[15];

data += 16;

}

dend += over;

while (data < dend) {

acc = acc OP *data;

data ++;

}

*dest = acc;

}

char combine6_descr[] = "combine6: Array code, unrolled by 2, Superscalar x2";

/* $begin combine6 */

/* Unroll loop by 2, 2-way parallelism */

void combine6(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-1;

data_t *data = get_vec_start(v);

data_t acc0 = IDENT;

data_t acc1 = IDENT;

/* Combine 2 elements at a time */

for (i = 0; i < limit; i+=2) {

acc0 = acc0 OP data[i];

acc1 = acc1 OP data[i+1];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc0 = acc0 OP data[i];

}

*dest = acc0 OP acc1;

}

/* $end combine6 */

char unroll4x2a_descr[] = "unroll4x2a: Array code, unrolled by 4, Superscalar x2";

void unroll4x2a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-3;

data_t *data = get_vec_start(v);

data_t acc0 = IDENT;

data_t acc1 = IDENT;

/* Combine 4 elements at a time */

for (i = 0; i < limit; i+=4) {

acc0 = acc0 OP data[i]; acc1 = acc1 OP data[i+1];

acc0 = acc0 OP data[i+2]; acc1 = acc1 OP data[i+3];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc0 = acc0 OP data[i];

}

*dest = acc0 OP acc1;

}

char unroll8x2a_descr[] = "unroll8x2a: Array code, unrolled by 8, Superscalar x2";

void unroll8x2a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-7;

data_t *data = get_vec_start(v);

data_t acc0 = IDENT;

data_t acc1 = IDENT;

/* Combine 8 elements at a time */

for (i = 0; i < limit; i+=8) {

acc0 = acc0 OP data[i]; acc1 = acc1 OP data[i+1];

acc0 = acc0 OP data[i+2]; acc1 = acc1 OP data[i+3];

acc0 = acc0 OP data[i+4]; acc1 = acc1 OP data[i+5];

acc0 = acc0 OP data[i+6]; acc1 = acc1 OP data[i+7];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc0 = acc0 OP data[i];

}

*dest = acc0 OP acc1;

}

char unroll3x3a_descr[] = "unroll3x3a: Array code, unrolled by 3, Superscalar x3";

void unroll3x3a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-2;

data_t *data = get_vec_start(v);

data_t acc0 = IDENT;

data_t acc1 = IDENT;

data_t acc2 = IDENT;

/* Combine 4 elements at a time */

for (i = 0; i < limit; i+=3) {

acc0 = acc0 OP data[i]; acc1 = acc1 OP data[i+1];

acc2 = acc2 OP data[i+2];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc0 = acc0 OP data[i];

}

*dest = acc0 OP acc1 OP acc2;

}

char unroll4x4a_descr[] = "unroll4x4a: Array code, unrolled by 4, Superscalar x4";

void unroll4x4a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-3;

data_t *data = get_vec_start(v);

data_t acc0 = IDENT;

data_t acc1 = IDENT;

data_t acc2 = IDENT;

data_t acc3 = IDENT;

/* Combine 4 elements at a time */

for (i = 0; i < limit; i+=4) {

acc0 = acc0 OP data[i]; acc1 = acc1 OP data[i+1];

acc2 = acc2 OP data[i+2]; acc3 = acc3 OP data[i+3];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc0 = acc0 OP data[i];

}

*dest = (acc0 OP acc1) OP (acc2 OP acc3);

}

char unroll8x4a_descr[] = "unroll8x4a: Array code, unrolled by 8, Superscalar x4";

void unroll8x4a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-7;

data_t *data = get_vec_start(v);

data_t acc0 = IDENT;

data_t acc1 = IDENT;

data_t acc2 = IDENT;

data_t acc3 = IDENT;

/* Combine 8 elements at a time */

for (i = 0; i < limit; i+=8) {

acc0 = acc0 OP data[i]; acc1 = acc1 OP data[i+1];

acc2 = acc2 OP data[i+2]; acc3 = acc3 OP data[i+3];

acc0 = acc0 OP data[i+4]; acc1 = acc1 OP data[i+5];

acc2 = acc2 OP data[i+6]; acc3 = acc3 OP data[i+7];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc0 = acc0 OP data[i];

}

*dest = acc0 OP acc1 OP acc2 OP acc3;

}

char unroll12x6a_descr[] = "unroll2x6a: Array code, unrolled by 12, Superscalar x6";

void unroll12x6a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-11;

data_t *data = get_vec_start(v);

data_t acc0 = IDENT;

data_t acc1 = IDENT;

data_t acc2 = IDENT;

data_t acc3 = IDENT;

data_t acc4 = IDENT;

data_t acc5 = IDENT;

/* Combine 12 elements at a time */

for (i = 0; i < limit; i+=12) {

acc0 = acc0 OP data[i];

acc0 = acc0 OP data[i+6];

acc1 = acc1 OP data[i+1];

acc1 = acc1 OP data[i+7];

acc2 = acc2 OP data[i+2];

acc2 = acc2 OP data[i+8];

acc3 = acc3 OP data[i+3];

acc3 = acc3 OP data[i+9];

acc4 = acc4 OP data[i+4];

acc4 = acc4 OP data[i+10];

acc5 = acc5 OP data[i+5];

acc5 = acc5 OP data[i+11];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc0 = acc0 OP data[i];

}

*dest = (acc0 OP acc1) OP (acc2 OP acc3) OP (acc4 OP acc5);

}

char unroll12x12a_descr[] = "unroll12x12a: Array code, unrolled by 12, Superscalar x12";

void unroll12x12a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-11;

data_t *data = get_vec_start(v);

data_t acc0 = IDENT;

data_t acc1 = IDENT;

data_t acc2 = IDENT;

data_t acc3 = IDENT;

data_t acc4 = IDENT;

data_t acc5 = IDENT;

data_t acc6 = IDENT;

data_t acc7 = IDENT;

data_t acc8 = IDENT;

data_t acc9 = IDENT;

data_t acc10 = IDENT;

data_t acc11= IDENT;

/* Combine 12 elements at a time */

for (i = 0; i < limit; i+=12) {

acc0 = acc0 OP data[i];

acc6 = acc6 OP data[i+6];

acc1 = acc1 OP data[i+1];

acc7 = acc7 OP data[i+7];

acc2 = acc2 OP data[i+2];

acc8 = acc8 OP data[i+8];

acc3 = acc3 OP data[i+3];

acc9 = acc9 OP data[i+9];

acc4 = acc4 OP data[i+4];

acc10 = acc10 OP data[i+10];

acc5 = acc5 OP data[i+5];

acc11 = acc11 OP data[i+11];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc0 = acc0 OP data[i];

}

*dest = (acc0 OP acc1) OP (acc2 OP acc3) OP (acc4 OP acc5)

OP (acc6 OP acc7) OP (acc8 OP acc9) OP (acc10 OP acc11);

}

char unroll5x5a_descr[] = "unroll5x5a: Array code, unrolled by 5, Superscalar x5";

void unroll5x5a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-4;

data_t *data = get_vec_start(v);

data_t acc0 = IDENT;

data_t acc1 = IDENT;

data_t acc2 = IDENT;

data_t acc3 = IDENT;

data_t acc4 = IDENT;

/* Combine 5 elements at a time */

for (i = 0; i < limit; i+=5) {

acc0 = acc0 OP data[i]; acc1 = acc1 OP data[i+1];

acc2 = acc2 OP data[i+2]; acc3 = acc3 OP data[i+3];

acc4 = acc4 OP data[i+4];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc0 = acc0 OP data[i];

}

*dest = (acc0 OP acc1) OP (acc2 OP acc3 OP acc4);

}

char unroll6x6a_descr[] = "unroll6x6a: Array code, unrolled by 6, Superscalar x6";

void unroll6x6a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-5;

data_t *data = get_vec_start(v);

data_t acc0 = IDENT;

data_t acc1 = IDENT;

data_t acc2 = IDENT;

data_t acc3 = IDENT;

data_t acc4 = IDENT;

data_t acc5 = IDENT;

/* Combine 6 elements at a time */

for (i = 0; i < limit; i+=6) {

acc0 = acc0 OP data[i]; acc1 = acc1 OP data[i+1];

acc2 = acc2 OP data[i+2]; acc3 = acc3 OP data[i+3];

acc4 = acc4 OP data[i+4]; acc5 = acc5 OP data[i+5];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc0 = acc0 OP data[i];

}

*dest = (acc0 OP acc1) OP (acc2 OP acc3) OP (acc4 OP acc5);

}

char unroll7x7a_descr[] = "unroll7x7a: Array code, unrolled by 7, Superscalar x7";

void unroll7x7a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-6;

data_t *data = get_vec_start(v);

data_t acc0 = IDENT;

data_t acc1 = IDENT;

data_t acc2 = IDENT;

data_t acc3 = IDENT;

data_t acc4 = IDENT;

data_t acc5 = IDENT;

data_t acc6 = IDENT;

/* Combine 7 elements at a time */

for (i = 0; i < limit; i+=7) {

acc0 = acc0 OP data[i]; acc1 = acc1 OP data[i+1];

acc2 = acc2 OP data[i+2]; acc3 = acc3 OP data[i+3];

acc4 = acc4 OP data[i+4]; acc5 = acc5 OP data[i+5];

acc6 = acc6 OP data[i+6];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc0 = acc0 OP data[i];

}

*dest = ((acc0 OP acc1) OP (acc2 OP acc3)) OP (acc4 OP acc5 OP acc6);

}

char unroll8x8a_descr[] = "unroll8x8a: Array code, unrolled by 8, Superscalar x8";

void unroll8x8a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-7;

data_t *data = get_vec_start(v);

data_t acc0 = IDENT;

data_t acc1 = IDENT;

data_t acc2 = IDENT;

data_t acc3 = IDENT;

data_t acc4 = IDENT;

data_t acc5 = IDENT;

data_t acc6 = IDENT;

data_t acc7 = IDENT;

/* Combine 8 elements at a time */

for (i = 0; i < limit; i+=8) {

acc0 = acc0 OP data[i]; acc1 = acc1 OP data[i+1];

acc2 = acc2 OP data[i+2]; acc3 = acc3 OP data[i+3];

acc4 = acc4 OP data[i+4]; acc5 = acc5 OP data[i+5];

acc6 = acc6 OP data[i+6]; acc7 = acc7 OP data[i+7];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc0 = acc0 OP data[i];

}

*dest = ((acc0 OP acc1) OP (acc2 OP acc3)) OP ((acc4 OP acc5) OP (acc6 OP acc7));

}

char unroll9x9a_descr[] = "unroll9x9a: Array code, unrolled by 9, Superscalar x9";

void unroll9x9a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-8;

data_t *data = get_vec_start(v);

data_t acc0 = IDENT;

data_t acc1 = IDENT;

data_t acc2 = IDENT;

data_t acc3 = IDENT;

data_t acc4 = IDENT;

data_t acc5 = IDENT;

data_t acc6 = IDENT;

data_t acc7 = IDENT;

data_t acc8 = IDENT;

/* Combine 9 elements at a time */

for (i = 0; i < limit; i+=9) {

acc0 = acc0 OP data[i]; acc1 = acc1 OP data[i+1];

acc2 = acc2 OP data[i+2]; acc3 = acc3 OP data[i+3];

acc4 = acc4 OP data[i+4]; acc5 = acc5 OP data[i+5];

acc6 = acc6 OP data[i+6]; acc7 = acc7 OP data[i+7];

acc8 = acc8 OP data[i+8];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc0 = acc0 OP data[i];

}

*dest = ((acc0 OP acc1) OP (acc2 OP acc3)) OP ((acc4 OP acc5) OP (acc6 OP acc7) OP acc8);

}

char unroll10x10a_descr[] = "unroll10x10a: Array code, unrolled by 10, Superscalar x10";

void unroll10x10a_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length-9;

data_t *data = get_vec_start(v);

data_t acc0 = IDENT;

data_t acc1 = IDENT;

data_t acc2 = IDENT;

data_t acc3 = IDENT;

data_t acc4 = IDENT;

data_t acc5 = IDENT;

data_t acc6 = IDENT;

data_t acc7 = IDENT;

data_t acc8 = IDENT;

data_t acc9 = IDENT;

/* Combine 10 elements at a time */

for (i = 0; i < limit; i+=10) {

acc0 = acc0 OP data[i]; acc1 = acc1 OP data[i+1];

acc2 = acc2 OP data[i+2]; acc3 = acc3 OP data[i+3];

acc4 = acc4 OP data[i+4]; acc5 = acc5 OP data[i+5];

acc6 = acc6 OP data[i+6]; acc7 = acc7 OP data[i+7];

acc8 = acc8 OP data[i+8]; acc9 = acc9 OP data[i+9];

}

/* Finish any remaining elements */

for (; i < length; i++) {

acc0 = acc0 OP data[i];

}

*dest = ((acc0 OP acc1) OP (acc2 OP acc3)) OP

((acc4 OP acc5) OP (acc6 OP acc7)) OP

(acc8 OP acc9);

}

char unrollx2as_descr[] = "unrollx2as: Array code, Unroll x2, Superscalar x2, noninterleaved";

void unrollx2as_combine(vec_ptr v, data_t *dest)

{

long int i;

long int length = vec_length(v);

long int limit = length/2;

data_t *data = get_vec_start(v);

data_t *data2 = data+limit;

data_t acc0 = IDENT;

data_t acc1 = IDENT;

/* Combine 2 elements at a time */

for (i = 0; i < limit; i++) {

acc0 = acc0 OP data[i]; acc1 = acc1 OP data2[i];

}

/* Finish any remaining elements */

for (i = limit*2; i < length; i++) {