/home/mesh/mesh/include/mesh_syscalls.h

Go to the documentation of this file.

/*************************************************************************
    This file is part of MESH.

    MESH is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    MESH 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 MESH.  If not, see <http://www.gnu.org/licenses/>.
**************************************************************************/
#ifndef MESH_SYSCALLS_H
#define MESH_SYSCALLS_H

void mesh_consume_str(const gchar *str,...);

void mesh_consume_str_no_sched(const gchar *str,...);

void mesh_consume_str_and_exit(const gchar *format, ...);

void mesh_sched_consume_str(mesh_resource *cr, const gchar *str,...);

// consume call that consumes a given number of mesh cycles
void mesh_consume_delay(mesh_resource *cr, mesh_time delay);

void mesh_lightweight_consume_str(const gchar *str,...);

// Applies a scheduling penalty to a resource
void mesh_sched_consume(mesh_resource *cr, double cost);

// returns the default power of a resource
double mesh_get_default_resource_power(mesh_resource *cr);

//unparsed versions of consume calls that do not take strings as
//arguments.  Instead the format is: mesh_consume([default consume],[#
//mem pairs],[no accesses],[block id],...)
void mesh_lightweight_consume(double cost, int no_mem_pairs, ...);

void mesh_consume(double cost, int no_mem_pairs, ...);

// commits any lightweight consume calls that have been made, allowing
// scheduling decisions for individual consume calls. This is the
// lightweight equivalent of mesh_consume_str().
void mesh_lightweight_commit();

// commits outstanding lightweight consume calls without allowing the
// scheduler to run at all. This is the lightweight equivalent of
// mesh_consume_str_no_sched().
void mesh_lightweight_commit_no_sched();

// commits outstanding lightweight consume calls. Individual consume
// calls will all execute as a group (on the same resource), but the
// thread will be subject to scheduling after they complete.
void mesh_lightweight_commit_group();

// causes lightweight consumes to be automatically committed when the
// size of a consume trace size reaches the threshold value. By
// default the threshold is set to a value that typically performs
// well. Use a negative threshold to restore the default or a zero
// threshold to disable autocommits completely.
void mesh_lightweight_autocommit(int threshold);

void mesh_yield();

// parses consume string, returns a completed consume data structure
mesh_consume_data *parse_consume_string(gchar *str);

// These functions can be used by user threads to store
// thread specific data.  It can either be a pointer to a
// dynamically allocated structure, or a simple integer
// stuffed into a pointer
void mesh_thread_setspecific(void *data);
void * mesh_thread_getspecific();

void mesh_thread_create_entry(mesh_thread *cr, gchar *key, void *value);
gboolean mesh_thread_has_entry(mesh_thread *cr, gchar *key, void **value);
void *mesh_thread_get_entry(mesh_thread *cr, gchar *key);
void mesh_thread_set_entry(mesh_thread *cr, gchar *key, void *value);

void mesh_resource_create_entry(mesh_resource *cr, gchar *key, void *value);
void *mesh_resource_get_entry(mesh_resource *cr, gchar *key);
void mesh_resource_set_entry(mesh_resource *cr, gchar *key, void *value);

void mesh_scheduler_create_entry(mesh_scheduler *cs, gchar *key, void *value);

void *mesh_scheduler_get_entry(mesh_scheduler *cs, gchar *key);

void mesh_scheduler_set_entry(mesh_scheduler *cs, gchar *key, void *value);

void mesh_thread_inc_counter(double);

double mesh_thread_get_and_clear_counter();

/* Synchronization Primitives

   These are modeled after the corresponding pthread calls and can be
   used in the same way.  All structure types are prefixed with mesh_thread
   instead of pthread, but otherwise the calling conventions are similar.

*/

gint mesh_thread_sem_init ( mesh_thread_sem *sem, gint pshared,
                            unsigned int value );
gint mesh_thread_sem_wait ( mesh_thread_sem *sem );
gint mesh_thread_sem_trywait ( mesh_thread_sem *sem );

gint mesh_thread_sem_post ( mesh_thread_sem *sem );

gint mesh_thread_sem_getvalue ( mesh_thread_sem *sem, int *sval );
gint mesh_thread_sem_destroy ( mesh_thread_sem *sem );

gint mesh_thread_sem_post_delayed ( mesh_thread_sem *sem );

gint mesh_thread_mutex_init(mesh_thread_mutex *mutex, void *attr);

gint mesh_thread_mutex_lock(mesh_thread_mutex *mutex);

gint mesh_thread_mutex_unlock(mesh_thread_mutex *mutex);

gint mesh_thread_mutex_unlock_delayed(mesh_thread_mutex *mutex);

gint mesh_thread_mutex_destroy(mesh_thread_mutex *mutex);

gint mesh_thread_mutex_trylock(mesh_thread_mutex *mutex);

// Condition Variables
gint mesh_thread_cond_init(mesh_thread_cond *cond, void *attr);
gint mesh_thread_cond_signal(mesh_thread_cond *cond);
gint mesh_thread_cond_broadcast(mesh_thread_cond *cond);
gint mesh_thread_cond_signal_delayed(mesh_thread_cond *cond);
gint mesh_thread_cond_broadcast_delayed(mesh_thread_cond *cond);
gint mesh_thread_cond_wait(mesh_thread_cond *cond, mesh_thread_mutex *mutex);
gint mesh_thread_cond_timedwait(mesh_thread_cond *cond, mesh_thread_mutex *mutex,
                               const struct timespec *abstime);
gint mesh_thread_cond_destroy(mesh_thread_cond *cond);

// Thread Joining
gint mesh_thread_join(mesh_thread *ct, void **retval);

// perform a delayed free()
void mesh_free_delayed(void *arg);

// Perform a delayed value move
void *mesh_memcpy_delayed(void *dest, const void *src, size_t n);

//Exit simulation
void mesh_exit();

//delays the untimed thread for a certain number of simulation cycles
//(kind of an untimed thread consume call)
void mesh_untimed_wait_for(mesh_time time);

// Stop the current thread from executing, and allow the kernel
// to schedule a different one.  This is used to execute a consume
// call, as well as any blocking synchronization operations.
void return_control_to_kernel(mesh_thread *ct,
                              mesh_scheduling_policy policy);

#endif