/*                                                                    tab:8
 *
 * expar-dx.c - Experimental Data Sets (Sequential Code)
 *
 * 
 * "Copyright (c) 1996 The Regents of the University of Maryland.
 * All rights reserved.
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose, without fee, and without written agreement is
 * hereby granted, provided that the above copyright notice and the following
 * two paragraphs appear in all copies of this software.
 * 
 * IN NO EVENT SHALL THE UNIVERSITY OF MARYLAND BE LIABLE TO ANY PARTY FOR
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
 * MARYLAND HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 * THE UNIVERSITY OF MARYLAND SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF MARYLAND HAS NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS."
 *
 * Authors:             David A. Bader   <dbader@umiacs.umd.edu>
 *                      Joseph F. Ja'Ja' <joseph@umiacs.umd.edu>
 *                      Institute for Advanced Computer Studies
 *                      Department of Electrical Engineering 
 *                      AV Williams Building
 *                      College Park, MD 20742
 *                      
 * Version:             1.0
 * Creation Date:       July 25, 1996
 * Filename:            expar-dx.c
 * History:
 */

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <limits.h>
#include "expar-dx.h"
#include "nas_rand.h"

void assert_malloc(void *ptr) {
  if (ptr==NULL) {
    fprintf(stderr,"ERROR: null pointer\n");
    exit(-1);
  }
}

void RNG_init(int pid)
{
    srandom(pid*(int)time(0) + 17*pid*(int)floor(time(0)*317.0));
}

/************************************************************/
/*                      INTEGERS                            */
/************************************************************/

void fill_bench_i_N(int PROCS, int M, int **A)
{
    int i, pid;
    
    nas_srand();

    for (pid=0 ; pid<PROCS ; pid++) 
      for (i=0 ; i<M ; i++)
	A[pid][i] = nas_rand();
}

void fill_bench_i_C(int PROCS, int M, int **A)
{
    int i, pid;

    for (pid=0 ; pid<PROCS ; pid++) 
      for (i=0 ; i<M ; i++)
	A[pid][i] = pid + (i*PROCS);
}

void fill_pid(int PROCS, int M, int **A)
{
    int i, pid;
    
    for (pid=0 ; pid<PROCS ; pid++) 
      for (i=0 ; i<M ; i++)
	A[pid][i] = pid;
}


void fill_bench_i_Z(int PROCS, int M, int **A)
{
    int i, pid;
    
    for (pid=0 ; pid<PROCS ; pid++) 
      for (i=0 ; i<M ; i++)
	A[pid][i] = 0;
}


void fill_bench_i_random(int PROCS, int M, int **A, int distrib)
/*
  distrib  entropy
     0         0
     1        31
     2        25.1
     3        16.9
     4        10.4
     5         6.2
*/
{
    int i, pid;

    for (pid=0 ; pid<PROCS ; pid++) {
      RNG_init(pid);

      switch (distrib) {
      case 0:
	for (i=0 ; i<M ; i++)
	  A[pid][i] = 0;
	break;
      case 1:
	for (i=0 ; i<M ; i++)
	  A[pid][i] = random();
	break;
      case 2:
	for (i=0 ; i<M ; i++)
	  A[pid][i] = random() & random();
	break;
      case 3:
	for (i=0 ; i<M ; i++)
	  A[pid][i] = random() & random() & random();
	break;
      case 4:
	for (i=0 ; i<M ; i++)
	  A[pid][i] = random() & random() & random() & random();
	break;
      case 5:
	for (i=0 ; i<M ; i++)
	  A[pid][i] = random() & random() & random() & random() & random();
	break;
      }
    }
}

void fill_bench_i_R(int PROCS, int M, int **A) {
     return fill_bench_i_random(PROCS, M, A, 1);
}

void fill_bench_i_S(int PROCS, int M, int **A) {
     return fill_bench_i_random(PROCS, M, A, 5);
}

static inline
int hrel_lookup(int PROCS, int pid,
		int h, int M, int lastP, int *k, int idx)
{
    register int
	i,
	done;

    int addr;

    i    = 0;
    done = 0;
    while ((i<lastP)&&(!done)) 
	if (k[i] <= idx)
	    i++;
	else {
	    done = 1;
	    if (i==0)
		addr = idx;
	    else
		addr = i*h*M + idx - k[i-1];
	}
    if (!done) {
	i = PROCS*M - k[lastP-1]; 
	i = pid - PROCS + i;
	addr = (PROCS-1)*h*M + i;
    }

    return(addr);
}

void fill_hrel(int PROCS, int M, int **A, int h)
/* These are the destination addresses */
{
    int
      i,
      *k,
      lastP,
      pid;

    if (h==1)
      fill_bench_i_C(PROCS, M, A);
    else {
      k = (int *) malloc(PROCS * sizeof(int));
      for (pid=0 ; pid<PROCS ; pid++) {
	lastP = (2 * PROCS) / h;
	for (i=0 ; i<lastP ; i++) 
	  k[i] = (int)floor( (double)(h*M) * (double)(2*PROCS - h*(i+1)) /
			    (double)(2*PROCS - h) );
	for (i=1 ; i<lastP ; i++)
	  k[i] += k[i-1];
	for (i=0 ; i<M ; i++) 
	  A[pid][i] = hrel_lookup(PROCS, pid,
				     h, M, lastP, k, PROCS*i + pid +1);
      }
      free(k);
    }
}


void fill_bench_i_same(int PROCS, int M, int **A)
{
    int	i, pid;

    for (pid=0 ; pid<PROCS ; pid++)
      for (i=0 ; i<M ; i++)
	A[pid][i] = i;
}

void fill_bench_i_block(int PROCS, int M, int **A)
{
    int	i, j, pid;

    j=0;
    for (pid=0 ; pid<PROCS ; pid++)
      for (i=0 ; i<M ; i++)
	A[pid][i] = j++;
}

/************************************************************/
/*                      DOUBLES                             */
/************************************************************/

#if (defined(T3D))
#define MAX_VAL (double)1.79769313486231e+308
#else
#define MAX_VAL (double)1.7976931348623158e+308
#endif
#define RANDOM_MAX      pow(2.0,31.0)

void fill_bench_d_U(int PROCS, int M, double **B) {
  int i, pid;

  double multiplier, offset;

  offset     = RANDOM_MAX / 2.0;
  multiplier = MAX_VAL/offset;

  for (pid=0 ; pid<PROCS ; pid++) {
    srandom(23+1001*pid); 
    for (i=0 ; i<M ; i++)
      B[pid][i] = ((double)random() - offset) * multiplier;
  }
}


void fill_bench_d_G(int PROCS, int M, double **B){
  int i,j, pid;

  double  multiplier, offset;

  offset     = 2.0 * RANDOM_MAX;
  multiplier = MAX_VAL/offset;

  for (pid=0 ; pid<PROCS ; pid++) {
    srandom(23+1001*pid); 
    for (i=0 ; i<M ; i++) 
      B[pid][i] = ((double)random() + (double)random() +
		   (double)random() + (double)random() - offset) * multiplier;
  }
}


void fill_bench_d_g_group(int PROCS, int M, double **B, int group) {
    int
	i, j, k,
	v, pid;

    double
	multiplier,
	t1, t2,
	offset;

    offset = RANDOM_MAX/2.0;
    multiplier = MAX_VAL/offset;
    t1 = RANDOM_MAX/(double)PROCS;

    for (pid=0 ; pid<PROCS ; pid++) {
      srandom(23+1001*pid); 
      v = ((pid - (pid % group)) + (PROCS/2)) % PROCS;
      k=0;
      for (i=0 ; i<group ; i++) {
	t2 = ((double)v * t1) - offset;
	for (j=0 ; j<(M/group) ; j++)
	  B[pid][k++] = (t2 + ((double)random() / (double)PROCS)) * multiplier;
	v = (++v) % PROCS; 
      }
    }
}

void fill_bench_d_B(int PROCS, int M, double **B) {
  int
    i, j, k, pid;

  double
      t1, t2,
      multiplier,
      offset;

  offset = RANDOM_MAX/2.0;
  multiplier = MAX_VAL/offset;
  t1 = RANDOM_MAX/(double)PROCS;

  for (pid=0 ; pid<PROCS ; pid++) {
    srandom(23+1001*pid); 
    k=0;
    for (i=0 ; i<PROCS ; i++) {
      t2 = (double)i * t1 - offset;
      for (j=0 ; j<(M/PROCS) ; j++)
	B[pid][k++] = (t2 + ((double)random() / (double)PROCS)) * multiplier;
    }
  }
}

void fill_bench_d_S(int PROCS, int M, double **B) {
  int
    i, j, k,
    target, pid;

  double
      multiplier,
      offset,
      t1;
  
  offset = RANDOM_MAX/2.0;
  multiplier = MAX_VAL/offset;

  for (pid=0 ; pid<PROCS ; pid++) {
    srandom(23+1001*pid); 
    if (pid < (PROCS/2))
      target = 2*pid + 1;
    else 
      target = (pid - (PROCS/2))*2;
    t1 = (double)target * (RANDOM_MAX/(double)PROCS) - offset;
    k=0;
    for (i=0 ; i<M ; i++)
      B[pid][k++] = (t1 + ((double)random() / (double)PROCS)) * multiplier;
  }
}

void fill_bench_d_Z(int PROCS, int M, double **B){
  int i, pid;

  for (pid=0 ; pid<PROCS ; pid++)
    for (i=0 ; i<M ; i++)
      B[pid][i] = 0.0;
}

void print_2D_array_i(int PROCS, int M, int **A, char *str) {
  int i, pid;
  fprintf(stdout,"Array for Benchmark: %s with PROCS: %d  M: %d\n",
	  str,PROCS,M);

  fprintf(stdout,"pid -> ",pid);
  for (pid=0 ; pid<PROCS ; pid++) 
    fprintf(stdout," %12d",pid);
  fprintf(stdout,"\n",pid);
  for (i=0 ; i<(7+PROCS*13) ; i++)
    fprintf(stdout,"-");
  fprintf(stdout,"\n");
  
  for (i=0 ; i<M ; i++) {
    fprintf(stdout,"%6d:",i);
    for (pid=0 ; pid<PROCS ; pid++) 
      fprintf(stdout," %12d",A[pid][i]);
    fprintf(stdout,"\n");
  }
  fprintf(stdout,"\n");
}

void print_2D_array_d(int PROCS, int M, double **A, char *str) {
  int i, pid;
  fprintf(stdout,"Array for Benchmark: %s with PROCS: %d  M: %d\n",
	  str,PROCS,M);

  fprintf(stdout,"pid -> ",pid);
  for (pid=0 ; pid<PROCS ; pid++) 
    fprintf(stdout,"\t%12d",pid);
  fprintf(stdout,"\n",pid);
  for (i=0 ; i<(7+PROCS*16) ; i++)
    fprintf(stdout,"-");
  fprintf(stdout,"\n");
  
  for (i=0 ; i<M ; i++) {
    fprintf(stdout,"%6d:",i);
    for (pid=0 ; pid<PROCS ; pid++) 
      fprintf(stdout,"\t%+12.3g",A[pid][i]);
    fprintf(stdout,"\n");
  }
  fprintf(stdout,"\n");
}

main() {

  int i, PROCS, M, **A;
  double **B;

  PROCS = 4;
  M     = 32;

  A = (int **)malloc(PROCS * sizeof(int*));
  assert_malloc(A);
  for (i=0 ; i<PROCS ; i++) {
    A[i] = (int *)malloc(M * sizeof(int));
    assert_malloc(A[i]);
  }

  fill_bench_i_N(PROCS, M, A);
  print_2D_array_i(PROCS, M, A,"i [N]");

  fill_bench_i_C(PROCS, M, A);
  print_2D_array_i(PROCS, M, A,"i [C]");

  fill_bench_i_R(PROCS, M, A);
  print_2D_array_i(PROCS, M, A,"i [R]");

  fill_bench_i_S(PROCS, M, A);
  print_2D_array_i(PROCS, M, A,"i [S]");

  fill_bench_i_Z(PROCS, M, A);
  print_2D_array_i(PROCS, M, A,"i [Z]");
  
  fill_bench_i_same(PROCS, M, A);
  print_2D_array_i(PROCS, M, A,"i [same]");
  
  fill_bench_i_block(PROCS, M, A);
  print_2D_array_i(PROCS, M, A,"i [block]");
  
  for (i=PROCS-1 ; i>=0 ; i--)
     free(A[i]);
  free(A);

  B = (double **)malloc(PROCS * sizeof(double*));
  assert_malloc(B);
  for (i=0 ; i<PROCS ; i++) {
    B[i] = (double *)malloc(M * sizeof(double));
    assert_malloc(B[i]);
  }

  fill_bench_d_U(PROCS, M, B);
  print_2D_array_d(PROCS, M, B,"d [U]");

  fill_bench_d_G(PROCS, M, B);
  print_2D_array_d(PROCS, M, B,"d [G]");

  fill_bench_d_g_group(PROCS, M, B, 2);
  print_2D_array_d(PROCS, M, B,"d [g-2]");

  fill_bench_d_B(PROCS, M, B);
  print_2D_array_d(PROCS, M, B,"d [B]");

  fill_bench_d_S(PROCS, M, B);
  print_2D_array_d(PROCS, M, B,"d [S]");

  fill_bench_d_Z(PROCS, M, B);
  print_2D_array_d(PROCS, M, B,"d [Z]");

  for (i=PROCS-1 ; i>=0 ; i--)
     free(B[i]);
  free(B);
}