static void parse_args(int argc, char **argv)
{
int c;
char *tmp = NULL;
int set_seed = 0;
prog = argv[0];
while ((c = getopt(argc, argv, "ynvs:m:i:")) != -1) {
switch (c) {
case 'y':
x86_64 = 1;
break;
case 'n':
x86_64 = 0;
break;
case 'v':
verbose++;
break;
case 'i':
if (strcmp("-", optarg) == 0)
input_file = stdin;
else
input_file = fopen(optarg, "r");
if (!input_file)
usage("Failed to open input file");
break;
case 's':
seed = (unsigned int)strtoul(optarg, &tmp, 0);
if (*tmp == ',') {
optarg = tmp + 1;
iter_start = strtoul(optarg, &tmp, 0);
}
if (*tmp != '\0' || tmp == optarg)
usage("Failed to parse seed");
set_seed = 1;
break;
case 'm':
iter_end = strtoul(optarg, &tmp, 0);
if (*tmp != '\0' || tmp == optarg)
usage("Failed to parse max_iter");
break;
default:
usage(NULL);
}
}
/* */
if (iter_end < iter_start)
usage("Max iteration number must be bigger than iter-num");
if (set_seed && input_file)
usage("Don't use input file (-i) with random seed (-s)");
/* */
if (!input_file) {
if (!set_seed) /* */
init_random_seed();
srand(seed);
}
}
void mpi_random_seed_slave(int pnode, int cnt) {
int this_seed;
MPI_Scatter(NULL, 1, MPI_INT, &this_seed, 1, MPI_INT, 0, comm_cart);
RANDOM_TRACE(printf("%d: Received seed %d\n", this_node, this_seed));
init_random_seed(this_seed);
}
void init_random(void)
{
/* initializes the random number generator. You MUST NOT FORGET THIS! */
unsigned long seed;
seed = (10*this_node+1)*1103515245 + 12345;
seed = (seed/65536) % 32768;
init_random_seed((long)seed);
}
void init_random(void) {
/** Set the initial seed */
init_random_seed(1 + this_node);
/** Register callbacks */
mpiCallbacks().add(mpi_random_seed_slave);
mpiCallbacks().add(mpi_random_set_stat_slave);
mpiCallbacks().add(mpi_random_get_stat_slave);
}
void mpi_random_seed(int cnt, vector<int> &seeds) {
int this_seed;
mpi_call(mpi_random_seed_slave, -1, cnt);
MPI_Scatter(&seeds[0], 1, MPI_INT, &this_seed, 1, MPI_INT, 0, comm_cart);
RANDOM_TRACE(printf("%d: Received seed %d\n", this_node, this_seed));
init_random_seed(this_seed);
}
/********* Main function ************/
int main()
{
/* Initialise random number generator */
init_random_seed();
/* read sudoku from a file */
read_sudoku();
/* Fill cells with random digits so each 3 × 3 square contains each of the integers 1 through 9 exactly once */
fill_rand_cells();
cost = evaluate_cost();
printf("COST: %d\n",cost);
int number_nonfixed=number_nonfixed_cells();
MCL=pow(number_nonfixed,2);
printf("MCL: %d\n",MCL);
int m,n;
int cycle = 0;
while(cost != 0) {
printf("CYCLE: %d\t COST: %d\n",++cycle,cost);
T=2.5;
for (n=1;n<=N;n++)
{
for (m=1;m<=MCL;m++)
{
choosing_neighbour();
if (cost==0)
{
break;
}
}
if (cost==0)
{
break;
}
printf("COST: %d\n",cost);
T=alpha*T;
}
}
printf("FINAL Cost: %d\t CYCLES: %d\n",cost, cycle);
/* write sudoku */
write_sudoku();
}
//*******************************
void *Init_Data(int count, void *lock, param_t *params)
{
int ii;
unsigned long seed = init_random_seed(); // random();
unsigned long value;
Values = (unsigned long *)malloc(count*sizeof(unsigned long));
My_Tree = (rbtree_t *)malloc(sizeof(rbtree_t));
rb_create(My_Tree, lock);
#ifndef VALIDATE
if (params->mode == MODE_TRAVERSE || params->mode == MODE_TRAVERSENLN)
{
rb_insert(My_Tree, -1, (void *)-1);
rb_insert(My_Tree, params->scale+1, (void *)(long)params->scale+1);
//count -= 2;
}
#endif
#ifdef VALIDATE
for (value=1; value<=count; value++)
{
rb_insert(My_Tree, value, (void *)(value));
}
#else
for (ii=0; ii<count; ii++)
{
value = get_random(&seed) % params->scale + 1;
while ( !rb_insert(My_Tree, value, (void *)value) )
{
value = get_random(&seed) % params->scale + 1;
}
#ifdef DEBUG_INSERT
if (ii%1000 == 0)
printf("Insert %d %ld\n", ii, value);
//check_tree();
#endif
Values[ii] = value;
}
#endif
return My_Tree;
}
void init_sles_components(struct android_app* state) { // FIXME conflicting types for 'init_sles_components' [enabled by default]
AAssetManager* asset_manager = state->activity->assetManager;
// ANativeActivity* nativeActivity = state->activity;
// internal_path = nativeActivity->externalDataPath;
// LOGD("android_main", "nativeActivity->externalDataPath: %s", nativeActivity->externalDataPath);
// LOGD("android_main", "nativeActivity->internalDataPath: %s", nativeActivity->internalDataPath);
load_all_assets(asset_manager);
create_sl_engine();
init_all_voices();
init_random_seed();
init_all_parts();
init_auto_vals();
sles_init_finished = TRUE;
LOGD("init_sles_thread", "sles_init_finished = TRUE");
}
void
BUuid::_SetToRandomFallback()
{
static bool sSeedInitialized = init_random_seed();
(void)sSeedInitialized;
for (int32 i = 0; i < 4; i++) {
uint32 value = random();
fValue[4 * i + 0] = uint8(value >> 24);
fValue[4 * i + 1] = uint8(value >> 16);
fValue[4 * i + 2] = uint8(value >> 8);
fValue[4 * i + 3] = uint8(value);
}
// random() returns 31 bit numbers only, so we move a few bits from where
// we overwrite them with the version anyway.
uint8 bitsToMove = fValue[kVersionByteIndex];
for (int32 i = 0; i < 4; i++)
fValue[4 * i] |= (bitsToMove << i) & 0x80;
}
void init_random(void)
{
init_random_seed(this_node);
}
/* no AMQP: when not using map_shared, 'pipe_size' is the size of the pipe
created with socketpair(); when map_shared is enabled, it refers to the
size of the shared memory area */
void load_plugins(struct plugin_requests *req)
{
u_int64_t buf_pipe_ratio_sz = 0, pipe_idx = 0;
int snd_buflen = 0, rcv_buflen = 0, socklen = 0, target_buflen = 0, ret;
int nfprobe_id = 0, min_sz = 0;
struct plugins_list_entry *list = plugins_list;
int l = sizeof(list->cfg.pipe_size), offset = 0;
struct channels_list_entry *chptr = NULL;
init_random_seed();
init_pipe_channels();
while (list) {
if ((*list->type.func)) {
if (list->cfg.data_type & (PIPE_TYPE_METADATA|PIPE_TYPE_PAYLOAD|PIPE_TYPE_MSG));
else {
Log(LOG_ERR, "ERROR ( %s/%s ): Data type not supported: %d\n", list->name, list->type.string, list->cfg.data_type);
exit(1);
}
min_sz = ChBufHdrSz;
if (list->cfg.data_type & PIPE_TYPE_METADATA) min_sz += PdataSz;
if (list->cfg.data_type & PIPE_TYPE_PAYLOAD) {
if (list->cfg.acct_type == ACCT_PM && list->cfg.snaplen) min_sz += (PpayloadSz+list->cfg.snaplen);
else min_sz += (PpayloadSz+DEFAULT_PLOAD_SIZE);
}
if (list->cfg.data_type & PIPE_TYPE_EXTRAS) min_sz += PextrasSz;
if (list->cfg.data_type & PIPE_TYPE_MSG) min_sz += PmsgSz;
if (list->cfg.data_type & PIPE_TYPE_BGP) min_sz += sizeof(struct pkt_bgp_primitives);
if (list->cfg.data_type & PIPE_TYPE_NAT) min_sz += sizeof(struct pkt_nat_primitives);
if (list->cfg.data_type & PIPE_TYPE_MPLS) min_sz += sizeof(struct pkt_mpls_primitives);
if (list->cfg.cpptrs.len) min_sz += list->cfg.cpptrs.len;
if (list->cfg.data_type & PIPE_TYPE_VLEN) min_sz += sizeof(struct pkt_vlen_hdr_primitives);
/* If nothing is supplied, let's hint some working default values */
if (!list->cfg.pipe_size || !list->cfg.buffer_size) {
if (!list->cfg.pipe_size) list->cfg.pipe_size = 4096000; /* 4Mb */
if (!list->cfg.buffer_size) {
if (list->cfg.pcap_savefile) list->cfg.buffer_size = 10240; /* 10Kb */
else list->cfg.buffer_size = MIN(min_sz, 10240);
}
}
/* some validations */
if (list->cfg.pipe_size < min_sz) list->cfg.pipe_size = min_sz;
if (list->cfg.buffer_size < min_sz) list->cfg.buffer_size = min_sz;
if (list->cfg.buffer_size > list->cfg.pipe_size) list->cfg.buffer_size = list->cfg.pipe_size;
/* if required let's align plugin_buffer_size to 4 bytes boundary */
#if NEED_ALIGN
while (list->cfg.buffer_size % 4 != 0) list->cfg.buffer_size--;
#endif
if (!list->cfg.pipe_amqp) {
/* creating communication channel */
socketpair(AF_UNIX, SOCK_DGRAM, 0, list->pipe);
/* checking SO_RCVBUF and SO_SNDBUF values; if different we take the smaller one */
getsockopt(list->pipe[0], SOL_SOCKET, SO_RCVBUF, &rcv_buflen, &l);
getsockopt(list->pipe[1], SOL_SOCKET, SO_SNDBUF, &snd_buflen, &l);
socklen = (rcv_buflen < snd_buflen) ? rcv_buflen : snd_buflen;
buf_pipe_ratio_sz = (list->cfg.pipe_size/list->cfg.buffer_size)*sizeof(char *);
if (buf_pipe_ratio_sz > INT_MAX) {
Log(LOG_ERR, "ERROR ( %s/%s ): Current plugin_buffer_size elems per plugin_pipe_size: %d. Max: %d.\nExiting.\n",
list->name, list->type.string, (list->cfg.pipe_size/list->cfg.buffer_size), (INT_MAX/sizeof(char *)));
exit_all(1);
}
else target_buflen = buf_pipe_ratio_sz;
if (target_buflen > socklen) {
Setsocksize(list->pipe[0], SOL_SOCKET, SO_RCVBUF, &target_buflen, l);
Setsocksize(list->pipe[1], SOL_SOCKET, SO_SNDBUF, &target_buflen, l);
}
getsockopt(list->pipe[0], SOL_SOCKET, SO_RCVBUF, &rcv_buflen, &l);
getsockopt(list->pipe[1], SOL_SOCKET, SO_SNDBUF, &snd_buflen, &l);
if (rcv_buflen < snd_buflen) snd_buflen = rcv_buflen;
if (snd_buflen < socklen) {
Setsocksize(list->pipe[0], SOL_SOCKET, SO_RCVBUF, &socklen, l);
Setsocksize(list->pipe[1], SOL_SOCKET, SO_SNDBUF, &socklen, l);
getsockopt(list->pipe[0], SOL_SOCKET, SO_RCVBUF, &rcv_buflen, &l);
getsockopt(list->pipe[1], SOL_SOCKET, SO_SNDBUF, &snd_buflen, &l);
if (rcv_buflen < snd_buflen) snd_buflen = rcv_buflen;
}
if (list->cfg.debug || (list->cfg.pipe_size > WARNING_PIPE_SIZE)) {
Log(LOG_INFO, "INFO ( %s/%s ): plugin_pipe_size=%llu bytes plugin_buffer_size=%llu bytes\n",
list->name, list->type.string, list->cfg.pipe_size, list->cfg.buffer_size);
if (target_buflen <= snd_buflen)
Log(LOG_INFO, "INFO ( %s/%s ): ctrl channel: obtained=%d bytes target=%d bytes\n",
list->name, list->type.string, snd_buflen, target_buflen);
else
/* This should return an error and exit but we fallback to a
warning in order to be backward compatible */
Log(LOG_WARNING, "WARN ( %s/%s ): ctrl channel: obtained=%d bytes target=%d bytes\n",
list->name, list->type.string, snd_buflen, target_buflen);
}
}
else {
pipe_idx++;
list->pipe[0] = list->pipe[1] = pipe_idx;
}
list->cfg.name = list->name;
list->cfg.type = list->type.string;
list->cfg.type_id = list->type.id;
chptr = insert_pipe_channel(list->type.id, &list->cfg, list->pipe[1]);
if (!chptr) {
Log(LOG_ERR, "ERROR ( %s/%s ): Unable to setup a new Core Process <-> Plugin channel.\nExiting.\n", list->name, list->type.string);
exit_all(1);
}
else chptr->plugin = list;
/* sets new value to be assigned to 'wakeup'; 'TRUE' disables on-request wakeup */
if (list->type.id == PLUGIN_ID_MEMORY) chptr->request = TRUE;
/* sets fixed/vlen offsets and cleaner routine; XXX: we should refine the cleaner
part: 1) ie. extras assumes it's automagically piled with metadata; 2) what if
multiple vlen components are stacked up? */
if (list->cfg.data_type & PIPE_TYPE_METADATA) {
chptr->clean_func = pkt_data_clean;
offset = sizeof(struct pkt_data);
}
if (list->cfg.data_type & PIPE_TYPE_PAYLOAD) chptr->clean_func = pkt_payload_clean;
if (list->cfg.data_type & PIPE_TYPE_EXTRAS) {
chptr->extras.off_pkt_extras = offset;
offset += sizeof(struct pkt_extras);
}
if (list->cfg.data_type & PIPE_TYPE_MSG) chptr->clean_func = pkt_msg_clean;
if (list->cfg.data_type & PIPE_TYPE_BGP) {
chptr->extras.off_pkt_bgp_primitives = offset;
offset += sizeof(struct pkt_bgp_primitives);
}
else chptr->extras.off_pkt_bgp_primitives = 0;
if (list->cfg.data_type & PIPE_TYPE_NAT) {
chptr->extras.off_pkt_nat_primitives = offset;
offset += sizeof(struct pkt_nat_primitives);
}
else chptr->extras.off_pkt_nat_primitives = 0;
if (list->cfg.data_type & PIPE_TYPE_MPLS) {
chptr->extras.off_pkt_mpls_primitives = offset;
offset += sizeof(struct pkt_mpls_primitives);
}
else chptr->extras.off_pkt_mpls_primitives = 0;
if (list->cfg.cpptrs.len) {
chptr->extras.off_custom_primitives = offset;
offset += list->cfg.cpptrs.len;
}
/* PIPE_TYPE_VLEN at the end of the stack so to not make
vlen other structures (although possible it would not
make much sense) */
if (list->cfg.data_type & PIPE_TYPE_VLEN) {
chptr->extras.off_pkt_vlen_hdr_primitives = offset;
offset += sizeof(struct pkt_vlen_hdr_primitives);
}
else chptr->extras.off_pkt_vlen_hdr_primitives = 0;
/* any further offset beyond this point must be set to
PM_VARIABLE_LENGTH so to indicate plugins to resolve
value at runtime. */
chptr->datasize = min_sz-ChBufHdrSz;
/* sets nfprobe ID */
if (list->type.id == PLUGIN_ID_NFPROBE) {
list->cfg.nfprobe_id = nfprobe_id;
nfprobe_id++;
}
switch (list->pid = fork()) {
case -1: /* Something went wrong */
Log(LOG_WARNING, "WARN ( %s/%s ): Unable to initialize plugin: %s\n", list->name, list->type.string, strerror(errno));
delete_pipe_channel(list->pipe[1]);
break;
case 0: /* Child */
/* SIGCHLD handling issue: SysV avoids zombies by ignoring SIGCHLD; to emulate
such semantics on BSD systems, we need an handler like handle_falling_child() */
#if defined (IRIX) || (SOLARIS)
signal(SIGCHLD, SIG_IGN);
#else
signal(SIGCHLD, ignore_falling_child);
#endif
#if defined HAVE_MALLOPT
mallopt(M_CHECK_ACTION, 0);
#endif
close(config.sock);
close(config.bgp_sock);
if (!list->cfg.pipe_amqp) close(list->pipe[1]);
(*list->type.func)(list->pipe[0], &list->cfg, chptr);
exit(0);
default: /* Parent */
if (!list->cfg.pipe_amqp) {
close(list->pipe[0]);
setnonblocking(list->pipe[1]);
}
break;
}
/* some residual check */
if (chptr && list->cfg.a_filter) req->bpf_filter = TRUE;
}
list = list->next;
}
sort_pipe_channels();
/* define pre_tag_map(s) now so that they don't finish unnecessarily in plugin memory space */
{
int ptm_index = 0, ptm_global = FALSE;
char *ptm_ptr = NULL;
list = plugins_list;
while (list) {
if (list->cfg.pre_tag_map) {
if (!ptm_index) {
ptm_ptr = list->cfg.pre_tag_map;
ptm_global = TRUE;
}
else {
if (!ptm_ptr || strcmp(ptm_ptr, list->cfg.pre_tag_map))
ptm_global = FALSE;
}
load_pre_tag_map(config.acct_type, list->cfg.pre_tag_map, &list->cfg.ptm, req, &list->cfg.ptm_alloc,
list->cfg.maps_entries, list->cfg.maps_row_len);
}
list = list->next;
ptm_index++;
}
/* enforcing global flag */
list = plugins_list;
while (list) {
list->cfg.ptm_global = ptm_global;
list = list->next;
}
}
/* AMQP handling, if required */
#ifdef WITH_RABBITMQ
{
int ret, index, index2;
for (index = 0; channels_list[index].aggregation || channels_list[index].aggregation_2; index++) {
chptr = &channels_list[index];
list = chptr->plugin;
if (list->cfg.pipe_amqp) {
plugin_pipe_amqp_init_host(&chptr->amqp_host, list);
ret = p_amqp_connect_to_publish(&chptr->amqp_host);
if (ret) plugin_pipe_amqp_sleeper_start(chptr);
}
/* reset core process pipe AMQP routing key */
if (list->type.id == PLUGIN_ID_CORE) list->cfg.pipe_amqp_routing_key = NULL;
}
for (index = 0; channels_list[index].aggregation || channels_list[index].aggregation_2; index++) {
struct plugins_list_entry *list2 = plugins_list;
struct channels_list_entry *chptr2 = NULL;
chptr = &channels_list[index];
list = chptr->plugin;
for (index2 = index; channels_list[index2].aggregation || channels_list[index2].aggregation_2; index2++) {
chptr2 = &channels_list[index2];
list2 = chptr2->plugin;
if (index2 > index && list->cfg.pipe_amqp_exchange && list->cfg.pipe_amqp_routing_key) {
if (!strcmp(list->cfg.pipe_amqp_exchange, list2->cfg.pipe_amqp_exchange) &&
!strcmp(list->cfg.pipe_amqp_routing_key, list2->cfg.pipe_amqp_routing_key)) {
Log(LOG_ERR, "ERROR ( %s/%s ): Duplicated plugin_pipe_amqp_exchange, plugin_pipe_amqp_routing_key: %s, %s\nExiting.\n",
list->name, list->type.string, list->cfg.pipe_amqp_exchange, list->cfg.pipe_amqp_routing_key);
exit(1);
}
}
}
}
}
#endif
/* Kafka handling, if required */
#ifdef WITH_KAFKA
{
int ret, index, index2;
for (index = 0; channels_list[index].aggregation || channels_list[index].aggregation_2; index++) {
chptr = &channels_list[index];
list = chptr->plugin;
/* XXX: no sleeper thread, trusting librdkafka */
if (list->cfg.pipe_kafka) ret = plugin_pipe_kafka_init_host(&chptr->kafka_host, list, TRUE);
/* reset core process pipe Kafka topic */
if (list->type.id == PLUGIN_ID_CORE) list->cfg.pipe_kafka_topic = NULL;
}
for (index = 0; channels_list[index].aggregation || channels_list[index].aggregation_2; index++) {
struct plugins_list_entry *list2 = plugins_list;
struct channels_list_entry *chptr2 = NULL;
chptr = &channels_list[index];
list = chptr->plugin;
for (index2 = index; channels_list[index2].aggregation || channels_list[index2].aggregation_2; index2++) {
chptr2 = &channels_list[index2];
list2 = chptr2->plugin;
if (index2 > index && list->cfg.pipe_kafka_broker_host && list->cfg.pipe_kafka_topic) {
if (!strcmp(list->cfg.pipe_kafka_broker_host, list2->cfg.pipe_kafka_broker_host) &&
list->cfg.pipe_kafka_broker_port == list2->cfg.pipe_kafka_broker_port &&
!strcmp(list->cfg.pipe_kafka_topic, list2->cfg.pipe_kafka_topic) /* && XXX: topic partition too? */ ) {
Log(LOG_ERR, "ERROR ( %s/%s ): Duplicated plugin_pipe_kafka_broker_*, plugin_pipe_kafka_topic: %s, %s, %s\nExiting.\n",
list->name, list->type.string, list->cfg.pipe_kafka_broker_host, list->cfg.pipe_kafka_broker_port,
list->cfg.pipe_kafka_topic);
exit(1);
}
}
}
}
}
#endif
}
int
main(int argc, char *argv[]) {
int rc = 0;
Network *N = NULL;
time_measure_start(&GNRL_ST.total_time);
//process input arguments and init global structure
rc |= process_input_args(argc, argv);
if (GNRL_ST.quiet_mode == FALSE)
printf("mfinder Version %.2f\n\n", VERSION);
if (rc == RC_ERR)
at_exit(-1);
//general initialization
rc |= gnrl_init();
if (rc == RC_ERR)
at_exit(-1);
// load network from input file
if (GNRL_ST.quiet_mode == FALSE)
printf("Loading Network\n");
load_network(&G_N, input_network_fname);
duplicate_network(G_N, &N, "real_network");
init_random_seed();
if (rc == RC_ERR)
at_exit(-1);
if (GNRL_ST.quiet_mode == FALSE)
printf("Searching motifs size %d\nProcessing Real network...\n", GNRL_ST.mtf_sz);
//search motifs size n in Real network
if (GNRL_ST.dont_search_real != TRUE)
rc |= motifs_search_real(N);
if (rc == RC_ERR)
at_exit(-1);
/*
printf("RES TBL real\n");
for (l_id = list64_get_next(RES_TBL.real, NULL); l_id != NULL;
l_id = list64_get_next(RES_TBL.real, l_id))
{
printf("id: %d\ncount: %.0f\n", (int)((Motif*)l_id->p)->id,
((Motif*)l_id->p)->count);
}
*/
if (GNRL_ST.quiet_mode == FALSE)
printf("Processing Random networks\n");
if (GNRL_ST.rnd_net_num > 0) {
// create random networks with same single node statisticfs as the input network
if (GNRL_ST.r_grassberger == FALSE) {
//use switches or stubs
rc |= process_rand_networks(&RES_TBL, GNRL_ST.mtf_sz);
} else {
//use grassberger alg
weights_arr = (double*) calloc(GNRL_ST.rnd_net_num + 1, sizeof (double));
rc |= process_rand_networks_grassberger(&RES_TBL, GNRL_ST.mtf_sz, weights_arr);
}
if (rc == RC_ERR)
at_exit(-1);
}
if (GNRL_ST.quiet_mode == FALSE)
printf("Calculating Results...\n");
if (GNRL_ST.rnd_net_num >= 0) {
//calculate final results and dump them to the results file
if (!GNRL_ST.r_grassberger) {
calc_final_results(&RES_TBL, &final_res, &final_res_all, GNRL_ST.rnd_net_num);
} else {
//Nadav change for GRASS NEW
calc_final_results_grassberger(&RES_TBL, FALSE, res_sub_motif, &final_res, &final_res_all, GNRL_ST.rnd_net_num, weights_arr);
}
}
//calculate final results
time_measure_stop(&GNRL_ST.total_time);
//output results
rc |= output_results(final_res, final_res_all);
free_network_mem(G_N);
free(G_N);
final_res_free(final_res);
final_res_free(final_res_all);
if (GNRL_ST.r_grassberger)
free(weights_arr);
res_tbl_mem_free(&RES_TBL);
if (GNRL_ST.calc_roles == TRUE) {
free_mem_role_hash();
free_roles_res_tbl(GNRL_ST.rnd_net_num);
free_role_members();
}
if (rc == RC_ERR)
at_exit(-1);
exit(at_exit(rc));
}
