source: trunk/libs/libalmosmkh/almosmkh.c

Last change on this file was 685, checked in by alain, 6 years ago

Introduce the display_socket() function.
File size: 56.4 KB
Line 
1/*
2 * almosmkh.c - User level ALMOS-MKH specific library implementation.
3 *
4 * Author Alain Greiner (2016,2017,2018,2019,2020)
5 *
6 * Copyright (c) UPMC Sorbonne Universites
7 *
8 * This file is part of ALMOS-MKH.
9 *
10 * ALMOS-MKH is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2.0 of the License.
13 *
14 * ALMOS-MKH is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with ALMOS-MKH; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
24#include <almosmkh.h>
25#include <shared_almos.h>
26#include <hal_user.h>
27#include <hal_macros.h>
28#include <hal_shared_types.h>
29#include <shared_fbf.h>
30#include <syscalls_numbers.h>
31#include <string.h>
32#include <stdio.h>
33#include <stdlib.h>
34#include <unistd.h>
35#include <mman.h>
36
37#define DEBUG_REMOTE_MALLOC 0
38#define DEBUG_PTHREAD_PARALLEL 0
39
40//////////////////////////////////////////////////////////////////////////////////////
41///////////// Non standard system calls ///////////////////////////////////////
42//////////////////////////////////////////////////////////////////////////////////////
43
44//////////////////////////
45int fg( unsigned int pid )
46{
47 return hal_user_syscall( SYS_FG,
48 (reg_t)pid, 0, 0, 0 );
49}
50
51//////////////////////////////
52int is_fg( unsigned int pid,
53 unsigned int * owner )
54{
55 return hal_user_syscall( SYS_IS_FG,
56 (reg_t)pid,
57 (reg_t)owner, 0, 0 );
58}
59
60///////////////////////////////////////////////
61int get_config( struct hard_config_s * config )
62{
63 return hal_user_syscall( SYS_GET,
64 GET_CONFIG,
65 (reg_t)config, 0, 0);
66}
67
68////////////////////////////////////
69int get_core_id( unsigned int * cxy,
70 unsigned int * lid )
71{
72 return hal_user_syscall( SYS_GET,
73 GET_CORE_ID,
74 (reg_t)cxy,
75 (reg_t)lid, 0 );
76}
77
78/////////////////////////////////////
79int get_nb_cores( unsigned int cxy,
80 unsigned int * ncores )
81{
82 return hal_user_syscall( SYS_GET,
83 GET_NB_CORES,
84 (reg_t)cxy,
85 (reg_t)ncores, 0 );
86}
87
88///////////////////////////////////////////
89int get_best_core( unsigned int base_cxy,
90 unsigned int level,
91 unsigned int * cxy,
92 unsigned int * lid )
93{
94 return hal_user_syscall( SYS_GET,
95 GET_BEST_CORE,
96 (reg_t)((base_cxy << 16) | (level & 0xFFFF)),
97 (reg_t)cxy,
98 (reg_t)lid );
99}
100
101//////////////////////////////////////////////
102int get_processes( unsigned int cxy,
103 unsigned int owned,
104 char * u_buf,
105 unsigned int size )
106{
107 return hal_user_syscall( SYS_GET,
108 GET_PROCESSES,
109 (reg_t)((cxy << 16) | (owned & 0xFFFF)),
110 (reg_t)u_buf,
111 (reg_t)size );
112}
113
114///////////////////////////////////////////
115int get_cycle( unsigned long long * cycle )
116{
117 return hal_user_syscall( SYS_GET,
118 GET_CYCLE,
119 (reg_t)cycle, 0, 0 );
120}
121
122///////////////////////////////////////////
123int get_thread_info( thread_info_t * info )
124{
125 return hal_user_syscall( SYS_GET,
126 GET_THREAD_INFO,
127 (reg_t)info, 0, 0 );
128}
129
130//////////////////////////////////
131int place_fork( unsigned int cxy )
132{
133 return hal_user_syscall( SYS_PLACE_FORK,
134 (reg_t)cxy, 0, 0, 0 );
135}
136
137/////////////////////////////////
138int utls( unsigned int operation,
139 unsigned int value )
140{
141 return hal_user_syscall( SYS_UTLS,
142 (reg_t)operation,
143 (reg_t)value, 0, 0 );
144}
145
146////////////////////////////////////////
147void get_uint32( unsigned int * buffer )
148{
149 unsigned int i;
150 int c; // ASCII character value
151
152 unsigned char buf[32];
153
154 unsigned int save = 0;
155 unsigned int value = 0;
156 unsigned int done = 0;
157 unsigned int overflow = 0;
158 unsigned int length = 0;
159
160 // get characters
161 while (done == 0)
162 {
163 // read one character
164 c = getchar();
165
166 // analyse this character
167 if ( ((c > 0x2F) && (c < 0x3A)) || // 0 to 9
168 ((c > 0x40) && (c < 0x47)) || // A to F
169 ((c > 0x60) && (c < 0x67)) || // a to f
170 (((c == 0x58) || (c == 0x78)) && (length == 1)) ) // X or x
171 {
172 putchar( c ); // echo
173 if ( c > 0x60 ) c = c - 0x20; // to upper case
174 buf[length] = (unsigned char)c;
175 length++;
176 }
177 else if (c == 0x0A) // LF character
178 {
179 done = 1;
180 }
181 else if ( (c == 0x7F) || // DEL character
182 (c == 0x08) ) // BS character
183 {
184 if ( length > 0 )
185 {
186 length--;
187 printf("\b \b"); // BS / / BS
188 }
189 }
190 else if ( c == 0 ) // EOF character
191 {
192 overflow = 1;
193 done = 1;
194 }
195
196 // test buffer overflow
197 if ( length >= 32 )
198 {
199 overflow = 1;
200 done = 1;
201 }
202 } // end while characters
203
204 // string to int conversion with overflow detection
205 if ( overflow == 0 )
206 {
207 // test (decimal / hexa)
208 if( (buf[0] == 0x30) && ((buf[1] == 0x58) || (buf[1] == 0x78)) ) // hexa input
209 {
210 for (i = 2; (i < length) && (overflow == 0) ; i++)
211 {
212 if( buf[i] < 0x40 ) value = (value << 4) + (buf[i] - 0x30);
213 else value = (value << 4) + (buf[i] - 0x37);
214 if (value < save) overflow = 1;
215 save = value;
216 }
217 }
218 else // decimal input
219 {
220 for (i = 0; (i < length) && (overflow == 0) ; i++)
221 {
222 value = (value * 10) + (buf[i] - 0x30);
223 if (value < save) overflow = 1;
224 save = value;
225 }
226 }
227 }
228
229 // write value to buffer
230 if ( overflow == 0 )
231 {
232 // return value
233 *buffer = value;
234 }
235 else
236 {
237 // cancel all echo characters
238 for (i = 0; i < length ; i++)
239 {
240 printf("\b \b"); // BS / / BS
241 }
242
243 // echo character '0'
244 putchar( '0' );
245
246 // return 0 value
247 *buffer = 0;
248 }
249} // end get_uint32()
250
251///////////////////////////////
252int get_string( char * string,
253 int maxlen )
254{
255 int c;
256 int length = 0;
257
258 while( 1 )
259 {
260 // check buffer overflow
261 if( length >= maxlen-1 )
262 {
263 // cancel all echo characters
264 while( length )
265 {
266 printf("\b \b"); // cancel one echo character
267 length--;
268 }
269 }
270
271 // read one character
272 c = getchar();
273
274 // analyse this character
275 if ( (c >= 0x20) && (c < 0x7F) ) // printable character
276 {
277 putchar( c ); // echo
278 string[length] = (char)c; // register character in string
279 length++; // update length
280 }
281 else if( c == 0x0A ) // LF character marks end of string
282 {
283 putchar( c ); // echo
284 string[length] = 0; // register NUL character in string
285 return length + 1;
286 }
287 else if ( (c == 0x7F) || // DEL character
288 (c == 0x08) ) // BS character
289 {
290 if ( length > 0 )
291 {
292 printf("\b \b"); // cancel one echo character
293 length--;
294 }
295 }
296 }
297} // end get_string()
298
299
300//////////////////////////////////////////////////////////////////////////////////////
301/////////////// non standard debug functions ///////////////////////////////////
302//////////////////////////////////////////////////////////////////////////////////////
303
304////////////////////////////////////
305void display_string( char * string )
306{
307 hal_user_syscall( SYS_DISPLAY,
308 DISPLAY_STRING,
309 (reg_t)string, 0, 0 );
310}
311
312/////////////////////////////////////////////////////
313int display_vmm( unsigned int cxy,
314 unsigned int pid,
315 unsigned int mapping )
316{
317 return hal_user_syscall( SYS_DISPLAY,
318 DISPLAY_VMM,
319 (reg_t)cxy,
320 (reg_t)pid,
321 (reg_t)mapping );
322}
323
324////////////////////////////////////
325int display_sched( unsigned int cxy,
326 unsigned int lid )
327{
328 return hal_user_syscall( SYS_DISPLAY,
329 DISPLAY_SCHED,
330 (reg_t)cxy,
331 (reg_t)lid, 0 );
332}
333
334////////////////////////////////////////////////
335int display_cluster_processes( unsigned int cxy,
336 unsigned int owned )
337{
338 return hal_user_syscall( SYS_DISPLAY,
339 DISPLAY_CLUSTER_PROCESSES,
340 (reg_t)cxy,
341 (reg_t)owned, 0 );
342}
343
344////////////////////////////////////////
345int display_busylocks( unsigned int pid,
346 unsigned int trdid )
347{
348 return hal_user_syscall( SYS_DISPLAY,
349 DISPLAY_BUSYLOCKS,
350 (reg_t)pid,
351 (reg_t)trdid, 0 );
352}
353
354/////////////////////////
355int display_chdev( void )
356{
357 return hal_user_syscall( SYS_DISPLAY,
358 DISPLAY_CHDEV, 0, 0, 0 );
359}
360
361///////////////////////
362int display_vfs( void )
363{
364 return hal_user_syscall( SYS_DISPLAY,
365 DISPLAY_VFS, 0, 0, 0 );
366}
367
368////////////////////////////////////////////////
369int display_txt_processes( unsigned int txt_id )
370{
371 return hal_user_syscall( SYS_DISPLAY,
372 DISPLAY_TXT_PROCESSES,
373 (reg_t)txt_id, 0, 0 );
374}
375
376////////////////////////
377int display_dqdt( void )
378{
379 return hal_user_syscall( SYS_DISPLAY,
380 DISPLAY_DQDT, 0, 0, 0 );
381}
382
383///////////////////////////////////////
384int display_mapper( char * path,
385 unsigned int page_id,
386 unsigned int nbytes)
387{
388 return hal_user_syscall( SYS_DISPLAY,
389 DISPLAY_MAPPER,
390 (reg_t)path,
391 (reg_t)page_id,
392 (reg_t)nbytes );
393}
394
395///////////////////////////////////////
396int display_barrier( unsigned int pid )
397{
398 return hal_user_syscall( SYS_DISPLAY,
399 DISPLAY_BARRIER,
400 (reg_t)pid, 0, 0 );
401}
402
403///////////////////////////////////////
404int display_fat( unsigned int min_slot,
405 unsigned int nb_slots )
406{
407 return hal_user_syscall( SYS_DISPLAY,
408 DISPLAY_FAT,
409 (reg_t)min_slot,
410 (reg_t)nb_slots, 0 );
411}
412
413/////////////////////////////////////
414int display_socket( unsigned int pid,
415 unsigned int fdid )
416{
417 return hal_user_syscall( SYS_DISPLAY,
418 DISPLAY_SOCKET,
419 (reg_t)pid,
420 (reg_t)fdid, 0 );
421}
422
423////////////////////////////////////////
424int display_fd_array( unsigned int pid )
425{
426 return hal_user_syscall( SYS_DISPLAY,
427 DISPLAY_FD,
428 (reg_t)pid, 0, 0 );
429}
430
431///////////////////////////////////////////
432int display_fbf_windows( unsigned int pid )
433{
434 return hal_user_syscall( SYS_DISPLAY,
435 DISPLAY_WINDOWS,
436 (reg_t)pid, 0, 0 );
437}
438
439///////////////////////////////
440int trace( unsigned int active,
441 unsigned int cxy,
442 unsigned int lid )
443{
444 return hal_user_syscall( SYS_TRACE,
445 (reg_t)active,
446 (reg_t)cxy,
447 (reg_t)lid, 0 );
448}
449
450/////////////////
451void idbg( void )
452{
453 char cmd;
454
455 while( 1 )
456 {
457 // display prompt
458 printf("\n[idbg] cmd = ");
459
460 // get a one character command
461 cmd = (char)getchar();
462
463 // display all busylocks owned by thread(pid,trdid)
464 if( cmd == 'b' )
465 {
466 unsigned int pid;
467 unsigned int trdid;
468
469 printf("b / pid = ");
470 get_uint32( &pid );
471
472 printf(" / trdid = ");
473 get_uint32( &trdid );
474
475 display_busylocks( pid , trdid );
476 }
477 // return to calling process
478 else if( cmd == 'c' )
479 {
480 printf("c\n");
481 break;
482 }
483 // display FAT mapper(min,slots)
484 else if( cmd == 'f' )
485 {
486 unsigned int min;
487 unsigned int slots;
488
489 printf(" / min = ");
490 get_uint32( &min );
491
492 printf(" / slots = ");
493 get_uint32( &slots );
494
495 display_fat( min , slots );
496 }
497 // list all supported commands
498 else if( cmd == 'h' )
499 {
500 printf("h\n"
501 "- b : display on TXT0 busylocks taken by thread[pid,trdid]\n"
502 "- c : resume calling process execution\n"
503 "- f : display on TXT0 FAT mapper[min_slot,nb_slotss]\n"
504 "- h : list of supported commands\n"
505 "- m : display on TXT0 mapper[path,page,nbytes]\n"
506 "- p : display on TXT0 process descriptors in cluster[cxy]\n"
507 "- q : display on TXT0 DQDT state\n"
508 "- s : display on TXT0 scheduler state for core[cxy,lid]\n"
509 "- t : display on TXT0 process decriptors attached to TXT[tid]\n"
510 "- v : display on TXT0 VMM state for process[cxy,pid]\n"
511 "- x : force calling process to exit\n"
512 "- y : activate/desactivate trace for core[cxy,lid]\n"
513 );
514 }
515 // display MAPPER(path,page,nbytes)
516 else if( cmd == 'm' )
517 {
518 char path[128];
519 unsigned int page;
520 unsigned int nbytes;
521
522 printf("m / path = ");
523 get_string( path , 128 );
524
525 printf(" / page = ");
526 get_uint32( &page );
527
528 printf(" / nbytes = ");
529 get_uint32( &nbytes );
530
531 display_mapper( path , page , nbytes );
532 }
533 // display all processes in cluster(cxy)
534 else if( cmd == 'p' )
535 {
536 unsigned int cxy;
537
538 printf("p / cxy = ");
539 get_uint32( &cxy );
540
541 display_cluster_processes( cxy , 0 );
542 }
543 // display DQDT
544 else if( cmd == 'q' )
545 {
546 printf("q\n");
547 display_dqdt();
548 }
549 // display scheduler state for core(cxy,lid)
550 else if( cmd == 's' )
551 {
552 unsigned int cxy;
553 unsigned int lid;
554
555 printf("s / cxy = ");
556 get_uint32( &cxy );
557
558 printf(" / lid = ");
559 get_uint32( &lid );
560
561 display_sched( cxy , lid );
562 }
563 // display all processes attached to TXT(txt_id)
564 else if( cmd == 't' )
565 {
566 unsigned int txt_id;
567
568 printf("t / txt_id = ");
569 get_uint32( &txt_id );
570
571 display_txt_processes( txt_id );
572 }
573 // display vmm state for process(cxy, pid)
574 else if( cmd == 'v' )
575 {
576 unsigned int cxy;
577 unsigned int pid;
578 unsigned int map;
579
580 printf("v / cxy = ");
581 get_uint32( &cxy );
582
583 printf(" / pid = ");
584 get_uint32( &pid );
585
586 printf(" / mapping = ");
587 get_uint32( &map );
588
589 display_vmm( cxy , pid , map );
590 }
591 // force the calling process to exit
592 else if( cmd == 'x' )
593 {
594 printf("x\n");
595 exit( 0 );
596 }
597 // activate scheduler trace for core(cxy,lid)
598 else if( cmd == 'y' )
599 {
600 unsigned int active;
601 unsigned int cxy;
602 unsigned int lid;
603
604 printf("y / active = ");
605 get_uint32( &active );
606
607 printf(" / cxy = ");
608 get_uint32( &cxy );
609
610 printf(" / lid = ");
611 get_uint32( &lid );
612
613 trace( active , cxy , lid );
614 }
615 } // en while
616} // end idbg()
617
618
619/////////////////////////////////////////////////////////////////////////////////////////
620/////////////// non standard remote_malloc ////////////////////////////////////////
621/////////////////////////////////////////////////////////////////////////////////////////
622
623/////////////////////////////////////////////////////////////////////////////////////////
624// Global variable defining the allocator array (one per cluster)
625// This array (about 16 Kbytes ) will be stored in the data segment
626// of any application linked with this libray.
627/////////////////////////////////////////////////////////////////////////////////////////
628
629malloc_store_t store[MALLOC_MAX_CLUSTERS];
630
631// Macro returning the smallest power of 2 larger or equal to size value
632
633#define GET_SIZE_INDEX(size) (size <= 0x00000001) ? 0 :\
634 (size <= 0x00000002) ? 1 :\
635 (size <= 0x00000004) ? 2 :\
636 (size <= 0x00000008) ? 3 :\
637 (size <= 0x00000010) ? 4 :\
638 (size <= 0x00000020) ? 5 :\
639 (size <= 0x00000040) ? 6 :\
640 (size <= 0x00000080) ? 7 :\
641 (size <= 0x00000100) ? 8 :\
642 (size <= 0x00000200) ? 9 :\
643 (size <= 0x00000400) ? 10 :\
644 (size <= 0x00000800) ? 11 :\
645 (size <= 0x00001000) ? 12 :\
646 (size <= 0x00002000) ? 13 :\
647 (size <= 0x00004000) ? 14 :\
648 (size <= 0x00008000) ? 15 :\
649 (size <= 0x00010000) ? 16 :\
650 (size <= 0x00020000) ? 17 :\
651 (size <= 0x00040000) ? 18 :\
652 (size <= 0x00080000) ? 19 :\
653 (size <= 0x00100000) ? 20 :\
654 (size <= 0x00200000) ? 21 :\
655 (size <= 0x00400000) ? 22 :\
656 (size <= 0x00800000) ? 23 :\
657 (size <= 0x01000000) ? 24 :\
658 (size <= 0x02000000) ? 25 :\
659 (size <= 0x04000000) ? 26 :\
660 (size <= 0x08000000) ? 27 :\
661 (size <= 0x10000000) ? 28 :\
662 (size <= 0x20000000) ? 29 :\
663 (size <= 0x40000000) ? 30 :\
664 (size <= 0x80000000) ? 31 :\
665 32
666
667////////////////////////////////////////////////////////////////////////////////////////////
668// This static function display the current state of the allocator in cluster <cxy>.
669////////////////////////////////////////////////////////////////////////////////////////////
670
671#if DEBUG_REMOTE_MALLOC
672static void display_free_array( unsigned int cxy )
673{
674 unsigned int next;
675 unsigned int id;
676 unsigned int iter;
677
678 printf("\n***** store[%x] base = %x / size = %x\n",
679 cxy , store[cxy].store_base, store[cxy].store_size );
680 for ( id = 0 ; id < 32 ; id++ )
681 {
682 next = store[cxy].free[id];
683 printf(" - free[%d] = " , id );
684 iter = 0;
685 while ( next != 0 )
686 {
687 printf("%x | ", next );
688 next = (*(unsigned int*)next);
689 iter++;
690 }
691 printf("0\n");
692 }
693} // end display_free_array()
694#endif
695
696
697////////////////////////////////////////////////////////////////////i//////////////////////
698// This static function initialises the store in the cluster identified by the <cxy>
699// arguments. It is called by the remote_malloc() function when a specific store(x,y)
700// is accessed for the first time.
701// It uses the mmap( MAP_REMOTE ) syscall to allocate a new vseg mapped in cluster (cxy).
702////////////////////////////////////////////////////////////////////i//////////////////////
703// @ cxy : target cluster identifier (fixed format).
704// @ store_size : store size (bytes).
705// # return without setting the initialized field in store(cxy) if failure.
706////////////////////////////////////////////////////////////////////i//////////////////////
707static void store_init( unsigned int cxy,
708 unsigned int store_size )
709{
710 unsigned int store_base; // store base address
711 unsigned int free_index; // index in free[array]
712
713 unsigned int alloc_base; // alloc[] array base
714 unsigned int alloc_size; // alloc[] array size
715 unsigned int alloc_index; // index in alloc[array]
716
717 unsigned int iter; // iterator
718
719#if DEBUG_REMOTE_MALLOC
720unsigned int core_cxy;
721unsigned int core_lid;
722get_core_id( &core_cxy , &core_lid );
723printf("\n[%s] core[%x,%d] enter for store[%x] / size = %x\n",
724__FUNCTION__, core_cxy, core_lid, cxy, store_size );
725#endif
726
727 // get index in free[] array from size
728 free_index = GET_SIZE_INDEX( store_size );
729
730 // check store size power of 2
731 if( store_size != (unsigned int)(1<<free_index) )
732 {
733 printf("\n[ERROR] in %s : store[%x] size not power of 2 / size = %x\n",
734 __FUNCTION__, cxy , store_size );
735 return;
736 }
737
738 // allocate store in virtual space
739 void * vadr = mmap( NULL, // MAP_FIXED not supported
740 store_size,
741 PROT_READ | PROT_WRITE,
742 MAP_REMOTE| MAP_SHARED,
743 cxy, // fd is cluster identifier
744 0 ); // offset unused
745
746 if( vadr == NULL )
747 {
748 printf("\n[ERROR] in %s : cannot mmap store[%x]\n",
749 __FUNCTION__, cxy );
750 return;
751 }
752
753 store_base = (unsigned int)vadr;
754
755 // check allocated store alignment
756 if( store_base % store_size )
757 {
758 printf("\n[ERROR] in %s : store[%x] not aligned / base = %x / size = %x\n",
759 __FUNCTION__, cxy , store_base , store_size );
760 return;
761 }
762
763#if DEBUG_REMOTE_MALLOC
764printf("\n[%s] core[%x,%d] created vseg %x for store[%x]\n",
765__FUNCTION__, core_cxy, core_lid, store_base, cxy );
766#endif
767
768 // compute size of block containing alloc[] array
769 alloc_size = store_size / MALLOC_MIN_BLOCK_SIZE;
770 if ( alloc_size < MALLOC_MIN_BLOCK_SIZE) alloc_size = MALLOC_MIN_BLOCK_SIZE;
771
772 // get index for the corresponding block
773 alloc_index = GET_SIZE_INDEX( alloc_size );
774
775 // compute alloc[] array base address
776 alloc_base = store_base + store_size - alloc_size;
777
778 // reset the free[] array
779 for ( iter = 0 ; iter < 32 ; iter++ )
780 {
781 store[cxy].free[iter] = 0;
782 }
783
784 // split the store into various sizes blocks,
785 // initializes the free[] array and NEXT pointers
786 // base is the block base address
787 unsigned int base = store_base;
788 unsigned int * ptr;
789 for ( iter = free_index-1 ; iter >= alloc_index ; iter-- )
790 {
791 store[cxy].free[iter] = base;
792 ptr = (unsigned int*)base;
793 *ptr = 0;
794 base = base + (1<<iter);
795 }
796
797 // initialize store mutex
798 if( pthread_mutex_init( &store[cxy].mutex , NULL ) )
799 {
800 printf("\n[ERROR] in %s : cannot initialize mutex for store[%x]\n",
801 __FUNCTION__, cxy );
802 return;
803 }
804
805 store[cxy].cxy = cxy;
806 store[cxy].store_base = store_base;
807 store[cxy].store_size = store_size;
808 store[cxy].alloc_size = alloc_size;
809 store[cxy].alloc_base = alloc_base;
810 store[cxy].initialized = MALLOC_INITIALIZED;
811
812
813#if DEBUG_REMOTE_MALLOC
814printf("\n[%s] core[%x,%d] completed store[%x] initialisation\n",
815__FUNCTION__, core_cxy, core_lid, cxy );
816#endif
817
818#if (DEBUG_REMOTE_MALLOC & 1)
819display_free_array( cxy );
820#endif
821
822} // end store_init()
823
824////////////////////////////////////////////////////////
825static unsigned int split_block( malloc_store_t * store,
826 unsigned int vaddr,
827 unsigned int searched_index,
828 unsigned int requested_index )
829{
830 // push the upper half block into free[searched_index-1]
831 unsigned int* new = (unsigned int*)(vaddr + (1<<(searched_index-1)));
832 *new = store->free[searched_index-1];
833 store->free[searched_index-1] = (unsigned int)new;
834
835 if ( searched_index == requested_index + 1 ) // terminal case: return lower half block
836 {
837 return vaddr;
838 }
839 else // non terminal case : lower half block must be split again
840 {
841 return split_block( store, vaddr, searched_index-1, requested_index );
842 }
843} // end split_block()
844
845//////////////////////////////////////////////////////
846static unsigned int get_block( malloc_store_t * store,
847 unsigned int searched_index,
848 unsigned int requested_index )
849{
850 // test terminal case
851 if ( (unsigned int)(1<<searched_index) > store->store_size ) // failure
852 {
853 return 0;
854 }
855 else // search a block in free[searched_index]
856 {
857 unsigned int vaddr = store->free[searched_index];
858 if ( vaddr == 0 ) // block not found : search in free[searched_index+1]
859 {
860 return get_block( store, searched_index+1, requested_index );
861 }
862 else // block found : pop it from free[searched_index]
863 {
864 // pop the block from free[searched_index]
865 unsigned int next = *((unsigned int*)vaddr);
866 store->free[searched_index] = next;
867
868 // test if the block must be split
869 if ( searched_index == requested_index ) // no split required
870 {
871 return vaddr;
872 }
873 else // split is required
874 {
875 return split_block( store, vaddr, searched_index, requested_index );
876 }
877 }
878 }
879} // end get_block()
880
881////////////////////////////////////////
882void * remote_malloc( unsigned int size,
883 unsigned int cxy )
884{
885 int error;
886
887#if DEBUG_REMOTE_MALLOC
888unsigned int core_cxy;
889unsigned int core_lid;
890get_core_id( &core_cxy , &core_lid );
891printf("\n[%s] core[%x,%d] enter for size = %x / target_cxy = %x\n",
892__FUNCTION__ , core_cxy, core_lid, size , cxy );
893#endif
894
895 // check arguments
896 if( size == 0 )
897 {
898 printf("\n[ERROR] in %s : requested size = 0 \n",
899 __FUNCTION__ );
900 return NULL;
901 }
902 if( cxy >= MALLOC_MAX_CLUSTERS )
903 {
904 printf("\n[ERROR] in %s : illegal cluster %x\n",
905 __FUNCTION__ , cxy );
906 return NULL;
907 }
908
909 // initializes target store if required
910 if( store[cxy].initialized != MALLOC_INITIALIZED )
911 {
912 store_init( cxy , MALLOC_LOCAL_STORE_SIZE );
913
914 if( store[cxy].initialized != MALLOC_INITIALIZED )
915 {
916 printf("\n[ERROR] in %s : cannot allocate store in cluster %x\n",
917 __FUNCTION__ , cxy );
918 return NULL;
919 }
920 }
921
922 // normalize size
923 if ( size < MALLOC_MIN_BLOCK_SIZE ) size = MALLOC_MIN_BLOCK_SIZE;
924
925 // compute requested_index for the free[] array
926 unsigned int requested_index = GET_SIZE_INDEX( size );
927
928 // take the lock protecting access to store[cxy]
929 error = pthread_mutex_lock( &store[cxy].mutex );
930
931 if( error )
932 {
933 printf("\n[ERROR] in %s : cannot take the lock protecting store in cluster %x\n",
934 __FUNCTION__ , cxy );
935 return NULL;
936 }
937
938 // call the recursive function get_block
939 unsigned int base = get_block( &store[cxy],
940 requested_index,
941 requested_index );
942
943 // check block found
944 if (base == 0)
945 {
946 pthread_mutex_unlock( &store[cxy].mutex );
947 printf("\n[ERROR] in %s : no more space in cluster %x\n",
948 __FUNCTION__ , cxy );
949 return NULL;
950 }
951
952 // compute pointer in alloc[] array
953 unsigned offset = (base - store[cxy].store_base) / MALLOC_MIN_BLOCK_SIZE;
954 unsigned char * ptr = (unsigned char*)(store[cxy].alloc_base + offset);
955
956 // update alloc_array
957 *ptr = requested_index;
958
959 // release the lock
960 pthread_mutex_unlock( &store[cxy].mutex );
961
962#if DEBUG_REMOTE_MALLOC
963printf("\n[%s] core[%x,%d] exit / base = %x / size = %x / from store[%x]\n",
964__FUNCTION__, core_cxy, core_lid, base , size , cxy );
965#endif
966
967 return (void*) base;
968
969} // end remote_malloc()
970
971//////////////////////////////////////////
972void * remote_calloc ( unsigned int count,
973 unsigned int size,
974 unsigned int cxy )
975{
976 void * ptr = remote_malloc( count * size , cxy );
977 memset( ptr , 0 , count * size );
978 return ptr;
979}
980
981//////////////////////////////////
982void * remote_realloc( void * ptr,
983 unsigned int size,
984 unsigned int cxy )
985{
986 // simple allocation when (ptr == NULL)
987 if( ptr == NULL )
988 {
989 return remote_malloc( size , cxy );
990 }
991
992 // simple free when (size == 0)
993 if( size == 0 )
994 {
995 remote_free( ptr , cxy );
996 return NULL;
997 }
998
999 // check cxy and ptr in general case
1000 if( cxy >= MALLOC_MAX_CLUSTERS )
1001 {
1002 printf("\n[ERROR] in %s : illegal cluster index %x\n",
1003 __FUNCTION__ , cxy );
1004 return NULL;
1005 }
1006
1007 unsigned int base = (unsigned int)ptr;
1008
1009 if( (base < store[cxy].store_base) ||
1010 (base >= (store[cxy].store_base + store[cxy].store_size)) )
1011 {
1012 printf("\n[ERROR] in %s : illegal pointer = %x\n",
1013 __FUNCTION__, ptr );
1014 return NULL;
1015 }
1016
1017 // compute index in free[] array
1018 int index = (base - store[cxy].store_base) / MALLOC_MIN_BLOCK_SIZE;
1019
1020 // compute old size
1021 char * pchar = (char *) (store[cxy].alloc_base + index);
1022 unsigned int old_size = (unsigned int)(1 << ((int) *pchar));
1023
1024 // allocate a new block
1025 void * new_ptr = remote_malloc( size , cxy );
1026
1027 // save old data to new block
1028 int min_size = (int)((size < old_size) ? size : old_size);
1029 memcpy( new_ptr, ptr, min_size );
1030
1031 // release old block
1032 remote_free( ptr , cxy );
1033
1034 return new_ptr;
1035
1036} // end remote_realloc()
1037
1038
1039//////////////////////////////////////////////////////
1040static void update_free_array( malloc_store_t * store,
1041 unsigned int base,
1042 unsigned int size_index )
1043{
1044 // This recursive function try to merge the released block
1045 // with the companion block if this companion block is free.
1046 // This companion has the same size, and almost the same address
1047 // (only one address bit is different)
1048 // - If the companion is not in free[size_index],
1049 // the released block is pushed in free[size_index].
1050 // - If the companion is found, it is evicted from free[size_index]
1051 // and the merged bloc is pushed in the free[size_index+1].
1052
1053
1054 // compute released block size
1055 unsigned int size = 1<<size_index;
1056
1057 // compute companion block and merged block base addresses
1058 unsigned int companion_base;
1059 unsigned int merged_base;
1060
1061 if ( (base & size) == 0 ) // the released block is aligned on (2*size)
1062 {
1063 companion_base = base + size;
1064 merged_base = base;
1065 }
1066 else
1067 {
1068 companion_base = base - size;
1069 merged_base = base - size;
1070 }
1071
1072 // scan all blocks in free[size_index]
1073 // the iter & prev variables are actually addresses
1074 unsigned int found = 0;
1075 unsigned int iter = store->free[size_index];
1076 unsigned int prev = (unsigned int)&store->free[size_index];
1077 while ( iter )
1078 {
1079 if ( iter == companion_base )
1080 {
1081 found = 1;
1082 break;
1083 }
1084 prev = iter;
1085 iter = *(unsigned int*)iter;
1086 }
1087
1088 if ( found == 0 ) // Companion not found => push in free[size_index]
1089 {
1090 *(unsigned int*)base = store->free[size_index];
1091 store->free[size_index] = base;
1092 }
1093 else // Companion found : merge
1094 {
1095 // evict the searched block from free[size_index]
1096 *(unsigned int*)prev = *(unsigned int*)iter;
1097
1098 // call the update_free() function for free[size_index+1]
1099 update_free_array( store, merged_base , size_index+1 );
1100 }
1101} // end update_free_array()
1102
1103////////////////////////////////////
1104void remote_free( void * ptr,
1105 unsigned int cxy )
1106{
1107
1108#if DEBUG_REMOTE_MALLOC
1109printf("\n[MALLOC] %s : enter for block = %x / cxy = %x\n",
1110__FUNCTION__, ptr, cxy );
1111#endif
1112
1113 unsigned int base = (unsigned int)ptr;
1114
1115 // check cxy value
1116 if( cxy >= MALLOC_MAX_CLUSTERS )
1117 {
1118 printf("\n[ERROR] in %s : illegal cluster index %x\n",
1119 __FUNCTION__ , cxy );
1120 return;
1121 }
1122
1123 // check ptr value
1124 if( (base < store[cxy].store_base) ||
1125 (base >= (store[cxy].store_base + store[cxy].store_size)) )
1126 {
1127 printf("\n[ERROR] in %s : illegal pointer for released block = %x\n",
1128 __FUNCTION__, ptr );
1129 return;
1130 }
1131
1132 // get the lock protecting store[cxy]
1133 pthread_mutex_lock( &store[cxy].mutex );
1134
1135 // compute released block index in alloc[] array
1136 unsigned index = (base - store[cxy].store_base ) / MALLOC_MIN_BLOCK_SIZE;
1137
1138 // get the released block size_index
1139 unsigned char* pchar = (unsigned char*)(store[cxy].alloc_base + index);
1140 unsigned int size_index = (unsigned int)*pchar;
1141
1142 // check block is allocated
1143 if ( size_index == 0 )
1144 {
1145 pthread_mutex_unlock( &store[cxy].mutex );
1146 printf("\n[ERROR] in %s : released block not allocated / ptr = %x\n",
1147 __FUNCTION__, ptr );
1148 return;
1149 }
1150
1151 // check released block alignment
1152 if ( base % (1 << size_index) )
1153 {
1154 pthread_mutex_unlock( &store[cxy].mutex );
1155 printf("\n[ERROR] in %s : released block not aligned / ptr = %x\n",
1156 __FUNCTION__, ptr );
1157 return;
1158 }
1159
1160 // reset the alloc[index] entry
1161 *pchar = 0;
1162
1163 // call the recursive function update_free_array()
1164 update_free_array( &store[cxy], base, size_index );
1165
1166 // release the lock
1167 pthread_mutex_unlock( &store[cxy].mutex );
1168
1169#if DEBUG_REMOTE_MALLOC
1170printf("\n[MALLOC] %s : conmpletes for block = %x / cxy = %x\n",
1171__FUNCTION__, ptr, cxy );
1172#endif
1173
1174} // end remote_free()
1175
1176/////////////////////////////////////////////////////////////////////////////////////////
1177/////////////// non standard pthread_parallel_create //////////////////////////////
1178/////////////////////////////////////////////////////////////////////////////////////////
1179
1180#define X_MAX 16 // max number of clusters in a row
1181#define Y_MAX 16 // max number of clusters in a column
1182#define CLUSTERS_MAX X_MAX * Y_MAX // max number of clusters
1183#define LEVEL_MAX 5 // max level of DQT
1184#define CORES_MAX 4 // max number of cores per cluster
1185
1186/////////////////////////////////////////////////////////////////////////////////////////
1187// Global variables
1188//
1189// WARNING : arguments of the pthread_create() function MUST be global variables.
1190/////////////////////////////////////////////////////////////////////////////////////////
1191
1192// 2D array of <build> threads attributes / indexed by [cid][level]
1193__attribute__((aligned(4096)))
1194pthread_attr_t pthread_build_attr[CLUSTERS_MAX][LEVEL_MAX];
1195
1196// 2D array of <build> threads arguments / indexed by [cid][level]
1197__attribute__((aligned(4096)))
1198pthread_parallel_build_args_t pthread_build_args[CLUSTERS_MAX][LEVEL_MAX];
1199
1200// 1D array of <work> threads attributes / indexed by [tid]
1201__attribute__((aligned(4096)))
1202pthread_attr_t pthread_work_attr[CLUSTERS_MAX * CORES_MAX];
1203
1204// 1D array of <work> threads arguments / indexed by [tid]
1205__attribute__((aligned(4096)))
1206pthread_parallel_work_args_t pthread_work_args[CLUSTERS_MAX * CORES_MAX];
1207
1208// kernel thread identifier / unused, but required by pthread_create()
1209__attribute__((aligned(4096)))
1210pthread_t trdid;
1211
1212///////////////////////////////////////////////////////////////////////////
1213static void pthread_recursive_build( pthread_parallel_build_args_t * args )
1214{
1215
1216 // get arguments
1217 unsigned int cid = args->cid;
1218 unsigned int level = args->level;
1219 unsigned int parent_cid = args->parent_cid;
1220 pthread_barrier_t * parent_barrier = args->parent_barrier;
1221 unsigned int root_level = args->root_level;
1222 void * work_func = args->work_func;
1223 unsigned int x_size = args->x_size;
1224 unsigned int y_size = args->y_size;
1225 unsigned int ncores = args->ncores;
1226
1227#if DEBUG_PTHREAD_PARALLEL
1228printf("\n[%s] <build> thread[%d][%d] enters / parent_cid %d / work_func %x\n",
1229__FUNCTION__, cid , level , parent_cid , work_func );
1230#endif
1231
1232 // set error default value in pthread_build_args[cid][level]
1233 pthread_build_args[cid][level].error = 0;
1234
1235 // get cxy from cid
1236 unsigned int cxy = HAL_CXY_FROM_XY( cid / y_size , cid % y_size );
1237
1238 // allocate the parent/child barrier in local cluster
1239 pthread_barrier_t * barrier = (pthread_barrier_t *)malloc( sizeof(pthread_barrier_t) );
1240
1241 if( barrier == NULL )
1242 {
1243 printf("\n[ERROR] in %s : cannot allocate barrier for <build> thread[%d][%d]\n",
1244 __FUNCTION__ , cid , level );
1245
1246 // report error to parent
1247 pthread_build_args[parent_cid][level+1].error = 1;
1248 }
1249
1250 ///////////////////////////////////////////////////////////
1251 if( level == 0 ) // children are <work> threads
1252 {
1253
1254 // check number of cores in local cluster
1255 unsigned int actual_ncores;
1256 get_nb_cores( cxy , &actual_ncores );
1257
1258 if( actual_ncores != ncores )
1259 {
1260 printf("\n[ERROR] in %s : actual_ncores (%d) in cluster %x\n",
1261 __FUNCTION__ , actual_ncores, cxy );
1262
1263 // report error to parent
1264 pthread_build_args[parent_cid][level+1].error = 1;
1265 }
1266
1267 // initializes barrier for (ncores + 1) in flat mode
1268 if( pthread_barrier_init( barrier , NULL , ncores + 1 ) )
1269 {
1270 printf("\n[ERROR] in %s : cannot init barrier for <build> thread[%d][%d]\n",
1271 __FUNCTION__ , cid , level );
1272
1273 // report error to parent
1274 pthread_build_args[parent_cid][level+1].error = 1;
1275 }
1276
1277#if DEBUG_PTHREAD_PARALLEL
1278printf("\n[%s] <build> thread[%d][%d] initialized barrier / %d children\n",
1279__FUNCTION__, cid, level, ncores );
1280#endif
1281 unsigned int lid; // core local index for <work> thread
1282 unsigned int tid; // <work> thread continuous index
1283
1284 // <build> thread creates ncores <work> threads
1285 for ( lid = 0 ; lid < ncores ; lid++ )
1286 {
1287 // compute work thread tid
1288 tid = (cid * ncores) + lid;
1289
1290 // set attributes for <work> thread[tid]
1291 pthread_work_attr[tid].attributes = PT_ATTR_DETACH |
1292 PT_ATTR_CLUSTER_DEFINED |
1293 PT_ATTR_CORE_DEFINED;
1294 pthread_work_attr[tid].cxy = cxy;
1295 pthread_work_attr[tid].lid = lid;
1296
1297 // set tid and barrier arguments for <work> thread[tid]
1298 pthread_work_args[tid].tid = tid;
1299 pthread_work_args[tid].barrier = barrier;
1300
1301 // create <work> thread
1302 if ( pthread_create( &trdid, // unused
1303 &pthread_work_attr[tid],
1304 work_func,
1305 &pthread_work_args[tid] ) )
1306 {
1307 printf("\n[ERROR] in %s : <build> thread[%d][%d] cannot create <work> thread[%d]\n",
1308 __FUNCTION__ , cid , level , tid );
1309
1310 // report error to parent
1311 pthread_build_args[parent_cid][level+1].error = 1;
1312 }
1313
1314#if DEBUG_PTHREAD_PARALLEL
1315printf("\n[%s] <build> thread[%d][%d] created <work> thread[%d]\n",
1316__FUNCTION__, cid, level, tid );
1317#endif
1318 }
1319
1320 // wait on barrier until all <work> children threads completed
1321 if( pthread_barrier_wait( barrier ) )
1322 {
1323 printf("\n[ERROR] in %s / barrier for <build> thread[%x][%d]\n",
1324 __FUNCTION__ , cid , level );
1325
1326 // report error to parent
1327 pthread_build_args[parent_cid][level+1].error = 1;
1328 }
1329
1330#if DEBUG_PTHREAD_PARALLEL
1331printf("\n[%s] <build> thread[%d][%d] resume after children completion\n",
1332__FUNCTION__ , cid , level );
1333#endif
1334
1335 } // end level == 0
1336
1337 ////////////////////////////////////////////////////////////
1338 else // children are "build" threads
1339 {
1340 // the 4 children threads can be linked to any core in each
1341 // sub-macro-cluster[i][j] with [ij] in {00,01,10,11}
1342
1343 unsigned int parent_x; // X coordinate of parent macro-cluster
1344 unsigned int parent_y; // Y coordinate of parent macro-cluster
1345 unsigned int child_x; // X coordinate of child macro-cluster
1346 unsigned int child_y; // Y coordinate of child macro-cluster
1347 unsigned int child_cid[2][2]; // selected cluster cid for child[i][j]
1348 unsigned int child_cxy[2][2]; // selected cluster cxy for child[i][j]
1349 unsigned int child_lid[2][2]; // selected core index for child[i][j]
1350 int child_sts[2][2]; // -1 if error / 0 if success / +1 if no core
1351 unsigned int i; // loop index for children
1352 unsigned int j; // loop index for children
1353
1354 unsigned int nb_children = 0; // actual number of children (can be < 4)
1355
1356 // get parent macro-cluster mask and half-size from level
1357 unsigned int mask = (1 << level) - 1;
1358 unsigned int half = (level > 0) ? (1 << (level - 1)) : 0;
1359
1360 // get parent macro-cluster coordinates
1361 parent_x = HAL_X_FROM_CXY( cxy ) & ~mask;
1362 parent_y = HAL_Y_FROM_CXY( cxy ) & ~mask;
1363
1364 // First step : select core for each child thread
1365 for (i = 0 ; i < 2 ; i++)
1366 {
1367 // compute child macro-cluster X coordinate
1368 child_x = (i == 0) ? parent_x : (parent_x + half);
1369
1370 for (j = 0 ; j < 2 ; j++)
1371 {
1372 // compute child macro-cluster Y coordinate
1373 child_y = (j == 0) ? parent_y : (parent_y + half);
1374
1375 // select the best core in macro-cluster
1376 unsigned int best_cxy;
1377 unsigned int best_lid;
1378
1379 child_sts[i][j] = get_best_core( HAL_CXY_FROM_XY( child_x , child_y ),
1380 level-1,
1381 &best_cxy,
1382 &best_lid );
1383
1384 if( child_sts[i][j] < 0 ) // failure => report error
1385 {
1386 printf("\n[ERROR] in %s : child[%d,%d] of <build> thread[%d,%d]\n",
1387 __FUNCTION__ , i , j , cid , level );
1388
1389 // report error to parent
1390 pthread_build_args[parent_cid][level+1].error = 1;
1391 }
1392 else if (child_sts[i][j] > 0 ) // macro-cluster empty => does nothing
1393 {
1394 }
1395 else // core found
1396 {
1397 child_cxy[i][j] = best_cxy;
1398 child_lid[i][j] = best_lid;
1399 child_cid[i][j] = (HAL_X_FROM_CXY(best_cxy) * y_size) + HAL_Y_FROM_CXY( best_cxy);
1400 nb_children++;
1401
1402#if DEBUG_PTHREAD_PARALLEL
1403printf("\n[%s] <build> thread[%d][%d] select core[%x][%d] for child[%d][%d]\n",
1404__FUNCTION__ , cid , level , best_cxy , best_lid , i , j );
1405#endif
1406
1407 }
1408 } // end for j
1409 } // end for i
1410
1411 // second step : initialize barrier for (nb_children + 1) in flat mode
1412 if( pthread_barrier_init( barrier , NULL , nb_children + 1 ) )
1413 {
1414 printf("\n[ERROR] in %s : cannot init barrier for <build> thread[%d][%d]\n",
1415 __FUNCTION__ , cid , level );
1416
1417 // report error to parent
1418 pthread_build_args[parent_cid][level+1].error = 1;
1419 }
1420
1421#if DEBUG_PTHREAD_PARALLEL
1422printf("\n[%s] <build> thread[%d][%d] initialized barrier / %d children\n",
1423__FUNCTION__, cid, level, nb_children );
1424#endif
1425
1426 // Third step : actually create the children threads
1427 for (i = 0 ; i < 2 ; i++)
1428 {
1429 for (j = 0 ; j < 2 ; j++)
1430 {
1431 // thread is created only if macro-cluster is active
1432 if( child_sts[i][j] == 0 )
1433 {
1434 unsigned int tgt_cid = child_cid[i][j];
1435 unsigned int tgt_lid = child_lid[i][j];
1436 unsigned int tgt_cxy = child_cxy[i][j];
1437
1438 // set child thread attributes
1439 pthread_build_attr[tgt_cid][level-1].attributes = PT_ATTR_DETACH |
1440 PT_ATTR_CLUSTER_DEFINED |
1441 PT_ATTR_CORE_DEFINED;
1442 pthread_build_attr[tgt_cid][level-1].cxy = tgt_cxy;
1443 pthread_build_attr[tgt_cid][level-1].lid = tgt_lid;
1444
1445 // propagate build function arguments from parent to child
1446 pthread_build_args[tgt_cid][level-1].cid = tgt_cid;
1447 pthread_build_args[tgt_cid][level-1].level = level-1;
1448 pthread_build_args[tgt_cid][level-1].parent_cid = cid;
1449 pthread_build_args[tgt_cid][level-1].parent_barrier = barrier;
1450 pthread_build_args[tgt_cid][level-1].root_level = root_level;
1451 pthread_build_args[tgt_cid][level-1].work_func = work_func;
1452 pthread_build_args[tgt_cid][level-1].x_size = x_size;
1453 pthread_build_args[tgt_cid][level-1].y_size = y_size;
1454 pthread_build_args[tgt_cid][level-1].ncores = ncores;
1455
1456 // create thread
1457 if( pthread_create( &trdid,
1458 &pthread_build_attr[tgt_cid][level-1],
1459 &pthread_recursive_build,
1460 &pthread_build_args[tgt_cid][level-1] ) )
1461 {
1462 printf("\n[ERROR] in %s : cannot create <build> thread[%x][%d]\n",
1463 __FUNCTION__ , child_cid , level -1 );
1464
1465 // report error to parent
1466 pthread_build_args[parent_cid][level+1].error = 1;
1467 }
1468
1469#if DEBUG_PTHREAD_PARALLEL
1470printf("\n[%s] <build> thread[%d][%d] created <build> thread[%d][%d] on core[%x,%d]\n",
1471__FUNCTION__, cid, level, tgt_cid, (level - 1), tgt_cxy, tgt_lid );
1472#endif
1473 } //end if sts[x][y]
1474 } // end for y
1475 } // end for x
1476
1477 // wait on barrier until all <build> children threads completed
1478 if( pthread_barrier_wait( barrier ) )
1479 {
1480 printf("\n[ERROR] in %s / barrier for <build> thread[%d][%d]\n",
1481 __FUNCTION__ , cid , level );
1482
1483 // report error to parent
1484 pthread_build_args[parent_cid][level+1].error = 1;
1485 }
1486
1487#if DEBUG_PTHREAD_PARALLEL
1488printf("\n[%s] <build> thread[%x][%d] resume after children completion\n",
1489__FUNCTION__, cid, level );
1490#endif
1491
1492 } // end level > 0
1493
1494 // report error to parent when required
1495 if( pthread_build_args[cid][level].error )
1496 {
1497 pthread_build_args[parent_cid][level+1].error = 1;
1498 }
1499
1500 // all <build> threads - but the root - signal completion to parent thread and exit
1501 if( level < root_level )
1502 {
1503 if( pthread_barrier_wait( parent_barrier ) )
1504 {
1505 printf("\n[ERROR] in %s / parent barrier for <build> thread[%d][%d]\n",
1506 __FUNCTION__ , cid , level );
1507
1508 // report error to parent
1509 pthread_build_args[parent_cid][level+1].error = 1;
1510 }
1511
1512#if DEBUG_PTHREAD_PARALLEL
1513printf("\n[%s] <build> thread[%x][%d] exit\n",
1514__FUNCTION__, cid , level );
1515#endif
1516 // <build> thread exit
1517 pthread_exit( NULL );
1518 }
1519} // end pthread_recursive_build()
1520
1521
1522//////////////////////////////////////////////////////
1523int pthread_parallel_create( unsigned int root_level,
1524 void * work_func )
1525{
1526
1527#if DEBUG_PTHREAD_PARALLEL
1528printf("\n[%s] enter / root_level %d / func %x\n",
1529__FUNCTION__, root_level, work_func );
1530#endif
1531
1532 // get platform parameters
1533 hard_config_t config;
1534 get_config( &config );
1535 unsigned int x_size = config.x_size;
1536 unsigned int y_size = config.y_size;
1537 unsigned int ncores = config.ncores;
1538
1539 // get calling thread cluster identifier
1540 unsigned int root_cxy;
1541 unsigned int root_lid; // unused, but required by get_core_id()
1542 get_core_id( &root_cxy , &root_lid );
1543
1544 // get calling thread continuous index
1545 unsigned int x = HAL_X_FROM_CXY( root_cxy );
1546 unsigned int y = HAL_Y_FROM_CXY( root_cxy );
1547 unsigned int root_cid = (y_size * x) + y;
1548
1549 // set the build function arguments for the root <build> thread
1550 pthread_build_args[root_cid][root_level].cid = root_cid;
1551 pthread_build_args[root_cid][root_level].level = root_level;
1552 pthread_build_args[root_cid][root_level].parent_cid = -1;
1553 pthread_build_args[root_cid][root_level].parent_barrier = NULL;
1554 pthread_build_args[root_cid][root_level].root_level = root_level;
1555 pthread_build_args[root_cid][root_level].work_func = work_func;
1556 pthread_build_args[root_cid][root_level].x_size = x_size;
1557 pthread_build_args[root_cid][root_level].y_size = y_size;
1558 pthread_build_args[root_cid][root_level].ncores = ncores;
1559
1560 // call the recursive function
1561 pthread_recursive_build( &pthread_build_args[root_cid][root_level] );
1562
1563 // check error when execution completes
1564 if( pthread_build_args[root_cid][root_level].error )
1565 {
1566 printf("\n[error] in %s\n", __FUNCTION__ );
1567 return -1;
1568 }
1569
1570 return 0;
1571
1572} // end pthread_parallel_create()
1573
1574/////////////////////////////////////////////////////////////////////////////////////////
1575/////////////// non standard Frame Buffer related syscalls
1576/////////////////////////////////////////////////////////////////////////////////////////
1577
1578////////////////////////////////
1579int fbf_get_config( int * width,
1580 int * height,
1581 int * type )
1582{
1583 return hal_user_syscall( SYS_FBF,
1584 (reg_t)FBF_GET_CONFIG,
1585 (reg_t)width,
1586 (reg_t)height,
1587 (reg_t)type );
1588}
1589
1590////////////////////////////
1591int fbf_read( void * buffer,
1592 int length,
1593 int offset )
1594{
1595 printf("[WARNING] the <%s> syscall is deprecated\n", __FUNCTION__ );
1596
1597 return hal_user_syscall( SYS_FBF,
1598 (reg_t)FBF_DIRECT_READ,
1599 (reg_t)buffer,
1600 (reg_t)length,
1601 (reg_t)offset );
1602}
1603
1604/////////////////////////////
1605int fbf_write( void * buffer,
1606 int length,
1607 int offset )
1608{
1609 printf("[WARNING] the <%s> syscall is deprecated\n", __FUNCTION__ );
1610
1611 return hal_user_syscall( SYS_FBF,
1612 (reg_t)FBF_DIRECT_WRITE,
1613 (reg_t)buffer,
1614 (reg_t)length,
1615 (reg_t)offset );
1616}
1617
1618//////////////////////////////////////
1619int fbf_create_window( int l_zero,
1620 int p_zero,
1621 int nlines,
1622 int npixels,
1623 void ** buffer )
1624{
1625 return hal_user_syscall( SYS_FBF,
1626 (reg_t)FBF_CREATE_WINDOW,
1627 (reg_t)((l_zero << 16) | p_zero),
1628 (reg_t)((nlines << 16) | npixels),
1629 (reg_t)buffer );
1630}
1631
1632///////////////////////////////
1633int fbf_active_window( int wid,
1634 int active )
1635{
1636 return hal_user_syscall( SYS_FBF,
1637 (reg_t)FBF_ACTIVE_WINDOW,
1638 (reg_t)wid,
1639 (reg_t)active, 0 );
1640}
1641
1642/////////////////////////////////
1643int fbf_delete_window( int wid )
1644{
1645 return hal_user_syscall( SYS_FBF,
1646 (reg_t)FBF_DELETE_WINDOW,
1647 (reg_t)wid, 0, 0 );
1648}
1649
1650//////////////////////////////
1651int fbf_move_window( int wid,
1652 int l_zero,
1653 int p_zero )
1654{
1655 return hal_user_syscall( SYS_FBF,
1656 (reg_t)FBF_MOVE_WINDOW,
1657 (reg_t)wid,
1658 (reg_t)l_zero,
1659 (reg_t)p_zero );
1660}
1661
1662////////////////////////////////
1663int fbf_resize_window( int wid,
1664 int width,
1665 int height )
1666{
1667 return hal_user_syscall( SYS_FBF,
1668 (reg_t)FBF_RESIZE_WINDOW,
1669 (reg_t)wid,
1670 (reg_t)width,
1671 (reg_t)height );
1672}
1673
1674/////////////////////////////////
1675int fbf_refresh_window( int wid,
1676 int line_first,
1677 int line_last )
1678{
1679 return hal_user_syscall( SYS_FBF,
1680 (reg_t)FBF_REFRESH_WINDOW,
1681 (reg_t)wid,
1682 (reg_t)line_first,
1683 (reg_t)line_last );
1684}
1685
1686/////////////////////////////////
1687int fbf_front_window( int wid )
1688{
1689 return hal_user_syscall( SYS_FBF,
1690 (reg_t)FBF_FRONT_WINDOW,
1691 (reg_t)wid, 0, 0 );
1692}
1693
1694// Local Variables:
1695// tab-width: 4
1696// c-basic-offset: 4
1697// c-file-offsets:((innamespace . 0)(inline-open . 0))
1698// indent-tabs-mode: nil
1699// End:
1700// vim: filetype=c:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
1701
1702
1703
Note: See TracBrowser for help on using the repository browser.