/home/mesh/mesh/include/mesh_kernel.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_KERNEL_H
#define MESH_KERNEL_H

#include <string.h>
#include <trash_stack.h>
#include <stdarg.h>
#include <gpriq.h>


extern pthread_key_t buffer_key;
extern mesh_thread *kernel_thread;
// These efficiently allocate/free new feature arrays. They may only
// be used after mesh_init() and before mesh_cleanup()
extern trash_stack *feature_stack;

#define mesh_new_feature_array() mesh_trash_stack_alloc0(feature_stack)
#define mesh_free_feature_array(array) mesh_trash_stack_free(feature_stack, array)

//do the same for shared resource slices
extern trash_stack *SR_slice_stack;

#define mesh_new_SR_slice() mesh_trash_stack_alloc0(SR_slice_stack)
#define mesh_free_SR_slice(slice) mesh_trash_stack_free(SR_slice_stack, slice)


typedef gint (*GPFunc)(gpointer, gpointer);

void g_slist_vsplit(GSList **src, GPFunc f, gpointer arg, int N, ...);

void g_slist_split(GSList **src, GPFunc f, gpointer arg, int N, GSList *dest[]);

void mesh_init(gint verbose);

void mesh_load_config_file(gchar* config_file);

//turns on the memory/SR model
void mesh_mem_model_init();

void mesh_kernel();

mesh_feature_list *mesh_create_feature_list();

// mark a feature as not being split
gint mesh_feature_nosplit(gchar *feature);

mesh_feature_list *mesh_feature_add(mesh_feature_list *cfl, gchar *feature, double power);

gint mesh_get_feature_index_by_name(gchar *name);

mesh_mem_controller *mesh_create_mem_controller(gchar *name,
                           gint (*schedule_mem)(gint res_id, gint block_id));

//lets the resource know which mem controller will handle its memory
//accesses
void mesh_register_mem_controller(mesh_resource *cr,
                             mesh_mem_controller *memc);

mesh_mem_resource *mesh_create_mem_resource(gchar *name,
                         double time_per_access,
                         float (*contention_model)(mesh_access_statistics *),
                         void (*arbitration_model)(float, GPriq *),
                         gint resource_id);


mesh_resource *mesh_create_resource(gchar *name, // textual description
                    mesh_feature_list *cfl, // features this resource accepts
                    mesh_scheduler *cs, // scheduler responsible for this resource
                    // function that resolves consume calls to physical time
                    double (*timing_resolution)(mesh_resource *, GSList *),
                    double default_power
                    );

mesh_resource *mesh_create_shared_resource(gchar  *name,
                           mesh_feature_list *cfl,
                           double (*timing_resolution)
                            (mesh_resource*,double *),
                           void (*contention)
                            (mesh_resource *, GSList *, mesh_time),
                           double default_power);

mesh_scheduler *mesh_create_scheduler(gchar *name, // textual description
                     // function that executes scheduling algorithm
                     GSList * (*execute_scheduler)(mesh_scheduler *));

mesh_scheduler *mesh_set_sched_resource(mesh_scheduler *cs, mesh_resource *cr);



mesh_scheduler *mesh_create_shared_scheduler(gchar *name, // textual description
                     // function that executes scheduling algorithm
                     void (*execute_shared)(mesh_scheduler *,GSList *,mesh_time));


mesh_thread *mesh_define_thread(gchar *name, // textual description
                  mesh_scheduler *execution_scheduler, // default execution scheduler
                  void *(*thread)(void *), // actual thread of user program
                  void *arg // argument to pass this thread
                  );

void mesh_start_thread(mesh_thread *thread);

void mesh_start_thread_delayed(mesh_thread *thread);

mesh_thread *mesh_create_thread(gchar *name, // textual description
                  mesh_scheduler *execution_scheduler, // default execution scheduler
                  void *(*thread)(void *), // actual thread of user program
                  void *arg // argument to pass this thread
                  );

mesh_thread *mesh_create_thread_delayed(gchar *name, // textual description
                  mesh_scheduler *execution_scheduler, // default execution scheduler
                  void *(*thread)(void *), // actual thread of user program
                  void *arg // argument to pass this thread
                  );

void mesh_squash_thread(mesh_thread *ct);

mesh_scheduler * mesh_get_scheduler_by_name(gchar *name);

// given a name, return a shared resource
mesh_resource *mesh_get_sr_by_name(gchar *name);

mesh_thread * mesh_get_thread_by_name(gchar *name);

void mesh_cleanup();

mesh_time mesh_getTime();

//This function will step through each shared resource access and
//estimate the amount of time that will take to service a
//non-contended access.  Additionally, it will sort the shared
//resource accesses acording to the S.R. accessed and populate the
//shared_contention_list.  Returns a value that is a sum of estimates
//for every shared resource access
mesh_time process_shared_resource_data(GSList **shared_contention_list,
                                       mesh_consume_data *cc,
                                       mesh_resource *resource);

void mesh_set_label_watch_output(gchar *filename);

void mesh_label_watch(gchar *name);

void mesh_set_error(mesh_time error);

void mesh_print_blocked_threads(gboolean flag);

void mesh_print_not_completed_threads(gboolean flag);

void mesh_print_thread_usage(gboolean flag);

void mesh_execute_at_commit(void (*function)(mesh_consume_data *));

void mesh_execute_at_stall(void (*function)(mesh_resource *, mesh_thread *));

void mesh_execute_at_finish(void (*function)(mesh_resource *, mesh_thread *));

void mesh_execute_at_interrupt(void (*function)(mesh_resource *, mesh_thread *));

void mesh_execute_at_squash(void (*function)(mesh_resource *, mesh_thread *));

void mesh_scheduler_is_eligible(mesh_scheduler *cs);

void mesh_thread_is_eligible(mesh_thread *mt);

void mesh_thread_is_not_eligible(mesh_thread *mt);

inline static mesh_thread *mesh_kernel_thread() {
    return kernel_thread;
}

mesh_time mesh_thread_created_at(mesh_thread *ct);

mesh_time mesh_thread_finished_at(mesh_thread *ct);

inline static mesh_thread *mesh_current_thread() {
    return pthread_getspecific(buffer_key);
}

void mesh_create_interrupt(mesh_resource *resource, gchar *name, gboolean maskable, 
                        void *(*isr)(void *), void *arg);

void mesh_set_interrupt_controller(mesh_resource *resource,
                              char* (*)(void *, GSList **p), 
                              void *arg);

void mesh_raise_interrupt(mesh_resource *cr, gchar *name);

void mesh_disable_interrupt(gchar *name);

void mesh_enable_interrupt(gchar *name);

gboolean mesh_is_interrupt_enabled(gchar *name, gboolean explicit, mesh_thread *thread);

// De-allocate all the memory associated with a given feature list.
void mesh_free_feature_list(mesh_feature_list *cfl);

// create and return a copy of the specified feature list
mesh_feature_list *mesh_copy_feature_list(mesh_feature_list *cfl);

// adds a consume call for the specified resource
void mesh_insert_consume(mesh_resource *cr, mesh_consume_data *cc);

//creates an untimed thread
mesh_thread *mesh_create_untimed_thread(gchar *name,
                           void *(*thread)(void *),
                           void *arg,
                           gboolean trace_visible);

// wakes up the kernel thread. If 'should_block' is TRUE this function
// will not return until the kernel goes back to sleep; otherwise it
// returns immediately. WARNING: this function should never be called
// directly by user threads.
void __mesh_local_to_kernel(mesh_pthread *pt, gboolean should_block);


// Routines to handle generic synchronization primitives
mesh_synchronization *mesh_create_synchronization(gint type);
gint mesh_destroy_synchronization(mesh_synchronization *cs);
gint mesh_synchronization_wakeup_delayed(mesh_thread *mt, mesh_synchronization *cs);
gint mesh_synchronization_wakeup(mesh_synchronization *cs);
gint mesh_synchronization_add_to_wait_list(mesh_synchronization *cs, mesh_thread *ct);


#endif