int main(int argc, char *argv[])
{
g_tw_ts_end = 1e9*60*60*24*365; /* one year, in nsecs */
tw_opt_add(app_opt);
tw_init(&argc, &argv);
if (!conf_file_name[0]){
fprintf(stderr, "Expected \"codes-config\" option, please see --help.\n");
MPI_Finalize();
return 1;
}
if (configuration_load(conf_file_name, MPI_COMM_WORLD, &config)){
fprintf(stderr, "Error loading config file %s.\n", conf_file_name);
MPI_Finalize();
return 1;
}
resource_lp_init();
lp_type_register("server", &s_lp);
codes_mapping_setup();
resource_lp_configure();
tw_run();
tw_end();
}
int main(
int argc,
char **argv)
{
int nprocs;
int rank;
int num_nets, *net_ids;
//printf("\n Config count %d ",(int) config.lpgroups_count);
g_tw_ts_end = s_to_ns(60*60*24*365); /* one year, in nsecs */
lp_io_handle handle;
tw_opt_add(app_opt);
tw_init(&argc, &argv);
if(argc < 2)
{
printf("\n Usage: mpirun <args> --sync=2/3 mapping_file_name.conf (optional --nkp) ");
MPI_Finalize();
return 0;
}
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
configuration_load(argv[2], MPI_COMM_WORLD, &config);
svr_add_lp_type();
codes_mapping_setup();
net_ids = model_net_configure(&num_nets);
assert(num_nets==1);
net_id = *net_ids;
free(net_ids);
num_servers = codes_mapping_get_lp_count("MODELNET_GRP", 0, "server",
NULL, 1);
if(net_id == DRAGONFLY)
{
num_routers = codes_mapping_get_lp_count("MODELNET_GRP", 0,
"dragonfly_router", NULL, 1);
offset = 1;
}
if(lp_io_prepare("modelnet-test", LP_IO_UNIQ_SUFFIX, &handle, MPI_COMM_WORLD) < 0)
{
return(-1);
}
tw_run();
model_net_report_stats(net_id);
if(lp_io_flush(handle, MPI_COMM_WORLD) < 0)
{
return(-1);
}
tw_end();
return 0;
}
int main(int argc, char *argv[]) {
int s, s1; // Socket descriptors
init_logger();
init_thread_info();
configuration_load(argc,argv);
if (weborf_conf.is_inetd) inetd();
print_start_disclaimer(argc,argv);
s=net_create_server_socket();
net_bind_and_listen(s);
set_new_gid(weborf_conf.gid);
set_new_uid(weborf_conf.uid);
// init the queue for opened sockets
if (q_init(&queue, MAXTHREAD + 1)!=0)
exit(NOMEM);
// Starts the 1st group of threads
init_thread_attr();
init_threads(INITIALTHREAD);
init_thread_shaping();
init_signals();
// Infinite cycle, accept connections
while (1) {
s1=accept(s, NULL,NULL);
if (s1 >= 0 && q_put(&queue, s1)!=0) { // Adds s1 to the queue
#ifdef REQUESTDBG
syslog(LOG_ERR,"Not enough resources, dropping connection...");
#endif
close(s1);
}
// Start new thread if needed
if (thread_info.free <= LOWTHREAD && thread_info.free<MAXTHREAD) {
// Need to start new thread
if (thread_info.count + INITIALTHREAD < MAXTHREAD) {
// Starts a group of threads
init_threads(INITIALTHREAD);
} else { // Can't start a group because the limit is close, starting less than a whole group
init_threads(MAXTHREAD - thread_info.count);
}
}
}
return 0;
}
int main(int argc, char **argv) {
int nprocs;
int rank;
int num_nets, *net_ids;
int i;
//for later random pairing:
srand(time(NULL));
g_tw_ts_end = s_to_ns(60*60*24*365);
tw_opt_add(app_opt);
tw_init(&argc, &argv);
if (!conf_file_name[0]) {
fprintf(stderr, "Expected \"codes-config\" option, please see --help.\n");
MPI_Finalize();
return 1;
}
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
if (configuration_load(conf_file_name, MPI_COMM_WORLD, &config)) {
fprintf(stderr, "Error loading config file %s.\n", conf_file_name);
MPI_Finalize();
return 1;
}
model_net_register();
node_add_lp_type();
codes_mapping_setup();
net_ids = model_net_configure(&num_nets);
assert(num_nets==1);
net_id = *net_ids;
free(net_ids);
if(net_id != TORUS) {
printf("\n This is written to simulate torus networks.");
MPI_Finalize();
return 0;
}
num_nodes = codes_mapping_get_lp_count(group_name, 0, "node", NULL, 1);
configuration_get_value_int(&config, param_group_nm, num_reqs_key, NULL, &num_reqs);
configuration_get_value_int(&config, param_group_nm, payload_sz_key, NULL, &payload_sz);
configuration_get_value_int(&config, param_group_nm, num_messages_key, NULL, &num_messages);
tw_run();
model_net_report_stats(net_id);
tw_end();
free_node_mappings();
return 0;
}
int main(
int argc,
char **argv)
{
int nprocs;
int rank;
lp_io_handle handle;
int ret;
g_tw_ts_end = s_to_ns(60*60*24*365); /* one year, in nsecs */
tw_opt_add(app_opt);
tw_init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
/* read in configuration file */
ret = configuration_load(conf_file_name, MPI_COMM_WORLD, &config);
if (ret)
{
fprintf(stderr, "Error opening config file: %s\n", conf_file_name);
return(-1);
}
lp_type_register("server", &svr_lp);
lsm_register();
codes_mapping_setup();
lsm_configure();
ret = lp_io_prepare("lsm-test", LP_IO_UNIQ_SUFFIX, &handle, MPI_COMM_WORLD);
if(ret < 0)
{
return(-1);
}
INIT_CODES_CB_INFO(&cb_info, svr_msg, h, tag, ret);
tw_run();
ret = lp_io_flush(handle, MPI_COMM_WORLD);
assert(ret == 0);
tw_end();
return 0;
}
int main(int argc, char *argv[])
{
int num_nets, *net_ids;
g_tw_ts_end = s_to_ns(60*60*24*365); /* one year, in nsecs */
tw_opt_add(app_opt);
tw_init(&argc, &argv);
if (!conf_file_name[0]) {
fprintf(stderr, "Expected \"codes-config\" option, please see --help.\n");
MPI_Finalize();
return 1;
}
/* loading the config file into the codes-mapping utility, giving us the
* parsed config object in return.
* "config" is a global var defined by codes-mapping */
if (configuration_load(conf_file_name, MPI_COMM_WORLD, &config)){
fprintf(stderr, "Error loading config file %s.\n", conf_file_name);
MPI_Finalize();
return 1;
}
/* currently restrict to simplenet, as other networks are trickier to
* setup. TODO: handle other networks properly */
if(net_id != SIMPLENET) {
printf("\n The test works with simple-net configuration only! ");
MPI_Finalize();
return 1;
}
testsvr_init();
model_net_register();
codes_mapping_setup();
/* Setup the model-net parameters specified in the global config object,
* returned are the identifier for the network type */
net_ids = model_net_configure(&num_nets);
assert(num_nets==1);
net_id = *net_ids;
free(net_ids);
tw_run();
tw_end();
return 0;
}
int main(
int argc,
char **argv)
{
int num_nets;
int *net_ids;
g_tw_ts_end = s_to_ns(60*60*24*365); /* one year, in nsecs */
tw_opt_add(app_opt);
tw_init(&argc, &argv);
if(argc < 2)
{
printf("\n Usage: mpirun <args> --sync=[1,3] -- mapping_file_name.conf (optional --nkp) ");
MPI_Finalize();
return 0;
}
configuration_load(argv[2], MPI_COMM_WORLD, &config);
model_net_register();
svr_add_lp_type();
codes_mapping_setup();
net_ids = model_net_configure(&num_nets);
assert(num_nets==1);
net_id = *net_ids;
free(net_ids);
assert(net_id == SIMPLENET);
assert(NUM_SERVERS == codes_mapping_get_lp_count("MODELNET_GRP", 0,
"server", NULL, 1));
tw_run();
tw_end();
return prog_rtn;
}
configuration_t *
configuration_init (const gchar *filename)
{
configuration_t *config;
gchar *history_file;
GKeyFile *keyfile;
config = g_new0 (configuration_t, 1);
/* init hash */
config->values = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, g_free);
/* init aliases */
config->aliases = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, g_free);
keyfile = configuration_load (filename);
section_to_hash (keyfile, "main", config->values);
section_to_hash (keyfile, "alias", config->aliases);
g_key_file_free (keyfile);
/* load history */
history_file = configuration_get_string (config, "HISTORY_FILE");
if (!*history_file) {
gchar cfile[XMMS_PATH_MAX], *key, *value;
xmms_usercachedir_get (cfile, XMMS_PATH_MAX);
key = g_strdup ("HISTORY_FILE");
value = g_build_filename (cfile, "nyxmms2_history", NULL);
g_hash_table_replace (config->values, key, value);
}
return config;
}
int main(int argc, char *argv[]) {
//printf("In main\n");
g_tw_ts_end = s_to_ns(60 * 60 * 24 * 365); /* one year, in nsecs */
/* ROSS initialization function calls */
tw_opt_add(app_opt); /* add user-defined args */
/* initialize ROSS and parse args. NOTE: tw_init calls MPI_Init */
tw_init(&argc, &argv);
if (!conf_file_name[0]) {
tw_error(TW_LOC,
"Expected \"codes-config\" option, please see --help.\n");
return 1;
}
/* loading the config file into the codes-mapping utility, giving us the
* parsed config object in return.
* "config" is a global var defined by codes-mapping */
if (configuration_load(conf_file_name, MPI_COMM_WORLD, &config)) {
tw_error(TW_LOC, "Error loading config file %s.\n", conf_file_name);
return 1;
}
lsm_register();
//lsm_configure();
/* register model-net LPs with ROSS */
model_net_register();
/* register the user LPs */
node_register();
forwarder_register();
/* setup the LPs and codes_mapping structures */
codes_mapping_setup();
/* setup the globals */
int rc = configuration_get_value_int(&config, "server_pings", "num_reqs",
NULL, &num_reqs);
if (rc != 0)
tw_error(TW_LOC, "unable to read server_pings:num_reqs");
int payload_sz_d;
rc = configuration_get_value_int(&config, "server_pings", "payload_sz",
NULL, &payload_sz_d);
if (rc != 0)
tw_error(TW_LOC, "unable to read server_pings:payload_sz");
payload_sz = (uint64_t) payload_sz_d;
/* get the counts for the client and svr clusters */
num_client_nodes = codes_mapping_get_lp_count("client_CLUSTER", 0, "node",
NULL, 1);
num_svr_nodes = codes_mapping_get_lp_count("svr_CLUSTER", 0, "node", NULL,
1);
num_burst_buffer_nodes = codes_mapping_get_lp_count("bb_CLUSTER", 0, "node",
NULL, 1);
num_storage_nodes = codes_mapping_get_lp_count("storage_CLUSTER", 0, "node",
NULL, 1);
num_client_forwarders = codes_mapping_get_lp_count("client_FORWARDERS", 0,
"forwarder", NULL, 1);
num_svr_forwarders = codes_mapping_get_lp_count("svr_FORWARDERS", 0,
"forwarder", NULL, 1);
num_burst_buffer_forwarders = codes_mapping_get_lp_count("bb_FORWARDERS", 0,
"forwarder", NULL, 1);
num_storage_forwarders = codes_mapping_get_lp_count("storage_FORWARDERS", 0,
"forwarder", NULL, 1);
/* Setup the model-net parameters specified in the global config object,
* returned are the identifier(s) for the network type.
* 1 ID -> all the same modelnet model
* 2 IDs -> clusters are the first id, forwarding network the second
* 3 IDs -> client is first, svr and bb second and forwarding network the third
* 4 IDs -> cluster client is the first, svr is the second, burst buffer the third and forwarding network the last
* */
int num_nets;
int *net_ids = model_net_configure(&num_nets);
assert(num_nets <= 5);
if (num_nets == 1) {
net_id_client = net_ids[0];
net_id_svr = net_ids[0];
net_id_bb = net_ids[0];
net_id_storage = net_ids[0];
net_id_forwarding = net_ids[0];
} else if (num_nets == 2) {
net_id_client = net_ids[0];
net_id_svr = net_ids[0];
net_id_bb = net_ids[0];
net_id_storage = net_ids[0];
net_id_forwarding = net_ids[1];
} else if (num_nets == 3) {
net_id_client = net_ids[0];
net_id_svr = net_ids[1];
net_id_bb = net_ids[1];
net_id_storage = net_ids[1];
net_id_forwarding = net_ids[2];
} else if (num_nets == 4) {
net_id_client = net_ids[0];
net_id_svr = net_ids[1];
net_id_bb = net_ids[2];
net_id_storage = net_ids[2];
net_id_forwarding = net_ids[3];
} else {
net_id_client = net_ids[0];
net_id_svr = net_ids[1];
net_id_bb = net_ids[2];
net_id_storage = net_ids[3];
net_id_forwarding = net_ids[4];
}
free(net_ids);
configuration_get_value_int(&config, param_group_nm, num_reqs_key, NULL,
&num_reqs);
configuration_get_value_int(&config, param_group_nm, payload_sz_key, NULL,
(int *) &payload_sz);
configuration_get_value_int(&config, param_group_nm, pvfs_file_sz_key, NULL,
&pvfs_file_sz); /*Sughosh: added for pvfsfs*/
configuration_get_value_int(&config, param_group_nm, bb_file_size_key, NULL,
&bb_file_sz); /*Tony: added for bb*/
configuration_get_value_int(&config, param_group_nm, bb_capacity_key, NULL,
&burst_buffer_max_capacity); /*Tony: added for bb*/
/* begin simulation */
model_net_report_stats(net_id);
tw_run();
tw_end();
return 0;
}
Server_status start(int incoming_sck) override
{
union
{
struct sockaddr s;
struct sockaddr_storage ss;
struct sockaddr_in s4;
struct sockaddr_in6 s6;
} u;
unsigned int sin_size = sizeof(u);
memset(&u, 0, sin_size);
int sck = accept(incoming_sck, &u.s, &sin_size);
if (-1 == sck) {
LOG(LOG_INFO, "Accept failed on socket %d (%s)", incoming_sck, strerror(errno));
_exit(1);
}
char source_ip[256];
strcpy(source_ip, inet_ntoa(u.s4.sin_addr));
REDEMPTION_DIAGNOSTIC_PUSH
REDEMPTION_DIAGNOSTIC_GCC_IGNORE("-Wold-style-cast") // only to release
const int source_port = ntohs(u.s4.sin_port);
REDEMPTION_DIAGNOSTIC_POP
/* start new process */
const pid_t pid = fork();
switch (pid) {
case 0: /* child */
// TODO: see exit status of child, we could use it to diagnose session behaviours
// TODO: we could probably use some session launcher object here. Something like
// an abstraction layer that would manage either forking of threading behavior
// this would also likely have some effect on network ressources management
// (that means the select() on ressources could be managed by that layer)
{
close(incoming_sck);
Inifile ini;
ini.set<cfg::font>(Font(app_path(AppPath::DefaultFontFile)));
ini.set<cfg::debug::config>(this->debug_config);
configuration_load(ini.configuration_holder(), this->config_filename);
if (ini.get<cfg::debug::session>()){
LOG(LOG_INFO, "Setting new session socket to %d\n", sck);
}
union
{
struct sockaddr s;
struct sockaddr_storage ss;
struct sockaddr_in s4;
struct sockaddr_in6 s6;
} localAddress;
socklen_t addressLength = sizeof(localAddress);
if (-1 == getsockname(sck, &localAddress.s, &addressLength)){
LOG(LOG_INFO, "getsockname failed error=%s", strerror(errno));
_exit(1);
}
char target_ip[256];
REDEMPTION_DIAGNOSTIC_PUSH
REDEMPTION_DIAGNOSTIC_GCC_IGNORE("-Wold-style-cast") // only to release
const int target_port = ntohs(localAddress.s4.sin_port);
REDEMPTION_DIAGNOSTIC_POP
// strcpy(real_target_ip, inet_ntoa(localAddress.s4.sin_addr));
strcpy(target_ip, inet_ntoa(localAddress.s4.sin_addr));
if (0 != strcmp(source_ip, "127.0.0.1")){
// do not log early messages for localhost (to avoid tracing in watchdog)
LOG(LOG_INFO, "Redemption " VERSION);
LOG(LOG_INFO, "src=%s sport=%d dst=%s dport=%d", source_ip, source_port, target_ip, target_port);
}
char real_target_ip[256];
if (ini.get<cfg::globals::enable_transparent_mode>() &&
(0 != strcmp(source_ip, "127.0.0.1"))) {
int fd = open("/proc/net/ip_conntrack", O_RDONLY);
// source and dest are inverted because we get the information we want from reply path rule
int res = parse_ip_conntrack(fd, target_ip, source_ip, target_port, source_port, real_target_ip, sizeof(real_target_ip), 1);
if (res){
LOG(LOG_WARNING, "Failed to get transparent proxy target from ip_conntrack: %d", fd);
}
close(fd);
if (setgid(this->gid) != 0){
LOG(LOG_ERR, "Changing process group to %u failed with error: %s\n", this->gid, strerror(errno));
_exit(1);
}
if (setuid(this->uid) != 0){
LOG(LOG_ERR, "Changing process user to %u failed with error: %s\n", this->uid, strerror(errno));
_exit(1);
}
LOG(LOG_INFO, "src=%s sport=%d dst=%s dport=%d", source_ip, source_port, real_target_ip, target_port);
}
else {
::memset(real_target_ip, 0, sizeof(real_target_ip));
}
int nodelay = 1;
if (0 == setsockopt(sck, IPPROTO_TCP, TCP_NODELAY, &nodelay, sizeof(nodelay))){
// Create session file
int child_pid = getpid();
char session_file[256];
sprintf(session_file, "%s/redemption/session_%d.pid", app_path(AppPath::Pid), child_pid);
int fd = open(session_file, O_WRONLY | O_CREAT, S_IRWXU);
if (fd == -1) {
LOG(LOG_ERR, "Writing process id to SESSION ID FILE failed. Maybe no rights ?:%d:%s\n", errno, strerror(errno));
_exit(1);
}
char text[256];
const size_t lg = snprintf(text, 255, "%d", child_pid);
if (write(fd, text, lg) == -1) {
LOG(LOG_ERR, "Couldn't write pid to %s/redemption/session_<pid>.pid: %s", app_path(AppPath::Pid), strerror(errno));
_exit(1);
}
close(fd);
// Launch session
if (0 != strcmp(source_ip, "127.0.0.1")){
// do not log early messages for localhost (to avoid tracing in watchdog)
LOG(LOG_INFO,
"New session on %d (pid=%d) from %s to %s",
sck, child_pid, source_ip, (real_target_ip[0] ? real_target_ip : target_ip));
}
ini.set_acl<cfg::globals::host>(source_ip);
// ini.context_set_value(AUTHID_TARGET, real_target_ip);
ini.set_acl<cfg::globals::target>(target_ip);
if (ini.get<cfg::globals::enable_transparent_mode>()
&& strncmp(target_ip, real_target_ip, strlen(real_target_ip))) {
ini.set_acl<cfg::context::real_target_device>(real_target_ip);
}
Session session(sck, ini, this->cctx, this->rnd, this->fstat);
// Suppress session file
unlink(session_file);
if (ini.get<cfg::debug::session>()){
LOG(LOG_INFO, "Session::end of Session(%d)", sck);
}
shutdown(sck, 2);
close(sck);
}
else {
LOG(LOG_ERR, "Failed to set socket TCP_NODELAY option on client socket");
}
_exit(0);
}
break;
default: /* father */
{
close(sck);
}
break;
case -1:
// error forking
LOG(LOG_ERR, "Error creating process for new session : %s\n", strerror(errno));
break;
}
return START_FAILED;
}
int main(int argc, char **argv)
{
printf("ur5 Server Start\n");
// JointVector tcp_home= {0.0, -191.0, 600.0, 0.0, -2.2211, -2.2211};
JointVector joint_home_rad={0.0000, -1.5708, 0.0000, -1.5708, 0.0000, 0.0000};
JointVector joint_home={0.0000, -90, 0.0000, -90, 0.0000, 0.0000};
JointVector init_two ={-6.5018, -95.3469, -29.8123, -194.7758, -59.0822, -62.3032};
JointVector init_right_side = {0.309199, -1.240009, 0.323497, -1.039543, 0.541075, 0.486453};
JointVector initialP_rad = {-0.330294, -1.881878, -0.290919, -2.243194, -0.660115, -0.704284};
JointVector viereck[4] = {{43.24, -140.88, -30.05, -12.83, 129.28, -0.27},
{130.67, -140.87, -30.05, -12.75, 44.08, -0.27},
{130.67, -187.90, 6.46, -1.22, 43.35, -0.27},
{43.24, -187.90, -30.05, 3.87, 100.32, -0.27}
};
JointVector PosOne= {36.12, -112.88, -8.78, -24.53, 88.39, 16.64};
int i,h,n=0;
for(i=0; i<4;i++){
for(h=0;h<6;h++){
viereck[i][h]= deg_to_rad(viereck[i][h]);
}
}
for(i=0;i<MSG_BUFFER_SIZE;i++) msg_buffer[i].text = msg_text_buffers[i];
// JointVector initialP={-30.4347, -132.2621, -40.8718, -149.8236, -59.1151, -62.2781};
// int i;
// printf("joint_home ={");
// for(i=0; i<6; i++){
// joint_home_rad[i]= deg_to_rad(joint_home[i]);
// joint_home[i] = rad_to_deg(joint_home_rad[i]);
// printf("%3.4f%s",joint_home_rad[i], i<5 ? ", " : "};");
//// }
// MovePTPPacket move_ptp_packet;
for(i=0; i<6; i++){
PosOne[i]= deg_to_rad(PosOne[i]);}
// move_ptp(joint_home_rad, PosOne , &move_ptp_packet);
// return 0;
struct connection_data server;
fd_set masterfds, readfds;
struct timeval timeout,send_time_start, send_time_end;
int rc;
pthread_t tcp_server_thread;
MovePTPPacket move_ptp_packet;
server.initialize_direction = -1.0;
read_args(argc, argv, &server);
initialize_direction = server.initialize_direction;
printf("initialize direction: %f", initialize_direction);
rc = pthread_create(&tcp_server_thread, NULL, &start_tcp_server, &server);
if(rc < 0){
quit_program=true;
}
int connection_timeout_count=0;
pva_packet.header.protocol_id=PVA_PACKET_ID;
p_packet.header.protocol_id=PPACKET_ID;
//--------------------------- Init Robot -------------------------------------------------------
configuration_load();
open_interface();
power_up();
set_wrench();
if(!initialize(0)){
puts("could not initialize robot");
exit(EXIT_FAILURE);
}
settle();
setup_sigint();
setup_sigpipe();
memcpy(&last_pva_packet, &pva_packet,sizeof(PVAPacket));
for(i=0;i<6;i++) last_pva_packet.acceleration[i] = 0.0;
for(i=0;i<6;i++) last_pva_packet.velocity[i] = 0.0;
bool timeout_flag=false;
char *buff[sizeof(PVAPacket)];
//------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------
// for(pva_packet.header.cycle_number =0; quit_program == false; pva_packet.header.cycle_number++) {
// robotinterface_read_state_blocking();
// pthread_mutex_lock(&connect_mutex);
// if(connection_timeout_count > TIMEOUT_TOLERANCE){
// connection_timeout_count=0;
// connected=false;
// }
// //--------------------------- Stuff roboter does -------------------------------------------------------
// robotinterface_get_actual(servo_packet.position, servo_packet.velocity);
// //------------------------------------------------------------------------------------------------------
// //------------------------------------------------------------------------------------------------------
// //---------------------------- send -------------------------------------------------------------------
// if(connected){
// gettimeofday(&send_time_start,0);
// if(send(client_fd, (char*) &pva_packet , sizeof(pva_packet),0) < 1){
// connected=false;
// }
// }
// //------------------------------------------------------------------------------------------------------
// //------------------------------------------------------------------------------------------------------
// //---------------------------- recieve -----------------------------------------------------------------
// timeout_flag=false;
// if(connected){
// FD_ZERO(&masterfds);
// FD_SET(client_fd, &masterfds);
// memcpy(&readfds, &masterfds, sizeof(fd_set));
// gettimeofday(&send_time_end,0);
// timeval_diff(&timeout, &send_time_start, &send_time_end);
// timeout.tv_usec = 6000 - timeout.tv_usec;
// if (select(client_fd +1, &readfds, NULL, NULL, &timeout) < 0) {
// pthread_mutex_lock(&connect_mutex);
// connected=false;
// pthread_mutex_unlock(&connect_mutex);
// }
// if(FD_ISSET(client_fd, &readfds)){
// n=recv(client_fd, buff, sizeof(buff), 0);
// if (n < 1 || n != sizeof(PVAPacket)){
// pthread_mutex_lock(&connect_mutex);
// connected=false;
// pthread_mutex_unlock(&connect_mutex);
// }
// }else{
// connection_timeout_count++;
// if(connection_timeout_count< TIMEOUT_TOLERANCE)
// timeout_flag=true;
// }
// if(!timeout_flag && connected){
// memcpy(&pva_packet, buff, n);
// if(connection_timeout_count) connection_timeout_count--;
// }
// }
// //------------------------------------------------------------------------------------------------------
// //------------------------------------------------------------------------------------------------------
// //---------------------------- do stuff with data ------------------------------------------------------
// // TODO check for errors-----
// //------------------------------------------------------------------------------------------------------
// if(!timeout_flag && connected){
// // save pva to last if something went wrong;
// memcpy(&last_pva_packet, &pva_packet, sizeof(PVAPacket);
// }
// //------------------------------------------------------------------------------------------------------
// //------------------------------------------------------------------------------------------------------
// //--------------------------- Stuff roboter does -------------------------------------------------------
// if(connected){
// if(!timeout){
// robotinterface_command_position_velocity_acceleration(pva_packet.position,
// pva_packet.velocity,
// pva_packet.acceleration);
// }else{ //timeout
// if(connection_timeout_count<3){
// connected=false;
// robotinterface_command_velocity(zero_vector);
// }
// // cause of timeout we take the last pva_packet
// robotinterface_command_position_velocity_acceleration(last_pva_packet.position,
// last_pva_packet.velocity,
// last_pva_packet.acceleration);
// }
// }else{
// robotinterface_command_velocity(zero_vector);
// }
// pthread_mutex_unlock(&connect_mutex);
// robotinterface_send();
// //------------------------------------------------------------------------------------------------------
// //------------------------------------------------------------------------------------------------------
// }
// // ---- quit programm
printf("shutdown robot...\n");
//---- shutdown robot ---------
// move to home ----
move_to_position(viereck[0]);
// move_to_position(joint_home_rad);
// move_to_position(PosOne);
// ---
puts("- Speeding down");
int j;
for (j = 0; j < 10; j++)
{
robotinterface_read_state_blocking();
robotinterface_command_velocity(zero_vector);
robotinterface_send();
}
puts("close robotinterface");
robotinterface_close();
puts("Done!");
printf("shutdown program\n");
return 0;
}
int main()
{
microcontroller_init();
uart1_queue_init(57600l); // default baudrate: 57600 due to XBee bi-direction communication
printf("Gluonpilot v%s ", version);
#ifdef LIMITED // Limited version is pre-loaded on modules sent to Non-European countries
printf("Limited version");
#endif
printf(" [%s %s, config: %dB, logline: %dB, navigation: %dB, double: %dB]\r\n\r\n",
__DATE__, __TIME__, sizeof(struct Configuration), sizeof(struct LogLine), sizeof(gluonscript_data.codes), sizeof(double));
microcontroller_reset_type(); // printf out reason of reset; for debugging
led_init();
// Create semaphores needed for FreeRTOS synchronization (better to do it know, they are changed in interrupts of uart2 and ppm)
vSemaphoreCreateBinary( xSpiSemaphore );
vSemaphoreCreateBinary( xGpsSemaphore );
// What hardware version are we using?
configuration_determine_hardware_version();
if (HARDWARE_VERSION == V01N)
printf("Found hardware version v0.1n\r\n");
else if (HARDWARE_VERSION == V01O)
printf("Found hardware version v0.1o\r\n");
else if (HARDWARE_VERSION == V01Q)
printf("Found hardware version v0.1q (GP2)\r\n");
else
printf("Found hardware version v0.1j or earlier\r\n");
// Open flash & load configuration
dataflash_open();
printf("%d MB flash found \r\n", (int)PAGE_SIZE/264);
//printf("Loading configuration...");
configuration_load();
//printf("done\r\n");
// Open RC receiver input: pwm_in/ppm_in task: in ppm_in/pwm_in.c
// This is too low level to do it in the control task
if (config.control.use_pwm)
{
pwm_in_open();
uart1_puts("Waiting for pwm");
pwm_in_wait_for();
if (! (ppm.channel[0] > 900 && ppm.channel[0] < 2100))
uart1_puts("not found!\r\n");
else
uart1_puts("done\r\n");
}
else
{
uart1_puts("Opening ppm...");
ppm_in_open(); // We need a complete frame (which takes at least 20ms) to start so never can start early enough!
uart1_puts(" done\r\n");
}
// Create our tasks.
if (config.control.servo_mix == QUADROCOPTER)
xTaskCreate( control_copter_task, ( signed portCHAR * ) "CControl", ( configMINIMAL_STACK_SIZE * 3 ), NULL, tskIDLE_PRIORITY + 7, NULL );
else
xTaskCreate( control_wing_task, ( signed portCHAR * ) "WControl", ( configMINIMAL_STACK_SIZE * 3 ), NULL, tskIDLE_PRIORITY + 7, NULL );
if (HARDWARE_VERSION == V01Q)
xTaskCreate( sensors_mpu6000_task, ( signed portCHAR * ) "Sensors", ( configMINIMAL_STACK_SIZE * 5 ), NULL, tskIDLE_PRIORITY + 6, NULL );
else
xTaskCreate( sensors_analog_task, ( signed portCHAR * ) "Sensors", ( configMINIMAL_STACK_SIZE * 5 ), NULL, tskIDLE_PRIORITY + 6, NULL );
xTaskCreate( sensors_gps_task, ( signed portCHAR * ) "GpsNavi", ( configMINIMAL_STACK_SIZE * 4 ), NULL, tskIDLE_PRIORITY + 5, NULL );
xTaskCreate( communication_input_task, ( signed portCHAR * ) "ConsoleInput", ( configMINIMAL_STACK_SIZE * 5 ), NULL, tskIDLE_PRIORITY + 4, NULL );
xTaskCreate( datalogger_task, ( signed portCHAR * ) "Dataflash", ( configMINIMAL_STACK_SIZE * 3 ), NULL, tskIDLE_PRIORITY + 3, NULL );
xTaskCreate( communication_telemetry_task, ( signed portCHAR * ) "Telemetry", ( configMINIMAL_STACK_SIZE * 2 ), NULL, tskIDLE_PRIORITY + 2, NULL );
xTaskCreate( osd_task, ( signed portCHAR * ) "OSD", ( configMINIMAL_STACK_SIZE * 1 ), NULL, tskIDLE_PRIORITY + 1, NULL );
#ifdef USE_TRACING
printf("\r\nENABLING TRACING\r\n");
setup_trace_pins();
#endif
// Order the scheduler to start scheduling our two tasks.
vTaskStartScheduler();
// We should only get here when the scheduler wasn't able to allocate enough memory.
uart1_puts("Not enough heap!\r\n");
return 1;
}
int main( int argc, char** argv )
{
int rank, nprocs;
int num_nets;
int* net_ids;
g_tw_ts_end = s_to_ns(60*60*24*365); /* one year, in nsecs */
workload_type[0]='\0';
tw_opt_add(app_opt);
tw_init(&argc, &argv);
if(strlen(workload_file) == 0)
{
if(tw_ismaster())
printf("\n Usage: mpirun -np n ./codes-nw-test --sync=1/2/3 --workload_type=type --workload_file=workload-file-name");
tw_end();
return -1;
}
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
configuration_load(argv[2], MPI_COMM_WORLD, &config);
nw_add_lp_type();
codes_mapping_setup();
num_net_lps = codes_mapping_get_lp_count("MODELNET_GRP", 0, "nw-lp", NULL, 0);
tw_run();
long long total_bytes_sent, total_bytes_recvd;
double avg_run_time;
double avg_comm_run_time;
double avg_col_run_time;
double total_avg_send_time;
double total_avg_wait_time;
double total_avg_recv_time;
double total_avg_col_time;
double total_avg_comp_time;
long overall_sends, overall_recvs, overall_waits, overall_cols;
MPI_Reduce(&num_bytes_sent, &total_bytes_sent, 1, MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&num_bytes_recvd, &total_bytes_recvd, 1, MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&avg_time, &avg_run_time, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&avg_recv_time, &total_avg_recv_time, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&avg_comm_time, &avg_comm_run_time, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&avg_col_time, &avg_col_run_time, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&avg_wait_time, &total_avg_wait_time, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&avg_send_time, &total_avg_send_time, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&avg_compute_time, &total_avg_comp_time, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&total_sends, &overall_sends, 1, MPI_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&total_recvs, &overall_recvs, 1, MPI_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&total_waits, &overall_waits, 1, MPI_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&total_collectives, &overall_cols, 1, MPI_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
if(!g_tw_mynode)
printf("\n Total bytes sent %lld recvd %lld \n avg runtime %lf \n avg comm time %lf avg compute time %lf \n avg collective time %lf avg send time %lf \n avg recv time %lf \n avg wait time %lf \n total sends %ld total recvs %ld total waits %ld total collectives %ld ", total_bytes_sent, total_bytes_recvd,
avg_run_time/num_net_lps,
avg_comm_run_time/num_net_lps,
total_avg_comp_time/num_net_lps,
total_avg_col_time/num_net_lps,
total_avg_send_time/num_net_lps,
total_avg_recv_time/num_net_lps,
total_avg_wait_time/num_net_lps,
overall_sends, overall_recvs, overall_waits, overall_cols);
tw_end();
return 0;
}
uint8_t execute_pdu(pdu_type *pdu) {
switch (pdu->opcode) {
case OPCODE_GET_TYPE: {
pdu->number_of_arguments = 1;
pdu->arguments[0] = MODULE_TYPE;
break;
}
case OPCODE_GET_ID: {
pdu->number_of_arguments = 1;
pdu->arguments[0] = get_module_id();
break;
}
case OPCODE_GET_FW_VERSION: {
pdu->number_of_arguments = 3;
pdu->arguments[0] = FIRMWARE_MAJOR;
pdu->arguments[1] = FIRMWARE_MINOR;
pdu->arguments[2] = FIRMWARE_PATCHLEVEL;
break;
}
case OPCODE_GET_NR_CHANNELS: {
pdu->number_of_arguments = 1;
pdu->arguments[0] = NUM_CHANNELS;
break;
}
case OPCODE_GET_FEATURES: {
pdu->number_of_arguments = 1;
pdu->arguments[0] = 0;
break;
}
case OPCODE_GET_SW_THRESHOLD: {
pdu->number_of_arguments = 1;
pdu->arguments[0] = get_switch_threshold();
break;
}
case OPCODE_GET_DIMMER_THRESHOLD: {
pdu->number_of_arguments = 1;
pdu->arguments[0] = get_long_press_threshold();
break;
}
case OPCODE_GET_DIMMER_DELAY: {
pdu->number_of_arguments = 1;
pdu->arguments[0] = get_dimmer_delay();
break;
}
case OPCODE_GET_SW_TIMER: {
if (pdu->number_of_arguments == 1) {
uint8_t channel_number = pdu->arguments[0];
if (is_valid_channel(channel_number)) {
uint16_t channel_timer = get_switch_timer(channel_number);
pdu->number_of_arguments = 1;
pdu->arguments[0] = channel_timer;
} else {
return ERROR_INVALID_CHANNEL_NUMBER;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_GET_CHANNEL_MAPPING: {
if (pdu->number_of_arguments == 1) {
uint8_t channel_number = pdu->arguments[0];
if (is_valid_channel(channel_number)) {
uint8_t channel_mapping = get_switch_mapping(channel_number);
pdu->number_of_arguments = 1;
pdu->arguments[0] = channel_mapping;
} else {
return ERROR_INVALID_CHANNEL_NUMBER;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_GET_DEFAULT_STATE: {
if (pdu->number_of_arguments == 1) {
uint8_t channel_number = pdu->arguments[0];
if (is_valid_channel(channel_number)) {
uint8_t channel_state = get_default_channel_state(channel_number);
pdu->number_of_arguments = 1;
pdu->arguments[0] = channel_state;
} else {
return ERROR_INVALID_CHANNEL_NUMBER;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_GET_DEFAULT_PERCENTAGE: {
if (pdu->number_of_arguments == 1) {
uint8_t channel_number = pdu->arguments[0];
if (is_valid_channel(channel_number)) {
uint8_t percentage = get_default_dimmer_percentage(channel_number);
pdu->number_of_arguments = 1;
pdu->arguments[0] = percentage;
} else {
return ERROR_INVALID_CHANNEL_NUMBER;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_GET_DEFAULT_DIMMER_DIRECTION: {
if (pdu->number_of_arguments == 1) {
uint8_t channel_number = pdu->arguments[0];
if (is_valid_channel(channel_number)) {
uint8_t direction = get_default_dimmer_direction(channel_number);
pdu->number_of_arguments = 1;
pdu->arguments[0] = direction;
} else {
return ERROR_INVALID_CHANNEL_NUMBER;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_SET_SW_THRESHOLD: {
if (pdu->number_of_arguments == 1) {
uint16_t threshold = pdu->arguments[0];
set_switch_threshold(threshold);
pdu->number_of_arguments = 0;
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_SET_DIMMER_DELAY: {
if (pdu->number_of_arguments == 1) {
uint8_t delay = pdu->arguments[0];
set_dimmer_delay(delay);
pdu->number_of_arguments = 0;
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_SET_DIMMER_THRESHOLD: {
if (pdu->number_of_arguments == 1) {
uint16_t threshold = pdu->arguments[0];
set_long_press_threshold(threshold);
pdu->number_of_arguments = 0;
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_SET_SW_TIMER: {
if (pdu->number_of_arguments == 2) {
uint8_t channel_number = pdu->arguments[0];
uint16_t timer = pdu->arguments[1];
if (is_valid_channel(channel_number)) {
set_switch_timer(channel_number, timer);
pdu->number_of_arguments = 0;
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_SET_CHANNEL_MAPPING: {
if (pdu->number_of_arguments == 2) {
uint8_t channel_number = pdu->arguments[0];
uint8_t mapping = pdu->arguments[1];
if (is_valid_channel(channel_number) && is_valid_channel(mapping)) {
set_switch_mapping(channel_number, mapping);
pdu->number_of_arguments = 0;
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_SET_DEFAULT_STATE: {
if (pdu->number_of_arguments == 2) {
uint8_t channel_number = pdu->arguments[0];
uint8_t default_state = pdu->arguments[1];
if (is_valid_channel(channel_number)) {
if (default_state == 0 || default_state == 1) {
set_default_channel_state(channel_number, default_state);
pdu->number_of_arguments = 0;
} else {
return ERROR_INVALID_STATE;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_SET_DEFAULT_PERCENTAGE: {
if (pdu->number_of_arguments == 2) {
uint8_t channel_number = pdu->arguments[0];
uint8_t default_percentage = pdu->arguments[1];
if (is_valid_channel(channel_number)) {
if (default_percentage >= 0 || default_percentage <= 100) {
set_default_dimmer_percentage(channel_number, default_percentage);
pdu->number_of_arguments = 0;
} else {
return ERROR_INVALID_PERCENTAGE;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_SET_DEFAULT_DIMMER_DIRECTION: {
if (pdu->number_of_arguments == 2) {
uint8_t channel_number = pdu->arguments[0];
uint8_t default_direction = pdu->arguments[1];
if (is_valid_channel(channel_number)) {
if (default_direction == 0 || default_direction == 1) {
set_default_dimmer_direction(channel_number, default_direction);
pdu->number_of_arguments = 0;
} else {
return ERROR_INVALID_STATE;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_RELOAD_CONFIGURATION: {
configuration_load();
pdu->number_of_arguments = 0;
break;
}
case OPCODE_SAVE_CONFIGURATION: {
configuration_save();
pdu->number_of_arguments = 0;
break;
}
case OPCODE_GET_OUTPUT_STATE: {
if (pdu->number_of_arguments == 1) {
uint8_t channel_number = pdu->arguments[0];
if (is_valid_channel(channel_number)) {
uint8_t output_state = get_output_state(channel_number);
pdu->number_of_arguments = 2;
pdu->arguments[0] = output_state;
pdu->arguments[1] = get_percentage(channel_number);
} else {
return ERROR_INVALID_CHANNEL_NUMBER;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_GET_INPUT_STATE: {
if (pdu->number_of_arguments == 1) {
uint8_t channel_number = pdu->arguments[0];
if (is_valid_channel(channel_number)) {
uint8_t switch_state = get_switch_state(channel_number);
pdu->number_of_arguments = 1;
pdu->arguments[0] = switch_state;
} else {
return ERROR_INVALID_CHANNEL_NUMBER;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_SWITCH_OUTPUT: {
if (pdu->number_of_arguments == 2) {
uint8_t channel_number = pdu->arguments[0];
if (is_valid_channel(channel_number)) {
uint8_t new_state = pdu->arguments[1];
if (new_state == STATE_OFF || new_state == STATE_ON) {
switch_output(channel_number, new_state);
pdu->number_of_arguments = 0;
} else {
return ERROR_INVALID_STATE;
}
} else {
return ERROR_INVALID_CHANNEL_NUMBER;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_DIM: {
if (pdu->number_of_arguments == 2) {
uint8_t channel_number = pdu->arguments[0];
if (is_valid_channel(channel_number)) {
uint8_t percentage = pdu->arguments[1];
if (percentage >= 0 || percentage <= 100) {
dim(channel_number, percentage);
pdu->number_of_arguments = 0;
} else {
return ERROR_INVALID_PERCENTAGE;
}
} else {
return ERROR_INVALID_CHANNEL_NUMBER;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
default: {
return ERROR_INVALID_OPCODE;
}
}
return 0;
}
int main(
int argc,
char **argv)
{
int nprocs;
int rank;
int num_nets;
int *net_ids;
char* anno;
lp_io_handle handle;
tw_opt_add(app_opt);
tw_init(&argc, &argv);
offset = 1;
if(argc < 2)
{
printf("\n Usage: mpirun <args> --sync=2/3 mapping_file_name.conf (optional --nkp) ");
MPI_Finalize();
return 0;
}
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
configuration_load(argv[2], MPI_COMM_WORLD, &config);
model_net_register();
svr_add_lp_type();
codes_mapping_setup();
net_ids = model_net_configure(&num_nets);
assert(num_nets==1);
net_id = *net_ids;
free(net_ids);
if(net_id != DRAGONFLY)
{
printf("\n The test works with dragonfly model configuration only! ");
MPI_Finalize();
return 0;
}
num_servers_per_rep = codes_mapping_get_lp_count("MODELNET_GRP", 1, "server",
NULL, 1);
configuration_get_value_int(&config, "PARAMS", "num_routers", anno, &num_routers_per_grp);
num_groups = (num_routers_per_grp * (num_routers_per_grp/2) + 1);
num_nodes = num_groups * num_routers_per_grp * (num_routers_per_grp / 2);
num_nodes_per_grp = num_routers_per_grp * (num_routers_per_grp / 2);
if(lp_io_prepare("modelnet-test", LP_IO_UNIQ_SUFFIX, &handle, MPI_COMM_WORLD) < 0)
{
return(-1);
}
tw_run();
model_net_report_stats(net_id);
if(lp_io_flush(handle, MPI_COMM_WORLD) < 0)
{
return(-1);
}
tw_end();
return 0;
}