void random_placement(node_type *node, int node_num, int grid_size, int seed)
{
int i;
/*********************************************/
/* reinitializes the random number generator */
/*********************************************/
random_reset();
for (i=0; i<node_num; ++i)
{
node[i].x = random_uniform_int(seed, 0, grid_size);
node[i].y = random_uniform_int(seed, 0, grid_size);
}
}
void expand_nodes(node_type *node, int node_num, int nodes2net, int grid_size, int expansion, int seed)
{ /* reminder: node should be sorted according to outdegree at all times */
int i, j;
int offset;
/*********************************************/
/* reinitializes the random number generator */
/*********************************************/
random_reset();
for (i=0; i<nodes2net; ++i)
{
offset = node_num + i*NETWORK_SIZE;
/******************************/
/* place the additional nodes */
/******************************/
if (expansion == RP_LC)
random_placement(node+offset, NETWORK_SIZE, grid_size, seed);
else
strategic_placement(node+offset, NETWORK_SIZE, grid_size, seed);
/*********************************************/
/* reassign node ids for the expansion nodes */
/*********************************************/
for (j = offset; j<offset+NETWORK_SIZE; ++j)
{
node[j].nid = j;
node[j].degree = 0; /* outdegree too */
}
/**************************************************************/
/* form a connected network among the nodes randomly */
/* no definite pattern was obvious from observation */
/* http://boardwatch.internet.com/isp/summer99/backbones.html */
/**************************************************************/
random_connection(node+offset, NETWORK_SIZE, &node[i], AVG_ENNOD, seed);
/****************************************************/
/* distribute neighboring nodes base on distance */
/****************************************************/
distribute_neighbors(node+offset, NETWORK_SIZE, &node[i]);
}
}
void place_nodes(node_type *node, int node_num, int grid_size, int placement, int seed)
{
/*********************************************/
/* reinitializes the random number generator */
/*********************************************/
random_reset();
/********************************************************************/
/* First thing first, generating the (x,y) coordinate for each node */
/********************************************************************/
switch (placement)
{
case RANDOM_UNIFORM:
random_placement(node, node_num, grid_size, seed);
break;
default:
fprintf(stderr, "place_nodes: placement method %d not supported!\n", placement);
exit(-1);
}
}
bool game_start(int skill,network_reply_join_remotes *remotes,char *err_str)
{
// pause time
game_time_pause_start();
// reset random numbers
random_reset();
// start progress
console_add_system("Starting Game");
progress_initialize("Starting");
progress_draw(0);
// start server
if (!server_game_start("Game",skill,remotes,err_str)) {
return(FALSE);
}
// start view
view_game_start();
// game in running state
server.game_open=TRUE;
server.state=gs_running;
game_time_pause_end();
return(TRUE);
}
void generate_degrees(node_type *node, int node_num, int degree_one, int seed)
{
#define DEBUG_generate_degrees
int i;
int degree, nodes, edges = 0, F;
float t, C_t;
int node_num_no1, degree_two = 0, rank;
float D_FRAC[19], base;
float ccdfIdeal;
float ccdfActual;
float diff;
int numNodesToAdd;
float ccdfSlope;
/* calculate what month (how many months since nov. '97) */
/* corresponds to this topology of size node_num. */
t = log((float)node_num/(float)P00)/s0;
/* fprintf(stderr,"MONTH = %f\n", t); */
/* using t calculated above, compute the exponent of the ccdf power law */
ccdfSlope = (a * t) + b;
/********************************************/
/* reinitialize the random number generator */
/********************************************/
random_reset();
/***************************/
/* generate degree 1 nodes */
/***************************/
node_num_no1 = node_num - degree_one;
nodes = 0;
for (i=node_num-1; i>=node_num_no1; --i)
{
node[i].nid = i;
node[i].degree = 1;
node[i].free_degree = 1;
}
nodes += degree_one;
// for each degree see if we need to add any of it to obtain the appropriate value on the ccdf
degree = 2;
while (nodes <= node_num && degree < node_num)
{
// this is where we should be at
ccdfIdeal = exp(c) * pow((float)degree,ccdfSlope);
// this is were we are before adding nodes of this degree
ccdfActual = (1.0 - ((float)nodes/(float)node_num));
// calc how many nodes of this degree we need to add to get the ccdf right
diff = ccdfActual - ccdfIdeal;
//fprintf(stderr,"%f %f %f\n",ccdfIdeal,ccdfActual,diff);
if (diff * (float)node_num > 1.0) // we actually need to add a node at this degree
{
numNodesToAdd = (int)(diff * (float)node_num);
for (i = node_num - nodes-1; i >= node_num - nodes - numNodesToAdd; --i)
{
//fprintf(stderr, "- %d %d\n", degree,i);
node[i].nid = i;
node[i].degree = degree;
node[i].free_degree = degree;
}
nodes += numNodesToAdd;
}
++degree;
}
/* use the degree-rank relationship to generate the top 3 degrees */
for(i=0; i<3; ++i)
{
node[i].nid = i;
rank = i + 1;
node[i].degree = pow((float)(rank), R)*exp(q)*pow(((float)node_num/(float)P00), (p/s0));
node[i].free_degree = node[i].degree;
//fprintf(stderr,"* %d\n",node[i].degree);
}
qsort(node, node_num, sizeof(node_type), degree_compare);
#ifdef DEBUG_generate_degrees
fprintf(my_stderr, "node[0].degree = %d\n", node[0].degree);
#endif /* DEBUG_generate_degrees */
/************************************/
/* the sum of node degrees can't be */
/* odd -- edges come in pairs */
/************************************/
for(i=0,edges=0;i<node_num;++i)
edges += node[i].degree;
if ( edges % 2 == 1 )
{
node[0].degree++;
node[0].free_degree++;
}
for (i=0; i<node_num; ++i)
node[i].nid = i;
}
void generate_degrees1(node_type *node, int node_num, int degree_one, int seed)
{
#define DEBUG_generate_degrees
int i;
int edges, percent;
float F;
percent = (int) ((float)node_num*DR_Frac);
degree_one = 0;
/********************************************/
/* reinitialize the random number generator */
/********************************************/
random_reset();
/***********************************/
/* generate nodes of all degrees */
/***********************************/
edges = 0;
for (i=0; i<node_num; ++i)
{
F = random_uniform_real(seed, 0.0, .999999);
node[i].nid = i;
node[i].degree = (int) pow( 1.0/(1.0 - F), (1.0/(-O-1)) );
node[i].free_degree = node[i].degree;
if (node[i].degree == 1)
degree_one++;
if (node[i].degree == 0 )
--i; /* ignore degree 0 */
else
edges += node[i].degree;
}
qsort(node, node_num, sizeof(node_type), degree_compare);
/*********************************************/
/* fix the top ``percent'' degrees according */
/* to the degree vs. rank power law */
/*********************************************/
for (i=0; i < percent; ++i)
{
edges -= node[i].degree;
node[i].degree = pow((float)(i+1), R)*exp(q)*pow(((float)node_num/(float)P00), (p/s0));
node[i].free_degree = node[i].degree;
edges += node[i].degree;
}
#ifdef DEBUG_generate_degrees
fprintf(my_stderr, "node[0].degree = %d\n", node[0].degree);
#endif /* DEBUG_generate_degrees */
/************************************/
/* the sum of node degrees can't be */
/* odd -- edges come in pairs */
/************************************/
if ( edges % 2 == 1 )
{
node[0].degree++;
node[0].free_degree++;
}
/*#ifdef DEBUG_generate_degrees
for (i=0; i<node_num; ++i)
fprintf(my_stderr, "%d\t%d\t%d\n", node[i].nid, node[i].degree, node[i].free_degree);
#endif DEBUG_generate_degrees*/
#ifdef DEBUG_generate_degrees
fprintf(stderr, "generate_degrees: degree_one = %d\n", degree_one);
#endif /* DEBUG_generate_degrees */
}
void random_connection(node_type *node, int node_num, node_type *n2ep, int avg_degree, int seed)
{
int i, j;
int *G, *L, G_num, L_num, g, l, links;
/*********************************************/
/* reinitializes the random number generator */
/*********************************************/
random_reset();
/***********************************************/
/* allocate the nnp array of size ``node_num'' */
/***********************************************/
for (i=0; i<node_num; ++i)
{
node[i].nnp = (node_type **)malloc(sizeof(node_type *)*node_num);
if (!node[i].nnp)
{
fprintf(stderr, "random_connection: no memory for node[%d].nnp (%d bytes)!\n", i, (int)sizeof(node_type *)*node_num);
exit(-1);
}
for (j=0; j<node_num; ++j)
node[i].nnp[j] = 0;
}
L = (int *)malloc(sizeof(int)*node_num);
if (!L)
{
fprintf(stderr, "random_connection: no memory for L (%d bytes)!\n", (int)sizeof(int)*node_num);
exit(-1);
}
G = (int *)malloc(sizeof(int)*node_num);
if (!G)
{
fprintf(stderr, "random_connection: no memory for G (%d bytes)!\n", (int)sizeof(int)*node_num);
exit(-1);
}
G[0] = 0;
G_num = 1;
L_num = node_num - 1;
for (i=1; i<node_num; ++i)
L[i-1] = i;
/************************************************************/
/* chain the expanded nodes together to ensure connectivity */
/************************************************************/
for (i=1; i<node_num; ++i)
{
g = random_uniform_int(seed, 0, G_num-1);
node[G[g]].nnp[node[G[g]].degree] = &node[L[0]];
++(node[G[g]].degree);
node[L[0]].nnp[node[L[0]].degree] = &node[G[g]];
++(node[L[0]].degree);
for (j=0; j<L_num-1; ++j)
L[j] = L[j+1];
++G_num;
--L_num;
}
/***********************************************/
/* chain the node to be expanded with the rest */
/***********************************************/
g = random_uniform_int(seed, 0, G_num-1);
n2ep->nnp[n2ep->degree] = &node[g];
++(n2ep->degree);
node[g].nnp[node[g].degree] = n2ep;
++(node[g].degree);
/***************************************/
/* fill the remaining degrees randomly */
/***************************************/
links = node_num * avg_degree / 2 - (node_num - 1);
i = 0;
while (i<links)
{
g = random_uniform_int(seed, 0, node_num-1);
l = random_uniform_int(seed, 0, node_num-1);
if (g == l)
continue;
if ( g!=node_num && l!=node_num)
{
for(j=0; j<node[g].degree; ++j)
if (&node[l] == node[g].nnp[j])
break;
if ( j == node[g].degree )
{
node[g].nnp[node[g].degree] = &node[l];
++(node[g].degree);
node[l].nnp[node[l].degree] = &node[g];
++(node[l].degree);
++i;
}
}
else if ( g==node_num)
{
for(j=0; j<node[l].degree; ++j)
if ((n2ep = node[l].nnp[j]))
break;
if ( j == node[l].degree )
{
n2ep->nnp[n2ep->degree] = &node[l];
++(n2ep->degree);
node[l].nnp[node[l].degree] = n2ep;
++(node[l].degree);
++i;
}
}
else if ( l==node_num)
{
for(j=0; j<node[g].degree; ++j)
if ((n2ep = node[g].nnp[j]))
break;
if ( j == node[g].degree )
{
n2ep->nnp[n2ep->degree] = &node[g];
++(n2ep->degree);
node[g].nnp[node[g].degree] = n2ep;
++(node[g].degree);
++i;
}
}
}
free(G);
free(L);
}
int main(int argc, char **argv)
{
int node_num;
int grid_size = 10000;
int degree_one = 0;
int placement = 0;
int expansion = 0;
int seed = 0;
int ch;
int print_version = 0;
float frac = 0.0;
node_type *node;
my_stderr = stderr;
/**************************************/
/* getopt the command line arguments */
/**************************************/
if (argc == 1)
{
usage();
exit(-1);
}
while ((ch = getopt(argc, argv, "d:f:p:n:s:Vvh")) != -1)
{
switch (ch)
{
case 'd':
frac = atof(optarg);
break;
case 'f':
my_stderr = fopen(optarg, "w");
if (!my_stderr)
{
fprintf(stderr, "unable to open \"%s\" to output debugging info!\n", optarg);
exit(-1);
}
break;
case 'p':
grid_size = atoi(optarg);
break;
case 'n':
node_num = atoi(optarg);
break;
case 's':
seed = atoi(optarg) % 64;
break;
case 'V':
case 'v':
print_version = 1;
break;
case 'h':
default:
usage();
exit(-1);
}
}
if ( print_version )
{
printf("Inet %s\n", VERSION);
exit(0);
}
//if ( node_num < 3037 )
if ( node_num < 10 )
{
//fprintf(stderr, "Error! the number of nodes must be no less than 3037!\n");
fprintf(stderr, "Error! the number of nodes must be no less than 10!\n");
exit(-1);
}
/****************************************************/
/* the default is computed by a linear relationship */
/****************************************************/
degree_one = (int)((float)node_num * frac);
fprintf(stderr, "1 degree_one : %d\n", degree_one);
if (degree_one == 0)
degree_one = DEGREE_1_SLOPE * node_num + DEGREE_1_INTERCEPT;
fprintf(stderr, "2 degree_one : %d\n", degree_one);
/*******************************************/
/* initializes the random number generator */
/*******************************************/
random_reset();
/*******************/
/* allocate memory */
/*******************/
node = (node_type *)malloc(sizeof(node_type) * node_num);
if (!node)
{
fprintf(stderr, "no enough memory for node array (%d bytes needed)!\n", sizeof(node_type) * node_num);
exit(-1);
}
/*****************************/
/* go ahead, make a topology */
/*****************************/
generate_degrees(node, node_num, degree_one, seed);
place_nodes(node, node_num, grid_size, placement, seed);
connect_nodes(node, node_num, seed);
generate_output(node, node_num);
if (my_stderr != stderr)
{
fclose(my_stderr);
}
}