Colony

/**

 * @file robot.c

 * @author Colony Project

 * @brief Simulator Robot Management

 *

 * Contains implementations of functions managing robots

 * in the simulator, including process control and memory

 * management.

 **/

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <signal.h>

#include <sys/wait.h>

#include <robot_shared.h>

#include <sys/ipc.h>

#include <sys/types.h>

#include <sys/shm.h>

#include <errno.h>

#include <pthread.h>

#include <err.h>

#include "robot.h"

#include "motion.h"

#include "gtk_gui.h"

void sig_chld_handler(int sig);

void robot_update(int i);

// global variables

int first_available_id = 0;

// an expanding array of robots

Robot* robots = NULL;

int robots_size = 0;

int num_robots = 0;

int iterator_pos = 0;

// signalled when all robots have run for a bit

pthread_mutex_t all_finished_mutex;

pthread_cond_t all_finished_cond;

int finished = 0;

int robots_initialize(void)

{

        int i;

        if (signal(SIGCHLD, sig_chld_handler) == SIG_ERR)

                return -1;

        robots_size = 10;

        robots = (Robot*)malloc(sizeof(Robot) * robots_size);

        if (!robots)

                return -1;

        memset(robots, 0, sizeof(Robot) * robots_size);

        for (i = 0; i < robots_size; i++)

                robots[i].id = -1;

        finished = 0;

        pthread_mutex_init(&all_finished_mutex, NULL);

        pthread_cond_init(&all_finished_cond, NULL);

        return 0;

}

/**

 * Creates a new robot. Returns its id on

 * success, or a negative integer on failure.

 **/

int robot_create(char *execname)

{

  int pid,i;

        int id = first_available_id;

        Robot* r = &robots[id];

        printf("ID: %d\n", id);

        // do shared memory stuff here

        key_t key = IPC_PRIVATE;

        //Memory accessible only to children with r/w privileges

        r->sharedMemID = shmget(key, sizeof(RobotShared), IPC_CREAT | 0666);

        //hack!! TODO: remove!!

        r->pose.x=first_available_id*100;

        r->pose.y=first_available_id*50;

        if(r->sharedMemID < 0)

        {

                fprintf(stderr, "Failed to get shared memory.\n");

                return -1;

        }

        r->shared = (RobotShared*)shmat(r->sharedMemID, NULL, 0);

        if(!(r->shared))

        {        

                //Free shared memory region

                if (!shmctl(r->sharedMemID, IPC_RMID, NULL))

                        fprintf(stderr, "Failed to free shared memory.\n");

                fprintf(stderr, "Error attaching memory to parent.\n");

                return -1;

        }

        // Initialize robot structure here

        r->shared->motor1 = 0;

        r->shared->motor2 = 0;

        r->id = id;

        if((pid = fork()) < 0)

        {

                //Free Shared Memory Region

                if (!shmdt(r->shared))

                        fprintf(stderr, "Failed to free shared memory.\n");

                if (!shmctl(r->sharedMemID, IPC_RMID, NULL))

                        fprintf(stderr, "Failed to free shared memory.\n");

                r->id = -1;

                fprintf(stderr, "Failed to fork robot process.\n");

                return -1;

        }

        if(!pid)

        {

          char var[21];

          /* restore default sigchld handler */

          signal(SIGCHLD, SIG_DFL);

          sprintf(var, "memory_id=%d", r->sharedMemID);

          putenv(var);

          //TODO: keep the other env. stuff around

          execv(execname, NULL);

          err(errno, "exec failed to run child process.\n");

        }

        else

        {

                r->pid = pid;

                do {

                        first_available_id++;

                } while (first_available_id < robots_size &&

                                robots[first_available_id].id != -1);

                // resize the array if necessary

                if (first_available_id >= robots_size)

                {

                        robots_size *= 2;

                        robots = realloc(robots, sizeof(Robot) * robots_size);

                        if (!robots)

                        {

                                fprintf(stderr, "Out of memory.\n");

                                return -1;

                        }

                        for (i = robots_size=first_available_id; i < robots_size; i++)

                          robots[i].id = -1;

                }

        }

        num_robots++;

        return id;

}

/**

 * Frees all resources associated with a robot, including

 * killing its process if necessary.

 *

 * @return zero on success, nonzero on failure

 **/

int robot_destroy(int id)

{

        Robot* r;

        if (id < 0 || id >= robots_size)

                return -1;

        r = &robots[id];

        if (r->id == 0)

                return -1;

    if (!shmdt(r->shared))

        {

                fprintf(stderr, "Failed to free shared memory.\n");

                return -1;

        }

        if (!shmctl(r->sharedMemID, IPC_RMID, NULL))

        {

                fprintf(stderr, "Failed to free shared memory.\n");

                return -1;

        }

        memset(r, 0, sizeof(Robot));

        r->id = -1;

        if (id < first_available_id)

                first_available_id = 0;

        return 0;

}

void robot_iterator_reset(void)

{

        iterator_pos = -1;

}

// note: addresses may change, replace with

// allocated memory

Robot* robot_iterator_next(void)

{

        if (iterator_pos >= robots_size)

                return NULL;

        do iterator_pos++;

        while (iterator_pos < robots_size && 

                        robots[iterator_pos].id == -1);

        if (iterator_pos >= robots_size)

                return NULL;

        return &(robots[iterator_pos]);

}

void sig_chld_handler(int sig)

{

  int ret,stat;

  pthread_mutex_lock(&all_finished_mutex);

  while((ret = waitpid(-1, &stat, WUNTRACED | WNOHANG)))

  {

    if(ret==-1)

      err(errno,"error waiting on robot");

    if(WIFSTOPPED(stat))

      finished++;

  }

  if (finished >= num_robots)

  {

    pthread_cond_signal(&all_finished_cond);

  }

  pthread_mutex_unlock(&all_finished_mutex);

}

void* robot_event_loop(void* arg)

{

        int i;

        //TODO: errors

        while (1)

        {

                pthread_mutex_lock(&all_finished_mutex);

                // TODO: race condition for adding robots?

                if (finished < num_robots)

                {

                        pthread_cond_wait(&all_finished_cond, &all_finished_mutex);

                }

                finished = 0;

                pthread_mutex_unlock(&all_finished_mutex);

                for (i = 0; i < robots_size; i++)

                        if (robots[i].id != -1)

                                robot_update(i);

                for (i = 0; i < robots_size; i++)

                {

                        if (robots[i].id == -1)

                                continue;

                        kill(robots[i].pid, SIGCONT);

                }

                gui_refresh();

        }

}

void robot_update(int i)

{

        Robot* r = &(robots[i]);

        if (r->id == -1)

                return;

        move_robot(r);

}