Subversion Repositories shark

//fsf_configuration_parameters.h
//===============================================================
//       FFFFFFIII   RRRRR      SSTTTTTTT
//      FF         IIR   RR    SS
//     FF           IR        SS
//    FFFFFF         RRRR    SSSSST
//   FF       FI       RRR  SS
//  FF         II     RRR  SS
// FF           IIIIIR    RS
//
// Basic FSF(FIRST Scheduling Framework) configuration parameters
//==============================================================

//////////////////////////////////////////////////////
// Definitions required to configure the fsf
// scheduling algorithms.

#include <unistd.h>
#include "stdbool.h"

#ifndef _FSF_CONFIGURATION_PARAMETERS_H_
#define _FSF_CONFIGURATION_PARAMETERS_H_

// This symbol specifies whether the scheduler will make a
// schedulability test of the requested contract or not

#define FSF_ADMISSION_TEST_IS_ENABLED        true


// Tune these values for optimizing the amount of memory used by the
// implementation

// Maximum number of accepted contracts (servers)

#define FSF_MAX_N_SERVERS                    125


// Maximum number of threads that may be scheduled by the framework

#define FSF_MAX_N_THREADS                    25


// Maximum number of critical sections that can be stored in a
// contract parameters object

#define FSF_MAX_N_CRITICAL_SECTIONS          10


// Maximum number of utilization values (pairs of budget and period)
// that can be stored in a contract parameters object

#define FSF_MAX_N_UTILIZATION_VALUES         5


// Maximum number of synchronization objects

#define FSF_MAX_N_SYNCH_OBJECTS              5


// Maximum number of shared objects

#define FSF_MAX_N_SHARED_OBJECTS             100


////////////////////////////////////////////
// Other implementation dependent parameters

// The current implementation in MaRTE OS uses the Application-Defined
// Scheduling Interface (proposed to the POSIX standardization
// committee), to create a fixed-priority-based scheduler that
// operates under the rules of the FIRST scheduling framework.

// In this implementation there are two special threads:
//   - The application scheduler thread, that
//     implements the scheduler

//   - The service thread, that is in charge of
//     negotiating and renegotiating contracts
//     concurrently with the application

// The following symbols are necessary to adapt the application to the
// underlying fixed priority scheduler

// Priority assigned to the application scheduler; it should be above
// the priorities of the application threads and of the service
// thread, and it should be at least 1 level below the maximum of the
// system

#define FSF_SCHEDULER_PRIORITY               104


// Real-time signal number reserved for the application scheduler to
// manage its timers.

#define FSF_SCHEDULER_SIGNAL                 SIGRTMIN


// The highest priority that can be assigned to an application thread,
// it should be defined as one level less than the
// FSF_SCHEDULER_PRIORITY

#define FSF_HIGHEST_THREAD_PRIORITY  FSF_SCHEDULER_PRIORITY-1


// The lowest priority that can be assigned to an application thread,
// it should be at least 1 level above the minimum of the system

#define FSF_LOWEST_THREAD_PRIORITY           3

// Each call to the functions that negotiate or renegotiate a contract
// or that change the quality and importance generates a request for
// the service thread that we call a service job.  This job will be
// pending in a queue until executed by the service thread.  The
// following symbol represents the maximum number of requests that can
// be simultaneously queued.
#define FSF_MAX_N_SERVICE_JOBS  FSF_MAX_N_SERVERS * 2

// In order to bound the background activity of the scheduler (i.e.,
// the admission tests necessary for the negotiation and
// re-negotiation of contracts), a service thread has been defined. It
// runs at a given priority level and has a budget and period
// assigned.


// Initial period of the service thread (timespec)

#define FSF_SERVICE_THREAD_PERIOD  {0,10000000}  //0.1 seg  //3.1 0.01


// Initial budget of the service thread (timespec)

#define FSF_SERVICE_THREAD_BUDGET  {0,1000000}   //0.01 seg //3.1 0.001


// Initial priority of the service thread, it has to be lower than the
// FSF_SCHEDULER_PRIORITY, and is set according to its period and the
// expected response times for reconfiguration or tunning of the
// system.

#define FSF_SERVICE_THREAD_PRIORITY          FSF_LOWEST_THREAD_PRIORITY+1 //3 3    //3 1



//Maximum number of servers that can be simultaneusly waiting for
//being signaled in a synchronization object

#define FSF_MAX_N_SERVERS_IN_SYNCH_OBJECT    4


//Maximum number of events that can be pending to be signaled in a
//synchronization object

#define FSF_MAX_N_EVENTS_IN_SYNCH_OBJECT    100  


//Maximum number of pending replenishments in each sporadic server

#define FSF_MAX_N_PENDING_REPLENISHMENTS     1050   //25


//Maximum number of target windows in a table driven schedule

#define FSF_MAX_N_TARGET_WINDOWS             100

//The cpu time given by the round robin scheduler
//to the threads in the background (timespec)

#define FSF_RR_SLICE_CPU_TIME               {0,100000000}  //3  0.1 sec

// This function must be supplied by the user to map the preemption
// level values given in the contracts for the servers, to priority
// values in the range that is allowed by the present implementation
// for application threads. The value returned by the function must
// fit in the interval defined by the constants:
// [FSF_LOWEST_THREAD_PRIORITY, FSF_HIGHEST_THREAD_PRIORITY]

int
fsf_priority_map (unsigned long plevel);

// This symbol specifies the maximum number of chars that are stored
// of a given shared_object_id, so this is the maximum length used
// in comparissons

#define FSF_MAX_SIZE_SHARED_OBJ_ID           65


#endif /* _FSF_CONFIGURATION_PARAMETERS_H_ */