int main(int argc, char* argv[]) {
if (argc < 6) {
cout << " usage: ./litter exp_on exp_off droprate days genrate"
<< " < graphfile\n";
return 0;
}
double churn_on = atof(argv[1]);
double churn_off = atof(argv[2]);
double drop_rate = double(1) - atof(argv[3]);
int days = atoi(argv[4]) + 1;
GDays = days;
int runtime = days * 24 * 3600;
int genrate = atoi(argv[5]);
int seed = -1;
if (argc >= 8) {
ps_rate = atoi(argv[6]);
cg_rate = atoi(argv[7]);
}
Random* rnd = new Ran1Random(seed);
EventScheduler* sched = new EventScheduler();
Network* net = new LitterNetwork(std::cin, *rnd, drop_rate);
ExpDRV* expon = new ExpDRV(*rnd, churn_on);
ExpDRV* expoff = new ExpDRV(*rnd, churn_off);
UniformNodeSelector* ns = new UniformNodeSelector(*rnd);
ns->selectFrom(net);
NodeIterator* ni = net->getNodeIterator();
int time = 0;
// Schedule a churn event for each node
while (ni->moveNext()) {
Node* node = ni->current();
time = rnd->getInt(3600);
sched->at(time, new ChurnEvent(*node, *sched, *net, *expoff, *expon));
}
// Schedule a pull request at each node
ni->reset();
while (ni->moveNext()) {
Node* node = ni->current();
time = rnd->getInt(3600);
sched->at(time, new PullSend(*node, *sched, *net, true));
}
// Schedule a checkgap at each node
ni->reset();
while (ni->moveNext()) {
Node* node = ni->current();
time = rnd->getInt(3600);
sched->at(time, new CheckGap(*node, *sched, *net));
}
// Periodically generates posts
sched->at(1800, new PostGen(*sched, *net, *rnd, *ns, genrate));
// Stops the scheduler
sched->at(runtime, new StopAction(*sched));
sched->start();
StatsPrint(*net, *sched);
// clean up global objects
delete rnd;
delete sched;
delete expon;
delete expoff;
delete net;
delete ni;
delete ns;
return 0;
}
int main(void) {
ifstream indata("090615.dat",ios::in);
int nodes = 100;
int ttl = 4;
int k = 100; //the nunber of items
int forl = 0;
int ctime, qtime, jtime, ftime, ltime;
double time = 0;
Ran1Random ran_no(-1);
EventScheduler sched;
auto_ptr<SimpleNetwork> Net_ptr (new SimpleNetwork(ran_no));
float fitness_sum = 0;
float a[nodes]; //fitness
float b[nodes];
float c[nodes]; //probability
for(int i = 0; i < nodes ; i++) {
indata >> b[i] >> c[i];
//cout << b[i] << "\t" << c[i] << endl;
a[i] = 0;
fitness_sum += b[i];
}
for(int i = 1 ; i < nodes ; i++) {
a[i] = b[i-1];
b[i] += a[i];
//cout << a[i] << "\t" << b[i] << endl;
}
float select_father;
float select_mother;
float father_prob;
float mother_prob;
for(int i = 0 ; i < nodes ; i++) {
float pure_cross;
//selection of father
select_father = ran_no.getDouble01()*fitness_sum;
for(int f = 0 ; f < nodes ; f++) {
if(a[f]<select_father && b[f]>select_father) {
father_prob = c[f];
//cout<<c[f]<<endl;
}
// else {}
}
//seletion of mother
select_mother = ran_no.getDouble01()*fitness_sum;
for(int m = 0 ; m < nodes ; m++) {
if(a[m]<select_mother && b[m]>select_mother) {
mother_prob = c[m];
//cout<<c[m]<<endl;
}
//else{}
}
pure_cross = (father_prob+ mother_prob)/2; //crossover without mutation
//cout<<pure_cross<<endl;
//cout << "before mutation : "<< pure_cross << endl;
//mutation process
//maximum mutation is 10% of crossover, minimum mutation is 1% of crossover
if (ran_no.getDouble01() > 0.5) {
// cout << 'a' << endl;
c[i] = pure_cross + ran_no.getDouble((pure_cross)*0.01, 0);
if (c[i] > 1) {
c[i] = 0.9999999;
//cout << 'a' << endl;
}
}
else {
//cout << 'b' <<endl;
c[i] = pure_cross - ran_no.getDouble((pure_cross)*0.01, 0);
if (c[i] < 0) {
c[i] = 0.0000001;
//cout << 'b' << endl;
}
}
//cout << c[i] << endl;
//c[i] = pure_cross;
}
// nodes creation of next generation
for(int i=0; i< nodes; i++) {
Net_ptr->create(1, c[i]);
//cout << c[i] << endl;
}
std::set<std::string> items = rstringGenerator(k, 10, ran_no);
std::set<std::string>::const_iterator item_it;
time += 10;
UniformNodeSelector uns(ran_no);
for (item_it = items.begin(); item_it != items.end(); item_it++) {
std::string item = *item_it;
ctime = time + ran_no.getExp(100.0);
Action* c_action = new CacheAction(sched, ran_no, uns, *Net_ptr.get(), item, ttl);
sched.at(ctime, c_action);
/*
jtime = ctime + ran_no.getExp(720.0);
Action* j_action = new JoinAction(sched, ran_no, *Net_ptr.get());
sched.at(jtime, j_action);
*/
UniformNodeSelector q_start(ran_no);
for (int iter = 0; iter < 100; iter++) {
Action* q_action = new QueryAction(sched, ran_no, q_start, *Net_ptr.get(), item, ttl);
qtime = jtime +ran_no.getExp(3600.0);
sched.at(qtime, q_action);
}
/*
forl++;
forl=forl%2;
if(forl == 0) {
ftime = qtime + ran_no.getExp(1080.0);
Action *f_action = new FailAction(sched, ran_no, *Net_ptr.get());
sched.at(ftime, f_action);
}
else {
ltime = qtime +ran_no.getExp(1080.0);
Action* l_action = new LeaveAction(sched, ran_no, *Net_ptr.get());
sched.at(ltime, l_action);
}
*/
time = ctime;
}
Action* stop = new StopAction(sched);
sched.at(360000, stop);
sched.start();
auto_ptr<NodeIterator> totn (Net_ptr->getNodeIterator());
int total_hits = 0;
while (totn->moveNext() ) {
SimpleNode* inNode = dynamic_cast<SimpleNode*> (totn->current() );
float hitrate;
int cpu_cost;
int disk_cost;
float prob;
float fitness;
hitrate = (float)inNode->getQueryhits()/(float)inNode->getQuerymessage();
total_hits = total_hits + (inNode->getQueryhits());
cpu_cost = inNode->getrxmessage()+(inNode->getprmessage())*(inNode->getItem()).size();
disk_cost = (inNode->getItem()).size();
fitness = 10*(exp((0.5*hitrate)-((0.2*disk_cost/100)+(0.3*cpu_cost/1000000))));
fitness = fitness * fitness;
//cout<<fitness<<"\t"<<inNode->getprob() << endl;
//cout << hitrate << "\t" << disk_cost << "\t" << cpu_cost << endl;
}
cout << total_hits << endl;
return 0;
}
int main(void) {
ifstream indata("final_test_modified.dat",ios::in);
ofstream datafile1;
ofstream datafile2;
datafile1.open("small_group_5.dat");
datafile2.open("big_group_5.dat");
int nodes = 100;
int node_ttl;
int connection_limit;
int k = 100; //the nunber of items
//int forl = 0;
int generation = 200;
int group1_portion = 10;
int group2_portion = 90;
float group1_fitness_sum = 0;
float group2_fitness_sum = 0;
float a[nodes];
float b[nodes]; //fitness
float c[nodes]; //probability
int d[nodes]; //connection
int e[nodes]; //TTL
float c_new[nodes]; // probability for child
int d_new[nodes]; // connection for child
int e_new[nodes]; // TTL for child
Ran1Random ran_no(-1);
EventScheduler sched;
for(int i = 0; i < nodes ; i++) {
indata >> b[i] >> c[i] >> d[i] >> e[i];
a[i] = 0;
}
float select_father;
float select_mother;
float father_prob;
int father_connection;
int father_TTL;
float mother_prob;
int mother_connection;
int mother_TTL;
float pure_cross_prob;
float pure_cross_ttl;
float pure_cross_connection;
//for crossover of query ignore probability
for(int ge = 1; ge < generation; ge++) {
datafile1 << "#-----------------------------" << endl;
datafile2 << "#-----------------------------" << endl;
int ctime, qtime;
double time = 0;
//empty network generation
auto_ptr<SimpleNetwork> Net_ptr (new SimpleNetwork(ran_no));
//for roulette selection method
for(int i = 0 ; i < nodes; i++) {
if(i < group1_portion) {
group1_fitness_sum += b[i];
}
else {
group2_fitness_sum += b[i];
}
}
for(int i = 1; i < group1_portion; i++) {
a[i] = b[i-1];
b[i] += a[i];
}
for(int i = group1_portion+1; i < nodes; i++) {
a[i] = b[i-1];
b[i] += a[i];
}
//cout << 'a' << endl;
for(int i = 0 ; i < group1_portion ; i++) {
int name_parent;
bool check_parent = false;
//selection of father
select_father = ran_no.getDouble01()*group1_fitness_sum;
//select_father = ran_no.getDouble01()*fitness_sum;
for(int f = 0 ; f < group1_portion ; f++) {
//for(int f = 0 ; f < nodes ; f++) {
if(a[f]<select_father && b[f]>select_father) {
father_prob = c[f];
father_connection = d[f];
father_TTL = e[f];
name_parent = f;
}
}
while(!check_parent) {
//seletion of mother
select_mother = ran_no.getDouble01()*group1_fitness_sum;
for(int m = 0 ; m < group1_portion ; m++) {
if(a[m]<select_mother && b[m]>select_mother) {
if(name_parent != m) {
mother_prob = c[m];
mother_connection = d[m];
mother_TTL = e[m];
check_parent = true;
}
}
}
}
pure_cross_prob = (father_prob + mother_prob)/2; //crossover without mutation
//mutation process for query ignore probability
//maximum mutation is 10% of crossover, minimum mutation is 1% of crossover
if (ran_no.getDouble01() > 0.5) {
c_new[i] = pure_cross_prob + ran_no.getDouble((pure_cross_prob)*0.001, 0);
if (c_new[i] > 1) {
c_new[i] = 0.9999999;
}
}
else {
c_new[i] = pure_cross_prob - ran_no.getDouble((pure_cross_prob)*0.001, 0);
if (c_new[i] < 0) {
c_new[i] = 0.0000001;
}
}
//for TTL
if (mother_TTL > father_TTL) {
pure_cross_ttl = ran_no.getInt(mother_TTL, father_TTL);
e_new[i] = pure_cross_ttl;
}
else {
pure_cross_ttl = ran_no.getInt(father_TTL, mother_TTL);
e_new[i] = pure_cross_ttl;
}
/*
if (ran_no.getDouble01() < 0.2) {
if (ran_no.getDouble01() > 0.5) {
e_new[i] = pure_cross_ttl + 1;
}
else {
e_new[i] = pure_cross_ttl - 1;
if (e_new[i] < 1) {
e_new[i] = 1;
}
}
}
else {
e_new[i] = pure_cross_ttl;
}
*/
//for connection
if (mother_connection > father_connection) {
pure_cross_connection = ran_no.getInt(mother_connection, father_connection);
d_new[i] = pure_cross_connection;
}
else {
pure_cross_connection = ran_no.getInt(father_connection, mother_connection);
d_new[i] = pure_cross_connection;
}
/*
if (ran_no.getDouble01() < 0.2) {
if (ran_no.getDouble01() > 0.5) {
d_new[i] = pure_cross_connection + 1;
}
else {
d_new[i] = pure_cross_connection - 1;
if (d_new[i] < 1) {
d_new[i] = 1;
}
}
}
else {
d_new[i] = pure_cross_connection;
}
*/
Net_ptr->create(1, e_new[i], d_new[i], c_new[i], true);
}
for(int i = group1_portion ; i < nodes ; i++) {
int name_parent;
bool check_parent = false;
//selection of father
select_father = ran_no.getDouble01()*group2_fitness_sum;
//cout << "select_father " << "\t" << select_father << endl;
//cout << "group_fitness_sum" << "\t" << group2_fitness_sum << endl;
//cout << a[99] << endl;
for(int f = group1_portion ; f < nodes ; f++) {
//cout << a[f] << endl;
if(a[f]<select_father && b[f]>select_father) {
father_prob = c[f];
father_connection = d[f];
father_TTL = e[f];
name_parent = f;
//cout << 'd' << endl;
}
}
while(!check_parent) {
//seletion of mother
select_mother = ran_no.getDouble01()*group2_fitness_sum;
for(int m = group1_portion ; m < nodes ; m++) {
if(a[m]<select_mother && b[m]>select_mother) {
if(name_parent != m) {
mother_prob = c[m];
mother_connection = d[m];
mother_TTL = e[m];
check_parent = true;
}
}
}
}
pure_cross_prob = (father_prob + mother_prob)/2; //crossover without mutation
//mutation process for query ignore probability
//maximum mutation is 10% of crossover, minimum mutation is 1% of crossover
if (ran_no.getDouble01() > 0.5) {
c_new[i] = pure_cross_prob + ran_no.getDouble((pure_cross_prob)*0.001, 0);
if (c_new[i] > 1) {
c_new[i] = 0.9999999;
}
}
else {
c_new[i] = pure_cross_prob - ran_no.getDouble((pure_cross_prob)*0.001, 0);
if (c_new[i] < 0) {
c_new[i] = 0.0000001;
}
}
if (mother_TTL > father_TTL) {
pure_cross_ttl = ran_no.getInt(mother_TTL, father_TTL);
e_new[i] = pure_cross_ttl;
}
else {
pure_cross_ttl = ran_no.getInt(father_TTL, mother_TTL);
e_new[i] = pure_cross_ttl;
}
/*
if (ran_no.getDouble01() < 0.2) {
if (ran_no.getDouble01() > 0.5) {
e_new[i] = pure_cross_ttl + 1;
}
else {
e_new[i] = pure_cross_ttl - 1;
if (e_new[i] < 1) {
e_new[i] = 1;
}
}
}
else {
e_new[i] = pure_cross_ttl;
}
*/
//for connection
if (mother_connection > father_connection) {
pure_cross_connection = ran_no.getInt(mother_connection, father_connection);
d_new[i] = pure_cross_connection;
}
else {
pure_cross_connection = ran_no.getInt(father_connection, mother_connection);
d_new[i] = pure_cross_connection;
}
/*
if (ran_no.getDouble01() < 0.2) {
if (ran_no.getDouble01() > 0.5) {
d_new[i] = pure_cross_connection + 1;
}
else {
d_new[i] = pure_cross_connection - 1;
if (d_new[i] < 1) {
d_new[i] = 1;
}
}
}
else {
d_new[i] = pure_cross_connection;
}
*/
Net_ptr->create(1, e_new[i], d_new[i], c_new[i], false);
}
std::set<std::string> items = rstringGenerator(k, 10, ran_no);
std::set<std::string>::const_iterator item_it;
time += 10;
UniformNodeSelector uns(ran_no);
for (item_it = items.begin(); item_it != items.end(); item_it++) {
std::string item = *item_it;
ctime = time + ran_no.getExp(100.0);
Action* c_action = new CacheAction(sched, ran_no, uns, *Net_ptr.get(), item);
sched.at(ctime, c_action);
/*
jtime = ctime + ran_no.getExp(720.0);
Action* j_action = new JoinAction(sched, ran_no, *Net_ptr.get());
sched.at(jtime, j_action);
*/
UniformNodeSelector q_start(ran_no);
for (int iter = 0; iter < 100; iter++) {
Action* q_action = new QueryAction(sched, ran_no, q_start, *Net_ptr.get(), item);
qtime = ctime +ran_no.getExp(3600.0);
sched.at(qtime, q_action);
}
/*
forl++;
forl=forl%2;
if(forl == 0) {
ftime = qtime + ran_no.getExp(1080.0);
Action *f_action = new FailAction(sched, ran_no, *Net_ptr.get());
sched.at(ftime, f_action);
}
else {
ltime = qtime +ran_no.getExp(1080.0);
Action* l_action = new LeaveAction(sched, ran_no, *Net_ptr.get());
sched.at(ltime, l_action);
}
*/
time = ctime;
}
Action* stop = new StopAction(sched);
sched.at(360000, stop);
sched.start();
auto_ptr<NodeIterator> totn (Net_ptr->getNodeIterator());
float hitrate;
int cpu_cost;
int disk_cost;
float prob;
float fitness;
int new_nodes = 0;
int total_ttl = 0;
int total_connection = 0;
float total_fitness = 0;
float total_prob = 0;
float total_hitrate = 0;
float total_cpu_cost = 0;
float total_disk_cost = 0;
float average_ttl;
float average_connection;
float average_fitness;
float average_prob;
float average_hitrate;
float average_cpu_cost;
float average_disk_cost;
cout << "#fit \t P_ig \t P_s \t cost_cpu \t cost_d" << endl;
while (totn->moveNext() ) {
SimpleNode* inNode = dynamic_cast<SimpleNode*> (totn->current() );
hitrate = (float)inNode->getQueryhits()/(float)inNode->getQuerymessage();
cpu_cost = inNode->getrxmessage()+(inNode->getprmessage())*(inNode->getItem()).size();
disk_cost = (inNode->getItem()).size();
fitness = exp((10*hitrate)-((disk_cost/100)+(cpu_cost/50000)));
//fitness = 10*(exp((0.5*hitrate)-((0.2*disk_cost/100)+(0.3*cpu_cost/500000))));
//fitness = fitness * fitness;
total_ttl += inNode->getTTL();
total_connection += inNode->getConnectionlimit();
total_hitrate += hitrate;
total_cpu_cost += cpu_cost;
total_disk_cost += disk_cost;
total_fitness += fitness;
total_prob += inNode->getprob();
b[new_nodes] = fitness;
//c[new_nodes] = inNode->getprob();
//d[new_nodes] = inNode->getConnectionlimit();
//e[new_nodes] = inNode->getTTL();
c[new_nodes] = c_new[new_nodes];
d[new_nodes] = d_new[new_nodes];
e[new_nodes] = e_new[new_nodes];
if (inNode -> getGroupid() == true){
//datafile1 << fitness << endl;
datafile1<<fitness<<"\t"<<inNode->getprob() << "\t" << hitrate << "\t" << cpu_cost << "\t" << disk_cost << "\t" << endl;
}
else {
//datafile2 << fitness << endl;
datafile2<<fitness<<"\t"<<inNode->getprob() << "\t" << hitrate << "\t" << cpu_cost << "\t" << disk_cost << "\t" << endl;
}
//cout<<fitness<<"\t"<<inNode->getprob() << "\t" << hitrate << "\t" << cpu_cost << "\t" << disk_cost << "\t" << endl;
//cout << hitrate << "\t" << disk_cost << "\t" << cpu_cost << endl;
//cout << inNode->getQueryhits() << "\t" << inNode->getQuerymessage() << endl;
//cout << fitness << "\t" << inNode->getprob() << "\t" << inNode->getTTL() << "\t" << inNode->getConnectionlimit() << endl;
new_nodes++;
}
//cout << total_hits << endl;
average_ttl = total_ttl / nodes;
average_connection = total_connection / nodes;
average_hitrate = total_hitrate / nodes;
average_cpu_cost = total_cpu_cost / nodes;
average_disk_cost = total_disk_cost / nodes;
average_fitness = total_fitness / nodes;
average_prob = total_prob / nodes;
//cout << average_hitrate << "\t" << average_cpu_cost << "\t" <<average_disk_cost << "\t" << average_fitness << "\t" << average_prob << "\t" << average_ttl << "\t" << average_connection << endl;
//cout << average_fitness << "\t" << average_prob << endl;
group1_fitness_sum = 0;
group2_fitness_sum = 0;
//fitness_sum = 0;
}
datafile1.close();
datafile2.close();
return 0;
}
