int
main(int argc, char *argv[])
{
float timeStep = 0.1f;
uint32_t nIntegrations = 1000;
uint32_t num_particles_x = 16;
uint32_t num_particles_y = 16;
uint32_t num_particles = num_particles_x * num_particles_y;
uint32_t num_levels = logf(num_particles) / logf(4.f);
uint32_t num_coefficients = 4;
uint32_t memory_size = 256 * 1024 * 1024;
initialize_data(memory_size, num_particles_x, num_particles_y,
num_levels, num_coefficients);
for(uint32_t loop = 0; loop < nIntegrations; loop++) {
calculate_multipoles();
reset_forces();
calculate_forces();
integrate(timeStep);
}
const char filename[] = "out.txt";
debug_write_positions_to_file(filename);
return 0;
}
/*
* Function: insert_data
*
* Description: This routine inserts the data into the table
*
*/
void insert_data()
{
colp *colsptr;
sword colindex;
row_count = 0;
while (row_count < numrows)
{
colsptr = cols;
numinsert = numrows - row_count < MAX_ROWS_PER_INSERT ?
numrows - row_count : MAX_ROWS_PER_INSERT;
for (colindex = 0; colindex < NUMCOLS; colsptr++, colindex++)
{
initialize_data(colsptr->c_buf, colsptr->c_size, colsptr->c_rlen,
numinsert);
colsptr->c_curlen = numinsert;
}
/* using offset zero - we want all the rows right away */
if (oexec(&cda))
{
err_report(&cda);
do_exit(OCI_EXIT_FAILURE);
}
printf(" Number of rows processed so far is %d\n", retval);
row_count += numinsert;
}
}
BOOL wing_editor::Create()
{
BOOL r;
int i;
CComboBox *box;
r = CDialog::Create(IDD, Fred_main_wnd);
box = (CComboBox *) GetDlgItem(IDC_ARRIVAL_LOCATION);
box->ResetContent();
for (i=0; i<MAX_ARRIVAL_NAMES; i++)
box->AddString(Arrival_location_names[i]);
box = (CComboBox *) GetDlgItem(IDC_DEPARTURE_LOCATION);
box->ResetContent();
for (i=0; i<MAX_DEPARTURE_NAMES; i++)
box->AddString(Departure_location_names[i]);
m_hotkey = 0;
m_waves_spin.SetRange(1, 99);
m_arrival_tree.link_modified(&modified); // provide way to indicate trees are modified in dialog
m_arrival_tree.setup((CEdit *) GetDlgItem(IDC_HELP_BOX));
m_departure_tree.link_modified(&modified);
m_departure_tree.setup();
m_arrival_delay_spin.SetRange(0, 999);
m_departure_delay_spin.SetRange(0, 999);
initialize_data(1);
return r;
}
static void dispatch_rts (
pami_context_t context, /**< IN: PAMI context */
void * cookie, /**< IN: dispatch cookie */
const void * header_addr, /**< IN: header address */
size_t header_size, /**< IN: header size */
const void * pipe_addr, /**< IN: address of PAMI pipe buffer */
size_t pipe_size, /**< IN: size of PAMI pipe buffer */
pami_endpoint_t origin,
pami_recv_t * recv) /**< OUT: receive message structure */
{
volatile size_t * active = (volatile size_t *) cookie;
fprintf (stderr, ">> 'rts' dispatch function. cookie = %p (active: %zu), header_size = %zu, pipe_size = %zu, recv = %p\n", cookie, *active, header_size, pipe_size, recv);
rts_info_t * rts = (rts_info_t *) header_addr;
fprintf (stderr, " 'rts' dispatch function. rts->origin = 0x%08x, rts->bytes = %zu\n", rts->origin, rts->bytes);
/*assert(pipe_addr!=NULL); */
/*pami_memregion_t * origin_memregion = (pami_memregion_t *) pipe_addr; */
get_info_t * get = (get_info_t *) malloc (sizeof(get_info_t));
get->value = active;
get->origin = rts->origin;
get->bytes = rts->bytes;
get->pad = 16;
initialize_data (get->buffer, 0, 6);
print_data (get->buffer, 12*4);
/* Create a memregion for the data buffer. */
size_t bytes = 0;
pami_result_t pami_rc = PAMI_Memregion_create (context, get->buffer, 12*4, &bytes, &(get->memregion));
if (PAMI_SUCCESS != pami_rc) {
fprintf (stderr, "PAMI_Memregion_create failed with rc = %d\n", pami_rc) ;
exit(1);
}
/* Perform the rdma get operation */
pami_rget_simple_t parameters;
parameters.rma.dest = rts->origin;
parameters.rma.bytes = rts->bytes;
parameters.rma.cookie = get;
parameters.rma.done_fn = get_done;
parameters.rdma.local.mr = &(get->memregion);
parameters.rdma.local.offset = 16;
parameters.rdma.remote.mr = &(rts->memregion);
parameters.rdma.remote.offset = 0;
fprintf (stderr, " 'rts' dispatch function. Before PAMI_Rget()\n");
pami_result_t status = PAMI_Rget (context, ¶meters);
fprintf (stderr, " 'rts' dispatch function. After PAMI_Rget(), status = %d\n", status);
if (status != PAMI_SUCCESS)
get_done (context, (void *) get, status);
fprintf (stderr, "<< 'rts' dispatch function.\n");
return;
}
static void
fr_application_startup (GApplication *application)
{
G_APPLICATION_CLASS (fr_application_parent_class)->startup (application);
fr_application_register_archive_manager_service (FR_APPLICATION (application));
initialize_data ();
initialize_app_menu (application);
}
static DFBResult
wm_join( CoreDFB *core, void *wm_data, void *shared_data )
{
WMData *data = wm_data;
WMShared *shared = shared_data;
D_DEBUG_AT( WM_Unique, "wm_join()\n" );
initialize_data( core, data, shared );
return unique_wm_module_init( core, data, shared, false );
}
// Initialize the methodDataOop corresponding to a given method.
void methodDataOopDesc::initialize(methodHandle method) {
ResourceMark rm;
// Set the method back-pointer.
_method = method();
set_creation_mileage(mileage_of(method()));
// Initialize flags and trap history.
_nof_decompiles = 0;
_nof_overflow_recompiles = 0;
_nof_overflow_traps = 0;
assert(sizeof(_trap_hist) % sizeof(HeapWord) == 0, "align");
Copy::zero_to_words((HeapWord*) &_trap_hist,
sizeof(_trap_hist) / sizeof(HeapWord));
// Go through the bytecodes and allocate and initialize the
// corresponding data cells.
int data_size = 0;
int empty_bc_count = 0; // number of bytecodes lacking data
BytecodeStream stream(method);
Bytecodes::Code c;
while ((c = stream.next()) >= 0) {
int size_in_bytes = initialize_data(&stream, data_size);
data_size += size_in_bytes;
if (size_in_bytes == 0) empty_bc_count += 1;
}
_data_size = data_size;
int object_size = in_bytes(data_offset()) + data_size;
// Add some extra DataLayout cells (at least one) to track stray traps.
int extra_data_count = compute_extra_data_count(data_size, empty_bc_count);
int extra_size = extra_data_count * DataLayout::compute_size_in_bytes(0);
// Add a cell to record information about modified arguments.
// Set up _args_modified array after traps cells so that
// the code for traps cells works.
DataLayout *dp = data_layout_at(data_size + extra_size);
int arg_size = method->size_of_parameters();
dp->initialize(DataLayout::arg_info_data_tag, 0, arg_size+1);
object_size += extra_size + DataLayout::compute_size_in_bytes(arg_size+1);
// Set an initial hint. Don't use set_hint_di() because
// first_di() may be out of bounds if data_size is 0.
// In that situation, _hint_di is never used, but at
// least well-defined.
_hint_di = first_di();
post_initialize(&stream);
set_object_is_parsable(object_size);
}
void MethodData::initialize() {
No_Safepoint_Verifier no_safepoint; // init function atomic wrt GC
ResourceMark rm;
init();
set_creation_mileage(mileage_of(method()));
// Go through the bytecodes and allocate and initialize the
// corresponding data cells.
int data_size = 0;
int empty_bc_count = 0; // number of bytecodes lacking data
_data[0] = 0; // apparently not set below.
BytecodeStream stream(method());
Bytecodes::Code c;
while ((c = stream.next()) >= 0) {
int size_in_bytes = initialize_data(&stream, data_size);
data_size += size_in_bytes;
if (is_empty_data(size_in_bytes, c)) empty_bc_count++;
}
_data_size = data_size;
int object_size = in_bytes(data_offset()) + data_size;
// Add some extra DataLayout cells (at least one) to track stray traps.
int extra_data_count = compute_extra_data_count(data_size, empty_bc_count);
int extra_size = extra_data_count * DataLayout::compute_size_in_bytes(0);
object_size += extra_size;
Copy::zero_to_bytes((HeapWord*) extra_data_base(), extra_size);
#ifndef GRAALVM
// Add a cell to record information about modified arguments.
// Set up _args_modified array after traps cells so that
// the code for traps cells works.
DataLayout *dp = data_layout_at(data_size + extra_size);
int arg_size = method()->size_of_parameters();
dp->initialize(DataLayout::arg_info_data_tag, 0, arg_size+1);
object_size += DataLayout::compute_size_in_bytes(arg_size+1);
#endif
// Set an initial hint. Don't use set_hint_di() because
// first_di() may be out of bounds if data_size is 0.
// In that situation, _hint_di is never used, but at
// least well-defined.
_hint_di = first_di();
post_initialize(&stream);
set_size(object_size);
}
/* This function can be called from within the sigprof handler and therefore
* must be signal safe. no strdup and friends.
*/
static void send_samples (TLS* tls)
{
Assert(tls != NULL);
tls->header.time_end = CBTF_GetTime();
tls->header.addr_begin = tls->buffer.addr_begin;
tls->header.addr_end = tls->buffer.addr_end;
/* rank is not filled until mpi_init finished. safe to set here*/
tls->header.rank = monitor_mpi_comm_rank();
tls->data.pc.pc_len = tls->buffer.length;
tls->data.count.count_len = tls->buffer.length;
tls->data.events.events_len = tls->buffer.length;
#if 0
int bufsize = tls->buffer.length * sizeof(tls->buffer);
int pcsize = tls->buffer.length * sizeof(tls->data.pc.pc_val);
int countsize = tls->buffer.length * sizeof(tls->data.count.count_val);
fprintf(stderr,"[%d:%d] HWCSAMP SEND SAMPLES\n", tls->header.pid,tls->header.omp_tid);
fprintf(stderr,"send_samples: size of tls data is %d, buffer is %d\n",sizeof(tls->data), sizeof(tls->buffer));
fprintf(stderr,"send_samples: size of tls PC data is %d %d, COUNT is %d %d\n",tls->buffer.length , pcsize,tls->buffer.length , countsize);
fprintf(stderr,"send_samples: size of tls HASH is %d\n", sizeof(tls->buffer.hash_table));
fprintf(stderr,"send_samples: size of tls data pc buff is %d\n", sizeof(tls->data.pc.pc_val)*CBTF_HWCPCBufferSize);
fprintf(stderr,"send_samples: size of tls data count buff is %d\n", sizeof(tls->data.count.count_val)*CBTF_HWCPCBufferSize);
fprintf(stderr,"send_samples: size of tls hwccounts is %d\n", sizeof(tls->buffer.hwccounts));
fprintf(stderr,"send_samples: size of CBTF_evcounts is %d\n", sizeof(CBTF_evcounts)*CBTF_HWCPCBufferSize);
fprintf(stderr,"send_samples: size of lon long is %d\n", sizeof(long long));
fprintf(stderr,"send_samples: size of uint64_t is %d\n", sizeof(uint64_t));
fprintf(stderr,"send_samples: size of CBTF_HWCPCData is %d\n", sizeof(CBTF_HWCPCData));
int eventssize = tls->buffer.length * sizeof(tls->data.events.events_val);
fprintf(stderr,"send_samples: size of eventssize = %d\n",eventssize);
#endif
#ifndef NDEBUG
if (IsCollectorDebugEnabled) {
fprintf(stderr, "[%ld,%d] hwcsamp send_samples:\n",tls->header.pid, tls->header.omp_tid);
fprintf(stderr, "[%ld,%d] time_range(%lu,%lu) addr range[%#lx, %#lx] pc_len(%d) count_len(%d)\n",
tls->header.pid, tls->header.omp_tid,
tls->header.time_begin,tls->header.time_end,
tls->header.addr_begin,tls->header.addr_end,
tls->data.pc.pc_len,
tls->data.count.count_len);
}
#endif
cbtf_collector_send(&(tls->header), (xdrproc_t)xdr_CBTF_hwcsamp_data, &(tls->data));
/* Re-initialize the data blob's header */
initialize_data(tls);
}
static DFBResult
wm_initialize( CoreDFB *core, void *wm_data, void *shared_data )
{
WMData *data = wm_data;
WMShared *shared = shared_data;
D_DEBUG_AT( WM_Unique, "wm_initialize()\n" );
initialize_data( core, data, shared );
D_MAGIC_SET( shared, WMShared );
return unique_wm_module_init( core, data, shared, true );
}
void main(int argc, char **argv) {
struct timeval start_t, end_t;
struct timezone tzdummy;
complex A[512*512], B[512*512], C[512*512];
/* Initialize Data*/
initialize_data(f1_name, A);
initialize_data(f2_name, B);
gettimeofday(&start_t, &tzdummy);
/* 2D FFT on A */
execute_fft(A, 1);
transpose(A);
execute_fft(A, 1);
/* 2D FFT on B */
execute_fft(B, 1);
transpose(B);
execute_fft(B, 1);
/* Multiplication Step */
execute_mm(A, B, C);
/* 2D FFT on C */
execute_fft(C, -1);
transpose(C);
execute_fft(C, -1);
gettimeofday(&end_t, &tzdummy);
output_data(f_out, C);
printf("\nElapsed time = %g s\n", (double)((unsigned int)end_t.tv_usec - (unsigned int)start_t.tv_usec) / 1000000.0);
printf("--------------------------------------------\n");
}
int
main (int argc,
char *argv[])
{
GnomeProgram *program;
char *description;
if (! g_thread_supported ()) {
g_thread_init (NULL);
gdk_threads_init ();
}
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
description = g_strdup_printf ("- %s", _("View and organize your images"));
context = g_option_context_new (description);
g_free (description);
g_option_context_add_main_entries (context, options, GETTEXT_PACKAGE);
program = gnome_program_init ("gthumb", VERSION,
LIBGNOMEUI_MODULE,
argc, argv,
GNOME_PARAM_GOPTION_CONTEXT, context,
GNOME_PARAM_HUMAN_READABLE_NAME, _("gThumb"),
GNOME_PARAM_APP_PREFIX, GTHUMB_PREFIX,
GNOME_PARAM_APP_SYSCONFDIR, GTHUMB_SYSCONFDIR,
GNOME_PARAM_APP_DATADIR, GTHUMB_DATADIR,
GNOME_PARAM_APP_LIBDIR, GTHUMB_LIBDIR,
NULL);
gnome_vfs_init ();
gnome_authentication_manager_init ();
glade_gnome_init ();
gthumb_init ();
initialize_data ();
prepare_app ();
gdk_threads_enter ();
gtk_main ();
gdk_threads_leave ();
release_data ();
return 0;
}
static void
on_bus_acquired (GDBusConnection *connection,
const char *name,
gpointer user_data)
{
guint registration_id;
registration_id = g_dbus_connection_register_object (connection,
FR_SERVICE_PATH,
introspection_data->interfaces[0],
&interface_vtable,
NULL,
NULL, /* user_data_free_func */
NULL); /* GError** */
g_assert (registration_id > 0);
initialize_data ();
}
int main (int argc, char* argv[]) {
struct timespec start, end;
initOpenCL();
/* START Measurements */
get_date(argc, argv);
clock_gettime(CLOCK_MONOTONIC, &start);
int arraySize = SIZE;
size_t bufferSize = arraySize * sizeof(double);
double* inputA = (double*) malloc (bufferSize);
double* inputB = (double*) malloc (bufferSize);
double* output = (double*) malloc (bufferSize);
/* Initilise data */
initialize_data(arraySize, inputA, inputB);
/* Computation */
vector_sum(arraySize, inputA, inputB, output);
/* END Measurements */
clock_gettime(CLOCK_MONOTONIC, &end);
get_date(argc, argv);
/* Check results */
//check_results(arraySize, inputA, inputB, output);
/* Cleaning */
cleanUpOpenCL();
double res=0;
int i;
for (i = 0; i < arraySize; i++) {
res = res + output[i] ;
}
times = (((double)(end.tv_sec - start.tv_sec)*1000) +
((double)(end.tv_nsec - start.tv_nsec)/1000000));
//cout << "Time to finish: " << times << " ms" << endl;
printf("Time to finish %6.0f ms [check = %e]\n", times, res);
}
gcp_solution_t* antcol(gcp_t *problem) {/*{{{*/
int c = 0;
gcp_solution_t *result;
result = malloc(sizeof(gcp_solution_t));
initialize_data(problem);
best_ant->ncolors = INT_MAX;
int terminate = FALSE;
while (!terminate) {
initialize_var_phero(problem);
construct_solutions(problem, c);
local_search(problem);
update_pheromone_trails(problem);
c++;
if (problem->flags & FLAG_VERBOSE) {
printf("Cycle %d - Colors used: %d\n", c, best_ant->ncolors);
}
else {
printf("*");
fflush(stdout);
}
/* test stop conditions */
if ((problem->flags & FLAG_CYCLE) && problem->ncycles <= c)
terminate = TRUE;
if ((problem->flags & FLAG_TIME) && problem->time <= current_usertime_secs())
terminate = TRUE;
}
*result = *best_ant;
result->ncycles = c;
return result;
}/*}}}*/
static void dispatch_rts (
pami_context_t context, /**< IN: PAMI context */
void * cookie, /**< IN: dispatch cookie */
const void * header_addr, /**< IN: header address */
size_t header_size, /**< IN: header size */
const void * pipe_addr, /**< IN: address of PAMI pipe buffer */
size_t pipe_size, /**< IN: size of PAMI pipe buffer */
pami_endpoint_t origin,
pami_recv_t * recv) /**< OUT: receive message structure */
{
volatile size_t * active = (volatile size_t *) cookie;
fprintf (stderr, ">> 'rts' dispatch function. cookie = %p (active: %zu), header_size = %zu, pipe_size = %zu, recv = %p\n", cookie, *active, header_size, pipe_size, recv);
rts_info_t * rts = (rts_info_t *) header_addr;
fprintf (stderr, " 'rts' dispatch function. rts->origin = 0x%08x, rts->bytes = %zu, rts->source = %p\n", rts->origin, rts->bytes, rts->source);
size_t pad = BUFFERSIZE;
get_info_t * get = (get_info_t *) malloc (sizeof(get_info_t));
get->value = active;
get->origin = rts->origin;
get->bytes = rts->bytes;
get->pad = pad;
initialize_data (get->buffer, 0, 6);
print_data (get->buffer, 12*4);
pami_get_simple_t parameters;
parameters.rma.dest = rts->origin;
parameters.rma.hints = null_send_hint;
parameters.rma.bytes = rts->bytes;
parameters.rma.cookie = get;
parameters.rma.done_fn = get_done;
parameters.addr.local = (void *) (get->buffer+4);
parameters.addr.remote = rts->source;
PAMI_Get (context, ¶meters);
fprintf (stderr, "<< 'rts' dispatch function.\n");
return;
}
/**
* Send events.
*
* Sends all the events in the tracing buffer to the framework for storage in
* the experiment's database. Then resets the tracing buffer to the empty state.
* This is done regardless of whether or not the buffer is actually full.
*/
static void send_samples(TLS *tls)
{
Assert(tls != NULL);
tls->header.id = strdup(cbtf_collector_unique_id);
tls->header.time_end = CBTF_GetTime();
tls->header.rank = monitor_mpi_comm_rank();
#ifndef NDEBUG
if (IsCollectorDebugEnabled) {
fprintf(stderr, "[%ld,%d] mpi send_samples:\n",tls->header.pid, tls->header.omp_tid);
fprintf(stderr, "[%ld,%d] time_range(%lu,%lu) addr range[%lx, %lx] stacktraces_len(%u) events_len(%u)\n",
tls->header.pid, tls->header.omp_tid,
tls->header.time_begin,tls->header.time_end,
tls->header.addr_begin,tls->header.addr_end,
#if defined(PROFILE)
tls->data.stacktraces.stacktraces_len
#else
tls->data.stacktraces.stacktraces_len,
tls->data.events.events_len
#endif
);
}
#endif
#if defined(PROFILE)
cbtf_collector_send(&(tls->header), (xdrproc_t)xdr_CBTF_mpi_profile_data, &(tls->data));
#else
#if defined(EXTENDEDTRACE)
cbtf_collector_send(&(tls->header), (xdrproc_t)xdr_CBTF_mpi_exttrace_data, &(tls->data));
#else
cbtf_collector_send(&(tls->header), (xdrproc_t)xdr_CBTF_mpi_trace_data, &(tls->data));
#endif
#endif
/* Re-initialize the data blob's header */
initialize_data(tls);
}
void MainWindow::on_actionOpen_triggered() {
filename = QFileDialog::getOpenFileName(this, "Open Stadium ROM", QString(), "Pokémon Stadium ROM (*.z64)");
// ROM opening
if(!filename.isEmpty()){
QFile romfile(filename);
romfile.open(QIODevice::ReadOnly);
QDataStream read(&romfile);
// ***** Checks the ROM validity *****
if(romfile.size() == 0x2000000) {
romfile.seek(0x00);
read>>header_PI_settings;
romfile.seek(0x04);
read>>header_clockrate;
romfile.seek(0x08);
read>>header_boot_address;
romfile.seek(0x0C);
read>>header_release;
romfile.seek(0x10);
read>>header_crc1;
romfile.seek(0x14);
read>>header_crc2;
romfile.seek(0x18);
read>>header_reserved1;
romfile.seek(0x1C);
read>>header_reserved2;
romfile.seek(0x20);
read>>header_name1;
romfile.seek(0x24);
read>>header_name2;
romfile.seek(0x28);
read>>header_name3;
romfile.seek(0x2C);
read>>header_name4;
romfile.seek(0x30);
read>>header_name5;
romfile.seek(0x34);
read>>header_reserved3;
romfile.seek(0x38);
read>>header_rom_format;
romfile.seek(0x3C);
read>>header_game_id;
romfile.seek(0x3E);
read>>header_region_code;
romfile.seek(0x3F);
read>>header_rom_version;
// Checks ROM language and validity
rom_check();
romfile.seek(0);
if(this->romtype != INVALID){
// ***** Reads the ROM data *****
// Initialization
initialize_char_table();
initialize_data();
initialize_min_levels();
initialize_iv_statexp_groups();
// Formulas
read_ch_formula(romfile);
read_damage_variance(romfile);
read_highCH_shift(romfile);
read_burn_shift(romfile);
read_odds_paralysis(romfile);
// Pokémon names
read_pkm_names(romfile);
initialize_nicknames();
// Pokémon data
read_pkm_data(romfile);
read_pokedex_data(romfile);
// Moves names and data
read_move_names(romfile);
read_move_data(romfile);
read_move_descriptions(romfile);
read_tmhm_data(romfile);
// Types names
read_type_names(romfile);
// Types chart (Weaknesses and Resistances)
read_type_chart(romfile);
// Experience data
read_experience_data(romfile);
// CPU Trainers / Rentals data
read_cpu_rentals(romfile);
initialize_trainers_names();
}
}
void main(int argc, char **argv) {
double start_t;
double end_t;
int my_rank, p, my_loc_rank, loc_p;
complex *A;
complex *B;
complex *C;
/* initialize MPI */
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &p);
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
/* Create MPI Datatype for Complex */
const float nitems=2;
int blocklengths[2] = {1,1};
MPI_Datatype types[2] = {MPI_FLOAT, MPI_FLOAT};
MPI_Aint offsets[2];
offsets[0] = offsetof(complex, r);
offsets[1] = offsetof(complex, i);
MPI_Type_create_struct(nitems, blocklengths, offsets, types, &mpi_complex);
MPI_Type_commit(&mpi_complex);
int workload = 512 / p;
complex a[512*workload];
complex b[512*workload];
complex c[512*workload];
/* Split the first two groups and a collector group*/
if(my_rank == 0) {
MPI_Comm_split(MPI_COMM_WORLD, 0, my_rank, &comm1);
MPI_Comm_split(MPI_COMM_WORLD, MPI_UNDEFINED, my_rank, &comm2);
MPI_Comm_split(MPI_COMM_WORLD, 0, my_rank, &commR2);
} else if(my_rank < p/2) {
MPI_Comm_split(MPI_COMM_WORLD, 0, my_rank, &comm1);
MPI_Comm_split(MPI_COMM_WORLD, MPI_UNDEFINED, my_rank, &comm2);
MPI_Comm_split(MPI_COMM_WORLD, MPI_UNDEFINED, my_rank, &commR2);
} else {
MPI_Comm_split(MPI_COMM_WORLD, MPI_UNDEFINED, my_rank-(p/2), &comm1);
MPI_Comm_split(MPI_COMM_WORLD, 0, my_rank-(p/2), &comm2);
MPI_Comm_split(MPI_COMM_WORLD, 0, my_rank-(p/2), &commR2);
}
/* Split the group for the latter two tasks */
/* All processors may participate, we only need one group for the two tasks */
MPI_Comm_split(MPI_COMM_WORLD, 0, my_rank, &comm3);
/* Initialize Data*/
workload = 512 / (p/2);
if(my_rank == 0) {
A = malloc(512*512 * sizeof(complex));
B = malloc(512*512 * sizeof(complex));
C = malloc(512*512 * sizeof(complex));
initialize_data(f1_name, A);
start_t = MPI_Wtime();
} else if(my_rank == p/2 || p == 1) {
B = malloc(512*512 * sizeof(complex));
initialize_data(f2_name, B);
}
if(my_rank < p/2) {
MPI_Scatter(A, 512*workload, mpi_complex,
a, 512*workload, mpi_complex,
0, comm1);
} else {
MPI_Scatter(B, 512*workload, mpi_complex,
b, 512*workload, mpi_complex,
0, comm2);
}
/* 2D FFT on A */
if(my_rank < p/2) {
MPI_Comm_rank(comm1, &my_loc_rank);
MPI_Comm_size(comm1, &loc_p);
execute_fft(a, 1, loc_p, my_loc_rank);
MPI_Gather(a, 512*workload, mpi_complex,
A, 512*workload, mpi_complex,
0, comm1);
if(my_loc_rank == 0) {
transpose(A);
}
MPI_Scatter(A, 512*workload, mpi_complex,
a, 512*workload, mpi_complex,
0, comm1);
execute_fft(a, 1, loc_p, my_loc_rank);
} else if(my_rank >= p/2 || p == 1) {
/* 2D FFT on B */
MPI_Comm_rank(comm2, &my_loc_rank);
MPI_Comm_size(comm2, &loc_p);
execute_fft(b, 1, loc_p, my_loc_rank);
MPI_Gather(b, 512*workload, mpi_complex,
B, 512*workload, mpi_complex,
0, comm2);
if(my_loc_rank == 0) {
transpose(B);
}
MPI_Scatter(B, 512*workload, mpi_complex,
b, 512*workload, mpi_complex,
0, comm2);
execute_fft(b, 1, loc_p, my_loc_rank);
}
/* Multiplication Step */
workload = 512 / p;
sync_tasks(a, b, A, B, p, my_rank);
MPI_Scatter(A, 512*workload, mpi_complex,
b, 512*workload, mpi_complex,
0, comm3);
MPI_Scatter(B, 512*workload, mpi_complex,
b, 512*workload, mpi_complex,
0, comm3);
execute_mm(a, b, c, p, my_rank);
/* 2D FFT on C */
execute_fft(c, -1, p, my_rank);
MPI_Gather(c, 512*workload, mpi_complex,
C, 512*workload, mpi_complex,
0, comm3);
if(my_rank == 0) {
transpose(C);
}
MPI_Scatter(C, 512*workload, mpi_complex,
c, 512*workload, mpi_complex,
0, comm3);
execute_fft(c, -1, p, my_rank);
MPI_Gather(c, 512*workload, mpi_complex,
C, 512*workload, mpi_complex,
0, comm3);
end_t = MPI_Wtime();
if(my_rank == 0) {
output_data(f_out, C);
printf("\nElapsed time = %g s\n", end_t - start_t);
printf("--------------------------------------------\n");
int i;
for(i = 0; i < 512*512; i++) {
free(&A[i]);
free(&B[i]);
free(&C[i]);
}
}
MPI_Finalize();
}
/*-------------------------------------------------------------------*/
void fer_sim(int *rate)
{
int i,j,k,ix;
short fer_flag;
static short first_time = 1;
if( first_time )
{
first_time = 0;
/*...initialize data...*/
initialize_data();
/*...set seed...*/
if (fer_sim_seed == 0) {
fer_sim_seed = (int)(time(NULL) & 0x0fff);
}
if ((trans_fp=fopen(trans_fname,"r")) == NULL)
{
fprintf(stderr,"ERROR: Cannot open file \"%s\" for reading.\n",trans_fname );
fprintf(log_fp,"ERROR: Cannot open file \"%s\" for reading.\n",trans_fname );
exit(1);
}
else
{
fprintf(log_fp,"FER Transition Prob. File : \"%s\"\n\n",trans_fname);
}
/* record initial parameters in log file */
fprintf(log_fp,"Random number generator initial seed : %d\n",fer_sim_seed);
/* read transition probability matrices */
for(i=0;i<NSTATES;i++)
{
for(j=0;j<NRATES_IN;j++)
{
for(k=0;k<NRATES_OUT;k++)
{
ix = fscanf(trans_fp,"%lf",&p[i][j][k]);
if(ix!=1)
{
printf("Error in read of transition matrices file\n");
fprintf(log_fp,"Error in read of transition matrices file\n");
exit(1);
}
}
}
}
/* convert probability transition matrices to cumulative values */
if(!prob_to_cum())
{
fprintf(stderr,"Problem with prob_to_cum()\n");
fprintf(log_fp,"Problem with prob_to_cum()\n");
}
/* clear rate and transition stat matrices */
initialize_stats();
} /* end if( first_time ) */
/* read encoded data */
/* convert code to internal value */
if(*rate==fullRate) rate_in = FULL;
else if(*rate==halfRate) rate_in = HALF;
else if(*rate==quarRate) rate_in = QUARTER;
else if(*rate==eighRate) rate_in = EIGHTH;
else if(*rate==fullProb) rate_in = FULL_ERRS;
else rate_in = -1; /* other codes invalid */
fer_flag = 0;
if (rate_in == -1)
{
fer_flag = 1;
}
else if (rate_in == -2)
{
fer_flag = 1;
fprintf(stderr,"Encoded data file format error -- invalid rate specified in %d-th frame\n",frame_cnt);
fprintf(log_fp,"Encoded data file format error -- invalid rate specified in %d-th frame\n",frame_cnt);
}
trans(rate_in); /* determine rate_out, event from random number and */
/* transition probability matrix */
/* Force RANDOM and MODIFIED to be an ERASURE (for simplicity) */
if(event==RANDOM) /* random data for the given frame length */
{
event = ERASURE;
}
else if(event==MODIFIED) /* XOR data with a randomly selected mask */
{
event = ERASURE;
}
else if( fer_flag == 1 )
{
event = ERASURE;
}
/* determine output rate code */
if(event==ERASURE) rate_code = erasRate;
else if(rate_out==FULL) rate_code = fullRate;
else if(rate_out==HALF) rate_code = halfRate;
else if(rate_out==QUARTER) rate_code = quarRate;
else if(rate_out==EIGHTH) rate_code = eighRate;
else if(rate_out==FULL_ERRS) rate_code = fullProb;
*rate = rate_code;
}
/*Algoritmo Principal*/
int main(int argc, char *argv[])
{
char name[20];// = "_kita_1";
char archiveName[20] = "archive";
char fitputName[20] = "fitput";
char varputName[20] = "varput";
char hvName[20]= "hv";
unsigned int i, j, t;
unsigned int fun, gen;
clock_t startTime, endTime;
double duration, clocktime;
FILE *fitfile,*varfile;
/*Parametros iniciales*/
strcpy(name,argv[1]);
fun = atoi(argv[2]);
gen = atoi(argv[3]);
printf("%s %d %d \n",name,fun,gen);
initialize_data(fun,gen);
/*Iniciar variables*/
initialize_memory();
/*
sprintf(name,"kita_1_");
sprintf(archiveName,strcat(name,"archive.out"));
sprintf(fitputName, strcat(name,"fitput.out"));
sprintf(varputName, strcat(name,"varput.out"));
sprintf(hvName,strcat(name,"hv.out"));
*/
//fitfile = fopen(strcat(strcat(fitputName,name),".out"),"w");
//varfile = fopen(strcat(strcat(varputName,name),".out"),"w");
//hv = fopen(strcat(strcat(hvName,name),".out"),"w");
/* Iniciar generador de aleatorios*/
initialize_rand();
startTime = clock();
/* Iniciar contador de generaciones*/
t = 0;
/* Iniciar valores de la poblacion de manera aleatoria*/
initialize_pop();
/* Calcular velocidad inicial*/
initialize_vel();
/* Evaluar las particulas de la poblacion*/
evaluate();
/* Almacenar el pBest inicial (variables and valor de aptitud) de las particulas*/
store_pbests();
/* Insertar las particulas no domindas de la poblacion en el archivo*/
insert_nondom();
//printf("\n%d",nondomCtr);
/*Ciclo Principal*/
while(t <= maxgen)
{
//clocktime = (clock() - startTime)/(double)CLOCKS_PER_SEC;
/*if(verbose > 0 && t%printevery==0 || t == maxgen)
{
fprintf(stdout,"Generation %d Time: %.2f sec\n",t,clocktime);
fflush(stdout);
}*/
/*if(t%printevery==0 || t == maxgen)
{
fprintf(outfile,"Generation %d Time: %.2f sec\n",t,clocktime);
}*/
/* Calcular la nueva velocidad de cada particula en la pooblacion*/
//printf("\n 1");
compute_velocity();
/* Calcular la nueva posicion de cada particula en la poblacion*/
//printf("\n 2");
compute_position();
/* Mantener las particulas en la poblacion de la poblacion en el espacio de busqueda*/
//printf("\n 3");
maintain_particles();
/* Pertubar las particulas en la poblacion*/
if(t < maxgen * pMut)
mutate(t);
/* Evaluar las particulas en la poblacion*/
//printf("\n 4");
evaluate();
/* Insertar nuevas particulas no domindas en el archivo*/
//printf("\n 5");
update_archive();
/* Actualizar el pBest de las particulas en la poblacion*/
//printf("\n 6");
update_pbests();
/* Escribir resultados del mejor hasta ahora*/
//verbose > 0 && t%printevery==0 || t == maxgen
/*if(t%printevery==0 || t == maxgen)
{
//fprintf(outfile, "Size of Pareto Set: %d\n", nondomCtr);
fprintf(fitfile, "%d\n",t);
fprintf(varfile, "%d\n",t);
for(i = 0; i < nondomCtr; i++)
{
for(j = 0; j < maxfun; j++)
fprintf(fitfile, "%f ", archiveFit[i][j]);
fprintf(fitfile, "\n");
}
fprintf(fitfile, "\n\n");
fflush(fitfile);
for(i = 0; i < nondomCtr; i++)
{
for(j = 0; j < maxfun; j++)
fprintf(varfile, "%f ", archiveVar[i][j]);
fprintf(varfile, "\n");
}
fprintf(varfile, "\n\n");
fflush(varfile);
}*/
/* Incrementar contador de generaciones*/
t++;
//printf("%d\n",t);
}
/* Escribir resultados en el archivo */
save_results(strcat(strcat(archiveName,name),".out"));
endTime = clock();
duration = ( endTime - startTime ) / (double)CLOCKS_PER_SEC;
fprintf(stdout, "%lf sec\n", duration);
//fclose(fitfile);
//fclose(varfile);
free_memory();
return EXIT_SUCCESS;
}
int main (int argc, char ** argv)
{
volatile size_t _rts_active = 1;
volatile size_t _ack_active = 1;
memset(&null_send_hint, 0, sizeof(null_send_hint));
pami_client_t client;
pami_context_t context[2];
char cl_string[] = "TEST";
pami_result_t result = PAMI_ERROR;
result = PAMI_Client_create (cl_string, &client, NULL, 0);
if (result != PAMI_SUCCESS)
{
fprintf (stderr, "Error. Unable to create pami client. result = %d\n", result);
return 1;
}
#ifdef TEST_CROSSTALK
size_t num = 2;
#else
size_t num = 1;
#endif
result = PAMI_Context_createv(client, NULL, 0, context, num);
if (result != PAMI_SUCCESS)
{
fprintf (stderr, "Error. Unable to create pami context(s). result = %d\n", result);
return 1;
}
pami_configuration_t configuration;
configuration.name = PAMI_CLIENT_TASK_ID;
result = PAMI_Client_query(client, &configuration,1);
if (result != PAMI_SUCCESS)
{
fprintf (stderr, "Error. Unable query configuration (%d). result = %d\n", configuration.name, result);
return 1;
}
pami_task_t task_id = configuration.value.intval;
fprintf (stderr, "My task id = %d\n", task_id);
configuration.name = PAMI_CLIENT_NUM_TASKS;
result = PAMI_Client_query(client, &configuration,1);
if (result != PAMI_SUCCESS)
{
fprintf (stderr, "Error. Unable query configuration (%d). result = %d\n", configuration.name, result);
return 1;
}
size_t num_tasks = configuration.value.intval;
fprintf (stderr, "Number of tasks = %zu\n", num_tasks);
if (num_tasks < 2)
{
fprintf (stderr, "Error. This test requires at least 2 tasks. Number of tasks in this job: %zu\n", num_tasks);
return 1;
}
pami_dispatch_hint_t options={};
#ifdef USE_SHMEM_OPTION
options.use_shmem = PAMI_HINT_ENABLE;
fprintf (stderr, "##########################################\n");
fprintf (stderr, "shared memory optimizations forced ON\n");
fprintf (stderr, "##########################################\n");
#elif defined(NO_SHMEM_OPTION)
options.use_shmem = PAMI_HINT_DISABLE;
fprintf (stderr, "##########################################\n");
fprintf (stderr, "shared memory optimizations forced OFF\n");
fprintf (stderr, "##########################################\n");
#endif
size_t i = 0;
#ifdef TEST_CROSSTALK
for (i=0; i<2; i++)
#endif
{
pami_dispatch_callback_function fn;
fprintf (stderr, "Before PAMI_Dispatch_set(%d) .. &_rts_active = %p, _rts_active = %zu\n", DISPATCH_ID_RTS, &_rts_active, _rts_active);
fn.p2p = dispatch_rts;
result = PAMI_Dispatch_set (context[i],
DISPATCH_ID_RTS,
fn,
(void *)&_rts_active,
options);
if (result != PAMI_SUCCESS)
{
fprintf (stderr, "Error. Unable register pami dispatch. result = %d\n", result);
return 1;
}
fprintf (stderr, "Before PAMI_Dispatch_set(%d) .. &_ack_active = %p, _ack_active = %zu\n", DISPATCH_ID_ACK, &_ack_active, _ack_active);
fn.p2p = dispatch_ack;
result = PAMI_Dispatch_set (context[i],
DISPATCH_ID_ACK,
fn,
(void *)&_ack_active,
options);
if (result != PAMI_SUCCESS)
{
fprintf (stderr, "Error. Unable register pami dispatch. result = %d\n", result);
return 1;
}
}
if (task_id == 0)
{
pami_send_immediate_t parameters;
#ifdef TEST_CROSSTALK
fprintf (stdout, "PAMI_Rget('simple') functional test [crosstalk]\n");
fprintf (stdout, "\n");
PAMI_Endpoint_create (client, num_tasks-1, 1, ¶meters.dest);
#else
fprintf (stdout, "PAMI_Rget('simple') functional test\n");
fprintf (stdout, "\n");
PAMI_Endpoint_create (client, num_tasks-1, 0, ¶meters.dest);
#endif
/* Allocate some memory from the heap. */
void * send_buffer = malloc (BUFFERSIZE);
/* Initialize the memory for validation. */
initialize_data ((uint32_t *)send_buffer, BUFFERSIZE, 0);
print_data (send_buffer, BUFFERSIZE);
/* Send an 'rts' message to the target task and provide the memory region */
rts_info_t rts_info;
PAMI_Endpoint_create (client, 0, 0, &rts_info.origin);
rts_info.bytes = BUFFERSIZE;
/* Create a memory region for this memoru buffer */
size_t bytes = 0;
pami_result_t pami_rc = PAMI_Memregion_create (context[0], send_buffer, BUFFERSIZE, &bytes, &(rts_info.memregion));
if (PAMI_SUCCESS != pami_rc) {
fprintf (stderr, "PAMI_Memregion_create failed with rc = %d\n", pami_rc) ;
exit(1);
}
parameters.dispatch = DISPATCH_ID_RTS;
parameters.header.iov_base = &rts_info;
parameters.header.iov_len = sizeof(rts_info_t);
parameters.data.iov_base = NULL;
parameters.data.iov_len = 0;
fprintf (stderr, "Before PAMI_Send_immediate()\n");
PAMI_Send_immediate (context[0], ¶meters);
/* wait for the 'ack' */
fprintf (stderr, "Wait for 'ack', _ack_active = %zu\n", _ack_active);
while (_ack_active != 0)
{
result = PAMI_Context_advance (context[0], 100);
if (result != PAMI_SUCCESS && result != PAMI_EAGAIN)
{
fprintf (stderr, "Error. Unable to advance pami context. result = %d\n", result);
return 1;
}
}
/* Destroy the local memory region */
PAMI_Memregion_destroy (context[0], &(rts_info.memregion));
free (send_buffer);
switch (_ack_status)
{
case 0:
fprintf (stdout, "Test PASSED\n");
break;
case 1:
fprintf (stdout, "Test FAILED (rget error)\n");
break;
case 2:
fprintf (stdout, "Test FAILED (data error)\n");
break;
default:
fprintf (stdout, "Test FAILED (unknown error)\n");
break;
}
}
else if (task_id == num_tasks-1)
{
#ifdef TEST_CROSSTALK
size_t contextid = 1;
#else
size_t contextid = 0;
#endif
/* wait for the 'rts' */
fprintf (stderr, "Wait for 'rts', _rts_active = %zu, contextid = %zu\n", _rts_active, contextid);
while (_rts_active != 0)
{
result = PAMI_Context_advance (context[contextid], 100);
if (result != PAMI_SUCCESS && result != PAMI_EAGAIN)
{
fprintf (stderr, "Error. Unable to advance pami context. result = %d\n", result);
return 1;
}
}
}
fprintf (stderr, "Test completed .. cleanup\n");
result = PAMI_Context_destroyv (context, num);
if (result != PAMI_SUCCESS)
{
fprintf (stderr, "Error. Unable to destroy pami context. result = %d\n", result);
return 1;
}
result = PAMI_Client_destroy(&client);
if (result != PAMI_SUCCESS)
{
fprintf (stderr, "Error. Unable to destroy pami client. result = %d\n", result);
return 1;
}
/*fprintf (stdout, "Success (%d)\n", task_id); */
return 0;
};
int main(int argc, char *argv[]) {/*{{{*/
extern char *optarg;
char op, *namefilein;
int it;
ALPHA = 2;
BETA = 1;
RHO = 0.4;
M = 40;
it = 1000;
/* Usando getopt para tratamento dos argumentos */
struct option longopts[] = {/*{{{*/
{"alpha", 1, NULL, 'a'},
{"beta", 1, NULL, 'b'},
{"rho", 1, NULL, 'r'},
{"ants", 1, NULL, 'm'},
{"iterations", 1, NULL, 'i'},
{"help", 0, NULL, 'h'},
};/*}}}*/
while ((op = getopt_long(argc, argv, "a:b:r:m:i:h", longopts, NULL)) != -1) {/*{{{*/
switch (op) {
case 'a':
ALPHA = atoi(optarg);
break;
case 'b':
BETA = atoi(optarg);
break;
case 'r':
RHO = atoi(optarg);
break;
case 'm':
M = atoi(optarg);
break;
case 'i':
it = atoi(optarg);
break;
case 'h':
print_help(argv[0]);
return 0;
// case ':':
// /* a opção anterior precisa de especificação mas não recebeu */
// printf("Erro: arquivo de saida nao especificado. Use '-h' para ajuda.\n");
// return 0;
// case '?':
// /* opção não existe */
// printf("Erro: opcao '-%c' nao existente. Use '-h' para ajuda.\n", optopt);
// return 0;
}
}/*}}}*/
/*{{{*/
/* O único argumento não capturado acima é o nome do arquivo de entrada,
* se existir */
if (optind < argc) {
namefilein = malloc(sizeof(char) * strlen(argv[optind]));
strcpy(namefilein, argv[optind++]);
/* verificar se foi passado algum argumento a mais */
if (optind < argc) {
printf("Erro: foram passados muitos argumentos. Use '-h' para ajuda.\n");
return 0;
}
}
else {
printf("Erro: falta nome do arquivo de entrada. Use '-h' para ajuda.\n");
return 0;
}
if (!fopen(namefilein, "r")) {
printf("Erro: arquivo ou diretorio inexistente.\n");
return 0;
}
/*}}}*/
int terminate = 0;
int k = 0;
initialize_data(namefilein);
while (!terminate && k != it) {
construct_solutions();
local_search();
//update_statistics();
update_pheromone_trails();
k++;
}
int menor = 0;
for (k = 1; k < M; k++) {
if (ant[menor].tour_length > ant[k].tour_length) {
menor = k;
}
}
printf("%d: %d\n", menor, ant[menor].tour_length);
return 0;
}/*}}}*/
int
main (int argc, const char **argv)
{
GMainLoop *main_loop;
struct sigaction sig_action;
const char *config_file;
char *python_path;
g_thread_init (NULL);
g_type_init ();
rcd_executable_name = g_strdup (argv[0]);
rcd_options_parse (argc, argv);
if (rcd_options_get_show_version ()) {
g_print ("%s\n", rcd_about_name ());
g_print ("%s\n\n", rcd_about_copyright ());
exit (0);
}
config_file = rcd_options_get_config_file ();
if (config_file && !g_file_test (config_file, G_FILE_TEST_EXISTS)) {
g_printerr ("Unable to find config file '%s'\n", config_file);
g_printerr ("rcd aborting\n");
exit (-1);
}
root_check ();
if (!rcd_options_get_late_background ())
daemonize ();
/* Set up SIGTERM and SIGQUIT handlers */
sig_action.sa_handler = signal_handler;
sigemptyset (&sig_action.sa_mask);
sig_action.sa_flags = 0;
sigaction (SIGINT, &sig_action, NULL);
sigaction (SIGTERM, &sig_action, NULL);
sigaction (SIGQUIT, &sig_action, NULL);
/* Set up SIGHUP handler. */
sig_action.sa_handler = sighup_handler;
sigemptyset (&sig_action.sa_mask);
sig_action.sa_flags = 0;
sigaction (SIGHUP, &sig_action, NULL);
/* If it looks like rcd-buddy is in the right place, set up
handlers for crashes */
python_path = g_find_program_in_path ("python");
if (python_path != NULL
&& g_file_test (SHAREDIR "/rcd-buddy", G_FILE_TEST_EXISTS)) {
sig_action.sa_handler = crash_handler;
sigaction (SIGSEGV, &sig_action, NULL);
sigaction (SIGFPE, &sig_action, NULL);
sigaction (SIGBUS, &sig_action, NULL);
sigaction (SIGABRT, &sig_action, NULL);
}
g_free (python_path);
rcd_privileges_init ();
initialize_logging ();
/* Check to see if the password file is secure.
If it isn't, a big warning will go out to the log file. */
rcd_identity_password_file_is_secure ();
/* Set the GPG keyring for package verification */
rc_verification_set_keyring (SHAREDIR "/rcd.gpg");
/* Create mid and secret */
if (!g_file_test (SYSCONFDIR "/mcookie", G_FILE_TEST_EXISTS))
rcd_create_uuid (SYSCONFDIR "/mcookie");
if (!g_file_test (SYSCONFDIR "/partnernet", G_FILE_TEST_EXISTS))
rcd_create_uuid (SYSCONFDIR "/partnernet");
/* Add memory usage watcher */
rcd_heartbeat_register_func (heartbeat_memory_monitor, NULL);
initialize_rc_packman ();
initialize_rc_services ();
initialize_rc_world ();
initialize_rpc ();
if (!rcd_options_get_no_modules_flag ())
rcd_module_init ();
/* We can't daemonize any later than this, so hopefully module
initialization won't be slow. */
if (rcd_options_get_late_background ()) {
rc_debug (RC_DEBUG_LEVEL_ALWAYS, "Running daemon in background.");
daemonize ();
/* We need to reinit logging, since the file descriptor gets closed
when we daemonize. */
rcd_log_reinit ();
/* Say hello again, so it gets stored in the log file. */
hello ();
}
rcd_rpc_local_server_start ();
if (rcd_prefs_get_remote_server_enabled ()) {
if (!rcd_rpc_remote_server_start ())
exit (-1);
}
initialize_data ();
/* No heartbeat if we have initialized from a dump file. */
if (rcd_options_get_dump_file () == NULL)
rcd_heartbeat_start ();
main_loop = g_main_loop_new (NULL, TRUE);
g_main_loop_run (main_loop);
/*
* We'll never reach here, because we'll exit() out in
* rcd-shutdown.c.
*/
g_assert_not_reached ();
return 0;
} /* main */
void main(int argc, char **argv) {
double start_t, end_t;
int my_rank, p;
complex A[512*512], B[512*512], C[512*512];
/* initialize MPI */
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &p);
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
/* Create MPI Datatype for Complex */
const float nitems=2;
int blocklengths[2] = {1,1};
MPI_Datatype types[2] = {MPI_FLOAT, MPI_FLOAT};
MPI_Aint offsets[2];
offsets[0] = offsetof(complex, r);
offsets[1] = offsetof(complex, i);
MPI_Type_create_struct(nitems, blocklengths, offsets, types, &mpi_complex);
MPI_Type_commit(&mpi_complex);
/* Initialize Data*/
if(my_rank == 0) {
initialize_data(f1_name, A);
initialize_data(f2_name, B);
start_t = MPI_Wtime();
dist_data(A, p);
dist_data(B, p);
} else {
recv_data(A, p, my_rank);
recv_data(B, p, my_rank);
}
/* 2D FFT on A */
execute_fft(A, 1, p, my_rank);
collect_data(A, p, my_rank);
if(my_rank == 0) {
transpose(A);
dist_data(A, p);
} else {
recv_data(A, p, my_rank);
}
execute_fft(A, 1, p, my_rank);
/* 2D FFT on B */
execute_fft(B, 1, p, my_rank);
collect_data(B, p, my_rank);
if(my_rank == 0) {
transpose(B);
dist_data(B, p);
} else {
recv_data(B, p, my_rank);
}
execute_fft(B, 1, p, my_rank);
/* Multiplication Step */
execute_mm(A, B, C, p, my_rank);
/* 2D FFT on C */
execute_fft(C, -1, p, my_rank);
collect_data(C, p, my_rank);
if(my_rank == 0) {
transpose(C);
dist_data(C, p);
} else {
recv_data(C, p, my_rank);
}
execute_fft(C, -1, p, my_rank);
collect_data(C, p, my_rank);
end_t = MPI_Wtime();
if(my_rank == 0) {
output_data(f_out, C);
printf("\nElapsed time = %g s\n", end_t - start_t);
printf("--------------------------------------------\n");
}
MPI_Finalize();
}
int main (int argc, char *argv[])
{
Zoltan_DD_Directory *dd;
ZTIMER *zt;
int myproc; /* MPI rank, my processor's MPI ID */
int nproc; /* MPI size, number of processors */
ZOLTAN_ID_PTR glist = NULL; /* list of GIDs */
ZOLTAN_ID_PTR llist = NULL; /* list of LIDs */
ZOLTAN_ID_PTR ulist = NULL; /* list of user data of type
ZOLTAN_ID_TYPE */
int *plist = NULL; /* list of partitions */
int *olist = NULL; /* list of owners */
Param param ; /* program's adjustable parameters */
char *store = NULL; /* non directory storage of test data */
Data *data = NULL; /* pointer into store */
/* these are all temporary variables */
int new_owner;
int count;
int i;
char *p;
int err;
int errcount;
int loop;
char str[100]; /* for building output messages */
static int timer[7] = {-1,-1,-1,-1,-1,-1,-1};
char *yo = "DD_Main";
/* initialize MPI communications, ignore errors */
MPI_Init (&argc, &argv);
MPI_Comm_rank (MPI_COMM_WORLD, &myproc);
MPI_Comm_size (MPI_COMM_WORLD, &nproc);
get_params (¶m); /* read input parameters */
zt = Zoltan_Timer_Create(1);
MACRO_TIMER_START(5, "Total time", 0);
MACRO_TIMER_START(0, "DD_Create time", 0);
err = Zoltan_DD_Create (&dd, MPI_COMM_WORLD, param.glen, param.llen,
param.ulen, param.tlen, param.debug_level);
if (err != ZOLTAN_OK)
ZOLTAN_PRINT_ERROR (myproc, yo, "Failed return from DD Create");
MACRO_TIMER_STOP(0);
param.slen = sizeof (Data) + sizeof(ZOLTAN_ID_TYPE)
* (param.glen + param.llen + param.ulen);
param.slen = Zoltan_Align(param.slen);
store = (char*) ZOLTAN_MALLOC (param.count * param.slen);
/* allocate storage for various lists */
glist = (ZOLTAN_ID_PTR) ZOLTAN_MALLOC(sizeof(ZOLTAN_ID_TYPE) * param.count
* param.glen);
plist = (int*) ZOLTAN_MALLOC (sizeof(int) * param.count);
olist = (int*) ZOLTAN_MALLOC (sizeof(int) * param.count);
if (param.llen)
llist = (ZOLTAN_ID_PTR) ZOLTAN_MALLOC (sizeof (ZOLTAN_ID_TYPE)
* param.count * param.llen);
if (param.ulen)
ulist = (ZOLTAN_ID_PTR) ZOLTAN_MALLOC (sizeof (ZOLTAN_ID_TYPE)
* param.count * param.ulen) ;
if (store == NULL || glist == NULL || (param.llen != 0 && llist == NULL)
|| (param.ulen != 0 && ulist == NULL) || plist == NULL || olist == NULL) {
ZOLTAN_PRINT_ERROR (myproc, yo, "Unable to malloc storage lists");
return ZOLTAN_MEMERR;
}
initialize_data (¶m, store, nproc);
/* create & update directory with myproc's initial simulated GIDs */
count = 0;
for (p = store; p < store + param.count * param.slen; p += param.slen)
if (((Data *)p)->new_owner == myproc) {
ZOLTAN_SET_ID (param.glen, glist + count * param.glen, ((Data*)p)->id);
if (param.llen)
ZOLTAN_SET_ID (param.llen, llist + count * param.llen,
((Data *)p)->id + param.glen);
if (param.ulen)
ZOLTAN_SET_ID (param.ulen, ulist + count * param.ulen,
((Data *)p)->id + (param.glen + param.llen));
plist [count] = ((Data *)p)->partition;
++count;
}
MACRO_TIMER_START (1, "DD_Update timer", 0);
err = Zoltan_DD_Update (dd, glist, llist, ulist, plist, count);
if (err != ZOLTAN_OK)
ZOLTAN_PRINT_ERROR (myproc, yo, "Failed return from DD Update");
MACRO_TIMER_STOP(1);
i = 0;
for (p = store; p < store + param.count * param.slen; p += param.slen) {
ZOLTAN_SET_ID (param.glen, glist + i * param.glen, ((Data *)p)->id);
++i;
}
MACRO_TIMER_START(2, "DD_Find timer", 0);
err = Zoltan_DD_Find (dd, glist, llist, ulist, plist, param.count, olist);
if (err != ZOLTAN_OK)
ZOLTAN_PRINT_ERROR (myproc, yo, "Failed return from DD Find");
MACRO_TIMER_STOP(2);
errcount = 0;
for (i = 0; i < param.count; i++)
if (olist[i] != ((Data *) (store + i * param.slen))->new_owner)
++errcount;
if (errcount)
sprintf (str, "FIRST TEST FAILED, errcount is %d", errcount);
else
sprintf (str, "FIRST TEST SUCCESSFUL");
ZOLTAN_PRINT_INFO (myproc, yo, str);
/* repeatedly simulate moving "dots" around the system */
for (loop = 0; loop < param.nloops; loop++)
{
for (p = store; p < store + param.count * param.slen; p += param.slen)
((Data*) p)->old_owner = ((Data*) p)->new_owner;
/* randomly exchange some dots and randomly reassign others */
for (i = 0; i < (param.pmove * param.count)/100; i++) {
Data *d1, *d2;
d1 = (Data*) (store + param.slen * (rand() % param.count));
d2 = (Data*) (store + param.slen * (rand() % param.count));
new_owner = d1->new_owner;
d1->new_owner = d2->new_owner;
d2->new_owner = new_owner;
}
for (i = 0; i < (param.count * param.pscatter)/100; i++)
((Data*) (store + param.slen *(rand() % param.count)))->new_owner
= rand() % nproc;
/* determine which new GIDs myproc gained, and update directory */
count = 0;
for (p = store; p < store + param.count * param.slen; p += param.slen)
if (((Data*)p)->new_owner == myproc) {
((Data*)p)->id[param.glen] = count; /* set LID */
ZOLTAN_SET_ID (param.glen, glist + count * param.glen,
((Data *)p)->id);
if (param.llen)
ZOLTAN_SET_ID (param.llen, llist + count * param.llen,
((Data*)p)->id + param.glen);
if (param.ulen)
ZOLTAN_SET_ID (param.ulen, ulist + count * param.ulen,
((Data*)p)->id + (param.glen + param.llen));
plist [count] = ((Data *)p)->partition;
++count;
}
MACRO_TIMER_START(1, "DD_Update", 0);
err = Zoltan_DD_Update (dd, glist, llist, ulist, plist, count);
if (err != ZOLTAN_OK)
ZOLTAN_PRINT_ERROR (myproc, yo, "Failed return from DD Update");
MACRO_TIMER_STOP(1);
/* use directory to "find" GIDs */
i = 0;
for (p = store; p < store + param.count * param.slen; p += param.slen) {
ZOLTAN_SET_ID (param.glen, glist + i * param.glen, ((Data *)p)->id);
++i;
}
MACRO_TIMER_START(2, "DD_Find timer", 0);
if (loop % 5 == 0)
err = Zoltan_DD_Find(dd,glist,NULL,ulist,plist,param.count,olist);
else if (loop % 7 == 0)
err = Zoltan_DD_Find(dd,glist,llist,NULL,plist,param.count,olist);
else if (loop % 9 == 0)
err = Zoltan_DD_Find(dd,glist,llist,ulist,NULL,param.count,olist);
else if (loop % 2 == 0)
err = Zoltan_DD_Find(dd,glist,llist,ulist,plist,param.count,NULL);
else
err = Zoltan_DD_Find(dd,glist,llist,ulist,plist,param.count,olist);
if (err != ZOLTAN_OK)
ZOLTAN_PRINT_ERROR (myproc, yo, "Failed return from DD Find");
MACRO_TIMER_STOP(2);
if (loop % 2) {
errcount = 0 ;
for (i = 0; i < param.count; i++)
if (olist[i] != ((Data *)(store + i * param.slen))->new_owner)
++errcount;
if (errcount)
sprintf (str,"LOOP %d TEST FAILED, errcount is %d",loop,errcount);
else
sprintf (str, "LOOP %d TEST SUCCESSFUL", loop);
ZOLTAN_PRINT_INFO (myproc, yo, str) ;
}
else {
sprintf (str, "LOOP %d Completed", loop);
ZOLTAN_PRINT_INFO (myproc, yo, str);
}
/* randomly remove a percentage of GIDs from the directory */
count = 0;
for (i = 0; i < (param.count * param.pdelete)/100; i++) {
data = (Data*) (store + param.slen * (rand() % param.count));
if (data->new_owner == myproc) {
ZOLTAN_SET_ID (param.glen, glist + count * param.glen, data->id);
++count;
}
data->new_owner = NO_PROC;
}
MACRO_TIMER_START(3, "DD_Remove timer", 0);
err = Zoltan_DD_Remove (dd, glist, count);
MACRO_TIMER_STOP(3);
if (err != ZOLTAN_OK)
ZOLTAN_PRINT_ERROR (myproc, yo, "Failed return from DD Remove");
/* update directory (put directory entries back in) */
for (p = store; p < store + param.count * param.slen; p += param.slen)
if (((Data*)p)->new_owner == NO_PROC)
((Data*)p)->new_owner = loop % nproc; /* place in new location */
count = 0;
for (p = store; p < store + param.count * param.slen; p += param.slen)
if (((Data*)p)->new_owner == myproc) {
ZOLTAN_SET_ID(param.glen,glist+count*param.glen,((Data*)p)->id);
if (param.llen)
ZOLTAN_SET_ID (param.llen, llist + count * param.llen,
((Data*)p)->id + param.glen);
if (param.ulen)
ZOLTAN_SET_ID(param.ulen, ulist + count * param.ulen,
((Data *)p)->id + (param.glen + param.llen));
plist [count] = ((Data*)p)->partition;
++count;
}
MACRO_TIMER_START(1, "DD_Update timer", 0);
err = Zoltan_DD_Update (dd, glist, NULL, NULL, NULL, count);
if (err != ZOLTAN_OK)
ZOLTAN_PRINT_ERROR (myproc, yo, "Failed return from DD Update");
MACRO_TIMER_STOP(1);
}
/* now Find directory info for GIDs myproc now owns and validate */
count = 0;
for (i = 0; i < param.count; i++) {
data = (Data *) (store + i * param.slen);
if (data->new_owner == myproc) {
ZOLTAN_SET_ID (param.glen, glist + count * param.glen, data->id);
++count;
}
}
MACRO_TIMER_START(2, "DD_Find", 0);
err = Zoltan_DD_Find (dd, glist, NULL, NULL, NULL, count, olist);
if (err != ZOLTAN_OK)
ZOLTAN_PRINT_ERROR (myproc, yo, "Failed return from DD Find");
MACRO_TIMER_STOP(2);
errcount = 0;
for (i = 0; i < count; i++)
if (olist[i] != myproc)
++errcount;
if (errcount) {
sprintf (str, "errcount is %d", errcount);
ZOLTAN_PRINT_ERROR (myproc, yo, str);
}
else
ZOLTAN_PRINT_INFO (myproc, yo, "TEST SUCCESSFUL");
Zoltan_DD_Stats (dd);
/* done, now free memory, stop MPI & directory, return */
ZOLTAN_FREE (&store);
ZOLTAN_FREE (&glist);
ZOLTAN_FREE (&plist);
ZOLTAN_FREE (&olist);
if (param.llen) ZOLTAN_FREE (&llist);
if (param.ulen) ZOLTAN_FREE (&ulist);
ZOLTAN_PRINT_INFO (myproc, yo, "Completing program");
MACRO_TIMER_START(4, "DD_Destroy", 0);
Zoltan_DD_Destroy (&dd);
MACRO_TIMER_STOP(4);
MACRO_TIMER_STOP(5);
Zoltan_Timer_PrintAll(zt, 0, MPI_COMM_WORLD, stderr);
MPI_Finalize ();
return ZOLTAN_OK;
}
/**
* Called by the CBTF collector service in order to start data collection.
*/
void cbtf_collector_start(const CBTF_DataHeader* const header)
{
/**
* Start tracing.
*
* Starts MPI event tracing for the thread executing this function.
* Initializes the appropriate thread-local data structures.
*
* @param arguments Encoded function arguments.
*/
/* Create and access our thread-local storage */
#ifdef USE_EXPLICIT_TLS
TLS* tls = malloc(sizeof(TLS));
Assert(tls != NULL);
CBTF_SetTLS(TLSKey, tls);
mpi_init_tls_done = true;
#else
TLS* tls = &the_tls;
#endif
Assert(tls != NULL);
tls->defer_sampling=FALSE;
/* Decode the passed function arguments */
// Need to handle the arguments...
CBTF_mpi_start_sampling_args args;
memset(&args, 0, sizeof(args));
#if 0
CBTF_DecodeParameters(arguments,
(xdrproc_t)xdr_CBTF_mpi_start_sampling_args,
&args);
#endif
#if defined(CBTF_SERVICE_USE_OFFLINE)
/* If CBTF_MPI_TRACED is set to a valid list of mpi functions, trace only
* those functions.
* If CBTF_MPI_TRACED is set and is empty, trace all functions.
* For any misspelled function name in CBTF_MPI_TRACED, silently ignore.
* If all names in CBTF_MPI_TRACED are misspelled or not part of
* TraceableFunctions, nothing will be traced.
*/
const char* mpi_traced = getenv("CBTF_MPI_TRACED");
if (mpi_traced != NULL && strcmp(mpi_traced,"") != 0) {
strcpy(tls->CBTF_mpi_traced,mpi_traced);
} else {
strcpy(tls->CBTF_mpi_traced,all);
}
#endif
memcpy(&tls->header, header, sizeof(CBTF_DataHeader));
/* Initialize the actual data blob */
initialize_data(tls);
/* We can not assign mpi rank in the header at this point as it may not
* be set yet. assign an integer tid value. omp_tid is used regardless of
* whether the application is using openmp threads.
* libmonitor uses the same numbering scheme as openmp.
*/
tls->header.omp_tid = monitor_get_thread_num();
#ifndef NDEBUG
IsCollectorDebugEnabled = (getenv("CBTF_DEBUG_COLLECTOR") != NULL);
IsCollectorDetailDebugEnabled = (getenv("CBTF_DEBUG_COLLECTOR_DETAIL") != NULL);
if (IsCollectorDebugEnabled) {
fprintf(stderr,"[%ld,%d] ENTERED cbtf_collector_start.\n",tls->header.pid, tls->header.omp_tid);
}
#endif
/* Initialize the MPI function wrapper nesting depth */
tls->nesting_depth = 0;
/* Begin sampling */
tls->header.time_begin = CBTF_GetTime();
tls->do_trace = TRUE;
}
/**
* Called by the CBTF collector service in order to start data collection.
*/
void cbtf_collector_start(const CBTF_DataHeader* header)
{
/**
* Start sampling.
*
* Starts hardware counter (HWC) sampling for the thread executing this
* function. Initializes the appropriate thread-local data structures and
* then enables the sampling counter.
*
* @param arguments Encoded function arguments.
*/
/* Create and access our thread-local storage */
#ifdef USE_EXPLICIT_TLS
TLS* tls = malloc(sizeof(TLS));
Assert(tls != NULL);
CBTF_SetTLS(TLSKey, tls);
#else
TLS* tls = &the_tls;
#endif
Assert(tls != NULL);
tls->defer_sampling=false;
#ifndef NDEBUG
IsCollectorDebugEnabled = (getenv("CBTF_DEBUG_COLLECTOR") != NULL);
IsCollectorDetailsDebugEnabled = (getenv("CBTF_DEBUG_COLLECTOR_DETAILS") != NULL);
#if defined (HAVE_OMPT)
IsOMPTDebugEnabled = (getenv("CBTF_DEBUG_COLLECTOR_OMPT") != NULL);
#endif
#endif
/* Decode the passed function arguments */
// Need to handle the arguments...
CBTF_hwcsamp_start_sampling_args args;
memset(&args, 0, sizeof(args));
args.sampling_rate = 100;
/* First set defaults */
int hwcsamp_rate = 100;
char* hwcsamp_papi_event = "PAPI_TOT_CYC,PAPI_TOT_INS";
#if defined (CBTF_SERVICE_USE_OFFLINE)
char* hwcsamp_event_param = getenv("CBTF_HWCSAMP_EVENTS");
if (hwcsamp_event_param != NULL) {
hwcsamp_papi_event=hwcsamp_event_param;
}
const char* sampling_rate = getenv("CBTF_HWCSAMP_RATE");
if (sampling_rate != NULL) {
hwcsamp_rate=atoi(sampling_rate);
}
args.collector = 1;
args.experiment = 0;
tls->data.interval = (uint64_t)(1000000000) / (uint64_t)(hwcsamp_rate);;
#endif
/* Initialize the actual data blob */
memcpy(&tls->header, header, sizeof(CBTF_DataHeader));
initialize_data(tls);
/* We can not assign mpi rank in the header at this point as it may not
* be set yet. assign an integer tid value. omp_tid is used regardless of
* whether the application is using openmp threads.
* libmonitor uses the same numbering scheme as openmp.
*/
tls->header.omp_tid = monitor_get_thread_num();
tls->header.id = strdup(cbtf_collector_unique_id);
tls->header.time_begin = CBTF_GetTime();
#ifndef NDEBUG
if (IsCollectorDebugEnabled) {
fprintf(stderr,"[%ld,%d] ENTER cbtf_collector_start\n",tls->header.pid,tls->header.omp_tid);
}
#endif
if(hwcsamp_papi_init_done == 0) {
#ifndef NDEBUG
if (IsCollectorDebugEnabled) {
fprintf(stderr,"[%ld,%d] cbtf_collector_start: initialize papi\n",tls->header.pid,tls->header.omp_tid);
}
#endif
CBTF_init_papi();
tls->EventSet = PAPI_NULL;
tls->data.clock_mhz = (float) hw_info->mhz;
hwcsamp_papi_init_done = 1;
} else {
tls->data.clock_mhz = (float) hw_info->mhz;
}
/* PAPI SETUP */
CBTF_Create_Eventset(&tls->EventSet);
int rval = PAPI_OK;
#ifndef NDEBUG
if (IsCollectorDebugEnabled) {
fprintf(stderr, "PAPI Version: %d.%d.%d.%d\n", PAPI_VERSION_MAJOR( PAPI_VERSION ),
PAPI_VERSION_MINOR( PAPI_VERSION ),
PAPI_VERSION_REVISION( PAPI_VERSION ),
PAPI_VERSION_INCREMENT( PAPI_VERSION ) );
fprintf(stderr,"System has %d hardware counters.\n", PAPI_num_counters());
}
#endif
/* In Component PAPI, EventSets must be assigned a component index
* before you can fiddle with their internals. 0 is always the cpu component */
#if (PAPI_VERSION_MAJOR(PAPI_VERSION)>=4)
rval = PAPI_assign_eventset_component( tls->EventSet, 0 );
if (rval != PAPI_OK) {
CBTF_PAPIerror(rval,"CBTF_Create_Eventset assign_eventset_component");
return;
}
#endif
/* NOTE: if multiplex is turned on, papi internaly uses a SIGPROF handler.
* Since we are sampling potentially with SIGPROF or now SIGRTMIN and we
* prefer to limit our events to 6, we do not need multiplexing.
*/
if (getenv("CBTF_HWCSAMP_MULTIPLEX") != NULL) {
#if !defined(RUNTIME_PLATFORM_BGP)
rval = PAPI_set_multiplex( tls->EventSet );
if ( rval == PAPI_ENOSUPP) {
fprintf(stderr,"CBTF_Create_Eventset: Multiplex not supported\n");
} else if (rval != PAPI_OK) {
CBTF_PAPIerror(rval,"CBTF_Create_Eventset set_multiplex");
}
#endif
}
/* TODO: check return values of direct PAPI calls
* and handle them as needed.
*/
/* Rework the code here to call PAPI directly rather than
* call any OPENSS helper functions due to inconsitent
* behaviour seen on various lab systems
*/
int eventcode = 0;
rval = PAPI_OK;
if (hwcsamp_papi_event != NULL) {
char *tfptr, *saveptr=NULL, *tf_token;
tfptr = strdup(hwcsamp_papi_event);
for (tf_token = strtok_r(tfptr, ",", &saveptr);
tf_token != NULL;
tf_token = strtok_r(NULL, ",", &saveptr) ) {
PAPI_event_name_to_code(tf_token,&eventcode);
rval = PAPI_add_event(tls->EventSet,eventcode);
if (rval != PAPI_OK) {
CBTF_PAPIerror(rval,"CBTF_Create_Eventset PAPI_event_name_to_code");
}
}
if (tfptr) free(tfptr);
} else {
PAPI_event_name_to_code("PAPI_TOT_CYC",&eventcode);
rval = PAPI_add_event(tls->EventSet,eventcode);
PAPI_event_name_to_code("PAPI_TOT_INS",&eventcode);
rval = PAPI_add_event(tls->EventSet,eventcode);
}
#if defined (HAVE_OMPT)
/* these are ompt specific.*/
/* initialize the flags and counts for idle,wait_barrier. */
tls->thread_idle = tls->thread_wait_barrier = tls->thread_barrier = false;
#endif
/* Begin sampling */
tls->header.time_begin = CBTF_GetTime();
CBTF_Start(tls->EventSet);
CBTF_Timer(tls->data.interval, hwcsampTimerHandler);
}
int main(void)
{
int sockfd, new_fd; // listen on sock_fd, new connection on new_fd
struct addrinfo hints, *servinfo, *p;
struct sockaddr_storage their_addr; // connector's address information
socklen_t sin_size;
struct sigaction sa;
int yes=1;
char s[INET6_ADDRSTRLEN];
int rv;
// Initialize mutex
if (pthread_mutex_init(&lock, NULL) != 0)
{
printf("\n mutex init failed\n");
return 1;
}
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE; // use my IP
if ((rv = getaddrinfo(NULL, PORT, &hints, &servinfo)) != 0) {
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
return 1;
}
// loop through all the results and bind to the first we can
for(p = servinfo; p != NULL; p = p->ai_next) {
if ((sockfd = socket(p->ai_family, p->ai_socktype,
p->ai_protocol)) == -1) {
perror("server: socket");
continue;
}
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes,
sizeof(int)) == -1) {
perror("setsockopt");
exit(1);
}
if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
close(sockfd);
perror("server: bind");
continue;
}
break;
}
if (p == NULL) {
fprintf(stderr, "server: failed to bind\n");
return 2;
}
freeaddrinfo(servinfo); // all done with this structure
if (listen(sockfd, BACKLOG) == -1) {
perror("listen");
exit(1);
}
sa.sa_handler = sigchld_handler; // reap all dead processes
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
if (sigaction(SIGCHLD, &sa, NULL) == -1) {
perror("sigaction");
exit(1);
}
// Server ready
// Initialize data
initialize_data();
printf("server: waiting for connections...\n");
while(1) { // main accept() loop
sin_size = sizeof their_addr;
new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);
if (new_fd == -1) {
perror("accept");
continue;
}
inet_ntop(their_addr.ss_family,
get_in_addr((struct sockaddr *)&their_addr),
s, sizeof s);
printf("server: got connection from %s\n", s);
pthread_t thread;
int rc = pthread_create(&thread, NULL,
handle_client, (void *)&new_fd);
}
pthread_mutex_destroy(&lock);
return 0;
}