Changeset 592


Ignore:
Timestamp:
Jul 8, 2006 7:46:43 PM (18 years ago)
Author:
bennylp
Message:

Attempted to fix epoll for Linux

Location:
pjproject/trunk/pjlib/src
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • pjproject/trunk/pjlib/src/pj/ioqueue_common_abs.c

    r582 r592  
    197197        h->connecting = 0; 
    198198 
    199         ioqueue_remove_from_set(ioqueue, h->fd, WRITEABLE_EVENT); 
    200         ioqueue_remove_from_set(ioqueue, h->fd, EXCEPTION_EVENT); 
     199        ioqueue_remove_from_set(ioqueue, h, WRITEABLE_EVENT); 
     200        ioqueue_remove_from_set(ioqueue, h, EXCEPTION_EVENT); 
    201201 
    202202 
    … …  
    273273 
    274274            if (pj_list_empty(&h->write_list)) 
    275                 ioqueue_remove_from_set(ioqueue, h->fd, WRITEABLE_EVENT); 
     275                ioqueue_remove_from_set(ioqueue, h, WRITEABLE_EVENT); 
    276276 
    277277        } 
    … …  
    326326                /* Clear operation if there's no more data to send. */ 
    327327                if (pj_list_empty(&h->write_list)) 
    328                     ioqueue_remove_from_set(ioqueue, h->fd, WRITEABLE_EVENT); 
     328                    ioqueue_remove_from_set(ioqueue, h, WRITEABLE_EVENT); 
    329329 
    330330            } 
    … …  
    379379        /* Clear bit in fdset if there is no more pending accept */ 
    380380        if (pj_list_empty(&h->accept_list)) 
    381             ioqueue_remove_from_set(ioqueue, h->fd, READABLE_EVENT); 
     381            ioqueue_remove_from_set(ioqueue, h, READABLE_EVENT); 
    382382 
    383383        rc=pj_sock_accept(h->fd, accept_op->accept_fd,  
    … …  
    412412        /* Clear fdset if there is no pending read. */ 
    413413        if (pj_list_empty(&h->read_list)) 
    414             ioqueue_remove_from_set(ioqueue, h->fd, READABLE_EVENT); 
     414            ioqueue_remove_from_set(ioqueue, h, READABLE_EVENT); 
    415415 
    416416        bytes_read = read_op->size; 
    … …  
    519519    h->connecting = 0; 
    520520 
    521     ioqueue_remove_from_set(ioqueue, h->fd, WRITEABLE_EVENT); 
    522     ioqueue_remove_from_set(ioqueue, h->fd, EXCEPTION_EVENT); 
     521    ioqueue_remove_from_set(ioqueue, h, WRITEABLE_EVENT); 
     522    ioqueue_remove_from_set(ioqueue, h, EXCEPTION_EVENT); 
    523523 
    524524    pj_mutex_unlock(h->mutex); 
    … …  
    586586    pj_mutex_lock(key->mutex); 
    587587    pj_list_insert_before(&key->read_list, read_op); 
    588     ioqueue_add_to_set(key->ioqueue, key->fd, READABLE_EVENT); 
     588    ioqueue_add_to_set(key->ioqueue, key, READABLE_EVENT); 
    589589    pj_mutex_unlock(key->mutex); 
    590590 
    … …  
    654654    pj_mutex_lock(key->mutex); 
    655655    pj_list_insert_before(&key->read_list, read_op); 
    656     ioqueue_add_to_set(key->ioqueue, key->fd, READABLE_EVENT); 
     656    ioqueue_add_to_set(key->ioqueue, key, READABLE_EVENT); 
    657657    pj_mutex_unlock(key->mutex); 
    658658 
    … …  
    760760    pj_mutex_lock(key->mutex); 
    761761    pj_list_insert_before(&key->write_list, write_op); 
    762     ioqueue_add_to_set(key->ioqueue, key->fd, WRITEABLE_EVENT); 
     762    ioqueue_add_to_set(key->ioqueue, key, WRITEABLE_EVENT); 
    763763    pj_mutex_unlock(key->mutex); 
    764764 
    … …  
    828828            status = status; 
    829829        } 
     830        PJ_LOG(3,(THIS_FILE, "pending write operation!!")); 
    830831    } 
    831832 
    … …  
    877878    pj_mutex_lock(key->mutex); 
    878879    pj_list_insert_before(&key->write_list, write_op); 
    879     ioqueue_add_to_set(key->ioqueue, key->fd, WRITEABLE_EVENT); 
     880    ioqueue_add_to_set(key->ioqueue, key, WRITEABLE_EVENT); 
    880881    pj_mutex_unlock(key->mutex); 
    881882 
    … …  
    946947    pj_mutex_lock(key->mutex); 
    947948    pj_list_insert_before(&key->accept_list, accept_op); 
    948     ioqueue_add_to_set(key->ioqueue, key->fd, READABLE_EVENT); 
     949    ioqueue_add_to_set(key->ioqueue, key, READABLE_EVENT); 
    949950    pj_mutex_unlock(key->mutex); 
    950951 
    … …  
    982983            pj_mutex_lock(key->mutex); 
    983984            key->connecting = PJ_TRUE; 
    984             ioqueue_add_to_set(key->ioqueue, key->fd, WRITEABLE_EVENT); 
    985             ioqueue_add_to_set(key->ioqueue, key->fd, EXCEPTION_EVENT); 
     985            ioqueue_add_to_set(key->ioqueue, key, WRITEABLE_EVENT); 
     986            ioqueue_add_to_set(key->ioqueue, key, EXCEPTION_EVENT); 
    986987            pj_mutex_unlock(key->mutex); 
    987988            return PJ_EPENDING; 

  • pjproject/trunk/pjlib/src/pj/ioqueue_common_abs.h

    r365 r592  
    129129 
    130130static void ioqueue_add_to_set( pj_ioqueue_t *ioqueue, 
    131                                 pj_sock_t fd, 
     131                                pj_ioqueue_key_t *key, 
    132132                                enum ioqueue_event_type event_type ); 
    133133static void ioqueue_remove_from_set( pj_ioqueue_t *ioqueue, 
    134                                      pj_sock_t fd,  
     134                                     pj_ioqueue_key_t *key,  
    135135                                     enum ioqueue_event_type event_type); 
    136136 

  • pjproject/trunk/pjlib/src/pj/ioqueue_epoll.c

    r590 r592  
    142142#define THIS_FILE   "ioq_epoll" 
    143143 
    144 #define TRACE_(expr) PJ_LOG(3,expr) 
    145 //#define TRACE_(expr) 
     144//#define TRACE_(expr) PJ_LOG(3,expr) 
     145#define TRACE_(expr) 
    146146 
    147147/* 
    … …  
    156156{ 
    157157    DECLARE_COMMON_KEY 
     158}; 
     159 
     160struct queue 
     161{ 
     162    pj_ioqueue_key_t        *key; 
     163    enum ioqueue_event_type  event_type; 
    158164}; 
    159165 
    … …  
    168174    pj_ioqueue_key_t    hlist; 
    169175    int                 epfd; 
     176    struct epoll_event *events; 
     177    struct queue       *queue; 
    170178}; 
    171179 
    … …  
    230238    } 
    231239     
     240    ioqueue->events = pj_pool_calloc(pool, max_fd, sizeof(struct epoll_event)); 
     241    PJ_ASSERT_RETURN(ioqueue->events != NULL, PJ_ENOMEM); 
     242 
     243    ioqueue->queue = pj_pool_calloc(pool, max_fd, sizeof(struct queue)); 
     244    PJ_ASSERT_RETURN(ioqueue->queue != NULL, PJ_ENOMEM); 
     245 
    232246    PJ_LOG(4, ("pjlib", "epoll I/O Queue created (%p)", ioqueue)); 
    233247 
    … …  
    306320 
    307321    /* os_epoll_ctl. */ 
    308     ev.events = EPOLLIN | EPOLLOUT | EPOLLERR; 
     322    ev.events = EPOLLIN | EPOLLERR; 
    309323    ev.epoll_data = (epoll_data_type)key; 
    310324    status = os_epoll_ctl(ioqueue->epfd, EPOLL_CTL_ADD, sock, &ev); 
    … …  
    323337    ++ioqueue->count; 
    324338 
     339    //TRACE_((THIS_FILE, "socket registered, count=%d", ioqueue->count)); 
     340 
    325341on_return: 
    326342    *p_key = key; 
    … …  
    374390 */ 
    375391static void ioqueue_remove_from_set( pj_ioqueue_t *ioqueue, 
    376                                      pj_sock_t fd,  
     392                                     pj_ioqueue_key_t *key,  
    377393                                     enum ioqueue_event_type event_type) 
    378394{ 
     395    if (event_type == WRITEABLE_EVENT) { 
     396        struct epoll_event ev; 
     397 
     398        ev.events = EPOLLIN | EPOLLERR; 
     399        ev.epoll_data = (epoll_data_type)key; 
     400        os_epoll_ctl( ioqueue->epfd, EPOLL_CTL_MOD, key->fd, &ev); 
     401    }    
    379402} 
    380403 
    … …  
    386409 */ 
    387410static void ioqueue_add_to_set( pj_ioqueue_t *ioqueue, 
    388                                 pj_sock_t fd, 
     411                                pj_ioqueue_key_t *key, 
    389412                                enum ioqueue_event_type event_type ) 
    390413{ 
     414    if (event_type == WRITEABLE_EVENT) { 
     415        struct epoll_event ev; 
     416 
     417        ev.events = EPOLLIN | EPOLLOUT | EPOLLERR; 
     418        ev.epoll_data = (epoll_data_type)key; 
     419        os_epoll_ctl( ioqueue->epfd, EPOLL_CTL_MOD, key->fd, &ev); 
     420    }    
    391421} 
    392422 
    … …  
    398428{ 
    399429    int i, count, processed; 
    400     struct epoll_event events[PJ_IOQUEUE_MAX_EVENTS_IN_SINGLE_POLL]; 
    401430    int msec; 
    402     struct queue { 
    403         pj_ioqueue_key_t        *key; 
    404         enum ioqueue_event_type  event_type; 
    405     } queue[PJ_IOQUEUE_MAX_EVENTS_IN_SINGLE_POLL]; 
     431    struct epoll_event *events = ioqueue->events; 
     432    struct queue *queue = ioqueue->queue; 
     433    pj_timestamp t1, t2; 
    406434     
    407435    PJ_CHECK_STACK(); 
    408436 
    409437    msec = timeout ? PJ_TIME_VAL_MSEC(*timeout) : 9000; 
    410      
    411     count = os_epoll_wait( ioqueue->epfd, events, PJ_ARRAY_SIZE(events), msec); 
    412     if (count == 0) 
     438 
     439    TRACE_((THIS_FILE, "start os_epoll_wait, msec=%d", msec)); 
     440    pj_get_timestamp(&t1); 
     441  
     442    count = os_epoll_wait( ioqueue->epfd, events, ioqueue->max, msec); 
     443    if (count == 0) { 
     444        TRACE_((THIS_FILE, "os_epoll_wait timed out")); 
    413445        return count; 
    414     else if (count < 0) 
     446    } 
     447    else if (count < 0) { 
     448        TRACE_((THIS_FILE, "os_epoll_wait error")); 
    415449        return -pj_get_netos_error(); 
     450    } 
     451 
     452    pj_get_timestamp(&t2); 
     453    TRACE_((THIS_FILE, "os_epoll_wait returns %d, time=%d usec", 
     454                       count, pj_elapsed_usec(&t1, &t2))); 
    416455 
    417456    /* Lock ioqueue. */ 
    … …  
    421460        pj_ioqueue_key_t *h = (pj_ioqueue_key_t*)(epoll_data_type) 
    422461                                events[i].epoll_data; 
     462 
     463        TRACE_((THIS_FILE, "event %d: events=%d", i, events[i].events)); 
    423464 
    424465        /* 
    … …  
    487528        pj_thread_sleep(msec); 
    488529    } 
     530 
     531    pj_get_timestamp(&t1); 
     532    TRACE_((THIS_FILE, "ioqueue_poll() returns %d, time=%d usec", 
     533                       processed, pj_elapsed_usec(&t2, &t1))); 
     534 
    489535    return processed; 
    490536} 

  • pjproject/trunk/pjlib/src/pj/ioqueue_select.c

    r433 r592  
    543543 */ 
    544544static void ioqueue_remove_from_set( pj_ioqueue_t *ioqueue, 
    545                                      pj_sock_t fd,  
     545                                     pj_ioqueue_key_t *key,  
    546546                                     enum ioqueue_event_type event_type) 
    547547{ 
    … …  
    549549 
    550550    if (event_type == READABLE_EVENT) 
    551         PJ_FD_CLR((pj_sock_t)fd, &ioqueue->rfdset); 
     551        PJ_FD_CLR((pj_sock_t)key->fd, &ioqueue->rfdset); 
    552552    else if (event_type == WRITEABLE_EVENT) 
    553         PJ_FD_CLR((pj_sock_t)fd, &ioqueue->wfdset); 
     553        PJ_FD_CLR((pj_sock_t)key->fd, &ioqueue->wfdset); 
    554554    else if (event_type == EXCEPTION_EVENT) 
    555         PJ_FD_CLR((pj_sock_t)fd, &ioqueue->xfdset); 
     555        PJ_FD_CLR((pj_sock_t)key->fd, &ioqueue->xfdset); 
    556556    else 
    557557        pj_assert(0); 
    … …  
    567567 */ 
    568568static void ioqueue_add_to_set( pj_ioqueue_t *ioqueue, 
    569                                 pj_sock_t fd, 
     569                                pj_ioqueue_key_t *key, 
    570570                                enum ioqueue_event_type event_type ) 
    571571{ 
    … …  
    573573 
    574574    if (event_type == READABLE_EVENT) 
    575         PJ_FD_SET((pj_sock_t)fd, &ioqueue->rfdset); 
     575        PJ_FD_SET((pj_sock_t)key->fd, &ioqueue->rfdset); 
    576576    else if (event_type == WRITEABLE_EVENT) 
    577         PJ_FD_SET((pj_sock_t)fd, &ioqueue->wfdset); 
     577        PJ_FD_SET((pj_sock_t)key->fd, &ioqueue->wfdset); 
    578578    else if (event_type == EXCEPTION_EVENT) 
    579         PJ_FD_SET((pj_sock_t)fd, &ioqueue->xfdset); 
     579        PJ_FD_SET((pj_sock_t)key->fd, &ioqueue->xfdset); 
    580580    else 
    581581        pj_assert(0); 

  • pjproject/trunk/pjlib/src/pjlib-test/ioq_tcp.c

    r559 r592  
    3939 
    4040#define THIS_FILE           "test_tcp" 
    41 #define PORT                50000 
    4241#define NON_EXISTANT_PORT   50123 
    4342#define LOOP                100 
    … …  
    258257 
    259258    // Bind server socket. 
    260     memset(&addr, 0, sizeof(addr)); 
    261     addr.sin_family = PJ_AF_INET; 
    262     addr.sin_port = pj_htons(PORT); 
    263     if (pj_sock_bind(ssock, &addr, sizeof(addr))) { 
     259    pj_sockaddr_in_init(&addr, 0, 0); 
     260    if ((rc=pj_sock_bind(ssock, &addr, sizeof(addr))) != 0 ) { 
    264261        app_perror("...bind error", rc); 
    265262        status=-10; goto on_error; 
    266263    } 
     264 
     265    // Get server address. 
     266    client_addr_len = sizeof(addr); 
     267    rc = pj_sock_getsockname(ssock, &addr, &client_addr_len); 
     268    if (rc != PJ_SUCCESS) { 
     269        app_perror("...ERROR in pj_sock_getsockname()", rc); 
     270        status=-15; goto on_error; 
     271    } 
     272    addr.sin_addr = pj_inet_addr(pj_cstr(&s, "127.0.0.1")); 
    267273 
    268274    // Create I/O Queue. 
    … …  
    302308        ++pending_op; 
    303309    } 
    304  
    305     // Initialize remote address. 
    306     memset(&addr, 0, sizeof(addr)); 
    307     addr.sin_family = PJ_AF_INET; 
    308     addr.sin_port = pj_htons(PORT); 
    309     addr.sin_addr = pj_inet_addr(pj_cstr(&s, "127.0.0.1")); 
    310310 
    311311    // Client socket connect() 
    … …  
    462462 
    463463    // Initialize remote address. 
    464     memset(&addr, 0, sizeof(addr)); 
    465     addr.sin_family = PJ_AF_INET; 
    466     addr.sin_port = pj_htons(NON_EXISTANT_PORT); 
    467     addr.sin_addr = pj_inet_addr(pj_cstr(&s, "127.0.0.1")); 
     464    pj_sockaddr_in_init(&addr, pj_cstr(&s, "127.0.0.1"), NON_EXISTANT_PORT); 
    468465 
    469466    // Client socket connect() 

  • pjproject/trunk/pjlib/src/pjlib-test/ioq_udp.c

    r590 r592  
    4141#define THIS_FILE           "test_udp" 
    4242#define PORT                51233 
    43 #define LOOP                100 
     43#define LOOP                2 
    4444///#define LOOP             2 
    4545#define BUF_MIN_SIZE        32 
    … …  
    818818    int bufsize, sock_count; 
    819819 
    820     goto pass1; 
     820    //goto pass1; 
    821821 
    822822    PJ_LOG(3, (THIS_FILE, "...compliance test (%s)", pj_ioqueue_name())); 
    … …  
    837837    } 
    838838     
     839    //return 0; 
     840 
    839841    PJ_LOG(4, (THIS_FILE, "...benchmarking different buffer size:")); 
    840842    PJ_LOG(4, (THIS_FILE, "... note: buf=bytes sent, fds=# of fds, " 
    … …  
    848850    PJ_LOG(3, (THIS_FILE, "...=====================================")); 
    849851 
    850     goto pass2; 
     852    //goto pass2; 
    851853 
    852854    for (bufsize=BUF_MIN_SIZE; bufsize <= BUF_MAX_SIZE; bufsize *= 2) { 
    … …  
    860862         sock_count *= 2)  
    861863    { 
    862         PJ_LOG(3,(THIS_FILE, "...testing with %d fds", sock_count)); 
     864        //PJ_LOG(3,(THIS_FILE, "...testing with %d fds", sock_count)); 
    863865        if ((status=bench_test(bufsize, sock_count-2)) != 0) 
    864866            return status; 

  • pjproject/trunk/pjlib/src/pjlib-test/test.h

    r590 r592  
    2525#define GROUP_OS                    0 
    2626#define GROUP_DATA_STRUCTURE        0 
    27 #define GROUP_NETWORK               0 
     27#define GROUP_NETWORK               1 
    2828#define GROUP_FILE                  0 
    2929 
    … …  
    4646#define INCLUDE_SOCK_PERF_TEST      GROUP_NETWORK 
    4747#define INCLUDE_SELECT_TEST         GROUP_NETWORK 
    48 #define INCLUDE_UDP_IOQUEUE_TEST    1   //GROUP_NETWORK 
     48#define INCLUDE_UDP_IOQUEUE_TEST    GROUP_NETWORK 
    4949#define INCLUDE_TCP_IOQUEUE_TEST    GROUP_NETWORK 
    5050#define INCLUDE_IOQUEUE_PERF_TEST   GROUP_NETWORK 
Note: See TracChangeset for help on using the changeset viewer.