|
48
|
1 #include <stdio.h>
|
|
50
|
2 #include <stdlib.h>
|
|
42
|
3 #include "Scheduler.h"
|
|
|
4 #include "SchedNop.h"
|
|
|
5 #include "error.h"
|
|
|
6
|
|
109
|
7 Scheduler::TaskObject task_list[MAX_TASK_OBJECT];
|
|
|
8
|
|
|
9 Scheduler::~Scheduler(void)
|
|
|
10 {
|
|
|
11 delete connector;
|
|
|
12 }
|
|
|
13
|
|
42
|
14 void
|
|
|
15 Scheduler::init(void)
|
|
|
16 {
|
|
|
17 init_impl();
|
|
109
|
18
|
|
|
19 for (int i = 0; i < 2; i++) {
|
|
|
20 buff_taskList[i] = (TaskListPtr)allocate(sizeof(TaskList));
|
|
|
21 buff_inListData[i] = (ListDataPtr)allocate(sizeof(ListData));
|
|
|
22 buff_outListData[i] = (ListDataPtr)allocate(sizeof(ListData));
|
|
|
23 }
|
|
42
|
24
|
|
109
|
25 buffFlag_taskList = 0;
|
|
|
26 buffFlag_inListData = 0;
|
|
|
27 buffFlag_outListData = 0;
|
|
|
28 flag_renewTaskList = 0;
|
|
|
29
|
|
|
30 // bzero でもいいけど
|
|
|
31 for (int i = 0; i < MAX_GLOBAL_AREA; i++) {
|
|
|
32 globalList[i] = NULL;
|
|
|
33 }
|
|
|
34
|
|
|
35 for (int i = 0; i < MAX_MAINMEM_AREA; i++) {
|
|
|
36 mainMemList[i] = NULL;
|
|
|
37 }
|
|
|
38
|
|
|
39
|
|
|
40 taskGroup = new TaskGroup;
|
|
|
41 renewTop_taskList = NULL;
|
|
|
42 renewCur_taskList = NULL;
|
|
42
|
43 }
|
|
|
44
|
|
|
45 void
|
|
|
46 Scheduler::run(void)
|
|
|
47 {
|
|
|
48 SchedTaskBase* taskTmp;
|
|
109
|
49
|
|
42
|
50 task1 = new SchedNop();
|
|
|
51 task2 = new SchedNop();
|
|
|
52 task3 = new SchedNop();
|
|
|
53
|
|
|
54 // main loop
|
|
|
55 do {
|
|
|
56 __debug("----------\n");
|
|
|
57 task3->write();
|
|
|
58 task2->exec();
|
|
|
59 task1->read();
|
|
|
60
|
|
|
61 taskTmp = task3;
|
|
|
62 task3 = task2;
|
|
|
63 task2 = task1;
|
|
|
64 task1 = task1->next(this, taskTmp);
|
|
|
65 } while (task1);
|
|
|
66
|
|
|
67 delete task3;
|
|
|
68 delete task2;
|
|
50
|
69 }
|
|
48
|
70
|
|
50
|
71
|
|
|
72 void
|
|
|
73 Scheduler::finish(void)
|
|
|
74 {
|
|
109
|
75 free(buff_taskList[0]);
|
|
|
76 free(buff_taskList[1]);
|
|
|
77 free(buff_inListData[0]);
|
|
|
78 free(buff_inListData[1]);
|
|
|
79 free(buff_outListData[0]);
|
|
|
80 free(buff_outListData[1]);
|
|
42
|
81 }
|
|
|
82
|
|
109
|
83 /**
|
|
|
84 * あらかじめ memory allocte してある TaskList の領域を
|
|
|
85 * パイプラインの各処理が交代して使う。
|
|
|
86 */
|
|
42
|
87 TaskListPtr
|
|
|
88 Scheduler::get_curListBuf(void)
|
|
|
89 {
|
|
109
|
90 buffFlag_taskList ^= 1;
|
|
|
91 curIndex_taskList = 0;
|
|
|
92
|
|
|
93 return buff_taskList[buffFlag_taskList];
|
|
|
94 }
|
|
|
95
|
|
|
96
|
|
|
97 /**
|
|
|
98 * あらかじめ memory allocte してある ListData の領域を
|
|
|
99 * パイプラインの各処理が交代して使う。
|
|
|
100 */
|
|
|
101 ListDataPtr
|
|
|
102 Scheduler::get_curWriteBuf(void)
|
|
|
103 {
|
|
|
104 buffFlag_outListData ^= 1;
|
|
|
105 return buff_outListData[buffFlag_outListData];
|
|
|
106 }
|
|
|
107
|
|
|
108
|
|
|
109 ListDataPtr
|
|
|
110 Scheduler::get_curReadBuf(void)
|
|
|
111 {
|
|
|
112 buffFlag_inListData ^= 1;
|
|
|
113 return buff_inListData[buffFlag_inListData];
|
|
|
114 }
|
|
|
115
|
|
|
116 /**
|
|
|
117 * タスク内で生成されたタスクを格納する TaskList を取得する
|
|
|
118 * 現在格納に使っている TaskList (renewCur_taskList) が使えるならそれを返す
|
|
|
119 * もしそうでないなら、新しく TaskList を allocate してそれを返す
|
|
|
120 * コード中で renewCur_taskList が NULL になるのは
|
|
|
121 * - プログラム開始時
|
|
|
122 * - タスク内生成タスクがある TaskList の実行を新しく始める (Nop2Ready 参照)
|
|
|
123 * 以上の場合です
|
|
|
124 */
|
|
|
125 TaskListPtr
|
|
|
126 Scheduler::get_renewListBuf(void)
|
|
|
127 {
|
|
|
128 if (renewCur_taskList && renewCur_taskList->length < TASK_MAX_SIZE) {
|
|
|
129 return renewCur_taskList;
|
|
|
130 } else {
|
|
|
131 TaskListPtr newList = (TaskListPtr)allocate(sizeof(TaskList));
|
|
|
132 newList->length = 0;
|
|
|
133 newList->next = NULL;
|
|
|
134 renewTop_taskList = TaskList::append(renewTop_taskList, newList);
|
|
|
135 renewCur_taskList = newList;
|
|
|
136 return newList;
|
|
|
137 }
|
|
|
138 }
|
|
|
139
|
|
|
140 void
|
|
|
141 Scheduler::dma_load(void *buf, uint32 addr, uint32 size, uint32 mask)
|
|
|
142 {
|
|
|
143 connector->dma_load(buf, addr, size, mask);
|
|
|
144 }
|
|
|
145
|
|
|
146 void
|
|
|
147 Scheduler::dma_store(void *buf, uint32 addr, uint32 size, uint32 mask)
|
|
|
148 {
|
|
|
149 connector->dma_store(buf, addr, size, mask);
|
|
|
150 }
|
|
|
151
|
|
|
152 void
|
|
|
153 Scheduler::dma_wait(uint32 mask)
|
|
|
154 {
|
|
|
155 connector->dma_wait(mask);
|
|
|
156 }
|
|
|
157
|
|
|
158 void
|
|
|
159 Scheduler::dma_loadList(ListDataPtr list, void *buff, uint32 mask)
|
|
|
160 {
|
|
|
161 connector->dma_loadList(list, buff, mask);
|
|
42
|
162 }
|
|
|
163
|
|
|
164
|
|
109
|
165 void
|
|
|
166 Scheduler::dma_storeList(ListDataPtr list, void *buff, uint32 mask)
|
|
|
167 {
|
|
|
168 return connector->dma_storeList(list, buff, mask);
|
|
|
169 }
|
|
|
170
|
|
|
171 void
|
|
|
172 Scheduler::mail_write(uint32 data)
|
|
|
173 {
|
|
|
174 connector->mail_write(data);
|
|
|
175 }
|
|
|
176
|
|
|
177 uint32
|
|
|
178 Scheduler::mail_read(void)
|
|
|
179 {
|
|
|
180 return connector->mail_read();
|
|
|
181 }
|
|
|
182
|
|
|
183 TaskGroupPtr
|
|
|
184 Scheduler::set_groupTask(uint32 command)
|
|
|
185 {
|
|
|
186 TaskGroupPtr ret = taskGroup;
|
|
|
187
|
|
|
188 reload_groupTask();
|
|
|
189
|
|
|
190 ret->command = command;
|
|
|
191 return ret;
|
|
|
192 }
|
|
|
193
|
|
|
194 void
|
|
|
195 Scheduler::add_groupTask(TaskGroupPtr group, TaskPtr task)
|
|
|
196 {
|
|
|
197 group->add(task);
|
|
|
198 }
|
|
|
199
|
|
|
200 void
|
|
|
201 Scheduler::remove_groupTask(TaskGroupPtr group, TaskPtr task)
|
|
42
|
202 {
|
|
109
|
203 group->remove(task);
|
|
|
204 }
|
|
|
205
|
|
|
206 void
|
|
|
207 Scheduler::reload_groupTask(void)
|
|
|
208 {
|
|
|
209 taskGroup = new TaskGroup;
|
|
|
210 }
|
|
|
211
|
|
|
212 uint32
|
|
|
213 Scheduler::status_groupTask(TaskGroupPtr group)
|
|
|
214 {
|
|
|
215 return group->status();
|
|
|
216 }
|
|
|
217
|
|
|
218 void*
|
|
|
219 Scheduler::global_alloc(int id, int size)
|
|
|
220 {
|
|
|
221 globalList[id] = allocate(size);
|
|
|
222 return globalList[id];
|
|
|
223 }
|
|
|
224
|
|
|
225 void*
|
|
|
226 Scheduler::global_get(int id)
|
|
|
227 {
|
|
|
228 return globalList[id];
|
|
|
229 }
|
|
|
230
|
|
|
231 void
|
|
|
232 Scheduler::global_free(int id)
|
|
|
233 {
|
|
|
234 free(globalList[id]);
|
|
|
235 globalList[id] = NULL;
|
|
|
236 }
|
|
|
237
|
|
|
238 /**
|
|
|
239 * mainMem_alloc で確保したメインメモリの領域アドレスを返す。
|
|
|
240 * これは Fifo, Cell で共通
|
|
|
241 */
|
|
|
242 void*
|
|
|
243 Scheduler::mainMem_get(int id)
|
|
|
244 {
|
|
|
245 return mainMemList[id];
|
|
42
|
246 }
|
|
|
247
|
|
|
248
|
|
109
|
249 /**
|
|
|
250 * 本当は Scheduler クラスに入れるべきなんだろうか。。。
|
|
|
251 * なんか手抜きの感がある
|
|
|
252 */
|
|
|
253 void
|
|
|
254 register_task(int cmd, Scheduler::TaskObject task)
|
|
42
|
255 {
|
|
109
|
256 task_list[cmd] = task;
|
|
42
|
257 }
|
