comparison example/word_count3/main.cc @ 508:217d7c53442b draft

add word_count3
author yutaka@henri.cr.ie.u-ryukyu.ac.jp
date Tue, 20 Oct 2009 16:28:16 +0900 (2009-10-20)
parents
children 278db3ca751d
comparison
equal deleted inserted replaced
507:823532f263af 508:217d7c53442b
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <sys/mman.h>
5 #include <sys/types.h>
6 #include <sys/stat.h>
7 #include <fcntl.h>
8 #include <unistd.h>
9 #include "TaskManager.h"
10 #include "Func.h"
11
12 #define TASKBUFF (1)
13
14 extern void task_init(void);
15
16 static TaskManager *manager;
17
18 static int count = 1;
19 static char *file = NULL;
20
21 const char *usr_help_str = "Usage: ./post [-cpu spe_num] [-count N]\n\
22 -count Number of print \"Hello, World!!\"";
23
24
25 struct task_list_t {
26 HTaskPtr task;
27 task_list_t *next;
28 };
29
30 typedef struct {
31 caddr_t file_mmap;
32 off_t size;
33 } st_mmap_t;
34
35
36 typedef struct {
37
38 /*16task毎に回す為に必要な変数*/
39 task_list_t *task_list;
40 HTaskPtr run_wait_task;
41 int *task_num;
42 int *sum_task_num;
43
44 /*dataを分割する際に必要な変数*/
45 int *file_size;
46 int *division_size;
47 int *division_out_size;
48 int *status_num;
49 int *out_task_num;
50 int *out_size;
51 int *sum_i;
52 int *word_flag;
53 caddr_t file_mmap;
54 unsigned long long *o_data;
55
56 } data_list_t;
57
58 /*与えられたsizeをfix_byte_sizeの倍数にする(丸め込むっていうのかな?)*/
59 int
60 fix_byte(int size,int fix_byte_size)
61 {
62 size = (size/fix_byte_size)*fix_byte_size + ((size%fix_byte_size)!= 0)*fix_byte_size;
63
64 return size;
65 }
66
67 void
68 create_data(char *filename, data_list_t *data)
69 {
70
71 data->file_size = (int*)manager->allocate(sizeof(int));
72 data->division_size = (int*)manager->allocate(sizeof(int));
73 data->division_out_size = (int*)manager->allocate(sizeof(int));
74 data->status_num = (int*)manager->allocate(sizeof(int));
75 data->out_size = (int*)manager->allocate(sizeof(int));
76 data->out_task_num = (int*)manager->allocate(sizeof(int));
77 data->task_num = (int*)manager->allocate(sizeof(int));
78 data->sum_task_num = (int*)manager->allocate(sizeof(int));
79 data->sum_i = (int*)manager->allocate(sizeof(int));
80 *data->sum_i = 0;
81 data->word_flag = (int*)manager->allocate(sizeof(int));
82 *data->word_flag = 0;
83 data->run_wait_task = (HTaskPtr)manager->allocate(sizeof(HTask));
84 data->run_wait_task = manager->create_task(WAIT_TASK);
85
86
87
88 /*マッピングだよ!*/
89 int fd = -1;
90 int map = MAP_PRIVATE;
91 off_t size;
92 struct stat sb;
93
94 if ((fd=open(filename,O_RDONLY,0666))==0) {
95 fprintf(stderr,"can't open %s\n",filename);
96 }
97
98 if (fstat(fd,&sb)) {
99 fprintf(stderr,"can't fstat %s\n",filename);
100 }
101
102 printf("file size %d\n",(int)sb.st_size);
103
104 /*sizeをページングサイズの倍数にあわせる*/
105 size = fix_byte(sb.st_size,4096);
106
107 printf("fix 4096byte file size %d\n",(int)size);
108
109 data->file_mmap = (char*)mmap(NULL,size,PROT_READ,map,fd,(off_t)0);
110 if (data->file_mmap == (caddr_t)-1) {
111 fprintf(stderr,"Can't mmap file\n");
112 perror(NULL);
113 exit(0);
114 }
115
116 if (size >= 4096*4) {
117 *data->division_size = 4096 * 4; /*16kbyte*/
118 }
119 else {
120 *data->division_size = size;
121 }
122
123 *data->file_size = size;
124
125 /* status が 2つなので、8 * 2 = 16; 8 は unsinged long long*/
126 *data->division_out_size = 16;
127
128 /*"word num" and "line num"*/
129 *data->status_num = 2;
130 *data->sum_task_num = size / (*data->division_size);
131
132 if (*data->sum_task_num < TASKBUFF) {
133 *data->task_num = *data->sum_task_num;
134 }
135 else {
136 *data->task_num = TASKBUFF;
137 }
138
139 *data->out_task_num = *data->sum_task_num + ( (*data->division_size) * (*data->sum_task_num) < size);
140
141 *data->out_size = (*data->division_out_size) * (*data->out_task_num);
142 data->o_data = (unsigned long long*)manager->allocate(*data->out_size);
143
144
145 }
146
147 void
148 func2(void *p)
149 {
150 data_list_t *data = (data_list_t*)p;
151
152 int in_off_set = 0;
153 int out_off_set = 0;
154
155 if (*data->file_size > 0) {
156
157 in_off_set = (*data->sum_i) * (*data->division_size);
158 out_off_set = (*data->sum_i) * (*data->status_num);
159 *data->division_size = *data->file_size;
160
161 HTaskPtr task = (HTaskPtr)manager->allocate(sizeof(HTask));
162 task = manager->create_task(EXEC_TASK);
163 task->add_inData(data->file_mmap + in_off_set, *data->division_size);
164 task->add_outData(data->o_data + out_off_set, *data->division_out_size);
165 task->add_param(*data->division_size);
166 task->add_param(*data->word_flag);
167 data->run_wait_task->wait_for(task);
168 task->set_cpu(SPE_ANY);
169 task->spawn();
170
171 }
172
173 data->run_wait_task->spawn();
174
175 }
176
177 void
178 func1(void *p)
179 {
180
181 /*receive*/
182 HTaskPtr wait_task = manager->create_task(WAIT_TASK);
183 data_list_t *data = (data_list_t*)p;
184
185
186 if (*data->sum_task_num < *data->task_num) {
187 *data->task_num = *data->sum_task_num;
188 }
189
190
191 /*run*/
192 task_list_t *t = data->task_list;
193
194 for (;t != NULL; t = t->next) {
195 wait_task->wait_for(t->task);
196 t->task->spawn();
197 }
198
199 task_list_t *now = NULL;
200 task_list_t *next = (task_list_t*)manager->allocate(sizeof(task_list_t));
201 next = NULL;
202
203 *data->sum_task_num -= *data->task_num;
204 if (*data->sum_task_num < TASKBUFF) {
205 *data->task_num = *data->sum_task_num;
206 } else {
207 *data->task_num = TASKBUFF;
208 }
209
210
211 /*for (int i = 0; i < *data->task_num; i++) {
212
213 now = (task_list_t*)manager->allocate(sizeof(task_list_t));
214 now->task = (HTaskPtr)manager->allocate(sizeof(HTask));
215 now->task = manager->create_task(HELLO_TASK);
216 now->task->set_cpu(SPE_ANY);
217 now->next = next;
218
219 next = now;
220
221 }*/
222
223
224 int in_off_set = 0;
225 int out_off_set = 0;
226 char next_word = 0;
227
228 for (int i = 0; i < *data->task_num; i++) {
229
230 in_off_set = (*data->sum_i) * (*data->division_size);
231 out_off_set = (*data->sum_i) * (*data->status_num);
232 next_word = data->file_mmap[(*data->sum_i + 1) * (*data->division_size) - 1];
233
234 now = (task_list_t*)manager->allocate(sizeof(task_list_t));
235 now->task = (HTaskPtr)manager->allocate(sizeof(HTask));
236 now->task = manager->create_task(EXEC_TASK);
237 now->task->add_inData(data->file_mmap + in_off_set, *data->division_size);
238 now->task->add_outData(data->o_data + out_off_set, *data->division_out_size);
239 now->task->add_param(*data->division_size);
240 now->task->add_param(*data->word_flag);
241 now->task->set_cpu(SPE_ANY);
242 now->next = next;
243
244 next = now;
245
246 *data->word_flag = ((next_word != 0x20) && (next_word != 0x0A));
247 *data->file_size -= *data->division_size;
248 *data->sum_i += 1;
249
250 }
251
252
253
254 data->task_list = now;
255
256
257 if (*data->sum_task_num > 0) {
258 wait_task->set_post(func1,p);
259 }
260
261 /* すべての task が終了するのを待つ。*/
262 else {
263 wait_task->set_post(func2,p);
264 }
265
266 /* 16task が終了するのを待つ */
267 wait_task->spawn();
268
269 }
270
271
272 int
273 init(int argc, char **argv)
274 {
275 for (int i = 1; argv[i]; ++i) {
276 if (strcmp(argv[i], "-count") == 0) {
277 count = atoi(argv[++i]);
278 } else if (strcmp(argv[i], "-file") == 0) {
279 file = argv[++i];
280 }
281
282
283 }
284
285 return 0;
286 }
287
288 void
289 run_init(TaskManager *manager)
290 {
291
292 data_list_t *data = (data_list_t*)manager->allocate(sizeof(data_list_t));;
293
294 /*data create from input file*/
295 create_data(file,data);
296
297 HTaskPtr t_print = manager->create_task(PRINT_TASK);
298 t_print->add_inData(data->o_data, *data->out_size);
299 t_print->add_param(*data->out_task_num);
300 t_print->add_param(*data->status_num);
301 t_print->wait_for(data->run_wait_task);
302
303 /*task create*/
304 task_list_t *now = NULL;
305 task_list_t *next = (task_list_t*)manager->allocate(sizeof(task_list_t));
306 next = NULL;
307
308 int in_off_set = 0;
309 int out_off_set = 0;
310 char next_word = 0;
311
312 for (int i = 0; i < *data->task_num; i++) {
313
314 in_off_set = (*data->sum_i) * (*data->division_size);
315 out_off_set = (*data->sum_i) * (*data->status_num);
316 next_word = data->file_mmap[(*data->sum_i + 1) * (*data->division_size) - 1];
317
318 now = (task_list_t*)manager->allocate(sizeof(task_list_t));
319 now->task = (HTaskPtr)manager->allocate(sizeof(HTask));
320 now->task = manager->create_task(EXEC_TASK);
321 now->task->add_inData(data->file_mmap + in_off_set, *data->division_size);
322 now->task->add_outData(data->o_data + out_off_set, *data->division_out_size);
323 now->task->add_param(*data->division_size);
324 now->task->add_param(*data->word_flag);
325 now->task->set_cpu(SPE_ANY);
326 now->next = next;
327
328 next = now;
329
330 *data->word_flag = ((next_word != 0x20) && (next_word != 0x0A));
331 *data->file_size -= *data->division_size;
332 *data->sum_i += 1;
333
334 }
335
336 data->task_list = now;
337
338 func1((void*)data);
339
340 t_print->spawn();
341
342 }
343
344 int
345 TMmain(TaskManager *manager_, int argc, char *argv[])
346 {
347 manager = manager_;
348
349 if (init(argc, argv) < 0) {
350 return -1;
351 }
352
353 task_init();
354 run_init(manager);
355
356 return 0;
357 }
358