Mercurial > hg > Game > Cerium
annotate example/word_count3/main.cc @ 906:becd6fad3ae0 draft
coord_pack is stuffed with infomation of create polygon at spe.
| author | Yutaka_Kinjyo |
|---|---|
| date | Mon, 19 Jul 2010 23:40:53 +0900 |
| parents | 94d82f2c842f |
| children |
| rev | line source |
|---|---|
| 508 | 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 | |
| 619 | 148 func2(SchedTask *s, void *p, void *q) |
| 508 | 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 | |
| 619 | 178 func1(SchedTask *s, void *p, void *q) |
| 508 | 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) { | |
| 619 | 258 wait_task->set_post(func1,p, 0); |
| 508 | 259 } |
| 260 | |
| 261 /* すべての task が終了するのを待つ。*/ | |
| 262 else { | |
| 619 | 263 wait_task->set_post(func2,p, 0); |
| 508 | 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]; | |
|
625
94d82f2c842f
64bit mode worked on Mac OS X.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
619
diff
changeset
|
280 } |
|
94d82f2c842f
64bit mode worked on Mac OS X.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
619
diff
changeset
|
281 } |
|
94d82f2c842f
64bit mode worked on Mac OS X.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
619
diff
changeset
|
282 if (!file) { |
|
94d82f2c842f
64bit mode worked on Mac OS X.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
619
diff
changeset
|
283 printf("usage: %s [-count 10] -file filename\n",argv[0]); |
|
94d82f2c842f
64bit mode worked on Mac OS X.
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
619
diff
changeset
|
284 exit(0); |
| 508 | 285 } |
| 286 | |
| 287 return 0; | |
| 288 } | |
| 289 | |
| 290 void | |
| 291 run_init(TaskManager *manager) | |
| 292 { | |
| 293 | |
| 294 data_list_t *data = (data_list_t*)manager->allocate(sizeof(data_list_t));; | |
| 295 | |
| 296 /*data create from input file*/ | |
| 297 create_data(file,data); | |
| 298 | |
| 299 HTaskPtr t_print = manager->create_task(PRINT_TASK); | |
| 300 t_print->add_inData(data->o_data, *data->out_size); | |
| 301 t_print->add_param(*data->out_task_num); | |
| 302 t_print->add_param(*data->status_num); | |
| 303 t_print->wait_for(data->run_wait_task); | |
| 304 | |
| 305 /*task create*/ | |
| 306 task_list_t *now = NULL; | |
| 307 task_list_t *next = (task_list_t*)manager->allocate(sizeof(task_list_t)); | |
| 308 next = NULL; | |
| 309 | |
| 310 int in_off_set = 0; | |
| 311 int out_off_set = 0; | |
| 312 char next_word = 0; | |
| 313 | |
| 314 for (int i = 0; i < *data->task_num; i++) { | |
| 315 | |
| 316 in_off_set = (*data->sum_i) * (*data->division_size); | |
| 317 out_off_set = (*data->sum_i) * (*data->status_num); | |
| 318 next_word = data->file_mmap[(*data->sum_i + 1) * (*data->division_size) - 1]; | |
| 319 | |
| 320 now = (task_list_t*)manager->allocate(sizeof(task_list_t)); | |
| 321 now->task = (HTaskPtr)manager->allocate(sizeof(HTask)); | |
| 322 now->task = manager->create_task(EXEC_TASK); | |
| 323 now->task->add_inData(data->file_mmap + in_off_set, *data->division_size); | |
| 324 now->task->add_outData(data->o_data + out_off_set, *data->division_out_size); | |
| 325 now->task->add_param(*data->division_size); | |
| 326 now->task->add_param(*data->word_flag); | |
| 327 now->task->set_cpu(SPE_ANY); | |
| 328 now->next = next; | |
| 329 | |
| 330 next = now; | |
| 331 | |
| 332 *data->word_flag = ((next_word != 0x20) && (next_word != 0x0A)); | |
| 333 *data->file_size -= *data->division_size; | |
| 334 *data->sum_i += 1; | |
| 335 | |
| 336 } | |
| 337 | |
| 338 data->task_list = now; | |
| 339 | |
| 619 | 340 func1(0, (void*)data, 0); |
| 508 | 341 |
| 342 t_print->spawn(); | |
| 343 | |
| 344 } | |
| 345 | |
| 346 int | |
| 347 TMmain(TaskManager *manager_, int argc, char *argv[]) | |
| 348 { | |
| 349 manager = manager_; | |
| 350 | |
| 351 if (init(argc, argv) < 0) { | |
| 352 return -1; | |
| 353 } | |
| 354 | |
| 355 task_init(); | |
| 356 run_init(manager); | |
| 357 | |
| 358 return 0; | |
| 359 } | |
| 360 |