Changeset 1654


Ignore:
Timestamp:
Jan 2, 2008 8:24:10 AM (12 years ago)
Author:
bennylp
Message:

Ticket #437: reduce stack and pool usage on pjnath to make it work better on Symbian

Location:
pjproject/trunk/pjnath
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/pjnath/include/pjnath/config.h

    r1479 r1654  
    256256 
    257257 
     258/** ICE session pool initial size. */ 
     259#ifndef PJNATH_POOL_LEN_ICE_SESS 
     260#   define PJNATH_POOL_LEN_ICE_SESS                 512 
     261#endif 
     262 
     263/** ICE session pool increment size */ 
     264#ifndef PJNATH_POOL_INC_ICE_SESS 
     265#   define PJNATH_POOL_INC_ICE_SESS                 512 
     266#endif 
     267 
     268/** ICE stream transport pool initial size. */ 
     269#ifndef PJNATH_POOL_LEN_ICE_STRANS 
     270#   define PJNATH_POOL_LEN_ICE_STRANS               1000 
     271#endif 
     272 
     273/** ICE stream transport pool increment size */ 
     274#ifndef PJNATH_POOL_INC_ICE_STRANS 
     275#   define PJNATH_POOL_INC_ICE_STRANS               512 
     276#endif 
     277 
     278/** NAT detect pool initial size */ 
     279#ifndef PJNATH_POOL_LEN_NATCK 
     280#   define PJNATH_POOL_LEN_NATCK                    512 
     281#endif 
     282 
     283/** NAT detect pool increment size */ 
     284#ifndef PJNATH_POOL_INC_NATCK 
     285#   define PJNATH_POOL_INC_NATCK                    512 
     286#endif 
     287 
     288/** STUN session pool initial size */ 
     289#ifndef PJNATH_POOL_LEN_STUN_SESS 
     290#   define PJNATH_POOL_LEN_STUN_SESS                1000 
     291#endif 
     292 
     293/** STUN session pool increment size */ 
     294#ifndef PJNATH_POOL_INC_STUN_SESS 
     295#   define PJNATH_POOL_INC_STUN_SESS                1000 
     296#endif 
     297 
     298/** STUN session transmit data pool initial size */ 
     299#ifndef PJNATH_POOL_LEN_STUN_TDATA 
     300#   define PJNATH_POOL_LEN_STUN_TDATA               1000 
     301#endif 
     302 
     303/** STUN session transmit data pool increment size */ 
     304#ifndef PJNATH_POOL_INC_STUN_TDATA 
     305#   define PJNATH_POOL_INC_STUN_TDATA               1000 
     306#endif 
     307 
     308 
    258309/** 
    259310 * @} 
  • pjproject/trunk/pjnath/include/pjnath/ice_session.h

    r1487 r1654  
    2626#include <pjnath/types.h> 
    2727#include <pjnath/stun_session.h> 
     28#include <pjnath/errno.h> 
    2829#include <pj/sock.h> 
    2930#include <pj/timer.h> 
     
    561562    /* Valid list */ 
    562563    pj_ice_sess_checklist valid_list;               /**< Valid list.        */ 
     564     
     565    /* Temporary buffer for misc stuffs to avoid using stack too much */ 
     566    union { 
     567        char txt[128]; 
     568        char errmsg[PJ_ERR_MSG_SIZE]; 
     569    } tmp; 
    563570}; 
    564571 
  • pjproject/trunk/pjnath/src/pjnath/ice_session.c

    r1574 r1654  
    1818 */ 
    1919#include <pjnath/ice_session.h> 
    20 #include <pjnath/errno.h> 
    2120#include <pj/addr_resolv.h> 
    2221#include <pj/array.h> 
     
    262261        name = "ice%p"; 
    263262 
    264     pool = pj_pool_create(stun_cfg->pf, name, 4000, 4000, NULL); 
     263    pool = pj_pool_create(stun_cfg->pf, name, PJNATH_POOL_LEN_ICE_SESS,  
     264                          PJNATH_POOL_INC_ICE_SESS, NULL); 
    265265    ice = PJ_POOL_ZALLOC_T(pool, pj_ice_sess); 
    266266    ice->pool = pool; 
     
    558558    pj_ice_sess_cand *lcand; 
    559559    pj_status_t status = PJ_SUCCESS; 
    560     char tmp[128]; 
    561560 
    562561    PJ_ASSERT_RETURN(ice && comp_id &&  
     
    585584 
    586585 
    587     pj_ansi_strcpy(tmp, pj_inet_ntoa(lcand->addr.ipv4.sin_addr)); 
     586    pj_ansi_strcpy(ice->tmp.txt, pj_inet_ntoa(lcand->addr.ipv4.sin_addr)); 
    588587    LOG4((ice->obj_name,  
    589588         "Candidate %d added: comp_id=%d, type=%s, foundation=%.*s, " 
     
    594593         (int)lcand->foundation.slen, 
    595594         lcand->foundation.ptr, 
    596          tmp,  
     595         ice->tmp.txt,  
    597596         (int)pj_ntohs(lcand->addr.ipv4.sin_port), 
    598597         pj_inet_ntoa(lcand->base_addr.ipv4.sin_addr), 
     
    734733    const pj_ice_sess_cand *lcand = check->lcand; 
    735734    const pj_ice_sess_cand *rcand = check->rcand; 
    736     char laddr[CHECK_NAME_LEN]; 
     735    char laddr[PJ_INET6_ADDRSTRLEN]; 
    737736    int len; 
     737 
     738    PJ_CHECK_STACK(); 
    738739 
    739740    pj_ansi_strcpy(laddr, pj_inet_ntoa(lcand->addr.ipv4.sin_addr)); 
     
    761762} 
    762763 
    763 static void dump_checklist(const char *title, const pj_ice_sess *ice,  
     764static void dump_checklist(const char *title, pj_ice_sess *ice,  
    764765                           const pj_ice_sess_checklist *clist) 
    765766{ 
    766767    unsigned i; 
    767     char buffer[CHECK_NAME_LEN]; 
    768768 
    769769    LOG4((ice->obj_name, "%s", title)); 
     
    771771        const pj_ice_sess_check *c = &clist->checks[i]; 
    772772        LOG4((ice->obj_name, " %s (%s, state=%s)", 
    773              dump_check(buffer, sizeof(buffer), clist, c), 
     773             dump_check(ice->tmp.txt, sizeof(ice->tmp.txt), clist, c), 
    774774             (c->nominated ? "nominated" : "not nominated"),  
    775775             check_state_name[c->state])); 
     
    785785                            pj_status_t err_code) 
    786786{ 
    787     char buf[CHECK_NAME_LEN]; 
    788  
    789787    pj_assert(check->state < PJ_ICE_SESS_CHECK_STATE_SUCCEEDED); 
    790788 
    791789    LOG5((ice->obj_name, "Check %s: state changed from %s to %s", 
    792          dump_check(buf, sizeof(buf), &ice->clist, check), 
     790         dump_check(ice->tmp.txt, sizeof(ice->tmp.txt), &ice->clist, check), 
    793791         check_state_name[check->state], 
    794792         check_state_name[st])); 
     
    938936            if (reason != NULL) { 
    939937                /* Found duplicate, remove it */ 
    940                 char buf[CHECK_NAME_LEN]; 
    941  
    942938                LOG5((ice->obj_name, "Check %s pruned (%s)", 
    943                       dump_check(buf, sizeof(buf), &ice->clist,  
    944                                 &clist->checks[j]), 
     939                      dump_check(ice->tmp.txt, sizeof(ice->tmp.txt),  
     940                                 &ice->clist, &clist->checks[j]), 
    945941                      reason)); 
    946942 
     
    976972{ 
    977973    if (!ice->is_complete) { 
    978         char errmsg[PJ_ERR_MSG_SIZE]; 
    979  
    980974        ice->is_complete = PJ_TRUE; 
    981975        ice->ice_status = status; 
     
    983977        /* Log message */ 
    984978        LOG4((ice->obj_name, "ICE process complete, status=%s",  
    985              pj_strerror(status, errmsg, sizeof(errmsg)).ptr)); 
     979             pj_strerror(status, ice->tmp.errmsg,  
     980                         sizeof(ice->tmp.errmsg)).ptr)); 
    986981 
    987982        dump_checklist("Valid list", ice, &ice->valid_list); 
     
    10571052    if (check->err_code==PJ_SUCCESS && check->nominated) { 
    10581053        pj_ice_sess_comp *comp; 
    1059         char buf[CHECK_NAME_LEN]; 
    10601054 
    10611055        LOG5((ice->obj_name, "Check %d is successful and nominated", 
     
    10751069                    LOG5((ice->obj_name,  
    10761070                         "Check %s to be failed because state is %s", 
    1077                          dump_check(buf, sizeof(buf), &ice->clist, c),  
     1071                         dump_check(ice->tmp.txt, sizeof(ice->tmp.txt),  
     1072                                    &ice->clist, c),  
    10781073                         check_state_name[c->state])); 
    10791074                    check_set_state(ice, c, PJ_ICE_SESS_CHECK_STATE_FAILED, 
     
    10881083                        LOG5((ice->obj_name,  
    10891084                             "Cancelling check %s (In Progress)", 
    1090                              dump_check(buf, sizeof(buf), &ice->clist, c))); 
     1085                             dump_check(ice->tmp.txt, sizeof(ice->tmp.txt),  
     1086                                        &ice->clist, c))); 
    10911087                        pj_stun_session_cancel_req(comp->stun_sess,  
    10921088                                                   c->tdata, PJ_FALSE, 0); 
     
    13691365    const pj_ice_sess_cand *rcand; 
    13701366    pj_uint32_t prio; 
    1371     char buffer[128]; 
    13721367    pj_status_t status; 
    13731368 
     
    13791374    LOG5((ice->obj_name,  
    13801375         "Sending connectivity check for check %s",  
    1381          dump_check(buffer, sizeof(buffer), clist, check))); 
     1376         dump_check(ice->tmp.txt, sizeof(ice->tmp.txt), clist, check))); 
    13821377 
    13831378    /* Create request */ 
     
    15541549    pj_ice_sess_checklist *clist; 
    15551550    const pj_ice_sess_cand *cand0; 
    1556     const pj_str_t *flist[PJ_ICE_MAX_CAND]; 
     1551    const pj_str_t *flist[PJ_ICE_MAX_CAND]; // XXX 
    15571552    pj_ice_rx_check *rcheck; 
    15581553    unsigned i, flist_cnt = 0; 
     1554    pj_time_val delay; 
     1555    pj_status_t status; 
    15591556 
    15601557    PJ_ASSERT_RETURN(ice, PJ_EINVAL); 
     
    16251622 
    16261623    /* Start periodic check */ 
    1627     return start_periodic_check(ice->stun_cfg.timer_heap, &clist->timer); 
     1624    /* We could start it immediately like below, but lets schedule timer  
     1625     * instead to reduce stack usage: 
     1626     * return start_periodic_check(ice->stun_cfg.timer_heap, &clist->timer); 
     1627     */ 
     1628    clist->timer.id = PJ_TRUE; 
     1629    delay.sec = delay.msec = 0; 
     1630    status = pj_timer_heap_schedule(ice->stun_cfg.timer_heap,  
     1631                                    &clist->timer, &delay); 
     1632    if (status != PJ_SUCCESS) { 
     1633        clist->timer.id = PJ_FALSE; 
     1634    } 
     1635 
     1636    return status; 
    16281637} 
    16291638 
     
    16621671    pj_ice_sess_checklist *clist; 
    16631672    pj_stun_xor_mapped_addr_attr *xaddr; 
    1664     char buffer[CHECK_NAME_LEN]; 
    16651673    unsigned i; 
    16661674 
     
    17311739        LOG4((ice->obj_name,  
    17321740             "Check %s%s: connectivity check FAILED: %s", 
    1733              dump_check(buffer, sizeof(buffer), &ice->clist, check), 
     1741             dump_check(ice->tmp.txt, sizeof(ice->tmp.txt),  
     1742                        &ice->clist, check), 
    17341743             (check->nominated ? " (nominated)" : " (not nominated)"), 
    17351744             errmsg)); 
     
    17541763        LOG4((ice->obj_name,  
    17551764             "Check %s%s: connectivity check FAILED: source address mismatch", 
    1756              dump_check(buffer, sizeof(buffer), &ice->clist, check), 
     1765             dump_check(ice->tmp.txt, sizeof(ice->tmp.txt),  
     1766                        &ice->clist, check), 
    17571767             (check->nominated ? " (nominated)" : " (not nominated)"))); 
    17581768        check_set_state(ice, check, PJ_ICE_SESS_CHECK_STATE_FAILED, status); 
     
    17801790    LOG4((ice->obj_name,  
    17811791         "Check %s%s: connectivity check SUCCESS", 
    1782          dump_check(buffer, sizeof(buffer), &ice->clist, check), 
     1792         dump_check(ice->tmp.txt, sizeof(ice->tmp.txt),  
     1793                    &ice->clist, check), 
    17831794         (check->nominated ? " (nominated)" : " (not nominated)"))); 
    17841795 
     
    23582369                                           NULL, src_addr, src_addr_len); 
    23592370        if (status != PJ_SUCCESS) { 
    2360             char errmsg[PJ_ERR_MSG_SIZE]; 
    2361             pj_strerror(status, errmsg, sizeof(errmsg)); 
     2371            pj_strerror(status, ice->tmp.errmsg, sizeof(ice->tmp.errmsg)); 
    23622372            LOG4((ice->obj_name, "Error processing incoming message: %s", 
    2363                   errmsg)); 
     2373                  ice->tmp.errmsg)); 
    23642374        } 
    23652375    } else { 
  • pjproject/trunk/pjnath/src/pjnath/ice_strans.c

    r1604 r1654  
    9898        name = "icstr%p"; 
    9999 
    100     pool = pj_pool_create(stun_cfg->pf, name, 1000, 512, NULL); 
     100    pool = pj_pool_create(stun_cfg->pf, name, PJNATH_POOL_LEN_ICE_STRANS,  
     101                          PJNATH_POOL_INC_ICE_STRANS, NULL); 
    101102    ice_st = PJ_POOL_ZALLOC_T(pool, pj_ice_strans); 
    102103    ice_st->pool = pool; 
  • pjproject/trunk/pjnath/src/pjnath/nat_detect.c

    r1546 r1654  
    221221     * Init NAT detection session. 
    222222     */ 
    223     pool = pj_pool_create(stun_cfg->pf, "natck%p", 512, 512, NULL); 
     223    pool = pj_pool_create(stun_cfg->pf, "natck%p", PJNATH_POOL_LEN_NATCK,  
     224                          PJNATH_POOL_INC_NATCK, NULL); 
    224225    if (!pool) 
    225226        return PJ_ENOMEM; 
  • pjproject/trunk/pjnath/src/pjnath/stun_msg.c

    r1479 r1654  
    708708    pj_uint32_t val; 
    709709 
     710    PJ_CHECK_STACK(); 
     711     
    710712    /* Create the attribute */ 
    711713    attr = PJ_POOL_ZALLOC_T(pool, pj_stun_sockaddr_attr); 
     
    772774        return PJ_ETOOSMALL; 
    773775 
     776    PJ_CHECK_STACK(); 
     777     
    774778    /* Copy and convert headers to network byte order */ 
    775779    PUTVAL16H(buf, 0, ca->hdr.type); 
     
    900904        (const pj_stun_string_attr*)a; 
    901905 
     906    PJ_CHECK_STACK(); 
     907     
    902908    /* Calculated total attr_len (add padding if necessary) */ 
    903909    *printed = (ca->value.slen + ATTR_HDR_LEN + 3) & (~3); 
     
    10811087    const pj_stun_uint_attr *ca = (const pj_stun_uint_attr*)a; 
    10821088 
     1089    PJ_CHECK_STACK(); 
     1090     
    10831091    if (len < 8)  
    10841092        return PJ_ETOOSMALL; 
     
    11641172    const pj_stun_uint64_attr *ca = (const pj_stun_uint64_attr*)a; 
    11651173 
     1174    PJ_CHECK_STACK(); 
     1175     
    11661176    if (len < 12)  
    11671177        return PJ_ETOOSMALL; 
     
    12431253    const pj_stun_msgint_attr *ca = (const pj_stun_msgint_attr*)a; 
    12441254 
     1255    PJ_CHECK_STACK(); 
     1256     
    12451257    if (len < 24)  
    12461258        return PJ_ETOOSMALL; 
     
    13471359        (const pj_stun_errcode_attr*)a; 
    13481360 
     1361    PJ_CHECK_STACK(); 
     1362     
    13491363    if (len < ATTR_HDR_LEN + 4 + (unsigned)ca->reason.slen)  
    13501364        return PJ_ETOOSMALL; 
     
    14621476    unsigned i; 
    14631477 
     1478    PJ_CHECK_STACK(); 
     1479     
    14641480    /* Check that buffer is enough */ 
    14651481    if (len < ATTR_HDR_LEN + (ca->attr_count << 1)) 
     
    15621578    const pj_stun_binary_attr *ca = (const pj_stun_binary_attr*)a; 
    15631579 
     1580    PJ_CHECK_STACK(); 
     1581     
    15641582    /* Calculated total attr_len (add padding if necessary) */ 
    15651583    *printed = (ca->length + ATTR_HDR_LEN + 3) & (~3); 
  • pjproject/trunk/pjnath/src/pjnath/stun_msg_dump.c

    r1450 r1654  
    2020#include <pjnath/errno.h> 
    2121#include <pj/assert.h> 
     22#include <pj/os.h> 
    2223#include <pj/string.h> 
    23  
    2424 
    2525#if PJ_LOG_MAX_LEVEL > 0 
     
    237237    PJ_ASSERT_RETURN(msg && buffer && length, NULL); 
    238238 
     239    PJ_CHECK_STACK(); 
     240     
    239241    p = buffer; 
    240242    end = buffer + length; 
  • pjproject/trunk/pjnath/src/pjnath/stun_session.c

    r1544 r1654  
    4646#define LOG_ERR_(sess,title,rc) pjnath_perror(sess->pool->obj_name,title,rc) 
    4747 
    48 #define TDATA_POOL_SIZE             1024 
    49 #define TDATA_POOL_INC              1024 
     48#define TDATA_POOL_SIZE             PJNATH_POOL_LEN_STUN_TDATA 
     49#define TDATA_POOL_INC              PJNATH_POOL_INC_STUN_TDATA 
    5050 
    5151 
     
    384384 
    385385    if (name==NULL) 
    386         name = "sess%p"; 
    387  
    388     pool = pj_pool_create(cfg->pf, name, 4000, 4000, NULL); 
     386        name = "stuse%p"; 
     387 
     388    pool = pj_pool_create(cfg->pf, name, PJNATH_POOL_LEN_STUN_SESS,  
     389                          PJNATH_POOL_INC_STUN_SESS, NULL); 
    389390    PJ_ASSERT_RETURN(pool, PJ_ENOMEM); 
    390391 
     
    996997    PJ_ASSERT_RETURN(sess && packet && pkt_size, PJ_EINVAL); 
    997998 
    998     tmp_pool = pj_pool_create(sess->cfg->pf, "tmpstun", 1024, 1024, NULL); 
     999    tmp_pool = pj_pool_create(sess->cfg->pf, "tmpstun",  
     1000                              PJNATH_POOL_LEN_STUN_TDATA,  
     1001                              PJNATH_POOL_INC_STUN_TDATA, NULL); 
    9991002    if (!tmp_pool) 
    10001003        return PJ_ENOMEM; 
Note: See TracChangeset for help on using the changeset viewer.