xmp_sort.c File Reference

#include <stdlib.h>
#include <string.h>
#include "xmp_internal.h"

Include dependency graph for xmp_sort.c:

Macros
#define	THRESHOLD_BSEARCH   8
#define	THRESHOLD_2WAY   32
#define	THRESHOLD_KWAY   THRESHOLD_2WAY*2
#define	COMPARE_UP(_type)
#define	COMPARE_DOWN(_type)
#define	PIVOT(_type)

Functions
void	dbg_printf (char *fmt,...)
void	xmp_sort_up (_XMP_array_t *a_desc, _XMP_array_t *b_desc)
void	xmp_sort_down (_XMP_array_t *a_desc, _XMP_array_t *b_desc)
void	_XMP_sort (_XMP_array_t *a_desc, _XMP_array_t *b_desc, int is_up)
void	xmpc_gmv_g_alloc (_XMP_gmv_desc_t **gmv_desc, _XMP_array_t *ap)
void	xmpc_gmv_g_dim_info (_XMP_gmv_desc_t *gp, int i, int kind, int lb, int len, int st)
void	xmpc_gmv_dealloc (_XMP_gmv_desc_t *gp)
void	xmpc_gmv_do (_XMP_gmv_desc_t *gmv_desc_leftp, _XMP_gmv_desc_t *gmv_desc_rightp, int mode)

Variables
int(*	compare_func )(const void *a, const void *b)
void(*	get_rotate_pivot )(void *p, const void *a, const int an, const void *b, const int bn)
size_t	datasize
MPI_Datatype	mpi_type

Macro Definition Documentation

COMPARE_DOWN

#define COMPARE_DOWN

(

_type

)

Value:

(const void *a, const void *b){ \
  if (*(_type *)a > *(_type *)b){ \
    return -1; \
  } \
  else if(*(_type *)a == *(_type *)b){ \
    return 0; \
  } \
  return 1; \
}

COMPARE_UP

#define COMPARE_UP

(

_type

)

Value:

(const void *a, const void *b){ \
  if (*(_type *)a < *(_type *)b){ \
    return -1; \
  } \
  else if(*(_type *)a == *(_type *)b){ \
    return 0; \
  } \
  return 1; \
}

PIVOT

#define PIVOT

(

_type

)

Value:

(void *p, const void *a, const int an, \
          const void *b, const int bn){ \
  _type am = 0, bm = 0; \
  if (an > 0){ \
    if (an % 2 == 0) \
      am = (((_type *)a)[an / 2] + ((_type *)a)[an / 2 - 1]) / 2; \
    else \
      am = ((_type *)a)[an / 2]; \
  } \
  if (bn > 0){ \
    if (bn % 2 == 0) \
      bm = (((_type *)b)[bn / 2] + ((_type *)b)[bn / 2 - 1]) / 2; \
    else \
      bm = ((_type *)b)[bn / 2]; \
  } \
  _type tmp; \
  if (an > 0 && bn > 0) tmp = (am + bm) / 2; \
  else if (an > 0 && bn == 0) tmp = am; \
  else if (an == 0 && bn > 0) tmp = bm; \
  memcpy(p, &tmp, datasize); \
}

THRESHOLD_2WAY

#define THRESHOLD_2WAY   32

THRESHOLD_BSEARCH

#define THRESHOLD_BSEARCH   8

THRESHOLD_KWAY

#define THRESHOLD_KWAY   THRESHOLD_2WAY*2

Function Documentation

_XMP_sort()

void _XMP_sort	(	_XMP_array_t *	a_desc,
		_XMP_array_t *	b_desc,
		int	is_up
	)

                                                                     {
 
  void *a_adr = a_desc->array_addr_p;
  int a_lshadow = a_desc->info[0].shadow_size_lo;
 
  int a_size = a_desc->info[0].ser_size;
  int a_ndims = a_desc->dim;
  int a_type = a_desc->type;
 
  int b_size = b_desc->info[0].ser_size;
  int b_ndims = b_desc->dim;
  int b_type = b_desc->type;
 
  if (a_size != b_size) _XMP_fatal("xmp_sort: different size for array arguments");
  if (a_ndims != 1 || b_ndims != 1) _XMP_fatal("xmp_sort: array arguments must be one-dimensional");
  if (a_type != b_type) _XMP_fatal("xmp_sort: different type for array arguments");
 
  int lsize = a_desc->info[0].par_size;
 
  comm = a_desc->array_nodes->comm;
  me = a_desc->array_nodes->comm_rank;
  nprocs = a_desc->array_nodes->comm_size;
 
  set_funcs(a_desc, is_up);
  datasize = a_desc->type_size;
 
  do_sort((char *)a_adr + a_lshadow * datasize, lsize, b_desc);
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

dbg_printf()

void dbg_printf	(	char *	fmt,
			...
	)

                               {
  ;
}

xmp_sort_down()

void xmp_sort_down	(	_XMP_array_t *	a_desc,
		_XMP_array_t *	b_desc
	)

                                                              {
  _XMP_sort(a_desc, b_desc, 0);
}

Here is the call graph for this function:

xmp_sort_up()

void xmp_sort_up	(	_XMP_array_t *	a_desc,
		_XMP_array_t *	b_desc
	)

                                                            {
  _XMP_sort(a_desc, b_desc, 1);
}

Here is the call graph for this function:

xmpc_gmv_dealloc()

void xmpc_gmv_dealloc

(

_XMP_gmv_desc_t *

gp

)

                                     {
 
  _XMP_free(gp->kind);
  _XMP_free(gp->lb);
  _XMP_free(gp->ub);
  _XMP_free(gp->st);
 
  _XMP_free(gp->a_lb);
  _XMP_free(gp->a_ub);
 
  _XMP_free(gp);
 
}

Here is the call graph for this function:

xmpc_gmv_do()

void xmpc_gmv_do	(	_XMP_gmv_desc_t *	gmv_desc_leftp,
		_XMP_gmv_desc_t *	gmv_desc_rightp,
		int	mode
	)

{
 
  _XMP_pack_comm_set = _XMPC_pack_comm_set;
  _XMP_unpack_comm_set = _XMPC_unpack_comm_set;
 
  if (gmv_desc_leftp->is_global && gmv_desc_rightp->is_global){
    _XMP_gmove_garray_garray(gmv_desc_leftp, gmv_desc_rightp, mode);
  }
  else if (gmv_desc_leftp->is_global && !gmv_desc_rightp->is_global){
    if (gmv_desc_rightp->ndims == 0){
      _XMP_gmove_garray_scalar(gmv_desc_leftp, gmv_desc_rightp->local_data, mode);
    }
    else {
      _XMP_array_t *a = NULL;
      _XMPC_larray_alloc(&a, gmv_desc_rightp,
                           gmv_desc_leftp->a_desc->type, gmv_desc_leftp->a_desc->align_template);
      _XMP_gmove_garray_larray(gmv_desc_leftp, gmv_desc_rightp, mode);
      _XMP_finalize_array_desc(a);
    }
  }
  else if (!gmv_desc_leftp->is_global && gmv_desc_rightp->is_global){
    if (gmv_desc_leftp->ndims == 0){
      _XMP_gmove_scalar_garray(gmv_desc_leftp->local_data, gmv_desc_rightp, mode);
    }
    else {
 
      _XMP_ASSERT(gmv_desc_rightp->a_desc);
 
      // create a temporal descriptor for the "non-distributed" LHS array (to be possible used
      // in _XMP_gmove_1to1)
      _XMP_array_t *a = NULL;
      _XMPC_larray_alloc(&a, gmv_desc_leftp,
                         gmv_desc_rightp->a_desc->type, gmv_desc_rightp->a_desc->align_template);
      _XMP_gmove_larray_garray(gmv_desc_leftp, gmv_desc_rightp, mode);
      _XMP_finalize_array_desc(a);
 
    }
  }
  else {
    _XMP_fatal("gmv_do: both sides are local.");
  }
 
}

xmpc_gmv_g_alloc()

void xmpc_gmv_g_alloc	(	_XMP_gmv_desc_t **	gmv_desc,
		_XMP_array_t *	ap
	)

{
  _XMP_gmv_desc_t *gp;
  int n = ap->dim;
 
  gp = (_XMP_gmv_desc_t *)_XMP_alloc(sizeof(_XMP_gmv_desc_t));
 
  gp->kind = (int *)_XMP_alloc(sizeof(int) * n);
  gp->lb = (int *)_XMP_alloc(sizeof(int) * n);
  gp->ub = (int *)_XMP_alloc(sizeof(int) * n);
  gp->st = (int *)_XMP_alloc(sizeof(int) * n);
  
  if (!gp || !gp->kind || !gp->lb || !gp->st)
    _XMP_fatal("gmv_g_alloc: cannot alloc memory");
 
  gp->is_global = true;
  gp->ndims = n;
  gp->a_desc = ap;
 
  gp->local_data = NULL;
  gp->a_lb = NULL;
  gp->a_ub = NULL;
 
  *gmv_desc = gp;
}

Here is the call graph for this function:

xmpc_gmv_g_dim_info()

void xmpc_gmv_g_dim_info	(	_XMP_gmv_desc_t *	gp,
		int	i,
		int	kind,
		int	lb,
		int	len,
		int	st
	)

{
  gp->kind[i] = kind;
 
  switch (kind){
  case XMP_N_GMOVE_ALL:
    gp->lb[i] = gp->a_desc->info[i].ser_lower;
    gp->ub[i] = gp->a_desc->info[i].ser_upper;
    gp->st[i] = 1;
    break;
  case XMP_N_GMOVE_INDEX:
  case XMP_N_GMOVE_RANGE:
    gp->lb[i] = lb;
    gp->ub[i] = lb + st * (len - 1);
    gp->st[i] = st;
    break;
  default:
    _XMP_fatal("wrong gmove kind");
  }
 
}

Here is the call graph for this function:

Variable Documentation

compare_func

int(* compare_func) (const void *a, const void *b)

datasize

size_t datasize

get_rotate_pivot

void(* get_rotate_pivot) (void *p, const void *a, const int an, const void *b, const int bn)

mpi_type

MPI_Datatype mpi_type