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