void mesh_report_reply(struct mesh_area* mesh, struct outbound_entry* e, struct comm_reply* reply, int what) { enum module_ev event = module_event_reply; e->qstate->reply = reply; if(what != NETEVENT_NOERROR) { event = module_event_noreply; if(what == NETEVENT_CAPSFAIL) event = module_event_capsfail; } mesh_run(mesh, e->qstate->mesh_info, event, e); }
void mesh_new_prefetch(struct mesh_area* mesh, struct query_info* qinfo, uint16_t qflags, uint32_t leeway) { struct mesh_state* s = mesh_area_find(mesh, qinfo, qflags&BIT_RD, 0); #ifdef UNBOUND_DEBUG struct rbnode_t* n; #endif /* already exists, and for a different purpose perhaps. * if mesh_no_list, keep it that way. */ if(s) { /* make it ignore the cache from now on */ if(!s->s.blacklist) sock_list_insert(&s->s.blacklist, NULL, 0, s->s.region); if(s->s.prefetch_leeway < leeway) s->s.prefetch_leeway = leeway; return; } if(!mesh_make_new_space(mesh, NULL)) { verbose(VERB_ALGO, "Too many queries. dropped prefetch."); mesh->stats_dropped ++; return; } s = mesh_state_create(mesh->env, qinfo, qflags&BIT_RD, 0); if(!s) { log_err("prefetch mesh_state_create: out of memory"); return; } #ifdef UNBOUND_DEBUG n = #endif rbtree_insert(&mesh->all, &s->node); log_assert(n != NULL); /* set detached (it is now) */ mesh->num_detached_states++; /* make it ignore the cache */ sock_list_insert(&s->s.blacklist, NULL, 0, s->s.region); s->s.prefetch_leeway = leeway; if(s->list_select == mesh_no_list) { /* move to either the forever or the jostle_list */ if(mesh->num_forever_states < mesh->max_forever_states) { mesh->num_forever_states ++; mesh_list_insert(s, &mesh->forever_first, &mesh->forever_last); s->list_select = mesh_forever_list; } else { mesh_list_insert(s, &mesh->jostle_first, &mesh->jostle_last); s->list_select = mesh_jostle_list; } } mesh_run(mesh, s, module_event_new, NULL); }
int mesh_new_callback(struct mesh_area* mesh, struct query_info* qinfo, uint16_t qflags, struct edns_data* edns, ldns_buffer* buf, uint16_t qid, mesh_cb_func_t cb, void* cb_arg) { struct mesh_state* s = mesh_area_find(mesh, qinfo, qflags&BIT_RD, 0); int was_detached = 0; int was_noreply = 0; int added = 0; /* there are no limits on the number of callbacks */ /* see if it already exists, if not, create one */ if(!s) { #ifdef UNBOUND_DEBUG struct rbnode_t* n; #endif s = mesh_state_create(mesh->env, qinfo, qflags&BIT_RD, 0); if(!s) { return 0; } #ifdef UNBOUND_DEBUG n = #endif rbtree_insert(&mesh->all, &s->node); log_assert(n != NULL); /* set detached (it is now) */ mesh->num_detached_states++; added = 1; } if(!s->reply_list && !s->cb_list && s->super_set.count == 0) was_detached = 1; if(!s->reply_list && !s->cb_list) was_noreply = 1; /* add reply to s */ if(!mesh_state_add_cb(s, edns, buf, cb, cb_arg, qid, qflags)) { if(added) mesh_state_delete(&s->s); return 0; } /* update statistics */ if(was_detached) { log_assert(mesh->num_detached_states > 0); mesh->num_detached_states--; } if(was_noreply) { mesh->num_reply_states ++; } mesh->num_reply_addrs++; if(added) mesh_run(mesh, s, module_event_new, NULL); return 1; }
void mesh_new_client(struct mesh_area* mesh, struct query_info* qinfo, uint16_t qflags, struct edns_data* edns, struct comm_reply* rep, uint16_t qid) { /* do not use CD flag from user for mesh state, we want the CD-query * to receive validation anyway, to protect out cache contents and * avoid bad-data in this cache that a downstream validator cannot * remove from this cache */ struct mesh_state* s = mesh_area_find(mesh, qinfo, qflags&BIT_RD, 0); int was_detached = 0; int was_noreply = 0; int added = 0; /* does this create a new reply state? */ if(!s || s->list_select == mesh_no_list) { if(!mesh_make_new_space(mesh, rep->c->buffer)) { verbose(VERB_ALGO, "Too many queries. dropping " "incoming query."); comm_point_drop_reply(rep); mesh->stats_dropped ++; return; } /* for this new reply state, the reply address is free, * so the limit of reply addresses does not stop reply states*/ } else { /* protect our memory usage from storing reply addresses */ if(mesh->num_reply_addrs > mesh->max_reply_states*16) { verbose(VERB_ALGO, "Too many requests queued. " "dropping incoming query."); mesh->stats_dropped++; comm_point_drop_reply(rep); return; } } /* see if it already exists, if not, create one */ if(!s) { #ifdef UNBOUND_DEBUG struct rbnode_t* n; #endif s = mesh_state_create(mesh->env, qinfo, qflags&BIT_RD, 0); if(!s) { log_err("mesh_state_create: out of memory; SERVFAIL"); error_encode(rep->c->buffer, LDNS_RCODE_SERVFAIL, qinfo, qid, qflags, edns); comm_point_send_reply(rep); return; } #ifdef UNBOUND_DEBUG n = #endif rbtree_insert(&mesh->all, &s->node); log_assert(n != NULL); /* set detached (it is now) */ mesh->num_detached_states++; added = 1; } if(!s->reply_list && !s->cb_list && s->super_set.count == 0) was_detached = 1; if(!s->reply_list && !s->cb_list) was_noreply = 1; /* add reply to s */ if(!mesh_state_add_reply(s, edns, rep, qid, qflags, qinfo->qname)) { log_err("mesh_new_client: out of memory; SERVFAIL"); error_encode(rep->c->buffer, LDNS_RCODE_SERVFAIL, qinfo, qid, qflags, edns); comm_point_send_reply(rep); if(added) mesh_state_delete(&s->s); return; } /* update statistics */ if(was_detached) { log_assert(mesh->num_detached_states > 0); mesh->num_detached_states--; } if(was_noreply) { mesh->num_reply_states ++; } mesh->num_reply_addrs++; if(s->list_select == mesh_no_list) { /* move to either the forever or the jostle_list */ if(mesh->num_forever_states < mesh->max_forever_states) { mesh->num_forever_states ++; mesh_list_insert(s, &mesh->forever_first, &mesh->forever_last); s->list_select = mesh_forever_list; } else { mesh_list_insert(s, &mesh->jostle_first, &mesh->jostle_last); s->list_select = mesh_jostle_list; } } if(added) mesh_run(mesh, s, module_event_new, NULL); }
int main (int argc, char **argv) { int mpiret; int wrongusage; const char *usage; mpi_context_t mpi_context, *mpi = &mpi_context; p4est_connectivity_t *connectivity; simple_config_t config; /* initialize MPI and p4est internals */ mpiret = sc_MPI_Init (&argc, &argv); SC_CHECK_MPI (mpiret); mpi->mpicomm = sc_MPI_COMM_WORLD; mpiret = sc_MPI_Comm_size (mpi->mpicomm, &mpi->mpisize); SC_CHECK_MPI (mpiret); mpiret = sc_MPI_Comm_rank (mpi->mpicomm, &mpi->mpirank); SC_CHECK_MPI (mpiret); sc_init (mpi->mpicomm, 1, 1, NULL, SC_LP_DEFAULT); p4est_init (NULL, SC_LP_DEFAULT); /* process command line arguments */ usage = "Arguments: <configuration> <level>\n Configuration can be any of\n" #ifndef P4_TO_P8 " unit|three|moebius|star|periodic|rotwrap|cubed|disk\n" #else " unit|periodic|rotwrap|twocubes|twowrap|rotcubes|shell|sphere\n" #endif " Level controls the maximum depth of refinement\n"; wrongusage = 0; config = P4EST_CONFIG_NULL; if (!wrongusage && argc != 3) { wrongusage = 1; } if (!wrongusage) { if (!strcmp (argv[1], "unit")) { #ifndef P4_TO_P8 config = P4EST_CONFIG_UNIT; #else config = P8EST_CONFIG_UNIT; #endif } #ifndef P4_TO_P8 else if (!strcmp (argv[1], "three")) { config = P4EST_CONFIG_THREE; } else if (!strcmp (argv[1], "moebius")) { config = P4EST_CONFIG_MOEBIUS; } else if (!strcmp (argv[1], "star")) { config = P4EST_CONFIG_STAR; } else if (!strcmp (argv[1], "periodic")) { config = P4EST_CONFIG_PERIODIC; } else if (!strcmp (argv[1], "rotwrap")) { config = P4EST_CONFIG_ROTWRAP; } else if (!strcmp (argv[1], "cubed")) { config = P4EST_CONFIG_CUBED; } else if (!strcmp (argv[1], "disk")) { config = P4EST_CONFIG_DISK; } #else else if (!strcmp (argv[1], "periodic")) { config = P8EST_CONFIG_PERIODIC; } else if (!strcmp (argv[1], "rotwrap")) { config = P8EST_CONFIG_ROTWRAP; } else if (!strcmp (argv[1], "twocubes")) { config = P8EST_CONFIG_TWOCUBES; } else if (!strcmp (argv[1], "twowrap")) { config = P8EST_CONFIG_TWOWRAP; } else if (!strcmp (argv[1], "rotcubes")) { config = P8EST_CONFIG_ROTCUBES; } else if (!strcmp (argv[1], "shell")) { config = P8EST_CONFIG_SHELL; } else if (!strcmp (argv[1], "sphere")) { config = P8EST_CONFIG_SPHERE; } #endif else { wrongusage = 1; } } if (wrongusage) { P4EST_GLOBAL_LERROR (usage); sc_abort_collective ("Usage error"); } /* assign variables based on configuration */ refine_level = atoi (argv[2]); /* create connectivity and forest structures */ if (0) { } #ifndef P4_TO_P8 else if (config == P4EST_CONFIG_THREE) { connectivity = p4est_connectivity_new_corner (); } else if (config == P4EST_CONFIG_MOEBIUS) { connectivity = p4est_connectivity_new_moebius (); } else if (config == P4EST_CONFIG_STAR) { connectivity = p4est_connectivity_new_star (); } else if (config == P4EST_CONFIG_PERIODIC) { connectivity = p4est_connectivity_new_periodic (); } else if (config == P4EST_CONFIG_ROTWRAP) { connectivity = p4est_connectivity_new_rotwrap (); } else if (config == P4EST_CONFIG_CUBED) { connectivity = p4est_connectivity_new_cubed (); } else if (config == P4EST_CONFIG_DISK) { connectivity = p4est_connectivity_new_disk (); } #else else if (config == P8EST_CONFIG_PERIODIC) { connectivity = p8est_connectivity_new_periodic (); } else if (config == P8EST_CONFIG_ROTWRAP) { connectivity = p8est_connectivity_new_rotwrap (); } else if (config == P8EST_CONFIG_TWOCUBES) { connectivity = p8est_connectivity_new_twocubes (); } else if (config == P8EST_CONFIG_TWOWRAP) { connectivity = p8est_connectivity_new_twowrap (); } else if (config == P8EST_CONFIG_ROTCUBES) { connectivity = p8est_connectivity_new_rotcubes (); } else if (config == P8EST_CONFIG_SHELL) { connectivity = p8est_connectivity_new_shell (); } else if (config == P8EST_CONFIG_SPHERE) { connectivity = p8est_connectivity_new_sphere (); } #endif else { #ifndef P4_TO_P8 connectivity = p4est_connectivity_new_unitsquare (); #else connectivity = p8est_connectivity_new_unitcube (); #endif } #if 0 /* hack test */ hack_test (mpi, connectivity); #else /* run mesh tests */ mesh_run (mpi, connectivity, 1, 0, 1, P4EST_CONNECT_FULL); mesh_run (mpi, connectivity, 0, 1, 0, P4EST_CONNECT_FULL); mesh_run (mpi, connectivity, 0, 0, 0, P4EST_CONNECT_FACE); mesh_run (mpi, connectivity, 1, 1, 1, P4EST_CONNECT_FACE); #endif /* clean up and exit */ p4est_connectivity_destroy (connectivity); sc_finalize (); mpiret = sc_MPI_Finalize (); SC_CHECK_MPI (mpiret); return 0; }
int main( int argc, char **argv ) { int i; QString m1,n1,o1; struct args pargs; QApplication *a; InitWidget *b; ScreenWidget *c; TextWidget *textOut; QProgressDialog *qProg; QPixmap *qpxMeshIcon=NULL; struct model_error model1,model2; int rcode; struct outbuf *log; struct prog_reporter pr; /* Initialize application */ a = NULL; b = NULL; c = NULL; qProg = NULL; memset(&model1,0,sizeof(model1)); memset(&model2,0,sizeof(model2)); memset(&pr,0,sizeof(pr)); log = NULL; i = 0; while (i<argc) { if (strcmp(argv[i],"-t") == 0) /* text version requested */ break; if (strcmp(argv[i],"-h") == 0) /* just asked for command line help */ break; i++; } if (i == argc) { /* no text version requested, initialize QT */ a = new QApplication( argc, argv ); /* Load pixmap for icon */ qpxMeshIcon = new QPixmap((const char**)meshIcon); if (a != NULL) a->connect( a, SIGNAL(lastWindowClosed()), a, SLOT(quit()) ); } else { a = NULL; /* No QT app needed */ } /* Parse arguments */ parse_args(argc,argv,&pargs); /* Display starting dialog if insufficient arguments */ if (pargs.m1_fname != NULL || pargs.m2_fname != NULL) { if (pargs.m1_fname == NULL || pargs.m2_fname == NULL) { fprintf(stderr,"ERROR: missing file name(s) in command line\n"); exit(1); } if (!pargs.do_wlog) { log = outbuf_new(stdio_puts,stdout); } else { textOut = new TextWidget(); textOut->setIcon(*qpxMeshIcon); log = outbuf_new(TextWidget_puts,textOut); textOut->show(); } if (pargs.no_gui) { pr.prog = stdio_prog; pr.cb_out = stdout; } else { qProg = new QProgressDialog("Calculating distance",0,100); qProg->setIcon(*qpxMeshIcon); qProg->setMinimumDuration(1500); pr.prog = QT_prog; pr.cb_out = qProg; } mesh_run(&pargs, &model1, &model2, log, &pr); } else { b = new InitWidget(pargs, &model1, &model2); b->setIcon(*qpxMeshIcon); b->show(); } if (a != NULL) { if (pargs.m1_fname != NULL || pargs.m2_fname != NULL) { c = new ScreenWidget(&model1, &model2, &pargs); c->setIcon(*qpxMeshIcon); a->setMainWidget(c); c->show(); } rcode = a->exec(); } else { rcode = 0; } /* Free widgets */ outbuf_delete(log); delete qProg; delete qpxMeshIcon; delete b; delete c; delete a; // QApplication must be last QT thing to delete /* Free model data */ if (model1.mesh != NULL) __free_raw_model(model1.mesh); free(model1.verror); free(model1.info); free_face_error(model1.fe); if (model2.mesh != NULL) __free_raw_model(model2.mesh); free(model2.verror); free(model2.info); /* Return exit code */ return rcode; }