1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
/* -*- C++ -*- */
/**
* @file Kokyu.h
*
* $Id$
*
* @author Venkita Subramonian (venkita@cs.wustl.edu)
*
* Based on previous work by Tim Harrison (harrison@cs.wustl.edu),
* Chris Gill, Carlos O'Ryan and other members of the DOC group.
*/
#ifndef KOKYU_H
#define KOKYU_H
#include "ace/pre.h"
#include "ace/OS.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
#include "ace/Array.h"
#include "ace/Time_Value.h"
#include "ace/Auto_Ptr.h"
#include "ace/Message_Block.h"
#include "ace/Sched_Params.h"
#include "kokyu_export.h"
namespace Kokyu
{
typedef long Priority_t;
typedef ACE_Time_Value Deadline_t; //absolute deadline
typedef ACE_Time_Value Execution_Time_t; //execution time
enum Dispatching_Type_t
// Defines the type of prioritization strategy
// to be used by a dispatching queue
{
FIFO_DISPATCHING,
DEADLINE_DISPATCHING,
LAXITY_DISPATCHING
};
enum Criticality_t
// Defines the criticality of the operation.
// For use with Dynamic Scheduler.
{
VERY_LOW_CRITICALITY,
LOW_CRITICALITY,
MEDIUM_CRITICALITY,
HIGH_CRITICALITY,
VERY_HIGH_CRITICALITY
};
enum Importance_t
// Defines the importance of the operation,
// which can be used by the Scheduler as a
// "tie-breaker" when other scheduling
// parameters are equal.
{
VERY_LOW_IMPORTANCE,
LOW_IMPORTANCE,
MEDIUM_IMPORTANCE,
HIGH_IMPORTANCE,
VERY_HIGH_IMPORTANCE
};
struct ConfigInfo
{
Priority_t preemption_priority_;
// OS priority of the dispatching thread associated with the queue
Priority_t thread_priority_;
// type of dispatching queue
Dispatching_Type_t dispatching_type_;
};
typedef ACE_Array<ConfigInfo> ConfigInfoSet;
struct QoSDescriptor
{
Priority_t preemption_priority_;
Deadline_t deadline_;
Execution_Time_t execution_time_;
Importance_t importance_;
};
class Kokyu_Export Dispatch_Command
{
public:
Dispatch_Command(int dont_delete = 0);
/// Command callback
virtual int execute () = 0;
int can_be_deleted () const;
void destroy (void);
protected:
/// Destructor
// only inheritance is possible and object should be on heap,
// since object could be handed over to a different thread.
virtual ~Dispatch_Command (void);
private:
int dont_delete_;
};
class Dispatcher_Impl;
class DSRT_Dispatcher_Impl;
enum DSRT_Sched_t {SCHED_MIF, SCHED_EDF};
struct DSRT_ConfigInfo
{
ACE_Sched_Params::Policy sched_policy_;
int sched_scope_;
};
typedef int guid_t;
class Kokyu_Export DSRT_Dispatcher
{
public:
int schedule (guid_t guid, const QoSDescriptor&);
int update_schedule (guid_t guid, const QoSDescriptor&);
int cancel_schedule (guid_t guid, const QoSDescriptor&);
void implementation (DSRT_Dispatcher_Impl*);
private:
DSRT_Dispatcher_Impl* dispatcher_impl_;
};
class Kokyu_Export Dispatcher
{
public:
int dispatch (const Dispatch_Command*, const QoSDescriptor&);
int shutdown ();
void implementation (Dispatcher_Impl*);
private:
auto_ptr<Dispatcher_Impl> dispatcher_impl_;
};
class Kokyu_Export Dispatcher_Factory
{
public:
//@@ Should we return auto_ptr<Dispatcher> instead?
static Dispatcher* create_dispatcher (const ConfigInfoSet&);
static DSRT_Dispatcher* create_DSRT_dispatcher (const DSRT_ConfigInfo&);
};
} //end of namespace
#if defined (__ACE_INLINE__)
#include "Kokyu.i"
#endif /* __ACE_INLINE__ */
#include "Dispatcher_Impl.h"
#include "DSRT_Dispatcher_Impl.h"
#include "ace/post.h"
#endif /* KOKYU_H */
|
