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;
}
