char *
hypre_MAlloc( int size )
{
char *ptr;
if (size > 0)
{
#ifdef HYPRE_USE_UMALLOC
int threadid = hypre_GetThreadID();
ptr = _umalloc_(size);
#else
ptr = malloc(size);
#endif
#if 1
if (ptr == NULL)
{
hypre_OutOfMemory(size);
}
#endif
}
else
{
ptr = NULL;
}
return ptr;
}
char *
hypre_ReAlloc( char *ptr,
int size )
{
#ifdef HYPRE_USE_UMALLOC
if (ptr == NULL)
{
ptr = hypre_MAlloc(size);
}
else if (size == 0)
{
hypre_Free(ptr);
}
else
{
int threadid = hypre_GetThreadID();
ptr = _urealloc_(ptr, size);
}
#else
ptr = realloc(ptr, size);
#endif
#if 1
if ((ptr == NULL) && (size > 0))
{
hypre_OutOfMemory(size);
}
#endif
return ptr;
}
char *
hypre_CAlloc( int count,
int elt_size )
{
char *ptr;
int size = count*elt_size;
if (size > 0)
{
#ifdef HYPRE_USE_UMALLOC
int threadid = hypre_GetThreadID();
ptr = _ucalloc_(count, elt_size);
#else
ptr = calloc(count, elt_size);
#endif
#if 1
if (ptr == NULL)
{
hypre_OutOfMemory(size);
}
#endif
}
else
{
ptr = NULL;
}
return ptr;
}
void
hypre_Free( char *ptr )
{
if (ptr)
{
#ifdef HYPRE_USE_UMALLOC
int threadid = hypre_GetThreadID();
_ufree_(ptr);
#else
free(ptr);
#endif
}
}
int
hypre_InitializeTiming( char *name )
{
int time_index;
double *old_wall_time;
double *old_cpu_time;
double *old_flops;
char **old_name;
int *old_state;
int *old_num_regs;
int new_name;
int i;
#ifdef HYPRE_USE_PTHREADS
int threadid = hypre_GetThreadID();
#endif
/*-------------------------------------------------------
* Allocate global TimingType structure if needed
*-------------------------------------------------------*/
if (hypre_global_timing == NULL)
{
#ifndef HYPRE_USE_PTHREADS
hypre_global_timing = hypre_CTAlloc(hypre_TimingType, 1);
#else
hypre_global_timing = hypre_CTAlloc(hypre_TimingType,
hypre_NumThreads + 1);
#endif
}
/*-------------------------------------------------------
* Check to see if name has already been registered
*-------------------------------------------------------*/
new_name = 1;
for (i = 0; i < (hypre_global_timing_ref(threadid, size)); i++)
{
if (hypre_TimingNumRegs(i) > 0)
{
if (strcmp(name, hypre_TimingName(i)) == 0)
{
new_name = 0;
time_index = i;
hypre_TimingNumRegs(time_index) ++;
break;
}
}
}
if (new_name)
{
for (i = 0; i < hypre_global_timing_ref(threadid ,size); i++)
{
if (hypre_TimingNumRegs(i) == 0)
{
break;
}
}
time_index = i;
}
/*-------------------------------------------------------
* Register the new timing name
*-------------------------------------------------------*/
if (new_name)
{
if (time_index == (hypre_global_timing_ref(threadid, size)))
{
old_wall_time = (hypre_global_timing_ref(threadid, wall_time));
old_cpu_time = (hypre_global_timing_ref(threadid, cpu_time));
old_flops = (hypre_global_timing_ref(threadid, flops));
old_name = (hypre_global_timing_ref(threadid, name));
old_state = (hypre_global_timing_ref(threadid, state));
old_num_regs = (hypre_global_timing_ref(threadid, num_regs));
(hypre_global_timing_ref(threadid, wall_time)) =
hypre_CTAlloc(double, (time_index+1));
(hypre_global_timing_ref(threadid, cpu_time)) =
hypre_CTAlloc(double, (time_index+1));
(hypre_global_timing_ref(threadid, flops)) =
hypre_CTAlloc(double, (time_index+1));
(hypre_global_timing_ref(threadid, name)) =
hypre_CTAlloc(char *, (time_index+1));
(hypre_global_timing_ref(threadid, state)) =
hypre_CTAlloc(int, (time_index+1));
(hypre_global_timing_ref(threadid, num_regs)) =
hypre_CTAlloc(int, (time_index+1));
(hypre_global_timing_ref(threadid, size)) ++;
for (i = 0; i < time_index; i++)
{
hypre_TimingWallTime(i) = old_wall_time[i];
hypre_TimingCPUTime(i) = old_cpu_time[i];
hypre_TimingFLOPS(i) = old_flops[i];
hypre_TimingName(i) = old_name[i];
hypre_TimingState(i) = old_state[i];
hypre_TimingNumRegs(i) = old_num_regs[i];
}
hypre_TFree(old_wall_time);
hypre_TFree(old_cpu_time);
hypre_TFree(old_flops);
hypre_TFree(old_name);
hypre_TFree(old_state);
hypre_TFree(old_num_regs);
}
hypre_TimingName(time_index) = hypre_CTAlloc(char, 80);
strncpy(hypre_TimingName(time_index), name, 79);
hypre_TimingState(time_index) = 0;
hypre_TimingNumRegs(time_index) = 1;
(hypre_global_timing_ref(threadid, num_names)) ++;
}
double
hypre_StructOverlapInnerProd( hypre_StructVector *x,
hypre_StructVector *y )
{
double final_innerprod_result;
double local_result, overlap_result;
double process_result;
hypre_Box *x_data_box;
hypre_Box *y_data_box;
hypre_BoxArray *overlap_boxes;
HYPRE_Int xi;
HYPRE_Int yi;
double *xp;
double *yp;
hypre_BoxArray *boxes;
hypre_Box *boxi, *boxj, intersect_box;
hypre_StructGrid *grid= hypre_StructVectorGrid(y);
hypre_BoxManager *boxman = hypre_StructGridBoxMan(grid);
hypre_BoxArray *neighbor_boxes;
HYPRE_Int *neighbors_procs= NULL;
hypre_BoxArray *selected_nboxes;
hypre_BoxArray *tmp_box_array, *tmp2_box_array;
hypre_Index loop_size;
hypre_IndexRef start;
hypre_Index unit_stride;
HYPRE_Int i, j;
HYPRE_Int myid;
HYPRE_Int boxarray_size;
HYPRE_Int loopi, loopj, loopk;
#ifdef HYPRE_USE_PTHREADS
HYPRE_Int threadid = hypre_GetThreadID();
#endif
local_result = 0.0;
process_result = 0.0;
hypre_SetIndex(unit_stride, 1, 1, 1);
hypre_MPI_Comm_rank(hypre_StructVectorComm(y), &myid);
/*-----------------------------------------------------------------------
* Determine the overlapped boxes on this local processor.
*-----------------------------------------------------------------------*/
boxes = hypre_StructGridBoxes(hypre_StructVectorGrid(y));
boxarray_size= hypre_BoxArraySize(boxes);
/*-----------------------------------------------------------------------
* To compute the inner product over this local processor, given a box,
* the inner product between x & y is computed over the whole box and
* over any overlapping between this box and overlap_boxes. The latter
* result is subtracted from the former. Overlapping between more than
* two boxes are handled.
*-----------------------------------------------------------------------*/
hypre_ForBoxI(i, boxes)
{
boxi = hypre_BoxArrayBox(boxes, i);
start = hypre_BoxIMin(boxi);
x_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(x), i);
y_data_box = hypre_BoxArrayBox(hypre_StructVectorDataSpace(y), i);
xp = hypre_StructVectorBoxData(x, i);
yp = hypre_StructVectorBoxData(y, i);
hypre_BoxGetSize(boxi, loop_size);
#ifdef HYPRE_USE_PTHREADS
local_result_ref[threadid] = &local_result;
#endif
hypre_BoxLoop2Begin(loop_size,
x_data_box, start, unit_stride, xi,
y_data_box, start, unit_stride, yi);
#define HYPRE_BOX_SMP_PRIVATE loopk,loopi,loopj,xi,yi
#define HYPRE_SMP_REDUCTION_OP +
#define HYPRE_SMP_REDUCTION_VARS local_result
#include "hypre_box_smp_forloop.h"
hypre_BoxLoop2For(loopi, loopj, loopk, xi, yi)
{
local_result += xp[xi] * yp[yi];
}
