コード例 #1
0
ファイル: extractl1.c プロジェクト: j2s2/netmagis
void mark_ifaces (int termif)
{
    struct node *n, *peer ;

    for (n = mobj_head (nodemobj) ; n != NULL ; n = n->next)
    {
	if (n->nodetype == NT_L1 && ! MK_ISSET (n, MK_IFACE))
	{
	    peer = get_neighbour (n, NT_L1) ;
	    if (termif)
	    {
		/* we don't want terminal interfaces */
		if (peer == NULL)
		    MK_SET (n, MK_IFACE) ;
	    }
	    else
	    {
		/* we don't want backbone interfaces */
		if (peer != NULL)
		{
		    MK_SET (n, MK_IFACE) ;
		    MK_SET (peer, MK_IFACE) ;		/* optimization */
		}
	    }
	}
    }
}
コード例 #2
0
ファイル: extractl3.c プロジェクト: j2s2/netmagis
int get_l3tol1 (FILE *fp, struct node *n, l3tol1_t *tab, int max)
{
    struct linklist *ll ;
    int idx ;

    /*
     * Search for routing instance if any
     */

    tab [0].r = get_neighbour (n, NT_ROUTER) ;
    idx = 0 ;

    for (ll = n->linklist ; ll != NULL ; ll = ll->next)
    {
	struct node *p ;

	p = getlinkpeer (ll->link, n) ;
	if (p->nodetype == NT_L2)
	{
	    struct node *m ;

	    for (m = mobj_head (nodemobj) ; m != NULL ; m = m->next)
		MK_CLEAR (m, MK_OUTPUTLINK) ;

	    idx = get_l3tol1_L2 (fp, p, tab, max, idx) ;
	}
    }
    return idx ;
}
コード例 #3
0
ファイル: LFeatures.c プロジェクト: Justmitya/Lifeline
int image_connected_components(LImage* image)
{
	int n = image->size;
	int number_connected_components = 0;
	for(int i = 0; i < n; ++i)
	{
		for(int j = 0; j < n; ++j)
  		{
  			if(image->grid[i*n+j].type == 1 && image->grid[i*n+j].componentNum == 0)
  			{
  				number_connected_components++;
  				image->grid[i*n+j].componentNum = number_connected_components;
  				for(int x = 0; x < n * n / 4; ++x)
  				{
	  				for(int i = 0; i < n; ++i)
					{
						for(int j = 0; j < n; ++j)
	  					{
	  						if(image->grid[i*n+j].enabled && image->grid[i*n+j].componentNum == 0)
	  						{
	  							for(int k = 0; k < 8; k++)
	  							{
	  								if(image->grid[get_neighbour(i, j, k, n)].componentNum == number_connected_components) image->grid[i*n+j].componentNum = number_connected_components;
	  							}
	  						}
	  					}
	  				}
	  			}
  			}
  		}
	}
	return number_connected_components;
	
}
コード例 #4
0
ファイル: transition_paint.cpp プロジェクト: ejrh/hex
bool TransitionPaintExecution::apply_transition(const std::vector<int>& dirs, const std::vector<int>& frame_nums) {

    for (auto dir_iter = dirs.begin(); dir_iter != dirs.end(); dir_iter++) {
        Point neighbour_pos = get_neighbour(tile_pos, *dir_iter);
        if (!game->level.contains(neighbour_pos)) {
            return false;
        }
        TileViewDef::pointer neighbour_def = view->level_view.tile_views[neighbour_pos].view_def;
        if (!neighbour_def) {
            return false;
        }

        if (!boost::regex_match(static_cast<std::string>(neighbour_def->name), pattern_re)) {
            return false;
        }
    }

    if (frame_nums.empty())
        return false;

    int variation = get("tile_variation");
    int r = variation % frame_nums.size();
    paint_frame(frame_nums[r]);

    return true;
}
コード例 #5
0
ファイル: LFeatures.c プロジェクト: Justmitya/Lifeline
int image_points_curvature(LImage* image)
{
	int n = image->size;
	for(int i = 0; i < n; ++i)
	{
		for(int j = 0; j < n; ++j)
		{
			int count = image_counter(image, i, j, n);
			if(image->grid[i*n+j].enabled && count == 2)
			{
				for(int k = 0; k < 8; k++)
	  			{
	  				if(image->grid[get_neighbour(i, j, k, n)].enabled)
	  				{
	  					if(image->grid[get_neighbour(i, j, (k + 3) % 8, n)].enabled) image->grid[i*n+j].curvature = 1;
	  					if(image->grid[get_neighbour(i, j, (k - 3) % 8, n)].enabled) image->grid[i*n+j].curvature = 1;
	  					if(image->grid[get_neighbour(i, j, (k + 2) % 8, n)].enabled) image->grid[i*n+j].curvature = 2;
	  					if(image->grid[get_neighbour(i, j, (k - 2) % 8, n)].enabled) image->grid[i*n+j].curvature = 2;
	  					if(image->grid[get_neighbour(i, j, (k + 1) % 8, n)].enabled) image->grid[i*n+j].curvature = 3;
	  					if(image->grid[get_neighbour(i, j, (k - 1) % 8, n)].enabled) image->grid[i*n+j].curvature = 3;
	  				}
	  			}
			}
		}
	}
	return 0;
}
コード例 #6
0
ファイル: bcube_topology.cpp プロジェクト: T3Fei/htsimMPTCP
vector<route_t*>* BCubeTopology::get_paths(int src, int dest) {
    vector<route_t*>* paths = new vector<route_t*>();

    for (int i=K; i>=0; i--) {
        if (addresses[src][i]!=addresses[dest][i])
            paths->push_back(dc_routing(src,dest,i));
        else
            paths->push_back(alt_dc_routing(src,dest,i,get_neighbour(src,i)));
    }
    return paths;
}
コード例 #7
0
ファイル: LFeatures.c プロジェクト: Justmitya/Lifeline
int image_line_type(LImage* image)
{
	int n = image->size;
	int diagonal_number = 0;
	for(int i = 0; i < n; ++i)
	{
		for(int j = 0; j < n; ++j)
		{
			int count = image_counter(image, i, j, n);
			if(image->grid[i*n+j].enabled && count == 2)
			{
				if(image->grid[get_neighbour(i, j, 0, n)].enabled && image->grid[get_neighbour(i, j, 4, n)].enabled)
				{
					diagonal_number++;
					image->grid[i*n+j].diagonalNum = diagonal_number;
					for(int x = 0; x < sqrt(2) * n; ++x)
	  				{
		  				for(int i = 0; i < n; ++i)
						{
							for(int j = 0; j < n; ++j)
		  					{
		  						int countt = image_counter(image, i, j, n);
		  						if(image->grid[i*n+j].enabled && image->grid[i*n+j].diagonalNum == 0 && countt == 2)
		  						{
		  							for(int k = 0; k < 8; k++)
		  							{
		  								if(image->grid[get_neighbour(i, j, k, n)].diagonalNum == diagonal_number && image->grid[get_neighbour(i, j, (k + 4) % 8, n)].enabled) image->grid[i*n+j].diagonalNum = diagonal_number;
		  							}
		  						}
		  					}
		  				}
		  			}
				}
				if(image->grid[get_neighbour(i, j, 2, n)].enabled && image->grid[get_neighbour(i, j, 6, n)].enabled)
				{
					diagonal_number++;
					image->grid[i*n+j].diagonalNum = diagonal_number;
					for(int x = 0; x < sqrt(2) * n; ++x)
	  				{
		  				for(int i = 0; i < n; ++i)
						{
							for(int j = 0; j < n; ++j)
		  					{
		  						int countt = image_counter(image, i, j, n);
		  						if(image->grid[i*n+j].enabled && image->grid[i*n+j].diagonalNum == 0 && countt == 2)
		  						{
		  							for(int k = 0; k < 8; k++)
		  							{
		  								if(image->grid[get_neighbour(i, j, k, n)].diagonalNum == diagonal_number && image->grid[get_neighbour(i, j, (k + 4) % 8, n)].enabled) image->grid[i*n+j].diagonalNum = diagonal_number;
		  							}
		  						}
		  					}
		  				}
		  			}
				}
			}
		}
	}
	return 0;
}
コード例 #8
0
ファイル: extractcoll.c プロジェクト: j2s2/netmagis
void output_collect_L2 (FILE *fp, struct node *L2node)
{
    struct node *L1node ;

    L1node = get_neighbour (L2node, NT_L1) ;
    if (L1node)
    {
	/*
	 * L2 is a collect point
	 */

	if (L2node->u.l2.stat != NULL)
	{
	    fprintf (fp, "trafic %s %s %s ",
			    L2node->u.l2.stat,
			    L1node->eq->name,
			    L1node->eq->snmp
	    	) ;
	    /* 
	     * Logical interface name present
	     */
	    if(L2node->u.l2.ifname != NULL && strcmp(L2node->u.l2.ifname, "-"))
	    {
	    	/* trafic <id collect> <eq> <comm> <logical iface> - */
	    	fprintf (fp, "%s -\n", L2node->u.l2.ifname) ;
	    }
	    else
	    {
	    	/* trafic <id collect> <eq> <comm> <phys iface> vlan */
		fprintf (fp, "%s %d\n", L1node->u.l1.ifname, L2node->u.l2.vlan) ;
	    }

	    L2node->mark = 0 ;
	}

	/*
	 * L1 is a collect point and a native Ethernet (not-802.1Q) interface
	 */

	if (L1node->u.l1.stat && L1node->u.l1.l1type == L1T_ETHER)
	    output_collect_L1 (fp, L1node) ;
    }
}
コード例 #9
0
ファイル: sel.c プロジェクト: sathieu/netmagis
static void sel_mark_net (ip_t *addr)
{
    struct node *n, *l2node ;
    struct network *net ;

    for (n = mobj_head (nodemobj) ; n != NULL ; n = n->next)
    {
	if (n->nodetype == NT_L3 && ip_match (&n->u.l3.addr, addr, 1))
	{
	    MK_SELECT (n) ;
	    l2node = get_neighbour (n, NT_L2) ;
	    if (l2node != NULL)
		transport_vlan_on_L2 (l2node, l2node->u.l2.vlan) ;
	}
    }

    for (net = mobj_head (netmobj) ; net != NULL ; net = net->next)
	if (ip_match (&net->addr, addr, 1))
	    MK_SELECT (net) ;

    for (n = mobj_head (nodemobj) ; n != NULL ; n = n->next)
	if (MK_ISSET (n, MK_L2TRANSPORT))
	    MK_SELECT (n) ;
}
コード例 #10
0
ファイル: battle.cpp プロジェクト: ejrh/hex
void Battle::set_up_participants() {
    BOOST_LOG_TRIVIAL(trace) << "Setting up battle participants";

    UnitStack::pointer attacker = game->level.tiles[attacking_point].stack;

    for (int dir = 0; dir < 7; dir++) {
        UnitStack::pointer stack;

        Point stack_point = get_neighbour(target_point, dir);
        if (game->level.contains(stack_point)) {
            stack = game->level.tiles[stack_point].stack;
        }

        if (stack && stack->owner == attacker->owner) {
            stacks[dir] = stack;
            stack_sides[dir] = Attacker;
        } else if (stack && stack->owner != attacker->owner) {
            stacks[dir] = stack;
            stack_sides[dir] = Defender;
        } else  {
            stacks[dir] = UnitStack::pointer();
            stack_sides[dir] = None;
        }
    }

    for (int dir = 0; dir < 7; dir++) {
        if (stacks[dir]) {
            BOOST_LOG_TRIVIAL(trace) << "Stack " << dir << ": " << stacks[dir]->id;
            for (unsigned int i = 0; i < stacks[dir]->units.size(); i++) {
                int participant_id = participants.size();
                participants.push_back(Participant(participant_id, stack_sides[dir], dir, stacks[dir], i));
                BOOST_LOG_TRIVIAL(trace) << "Participant: " << participants[participant_id];
            }
        }
    }
}
コード例 #11
0
ファイル: extractcoll.c プロジェクト: j2s2/netmagis
void output_portmac (FILE *fp, struct node *bridgenode)
{
    struct linklist *ll ;
    struct node *n ;
    vlanset_t vlanset;
    vlan_t v;
    int done = 0;
    
    /* get all VLAN ids */
    vlan_zero(vlanset);
    for (ll = bridgenode->linklist ; ll != NULL ; ll = ll->next)
    {
    	struct link *l ; struct node *other ;

	l = ll->link ;
	other = getlinkpeer (l, bridgenode) ;
	if(other->nodetype == NT_L2)
		vlan_set (vlanset, other->u.l2.vlan);
    }

    /* for each VLAN found */
    for (v = 0 ; v < MAXVLAN ; v++)
    {
    	if(vlan_isset (vlanset, v)) 
	{
	    /* process each L2 node */
	    for (ll = bridgenode->linklist ; ll != NULL ; ll = ll->next)
	    {
		struct link *l ;
		struct node *L2node ;

		l = ll->link ;
		L2node = getlinkpeer (l, bridgenode) ;

		/* examine associated L1 */
		if(L2node->nodetype == NT_L2)
		{
		    struct node *L1node ;

		    L1node = get_neighbour (L2node, NT_L1) ;

		    /* only edge L1 interface */
		    if(L1node != NULL
			    && MK_ISSELECTED (L1node)
			    && !MK_ISSET(L1node, MK_PORTMAC)
			    && strcmp (L1node->u.l1.link, EXTLINK) == 0)
		    {
			    char *ifname = L1node->u.l1.ifname;

			    if(!done)
			    {
				/* portmac <id_collect> <eq> <comm> <eqtype> <iflist> <vlan> */
				fprintf (fp, "portmac P%s.%d %s %s %s %s",
					    bridgenode->eq->name,
					    v,
					    bridgenode->eq->name,
					    bridgenode->eq->snmp,
					    bridgenode->eq->type,
					    ifname
					) ;

				done = 1 ;
			    }
			    else
			    {
				fprintf(fp, ",%s", ifname) ;
			    }

			    /* mark node */
			    MK_SET(L1node, MK_PORTMAC) ;
		    }
		}
	    }

	    if(done)
	    {
		/* output vlan id */
	        fprintf(fp, " %d\n", v) ;
	    	done = 0 ;
	    }


	    /* clear mark */
	    for (n = mobj_head (nodemobj) ; n != NULL ; n = n->next)
	    {
		if(n->nodetype == NT_L1)
		    MK_CLEAR (n, MK_PORTMAC) ;
	    }

	}
    }
}
コード例 #12
0
ファイル: LFeatures.c プロジェクト: Justmitya/Lifeline
int image_branch_points(LImage* image)
{
	int n = image->size;
	//First mark all pixels with more than 2 neighbors with a dummy variable
	for(int i = 0; i < n; ++i)
    {
    	for(int j = 0; j < n; ++j)
      	{
			int count = image_counter(image, i, j, n);
			if(image->grid[i*n+j].enabled && count > 2)
			{
				image->grid[i*n+j].dummy = 1;
			}else{
				image->grid[i*n+j].dummy = 0;
			}
		}
	}
	for(int i = 0; i < n; ++i)
    {
    	for(int j = 0; j < n; ++j)
      	{
      		int count_dummy = image_counter_dummy(image, i, j, n);
      		if(image->grid[i*n+j].dummy == 1 && count_dummy > 1)
      		{
      			for(int k = 0; k < 16; k++)
      			{
  					if(image->grid[get_neighbour(i, j, k, n)].dummy == 1 && image->grid[get_neighbour(i, j, k + 2, n)].dummy == 1) 
  					{
  						image->grid[get_neighbour(i, j, k, n)].dummy = 0;
  						image->grid[get_neighbour(i, j, k + 2, n)].dummy = 0;
  						image->grid[get_neighbour(i, j, k + 1, n)].enabled = 1;
  						image->grid[get_neighbour(i, j, k + 1, n)].type = 2;
  						image->grid[i*n+j].dummy = 0;
  					}

      			}     			
      		}
      	}
    }
    for(int i = 0; i < n; ++i)
    {
    	for(int j = 0; j < n; ++j)
      	{
      		if(image->grid[i*n+j].type == 2)
      		{
      			for(int k = 0; k < 8; k++)
      			{
      				if(image->grid[get_neighbour(i, j, k, n)].dummy == 1) image->grid[get_neighbour(i, j, k, n)].dummy = 0;
      				if(image->grid[get_neighbour(i, j, k, n)].type == 2) image->grid[get_neighbour(i, j, k, n)].type = 0;
      			}
      		}
      	} 	
    }
    for(int i = 0; i < n; ++i)
    {
    	for(int j = 0; j < n; ++j)
      	{
      		if(image->grid[i*n+j].dummy == 1) 
      		{
      			image->grid[i*n+j].dummy = 0;
      			image->grid[i*n+j].type = 2;
      		}
      	}
    }
    for(int i = 0; i < n; ++i)
    {
    	for(int j = 0; j < n; ++j)
      	{
      		if(image->grid[i*n+j].type == 2)
      		{
      			for(int k = 0; k < 8; k++)
      			{
      				if(image->grid[get_neighbour(i, j, k, n)].type == 2) image->grid[get_neighbour(i, j, k, n)].type = 0;
      			}
      		}
      	}
    }
	return 0;
}
コード例 #13
0
ファイル: LFeatures.c プロジェクト: Justmitya/Lifeline
int image_counter_dummy(LImage* image, int i, int j, int n)
{
	int count = 0;
	for(int k = 0; k < 8; ++k) if(image->grid[get_neighbour(i,j,k,n)].dummy == 1) count++;
	return count;
}
コード例 #14
0
ファイル: LFeatures.c プロジェクト: Justmitya/Lifeline
int image_thin(LImage* image)
{
	int n = image->size;
    for(int i = 0; i < n; ++i)
    {
    	for(int j = 0; j < n; ++j)
      	{
			if(image->grid[i*n+j].enabled)
			{
				//We want to check if we can remove this pixel
				//We have to check it the surrounding 8 pixels are
				//still connected when we remove this pixel			
					
				int count = image_counter(image, i, j, n);
				if(count >= 7) //With 7 or more surrounding pixels they will always be connected
				{
					image->grid[i*n+j].enabled = 0; //So we can remove the center pixel
				}
				else if(count >= 2)
				{
					//Now we want to check if the surrounding pixels are connected
					//We find the first black pixel, then from there search for the
					//first white pixel that might disconnect it
					int firstBlack = -1;
					int state = 0;
					int disconnections = 0;
					for(int k = 0; k < 16; k++)
					{
						if(state == 0) //Searching for black pixel
						{
							if(image->grid[get_neighbour(i, j, k, n)].enabled) 
							{
								if( firstBlack == -1 ) firstBlack = k;
								state = 1;
							}
						}
						else if(state == 1) //Black pixel was found, keep following untill white
						{
							if(!image->grid[get_neighbour(i, j, k, n)].enabled) state = 2;	
						}
						else if(state == 2) //White pixel found. Did this white pixel disconnect the black pixels?
						{
							//Check the pixel after the white pixel
							if(image->grid[get_neighbour(i, j, k, n)].enabled)
							{
								//There was a black pixel after the white pixel
								//If the white pixel was at a corner, then it
								//is not disconnected. If the white pixel is in the middle
								//then it is disconnected
								if(k%2 == 1)
									state = 1;
								else 
								{
									state = 0;
									disconnections++;
								}
							}
							else //A second white pixel. Then yes this was a disconnection
							{
								state = 0;
								disconnections++;
								
							}
						}
						//Check if we already went a full round
						if( k >= 8 ){
							if( (k-8) >= firstBlack ) break;						
						}
					}
					//If the 8 pixels have one disconnection or less
					//Then they are still connected so we can remove this pixel
					if(disconnections <= 1)
					{
						image->grid[i*n+j].enabled = 0;
					}
				}
			}
		}
	}
	return 0;	
}
コード例 #15
0
ファイル: extractl3.c プロジェクト: j2s2/netmagis
int main (int argc, char *argv [])
{
    int i ;
    struct node *n ;
    struct eq *eq ;
    ip_t cidr ;
    int c, err ;
    char *prog, *errstr ;

    prog = argv [0] ;
    err = 0 ;

    sel_init () ;

    while ((c = getopt (argc, argv, "an:e:E:tv:m")) != -1)
    {
	switch (c)
	{
	    case 'a' :
	    case 'n' :
	    case 'e' :
	    case 'E' :
	    case 't' :
	    case 'v' :
	    case 'm' :
		if ((errstr = sel_register (c, optarg)) != NULL)
		{
		    fprintf (stderr, "%s: %s\n", prog, errstr) ;
		    err = 1 ;
		}
		break ;
	    case '?' :
	    default :
		usage (prog) ;
	}
    }

    if (err)
	exit (1) ;

    argc -= optind ;
    argv += optind ;

    if (argc == 0)
	usage (prog) ;

    /*
     * Read the graph and select subgraph
     */

    bin_read (stdin, mobjlist) ;
    sel_mark () ;

    /*
     * First pass : mark all L3 nodes matching CIDR arguments
     */

    for (i = 0 ; i < argc ; i++)
    {
	if (! ip_pton (argv [i], &cidr))
	{
	    fprintf (stderr, "%s: Invalid cidr '%s'\n", prog, argv [i]) ;
	    exit (1) ;
	}

	for (n = mobj_head (nodemobj) ; n != NULL ; n = n->next)
	    if (n->nodetype == NT_L3 && ip_match (&n->u.l3.addr, &cidr, 0))
		MK_SET (n, MK_IPMATCH) ;
    }

    /*
     * Output selection arguments
     */

    fprintf (stdout, "selection") ;
    for (i = 0 ; i < argc ; i++)
	fprintf (stdout, " %s", argv [i]) ;
    fprintf (stdout, "\n") ;

    /*
     * Second pass : identify all routing instances connected to those
     * L3 nodes we have marked before, and print equipements which are
     * routing instances.
     */

    for (n = mobj_head (nodemobj) ; n != NULL ; n = n->next)
    {
	if (n->nodetype == NT_L3 && MK_ISSET (n, MK_IPMATCH))
	{
	    struct node *r ;

	    MK_SET (n->eq, MK_IPMATCH) ;

	    r = get_neighbour (n, NT_ROUTER) ;
	    if (r != NULL && ! MK_ISSET (r, MK_ISROUTER))
	    {
		MK_SET (n, MK_ISROUTER) ;
		MK_SET (r, MK_ISROUTER) ;
		MK_SET (n->eq, MK_ISROUTER) ;
		if (MK_ISSELECTED (n))
		    fprintf (stdout, "eq %s:%s router\n",
				    n->eq->name, r->u.router.name) ;
	    }
	}
    }

    /*
     * Third pass : print equipements which are not routing instances
     */

    for (eq = mobj_head (eqmobj) ; eq != NULL ; eq = eq->next)
	if (MK_ISSET (eq, MK_IPMATCH) && ! MK_ISSET (eq, MK_ISROUTER))
	    if (MK_ISSELECTED (eq))
		fprintf (stdout, "eq %s host\n", eq->name) ;

    /*
     * Fourth pass : identify broadcast domain for each L3
     */

    for (n = mobj_head (nodemobj) ; n != NULL ; n = n->next)
    {
	if (n->nodetype == NT_L3
				&& MK_ISSET (n, MK_IPMATCH)
				&& ! MK_ISSET (n, MK_PROCESSED))
	    walkl3 (stdout, n) ;
    }

    sel_end () ;
    exit (0) ;
}
コード例 #16
0
ファイル: extractl3.c プロジェクト: j2s2/netmagis
void walkl3 (FILE *fp, struct node *n)
{
    struct node *l2 ;
    struct node *m ;
    char cloudname [MAXCLOUDNAME] ;
    int l1count, l3count ;
    struct node *directl1 [2], *directl3 [2] ;
    int selected ;

    /*
     * Reset all non-L3 nodes
     */

    for (m = mobj_head (nodemobj) ; m != NULL ; m = m->next)
    {
	if (m->nodetype == NT_L3)
	    MK_CLEAR (m, MK_L2TRANSPORT) ;
	else
	{
	    MK_CLEAR (m, MK_L2TRANSPORT) ;
	    MK_CLEAR (m, MK_IPMATCH) ;
	    MK_CLEAR (m, MK_ISROUTER) ;
	    MK_CLEAR (m, MK_VLANTRAVERSAL) ;
	    MK_CLEAR (m, MK_PROCESSED) ;
	}
	vlan_zero (m->vlanset) ;
    }

    l2 = get_neighbour (n, NT_L2) ;
    if (l2 != NULL)
	transport_vlan_on_L2 (l2, l2->u.l2.vlan) ;

    /*
     * All reachable L2 nodes are marked.
     *
     * Count physical interfaces (L1 nodes) to see if this equipement
     * is connected via a direct link to another node, or if this
     * equipement is connected to a broadcast domain.
     *
     * Count marked L1 nodes. If there is only 2 of them, check if
     * linkname matches (if not "X", or EXTLINK).
     */

    l1count = 0 ;
    l3count = 0 ;

    selected = 0 ;
    for (m = mobj_head (nodemobj) ; m != NULL ; m = m->next)
    {
	if (m->nodetype == NT_L1 && MK_ISSET (m, MK_L2TRANSPORT))
	{
	    if (MK_ISSELECTED (m) || MK_ISSELECTED (m->eq))
		selected = 1 ;

	    if (l1count < 2)
		directl1 [l1count] = m ;
	    l1count++ ;
	}

	if (m->nodetype == NT_L3 && MK_ISSET (m, MK_L2TRANSPORT)
					&& MK_ISSET (m, MK_IPMATCH))
	{
	    if (MK_ISSELECTED (m) || MK_ISSELECTED (m->eq))
		selected = 1 ;

	    if (l3count < 2)
		directl3 [l3count] = m ;
	    l3count++ ;
	}
    }

    if (! selected)
	return ;

    if (l1count == 2 && l3count == 2 &&
		directl1 [0]->u.l1.link == directl1 [1]->u.l1.link)
    {
	/*
	 * This is a direct link between two L3 nodes
	 */

	output_direct (fp, directl3) ;

	MK_SET (directl3 [0], MK_PROCESSED) ;
	MK_SET (directl3 [1], MK_PROCESSED) ;
    }
    else
    {
	/*
	 * This is a cloud
	 */

	for (m = mobj_head (nodemobj) ; m != NULL ; m = m->next)
	{
	    if (m->nodetype == NT_L2 && MK_ISSET (m, MK_L2TRANSPORT))
	    {
		struct linklist *ll ;
		struct node *r ;

		for (ll = m->linklist ; ll != NULL ; ll = ll->next)
		{
		    r = getlinkpeer (ll->link, m) ;
		    if (r->nodetype == NT_L3 && MK_ISSET (r, MK_IPMATCH))
			MK_SET (r, MK_VLANTRAVERSAL) ;
		}
	    }
	}

	/*
	 * Output cloud
	 */

	output_cloud (fp, n, cloudname, sizeof cloudname) ;

	/*
	 * Output links to this cloud
	 */

	for (m = mobj_head (nodemobj) ; m != NULL ; m = m->next)
	{
	    if (m->nodetype == NT_L3 && MK_ISSET (m, MK_VLANTRAVERSAL))
	    {
		output_link (fp, m, cloudname) ;
		MK_CLEAR (m, MK_VLANTRAVERSAL) ;
		MK_SET (m, MK_PROCESSED) ;
	    }
	}
    }
}
コード例 #17
0
ファイル: extractl3.c プロジェクト: j2s2/netmagis
void output_cloud (FILE *fp, struct node *n, char *cloudname, size_t size)
{
    static int cloudno = 0 ;
    struct node *l1node, *l2node ;
    vlanset_t vs ;
    ip_t tabnet [MAXNET] ;
    int ntab ;
    iptext_t addr ;
    int i ;

    cloudno++ ;
    snprintf (cloudname, size, CLOUDFORMAT, cloudno) ;

    fprintf (fp, "cloud %s", cloudname) ;

    /*
     * Reference to the broadcast domain
     * - get the first marked L1 interface
     * - name of equipement of this L1
     * - get the first marked L2 from this L1
     */

    find_interface (&l1node, &l2node) ;
    if (l1node == NULL || l2node == NULL)
    {
	/*
	 * Degenerated case such as an L3 node not connected to the
	 * rest of the world...
	 */
	if (l2node == NULL)
	    l2node = get_neighbour (n, NT_L2) ;

	if (l2node != NULL)
	    fprintf (fp, " {%s %s %d}", l2node->eq->name, "-", l2node->u.l2.vlan) ;
	else
	    fprintf (fp, " {%s %s %d}", "-", "-", 0) ;
    }
    else
	fprintf (fp, " {%s %s %d}",
			    l1node->eq->name, l1node->u.l1.ifname, l2node->u.l2.vlan) ;

    /*
     * Get all vlan used
     */

    traversed_vlans (vs) ;
    fprintf (fp, " {") ;
    print_vlanlist (fp, vs, 1) ;
    fprintf (fp, "}") ;

    /*
     * Get all network CIDR from L3 nodes
     */

    ntab = find_networks (tabnet, NTAB (tabnet)) ;
    fprintf (fp, " {") ;
    for (i = 0 ; i < ntab ; i++)
    {
	if (i != 0)
	    fprintf (fp, " ") ;
	ip_ntop (&tabnet [i], addr, 1) ;
	fprintf (fp, "%s", addr) ;
    }
    fprintf (fp, "}") ;

    fprintf (fp, "\n") ;
}
コード例 #18
0
ファイル: pim_interface.cpp プロジェクト: Distrotech/mrd6
void pim_interface::handle_hello(const sockaddr_in6 *from,
				 pim_hello_message *msg, uint16_t len) {
	m_stats.counter(HelloCount, RX)++;

	/* rejected by configuration */
	if (!conf()->neigh_acl_accepts(from->sin6_addr))
		return;

	uint16_t holdtime = 0;
	bool has_dr_priority = false;
	uint32_t dr_priority = 0;
	bool has_genid = false;
	uint32_t genid = mrd::get_randu32();
	bool has_lan_delay = false;
	uint16_t propdelay = 0, overrinter = 0;
	bool trackbit = false;

	int address_count = 0;
	pim_encoded_unicast_address *addresses = 0;
	int old_address_count = 0;
	pim_encoded_unicast_address *old_addresses = 0;

	int slen = sizeof(pim_hello_message);

	pim_hello_option *opt = msg->options();

	while (slen < len) {
		uint16_t optlen = ntoh(opt->length);

		switch (ntoh(opt->type)) {
		case pim_hello_option::holdtime:
			if (optlen == 2)
				holdtime = ntoh(opt->data16()[0]);
			break;
		case pim_hello_option::lan_prune_delay:
			if (optlen == 4) {
				has_lan_delay = true;
				propdelay = ntoh(opt->data16()[0]);
				overrinter = ntoh(opt->data16()[1]);
				trackbit = (propdelay & 0x8000) != 0;
				propdelay &= 0x7fff;
			}
			break;
		case pim_hello_option::dr_priority:
			if (optlen == 4) {
				has_dr_priority = true;
				dr_priority = ntoh(opt->data32()[0]);
			}
			break;
		case pim_hello_option::genid:
			if (optlen == 4) {
				has_genid = true;
				genid = ntoh(opt->data32()[0]);
			}
			break;
		case pim_hello_option::addrlist:
			if ((optlen % sizeof(pim_encoded_unicast_address)) == 0) {
				address_count = optlen / sizeof(pim_encoded_unicast_address);
				addresses = (pim_encoded_unicast_address *)opt->data();
			}
			break;
		case pim_hello_option::cisco_old_addrlist:
			if ((optlen % sizeof(pim_encoded_unicast_address)) == 0) {
				old_address_count = optlen / sizeof(pim_encoded_unicast_address);
				old_addresses = (pim_encoded_unicast_address *)opt->data();
			}
			break;
		}

		slen += sizeof(pim_hello_option) + optlen;
		opt = opt->next();
	}

	pim_neighbour *neigh;

	if ((neigh = get_neighbour(from->sin6_addr))) {
		if (holdtime == 0) {
			neighbour_timed_out(neigh);
			return;
		}

		if (!neigh->compare_genid(genid)) {
			if (should_log(NORMAL))
				neigh->log().writeline("Had different GenID, forcing timeout.");
			remove_neighbour(neigh, false);
			neigh = 0;
		}
	}

	bool is_new = false;

	if (!neigh) {
		if (!(neigh = allocate_neighbour(from->sin6_addr))) {
			if (should_log(DEBUG))
				log().writeline("Failed to allocate neighbor state.");
			return;
		}

		is_new = true;
	}

	if (!conf()->support_old_cisco_addrlist()) {
		old_addresses = 0;
		old_address_count = 0;
	}

	neigh->update_from_hello(addresses, address_count,
				 old_addresses, old_address_count, holdtime);

	if (has_dr_priority)
		neigh->set_dr_priority(dr_priority);
	if (has_genid)
		neigh->set_genid(genid);
	if (has_lan_delay)
		neigh->set_lan_delay(propdelay, overrinter, trackbit);

	if (is_new)
		found_new_neighbour(neigh);

	check_lan_delay();
	elect_subnet_dr();
}
コード例 #19
0
ファイル: openmp.c プロジェクト: Thundzz/GPU
static void omp_force (sotl_device_t *dev)
{
    struct timeval tv1,tv2;

    sotl_atom_set_t *set = &dev->atom_set;

    gettimeofday(&tv1,NULL);
    int start_ind, end_ind;

    #pragma omp parallel for
    for (unsigned current = 0; current < set->natoms; current++)
    {
        calc_t force[3] = { 0.0, 0.0, 0.0 };
//
//    }
//        /*Version naive*/

//        for (unsigned other = 0; other < set->natoms; other++)
//            if (current != other)
//            {
//                calc_t sq_dist = squared_distance (set, current, other);
//
//                if (sq_dist < LENNARD_SQUARED_CUTOFF)
//                {
//                    calc_t intensity = lennard_jones (sq_dist);
//
//                    force[0] += intensity * (set->pos.x[current] - set->pos.x[other]);
//                    force[1] += intensity * (set->pos.x[set->offset + current] -
//                                             set->pos.x[set->offset + other]);
//                    force[2] += intensity * (set->pos.x[set->offset * 2 + current] -
//                                             set->pos.x[set->offset * 2 + other]);
//                }
//
//            }
        /* Fin version naive */



        /**
          * Version Tri par boites :
          */
        unsigned other;
        int box_id_current = atom_box_calc(dev, current);
        if (is_valid_box(dev, box_id_current))
        {
            for (int i = -1; i<2; i++)
            {
                for (int j = -1; j<2; j++)
                {
                    for (int k = -1; k<2; k++)
                    {
                        int box_id_other = get_neighbour(dev, box_id_current, i, j, k);
                        if (is_valid_box(dev, box_id_other))
                        {
                            start_ind = box_count_cummul[box_id_other];
                            end_ind = box_count_cummul[box_id_other-1];
                            int size = start_ind - end_ind;
                            for (int l = 0; l < size; l++)
                            {
                                other = box_count_cummul[box_id_other]-l-1;
                                if (other != current)
                                {
                                    calc_t sq_dist = squared_distance (set, current, other);
                                    if (sq_dist < LENNARD_SQUARED_CUTOFF)
                                    {
                                        calc_t intensity = lennard_jones (sq_dist);
                                        force[0] += intensity * (set->pos.x[current] - set->pos.x[other]);
                                        force[1] += intensity * (set->pos.x[set->offset + current] -
                                                                 set->pos.x[set->offset + other]);
                                        force[2] += intensity * (set->pos.x[set->offset * 2 + current] -
                                                                 set->pos.x[set->offset * 2 + other]);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        /*Fin version Tri par Boites */


        /** Version Tri par Z :
          */
//        for (unsigned other = current+1; other < set->natoms && ((set->pos.z[other] - set->pos.z[current]) < LENNARD_CUTOFF); other++)
//        {
//            //Now takes the atoms near from current according to the sorted array
//            if (current != other)
//            {
//                calc_t sq_dist = squared_distance (set, current, other);
//
//                if (sq_dist < LENNARD_SQUARED_CUTOFF)
//                {
//                    calc_t intensity = lennard_jones (sq_dist);
//
//                    force[0] += intensity * (set->pos.x[current] - set->pos.x[other]);
//                    force[1] += intensity * (set->pos.x[set->offset + current] -
//                                             set->pos.x[set->offset + other]);
//                    force[2] += intensity * (set->pos.x[set->offset * 2 + current] -
//                                             set->pos.x[set->offset * 2 + other]);
//                }
//            }
//        }
//        for (unsigned other = current; other > 0 && ((set->pos.z[current] - set->pos.z[other-1]) < LENNARD_CUTOFF); other--)
//        {
//            //Now takes the atoms near from current according to the sorted array
//            if (current != other-1)
//            {
//                calc_t sq_dist = squared_distance (set, current, other-1);
//
//                if (sq_dist < LENNARD_SQUARED_CUTOFF)
//                {
//                    calc_t intensity = lennard_jones (sq_dist);
//
//                    force[0] += intensity * (set->pos.x[current] - set->pos.x[other-1]);
//                    force[1] += intensity * (set->pos.x[set->offset + current] -
//                                             set->pos.x[set->offset + other-1]);
//                    force[2] += intensity * (set->pos.x[set->offset * 2 + current] -
//                                             set->pos.x[set->offset * 2 + other-1]);
//                }
//            }
//        }
        /*Fin version Tri par Z */

        set->speed.dx[current] += force[0];
        set->speed.dx[set->offset + current] += force[1];
        set->speed.dx[set->offset * 2 + current] += force[2];
    }

    gettimeofday(&tv2,NULL);
    time_force += (float)TIME_DIFF(tv1,tv2);
}
コード例 #20
0
/**
 * IMPLEMENTATION D'UN RECUIT SIMULÉ 
 *
 * Voisinage : On enlève une station d'une remorque, et on l'insert_best 
 * (ou juste insert) dans une des remorque (sa remorque y compris, sa place
 * peut n'être plus optimale avec d'autres insertions)
 *
 * Energie : 
 *  - Version 0 : Cout de la solution
 *
 * Temperature : 
 *  - Version 0 : Décroissance de la température en T(n+1) = lambda * T(n)
 *   avec lambda = 0.99
 *
 * Solution initiale : La solution la plus bête possible, pour ne pas ensuite
 * être gêné par une solution qui serait trop bonne.
 * 
 * Algorithme :
 *  s := s0     // solution
 *  e := E(s)   // energie
 *  k := 0      // Iteration
 *  tant que k < kmax et e > emax
 *    sn := voisin(s)
 *    en := E(sn)
 *    si en < e ou aléatoire() < P(en - e, temp(k/kmax)) alors
 *      s := sn; e := en
 *    k := k + 1
 *  retourne s
 * 
 * @return Si une solution a pu être trouvée
 */
bool AnnealingSolver::solve() {
  if (log2()) {
      cout << "\n---AnnealingSolver::solve START instance: "
           << inst->name << " de taille "
           << inst->stations->size() << "\n";
  }

  // Seed initialisation
  srand (time(NULL));
  // ((double) rand() / (RAND_MAX)) // double btwn 0 and 1

  // Arguments
  Options* args = Options::args;
  const string sinserter = args->station_inserter;
  const string rchooser = args->remorque_chooser;
  int itermax = args->itermax;
  int recuit_variant = args->recuit_variant;
  double temp_init = args->temp_init;
  double lambda = args->lambda;
  int size_palier = args->size_palier;

  // Par défaut (-1) on ne fait qu'une seule itération
  itermax =  itermax == -1 ? 1 : itermax;
  temp_init =  temp_init == 10000.0 ? 10000.0 : temp_init;
  lambda =  lambda == 0.99 ? 0.99 : lambda;
  size_palier =  size_palier == 10 ? 10 : size_palier;

  double taux_acceptation_min = 0.000001;
  double taux_acceptation = 1;
  double nb_accepted = 0;

  // Recuit informations
  double temperature = temp_init;   // Initial temperature (default)
  double energy_max = 0;  // Energy maximum of acceptation
  double energy;          // Energy
  int k = 0;              // Iteration
  Solution* neighbour = new Solution(inst); // Intermediate solution

  // INITIAL SOLUTION (Stupid)
  Solution* sol = new Solution(inst);
  get_initial_solution(sol);
  energy = get_energy(sol);
  logn2("AnnealingSolver::Cost of the initial solution = "+sol->get_cost_string());
  logn2("AnnealingSolver::Energy of the initial solution = "+to_string(energy));

  // Result File 
  ofstream energy_file;
  energy_file.open("energy.csv",ios::app);
  energy_file << "\n"<< inst->name << ";" << time(NULL) << "\nEnergy;";

  ofstream temp_file;
  temp_file.open("temp.csv",ios::app);
  temp_file << "\n"<< inst->name << ";" << time(NULL) << "\nTemperature;";

  ofstream taux_acceptation_file;
  taux_acceptation_file.open("taux_acceptation.csv",ios::app);
  taux_acceptation_file << "\n"<< inst->name << ";" << time(NULL) << "\nTaux d'acceptation;";

  Solution* best_sol = new Solution(inst);
  best_sol->copy(sol);

  // RECUIT
  while (k < itermax && 
         energy > energy_max && 
         taux_acceptation > taux_acceptation_min) 
  {
    logn3("AnnealingSolver:: Iteration number "+to_string(k));

    energy_file << energy << ";";    
    temp_file << temperature << ";";    
    taux_acceptation_file << taux_acceptation << ";";    

    // Updating Temperature
    if (k % size_palier == 0)
      temperature = get_next_temperature(temperature,lambda);
    logn3("AnnealingSolver:: Temperature value "+to_string(temperature));

    // Getting neighbour
    get_neighbour(neighbour,sol,recuit_variant);
    double energy_neighbour = get_energy(neighbour);
    logn3("AnnealingSolver:: Energy of neighbour = "+to_string(energy_neighbour));

    // Choosing the solution
    if (energy_neighbour < energy ||
        ((double) rand() / (RAND_MAX)) < exp((energy - energy_neighbour)/temperature)) 
    {
      logn3("AnnealingSolver:: New solution found, energy = "+to_string(energy_neighbour));
      if (energy_neighbour < energy)
        cout << "-"; // Better
      else 
        cout << "+"; // Metropolis

      nb_accepted++;

      sol->clear();
      sol->copy(neighbour);

      if (sol->get_cost() < best_sol->get_cost()) {
        // We have a better solution 
        cout << endl << "AnnealingSolver:: Better sol found : " 
          << sol->get_cost() << " Temp : " << temperature << endl;
        best_sol->clear();
        best_sol->copy(sol);
      }

      energy = energy_neighbour;
    }
    else { // neighbour rejected 
      cout << ".";
    }

    // Updating iteration
    ++k;
    taux_acceptation = nb_accepted / k ;
  }
  cout << endl;

  energy_file << "\n" << best_sol->get_cost_string() << "\n";
  temp_file << "\n" << best_sol->get_cost_string() << "\n";
  taux_acceptation_file << "\n" << best_sol->get_cost_string() << "\n";

  energy_file.close();
  temp_file.close();
  taux_acceptation_file.close();

  this->found = true;
  this->solution = best_sol;
  logn2("StupidSolver::solve: END");
  return found;
}
コード例 #21
0
ファイル: pim_interface.cpp プロジェクト: Distrotech/mrd6
void pim_interface::handle_assert(const sockaddr_in6 *from, pim_assert_message *msg, uint16_t length) {
	m_stats.counter(AssertCount, RX)++;

	if (should_log(MESSAGE_CONTENT)) {
		base_stream &os = log();
		os.inc_level();
		_debug_pim_dump(os, *msg);
		os.dec_level();
	}

	if (!get_neighbour(from->sin6_addr)) {
		m_stats.counter(AssertCount, Bad)++;
		return;
	}

	inet6_addr grpaddr(msg->gaddr.addr, msg->gaddr.masklen);
	pim_group_node *node = pim->get_group(grpaddr);

	bool rpt = msg->rpt();
	uint32_t metric_pref = msg->metric_pref();
	uint32_t metric = ntoh(msg->metric);

	if (node) {
		if (!IN6_IS_ADDR_UNSPECIFIED(&msg->saddr.addr)) {
			pim_group_source_state *state = node->get_state(msg->saddr.addr);
			if (state) {
				pim_common_oif::assert_state prev = pim_common_oif::AssertNoInfo;
				bool existed = false;

				pim_common_oif *oif = (pim_common_oif *)state->get_oif(owner());
				if (oif) {
					prev = oif->current_assert_state();
					existed = true;
				}

				state->handle_assert(owner(), from->sin6_addr,
						     rpt, metric, metric_pref);

				/* for some future reason the oif may be released meanwhile */
				oif = (pim_common_oif *)state->get_oif(owner());

				if (!oif && existed) {
					/* transitioned somehow */
					return;
				}

				pim_common_oif::assert_state current = oif ?
					oif->current_assert_state() : pim_common_oif::AssertNoInfo;

				if (current != pim_common_oif::AssertNoInfo || current != prev) {
					/* (S,G) Assert state machine is not NoInfo
					 * or a transition occurred: no (*,G) handling */
					return;
				}
			}
		}

		if (node->has_wildcard()) {
			node->wildcard()->handle_assert(owner(), from->sin6_addr,
						        rpt, metric, metric_pref);
		}
	}
}