isc_result_t
isc_result_register(unsigned int base, unsigned int nresults,
const char **text1, isc_msgcat_t *msgcat, int set)
{
initialize();
return (register_table(base, nresults, text1, msgcat, set));
}
static void
standard_table(atom_t name, void (*func)(OrdTable))
{ OrdTable t = malloc(sizeof(ordtable));
if ( t )
{ exact_table(t);
t->name = name;
if ( func )
(*func)(t);
register_table(t);
} else
PL_warning("Could not allocate table");
}
static void
initialize_action(void) {
isc_result_t result;
RUNTIME_CHECK(isc_mutex_init(&lock) == ISC_R_SUCCESS);
ISC_LIST_INIT(tables);
result = register_table(ISC_RESULTCLASS_ISC, ISC_R_NRESULTS, text,
isc_msgcat, ISC_RESULT_RESULTSET);
if (result != ISC_R_SUCCESS)
UNEXPECTED_ERROR(__FILE__, __LINE__,
"register_table() %s: %u",
isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
ISC_MSG_FAILED, "failed"),
result);
}
static void _init(void)
{
register_table(&table);
}
static foreign_t
pl_new_order_table(term_t name, term_t options)
{ OrdTable t = malloc(sizeof(ordtable));
term_t tail = PL_copy_term_ref(options);
term_t head = PL_new_term_ref();
exact_table(t);
if ( !PL_get_atom(name, &t->name) )
{ free(t);
return error(ERR_INSTANTIATION, "new_order_table/2", 1, name);
}
while(PL_get_list(tail, head, tail))
{ atom_t name;
int arity;
if ( PL_get_name_arity(head, &name, &arity) )
{ if ( name == ATOM_case_insensitive )
{ case_insensitive_table(t);
} else if ( name == ATOM_iso_latin_1 )
{ iso_latin_1_table(t);
} else if ( name == ATOM_iso_latin_1_case_insensitive )
{ iso_latin_1_case_table(t);
} else if ( name == ATOM_copy && arity == 1 )
{ term_t a = PL_new_term_ref();
OrdTable from;
_PL_get_arg(1, head, a);
if ( get_order_table(a, &from) )
{ copy_table(t, from);
} else
{ free(t);
return FALSE;
}
} else if ( arity == 1 )
{ fid_t fid = PL_open_foreign_frame();
term_t a = PL_new_term_ref();
_PL_get_arg(1, head, a);
if ( !parse_set(t, name, a) )
goto err1;
PL_close_foreign_frame(fid);
} else if ( name == ATOM_eq && arity == 2 )
{ fid_t fid = PL_open_foreign_frame();
term_t c = PL_new_term_ref();
int from, to;
if ( !PL_get_arg(1, head, c) || !get_char(c, &from) ||
!PL_get_arg(2, head, c) || !get_char(c, &to) )
{ free(t);
return FALSE;
}
ORD(t, from) = to;
PL_close_foreign_frame(fid);
} else
goto err1;
} else
{ err1:
free(t);
return error(ERR_INSTANTIATION, "new_order_table/2", 2, options);
}
}
if ( !PL_get_nil(tail) )
goto err1;
register_table(t);
PL_succeed;
}
int main(int argc, char **argv){
char addr[32];
if (argc < 4){
fprintf(stdout,"not enough args\n");
fprintf(stdout,"usage: prog <auscoutd address> <port> <port>\n");
fprintf(stdout,"address - mock auscoud server address, e.g. \"localhost\"\n");
fprintf(stdout,"port - mock auscoutd server port e.g. 4005\n");
fprintf(stdout,"port - port to recieve init from auscout driver, e.g. 4009\n");
return 0;
}
/* progname <auscoutd address> <auscoutd port> <driver port>*/
const char *auscoutd_address = argv[1];
const int port = atoi(argv[2]);
const int driver_port = atoi(argv[3]);
int subscr_port = port + 2;
int result_port = port + 3;
int table_port = port + 1;
snprintf(addr, 32, "tcp://%s:%d", auscoutd_address, table_port);
fprintf(stdout,"register as table with %s\n", addr);
void *ctx = zmq_init(1);
assert(ctx);
assert(register_table(ctx, addr) == 0);
/* skt to recieve number of files to be sent from auscout driver program */
snprintf(addr, 32, "tcp://*:%d", driver_port);
void *prepskt = socket_bind(ctx, ZMQ_PAIR, addr);
assert(prepskt);
snprintf(addr, 32, "tcp://%s:%d", auscoutd_address, subscr_port);
void *subscr_skt = socket_connect(ctx, ZMQ_SUB, addr);
assert(subscr_skt);
assert(zmq_setsockopt(subscr_skt, ZMQ_SUBSCRIBE, "phash.", 6) == 0);
snprintf(addr, 32, "tcp://%s:%d", auscoutd_address, result_port);
void *result_skt = socket_connect(ctx, ZMQ_REQ, addr);
assert(result_skt);
struct timespec seed_ts;
clock_gettime(CLOCK_REALTIME, &seed_ts);
srand(seed_ts.tv_nsec);
uint8_t cmd, thrdnum, tblnum;
struct timespec start_ts, end_ts, diff_ts;
uint32_t uid, nbframes, count = 0, nbquerys;
void *data;
int64_t more;
size_t msg_size, more_size = sizeof(int64_t);
float cs = 0.05555f;
fprintf(stdout,"\nready to recieve subscription messages from auscoutd ...\n\n");
while (1){
recieve_msg(prepskt, &msg_size, &more, &more_size, &data);
assert(msg_size == sizeof(uint32_t));
memcpy(&nbquerys, data, sizeof(uint32_t));
free(data);
fprintf(stdout,"expecting %d querys\n\n", nbquerys);
clock_gettime(CLOCK_MONOTONIC, &start_ts);
count = 0;
do {
/* recieve topic */
recieve_msg(subscr_skt, &msg_size, &more, &more_size, &data);
free(data);
/* recieve cmd */
recieve_msg(subscr_skt, &msg_size, &more, &more_size, &data);
memcpy(&cmd, data, sizeof(uint8_t));
free(data);
recieve_msg(subscr_skt, &msg_size, &more, &more_size, &data);
memcpy(&nbframes, data, sizeof(uint32_t));
nbframes = nettohost32(nbframes);
free(data);
/* recieve hash */
recieve_msg(subscr_skt, &msg_size, &more, &more_size, &data);
free(data);
recieve_msg(subscr_skt, &msg_size, &more, &more_size, &data);
memcpy(&thrdnum, data, sizeof(uint8_t));
free(data);
recieve_msg(subscr_skt, &msg_size, &more, &more_size, &data);
memcpy(&uid, data, sizeof(uint32_t));
uid = nettohost32(uid);
free(data);
if (cmd == 1){
/* recieved lookup */
uid = 0; /* send back random integer id*/
cs = 0.5555;
fprintf(stdout,"(%d) lookup: %u frames\n",count,nbframes);
fprintf(stdout," reply : thrdnum %u | uid %u | cs %f\n\n",thrdnum,uid,cs);
uid = hosttonet32(uid);
cs = hosttonetf(cs);
sendmore_msg_vsm(result_skt, &thrdnum, sizeof(uint8_t));
sendmore_msg_vsm(result_skt, &uid, sizeof(uint32_t));
send_msg_vsm(result_skt, &cs, sizeof(float));
recieve_msg(result_skt, &msg_size, &more, &more_size, &data);
free(data);
} else if (cmd == 2){
tblnum = thrdnum;
/* recieved submission */
fprintf(stdout,"(%d) submit: %u frames | %u table\n",count,nbframes,tblnum);
fprintf(stdout," no reply\n\n");
}
fprintf(stdout,"**************************************\n");
} while (++count < nbquerys);
clock_gettime(CLOCK_MONOTONIC, &end_ts);
diff_ts = diff_timespec(start_ts, end_ts);
unsigned long long total_ull = 1000000000*diff_ts.tv_sec + diff_ts.tv_nsec;
float total_secs = (float)total_ull/1000000000.0f;
float rate = (float)nbquerys/total_secs;
fprintf(stdout,"recieved %d querys in %f secs - %f querys/sec\n",\
nbquerys, total_secs, rate);
}
zmq_close(subscr_skt);
zmq_close(result_skt);
zmq_close(prepskt);
zmq_term(ctx);
return 0;
}
