#include <stdlib.h>

#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 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 i;

long 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 i;

long 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 i;

long 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 i;

long 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 i;

long 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 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 */

/* 2 x 1 loop unrolling */

void combine5(vec_ptr v, data_t *dest)

{

long i;

long length = vec_length(v);

long 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 i;

long length = vec_length(v);

long 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 */

/* 2 x 1 loop unrolling, 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 i = 0;

long length = vec_length(v);

long 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 i;

long length = vec_length(v);

long 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 i;

long length = vec_length(v);

long 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 i;

long length = vec_length(v);

long 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 i;

long length = vec_length(v);

long 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 i;

long length = vec_length(v);

long 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 i;

long length = vec_length(v);

long 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 i;

long length = vec_length(v);

long 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 i;

long length = vec_length(v);

long 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 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 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 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 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 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 */

/* 2 x 2 loop unrolling */

void combine6(vec_ptr v, data_t *dest)

{

long i;

long length = vec_length(v);

long 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 i;

long length = vec_length(v);

long 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 i;

long length = vec_length(v);

long 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 i;

long length = vec_length(v);

long 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 i;

long length = vec_length(v);

long 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 i;

long length = vec_length(v);

long 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 i;

long length = vec_length(v);

long 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 i;

long length = vec_length(v);

long 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 unroll16x16a_descr[] = "unroll16x16a: Array code, unrolled by 16, Superscalar x16";

void unroll16x16a_combine(vec_ptr v, data_t *dest)

{

long i;

long length = vec_length(v);

long limit = length-15;

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;

data_t acc12= IDENT;

data_t acc13= IDENT;

data_t acc14= IDENT;

data_t acc15= IDENT;

/* Combine 16 elements at a time */

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

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];

acc12 = acc12 OP data[i+12];

acc13 = acc13 OP data[i+13];

acc14 = acc14 OP data[i+14];

acc15 = acc15 OP data[i+15];

}

/* 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))

OP ((acc12 OP acc13) OP (acc14 OP acc15));

}

char unroll20x20a_descr[] = "unroll20x20a: Array code, unrolled by 20, Superscalar x20";

void unroll20x20a_combine(vec_ptr v, data_t *dest)

{

long i;

long length = vec_length(v);

long limit = length-19;

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;

data_t acc12= IDENT;

data_t acc13= IDENT;

data_t acc14= IDENT;

data_t acc15= IDENT;

data_t acc16= IDENT;

data_t acc17= IDENT;

data_t acc18= IDENT;

data_t acc19= IDENT;

/* Combine 20 elements at a time */

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

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];

acc12 = acc12 OP data[i+12];

acc13 = acc13 OP data[i+13];

acc14 = acc14 OP data[i+14];

acc15 = acc15 OP data[i+15];

acc16 = acc16 OP data[i+16];

acc17 = acc17 OP data[i+17];

acc18 = acc18 OP data[i+18];

acc19 = acc19 OP data[i+19];

}

/* 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)))

OP

(((acc12 OP acc13) OP (acc14 OP acc15)) OP ((acc16 OP acc17) OP (acc18 OP acc19)));

}

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

void unroll5x5a_combine(vec_ptr v, data_t *dest)

{

long i;

long length = vec_length(v);

long 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 i;

long length = vec_length(v);

long 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 i;

long length = vec_length(v);

long 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);

}