void tcpdemux::remove_all_flows()
{
for(flow_map_t::iterator it=flow_map.begin();it!=flow_map.end();it++){
post_process(it->second);
}
flow_map.clear();
}
void enframe()
{
static uint16_t frame_num = 0;
if(cbuffer.count < FRAME_SIZE)
return; //nothing to do
float32_t fdata[FFT_SIZE] = {0};
if(frame_num >= NUM_FRAME)
post_process();
uint16_t i;
uint16_t head_length = MAX_BUF_SIZE-cbuffer.header;
if(head_length < MIN2(FRAME_SIZE,FFT_SIZE))//complex case
{
for(i = 0; i < head_length; i++)
fdata[i] = Hamming[i]*cbuffer.data[cbuffer.header+i];
for(i = 0; i < MIN2(FRAME_SIZE,FFT_SIZE)-head_length; i++)
fdata[head_length+i] = Hamming[head_length+i]*cbuffer.data[i];
}
else //simple case
for(i = 0; i < MIN2(FRAME_SIZE,FFT_SIZE); ++i) //SIMD not available
fdata[i] = Hamming[i]*cbuffer.data[cbuffer.header+i];
#if(FFT_SIZE > FRAME_SIZE)
memset(fdata+FRAME_SIZE, 0, (FFT_SIZE-FRAME_SIZE+1)*sizeof(float32_t));//zero padding
#endif
cbuffer.count -= FRAME_SHIFT; //counter modification
cbuffer.header += FRAME_SHIFT;
if(cbuffer.header >= MAX_BUF_SIZE)
cbuffer.header -= MAX_BUF_SIZE;
mfcc(fdata, feature_vec[frame_num]);
post_proc_callback(&feature_vec[0][0], frame_num);
frame_num++;
}
void tcpdemux::remove_flow(const flow_addr &flow)
{
flow_map_t::iterator it = flow_map.find(flow);
if(it!=flow_map.end()){
post_process(it->second);
flow_map.erase(it);
}
}
void extract_jsa_candidate(jsa_solutiont &solution, const jsa_programt &prog,
const goto_tracet &trace, const pred_op_idst &pred_ops,
const pred_op_idst &result_pred_ops, const size_t max_size)
{
jsa_genetic_solutiont tmp;
extract_jsa_genetic_candidate(tmp, prog, trace);
post_process(tmp, pred_ops, result_pred_ops, max_size);
solution=convert(tmp, prog);
}
decision_proceduret::resultt bv_refinementt::dec_solve()
{
// do the usual post-processing
status() << "BV-Refinement: post-processing" << eom;
post_process();
debug() << "Solving with " << prop.solver_text() << eom;
unsigned iteration=0;
// now enter the loop
while(true)
{
iteration++;
status() << "BV-Refinement: iteration " << iteration << eom;
// output the very same information in a structured fashion
if(ui==ui_message_handlert::XML_UI)
{
xmlt xml("refinement-iteration");
xml.data=i2string(iteration);
std::cout << xml << '\n';
}
switch(prop_solve())
{
case D_SATISFIABLE:
check_SAT();
if(!progress)
{
status() << "BV-Refinement: got SAT, and it simulates => SAT" << eom;
status() << "Total iterations: " << iteration << eom;
return D_SATISFIABLE;
}
else
status() << "BV-Refinement: got SAT, and it is spurious, refining" << eom;
break;
case D_UNSATISFIABLE:
check_UNSAT();
if(!progress)
{
status() << "BV-Refinement: got UNSAT, and the proof passes => UNSAT" << eom;
status() << "Total iterations: " << iteration << eom;
return D_UNSATISFIABLE;
}
else
status() << "BV-Refinement: got UNSAT, and the proof fails, refining" << eom;
break;
default:
return D_ERROR;
}
}
}
void
GraphImpl::process(ProcessContext& context)
{
if (!_process)
return;
pre_process(context);
run(context);
post_process(context);
}
static int
process_file(Elf *elf, char *cur_file, Cmd_Info *cmd_info)
{
int error = SUCCESS;
int x;
GElf_Ehdr ehdr;
size_t shnum;
/*
* Initialize
*/
if (gelf_getehdr(elf, &ehdr) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
if (elf_getshnum(elf, &shnum) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
initialize(shnum, cmd_info);
if (ehdr.e_phnum != 0) {
if (build_segment_table(elf, &ehdr) == FAILURE)
return (FAILURE);
}
if ((x = traverse_file(elf, &ehdr, cur_file, cmd_info)) ==
FAILURE) {
error_message(WRN_MANIPULATED_ERROR,
PLAIN_ERROR, (char *)0,
prog, cur_file);
error = FAILURE;
} else if (x != DONT_BUILD && x != FAILURE) {
post_process(cmd_info);
if (build_file(elf, &ehdr, cmd_info) == FAILURE) {
error_message(WRN_MANIPULATED_ERROR,
PLAIN_ERROR, (char *)0,
prog, cur_file);
error = FAILURE;
}
}
free(off_table);
free(sec_table);
free(nobits_table);
if (x == DONT_BUILD)
return (DONT_BUILD);
else
return (error);
}
/**
* This uses link_array. It post-processes
* this linkage, and prints the appropriate thing. There are no fat
* links in it.
*/
Linkage_info analyze_thin_linkage(Sentence sent, Parse_Options opts, int analyze_pass)
{
int i;
Linkage_info li;
PP_node * pp;
Postprocessor * postprocessor;
Sublinkage *sublinkage;
Parse_info pi = sent->parse_info;
build_digraph(pi, word_links);
memset(&li, 0, sizeof(li));
sublinkage = x_create_sublinkage(pi);
postprocessor = sent->dict->postprocessor;
compute_link_names(sent);
for (i=0; i<pi->N_links; i++) {
copy_full_link(&(sublinkage->link[i]), &(pi->link_array[i]));
}
if (analyze_pass==PP_FIRST_PASS) {
post_process_scan_linkage(postprocessor, opts, sent, sublinkage);
free_sublinkage(sublinkage);
free_digraph(pi, word_links);
return li;
}
/* The code below can be used to generate the "islands" array. For this to work,
* however, you have to call "build_digraph" first (as in analyze_fat_linkage).
* and then "free_digraph". For some reason this causes a space leak. */
pp = post_process(postprocessor, opts, sent, sublinkage, TRUE);
li.N_violations = 0;
li.and_cost = 0;
li.unused_word_cost = unused_word_cost(sent->parse_info);
li.improper_fat_linkage = FALSE;
li.inconsistent_domains = FALSE;
li.disjunct_cost = disjunct_cost(pi);
li.null_cost = null_cost(pi);
li.link_cost = link_cost(pi);
li.andlist = NULL;
if (pp==NULL) {
if (postprocessor != NULL) li.N_violations = 1;
} else if (pp->violation!=NULL) {
li.N_violations++;
}
free_sublinkage(sublinkage);
free_digraph(pi, word_links);
return li;
}
__DEVICE__
void exec_update_and_postprocess (CDATAFORMAT min_time, solver_props *props, unsigned int modelid, int resuming) {
int i;
for(i=0;i<NUM_ITERATORS;i++){
if(props[i].running[modelid] && (!resuming || props[i].next_time[modelid] == min_time)){
props[i].dirty_states[modelid] = 0 == update(&props[i], modelid);
}
if(props[i].running[modelid] && (resuming && props[i].next_time[modelid] == min_time)){
props[i].dirty_states[modelid] |= 0 == post_process(&props[i], modelid);
}
}
}
std::string &post_process_fitness_source(std::string &result,
const symbol_tablet &st, const goto_functionst &gf,
const size_t num_ce_vars, const size_t num_vars, const size_t num_consts,
const size_t max_prog_size, const std::string &exec)
{
const namespacet ns(st);
std::stringstream ss;
dump_c(gf, true, ns, ss);
add_first_prog_offset(result, num_ce_vars);
add_assume_implementation(result);
add_danger_execute(result, num_vars, num_consts, max_prog_size, exec);
return post_process(result, ss);
}
int main(int argc, char** argv)
{
uint8_t inbuf[SIZE];
uint8_t outbuf[SIZE];
// Test SHA-3
pp_data data;
data.type = SHA3;
data.input_data.sample = inbuf;
data.output_data = outbuf;
post_process(&data);
return 0;
}
t_list *tokenize_prompt(t_context *context, char *format)
{
t_token token;
int ret;
t_list *tokens;
tokens = 0;
while ((ret = read_token(&format, &token)) == 1)
ft_lstappend(&tokens, ft_lstnew(&token, sizeof(t_token)));
if (ret == -1)
ft_lstdel(&tokens, free_token);
post_process(context, tokens);
return (tokens);
}
intermediate_model
intermediate_model_factory::intermediate_model_for_descriptor(
const annotations::annotation_groups_factory& agf,
const annotations::type_repository& atrp,
frontend_registrar& rg, const descriptor& d) const {
BOOST_LOG_SEV(lg, debug) << "Creating intermediate model. "
<< "Descriptor: " << d;
auto& f(rg.frontend_for_extension(d.extension()));
auto r(f.read(d));
post_process(agf, atrp, r);
BOOST_LOG_SEV(lg, debug) << "Created intermediate model.";
return r;
}
decision_proceduret::resultt dplib_dect::dec_solve()
{
dplib_prop.out << "QUERY FALSE;" << std::endl;
dplib_prop.out << "COUNTERMODEL;" << std::endl;
post_process();
temp_out.close();
temp_result_filename=
"dplib_dec_result_"+i2string(getpid())+".tmp";
std::string command=
"dplibl "+temp_out_filename+" > "+temp_result_filename+" 2>&1";
system(command.c_str());
status("Reading result from CVCL");
return read_dplib_result();
}
int main(int argc, char **argv)
{
XMLParserContext *h;
int i;
if(argc != 3)
{
printf("error input args\n");
system("pause");
return 0;
}
h = read_XML_file(argv[1]);
for(i = 0; i < h->i_count_data_sets; i++)
{
parse_events(h, i);
post_process(h, i);
}
release_XML_file(h, argv[2]);
system("pause");
return 0;
}
int main(int argc, char* argv[])
{
// Check arguments
if (argc < 3) {
std::cerr << "Usage: shallow_water NODES_FILE TRIS_FILE\n";
exit(1);
}
MeshType mesh;
// HW4B: Need node_type before this can be used!
#if 1
std::vector<typename MeshType::node_type> mesh_node;
#endif
// Read all Points and add them to the Mesh
std::ifstream nodes_file(argv[1]);
Point p;
while (CS207::getline_parsed(nodes_file, p)) {
// HW4B: Need to implement add_node before this can be used!
#if 1
mesh_node.push_back(mesh.add_node(p));
#endif
}
// Read all mesh triangles and add them to the Mesh
std::ifstream tris_file(argv[2]);
std::array<int,3> t;
while (CS207::getline_parsed(tris_file, t)) {
// HW4B: Need to implement add_triangle before this can be used!
#if 1
mesh.add_triangle(mesh_node[t[0]], mesh_node[t[1]], mesh_node[t[2]]);
#endif
}
// Print out the stats
std::cout << mesh.num_nodes() << " "
<< mesh.num_edges() << " "
<< mesh.num_triangles() << std::endl;
// HW4B Initialization
// Set the initial conditions according the type of input pattern
if(argv[2][5]=='d'){
Dam<MeshType> init;
for(auto it= mesh.node_begin(); it != mesh.node_end(); ++it)
init(*it);
}
else if((argv[2][5]=='p')){
Pebble<MeshType> init;
for(auto it= mesh.node_begin(); it != mesh.node_end(); ++it)
init(*it);
}
else{
Wave<MeshType> init;
for(auto it= mesh.node_begin(); it != mesh.node_end(); ++it)
init(*it);
}
// Set triangle values
for (auto it=mesh.triangle_begin(); it!=mesh.triangle_end(); ++it) {
(*it).value().Q = QVar(0.0,0.0,0.0);
(*it).value().Q += (*it).node(0).value().Q;
(*it).value().Q += (*it).node(1).value().Q;
(*it).value().Q += (*it).node(2).value().Q;
(*it).value().Q /= 3.0;
}
// Launch the SDLViewer
CS207::SDLViewer viewer;
viewer.launch();
// HW4B: Need to define Mesh::node_type and node/edge iterator
// before these can be used!
#if 1
auto node_map = viewer.empty_node_map(mesh);
viewer.add_nodes(mesh.node_begin(), mesh.node_end(),
CS207::DefaultColor(), NodePosition(), node_map);
viewer.add_edges(mesh.edge_begin(), mesh.edge_end(), node_map);
#endif
viewer.center_view();
// HW4B: Timestep
// CFL stability condition requires dt <= dx / max|velocity|
// For the shallow water equations with u = v = 0 initial conditions
// we can compute the minimum edge length and maximum original water height
// to set the time-step
// Compute the minimum edge length and maximum water height for computing dt
double min_edge_length =( *mesh.edge_begin()).length();
for (auto it=mesh.edge_begin(); it!=mesh.edge_end(); ++it) {
if ((*it).length() < min_edge_length) {
min_edge_length = (*it).length();
}
}
double max_height = 0.0;
for (auto it=mesh.node_begin(); it!=mesh.node_end(); ++it) {
if ((*it).value().Q.h > max_height) {
max_height = (*it).value().Q.h;
}
}
#if 1
double dt = 0.25 * min_edge_length / (sqrt(grav * max_height));
#else
// Placeholder!! Delete me when min_edge_length and max_height can be computed!
double dt = 0.1;
#endif
double t_start = 0;
double t_end = 10;
// Preconstruct a Flux functor
EdgeFluxCalculator f;
// Begin the time stepping
for (double t = t_start; t < t_end; t += dt) {
//print(mesh, t);
// Step forward in time with forward Euler
hyperbolic_step(mesh, f, t, dt);
// Update node values with triangle-averaged values
post_process(mesh);
// Update the viewer with new node positions
// HW4B: Need to define node_iterators before these can be used!
#if 1
viewer.add_nodes(mesh.node_begin(), mesh.node_end(),
CS207::DefaultColor(), NodePosition(), node_map);
#endif
viewer.set_label(t);
// These lines slow down the animation for small meshes.
// Feel free to remove them or tweak the constants.
if (mesh.num_nodes() < 100)
CS207::sleep(0.05);
}
return 0;
}
int main( int argc, char *argv[])
{
static FLOAT synth_buf[L_FRAME+M]; /* Synthesis */
FLOAT *synth;
static int parm[PRM_SIZE+2]; /* Synthesis parameters + BFI */
static INT16 serial[SERIAL_SIZE]; /* Serial stream */
static FLOAT Az_dec[MP1*2]; /* Decoded Az for post-filter */
static int T2[2]; /* Decoded Pitch */
INT32 frame;
int i;
FILE *f_syn, *f_serial;
printf("\n");
printf("************** G.729A 8 KBIT/S SPEECH DECODER ************\n");
printf("\n");
printf("----------------- Floating point C simulation ----------------\n");
printf("\n");
printf("------------ Version 1.01 (Release 2, November 2006) --------\n");
printf("\n");
/* Passed arguments */
if ( argc != 3)
{
printf("Usage :%s bitstream_file outputspeech_file\n",argv[0]);
printf("\n");
printf("Format for bitstream_file:\n");
printf(" One (2-byte) synchronization word \n");
printf(" One (2-byte) size word,\n");
printf(" 80 words (2-byte) containing 80 bits.\n");
printf("\n");
printf("Format for outputspeech_file:\n");
printf(" Synthesis is written to a binary file of 16 bits data.\n");
exit( 1 );
}
/* Open file for synthesis and packed serial stream */
if( (f_serial = fopen(argv[1],"rb") ) == NULL )
{
printf("%s - Error opening file %s !!\n", argv[0], argv[1]);
exit(0);
}
if( (f_syn = fopen(argv[2], "wb") ) == NULL )
{
printf("%s - Error opening file %s !!\n", argv[0], argv[2]);
exit(0);
}
printf("Input bitstream file : %s\n",argv[1]);
printf("Synthesis speech file : %s\n",argv[2]);
/*-----------------------------------------------------------------*
* Initialization of decoder *
*-----------------------------------------------------------------*/
for (i=0; i<M; i++) synth_buf[i] = (F)0.0;
synth = synth_buf + M;
bad_lsf = 0; /* Initialize bad LSF indicator */
init_decod_ld8a();
init_post_filter();
init_post_process();
/*-----------------------------------------------------------------*
* Loop for each "L_FRAME" speech data *
*-----------------------------------------------------------------*/
frame =0;
while( fread(serial, sizeof(INT16), SERIAL_SIZE, f_serial) == SERIAL_SIZE)
{
frame++;
printf(" Frame: %ld\r", frame);
bits2prm_ld8k( &serial[2], &parm[1]);
if (serial[0] == SYNC_WORD) {
parm[0] = 0; /* No frame erasure */
} else {
parm[0] = 1; /* frame erased */
}
parm[4] = check_parity_pitch(parm[3], parm[4] ); /* get parity check result */
decod_ld8a(parm, synth, Az_dec, T2); /* decoder */
post_filter(synth, Az_dec, T2); /* Post-filter */
post_process(synth, L_FRAME); /* Highpass filter */
fwrite16(synth, L_FRAME, f_syn);
}
return(0);
}
//--------------------------------------------------------
// finish
// finalize state of nodal atomic quantities
//--------------------------------------------------------
void ElasticTimeIntegratorVerlet::finish()
{
post_process();
}
//--------------------------------------------------------
// finish
// finalize state of nodal atomic quantities
//--------------------------------------------------------
void ElasticTimeIntegratorFractionalStep::finish()
{
post_process();
}
int main(int argc, char **argv)
{
FILE *fp, *fp2, *pipe;
char testName[32] = "MPI_Allreduce", file1[64], file2[64], pipeStr[8];
int dblSize, proc, nprocs, nodeCPUs, nodes;
unsigned int i, j, size, localSize, NLOOP = NLOOP_MAX;
unsigned int smin = MIN_COL_SIZE, smed = MED_COL_SIZE, smax = MAX_COL_SIZE;
double tScale = USEC, bwScale = MB_8;
double tStart, timeMin, timeMinGlobal, overhead, threshold_lo, threshold_hi;
double msgBytes, sizeBytes, UsedMem, localMax;
double tElapsed[NREPS], tElapsedGlobal[NREPS];
double *A, *B;
pipe = popen( "cat /proc/cpuinfo | grep processor | wc -l", "r" );
fgets( pipeStr, 8, pipe ); pclose(pipe);
nodeCPUs = atoi(pipeStr);
// Initialize parallel environment
MPI_Init( &argc, &argv );
MPI_Comm_size( MPI_COMM_WORLD, &nprocs );
MPI_Comm_rank( MPI_COMM_WORLD, &proc );
// Reset maximum message size to fit within node memory
if( nprocs > nodeCPUs ){
nodes = nprocs / nodeCPUs;
if( smax > nodes ) smax = smax / nodes;
if( smed > nodes ) smed = smed / nodes;
}
// Check for user defined limits
checkEnvCOL( proc, &NLOOP, &smin, &smed, &smax );
// Initialize local variables
dblSize = sizeof(double);
UsedMem = (double)smax*(double)dblSize*(double)( nprocs + 1 );
// Allocate and initialize arrays
srand( SEED );
A = doubleVector( smax );
B = doubleVector( smax*nprocs );
// Open output file and write header
if( proc == 0 ){
// Check timer overhead in seconds
timerTest( &overhead, &threshold_lo, &threshold_hi );
// Open output files and write headers
sprintf( file1, "allreduce_time-np_%.4d.dat", nprocs );
sprintf( file2, "allreduce_bw-np_%.4d.dat", nprocs );
fp = fopen( file1, "a" );
fp2 = fopen( file2, "a" );
printHeaders( fp, fp2, testName, UsedMem, overhead, threshold_lo );
}
//================================================================
// Single loop with minimum size to verify that inner loop length
// is long enough for the timings to be accurate
//================================================================
// Warmup with a medium size message
MPI_Allreduce( A, B, smed, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD );
// Test is current NLOOP is enough to capture fastest test cases
MPI_Barrier( MPI_COMM_WORLD );
tStart = benchTimer();
for(j = 0; j < NLOOP; j++){
MPI_Allreduce( A, B, smin, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
}
timeMin = benchTimer() - tStart;
MPI_Reduce( &timeMin, &timeMinGlobal, 1, MPI_DOUBLE, MPI_MIN, 0, MPI_COMM_WORLD );
if( proc == 0 ) resetInnerLoop( timeMinGlobal, threshold_lo, &NLOOP );
MPI_Bcast( &NLOOP, 1, MPI_INT, 0, MPI_COMM_WORLD );
//================================================================
// Execute test for each requested size
//================================================================
localMax = 0.0;
for( size = smin; size <= smax; size = size*2 ){
// Warmup with a medium size message
MPI_Allreduce( A, B, smed, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD );
// Repeat NREPS to collect statistics
for(i = 0; i < NREPS; i++){
MPI_Barrier( MPI_COMM_WORLD );
tStart = benchTimer();
for(j = 0; j < NLOOP; j++){
MPI_Allreduce( A, B, size, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
}
tElapsed[i] = benchTimer() - tStart;
}
MPI_Reduce( tElapsed, tElapsedGlobal, NREPS, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD );
// Only task 0 needs to do the analysis of the collected data
if( proc == 0 ){
// sizeBytes is size to write to file
// msgBytes is actual data exchanged on the wire
msgBytes = (double)size*(double)nprocs*(double)dblSize;
sizeBytes = (double)size*(double)dblSize;
post_process( fp, fp2, threshold_hi, tElapsedGlobal, tScale,
bwScale, size*dblSize, sizeBytes, msgBytes, &NLOOP,
&localMax, &localSize );
}
MPI_Bcast( &NLOOP, 1, MPI_INT, 0, MPI_COMM_WORLD );
}
//================================================================
// Print completion message, free memory and exit
//================================================================
if( proc == 0 ){
fclose(fp);
fclose(fp2);
fprintf( stdout,"\n %s test completed.\n\n", testName );
}
free( A );
free( B );
MPI_Finalize();
return 0;
}
//--------------------------------------------------------
// finish
// finalize state of nodal atomic quantities
//--------------------------------------------------------
void FluidsTimeIntegratorGear::finish()
{
post_process();
}
int main(int argc, char **argv) {
if(argc != 2) {
fprintf(stderr, "%s <original boot.img> #This program will take local 'kernel' 'second' 'dt' 'ramdisk' files\n", argv[0]);
}
//TODO: Merge with extract.c?
//{
int ifd = open(argv[1], O_RDONLY);
off_t isize = lseek(ifd, 0, SEEK_END);
lseek(ifd, 0, SEEK_SET);
uint8_t *iorig = mmap(NULL, isize, PROT_READ, MAP_SHARED, ifd, 0);
uint8_t *ibase = iorig;
assert(ibase);
while(ibase<(iorig+isize)) {
if(memcmp(ibase, BOOT_MAGIC, BOOT_MAGIC_SIZE) == 0)
break;
ibase += 256;
}
assert(ibase < (iorig+isize));
//}
//
struct boot_img_hdr *ihdr = (struct boot_img_hdr*) ibase;
assert(
ihdr->page_size == 2048 ||
ihdr->page_size == 4096
);
unlink("new-boot.img");
int ofd = open("new-boot.img", O_RDWR|O_CREAT, 0644);
ftruncate(ofd, ihdr->page_size);
//Write back original header, we'll change it later
write(ofd, ihdr, sizeof(*ihdr));
struct boot_img_hdr *hdr = mmap(NULL, sizeof(*ihdr), PROT_READ|PROT_WRITE, MAP_SHARED, ofd, 0);
//First set everything to zero, so we know where we are at.
hdr->kernel_size = 0;
hdr->ramdisk_size = 0;
hdr->second_size = 0;
hdr->unused[0] = 0;
memset(hdr->id, 0, sizeof(hdr->id)); //Setting id to 0 might be wrong?
int pos = hdr->page_size;
int size = 0;
size = append_file(ofd, "kernel", pos);
pos += size + hdr->page_size - 1;
pos &= ~(hdr->page_size-1);
hdr->kernel_size = size;
size = append_ramdisk(ofd, pos);
pos += size + hdr->page_size - 1;
pos &= ~(hdr->page_size-1);
hdr->ramdisk_size = size;
if(access("second", R_OK) == 0) {
size = append_file(ofd, "second", pos);
pos += size + hdr->page_size - 1;
pos &= ~(hdr->page_size-1);
hdr->second_size = size;
}
if(access("dt", R_OK) == 0) {
size = append_file(ofd, "dt", pos);
pos += size + hdr->page_size - 1;
pos &= ~(hdr->page_size-1);
hdr->unused[0] = size;
}
post_process(hdr, ofd, pos);
munmap(hdr, sizeof(*ihdr));
close(ofd);
return 0;
}
int main(int argc, char **argv)
{
FILE *fp, *fp2;
char testName[32] = "MPI_Get_Fence", file1[64], file2[64];
int dblSize, proc, nprocs, npairs, partner;
unsigned int i, j, k, size, localSize, NLOOP = NLOOP_MAX;
unsigned int smin = MIN_P2P_SIZE, smed = MED_P2P_SIZE, smax = MAX_P2P_SIZE;
double tScale = USEC, bwScale = MB_8;
double tStart, timeMin, timeMinGlobal, overhead, threshold_lo, threshold_hi;
double msgBytes, sizeBytes, localMax, UsedMem;
double tElapsed[NREPS], tElapsedGlobal[NREPS];
double *A, *B;
MPI_Win win;
// Initialize parallel environment
MPI_Init(&argc, &argv);
MPI_Comm_size( MPI_COMM_WORLD, &nprocs );
MPI_Comm_rank( MPI_COMM_WORLD, &proc );
// Test input parameters
if( nprocs%2 != 0 && proc == 0 )
fatalError( "P2P test requires an even number of processors" );
// Check for user defined limits
checkEnvP2P( proc, &NLOOP, &smin, &smed, &smax );
// Initialize local variables
localMax = 0.0;
npairs = nprocs/2;
if( proc < npairs ) partner = proc + npairs;
if( proc >= npairs ) partner = proc - npairs;
UsedMem = (double)smax*(double)sizeof(double)*2.0;
// Allocate and initialize arrays
srand( SEED );
A = doubleVector( smax );
B = doubleVector( smax );
// Open output file and write header
if( proc == 0 ){
// Check timer overhead in seconds
timerTest( &overhead, &threshold_lo, &threshold_hi );
// Open output files and write headers
sprintf( file1, "getfence_time-np_%.4d.dat", nprocs );
sprintf( file2, "getfence_bw-np_%.4d.dat", nprocs );
fp = fopen( file1, "a" );
fp2 = fopen( file2, "a" );
printHeaders( fp, fp2, testName, UsedMem, overhead, threshold_lo );
}
// Get type size
MPI_Type_size( MPI_DOUBLE, &dblSize );
// Set up a window for RMA
MPI_Win_create( A, smax*dblSize, dblSize, MPI_INFO_NULL, MPI_COMM_WORLD, &win );
//================================================================
// Single loop with minimum size to verify that inner loop length
// is long enough for the timings to be accurate
//================================================================
// Warmup with a medium size message
if( proc < npairs ){
MPI_Win_fence( 0, win );
MPI_Get( B, smed, MPI_DOUBLE, partner, 0, smed, MPI_DOUBLE, win );
MPI_Win_fence( 0, win );
}else{
MPI_Win_fence( 0, win );
MPI_Win_fence( 0, win );
}
// Test if current NLOOP is enough to capture fastest test cases
MPI_Barrier( MPI_COMM_WORLD );
tStart = benchTimer();
if( proc < npairs ){
for(j = 0; j < NLOOP; j++){
MPI_Win_fence( 0, win );
MPI_Get( B, smin, MPI_DOUBLE, partner, 0, smin, MPI_DOUBLE, win );
MPI_Win_fence( 0, win );
}
}else{
for(j = 0; j < NLOOP; j++){
MPI_Win_fence( 0, win );
MPI_Win_fence( 0, win );
}
}
timeMin = benchTimer() - tStart;
MPI_Reduce( &timeMin, &timeMinGlobal, 1, MPI_DOUBLE, MPI_MIN, 0, MPI_COMM_WORLD );
if( proc == 0 ) resetInnerLoop( timeMinGlobal, threshold_lo, &NLOOP );
MPI_Bcast( &NLOOP, 1, MPI_INT, 0, MPI_COMM_WORLD );
//================================================================
// Execute test for each requested size
//================================================================
for( size = smin; size <= smax; size = size*2 ){
// Warmup with a medium size message
if( proc < npairs ){
MPI_Win_fence( 0, win );
MPI_Get( B, smed, MPI_DOUBLE, partner, 0, smed, MPI_DOUBLE, win );
MPI_Win_fence( 0, win );
}else{
MPI_Win_fence( 0, win );
MPI_Win_fence( 0, win );
}
// Repeat NREPS to collect statistics
for(i = 0; i < NREPS; i++){
MPI_Barrier( MPI_COMM_WORLD );
tStart = benchTimer();
if( proc < npairs ){
for(j = 0; j < NLOOP; j++){
MPI_Win_fence( 0, win );
MPI_Get( B, size, MPI_DOUBLE, partner, 0, size, MPI_DOUBLE, win );
MPI_Win_fence( 0, win );
}
}else{
for(j = 0; j < NLOOP; j++){
MPI_Win_fence( 0, win );
MPI_Win_fence( 0, win );
}
}
tElapsed[i] = benchTimer() - tStart;
}
MPI_Reduce( tElapsed, tElapsedGlobal, NREPS, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD );
// Only task 0 needs to do the analysis of the collected data
if( proc == 0 ){
// sizeBytes is size to write to file
// msgBytes is actual data exchanged on the wire
msgBytes = (double)size*(double)npairs*(double)dblSize;
sizeBytes = (double)size*(double)dblSize;
post_process( fp, fp2, threshold_hi, tElapsedGlobal, tScale,
bwScale, size*dblSize, sizeBytes, msgBytes, &NLOOP,
&localMax, &localSize );
}
MPI_Bcast( &NLOOP, 1, MPI_INT, 0, MPI_COMM_WORLD );
}
MPI_Win_free( &win );
MPI_Barrier( MPI_COMM_WORLD );
free( A );
free( B );
//================================================================
// Print completion message, free memory and exit
//================================================================
if( proc == 0 ){
printSummary( fp2, testName, localMax, localSize );
fclose( fp2 );
fclose( fp );
}
MPI_Finalize();
return 0;
}
/**
* This uses link_array. It enumerates and post-processes
* all the linkages represented by this one. We know this contains
* at least one fat link.
*/
Linkage_info analyze_fat_linkage(Sentence sent, Parse_Options opts, int analyze_pass)
{
int i;
Linkage_info li;
DIS_node *d_root;
PP_node *pp;
Postprocessor *postprocessor;
Sublinkage *sublinkage;
Parse_info pi = sent->parse_info;
PP_node accum; /* for domain ancestry check */
D_type_list * dtl0, * dtl1; /* for domain ancestry check */
sublinkage = x_create_sublinkage(pi);
postprocessor = sent->dict->postprocessor;
build_digraph(pi, word_links);
structure_violation = FALSE;
d_root = build_DIS_CON_tree(pi, word_links); /* may set structure_violation to TRUE */
li.N_violations = 0;
li.improper_fat_linkage = structure_violation;
li.inconsistent_domains = FALSE;
li.unused_word_cost = unused_word_cost(sent->parse_info);
li.disjunct_cost = disjunct_cost(pi);
li.null_cost = null_cost(pi);
li.link_cost = link_cost(pi);
li.and_cost = 0;
li.andlist = NULL;
if (structure_violation) {
li.N_violations++;
free_sublinkage(sublinkage);
free_digraph(pi, word_links);
free_DIS_tree(d_root);
return li;
}
if (analyze_pass==PP_SECOND_PASS) {
li.andlist = build_andlist(sent, word_links);
li.and_cost = li.andlist->cost;
}
else li.and_cost = 0;
compute_link_names(sent);
for (i=0; i<pi->N_links; i++) accum.d_type_array[i] = NULL;
for (;;) { /* loop through all the sub linkages */
for (i=0; i<pi->N_links; i++) {
patch_array[i].used = patch_array[i].changed = FALSE;
patch_array[i].newl = pi->link_array[i].l;
patch_array[i].newr = pi->link_array[i].r;
copy_full_link(&sublinkage->link[i], &(pi->link_array[i]));
}
fill_patch_array_DIS(d_root, NULL, word_links);
for (i=0; i<pi->N_links; i++) {
if (patch_array[i].changed || patch_array[i].used) {
sublinkage->link[i]->l = patch_array[i].newl;
sublinkage->link[i]->r = patch_array[i].newr;
}
else if ((dfs_root_word[pi->link_array[i].l] != -1) &&
(dfs_root_word[pi->link_array[i].r] != -1)) {
sublinkage->link[i]->l = -1;
}
}
compute_pp_link_array_connectors(sent, sublinkage);
compute_pp_link_names(sent, sublinkage);
/* 'analyze_pass' logic added ALB 1/97 */
if (analyze_pass==PP_FIRST_PASS) {
post_process_scan_linkage(postprocessor,opts,sent,sublinkage);
if (!advance_DIS(d_root)) break;
else continue;
}
pp = post_process(postprocessor, opts, sent, sublinkage, TRUE);
if (pp==NULL) {
if (postprocessor != NULL) li.N_violations = 1;
}
else if (pp->violation == NULL) {
/* the purpose of this stuff is to make sure the domain
ancestry for a link in each of its sentences is consistent. */
for (i=0; i<pi->N_links; i++) {
if (sublinkage->link[i]->l == -1) continue;
if (accum.d_type_array[i] == NULL) {
accum.d_type_array[i] = copy_d_type(pp->d_type_array[i]);
} else {
dtl0 = pp->d_type_array[i];
dtl1 = accum.d_type_array[i];
while((dtl0 != NULL) && (dtl1 != NULL) && (dtl0->type == dtl1->type)) {
dtl0 = dtl0->next;
dtl1 = dtl1->next;
}
if ((dtl0 != NULL) || (dtl1 != NULL)) break;
}
}
if (i != pi->N_links) {
li.N_violations++;
li.inconsistent_domains = TRUE;
}
}
else if (pp->violation!=NULL) {
li.N_violations++;
}
if (!advance_DIS(d_root)) break;
}
for (i=0; i<pi->N_links; ++i) {
free_d_type(accum.d_type_array[i]);
}
/* if (display_on && (li.N_violations != 0) &&
(verbosity > 3) && should_print_messages)
printf("P.P. violation in one part of conjunction.\n"); */
free_sublinkage(sublinkage);
free_digraph(pi, word_links);
free_DIS_tree(d_root);
return li;
}
/*************************************************************************
* Entry point for ama
*************************************************************************/
int main(int argc, char **argv) {
AMA_OPTIONS_T options;
ARRAYLST_T *motifs;
clock_t c0, c1; // measuring cpu_time
MOTIF_AND_PSSM_T *combo;
CISML_T *cisml;
PATTERN_T** patterns;
PATTERN_T *pattern;
FILE *fasta_file, *text_output, *cisml_output;
int i, seq_loading_num, seq_counter, unique_seqs, seq_len, scan_len, x1, x2, y1, y2;
char *seq_name, *path;
bool need_postprocessing, created;
SEQ_T *sequence;
RBTREE_T *seq_ids;
RBNODE_T *seq_node;
double *logcumback;
ALPH_T *alph;
// process the command
process_command_line(argc, argv, &options);
// load DNA motifs
motifs = load_motifs(&options);
// get the alphabet
if (arraylst_size(motifs) > 0) {
combo = (MOTIF_AND_PSSM_T*)arraylst_get(0, motifs);
alph = alph_hold(get_motif_alph(combo->motif));
} else {
alph = alph_dna();
}
// pick columns for GC operations
x1 = -1; x2 = -1; y1 = -1; y2 = -1;
if (alph_size_core(alph) == 4 && alph_size_pairs(alph) == 2) {
x1 = 0; // A
x2 = alph_complement(alph, x1); // T
y1 = (x2 == 1 ? 2 : 1); // C
y2 = alph_complement(alph, y1); // G
assert(x1 != x2 && y1 != y2 && x1 != y1 && x2 != y2 && x1 != y2 && x2 != y1);
}
// record starting time
c0 = clock();
// Create cisml data structure for recording results
cisml = allocate_cisml(PROGRAM_NAME, options.command_line, options.motif_filename, options.fasta_filename);
set_cisml_background_file(cisml, options.bg_filename);
// make a CISML pattern to hold scores for each motif
for (i = 0; i < arraylst_size(motifs); i++) {
combo = (MOTIF_AND_PSSM_T*)arraylst_get(i, motifs);
add_cisml_pattern(cisml, allocate_pattern(get_motif_id(combo->motif), ""));
}
// Open the FASTA file for reading.
fasta_file = NULL;
if (!open_file(options.fasta_filename, "r", false, "FASTA", "sequences", &fasta_file)) {
die("Couldn't open the file %s.\n", options.fasta_filename);
}
if (verbosity >= NORMAL_VERBOSE) {
if (options.last == 0) {
fprintf(stderr, "Using entire sequence\n");
} else {
fprintf(stderr, "Limiting sequence to last %d positions.\n", options.last);
}
}
//
// Read in all sequences and score with all motifs
//
seq_loading_num = 0; // keeps track on the number of sequences read in total
seq_counter = 0; // holds the index to the seq in the pattern
unique_seqs = 0; // keeps track on the number of unique sequences
need_postprocessing = false;
sequence = NULL;
logcumback = NULL;
seq_ids = rbtree_create(rbtree_strcasecmp,rbtree_strcpy,free,rbtree_intcpy,free);
while (read_one_fasta(alph, fasta_file, options.max_seq_length, &sequence)) {
++seq_loading_num;
seq_name = get_seq_name(sequence);
seq_len = get_seq_length(sequence);
scan_len = (options.last != 0 ? options.last : seq_len);
// red-black trees are only required if duplicates should be combined
if (options.combine_duplicates){
//lookup seq id and create new entry if required, return sequence index
seq_node = rbtree_lookup(seq_ids, get_seq_name(sequence), true, &created);
if (created) { // assign it a loading number
rbtree_set(seq_ids, seq_node, &unique_seqs);
seq_counter = unique_seqs;
++unique_seqs;
} else {
seq_counter = *((int*)rbnode_get(seq_node));
}
}
//
// Set up sequence-dependent background model and compute
// log cumulative probability of sequence.
// This needs the sequence in raw format.
//
if (options.sdbg_order >= 0)
logcumback = log_cumulative_background(alph, options.sdbg_order, sequence);
// Index the sequence, throwing away the raw format and ambiguous characters
index_sequence(sequence, alph, SEQ_NOAMBIG);
// Get the GC content of the sequence if binning p-values by GC
// and store it in the sequence object.
if (options.num_gc_bins > 1) {
ARRAY_T *freqs = get_sequence_freqs(sequence, alph);
set_total_gc_sequence(sequence, get_array_item(y1, freqs) + get_array_item(y2, freqs)); // f(C) + f(G)
free_array(freqs); // clean up
} else {
set_total_gc_sequence(sequence, -1); // flag ignore
}
// Scan with motifs.
for (i = 0; i < arraylst_size(motifs); i++) {
pattern = get_cisml_patterns(cisml)[i];
combo = (MOTIF_AND_PSSM_T*)arraylst_get(i, motifs);
if (verbosity >= HIGHER_VERBOSE) {
fprintf(stderr, "Scanning %s sequence with length %d "
"abbreviated to %d with motif %s with length %d.\n",
seq_name, seq_len, scan_len,
get_motif_id(combo->motif), get_motif_length(combo->motif));
}
SCANNED_SEQUENCE_T* scanned_seq = NULL;
if (!options.combine_duplicates || get_pattern_num_scanned_sequences(pattern) <= seq_counter) {
// Create a scanned_sequence record and save it in the pattern.
scanned_seq = allocate_scanned_sequence(seq_name, seq_name, pattern);
set_scanned_sequence_length(scanned_seq, scan_len);
} else {
// get existing sequence record
scanned_seq = get_pattern_scanned_sequences(pattern)[seq_counter];
set_scanned_sequence_length(scanned_seq, max(scan_len, get_scanned_sequence_length(scanned_seq)));
}
// check if scanned component of sequence has sufficient length for the motif
if (scan_len < get_motif_length(combo->motif)) {
// set score to zero and p-value to 1 if not set yet
if(!has_scanned_sequence_score(scanned_seq)){
set_scanned_sequence_score(scanned_seq, 0.0);
}
if(options.pvalues && !has_scanned_sequence_pvalue(scanned_seq)){
set_scanned_sequence_pvalue(scanned_seq, 1.0);
}
add_scanned_sequence_scanned_position(scanned_seq);
if (get_scanned_sequence_num_scanned_positions(scanned_seq) > 0L) {
need_postprocessing = true;
}
if (verbosity >= HIGH_VERBOSE) {
fprintf(stderr, "%s too short for motif %s. Score set to 0.\n",
seq_name, get_motif_id(combo->motif));
}
} else {
// scan the sequence using average/maximum motif affinity
ama_sequence_scan(alph, sequence, logcumback, combo->pssm_pair,
options.scoring, options.pvalues, options.last, scanned_seq,
&need_postprocessing);
}
} // All motifs scanned
free_seq(sequence);
if (options.sdbg_order >= 0) myfree(logcumback);
} // read sequences
fclose(fasta_file);
if (verbosity >= HIGH_VERBOSE) fprintf(stderr, "(%d) sequences read in.\n", seq_loading_num);
if (verbosity >= NORMAL_VERBOSE) fprintf(stderr, "Finished \n");
// if any sequence identifier was multiple times in the sequence set then
// postprocess of the data is required
if (need_postprocessing || options.normalize_scores) {
post_process(cisml, motifs, options.normalize_scores);
}
// output results
if (options.output_format == DIRECTORY_FORMAT) {
if (create_output_directory(options.out_dir, options.clobber, verbosity > QUIET_VERBOSE)) {
// only warn in higher verbose modes
fprintf(stderr, "failed to create output directory `%s' or already exists\n", options.out_dir);
exit(1);
}
path = make_path_to_file(options.out_dir, text_filename);
//FIXME check for errors: MEME doesn't either and we at least know we have a good directory
text_output = fopen(path, "w");
free(path);
path = make_path_to_file(options.out_dir, cisml_filename);
//FIXME check for errors
cisml_output = fopen(path, "w");
free(path);
print_cisml(cisml_output, cisml, true, NULL, false);
print_score(cisml, text_output);
fclose(cisml_output);
fclose(text_output);
} else if (options.output_format == GFF_FORMAT) {
print_score(cisml, stdout);
} else if (options.output_format == CISML_FORMAT) {
print_cisml(stdout, cisml, true, NULL, false);
} else {
die("Output format invalid!\n");
}
//
// Clean up.
//
rbtree_destroy(seq_ids);
arraylst_destroy(motif_and_pssm_destroy, motifs);
free_cisml(cisml);
rbtree_destroy(options.selected_motifs);
alph_release(alph);
// measure time
if (verbosity >= NORMAL_VERBOSE) { // starting time
c1 = clock();
fprintf(stderr, "cycles (CPU); %ld cycles\n", (long) c1);
fprintf(stderr, "elapsed CPU time: %f seconds\n", (float) (c1-c0) / CLOCKS_PER_SEC);
}
return 0;
}
static int
parse_document(
fs::path const& filein_
, fs::path const& fileout_
, fs::path const& xinclude_base_
, int indent
, int linewidth
, bool pretty_print)
{
string_stream buffer;
id_manager ids;
int result = 0;
try {
actions actor(filein_, xinclude_base_, buffer, ids);
set_macros(actor);
if (actor.error_count == 0) {
actor.current_file = load(filein_); // Throws load_error
parse_file(actor);
if(actor.error_count) {
detail::outerr()
<< "Error count: " << actor.error_count << ".\n";
}
}
result = actor.error_count ? 1 : 0;
}
catch (load_error& e) {
detail::outerr(filein_) << detail::utf8(e.what()) << std::endl;
result = 1;
}
if (result == 0)
{
std::string stage2 = ids.replace_placeholders(buffer.str());
fs::ofstream fileout(fileout_);
if (fileout.fail()) {
::quickbook::detail::outerr()
<< "Error opening output file "
<< fileout_
<< std::endl;
return 1;
}
if (pretty_print)
{
try
{
fileout << post_process(stage2, indent, linewidth);
}
catch (quickbook::post_process_failure&)
{
// fallback!
::quickbook::detail::outerr()
<< "Post Processing Failed."
<< std::endl;
fileout << stage2;
return 1;
}
}
else
{
fileout << stage2;
}
if (fileout.fail()) {
::quickbook::detail::outerr()
<< "Error writing to output file "
<< fileout_
<< std::endl;
return 1;
}
}
return result;
}
decision_proceduret::resultt smt1_dect::dec_solve()
{
// SMT1 is really not incremental
assert(!dec_solve_was_called);
dec_solve_was_called=true;
post_process();
// this closes the SMT benchmark
smt1_prop.finalize();
temp_out.close();
temp_result_filename=
get_temporary_file("smt1_dec_result_", "");
std::string command;
switch(solver)
{
case CVC3:
command = "cvc3 +model -lang smtlib -output-lang smtlib "
+ temp_out_filename
+ " > "
+ temp_result_filename;
break;
case BOOLECTOR:
// –rwl0 disables rewriting, which makes things slower,
// but in return values for arrays appear
command = "boolector -rwl0 --smt "
+ temp_out_filename
+ " -fm --output "
+ temp_result_filename;
break;
case OPENSMT:
command = "todo "
+ temp_out_filename
+ " > "
+ temp_result_filename;
break;
case YICES:
command = "yices -smt -e "
+ temp_out_filename
+ " > "
+ temp_result_filename;
break;
case MATHSAT:
command = "mathsat -model -input=smt"
" < "+temp_out_filename
+ " > "+temp_result_filename;
break;
case Z3:
command = "z3 -m "
+ temp_out_filename
+ " > "
+ temp_result_filename;
break;
default:
assert(false);
}
#if defined(__LINUX__) || defined(__APPLE__)
command+=" 2>&1";
#endif
system(command.c_str());
std::ifstream in(temp_result_filename.c_str());
switch(solver)
{
case BOOLECTOR:
return read_result_boolector(in);
case CVC3:
return read_result_cvc3(in);
case OPENSMT:
return read_result_opensmt(in);
case YICES:
return read_result_yices(in);
case MATHSAT:
return read_result_mathsat(in);
case Z3:
return read_result_z3(in);
default:
assert(false);
}
}
int main(int argc, char **argv)
{
FILE *fp, *fp2;
char testName[32] = "PHI_TRANSFER_KEEP_NOAL_IN";
int micNum, tid;
unsigned int i, j, size, localSize, NLOOP = NLOOP_PHI_MAX, NLOOP_PHI;
unsigned int smin = MIN_PHI_SIZE, smed = MED_PHI_SIZE, smax = MAX_PHI_SIZE;
double *f0, *f0_noal, *f1, *f1_noal;
double timeMin, tStart, tElapsed[NREPS];
double tScale = USEC, bwScale = MB;
double overhead, threshold_lo, threshold_hi;
double tMin, tMax, tAvg, stdDev, bwMax, bwMin, bwAvg, bwDev;
double UsedMem, localMax, msgBytes;
double tMsg[NREPS], bwMsg[NREPS];
// Identify number of MIC devices
micNum = _Offload_number_of_devices();
if( micNum == 0 ) fatalError( "No Xeon Phi devices found. Test Aborted." );
// Check for user defined limits
checkEnvPHI( &NLOOP, &smin, &smed, &smax );
if( micNum == 1 ) UsedMem = (double)smax*sizeof(double);
if( micNum == 2 ) UsedMem = (double)smax*2.0*sizeof(double);
// Allocate and initialize test array
srand( SEED );
f0 = doubleVector( smax+1 );
// This array is unaligned by exactly 8 bytes
f0_noal = &f0[1];
// Check timer overhead in seconds
timerTest( &overhead, &threshold_lo, &threshold_hi );
// Open output files and write headers
fp = fopen( "mic0_keep_noal_time_in.dat", "a" );
fp2 = fopen( "mic0_keep_noal_bw_in.dat", "a" );
printHeaders( fp, fp2, testName, UsedMem, overhead, threshold_lo );
//================================================================
// Single loop with minimum size to verify that inner loop length
// is long enough for the timings to be accurate
//================================================================
// Warmup processor with a large size exchange
// Since we will be reusing we want to make sure this exchange uses smax
#pragma offload_transfer target(mic:0) in( f0_noal : length(smax) ALLOC KEEP )
// Test is current NLOOP is enough to capture fastest test cases
tStart = benchTimer();
for(j = 0; j < NLOOP; j++){
#pragma offload_transfer target(mic:0) in( f0_noal : length(smin) REUSE KEEP )
}
timeMin = benchTimer() - tStart;
resetInnerLoop( timeMin, threshold_lo, &NLOOP );
// Let's save this info in case we have more than one Phi device
NLOOP_PHI = NLOOP;
//================================================================
// Execute test for each requested size
//================================================================
localSize = smin;
localMax = 0.0;
for( size = smin; size <= smax; size = size*2 ){
// Copy array to Phi (read/write test)
for( i = 0; i < NREPS; i++){
tStart = benchTimer();
for(j = 0; j < NLOOP; j++){
#pragma offload_transfer target(mic:0) in( f0_noal : length(size) REUSE KEEP )
}
tElapsed[i] = benchTimer() - tStart;
}
msgBytes = (double)( size*sizeof(double));
post_process( fp, fp2, threshold_hi, tElapsed, tScale, bwScale, size,
msgBytes, msgBytes, &NLOOP, &localMax, &localSize );
}
// Print completion message
printSummary( fp2, testName, localMax, localSize );
fclose( fp2 );
fclose( fp );
if( micNum == 2 ){
// Allocate and initialize test array for second Phi coprocessor (mic:1)
f1 = doubleVector(smax+1);
f1_noal = &f1[1];
// Open output files and write headers
fp = fopen( "mic1_keep_noal_time_in.dat", "a" );
fp2 = fopen( "mic1_keep_noal_bw_in.dat", "a" );
printHeaders( fp, fp2, testName, UsedMem, overhead, threshold_lo );
//================================================================
// Single loop with minimum size to verify that inner loop length
// is long enough for the timings to be accurate
//================================================================
// Warmup processor with a large size exchange
// Since we will be reusing we want to make sure this exchanges uses smax
#pragma offload_transfer target(mic:1) in( f1_noal : length(smax) ALLOC KEEP )
// Reset innermost loop to safe value and local quantities to defaults
NLOOP = NLOOP_PHI;
localSize = smin;
localMax = 0.0;
//================================================================
// Execute test for each requested size
//================================================================
for( size = smin; size <= smax; size = size*2 ){
// Copy array to Phi (read/write test)
for( i = 0; i < NREPS; i++){
tStart = benchTimer();
for(j = 0; j < NLOOP; j++){
#pragma offload_transfer target(mic:1) in( f1_noal : length(size) REUSE KEEP )
}
tElapsed[i] = benchTimer() - tStart;
}
msgBytes = (double)( size*sizeof(double));
post_process( fp, fp2, threshold_hi, tElapsed, tScale, bwScale, size,
msgBytes, msgBytes, &NLOOP, &localMax, &localSize );
}
// Print completion message
printSummary( fp2, testName, localMax, localSize );
fclose( fp2 );
fclose( fp );
//------- TESTING SIMULTANEOUS DATA TRANSFER TO BOTH PHI DEVICES ------
// Open output files and write headers
fp = fopen( "mic0+1_keep_noal_time_in.dat", "a" );
fp2 = fopen( "mic0+1_keep_noal_bw_in.dat", "a" );
printHeaders( fp, fp2, testName, UsedMem, overhead, threshold_lo );
// Warmup processor with a medium size exchange
#pragma offload_transfer target(mic:0) in( f0_noal : length(smed) REUSE KEEP )
#pragma offload_transfer target(mic:1) in( f1_noal : length(smed) REUSE KEEP )
// Reset innermost loop to safe value and local quantities to defaults
NLOOP = NLOOP_PHI;
localSize = smin;
localMax = 0.0;
//================================================================
// Execute test for each requested size
//================================================================
for( size = smin; size <= smax; size = size*2 ){
for( i = 0; i < NREPS; i++){
tStart = benchTimer();
#pragma omp parallel private(j,tid) num_threads(2)
{
tid = omp_get_thread_num();
if( tid == 0 ){
for(j = 0; j < NLOOP; j++){
#pragma offload_transfer target(mic:0) in( f0_noal : length(size) REUSE KEEP )
}
}
if( tid == 1 ){
for(j = 0; j < NLOOP; j++){
#pragma offload_transfer target(mic:1) in( f1_noal : length(size) REUSE KEEP )
}
}
}
tElapsed[i] = 0.5*( benchTimer() - tStart );
}
msgBytes = (double)( size*sizeof(double));
post_process( fp, fp2, threshold_hi, tElapsed, tScale, bwScale, size,
msgBytes, msgBytes, &NLOOP, &localMax, &localSize );
}
// Print completion message
printSummary( fp2, testName, localMax, localSize );
fclose( fp2 );
fclose( fp );
}
free( f0 );
if( micNum == 2 ) free( f1 );
return 0;
}
int main(int argc, char* argv[])
{
// Check arguments
if (argc < 3) {
std::cerr << "Usage: shallow_water NODES_FILE TRIS_FILE\n";
exit(1);
}
MeshType mesh;
// HW4B: Need node_type before this can be used!
#if 1
std::vector<typename MeshType::node_type> mesh_node;
#endif
// Read all Points and add them to the Mesh
std::ifstream nodes_file(argv[1]);
Point p;
while (CS207::getline_parsed(nodes_file, p)) {
// HW4B: Need to implement add_node before this can be used!
#if 1
mesh_node.push_back(mesh.add_node(p));
#endif
}
// Read all mesh triangles and add them to the Mesh
std::ifstream tris_file(argv[2]);
std::array<int,3> t;
while (CS207::getline_parsed(tris_file, t)) {
// HW4B: Need to implement add_triangle before this can be used!
#if 1
mesh.add_triangle(mesh_node[t[0]], mesh_node[t[1]], mesh_node[t[2]]);
#endif
}
// Print out the stats
std::cout << mesh.num_nodes() << " "
<< mesh.num_edges() << " "
<< mesh.num_triangles() << std::endl;
// HW4B Initialization
// Set the initial conditions based off third argument
// Perform any needed precomputation
std::pair<double, double> value_pair;
if ((*argv[3]) == '0') {
std::cout << "Pebble Ripple" << std::endl;
value_pair = PebbleRipple()(mesh);
} else if ((*argv[3]) == '1') {
std::cout << "Sharp Wave" << std::endl;
value_pair = SharpWave()(mesh);
} else {
std::cout << "Dam Break" << std::endl;
value_pair = DamBreak()(mesh);
}
double max_height = value_pair.first;
double min_edge_length = value_pair.second;
// Launch the SDLViewer
CS207::SDLViewer viewer;
viewer.launch();
// HW4B: Need to define Mesh::node_type and node/edge iterator
// before these can be used!
#if 1
auto node_map = viewer.empty_node_map(mesh);
viewer.add_nodes(mesh.node_begin(), mesh.node_end(),
CS207::DefaultColor(), NodePosition(), node_map);
viewer.add_edges(mesh.edge_begin(), mesh.edge_end(), node_map);
#endif
viewer.center_view();
// CFL stability condition requires dt <= dx / max|velocity|
// For the shallow water equations with u = v = 0 initial conditions
// we can compute the minimum edge length and maximum original water height
// to set the time-step
// Compute the minimum edge length and maximum water height for computing dt
#if 1
double dt = 0.25 * min_edge_length / (sqrt(grav * max_height));
#else
// Placeholder!! Delete me when min_edge_length and max_height can be computed!
double dt = 0.1;
#endif
double t_start = 0;
double t_end = 5;
// Preconstruct a Flux functor
EdgeFluxCalculator f;
// Begin the time stepping
for (double t = t_start; t < t_end; t += dt) {
// Step forward in time with forward Euler
hyperbolic_step(mesh, f, t, dt);
// Update node values with triangle-averaged values
post_process(mesh);
// Update the viewer with new node positions
#if 1
// Update viewer with nodes' new positions
viewer.add_nodes(mesh.node_begin(), mesh.node_end(),
CoolColor(), NodePosition(), node_map);
#endif
viewer.set_label(t);
// These lines slow down the animation for small meshes.
// Feel free to remove them or tweak the constants.
if (mesh.num_nodes() < 100)
CS207::sleep(0.05);
}
return 0;
}
void linkage_post_process(Linkage linkage, Postprocessor * postprocessor) {
int N_sublinkages = linkage_get_num_sublinkages(linkage);
Parse_Options opts = linkage->opts;
Sentence sent = linkage->sent;
Sublinkage * subl;
PP_node * pp;
int i, j, k;
D_type_list * d;
for (i=0; i<N_sublinkages; ++i) {
subl = &linkage->sublinkage[i];
if (subl->pp_info != NULL) {
for (j=0; j<subl->num_links; ++j) {
exfree_pp_info(subl->pp_info[j]);
}
post_process_free_data(&subl->pp_data);
exfree(subl->pp_info, sizeof(PP_info)*subl->num_links);
}
subl->pp_info = (PP_info *) exalloc(sizeof(PP_info)*subl->num_links);
for (j=0; j<subl->num_links; ++j) {
subl->pp_info[j].num_domains = 0;
subl->pp_info[j].domain_name = NULL;
}
if (subl->violation != NULL) {
exfree(subl->violation, sizeof(char)*(strlen(subl->violation)+1));
subl->violation = NULL;
}
if (linkage->info.improper_fat_linkage) {
pp = NULL;
} else {
pp = post_process(postprocessor, opts, sent, subl, FALSE);
/* This can return NULL, for example if there is no
post-processor */
}
if (pp == NULL) {
for (j=0; j<subl->num_links; ++j) {
subl->pp_info[j].num_domains = 0;
subl->pp_info[j].domain_name = NULL;
}
}
else {
for (j=0; j<subl->num_links; ++j) {
k=0;
for (d = pp->d_type_array[j]; d!=NULL; d=d->next) k++;
subl->pp_info[j].num_domains = k;
if (k > 0) {
subl->pp_info[j].domain_name = (char **) exalloc(sizeof(char *)*k);
}
k = 0;
for (d = pp->d_type_array[j]; d!=NULL; d=d->next) {
subl->pp_info[j].domain_name[k] = (char *) exalloc(sizeof(char)*2);
sprintf(subl->pp_info[j].domain_name[k], "%c", d->type);
k++;
}
}
subl->pp_data = postprocessor->pp_data;
if (pp->violation != NULL) {
subl->violation =
(char *) exalloc(sizeof(char)*(strlen(pp->violation)+1));
strcpy(subl->violation, pp->violation);
}
}
}
post_process_close_sentence(postprocessor);
}
