Subversion Repositories shark

//fsf_implementation_specific.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

//

// FSF(FIRST Scheduling Framework) 

//implementation-defined optional functionality

//================================================

#include "fsf_basic_types.h"

#include "fsf_core.h"

#ifndef _FSF_IMPLEMENTATION_SPECIFIC_H_

#define _FSF_IMPLEMENTATION_SPECIFIC_H_

#define FSF_IMPLEMENTATION_SPECIFIC_MODULE_SUPPORTED     1

// The operations defined in this module are of optional use. They

// only work in the fixed priority implementation, and they may be

// used to enhance the behavior of the applications running under the

// fsf scheduler.

//// The definition of this type is in fsf_basic_types.h

//

//typedef unsigned long      fsf_preemption_level_t;

//                           // range 1..2**32-1

//fsf_set_contract_preemption_level: The operation updates the

//specified contract parameters object by setting its preemption level

//to the specified input parameter.

int

fsf_set_contract_preemption_level

  (fsf_contract_parameters_t     *contract,

   fsf_preemption_level_t         preemption_level);

//fsf_get_contract_preemption_level: The operation obtains from the

//specified contract parameters object its preemption level and copies

//it to the place pointed to by the specified input parameter.

int

fsf_get_contract_preemption_level

  (const fsf_contract_parameters_t *contract,

   fsf_preemption_level_t          *preemption_level);

//fsf_set_service_thread_preemption_level: this function sets the

//preemption level of the service thread to the specified value. The

//initial preemption level is a configurable parameter. This value

//is stored in a temporary variable and it is used the next time the

//service thread data is updated with the fsf_set_service_thread_data

//function

int

fsf_set_service_thread_preemption_level

  (fsf_preemption_level_t         preemption_level);

//fsf_get_service_thread_preemption_level: this function stores the

//current preemption level of the service thread in the variable

//pointed to by preemption_level

int

fsf_get_service_thread_preemption_level

  (fsf_preemption_level_t        *preemption_level);

//fsf_thread_exit: There is a limitation in the current version of the

//MaRTE implementation that causes the information of a terminated

//thread to continue to be stored in the fsf scheduler, and the thread

//to continue to be counted in the number of threads. The

//fsf_thread_exit operation allows the implementation to delete the

//thread's information, and then terminate the thread. Therefore, it

//is recommended to use this function to terminate a thread under fsf.

//This operation shall terminate the calling thread, make the value

//value_ptr available to any successful join with the terminating

//thread, and unbind the thread from its associated server. After

//cleaning up the thread management data, it is unbound and the

//scheduling policy is changed to fixed priority before the posix

//pthread_exit() function is called.

void

fsf_thread_exit (void *value_ptr);

//fsf_set_shared_obj_preemption_level: The operation updates the

//specified shared object by setting its preemption level

//to the specified input parameter. 

//OBSERVATION: if this value is changed being any contract that

//uses the resource already accepted, the system's behavior and

//particularly the acceptance tests correctness are not garantee

//and probably wrong.

int

fsf_set_shared_obj_preemption_level

  (fsf_shared_obj_handle_t  obj_handle,

   fsf_preemption_level_t   preemption_level);

//fsf_get_shared_obj_preemption_level: The operation obtains from the

//specified shared object its preemption level and copies

//it to the place pointed to by the specified input parameter.

int

fsf_get_shared_obj_preemption_level

  (fsf_shared_obj_handle_t  obj_handle,

   fsf_preemption_level_t  *preemption_level);

#endif // _FSF_IMPLEMENTATION_SPECIFIC_H_