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
|
// $Id$
// ============================================================================
//
// = LIBRARY
// tests
//
// = FILENAME
// Priority_Task_Test.cpp
//
// = DESCRIPTION
// This is a simple test to illustrate the priority mechanism of
// ACE Tasks.
//
// = AUTHOR
// Doug Schmidt
//
// ============================================================================
#include "ace/Task.h"
#include "ace/Sched_Params.h"
#include "test_config.h"
#if defined (ACE_HAS_THREADS)
class Priority_Task : public ACE_Task<ACE_MT_SYNCH>
{
public:
Priority_Task (void);
int open (void *);
int svc (void);
private:
int priority_;
};
Priority_Task::Priority_Task (void)
: ACE_Task<ACE_MT_SYNCH> (ACE_Thread_Manager::instance ()),
priority_ (0)
{
}
int
Priority_Task::open (void *arg)
{
this->priority_ = *(int *) arg;
long flags = THR_NEW_LWP;
// To get FIFO scheduling with PTHREADS.
flags |= THR_SCHED_FIFO;
// Become an active object.
if (this->activate (flags, 1, 0, this->priority_) == -1)
{
// On Linux, only the superuser can set the policy to other than
// ACE_SCHED_OTHER. But with ACE_SCHED_OTHER, there is only 1
// thread priority value, 0. So, let the superuser run an
// interesting test, but for other users use priority 0.
ACE_DEBUG ((LM_DEBUG, "(%t) task activation at priority %d with flags "
"%ld failed; retry at priority 0 with with flags "
"%ld\n",
this->priority_, flags, THR_NEW_LWP));
flags = THR_NEW_LWP;
this->priority_ = 0;
if (this->activate (flags, 1, 1, this->priority_) == -1)
ACE_DEBUG ((LM_ERROR, "(%t) task activation at priority 0 failed, exiting!\n%a", -1));
}
return 0;
}
int
Priority_Task::svc (void)
{
ACE_hthread_t thr_handle;
ACE_Thread::self (thr_handle);
int prio;
if (ACE_Thread::getprio (thr_handle, prio) == -1)
ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "getprio failed"), -1);
ACE_DEBUG ((LM_DEBUG, "(%t) prio = %d, priority_ = %d\n",
prio, this->priority_));
ACE_ASSERT (this->priority_ == prio);
return 0;
}
#endif /* ACE_HAS_THREADS */
int
main (int, char *[])
{
ACE_START_TEST ("Priority_Task_Test");
#if defined (ACE_HAS_THREADS)
Priority_Task tasks[ACE_MAX_ITERATIONS];
int i;
// Spawn off ACE_MAX_ITERATIONS of tasks, passing each one their
// iteration number as their priority.
// NOTE: on Solaris, for example, this requests the min FIFO
// priority. But, this test doesn't use the Realtime scheduling
// class. The FIFO priorities are used because they're all nonnegative.
int priority = ACE_Sched_Params::priority_min (ACE_SCHED_FIFO,
ACE_SCOPE_THREAD);
for (i = 0; i < ACE_MAX_ITERATIONS; i++)
{
tasks[i].open ((void *) &priority);
priority = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO,
priority,
ACE_SCOPE_THREAD);
}
ACE_DEBUG ((LM_DEBUG, "(%t) %d tasks spawned, wait for them to exit . . .\n",
ACE_MAX_ITERATIONS));
// Wait for all tasks to exit.
ACE_Thread_Manager::instance ()->wait ();
#else
ACE_ERROR ((LM_ERROR, "threads not supported on this platform\n"));
#endif /* ACE_HAS_THREADS */
ACE_END_TEST;
return 0;
}
|
