Changeset 637 for trunk/kernel/syscalls


Ignore:
Timestamp:
Jul 18, 2019, 2:06:55 PM (5 years ago)
Author:
alain
Message:

Introduce the non-standard pthread_parallel_create() system call
and re-write the <fft> and <sort> applications to improve the
intrinsic paralelism in applications.

Location:
trunk/kernel/syscalls
Files:
32 edited

Legend:

Unmodified
Added
Removed

  • trunk/kernel/syscalls/shared_include/shared_mman.h

    r623 r637  
    5151typedef struct mmap_attr_s
    5252{
    53         void         * addr;       /*! requested virtual address (unused : should be NULL)    */
     53        void         * addr;       /*! buffer for allocated vseg base address (return value)  */
    5454        unsigned int   length;     /*! requested vseg size (bytes)                            */
    5555        unsigned int   prot;       /*! access modes                                           */

  • trunk/kernel/syscalls/shared_include/syscalls_numbers.h

    r626 r637  
    2929 * It must be kept consistent with the array defined in do_syscalls.c
    3030 *****************************************************************************************/
    31 typedef enum {
     31typedef enum
     32{
    3233    SYS_THREAD_EXIT    = 0,
    3334    SYS_THREAD_YIELD   = 1,
    … …  
    7576
    7677    SYS_GET_CONFIG     = 40,
    77     SYS_GET_CORE       = 41,
     78    SYS_GET_CORE_ID    = 41,
    7879    SYS_GET_CYCLE      = 42,
    7980    SYS_DISPLAY        = 43,
    … …  
    8889    SYS_SYNC           = 51,
    8990    SYS_FSYNC          = 52,
     91    SYS_GET_BEST_CORE  = 53,
     92    SYS_GET_NB_CORES   = 54,
    9093
    91     SYSCALLS_NR        = 53,
     94    SYSCALLS_NR        = 55,
    9295
    9396} syscalls_t;

  • trunk/kernel/syscalls/sys_barrier.c

    r635 r637  
    3333#include <remote_barrier.h>
    3434
    35 #if DEBUG_SYS_BARRIER
    3635//////////////////////////////////////////////////////
    3736static char * sys_barrier_op_str( uint32_t operation )
    … …  
    4241        else                                    return "undefined";
    4342}
    44 #endif
    4543
    4644//////////////////////////////////
    … …  
    7472
    7573#if DEBUG_SYSCALLS_ERROR
    76 printk("\n[ERROR] in %s : unmapped barrier %x / thread %x / process %x\n",
    77 __FUNCTION__ , vaddr , this->trdid , process->pid );
     74printk("\n[ERROR] in %s for %s : unmapped barrier %x / thread[%x,%x]\n",
     75__FUNCTION__, sys_barrier_op_str(operation), vaddr, process->pid, this->trdid );
    7876#endif
    7977        this->errno = error;
    … …  
    9492
    9593#if DEBUG_SYSCALLS_ERROR
    96 printk("\n[ERROR] in %s : unmapped barrier attributes %x / thread %x / process %x\n",
    97 __FUNCTION__ , attr , this->trdid , process->pid );
     94printk("\n[ERROR] in %s for INIT : unmapped barrier attributes %x / thread[%x,%x]\n",
     95__FUNCTION__ , attr , process->pid , this->trdid );
    9896#endif
    9997                    this->errno = EINVAL;
    … …  
    102100 
    103101                // copy barrier attributes into kernel space
    104                 hal_copy_from_uspace( local_cxy,
    105                                       &k_attr,
    106                                       (void*)attr,
     102                hal_copy_from_uspace( XPTR( local_cxy , &k_attr ),
     103                                      (void *)attr,
    107104                                      sizeof(pthread_barrierattr_t) );
    108105
    … …  
    111108
    112109#if DEBUG_SYSCALLS_ERROR
    113 printk("\n[ERROR] in %s : wrong arguments / count %d / x_size %d / y_size %d / nthreads %x\n",
     110printk("\n[ERROR] in %s for INIT : count (%d) != x_size (%d) * y_size (%d) * nthreads (%x)\n",
    114111__FUNCTION__, count, k_attr.x_size, k_attr.y_size, k_attr.nthreads );
    115112#endif
    … …  
    131128
    132129#if DEBUG_SYSCALLS_ERROR
    133 printk("\n[ERROR] in %s : cannot create barrier %x / thread %x / process %x\n",
    134 __FUNCTION__ , vaddr , this->trdid , process->pid );
     130printk("\n[ERROR] in %s for INIT : cannot create barrier %x / thread[%x,%x]\n",
     131__FUNCTION__ , vaddr , process->pid , this->trdid );
    135132#endif
    136133                this->errno = ENOMEM;
    … …  
    148145
    149146#if DEBUG_SYSCALLS_ERROR
    150 printk("\n[ERROR] in %s : barrier %x not registered / thread %x / process %x\n",
    151 __FUNCTION__ , (intptr_t)vaddr , this->trdid , process->pid );
     147printk("\n[ERROR] in %s for WAIT : barrier %x not registered / thread[%x,%x]\n",
     148__FUNCTION__ , (intptr_t)vaddr , process->pid, this->trdid );
    152149#endif
    153150                this->errno = EINVAL;
    … …  
    169166
    170167#if DEBUG_SYSCALLS_ERROR
    171 printk("\n[ERROR] in %s : barrier %x not registered / thread %x / process %x\n",
    172 __FUNCTION__ , (intptr_t)vaddr , this->trdid , process->pid );
     168printk("\n[ERROR] in %s for DESTROY : barrier %x not registered / thread[%x,%x]\n",
     169__FUNCTION__ , (intptr_t)vaddr , process->pid, this->trdid );
    173170#endif
    174171                this->errno = EINVAL;

  • trunk/kernel/syscalls/sys_chdir.c

    r610 r637  
    22 * sys_chdir.c - kernel function implementing the "chdir" syscall.
    33 *
    4  * Author    Alain Greiner (2016,2017,2018)
     4 * Author    Alain Greiner (2016,2017,2018, 2019)
    55 *
    66 * Copyright (c) UPMC Sorbonne Universites
    … …  
    7575
    7676    // copy pathname in kernel space
    77     hal_strcpy_from_uspace( kbuf , pathname , CONFIG_VFS_MAX_PATH_LENGTH );
     77    hal_strcpy_from_uspace( XPTR( local_cxy , kbuf ),
     78                            pathname,
     79                            CONFIG_VFS_MAX_PATH_LENGTH );
    7880
    7981#if DEBUG_SYS_CHDIR

  • trunk/kernel/syscalls/sys_chmod.c

    r566 r637  
    22 * sys_chmod.c - Change file access rights.
    33 *
    4  * Author    Alain Greiner  (2016,2017)
     4 * Author    Alain Greiner  (2016,2017,2018,2019)
    55 *
    66 * Copyright (c) 2015 UPMC Sorbonne Universites
    … …  
    4747
    4848#if DEBUG_SYSCALLS_ERROR
    49         printk("\n[ERROR] in %s : pathname too long / thread %x in process %x\n",
    50         __FUNCTION__, this->trdid, process->pid );
     49printk("\n[ERROR] in %s : pathname too long / thread %x in process %x\n",
     50__FUNCTION__, this->trdid, process->pid );
    5151#endif
    5252        this->errno = ENFILE;
    … …  
    5555
    5656    // copy pathname in kernel space
    57     hal_strcpy_from_uspace( kbuf , pathname , CONFIG_VFS_MAX_PATH_LENGTH );
     57    hal_strcpy_from_uspace( XPTR( local_cxy , kbuf ),
     58                            pathname,
     59                            CONFIG_VFS_MAX_PATH_LENGTH );
    5860
    5961    printk("\n[ERROR] in %s : not implemented yet\n", __FUNCTION__ );

  • trunk/kernel/syscalls/sys_display.c

    r635 r637  
    122122
    123123            // copy string to kernel space
    124             hal_strcpy_from_uspace( kbuf , string , 512 );
     124            hal_strcpy_from_uspace( XPTR( local_cxy , kbuf ),
     125                                    string,
     126                                    512 );
    125127
    126128            // print message on TXT0 kernel terminal
    … …  
    136138
    137139            // check cxy argument
    138                 if( cluster_is_undefined( cxy ) )
     140                if( cluster_is_active( cxy ) == false )
    139141            {
    140142
    … …  
    172174
    173175            // check cxy argument
    174                 if( cluster_is_undefined( cxy ) )
     176                if( cluster_is_active( cxy ) == false )
    175177            {
    176178
    … …  
    213215
    214216            // check cxy argument
    215                 if( cluster_is_undefined( cxy ) )
     217                if( cluster_is_active( cxy ) == false )
    216218            {
    217219
    … …  
    323325
    324326            // copy pathname in kernel space
    325             hal_strcpy_from_uspace( kbuf , path , CONFIG_VFS_MAX_PATH_LENGTH );
     327            hal_strcpy_from_uspace( XPTR( local_cxy , kbuf ),
     328                                    path,
     329                                    CONFIG_VFS_MAX_PATH_LENGTH );
    326330
    327331            // compute root inode for pathname
    … …  
    447451                uint32_t  cxy = (uint32_t)arg0;
    448452
    449                 if( cluster_is_undefined( cxy ) )
     453                if( cluster_is_active( cxy ) == false )
    450454                {
    451455

  • trunk/kernel/syscalls/sys_exec.c

    r635 r637  
    8989
    9090    // copy the array of pointers to kernel buffer
    91     hal_copy_from_uspace( local_cxy,
    92                           k_pointers,
     91    hal_copy_from_uspace( XPTR( local_cxy , k_pointers ),
    9392                          u_pointers,
    9493                          CONFIG_PPM_PAGE_SIZE );
    … …  
    109108
    110109        // copy the user string to kernel buffer
    111         hal_copy_from_uspace( local_cxy,
    112                               k_buf_ptr,
     110        hal_copy_from_uspace( XPTR( local_cxy , k_buf_ptr ),
    113111                              k_pointers[index],
    114112                              length );
    … …  
    199197
    200198    // copy pathname in exec_info structure (kernel space)
    201     hal_strcpy_from_uspace( exec_info.path , pathname , CONFIG_VFS_MAX_PATH_LENGTH );
     199    hal_strcpy_from_uspace( XPTR( local_cxy , exec_info.path ),
     200                            pathname,
     201                            CONFIG_VFS_MAX_PATH_LENGTH );
    202202
    203203#if DEBUG_SYS_EXEC

  • trunk/kernel/syscalls/sys_fork.c

    r635 r637  
    105105        else                                  // DQDT placement
    106106        {
    107                 child_cxy = dqdt_get_cluster_for_process();
     107                child_cxy = dqdt_get_cluster_for_thread( LOCAL_CLUSTER->dqdt_root_xp );
    108108        }
    109109

  • trunk/kernel/syscalls/sys_get_config.c

    r635 r637  
    108108
    109109    // copy to user space
    110         hal_copy_to_uspace( local_cxy, &k_x_size, x_size, sizeof(uint32_t) );
    111         hal_copy_to_uspace( local_cxy, &k_y_size, y_size, sizeof(uint32_t) );
    112         hal_copy_to_uspace( local_cxy, &k_ncores, ncores, sizeof(uint32_t) );
     110        hal_copy_to_uspace( x_size, XPTR( local_cxy , &k_x_size ), sizeof(uint32_t) );
     111        hal_copy_to_uspace( y_size, XPTR( local_cxy , &k_y_size ), sizeof(uint32_t) );
     112        hal_copy_to_uspace( ncores, XPTR( local_cxy , &k_ncores ), sizeof(uint32_t) );
    113113
    114114    hal_fence();

  • trunk/kernel/syscalls/sys_get_cycle.c

    r635 r637  
    4545    process_t * process = this->process;
    4646
     47#if (DEBUG_SYS_GET_CYCLE || CONFIG_INSTRUMENTATION_SYSCALLS)
     48uint64_t     tm_start = hal_get_cycles();
     49#endif
     50
    4751    // check buffer in user space
    4852    error = vmm_get_vseg( process , (intptr_t)cycle , &vseg );
    … …  
    6367
    6468    // copy to user space
    65         hal_copy_to_uspace( local_cxy, &k_cycle, cycle, sizeof(uint64_t) );
     69        hal_copy_to_uspace( cycle,
     70                        XPTR( local_cxy , &k_cycle ),
     71                        sizeof(uint64_t) );
     72
     73#if (DEBUG_SYS_GET_CYCLE || CONFIG_INSTRUMENTATION_SYSCALLS)
     74uint64_t     tm_end = hal_get_cycles();
     75#endif
     76
     77#if DEBUG_SYS_GET_CYCLE
     78if( DEBUG_SYS_GET_CYCLE < tm_end )
     79printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
     80__FUNCTION__ , process->pid, this->trdid, (uint32_t)tm_end );
     81#endif
     82
     83#if CONFIG_INSTRUMENTATION_SYSCALLS
     84hal_atomic_add( &syscalls_cumul_cost[SYS_GET_CYCLE] , tm_end - tm_start );
     85hal_atomic_add( &syscalls_occurences[SYS_GET_CYCLE] , 1 );
     86#endif
    6687
    6788        return 0;

  • trunk/kernel/syscalls/sys_getcwd.c

    r610 r637  
    22 * sys_getcwd.c - kernel function implementing the "getcwd" syscall.
    33 *
    4  * Author    Alain Greiner (2016,2017,2018)
     4 * Author    Alain Greiner (2016,2017,2018,2019)
    55 *
    66 * Copyright (c)  UPMC Sorbonne Universites
    … …  
    9797
    9898    // copy kernel buffer to user space
    99     hal_strcpy_to_uspace( buffer , first , CONFIG_VFS_MAX_PATH_LENGTH );
     99    hal_strcpy_to_uspace( buffer,
     100                          XPTR( local_cxy , first ),
     101                          CONFIG_VFS_MAX_PATH_LENGTH );
    100102
    101103    hal_fence();

  • trunk/kernel/syscalls/sys_is_fg.c

    r635 r637  
    9090
    9191    // copy to user space
    92     hal_copy_to_uspace( local_cxy, &is_txt_owner, is_fg, sizeof(uint32_t) );
     92    hal_copy_to_uspace( is_fg,
     93                        XPTR( local_cxy , &is_txt_owner ),
     94                        sizeof(uint32_t) );
    9395
    9496    hal_fence();

  • trunk/kernel/syscalls/sys_mkdir.c

    r610 r637  
    6060
    6161    // copy pathname in kernel space
    62     hal_strcpy_from_uspace( kbuf , pathname , CONFIG_VFS_MAX_PATH_LENGTH );
     62    hal_strcpy_from_uspace( XPTR( local_cxy , kbuf ),
     63                            pathname,
     64                            CONFIG_VFS_MAX_PATH_LENGTH );
    6365
    6466#if DEBUG_SYS_MKDIR

  • trunk/kernel/syscalls/sys_mkfifo.c

    r566 r637  
    22 * sys_mkfifo.c - creates a named FIFO file.
    33 *
    4  * Author    Alain Greiner (2016,2017)
     4 * Author    Alain Greiner (2016,2017,2018,2019)
    55 *
    66 * Copyright (c) UPMC Sorbonne Universites
    … …  
    3333                 uint32_t  mode __attribute__((unused)) )
    3434{
    35     error_t        error;
    3635    char           kbuf[CONFIG_VFS_MAX_PATH_LENGTH];
    3736
    … …  
    3938    process_t * process = this->process;
    4039
     40#if (DEBUG_SYS_MKFIFO || CONFIG_INSTRUMENTATION_SYSCALLS)
     41uint64_t     tm_start = hal_get_cycles();
     42#endif
     43
     44#if DEBUG_SYS_MKFIFO
     45if( DEBUG_SYS_MKFIFO < tm_end )
     46printk("\n[%s] thread[%x,%x] enter for <%s> / cycle %d\n",
     47__FUNCTION__, process->pid, this->trdid, pathname, (uint32_t)tm_end );
     48#endif
     49 
    4150    // check fd_array not full
    4251    if( process_fd_array_full() )
    4352    {
    44         printk("\n[ERROR] in %s : file descriptor array full for process %x\n",
    45                __FUNCTION__ , process->pid );
     53
     54#if DEBUG_SYSCALLS_ERROR
     55printk("\n[ERROR] in %s : file descriptor array full for process %x\n",
     56__FUNCTION__ , process->pid );
     57#endif
    4658        this->errno = ENFILE;
    4759        return -1;
    … …  
    5163    if( hal_strlen_from_uspace( pathname ) >= CONFIG_VFS_MAX_PATH_LENGTH )
    5264    {
    53         printk("\n[ERROR] in %s : pathname too long\n", __FUNCTION__ );
     65
     66#if DEBUG_SYSCALLS_ERROR
     67printk("\n[ERROR] in %s : pathname too long\n", __FUNCTION__ );
     68#endif
    5469        this->errno = ENFILE;
    5570        return -1;
    … …  
    5772
    5873    // copy pathname in kernel space
    59     hal_strcpy_from_uspace( kbuf , pathname , CONFIG_VFS_MAX_PATH_LENGTH );
     74    hal_strcpy_from_uspace( XPTR( local_cxy , kbuf ),
     75                            pathname,
     76                            CONFIG_VFS_MAX_PATH_LENGTH );
    6077
    6178    printk("\n[ERROR] in %s : not implemented yet\n", __FUNCTION__ );
    6279    return -1;
    6380
    64     if( error )
    65     {
    66         printk("\n[ERROR] in %s : cannot create named FIFO %s\n",
    67                __FUNCTION__ , kbuf );
    68         this->errno = error;
    69         return -1;
    70     }
     81#if (DEBUG_SYS_MKFIFO || CONFIG_INSTRUMENTATION_SYSCALLS)
     82uint64_t     tm_end = hal_get_cycles();
     83#endif
    7184
    72     return 0;
     85#if DEBUG_SYS_MKFIFO
     86if( DEBUG_SYS_MKFIFO < tm_end )
     87printk("\n[%s] thread[%x,%x] exit for <%s> / cycle %d\n",
     88__FUNCTION__, process->pid, this->trdid, pathname, (uint32_t)tm_end );
     89#endif
     90 
     91#if CONFIG_INSTRUMENTATION_SYSCALLS
     92hal_atomic_add( &syscalls_cumul_cost[SYS_MKFIFO] , tm_end - tm_start );
     93hal_atomic_add( &syscalls_occurences[SYS_MKFIFO] , 1 );
     94#endif
    7395
    7496} // end sys_mkfifo()

  • trunk/kernel/syscalls/sys_mmap.c

    r635 r637  
    4141{
    4242    vseg_t      * vseg;
    43     cxy_t         vseg_cxy;
    44     vseg_type_t   vseg_type;
     43    cxy_t         vseg_cxy;     // target cluster for the vseg
     44    vseg_type_t   vseg_type;    // vseg type
    4545    mmap_attr_t   k_attr;       // attributes copy in kernel space
    4646    xptr_t        mapper_xp;
    47     error_t       error;
    4847    reg_t         save_sr;      // required to enable IRQs
    4948
    … …  
    6261
    6362    // check user buffer (containing attributes) is mapped
    64     error = vmm_get_vseg( process , (intptr_t)attr , &vseg );
    65 
    66     if( error )
     63    if( vmm_get_vseg( process , (intptr_t)attr , &vseg ) )
    6764    {
    6865
    … …  
    7673
    7774    // copy attributes from user space to kernel space
    78     hal_copy_from_uspace( local_cxy,
    79                           &k_attr,
     75    hal_copy_from_uspace( XPTR( local_cxy , &k_attr ),
    8076                          attr,
    8177                          sizeof(mmap_attr_t) );
    … …  
    119115
    120116    // test mmap type : can be FILE / ANON / REMOTE
     117    // to define vseg_type & vseg_cxy
    121118
    122119    /////////////////////////////////////////////////////////// MAP_FILE
    … …  
    126123#if (DEBUG_SYS_MMAP & 1)
    127124if ( DEBUG_SYS_MMAP < tm_start )
    128 printk("\n[%s] thread[%x,%x] map file : fdid %d / offset %d / %d bytes\n",
     125printk("\n[%s] thread[%x,%x] type file : fdid %d / offset %x / %x bytes\n",
    129126__FUNCTION__, process->pid, this->trdid, fdid, offset, length );
    130127#endif
    131128
    132             // FIXME: handle concurent delete of file by another thread closing it
     129            // FIXME: handle concurent delete of file by another thread
    133130
    134131                if( fdid >= CONFIG_PROCESS_FILE_MAX_NR )
    … …  
    228225#if (DEBUG_SYS_MMAP & 1)
    229226if ( DEBUG_SYS_MMAP < tm_start )
    230 printk("\n[%s] thread[%x,%x] map anon / %d bytes / cluster %x\n",
     227printk("\n[%s] thread[%x,%x] type anon / %x bytes / cluster %x\n",
    231228__FUNCTION__, process->pid, this->trdid, length, vseg_cxy );
    232229#endif
    … …  
    242239#if (DEBUG_SYS_MMAP & 1)
    243240if ( DEBUG_SYS_MMAP < tm_start )
    244 printk("\n[%s] thread[%x,%x] map remote / %d bytes / cluster %x\n",
     241printk("\n[%s] thread[%x,%x] type remote / %x bytes / target cluster %x\n",
    245242__FUNCTION__, process->pid, this->trdid, length, vseg_cxy );
    246243#endif
    247244 
    248         if( cluster_is_undefined( vseg_cxy ) )
     245        if( cluster_is_active( vseg_cxy ) == false )
    249246        {
    250247
    … …  
    266263    process_t * ref_ptr = GET_PTR( ref_xp );
    267264
    268     // create the vseg in reference cluster
     265    // register vseg in reference VSL
    269266    if( local_cxy == ref_cxy )
    270267    {
    … …  
    306303    }
    307304
    308     // copy vseg base address to user space
    309     hal_copy_to_uspace( local_cxy,
    310                         &vseg->min,
    311                         &attr->addr,
     305    // copy vseg base address to user space mmap_attr_t
     306    hal_copy_to_uspace( &attr->addr,
     307                        XPTR( ref_cxy , &vseg->min ),
    312308                        sizeof(intptr_t) );
    313309    hal_fence();
    … …  
    324320#if DEBUG_SYS_MMAP
    325321if ( DEBUG_SYS_MMAP < tm_end )
    326 printk("\n[%s] thread[%x,%x] exit / %s / cxy %x / base %x / size %d / cycle %d\n",
     322printk("\n[%s] thread[%x,%x] exit / %s / cxy %x / base %x / size %x / cycle %d\n",
    327323__FUNCTION__, process->pid, this->trdid,
    328324vseg_type_str(vseg->type), vseg->cxy, vseg->min, length, (uint32_t)tm_end );

  • trunk/kernel/syscalls/sys_open.c

    r625 r637  
    7777
    7878    // copy pathname in kernel space
    79     hal_strcpy_from_uspace( kbuf , pathname , CONFIG_VFS_MAX_PATH_LENGTH );
     79    hal_strcpy_from_uspace( XPTR( local_cxy , kbuf ) , pathname , CONFIG_VFS_MAX_PATH_LENGTH );
    8080
    8181#if DEBUG_SYS_OPEN

  • trunk/kernel/syscalls/sys_opendir.c

    r635 r637  
    8585
    8686    // copy pathname in kernel space
    87     hal_strcpy_from_uspace( kbuf , pathname , CONFIG_VFS_MAX_PATH_LENGTH );
     87    hal_strcpy_from_uspace( XPTR( local_cxy , kbuf ),
     88                            pathname,
     89                            CONFIG_VFS_MAX_PATH_LENGTH );
    8890
    8991#if DEBUG_SYS_OPENDIR
    … …  
    174176
    175177    // set ident value in user buffer
    176     hal_copy_to_uspace( local_cxy,
    177                         &ident,
    178                         dirp,
     178    hal_copy_to_uspace( dirp,
     179                        XPTR( local_cxy , &ident ),
    179180                        sizeof(intptr_t) );
    180181

  • trunk/kernel/syscalls/sys_place_fork.c

    r623 r637  
    4040    process_t * process = this->process;
    4141
     42#if (DEBUG_SYS_PLACE_FORK || CONFIG_INSTRUMENTATION_SYSCALLS)
     43uint64_t     tm_start = hal_get_cycles();
     44#endif
     45
     46#if DEBUG_SYS_PLACE_FORK
     47if( DEBUG_SYS_PLACE_FORK < tm_start )
     48printk("\n[%s] thread[%x,%x] enter / cxy %x / cycle %d\n",
     49__FUNCTION__, process->pid, this->trdid, cxy, (uint32_t)tm_start );
     50#endif
     51
    4252    // check cxy argument
    43     if( cluster_is_undefined( cxy ) )
     53    if( cluster_is_active( cxy ) == false )
    4454    {
    4555       
    … …  
    5666    this->fork_cxy  = cxy;
    5767
     68#if (DEBUG_SYS_PLACE_FORK || CONFIG_INSTRUMENTATION_SYSCALLS)
     69uint64_t     tm_end = hal_get_cycles();
     70#endif
     71
     72#if DEBUG_SYS_PLACE_FORK
     73if( DEBUG_SYS_PLACE_FORK < tm_end )
     74printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
     75__FUNCTION__ , process->pid, this->trdid, (uint32_t)tm_end );
     76#endif
     77
     78#if CONFIG_INSTRUMENTATION_SYSCALLS
     79hal_atomic_add( &syscalls_cumul_cost[SYS_PLACE_FORK] , tm_end - tm_start );
     80hal_atomic_add( &syscalls_occurences[SYS_PLACE_FORK] , 1 );
     81#endif
     82
    5883        return 0;
    5984

  • trunk/kernel/syscalls/sys_readdir.c

    r635 r637  
    112112
    113113    // copy dirent pointer to user buffer
    114     hal_copy_to_uspace( local_cxy,
    115                         &direntp,
    116                         buffer,
     114    hal_copy_to_uspace( buffer,
     115                        XPTR( local_cxy , &direntp ),
    117116                        sizeof(void *) );
    118117

  • trunk/kernel/syscalls/sys_rename.c

    r613 r637  
    22 * sys_rename.c - Rename a file or a directory.
    33 *
    4  * Author        Alain Greiner (2016,2017,2018)
     4 * Author        Alain Greiner (2016,2017,2018,2019)
    55 *
    66 * Copyright (c) UPMC Sorbonne Universites
    … …  
    7575
    7676    // copy old name an new name in kernel space
    77     hal_strcpy_from_uspace( k_old , old , CONFIG_VFS_MAX_PATH_LENGTH );
    78     hal_strcpy_from_uspace( k_new , new , CONFIG_VFS_MAX_PATH_LENGTH );
     77    hal_strcpy_from_uspace( XPTR( local_cxy , k_old ) , old , CONFIG_VFS_MAX_PATH_LENGTH );
     78    hal_strcpy_from_uspace( XPTR( local_cxy , k_new ) , new , CONFIG_VFS_MAX_PATH_LENGTH );
    7979
    8080#if DEBUG_SYS_RENAME

  • trunk/kernel/syscalls/sys_rmdir.c

    r604 r637  
    22 * sys_rmdir.c - Remove a directory from file system.
    33 *
    4  * Author    Alain Greiner (2016,2017)
     4 * Author    Alain Greiner (2016,2017,2018,2019)
    55 *
    66 * Copyright (c) 2015 UPMC Sorbonne Universites
    … …  
    4242        process_t * process = this->process;
    4343
     44#if (DEBUG_SYS_RMDIR || CONFIG_INSTRUMENTATION_SYSCALLS)
     45uint64_t     tm_start = hal_get_cycles();
     46#endif
     47
    4448    // check pathname length
    4549    if( hal_strlen_from_uspace( pathname ) >= CONFIG_VFS_MAX_PATH_LENGTH )
    … …  
    5458
    5559    // copy pathname in kernel space
    56     hal_strcpy_from_uspace( kbuf , pathname , CONFIG_VFS_MAX_PATH_LENGTH );
     60    hal_strcpy_from_uspace( XPTR( local_cxy , kbuf ),
     61                            pathname,
     62                            CONFIG_VFS_MAX_PATH_LENGTH );
    5763
    5864    // get cluster and local pointer on reference process

  • trunk/kernel/syscalls/sys_sem.c

    r635 r637  
    5858    process_t      * process = this->process;
    5959
     60#if (DEBUG_SYS_SEM || CONFIG_INSTRUMENTATION_SYSCALLS)
     61uint64_t     tm_start = hal_get_cycles();
     62#endif
     63
    6064#if DEBUG_SYS_SEM
    61 uint64_t    tm_start;
    62 uint64_t    tm_end;
    63 tm_start = hal_get_cycles();
    6465if( DEBUG_SYS_SEM < tm_start )
    6566printk("\n[DBG] %s : thread %x in process %x enter for %s / cycle %d\n",
    … …  
    137138 
    138139            // return value to user
    139             hal_copy_to_uspace( local_cxy,
    140                                 &current,
    141                                 current_value,
     140            hal_copy_to_uspace( current_value,
     141                                XPTR( local_cxy , &current ),
    142142                                sizeof(uint32_t) );
    143143        }
    … …  
    224224    hal_fence();
    225225
     226#if (DEBUG_SYS_SEM || CONFIG_INSTRUMENTATION_SYSCALLS)
     227uint64_t     tm_end = hal_get_cycles();
     228#endif
     229
    226230#if DEBUG_SYS_SEM
    227 tm_end = hal_get_cycles();
    228231if( DEBUG_SYS_SEM < tm_end )
    229232printk("\n[DBG] %s : thread %x in process %x exit for %s / cost = %d / cycle %d\n",
    … …  
    232235#endif
    233236
     237#if CONFIG_INSTRUMENTATION_SYSCALLS
     238hal_atomic_add( &syscalls_cumul_cost[SYS_SEM] , tm_end - tm_start );
     239hal_atomic_add( &syscalls_occurences[SYS_SEM] , 1 );
     240#endif
     241
    234242    return 0;
    235243

  • trunk/kernel/syscalls/sys_stat.c

    r635 r637  
    8080
    8181    // copy pathname in kernel space
    82     hal_strcpy_from_uspace( kbuf , pathname , CONFIG_VFS_MAX_PATH_LENGTH );
     82    hal_strcpy_from_uspace( XPTR( local_cxy , kbuf ),
     83                            pathname,
     84                            CONFIG_VFS_MAX_PATH_LENGTH );
    8385
    8486#if DEBUG_SYS_STAT
    … …  
    121123   
    122124    // copy k_stat to u_stat
    123     hal_copy_to_uspace( local_cxy,
    124                         &k_stat,
    125                         u_stat,
     125    hal_copy_to_uspace( u_stat,
     126                        XPTR( local_cxy , &k_stat ),
    126127                        sizeof(struct stat) );
    127128

  • trunk/kernel/syscalls/sys_thread_create.c

    r635 r637  
    6666
    6767#if DEBUG_SYS_THREAD_CREATE
    68 tm_start = hal_get_cycles();
    6968if( DEBUG_SYS_THREAD_CREATE < tm_start )
    7069printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
    … …  
    7372
    7473    // check trdid buffer in user space
    75     error = vmm_get_vseg( process , (intptr_t)trdid_ptr , &vseg );
    76 
    77     if ( error )
     74    if( vmm_get_vseg( process , (intptr_t)trdid_ptr , &vseg ) )
    7875    {
    7976
    … …  
    8986    if( user_attr != NULL )
    9087    {
    91             error = vmm_get_vseg( process , (intptr_t)user_attr , &vseg );
    92 
    93             if( error )
     88            if( vmm_get_vseg( process , (intptr_t)user_attr , &vseg ) )
    9489            {
    9590
    … …  
    10297            }
    10398       
    104             hal_copy_from_uspace( local_cxy,
    105                               &kern_attr,
     99            hal_copy_from_uspace( XPTR( local_cxy , &kern_attr ),
    106100                              user_attr,
    107101                              sizeof(pthread_attr_t) );
    … …  
    109103
    110104        // check start_func in user space
    111         error = vmm_get_vseg( process , (intptr_t)start_func , &vseg );
    112 
    113     if( error )
     105        if( vmm_get_vseg( process , (intptr_t)start_func , &vseg ) )
    114106    {
    115107
    … …  
    125117        if( start_args != NULL )
    126118    {
    127         error = vmm_get_vseg( process , (intptr_t)start_args , &vseg );
    128 
    129             if( error )
     119        if( vmm_get_vseg( process , (intptr_t)start_args , &vseg ) )
    130120            {
    131121
    … …  
    145135            if( kern_attr.attributes & PT_ATTR_CLUSTER_DEFINED )
    146136            {
    147                     if( cluster_is_undefined( kern_attr.cxy ) )
     137                    if( cluster_is_active( kern_attr.cxy ) == false )
    148138                    {
    149139
    … …  
    159149        else
    160150        {
    161             child_cxy = dqdt_get_cluster_for_process();
     151            child_cxy = dqdt_get_cluster_for_thread( LOCAL_CLUSTER->dqdt_root_xp );
    162152        }
    163153        }
    … …  
    165155        {
    166156        kern_attr.attributes = PT_ATTR_DETACH | PT_ATTR_CLUSTER_DEFINED;
    167         child_cxy           = dqdt_get_cluster_for_process();
     157        child_cxy = dqdt_get_cluster_for_thread( LOCAL_CLUSTER->dqdt_root_xp );
    168158        }
    169159
    … …  
    209199        // returns trdid to user space
    210200        trdid = hal_remote_l32( XPTR( child_cxy , &child_ptr->trdid ) );
    211         hal_copy_to_uspace( local_cxy,
    212                         &trdid,
    213                         trdid_ptr,
     201        hal_copy_to_uspace( trdid_ptr,
     202                        XPTR( local_cxy , &trdid ),
    214203                        sizeof(pthread_t) );
    215204

  • trunk/kernel/syscalls/sys_thread_detach.c

    r566 r637  
    22 * sys_thread_detach.c - detach a joinable thread
    33 *
    4  * Authors   Alain Greiner (2016,2017)
     4 * Authors   Alain Greiner (2016,2017,2018,2019)
    55 *
    6  * Copyright (c) 2011,2012 UPMC Sorbonne Universites
     6 * Copyright (c) UPMC Sorbonne Universites
    77 *
    88 * This file is part of ALMOS-MKH.
    … …  
    4848
    4949    // check trdid argument
    50         if( (target_ltid >= CONFIG_THREADS_MAX_PER_CLUSTER) || cluster_is_undefined( target_cxy ) ) 
     50        if( (target_ltid >= CONFIG_THREADS_MAX_PER_CLUSTER) ||
     51        (cluster_is_active( target_cxy ) == false) ) 
    5152        {
    5253        printk("\n[ERROR] in %s : illegal trdid argument\n", __FUNCTION__ );

  • trunk/kernel/syscalls/sys_thread_join.c

    r633 r637  
    22 * sys_thread_join.c - passive wait on the end of a given thread.
    33 *
    4  * Authors    Alain Greiner (2016,2017)
    5  *
    6  * Copyright (c) 2011,2012 UPMC Sorbonne Universites
     4 * Authors    Alain Greiner (2016,2017,2018,2019)
     5 *
     6 * Copyright (c) UPMC Sorbonne Universites
    77 *
    88 * This file is part of ALMOS-MKH.
    … …  
    7272
    7373    // check trdid argument
    74         if( (target_ltid >= CONFIG_THREADS_MAX_PER_CLUSTER) || cluster_is_undefined(target_cxy) )
     74        if( (target_ltid >= CONFIG_THREADS_MAX_PER_CLUSTER) ||
     75        (cluster_is_active(target_cxy) == false) )
    7576        {
    7677

  • trunk/kernel/syscalls/sys_thread_wakeup.c

    r566 r637  
    11/*
    2  * sys_thread_wakeup.c - wakeup all indicated threads
     2 * sys_thread_wakeup.c - wakeup indicated thread
    33 *
    4  * Author    Alain Greiner (2016,2017)
     4 * Author    Alain Greiner (2016,2017,2018,2019)
    55 *
    66 * Copyright (c) UPMC Sorbonne Universites
    … …  
    3636    process_t * process = this->process;
    3737
     38#if (DEBUG_SYS_THREAD_WAKEUP || CONFIG_INSTRUMENTATION_SYSCALLS)
     39uint64_t     tm_start = hal_get_cycles();
     40#endif
     41
    3842#if DEBUG_SYS_THREAD_WAKEUP
    39 uint64_t     tm_start;
    40 uint64_t     tm_end;
    41 tm_start = hal_get_cycles();
    4243if( DEBUG_SYS_THREAD_WAKEUP < tm_start )
    43 printk("\n[DBG] %s : thread %x in process enter to activate thread %x / cycle %d\n",
     44printk("\n[%s] thread %x in process enter to activate thread %x / cycle %d\n",
    4445__FUNCTION__, this->trdid, process->pid, trdid, (uint32_t)tm_start );
    4546#endif
    … …  
    5051
    5152    // check trdid argument
    52         if( (target_ltid >= CONFIG_THREADS_MAX_PER_CLUSTER) || cluster_is_undefined( target_cxy ) ) 
     53        if( (target_ltid >= CONFIG_THREADS_MAX_PER_CLUSTER) ||
     54        (cluster_is_active( target_cxy ) == false) ) 
    5355        {
    5456
    … …  
    7880    thread_unblock( thread_xp , THREAD_BLOCKED_GLOBAL );
    7981
     82#if (DEBUG_SYS_THREAD_WAKEUP || CONFIG_INSTRUMENTATION_SYSCALLS)
     83uint64_t     tm_end = hal_get_cycles();
     84#endif
     85
     86
    8087#if DEBUG_SYS_THREAD_WAKEUP
    81 tm_end = hal_get_cycles();
    8288if( DEBUG_SYS_THREAD_WAKEUP < tm_end )
    83 printk("\n[DBG] %s : thread %x in process %x exit / thread %x activated / cycle %d\n",
     89printk("\n[%s] thread %x in process %x exit / thread %x activated / cycle %d\n",
    8490__FUNCTION__ , this->trdid, process->pid, trdid, (uint32_t)tm_end );
     91#endif
     92
     93#if CONFIG_INSTRUMENTATION_SYSCALLS
     94hal_atomic_add( &syscalls_cumul_cost[SYS_THREAD_WAKEUP] , tm_end - tm_start );
     95hal_atomic_add( &syscalls_occurences[SYS_THREAD_WAKEUP] , 1 );
    8596#endif
    8697

  • trunk/kernel/syscalls/sys_timeofday.c

    r635 r637  
    5050        process_t *    process = this->process;
    5151
     52#if (DEBUG_SYS_TIMEOFDAY || CONFIG_INSTRUMENTATION_SYSCALLS)
     53uint64_t     tm_start = hal_get_cycles();
     54#endif
     55
     56#if DEBUG_SYS_TIMEOFDAY
     57if( DEBUG_SYS_TIMEOFDAY < tm_start )
     58printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
     59__FUNCTION__, process->pid, this->trdid, (uint32_t)tm_start );
     60#endif
     61 
    5262    // check tz (non supported / must be null)
    5363    if( tz )
    … …  
    8292
    8393    // copy values to user space
    84         hal_copy_to_uspace( local_cxy,
    85                         &k_tv,
    86                         tv,
     94        hal_copy_to_uspace( tv,
     95                        XPTR( local_cxy , &k_tv ),
    8796                        sizeof(struct timeval) );
    8897
    8998    hal_fence();
    9099
     100#if (DEBUG_SYS_TIMEOFDAY || CONFIG_INSTRUMENTATION_SYSCALLS)
     101uint64_t     tm_end = hal_get_cycles();
     102#endif
     103
     104#if DEBUG_SYS_TIMEOFDAY
     105if( DEBUG_SYS_TIMEOFDAY < tm_end )
     106printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
     107__FUNCTION__, process->pid, this->trdid, (uint32_t)tm_end );
     108#endif
     109 
     110#if CONFIG_INSTRUMENTATION_SYSCALLS
     111hal_atomic_add( &syscalls_cumul_cost[SYS_TIMEOFDAY] , tm_end - tm_start );
     112hal_atomic_add( &syscalls_occurences[SYS_TIMEOFDAY] , 1 );
     113#endif
     114
    91115        return 0;
    92116

  • trunk/kernel/syscalls/sys_trace.c

    r566 r637  
    22 * sys_trace.c - activate / desactivate the context switches trace for a given core
    33 *
    4  * Author    Alain Greiner (c) (2016,2017,2018)
     4 * Author    Alain Greiner (c) (2016,2017,2018,2019)
    55 *
    66 * Copyright (c) UPMC Sorbonne Universites
    … …  
    4040    process_t * process = this->process;
    4141
     42#if (DEBUG_SYS_TRACE || CONFIG_INSTRUMENTATION_SYSCALLS)
     43uint64_t     tm_start = hal_get_cycles();
     44#endif
     45
    4246#if DEBUG_SYS_TRACE
    43 uint64_t    tm_start;
    44 uint64_t    tm_end;
    45 tm_start = hal_get_cycles();
    4647if( DEBUG_SYS_TRACE < tm_start )
    47 printk("\n[DBG] %s : thread %d enter / process %x / cycle = %d\n",
    48 __FUNCTION__, this, this->process->pid, (uint32_t)tm_start );
     48printk("\n[%s] thread[%x,%x] enters / cycle = %d\n",
     49__FUNCTION__, this->process->pid, this->trdid, (uint32_t)tm_start );
    4950#endif
    5051
    5152    // check cluster identifier
    52     if( cluster_is_undefined( cxy ) )
     53    if( cluster_is_active( cxy ) == false )
    5354    {
    5455
    … …  
    8586    hal_fence();
    8687
    87 #if DEBUG_SYS_TRACE
    88 tm_end = hal_get_cycles();
    89 if( DEBUG_SYS_TRACE < tm_end )
    90 printk("\n[DBG] %s : thread %x exit / process %x / cost = %d / cycle %d\n",
    91 __FUNCTION__, this, this->process->pid, (uint32_t)(tm_end - tm_start) , (uint32_t)tm_end );
     88#if (DEBUG_SYS_TRACE || CONFIG_INSTRUMENTATION_SYSCALLS)
     89uint64_t     tm_end = hal_get_cycles();
    9290#endif
    9391
     92#if DEBUG_SYS_TRACE
     93if( DEBUG_SYS_TRACE < tm_end )
     94printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
     95__FUNCTION__, this->process->pid, this->trdid, (uint32_t)tm_end );
     96#endif
     97
     98#if CONFIG_INSTRUMENTATION_SYSCALLS
     99hal_atomic_add( &syscalls_cumul_cost[SYS_TRACE] , tm_end - tm_start );
     100hal_atomic_add( &syscalls_occurences[SYS_TRACE] , 1 );
     101#endif
    94102    return 0;
    95103

  • trunk/kernel/syscalls/sys_unlink.c

    r610 r637  
    22 * sys_unlink.c - unlink a file or directorya from VFS
    33 *
    4  * Author     Alain Greiner (2016,2017,2018)
     4 * Author     Alain Greiner (2016,2017,2018,2019)
    55 *
    66 * Copyright (c)  UPMC Sorbonne Universites
    … …  
    6060
    6161    // copy pathname in kernel space
    62     hal_strcpy_from_uspace( kbuf , pathname , CONFIG_VFS_MAX_PATH_LENGTH );
     62    hal_strcpy_from_uspace( XPTR( local_cxy , kbuf ),
     63                            pathname,
     64                            CONFIG_VFS_MAX_PATH_LENGTH );
    6365
    6466#if DEBUG_SYS_UNLINK

  • trunk/kernel/syscalls/sys_wait.c

    r635 r637  
    5353    pid_t       pid     = process->pid;
    5454
     55
    5556#if DEBUG_SYS_WAIT
    56 uint64_t    cycle = hal_get_cycles();
     57uint64_t cycle = hal_get_cycles();
    5758if( DEBUG_SYS_WAIT < cycle )
    5859printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
    … …  
    153154#endif
    154155                 // return child termination state  to parent process
    155                  hal_copy_to_uspace( local_cxy,
    156                                      &child_state,
    157                                      status,
     156                 hal_copy_to_uspace( status,
     157                                     XPTR( local_cxy , &child_state ),
    158158                                     sizeof(int) );
    159159                 return child_pid;
    … …  
    192192
    193193    // never executed
    194         return -1;
     194        return 0;
    195195
    196196}  // end sys_wait()

  • trunk/kernel/syscalls/syscalls.h

    r626 r637  
    210210/******************************************************************************************
    211211 * [13] This function map physical memory (or a file) in the calling thread virtual space.
    212  * The <attr> argument is a pointer on a structure for arguments (see shared_syscalls.h).
     212 * The <attr> argument is a pointer on a structure for arguments (see shared_mman.h).
    213213 * The user defined virtual address (MAP_FIXED flag) is not supported.
    214214 * TODO : the access rights checking is not implemented yet [AG]
    … …  
    560560
    561561/******************************************************************************************
    562  * [41] This function implements the non-standard get_core() syscall.
     562 * [41] This function implements the non-standard get_core_id() syscall.
    563563 * It returns in <cxy> and <lid> the calling core cluster and local index.
    564564 ******************************************************************************************
    … …  
    567567 * @ return 0 if success / return -1 if illegal arguments
    568568 *****************************************************************************************/
    569 int sys_get_core( uint32_t * cxy,
    570                   uint32_t * lid );
     569int sys_get_core_id( uint32_t * cxy,
     570                     uint32_t * lid );
    571571
    572572/******************************************************************************************
    … …  
    696696int sys_fsync( uint32_t file_id );
    697697
     698/******************************************************************************************
     699 * [53] This function implements the non-standard "get_best_core" syscall.
     700 * It selects, in a macro-cluster specified by the <base_cxy> and <level> arguments,
     701 * the core that has the lowest load.
     702 * When an active core has been found in the target macro-cluster, it writes into the
     703 * <cxy> and <lid> buffers the cluster identifier and the core local index, and return 0.
     704 * It returns -1 in case of illegal arguments (level / cxy / lid).
     705 * It returns +1 if there is no active core in specified macro-cluster.
     706 ******************************************************************************************
     707 * @ base_cxy : [in]  any cluster identifier in macro-cluster.
     708 * @ level    : [in]  macro-cluster level in [1,2,3,4,5].
     709 * @ cxy      : [out] selected core cluster identifier.
     710 * @ lid      : [out] selected core local index in cluster.
     711 * @ return 0 if success / -1 if illegal arguments / +1 if no core in macro-clusters.
     712 *****************************************************************************************/
     713int sys_get_best_core( uint32_t   base_cxy,
     714                       uint32_t   level,
     715                       uint32_t * cxy,
     716                       uint32_t * lid );
     717
     718/******************************************************************************************
     719 * [54] This function implements the non-standard "get_nb_cores" syscall.
     720 * It writes in the <ncores> buffer the number of cores in the target cluster <cxy>.
     721 ******************************************************************************************
     722 * @ cxy      : [in]  target cluster identifier.
     723 * @ ncores   : [out] number of cores / 0 if cluster cxy undefined in architecture.
     724 * @ return 0 if success / return -1 if illegal "ncores" arguments.
     725 *****************************************************************************************/
     726int sys_get_nb_cores( uint32_t   cxy,
     727                      uint32_t * ncores );
     728
    698729#endif  // _SYSCALLS_H_
Note: See TracChangeset for help on using the changeset viewer.