Agent networking optimization

[paches00]

My model begins by initializing agents with the network skill and creates a UDP server for each of them:

init {
    create simple_agent number: number_of_agents {
        do connect to: url protocol: "udp_server" port: port + base_id;
        base_id <- base_id + 1;
        self.name <- string(base_id);
    }
}

Next, the agent fetches the message from the network and then sets it's location based on the point included in the message contents:

reflex fetch when: has_more_message() {
    loop while: has_more_message() {
        message msg <- fetch_message();

        list<string> coords <- msg.contents regex_matches("[-+]?\\d*\\.?\\d+");   
        target_location <- {float(coords[1]) + correction.y, float(coords[0]) - correction.x, 0};
        rot <- float(coords[3]) * -100;
 			
 	self.location <- target_location;
    }
}

aspect default { 
    	draw circle(4) at: self.location color: #green rotate: rot anchor: #166 
}

Now, while this works and the agents move smoothly, the changes lag behind. The UDP client is publishing information at a rate of 120 hz and it should be much faster. Could the networking components not handle the fast rate? Or is the message buffer affecting the message fetch? I am not sure and would appreciate some help or advise if possible. Thank you.

[paches00]

Overall, I am just looking for ways to optimize my model since it will be used as a "game" of sorts and as close to "real-time" outputs are desired. I'll paste my full model below if more information is required.

/**
* Name: optitrack_demo
* Based on the internal empty template. 
* Author: fheshiki
* Tags: 
*/

model optitrack_demo

global {
	// REAL-WORLD DIMENSIONS FOR LAB SET-UP
	geometry shape <- rectangle(137.5, 68.5); //, by  each square in the floor is 50 cm and so we have a predefined area of 7 by 4 squares
	point correction <- {-38.33982050418854, 72.43500351905823, 0}; // Previous Calibration: ['71.20521068572998','-106.8634033203125']
    list<geometry> arena_keystone <- [{0.0736697534742366,0.23169516447101535,0.0},{0.0675060826301559,1.0367573972528539,0.0},{0.8445979162363061,1.011437353862544,0.0},{0.8474850121913879,0.23125704030401106,0.0}];
    float grid_width <- shape.width;
    float grid_height <- shape.height;
    
    // CONNECTION VARIABLES
	int port <- 9876;
    string url <- "localhost";
    int number_of_agents <- 10;
    int base_id <- 0;
	
	// DISPLAY VARIABLES
	int screen <- 0;
	bool show_border<- false;
	bool draw_connections<- true;
	
	// OFFSET VARIABLES -0.5, -1.5, -2.0, -4.5
	float x_offset_min <- -0.5;
	float x_offset_max <- -1.5;
	float y_offset_min <- -2.0;
	float y_offset_max <- -4.5;
	
	// MODEL VARIABLES
	int proximity_graph_distance <- 50;
	graph<simple_agent, simple_agent> proximity_graph;
	
    init {
		create simple_agent number: number_of_agents {
		   do connect to: url protocol: "udp_server" port: port + base_id;
		   base_id <- base_id + 1;
		   self.name <- string(base_id);
		}
	}
	
	reflex updateProximityGraph when: draw_connections {
		proximity_graph <- graph<simple_agent, simple_agent>(list(simple_agent) as_intersection_graph(proximity_graph_distance));
	}
}

species simple_agent skills: [moving, network] {
	float rot;
	point target_location;
	
	init {
		self.location <- {-500, -500, -500};
	}
	
	reflex fetch when: has_more_message() {
        loop while: has_more_message() {
            message msg <- fetch_message();

            list<string> coords <- msg.contents regex_matches("[-+]?\\d*\\.?\\d+");
           
            target_location <- {float(coords[1]) + correction.y, float(coords[0]) - correction.x, 0};
            rot <- float(coords[3]) * -100;
 			
 			self.location <- target_location;
        }
    }

	action calculate_offset {
    	float offset_x;
    	
    	if (self.location.x >= 0) {
        	offset_x <- x_offset_min + (self.location.x / grid_width) * (x_offset_max - x_offset_min);
    	} else {
        	offset_x <- x_offset_min + (self.location.x / -grid_width) * (x_offset_max - x_offset_min);
    	}

    	float offset_y;
    	if (self.location.y >= 0) {
        	offset_y <- y_offset_min + (self.location.y / grid_height) * (y_offset_max - y_offset_min);
    	} else {
        	offset_y <- y_offset_min + (self.location.y / -grid_height) * (y_offset_max - y_offset_min);
    	}
   	 
    	return {offset_x, offset_y, 0};
	}

	aspect default {
    	point offset <- calculate_offset();
   	 
    	draw circle(4) at: (self.location + offset) color: #green rotate: rot anchor: #center;
	}

}

grid space cell_width:15.5 cell_height:15.5 {
    aspect dev {
    	if (show_border){
    		draw shape color: #white border: #green width: 1;
    	} else {
        	draw shape color: #white border: #white width: 1;
        }
    }
}

experiment MainVisualize type: gui virtual: true {
	float minimum_cycle_duration<-0.001;
	
	// Connection Parameters
    parameter "URL" var: url <- url among: ["10.205.3.55", "127.0.0.1", "10.205.3.9", "10.205.3.82", "localhost"] category: "Connection Variables";
    parameter "PORT" var: port <- port among: [9876, 1234, 53408] category: "Connection Variables";
    parameter "Number of Agents" var: number_of_agents <- number_of_agents min: 0 max: 10 category: "Connection Variables";
    parameter "Base ID" var: base_id <- base_id min: 0 max: 10 category: "Connection Variables";
    
    // Display Parameters
    parameter "Show Grid" var: show_border <- show_border category: "Display";
    parameter "Fullscreen" var: screen <- screen among: [0, 1] category: "Display" ;  
    parameter "Draw Connections" var: draw_connections <- draw_connections enables: [proximity_graph] category: "Display";
    parameter "Correction" var: correction <- correction category: "Display";
    
    // Offset Parameters
    parameter "X Offset Minimum" var: x_offset_min <- x_offset_min category: "Offset";
    parameter "X Offset Maximum" var: x_offset_max <- x_offset_max category: "Offset";
    parameter "Y Offset Minimum" var: y_offset_min <- y_offset_min category: "Offset";
    parameter "Y Offset Maximum" var: y_offset_max <- y_offset_max category: "Offset";
    
    // Demo Parameters
    parameter "Proximity Distance" var: proximity_graph_distance <- proximity_graph_distance min: 1 max: 300;
 	
    
    output {
        display objects_display type: opengl toolbar: false virtual: true {
            species simple_agent position: {0, 0, 0.01};
            
            graphics "proximity_graph" {
				if (draw_connections){
					loop eg over: proximity_graph.edges {
						geometry edge_geom <- geometry(eg);
						
						int edge_distance_in_cms <- round(edge_geom.points[0] distance_to edge_geom.points[1]);
						
						if (edge_distance_in_cms < proximity_graph_distance) {
							point middle_of_the_line <- {((edge_geom.points[0].x + edge_geom.points[1].x) / 2),((edge_geom.points[0].y + edge_geom.points[1].y) / 2) + 5};
							
							draw line(edge_geom.points) color:#green width: 6;							
							draw(string(edge_distance_in_cms)) color: #green rotate: 90 at: middle_of_the_line font: font("SansSerif", 25, #plain);
						} 
					}
				}
			}
        }
    }
}

experiment Main parent: MainVisualize type: gui {    
    output {
        display objects_display_simulator parent: objects_display fullscreen: screen keystone: arena_keystone {
            species space position: {0, 0, -0.01} aspect: dev refresh: false;
        }
    }
}

experiment Benchmarking parent: Main type: gui benchmark: true {}

[lesquoyb]

Hello, sorry for the late reply.

If everything is working well but it feels like it's lagging behind there are two possibilities:

1. either the fetching (and the code around it) is too slow as you mentioned
2. or the display is lagging behind the actual state of the simulation

If it's the first, you can try reducing the number of messages (for example do not send messages if there's no movement, or only once a certain distance has been traveled etc.) or the length of messages themselves (truncating numbers sent, remove all unnecessary wrapping etc.) and finally you could try to only open one UDP server that would manage messages for all agents, using an id in the message to identify to which agent the message corresponds to.

If it's the second one, you can try to synchronize the display, it does have an impact on performances though, so depending on your computer that may even worsen the lag. You could also try to manually force the refreshing of display every X cycles using the update_outputs action of the experiment.

Hope this helps, in any case I'd be interested in your feedback on what worked or not. I also noticed you have a benchmark experiment, could you provide the csv it produced in case the issue is still not fixed ?