event.c

Go to the documentation of this file.

/* **************************************************************
Copyright (C) 2010, 2011, 2012 Hewlett-Packard Development Company, L.P.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
version 2 as published by the Free Software Foundation.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 ************************************************************** */
/* local includes */
#include <event.h>
#include <logging.h>
#include <scheduler.h>

/* std libaray includes */
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

/* ************************************************************************** */
/* **** Local(private) fields *********************************************** */
/* ************************************************************************** */

event_loop_t vl_singleton;

int el_created = 0;

event_loop_t* event_loop_get()
{

  /* if the event loop has already been created, return it */
  if(el_created)
  {
    return &vl_singleton;
  }

  vl_singleton.queue = g_async_queue_new_full((GDestroyNotify)event_destroy);
  vl_singleton.occupied   = 0;
  vl_singleton.terminated = 0;
  el_created = 1;

  return &vl_singleton;
}

int event_loop_put(event_loop_t* event_loop, event_t* e)
{
  g_async_queue_push(event_loop->queue, e);
  return 1;
}

event_t* event_loop_take(event_loop_t* event_loop)
{
  GTimeVal timeout;
  event_t* ret;

  if(event_loop->terminated)
  {
    return NULL;
  }

  /* wait for 1 second */
  timeout.tv_sec  = 1;
  timeout.tv_usec = 0;

#if GLIB_MAJOR_VERSION >= 2 && GLIB_MINOR_VERSION >= 32
  if((ret = g_async_queue_timeout_pop(event_loop->queue,
      timeout.tv_sec * 1000000 + timeout.tv_usec)) == NULL)
    return ret;
#else
  g_get_current_time(&timeout);
  g_time_val_add(&timeout, 1000000);
  if((ret = g_async_queue_timed_pop(event_loop->queue, &timeout)) == NULL)
    return ret;
#endif

  if(ret->func == NULL)
  {
    event_destroy(ret);
    ret = NULL;
  }

  return ret;
}

/* ************************************************************************** */
/* **** Constructor Destructor ********************************************** */
/* ************************************************************************** */

event_t* event_init(void(*func)(scheduler_t*, void*), void* arg, char* name, char* source_name, uint16_t source_line)
{
  event_t* e = g_new(event_t, 1);

  e->func = func;
  e->argument = arg;
  e->name = name;
  e->source_name = source_name;
  e->source_line = source_line;

  return e;
}

void event_destroy(event_t* e)
{
  e->func     = NULL;
  e->argument = NULL;
  e->name     = NULL;

  g_free(e);
}

void event_loop_destroy()
{
  g_async_queue_unref(event_loop_get()->queue);
  el_created = 0;
}

/* ************************************************************************** */
/* **** EventLoop Functions ************************************************* */
/* ************************************************************************** */

void event_signal_ext(void* func, void* args, char* name, char* s_name, uint16_t s_line)
{
  V_EVENT("EVENT: creating event: [%p, %p, %s, %s, %d]", func, args, name, s_name, s_line);
  event_loop_put(event_loop_get(), event_init((event_function)func, args, name, s_name, s_line));
}

int event_loop_enter(scheduler_t* scheduler,
    void(*update_call)(scheduler_t*),
    void(*signal_call)(scheduler_t*))
{
  event_t* e;
  event_loop_t* event_loop = event_loop_get();

  /* start by checking to make sure this is the only thread in this loop */
  g_async_queue_lock(event_loop->queue);
  if(event_loop->occupied)
  {
    g_async_queue_unlock(event_loop->queue);
    return 0x1;
  }
  event_loop->occupied = 1;
  event_loop->terminated = 0;
  g_async_queue_unlock(event_loop->queue);

  main_thread = g_thread_self();

  /* from here on out, this is the only thread in this event loop     */
  /* the loop to execute events is very simple, grab event, run event */
  while(!event_loop->terminated)
  {
    e = event_loop_take(event_loop);

    if(signal_call)
      signal_call(scheduler);
    if(e == NULL)
      continue;

    if(TVERB_EVENT && strcmp(e->name, "log_event") != 0)
      log_printf("EVENT: calling %s, source[%s.%d] \n", e->name, e->source_name, e->source_line);
    e->func(scheduler, e->argument);

    if(TVERB_EVENT && strcmp(e->name, "log_event") != 0)
      log_printf("EVENT: finished %s, source[%s.%d] \n", e->name, e->source_name, e->source_line);

    event_destroy(e);

    if(update_call)
      update_call(scheduler);
  }

  return 0x0;
}

void event_loop_terminate()
{
  event_loop_t* event_loop = event_loop_get();

  event_loop->terminated = 1;
  event_loop->occupied = 0;
  event_signal(NULL, NULL);
}