/* Initialization */
int main (int argc, char** argv) {
int j,k;
srandom(SEED);
char fname[50];
sprintf(fname,"MM_PAR.%dP.%d.txt",NUM_THREADS,ARRAY_SIZE);
f = fopen(fname,"w+");
/*The number of threads */
fprintf(f,"Number of threads = %d\n",NUM_THREADS);
/*The number of data points for each experiment */
for(j=0; j<NUM_DATA_POINTS; j++) {
fprintf(f,"Array size = %d\n",ARRAY_SIZE);
CHUNK_SIZE = ARRAY_SIZE/NUM_THREADS;
fprintf(f,"Chunk size = %d\n",CHUNK_SIZE);
/* The inner loop to average for each data point */
for(k=0;k<NUM_TRIALS; k++) {
fprintf(f,"Trial = %d\n",k);
N = init_array();
M = init_array();
C = init_array();
randomize_array(N);
randomize_array(M);
par_multiply();
if(PRINT_SOLUTION)
print_array(C);
free(N);
free(M);
free(C);
}
ARRAY_SIZE += ARRAY_SIZE;
}
fclose(f);
pthread_exit(NULL);
return 0;
}
int min(int a[N]){
init_array(a);
#pragma xmp reduction(MIN:a)
for(int i=0;i<N;i++)
if(a[i] != (100+i))
return -1;
return 0;
}
int mult(int a[N]){
init_array(a);
#pragma xmp reduction(*:a)
for(int i=0;i<N;i++)
if(a[i] != (100+i)*(200+i)*(300+i))
return -1;
return 0;
}
int plus(int a[N]){
init_array(a);
#pragma xmp reduction(+:a)
for(int i=0;i<N;i++)
if(a[i] != (100+i)+(200+i)+(300+i))
return -1;
return 0;
}
int main(int argc, const char *argv[])
{
int array[N];
init_array(array,N);
print_array(array,N);
delete_same(array,N);
print_array(array,N);
return 0;
}
static void matrix_prod(Array mat1, Array mat2, int trans1, int trans2, Array ans)
/*
General matrix product between mat1 and mat2. Put answer in ans.
trans1 and trans2 are logical flags which indicate if the matrix is
to be transposed. Normal matrix multiplication has trans1 = trans2 = 0.
*/
{
int i,j,k,K1,K2;
const void *vmax;
double m1, m2;
Array tmp;
/* Test whether everything is a matrix */
assert(DIM_LENGTH(mat1) == 2 &&
DIM_LENGTH(mat2) == 2 && DIM_LENGTH(ans) == 2);
/* Test whether matrices conform. K is the dimension that is
lost by multiplication */
if (trans1) {
assert ( NCOL(mat1) == NROW(ans) );
K1 = NROW(mat1);
}
else {
assert ( NROW(mat1) == NROW(ans) );
K1 = NCOL(mat1);
}
if (trans2) {
assert ( NROW(mat2) == NCOL(ans) );
K2 = NCOL(mat2);
}
else {
assert ( NCOL(mat2) == NCOL(ans) );
K2 = NROW(mat2);
}
assert (K1 == K2);
tmp = init_array();
/* In case ans is the same as mat1 or mat2, we create a temporary
matrix to hold the answer, then copy it to ans
*/
vmax = vmaxget();
tmp = make_zero_matrix(NROW(ans), NCOL(ans));
for (i = 0; i < NROW(tmp); i++) {
for (j = 0; j < NCOL(tmp); j++) {
for(k = 0; k < K1; k++) {
m1 = (trans1) ? MATRIX(mat1)[k][i] : MATRIX(mat1)[i][k];
m2 = (trans2) ? MATRIX(mat2)[j][k] : MATRIX(mat2)[k][j];
MATRIX(tmp)[i][j] += m1 * m2;
}
}
}
copy_array(tmp, ans);
vmaxset(vmax);
}
int main(int argc, char** argv)
{
/* Retrieve problem size. */
int ni = NI;
int nj = NJ;
int nk = NK;
int nl = NL;
int nm = NM;
/* Variable declaration/allocation. */
POLYBENCH_2D_ARRAY_DECL(E, DATA_TYPE, NI, NJ, ni, nj);
POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, NI, NK, ni, nk);
POLYBENCH_2D_ARRAY_DECL(B, DATA_TYPE, NK, NJ, nk, nj);
POLYBENCH_2D_ARRAY_DECL(F, DATA_TYPE, NJ, NL, nj, nl);
POLYBENCH_2D_ARRAY_DECL(C, DATA_TYPE, NJ, NM, nj, nm);
POLYBENCH_2D_ARRAY_DECL(D, DATA_TYPE, NM, NL, nm, nl);
POLYBENCH_2D_ARRAY_DECL(G, DATA_TYPE, NI, NL, ni, nl);
/* Initialize array(s). */
init_array (ni, nj, nk, nl, nm,
POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B),
POLYBENCH_ARRAY(C),
POLYBENCH_ARRAY(D));
/* Start timer. */
polybench_start_instruments;
/* Run kernel. */
kernel_3mm (ni, nj, nk, nl, nm,
POLYBENCH_ARRAY(E),
POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B),
POLYBENCH_ARRAY(F),
POLYBENCH_ARRAY(C),
POLYBENCH_ARRAY(D),
POLYBENCH_ARRAY(G));
/* Stop and print timer. */
polybench_stop_instruments;
polybench_print_instruments;
/* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */
polybench_prevent_dce(print_array(ni, nl, POLYBENCH_ARRAY(G)));
/* Be clean. */
POLYBENCH_FREE_ARRAY(E);
POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(B);
POLYBENCH_FREE_ARRAY(F);
POLYBENCH_FREE_ARRAY(C);
POLYBENCH_FREE_ARRAY(D);
POLYBENCH_FREE_ARRAY(G);
return 0;
}
int main(void)
{
int a[N];
init_array(a, N);
show(a, N);
merge_sort(a, 0, N - 1);
show(a, N);
return 0;
}
int main(int argc, char** argv)
{
/* Prepare ctuning vars */
long ct_repeat=0;
long ct_repeat_max=1;
int ct_return=0;
/* Retrieve problem size. */
int n = N;
#ifdef OPENME
openme_init(NULL,NULL,NULL,0);
openme_callback("PROGRAM_START", NULL);
#endif
/* Variable declaration/allocation. */
POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n);
POLYBENCH_1D_ARRAY_DECL(p, DATA_TYPE, N, n);
/* Initialize array(s). */
init_array (n, POLYBENCH_ARRAY(p), POLYBENCH_ARRAY(A));
/* Start timer. */
polybench_start_instruments;
/* Run kernel. */
if (getenv("CT_REPEAT_MAIN")!=NULL) ct_repeat_max=atol(getenv("CT_REPEAT_MAIN"));
#ifdef OPENME
openme_callback("KERNEL_START", NULL);
#endif
for (ct_repeat=0; ct_repeat<ct_repeat_max; ct_repeat++)
kernel_cholesky (n, POLYBENCH_ARRAY(p), POLYBENCH_ARRAY(A));
#ifdef OPENME
openme_callback("KERNEL_END", NULL);
#endif
/* Stop and print timer. */
polybench_stop_instruments;
polybench_print_instruments;
/* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */
polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A)));
/* Be clean. */
POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(p);
#ifdef OPENME
openme_callback("PROGRAM_END", NULL);
#endif
return 0;
}
int main(int argc, char** argv)
{
#pragma hmpp atax acquire
/* Retrieve problem size. */
int nx = NX;
int ny = NY;
/* Variable declaration/allocation. */
POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, NX, NY, nx, ny);
POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, NY, ny);
POLYBENCH_1D_ARRAY_DECL(y, DATA_TYPE, NY, ny);
POLYBENCH_1D_ARRAY_DECL(tmp, DATA_TYPE, NX, nx);
#pragma hmpp atax allocate, &
#pragma hmpp & args[A].size={nx,ny}, args[A].hostdata="A", &
#pragma hmpp & args[x].size={ny}, args[x].hostdata="x", &
#pragma hmpp & args[y].size={ny}, args[y].hostdata="y", &
#pragma hmpp & args[tmp].size={nx}, args[tmp].hostdata="tmp"
/* Initialize array(s). */
init_array (nx, ny, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(x));
#pragma hmpp atax advancedload, args[A;x]
/* Start timer. */
polybench_start_instruments;
/* Run kernel. */
#pragma hmpp atax callsite
kernel_atax (nx, ny,
POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(x),
POLYBENCH_ARRAY(y),
POLYBENCH_ARRAY(tmp));
/* Stop and print timer. */
polybench_stop_instruments;
polybench_print_instruments;
#pragma hmpp atax delegatedstore, args[y]
/* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */
polybench_prevent_dce(print_array(nx, POLYBENCH_ARRAY(y)));
/* Be clean. */
POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(x);
POLYBENCH_FREE_ARRAY(y);
POLYBENCH_FREE_ARRAY(tmp);
#pragma hmpp atax release
return 0;
}
int main()
{
float cel[N], far[N];
init_array(cel, N);
cel2far(cel, far, N);
print_arrays(cel, far, N);
system("pause");
return 0;
}
int main() {
int a[N][N];
#pragma smecy map(OpenCL) arg(a, out)
init_array(a);
printf("a[27][42] = %d\n", a[27][42]);
return 0;
}
l4_cap_idx_t l4x_have_irqcap(int irqnum)
{
if (!init_done)
init_array();
if (irqnum >= BASE && (irqnum - BASE) < NR_REQUESTABLE)
return caps[irqnum - BASE];
return L4_INVALID_CAP;
}
int main()
{
int *array = init_array();
fillArray(array, 50);
squareArray(array, 50);
printArray(array, 50);
return 0;
}
int main(void)
{
int a[N];
init_array(a, N);
show_array(a, N);
insert_sort(a, N);
show_array(a, N);
return 0;
}
int main(int argc, char** argv)
{
init_array();
kernel_sor();
#ifdef PRINT
print_array();
#endif
return (int)X;
}
void trie_tree_insert_begin(int input_num)
{
assert(!be_creating);
assert(input_num > 0);
assert(input_cache.len==0);
assert(successor_array.len==0);
be_inserting = true;
init_array(&input_cache, sizeof(trie_input));
append_array(&input_cache, input_num);
}
int main(int argc, char** argv)
{
/* Retrieve problem size. */
int q = Q;
int d = D;
/* Variable declaration/allocation. */
POLYBENCH_2D_ARRAY_DECL(M, DATA_TYPE, Q, D, q, d);
POLYBENCH_2D_ARRAY_DECL(MatchQ, DATA_TYPE, Q, D, q, d);
POLYBENCH_1D_ARRAY_DECL(QS, DATA_TYPE, Q, q);
POLYBENCH_1D_ARRAY_DECL(DB, DATA_TYPE, D, d);
/* Initialize array(s). */
init_array (q, d,
POLYBENCH_ARRAY(QS),
POLYBENCH_ARRAY(DB),
POLYBENCH_ARRAY(MatchQ));
/* Start timer. */
polybench_start_instruments;
/*
DATA_TYPE POLYBENCH_1D(QS,Q,q),
DATA_TYPE POLYBENCH_1D(DB,D,d),
DATA_TYPE POLYBENCH_2D(MatchQ,Q,D,q,d),
DATA_TYPE POLYBENCH_2D(M,Q,D,q,d))
*/
/* Run kernel. */
kernel_mvt (q, d,
POLYBENCH_ARRAY(QS),
POLYBENCH_ARRAY(DB),
POLYBENCH_ARRAY(MatchQ),
POLYBENCH_ARRAY(M));
/* Stop and print timer. */
polybench_stop_instruments;
polybench_print_instruments;
/* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */
polybench_prevent_dce(print_array(q, d,
POLYBENCH_ARRAY(QS),
POLYBENCH_ARRAY(DB),
POLYBENCH_ARRAY(MatchQ)));
/* Be clean. */
POLYBENCH_FREE_ARRAY(M);
POLYBENCH_FREE_ARRAY(QS);
POLYBENCH_FREE_ARRAY(DB);
POLYBENCH_FREE_ARRAY(MatchQ);
return 0;
}
int main(void)
{
int a[N];
init_array(a, N);
show_array(a, N);
quick_sort(a, 0, N - 1);
show_array(a, N);
return 0;
}
int main(int argc, const char *argv[])
{
int array[M][N];
int *ptr = &array[0][0];
init_array(ptr , M*N);
printf_array(ptr , M*N);
getchar();
sort_array(ptr , 0 ,M*N-1);
printf_array(ptr , M*N);
return 0;
}
int main(int argc, const char *argv[])
{
int array[M];
init_array(array , M);
printf_array(array , M);
delete_same_data(array , M);
printf_array(array , M);
printf("\n");
printf_result(array , M);
return 0;
}
int main(void)
{
int array[10];
int *str;
init_array(array);
print_array(array);
change_array(array);
// print_array(str);
return 0;
}
int main() {
int i,
cmp;
//__CPROVER_assume(n < 5);
i = init_array(5);
bubble_sort(a,5);
cmp = a[0];
return 0;
}
int main(void)
{
int a[N];
init_array(a, N);
show_array(a, N);
bubble_sort(a, N);
show_array(a, N);
return 0;
}
static void init_generic_currval(struct gl_context *ctx)
{
struct vbo_context *vbo = vbo_context(ctx);
GLuint i;
for (i = 0; i < VERT_ATTRIB_GENERIC_MAX; i++) {
struct gl_vertex_array *cl = &vbo->currval[VBO_ATTRIB_GENERIC0 + i];
init_array(ctx, cl, 1, ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + i]);
}
}
int main(int argc, const char *argv[])
{
int array[N];
init_array(array);
print_array(array);
printf("\n");
sort(array);
print_array(array);
printf("\n");
return 0;
}
int main(int argc, char *argv[])
{
int array[M];
init_array(array, M);
print_array(array, M);
sort_array(array, M);
print_array(array, M);
return 0;
}
void generate_three_address_code(block_node * statements) {
// Writes basic functions to be used when generating three address code
//prepare_cfile("out.c");
int i = 0;
//init_array_vars(&vars, 2);
init_array(&lines, 2);
init_array(&functions, 2);
init_errors();
scope * root_scope = new_scope(NULL);
compile_block(statements, root_scope, &lines, 0);
if(num_of_errors > 0) {
print_array(&errors);
} else {
print_code(&lines);
write_to_file(&lines, 0, "w+");
}
}
void ejecutar(pila_tipo_dato *pilaPos, char *res ){
pila_tipo_dato auxresult;
pila_init(&auxresult);
int error=0;
char elemento[TAM_RES],result1[TAM_RES],result2[TAM_RES],resultOp[TAM_RES];
while(pilaPos->cant_element!=0)
{
//ceramos los vectores
init_array(result1,TAM_RES);
init_array(result2,TAM_RES);
init_array(elemento,TAM_RES);
init_array(resultOp,TAM_RES);
pila_desapilar(pilaPos,elemento);
//vemos si es operador
if (esOperador(elemento)==1)
{
if ((auxresult.cant_element)<2){
res[0]=elemento[0];
strcat(res,"Error!!");
pilaPos->cant_element=0;
error=1;
//ocurrio un error
}
pila_desapilar(&auxresult,result1);
pila_desapilar(&auxresult,result2);
operar(result1, result2,elemento[0],resultOp);
pila_apilar(&auxresult,resultOp);
if(error==0){pila_getfrente(&auxresult,res);}
}
else{
pila_apilar(&auxresult,elemento);
}
}
}
int main(int argc, char **argv)
{
int j;
init_array();
start_timer();
simple(A);
printf("A[0] = %d\n", A[0]);
end_timer();
}
