int main ()
{ int x = 1;
while (x == 1)
{
int selection;
printf("\nPerformance Assessment: \n");
printf("-----------------------\n");
printf("1) Enter parameters\n");
printf("2) Print table of parameters\n");
printf("3) Print table of performance\n");
printf("4) Quit\n\n");
printf("Enter Selection: ");
scanf("%d", &selection);
if (selection == 1)
enter_params();
else if (selection == 2)
print_params();
else if (selection == 3)
print_performance();
else if (selection == 4)
{
deallocate_memory();
x = 2;
}
}
return 0;
}
/*
* @brief Photographic tone-reproduction
*
* @param Y input luminance
* @param L output tonemapped intensities
* @param use_scales true: local version, false: global version of TMO
* @param key maps log average luminance to this value (default: 0.18)
* @param phi sharpening parameter (defaults to 1 - no sharpening)
* @param num number of scales to use in computation (default: 8)
* @param low size in pixels of smallest scale (should be kept at 1)
* @param high size in pixels of largest scale (default 1.6^8 = 43)
*/
void tmo_reinhard02(
unsigned int width, unsigned int height,
const float *nY, float *nL,
bool use_scales, float key, float phi,
int num, int low, int high, bool temporal_coherent )
{
const pfstmo::Array2D* Y = new pfstmo::Array2D(width, height, const_cast<float*>(nY));
pfstmo::Array2D* L = new pfstmo::Array2D(width, height, nL);
int x,y;
::key = key;
::phi = phi;
::range = num;
::scale_low = low;
::scale_high = high;
::use_scales = (use_scales) ? 1 : 0;
::temporal_coherent = temporal_coherent;
cvts.xmax = Y->getCols();
cvts.ymax = Y->getRows();
sigma_0 = log (scale_low);
sigma_1 = log (scale_high);
compute_bessel();
allocate_memory ();
// reading image
for( y=0 ; y<cvts.ymax ; y++ )
for( x=0 ; x<cvts.xmax ; x++ )
image[y][x][0] = (*Y)(x,y);
copy_luminance();
scale_to_midtone();
if( use_scales )
{
#ifdef APPROXIMATE
build_pyramid(luminance, cvts.xmax, cvts.ymax);
#else
compute_fourier_convolution();
#endif
}
tonemap_image();
// saving image
for( y=0 ; y<cvts.ymax ; y++ )
for( x=0 ; x<cvts.xmax ; x++ )
(*L)(x,y) = image[y][x][0];
// print_parameter_settings();
deallocate_memory();
clean_pyramid();
delete L;
delete Y;
}
/* main program reads data from stdin and controls all the action
*/
int main(int argc, char **argv)
{
char c;
int candID = 0, j, totalCands, totalVotes = 0, prefOrd, victorID, width = 0;
cand_t *candidates;
list_t *voter = make_list();
scanf("%d\n", &totalCands);
candidates = malloc(sizeof(cand_t) * totalCands);
assert(candidates != NULL);
/* Candidate names are stored and other variables of each candidate
struct are initialized */
for(j = 0 ; candID < totalCands; j = 0, candID++)
{
while ((c=getchar())!= CH_NEWLINE)
candidates[candID].name[j++] = c;
candidates[candID].name[j] = CH_NULL;
if(j > width)
width = j; /*width for printing names in output*/
candidates[candID].votes = 0;
candidates[candID].voterListArr = NULL;
candidates[candID].eliminated = FALSE;
}
candID = 0;
/* Preference values for each candidate by every voter is read */
while(scanf("%d", &prefOrd) == 1)
{
/* Each vote is added to a list of votes for particular voter */
insert_vote(voter, candID, prefOrd);
/* VictorID is the ID of cand. who is the first pref. of the voter*/
if(prefOrd == 1)
victorID = candID;
candID++;
/* When all the votes of the particular voter is stored, the list of
votes are assigned to the first-pref candidate */
if(candID == totalCands)
{
totalVotes++;
candID = 0;
insert_voter(candidates, victorID, voter);
voter = make_list();
}
}
/* Elimination process */
preferencing(candidates, totalCands, totalVotes, width);
deallocate_memory(candidates, totalCands);
return 0;
}
/** Custom realloc function with memory event recording. */
void* CU_realloc(void *ptr, size_t size, unsigned int uiLine, const char* szFileName)
{
void* pVoid = NULL;
deallocate_memory(ptr, uiLine, szFileName);
#ifdef CUNIT_BUILD_TESTS
if (CU_FALSE == f_bTestCunitMallocActive) {
free(ptr);
return NULL;
}
#endif
pVoid = realloc(ptr, size);
if (NULL != pVoid) {
allocate_memory(size, pVoid, uiLine, szFileName);
}
return pVoid;
}
/** Custom free function with memory event recording. */
void CU_free(void *ptr, unsigned int uiLine, const char* szFileName)
{
deallocate_memory(ptr, uiLine, szFileName);
free(ptr);
}
/* This version is the traditional level-synchronized BFS using two queues. A
* bitmap is used to indicate which vertices have been visited. Messages are
* sent and processed asynchronously throughout the code to hopefully overlap
* communication with computation. */
void run_bfs(int64_t root, int64_t* pred) {
allocate_memory();
const ptrdiff_t nlocalverts = g.nlocalverts;
const size_t* const restrict rowstarts = g.rowstarts;
const int64_t* const restrict column = g.column;
int64_t maxlocalverts = g.max_nlocalverts;
/* Set up the visited bitmap. */
const int ulong_bits = sizeof(unsigned long) * CHAR_BIT;
const int ulong_bits_squared = ulong_bits * ulong_bits;
int64_t local_queue_summary_size = (maxlocalverts + ulong_bits_squared - 1) / ulong_bits_squared;
int64_t local_queue_size = local_queue_summary_size * ulong_bits;
int lg_local_queue_size = lg_int64_t(local_queue_size);
int64_t global_queue_summary_size = MUL_SIZE(local_queue_summary_size);
int64_t global_queue_size = MUL_SIZE(local_queue_size);
#define SWIZZLE_VERTEX(c) ((VERTEX_OWNER(c) << lg_local_queue_size) * ulong_bits | VERTEX_LOCAL(c))
#if 0
int64_t* restrict column_swizzled = (int64_t*)xmalloc(nlocaledges * sizeof(int64_t));
{
size_t i;
for (i = 0; i < nlocaledges; ++i) {
int64_t c = column[i];
column_swizzled[i] = SWIZZLE_VERTEX(c);
}
}
#endif
unsigned long* restrict in_queue = g_in_queue;
memset(in_queue, 0, global_queue_size * sizeof(unsigned long));
unsigned long* restrict in_queue_summary = g_in_queue_summary;
memset(in_queue_summary, 0, global_queue_summary_size * sizeof(unsigned long));
unsigned long* restrict out_queue = g_out_queue;
unsigned long* restrict out_queue_summary = g_out_queue_summary;
unsigned long* restrict visited = g_visited;
memset(visited, 0, local_queue_size * sizeof(unsigned long));
#define SET_IN(v) do {int64_t vs = SWIZZLE_VERTEX(v); size_t word_idx = vs / ulong_bits; int bit_idx = vs % ulong_bits; unsigned long mask = (1UL << bit_idx); in_queue_summary[word_idx / ulong_bits] |= (1UL << (word_idx % ulong_bits)); in_queue[word_idx] |= mask;} while (0)
#define TEST_IN(vs) (((in_queue_summary[vs / ulong_bits / ulong_bits] & (1UL << ((vs / ulong_bits) % ulong_bits))) != 0) && ((in_queue[vs / ulong_bits] & (1UL << (vs % ulong_bits))) != 0))
#define TEST_VISITED_LOCAL(v) ((visited[(v) / ulong_bits] & (1UL << ((v) % ulong_bits))) != 0)
// #define SET_VISITED_LOCAL(v) do {size_t word_idx = (v) / ulong_bits; int bit_idx = (v) % ulong_bits; unsigned long mask = (1UL << bit_idx); __sync_fetch_and_or(&visited[word_idx], mask); __sync_fetch_and_or(&out_queue[word_idx], mask);} while (0)
#define SET_VISITED_LOCAL(v) do {size_t word_idx = (v) / ulong_bits; int bit_idx = (v) % ulong_bits; unsigned long mask = (1UL << bit_idx); visited[word_idx] |= mask; out_queue[word_idx] |= mask;} while (0)
SET_IN(root);
{ptrdiff_t i; _Pragma("omp parallel for schedule(static)") for (i = 0; i < nlocalverts; ++i) pred[i] = -1;}
if (VERTEX_OWNER(root) == rank) {
pred[VERTEX_LOCAL(root)] = root;
SET_VISITED_LOCAL(VERTEX_LOCAL(root));
}
uint16_t cur_level = 0;
while (1) {
++cur_level;
#if 0
if (rank == 0) fprintf(stderr, "BFS level %" PRIu16 "\n", cur_level);
#endif
memset(out_queue, 0, local_queue_size * sizeof(unsigned long));
// memset(out_queue_summary, 0, local_queue_summary_size * sizeof(unsigned long));
ptrdiff_t i, ii;
#if 0
#pragma omp parallel for schedule(static)
for (i = 0; i < global_queue_summary_size; ++i) {
unsigned long val = 0UL;
int j;
unsigned long mask = 1UL;
for (j = 0; j < ulong_bits; ++j, mask <<= 1) {
if (in_queue[i * ulong_bits + j]) val |= mask;
}
in_queue_summary[i] = val;
}
#endif
unsigned long not_done = 0;
#pragma omp parallel for schedule(static) reduction(|:not_done)
for (ii = 0; ii < nlocalverts; ii += ulong_bits) {
size_t i, i_end = ii + ulong_bits;
if (i_end > nlocalverts) i_end = nlocalverts;
for (i = ii; i < i_end; ++i) {
if (!TEST_VISITED_LOCAL(i)) {
size_t j, j_end = rowstarts[i + 1];
for (j = rowstarts[i]; j < j_end; ++j) {
int64_t v1 = column[j];
int64_t v1_swizzled = SWIZZLE_VERTEX(v1);
if (TEST_IN(v1_swizzled)) {
pred[i] = (v1 & INT64_C(0xFFFFFFFFFFFF)) | ((int64_t)cur_level << 48);
not_done |= 1;
SET_VISITED_LOCAL(i);
break;
}
}
}
}
}
#if 1
#pragma omp parallel for schedule(static)
for (i = 0; i < local_queue_summary_size; ++i) {
unsigned long val = 0UL;
int j;
unsigned long mask = 1UL;
for (j = 0; j < ulong_bits; ++j, mask <<= 1) {
unsigned long full_val = out_queue[i * ulong_bits + j];
visited[i * ulong_bits + j] |= full_val;
if (full_val) val |= mask;
}
out_queue_summary[i] = val;
// not_done |= val;
}
#endif
MPI_Allreduce(MPI_IN_PLACE, ¬_done, 1, MPI_UNSIGNED_LONG, MPI_BOR, MPI_COMM_WORLD);
if (not_done == 0) break;
MPI_Allgather(out_queue, local_queue_size, MPI_UNSIGNED_LONG, in_queue, local_queue_size, MPI_UNSIGNED_LONG, MPI_COMM_WORLD);
MPI_Allgather(out_queue_summary, local_queue_summary_size, MPI_UNSIGNED_LONG, in_queue_summary, local_queue_summary_size, MPI_UNSIGNED_LONG, MPI_COMM_WORLD);
}
deallocate_memory();
}
void make_graph_data_structure(const tuple_graph* const tg) {
convert_graph_to_oned_csr(tg, &g);
allocate_memory(); /* Make sure all of the space is available */
deallocate_memory();
}
