Subversion Repositories an-fpga-implementation-of-low-latency-noc-based-mpsoc

#ifndef ORCC_LIB_H
#define ORCC_LIB_H
 
#define MAX_ACTORS 1024
 
 
typedef signed char i8;
typedef short i16;
typedef int i32;
typedef long long int i64;
 
typedef unsigned char u8;
typedef unsigned short u16;
typedef unsigned int u32;
typedef unsigned long long int u64;
 
///////////////////////////////////////////////////
 
#ifndef CACHELINE_SIZE
#define CACHELINE_SIZE 4 // 
#endif
 
// Declare the FIFO structure with a size equal to (size)
#define DECLARE_FIFO(type, size, count, readersnb) static type array_##count[(size)]; \
static unsigned int read_inds_##count[readersnb] = {0}; \
static FIFO_T(type) fifo_##count = {{0}, read_inds_##count, {0}, 0, {0}, array_##count};
 
#define FIFO_T(T) FIFO_T_EXPAND(T)
#define FIFO_T_EXPAND(T) fifo_##T##_t
 
#define FIFO_GET_ROOM(T) FIFO_GET_ROOM_EXPAND(T)
#define FIFO_GET_ROOM_EXPAND(T) fifo_ ## T ## _get_room
 
#define FIFO_GET_NUM_TOKENS(T) FIFO_GET_NUM_TOKENS_EXPAND(T)
#define FIFO_GET_NUM_TOKENS_EXPAND(T) fifo_ ## T ## _get_num_tokens
 
/* Define structure and methods for all types thanks to macro expansion */
 
#define T i8
#include "generic_fifo.h"
#undef T
 
#define T i16
#include "generic_fifo.h"
#undef T
 
#define T i32
#include "generic_fifo.h"
#undef T
 
#define T i64
#include "generic_fifo.h"
#undef T
 
#define T u8
#include "generic_fifo.h"
#undef T
 
#define T u16
#include "generic_fifo.h"
#undef T
 
#define T u32
#include "generic_fifo.h"
#undef T
 
#define T u64
#include "generic_fifo.h"
#undef T
 
#define T float
#include "generic_fifo.h"
#undef T
 
//#endif  /* _ORCC_FIFO_H_ */
 
///////////////////////////////////////////////////
 
 
typedef int boolean;
#define TRUE  1
#define FALSE 0
 
/* Scheduling strategy codes */
typedef enum {
    ORCC_SS_ROUND_ROBIN,
    ORCC_SS_DD_DRIVEN, /* data-driven & demand-driven */
    ORCC_SS_SIZE /* only used for string tab declaration */
} schedstrategy_et;
 
/* Mapping strategy codes */
typedef enum {
#ifdef METIS_ENABLE
    ORCC_MS_METIS_REC,
    ORCC_MS_METIS_KWAY_CV,
    ORCC_MS_METIS_KWAY_EC,
#endif /* METIS_ENABLE */
    ORCC_MS_ROUND_ROBIN,
    ORCC_MS_QM,
    ORCC_MS_WLB,
    ORCC_MS_COWLB,
    ORCC_MS_KRWLB,
    ORCC_MS_SIZE /* only used for string tab declaration */
} mappingstrategy_et;
 
typedef enum reasons {
    starved,
    full
} reasons_t;
 
typedef struct actor_s actor_t;
typedef struct waiting_s waiting_t;
typedef struct agent_s agent_t;
typedef struct action_s action_t;
typedef struct local_scheduler_s local_scheduler_t;
typedef struct schedinfo_s schedinfo_t;
typedef struct options_s options_t;
typedef struct global_scheduler_s global_scheduler_t;
typedef struct mapping_s mapping_t;
typedef struct network_s network_t;
typedef struct connection_s connection_t;
 
/*
 * Actors are the vertices of orcc Networks
 */
struct actor_s {
    char *name;
    void (*init_func)(schedinfo_t *);
    void (*sched_func)(schedinfo_t *);
    int num_inputs; /** number of input ports */
    int num_outputs; /** number of output ports */
    int in_list; /** set to 1 when the actor is in the schedulable list. Used by add_schedulable to do the membership test in O(1). */
    int in_waiting; /** idem with the waiting list. */
    local_scheduler_t *sched; /** scheduler which execute this actor. */
    int processor_id; /** id of the processor core mapped to this actor. */
    int id;
    int commCost;  /** Used by Quick Mapping algo */
    int triedProcId;  /** Used by Quick Mapping algo */
    int evaluated;  /** Used by KL algo */
    int workload; /** actor's workload */
    double ticks; /** elapsed ticks obtained by profiling */
    action_t **actions;
    int nb_actions;
    double scheduler_workload;
    char *class_name;
    int firings; /** nb of firings for profiling */
    int switches; /** nb of switches for profiling */
    int misses; /** nb of misses for profiling */
};
 
 
struct waiting_s {
    actor_t *waiting_actors[MAX_ACTORS];
    volatile unsigned int next_entry;
    unsigned int next_waiting;
};
 
 
 
struct agent_s {
    options_t *options; /** Mapping options */
    global_scheduler_t *scheduler;
    network_t *network;
    mapping_t *mapping;
    int nb_threads;
#ifdef THREADS_ENABLE
    orcc_semaphore_t sem_agent;
#endif
};
 
 
/*
 * Actions
 */
struct action_s {
    char *name;
    double workload; /** action's workload */
    double ticks; /** elapsed ticks obtained by profiling */
    double min_ticks; /** elapsed min clockcycles obtained by profiling */
    double avg_ticks; /** elapsed average clockcycles obtained by profiling */
    double max_ticks; /** elapsed max clockcycles obtained by profiling */
    double variance_ticks; /** elapsed clockcycles variance obtained by profiling */
    int firings; /** nb of firings for profiling */
};
 
 
 
struct schedinfo_s {
    int num_firings;
    reasons_t reason;
    int ports; /** contains a mask that indicate the ports affected */
};
 
struct options_s
{
    /* Video specific options */
    char *input_file;
    char *input_directory;               // Directory for input files.
 
    /* Video specific options */
    char display_flags;                  // Display flags
    int nbLoops;                         // (Deprecated) Number of times the input file is read
    int nbFrames;                        // Number of frames to display before closing application
    char *yuv_file;                      // Reference YUV file
 
    /* Runtime options */
    schedstrategy_et sched_strategy;     // Strategy for the actor scheduling
    char *mapping_input_file;            // Predefined mapping configuration
    char *mapping_output_file;           //
    int nb_processors;
    boolean enable_dynamic_mapping;
    mappingstrategy_et mapping_strategy; // Strategy for the actor mapping
    int nbProfiledFrames;                // Number of frames to display before remapping application
    int mapping_repetition;              // Repetition of the actor remapping
 
    char *profiling_file; // profiling file
    char *write_file; // write file
 
    /* Debugging options */
    boolean print_firings;
};
 
 
 
struct global_scheduler_s {
    local_scheduler_t **schedulers;
    int nb_schedulers;
    agent_t *agent;
};
 
/*
 * Mapping structure store the mapping result
 */
struct mapping_s {
    int number_of_threads;
    int *threads_affinities;
    actor_t ***partitions_of_actors;
    int *partitions_size;
};
 
/*
 * Orcc Networks are directed graphs
 */
struct network_s {
    char *name;
    actor_t **actors;
    connection_t **connections;
    int nb_actors;
    int nb_connections;
};
 
/*
 * Connections are the edges of orcc Networks
 */
struct connection_s {
    actor_t *src;
    actor_t *dst;
    int workload; /** connections's workload */
    long rate; /** communication rate obtained by profiling */
};
 
 
 
 
 
struct local_scheduler_s {
    int id; /** Unique ID of this scheduler */
    int nb_schedulers;
    schedstrategy_et strategy; /** Scheduling strategy */
 
    /* Round robin */
    int num_actors; /** number of actors managed by this scheduler */
    actor_t **actors; /** static list of actors managed by this scheduler */
    int rr_next_schedulable; /** index of the next actor to schedule in last list */
 
    /* Data demand/driven scheduler */
    actor_t *schedulable[MAX_ACTORS]; /** dynamic list of the next actors to schedule */
    unsigned int ddd_next_entry; /** index of the next actor to schedule in last list */
    unsigned int ddd_next_schedulable; /** index of next actor added in the list */
 
    /* Multicore with data demand/driven scheduler */
    int round_robin; /** set to 1 when last scheduled actor is a result of round robin scheduling */
    waiting_t **waiting_schedulable; /** receiving lists from other schedulers of some actors to schedule */
 
    /* Mapping synchronization */
    agent_t *agent;
#ifdef THREADS_ENABLE
    orcc_semaphore_t sem_thread;
#endif
};
 
 
 
 
 
 
/*
 
 
// a simple delay function
 
void delay ( unsigned int num ){
 
	while (num>0){ 
		num--;
		nop(); // asm volatile ("nop");
	}
	return;
 
}
 
#ifndef RANDOM_H
	#define RANDOM_H
 
// KISS is one random number generator according to three numbers.
static unsigned int x=123456789,y=234567891,z=345678912,w=456789123,c=0; 
 
unsigned int JKISS32() { 
    unsigned int t; 
 
    y ^= (y<<5); y ^= (y>>7); y ^= (y<<22); 
 
    t = z+w+c; z = w; c = t < 0; w = t&2147483647; 
 
    x += 1411392427; 
 
    return x + y + w; 
}
 
unsigned int rand(void){
	return JKISS32();
}
 
void srand(unsigned int seed){
	x^=seed; y+=seed; z^=seed; w-=seed;
}
 
#endif
*/
 
#endif