Changeset c0442f


Ignore:
Timestamp:
2011-12-23 09:55:52 (2 years ago)
Author:
Poul-Henning Kamp <phk@…>
Branches:
master, 4.0, experimental-ims
Children:
f7ef38
Parents:
4354cd
git-author:
Poul-Henning Kamp <phk@…> (2011-12-23 09:55:52)
git-committer:
Poul-Henning Kamp <phk@…> (2011-12-23 09:55:52)
Message:

Only allocate sp->req where we need it.

It's lifetime is now controlled by the timeout_linger parameter, so that
the waiters won't have to think about it at all.

Location:
bin/varnishd
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • bin/varnishd/cache/cache.h

    r2c90d7 rc0442f  
    923923int SES_Schedule(struct sess *sp); 
    924924void SES_Handle(struct sess *sp, double now); 
     925void SES_GetReq(struct sess *sp); 
     926void SES_ReleaseReq(struct sess *sp); 
    925927 
    926928/* cache_shmlog.c */ 
  • bin/varnishd/cache/cache_center.c

    r4354cd rc0442f  
    3838 * extract the DOT lines and run though dot(1), for instance with the 
    3939 * command: 
    40  *      sed -n '/^DOT/s///p' cache_center.c | dot -Tps > /tmp/_.ps 
     40 *      sed -n '/^DOT/s///p' cache/cache_center.c | dot -Tps > /tmp/_.ps 
    4141 */ 
    4242 
     
    9292DOT     wait -> start [label="got req"] 
    9393DOT     wait -> "SES_Delete()" [label="errors"] 
    94 DOT     wait -> herding [label="timeout"] 
     94DOT     wait -> herding [label="timeout_linger"] 
     95DOT     herding -> wait [label="fd read_ready"] 
    9596DOT } 
    9697 */ 
     
    107108        wrk = sp->wrk; 
    108109        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC); 
     110        if (sp->req == NULL) 
     111                SES_GetReq(sp); 
     112 
    109113        AZ(sp->vcl); 
    110114        AZ(wrk->obj); 
     
    151155                                wrk->stats.sess_herd++; 
    152156                                SES_Charge(sp); 
     157                                SES_ReleaseReq(sp); 
    153158                                WAIT_Enter(sp); 
    154159                                return (1); 
     
    351356DOT     DONE [ 
    352357DOT             shape=hexagon 
    353 DOT             label="Request completed" 
     358DOT             label="cnt_done:\nRequest completed" 
    354359DOT     ] 
    355360DOT     ESI_RESP [ shape=hexagon ] 
    356 DOT     DONE -> start 
     361DOT     DONE -> start [label="full pipeline"] 
    357362DOT     DONE -> wait 
    358363DOT     DONE -> ESI_RESP 
     
    447452                return (0); 
    448453        } 
    449         if (Tlen(sp->htc->rxbuf)) { 
     454        if (Tlen(sp->htc->rxbuf)) 
    450455                wrk->stats.sess_readahead++; 
    451                 sp->step = STP_WAIT; 
    452                 sp->t_req = sp->t_idle; 
    453                 return (0); 
    454         } 
    455         if (cache_param->timeout_linger > 0.) { 
    456                 wrk->stats.sess_linger++; 
    457                 sp->step = STP_WAIT; 
    458                 sp->t_req = sp->t_idle;         // XXX: not quite correct 
    459                 return (0); 
    460         } 
    461         wrk->stats.sess_herd++; 
    462         WAIT_Enter(sp); 
    463         return (1); 
     456        sp->step = STP_WAIT; 
     457        sp->t_req = sp->t_idle; 
     458        return (0); 
    464459} 
    465460 
     
    10241019DOT     first [ 
    10251020DOT             shape=box 
    1026 DOT             label="first\nConfigure data structures" 
     1021DOT             label="cnt_first:\nSockaddr's" 
    10271022DOT     ] 
    10281023DOT } 
     
    15681563/*-------------------------------------------------------------------- 
    15691564 * START 
    1570  * Handle a request, wherever it came from recv/restart. 
     1565 * Handle a request. 
    15711566 * 
    15721567DOT start [ 
    15731568DOT     shape=box 
    1574 DOT     label="Dissect request\nHandle expect" 
     1569DOT     label="cnt_start:\nDissect request\nHandle expect" 
    15751570DOT ] 
    15761571DOT start -> recv [style=bold,color=green] 
     
    15891584        wrk = sp->wrk; 
    15901585        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC); 
     1586        CHECK_OBJ_NOTNULL(sp->req, REQ_MAGIC); 
    15911587        AZ(sp->restarts); 
    15921588        AZ(wrk->obj); 
     
    16851681 
    16861682        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC); 
     1683#if 0 
    16871684        CHECK_OBJ_NOTNULL(sp->req, REQ_MAGIC); 
    16881685        MPL_AssertSane(sp->req); 
     1686#endif 
    16891687        wrk = sp->wrk; 
    16901688        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC); 
     
    17241722        for (done = 0; !done; ) { 
    17251723                assert(sp->wrk == wrk); 
     1724#if 0 
    17261725                CHECK_OBJ_NOTNULL(sp->req, REQ_MAGIC); 
    17271726                MPL_AssertSane(sp->req); 
     1727#endif 
    17281728                /* 
    17291729                 * This is a good place to be paranoid about the various 
  • bin/varnishd/cache/cache_session.c

    r2c90d7 rc0442f  
    219219                return (NULL); 
    220220        sp = &sm->sess; 
    221         sp->req = MPL_Get(pp->mpl_req, NULL); 
    222         AN(sp->req); 
    223         sp->req->magic = REQ_MAGIC; 
    224221        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC); 
    225222        return (sp); 
     
    246243 
    247244/*-------------------------------------------------------------------- 
     245 */ 
     246 
     247static struct sesspool * 
     248ses_getpool(const struct sess *sp) 
     249{ 
     250        struct sessmem *sm; 
     251        struct sesspool *pp; 
     252 
     253        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC); 
     254        sm = sp->mem; 
     255        CHECK_OBJ_NOTNULL(sm, SESSMEM_MAGIC); 
     256        pp = sm->pool; 
     257        CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC); 
     258        return (pp); 
     259} 
     260 
     261/*-------------------------------------------------------------------- 
    248262 * Schedule a session back on a work-thread from its pool 
    249263 */ 
     
    252266SES_Schedule(struct sess *sp) 
    253267{ 
    254         struct sessmem *sm; 
    255         struct sesspool *pp; 
    256  
    257         CHECK_OBJ_NOTNULL(sp, SESS_MAGIC); 
    258  
     268        struct sesspool *pp; 
     269 
     270        pp = ses_getpool(sp); 
    259271        AZ(sp->wrk); 
    260  
    261         sm = sp->mem; 
    262         CHECK_OBJ_NOTNULL(sm, SESSMEM_MAGIC); 
    263  
    264         pp = sm->pool; 
    265         CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC); 
    266272 
    267273        AN(pp->pool); 
     
    331337        struct sesspool *pp; 
    332338 
    333  
    334         CHECK_OBJ_NOTNULL(sp, SESS_MAGIC); 
    335         CHECK_OBJ_NOTNULL(sp->req, REQ_MAGIC); 
    336         MPL_AssertSane(sp->req); 
     339        pp = ses_getpool(sp); 
     340 
    337341        sm = sp->mem; 
    338342        CHECK_OBJ_NOTNULL(sm, SESSMEM_MAGIC); 
    339         pp = sm->pool; 
    340         CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC); 
    341343        wrk = sp->wrk; 
    342344        CHECK_OBJ_ORNULL(wrk, WORKER_MAGIC); 
     
    349351        assert(sp->fd < 0); 
    350352 
     353        if (sp->req != NULL) 
     354                SES_ReleaseReq(sp); 
     355 
    351356        AZ(sp->vcl); 
    352357        if (*sp->addr == '\0') 
     
    362367            b->sess, b->req, b->pipe, b->pass, 
    363368            b->fetch, b->hdrbytes, b->bodybytes); 
    364  
    365         CHECK_OBJ_NOTNULL(sp->req, REQ_MAGIC); 
    366         MPL_AssertSane(sp->req); 
    367         MPL_Free(pp->mpl_req, sp->req); 
    368         sp->req = NULL; 
    369369 
    370370        if (sm->workspace != cache_param->sess_workspace || 
     
    393393 
    394394/*-------------------------------------------------------------------- 
     395 * Alloc/Free/Clean sp->req 
     396 */ 
     397 
     398void 
     399SES_GetReq(struct sess *sp) 
     400{ 
     401        struct sesspool *pp; 
     402 
     403        pp = ses_getpool(sp); 
     404        AZ(sp->req); 
     405        sp->req = MPL_Get(pp->mpl_req, NULL); 
     406        AN(sp->req); 
     407        sp->req->magic = REQ_MAGIC; 
     408} 
     409 
     410void 
     411SES_ReleaseReq(struct sess *sp) 
     412{ 
     413        struct sesspool *pp; 
     414 
     415        pp = ses_getpool(sp); 
     416        CHECK_OBJ_NOTNULL(sp->req, REQ_MAGIC); 
     417        MPL_AssertSane(sp->req); 
     418        MPL_Free(pp->mpl_req, sp->req); 
     419        sp->req = NULL; 
     420} 
     421 
     422/*-------------------------------------------------------------------- 
    395423 * Create and delete pools 
    396424 */ 
    397425 
    398426struct sesspool * 
    399 SES_NewPool(struct pool *pp, unsigned pool_no) 
    400 { 
    401         struct sesspool *sp; 
     427SES_NewPool(struct pool *wp, unsigned pool_no) 
     428{ 
     429        struct sesspool *pp; 
    402430        char nb[8]; 
    403431 
    404         ALLOC_OBJ(sp, SESSPOOL_MAGIC); 
    405         AN(sp); 
    406         sp->pool = pp; 
    407         VTAILQ_INIT(&sp->freelist); 
    408         Lck_New(&sp->mtx, lck_sessmem); 
     432        ALLOC_OBJ(pp, SESSPOOL_MAGIC); 
     433        AN(pp); 
     434        pp->pool = wp; 
     435        VTAILQ_INIT(&pp->freelist); 
     436        Lck_New(&pp->mtx, lck_sessmem); 
    409437        bprintf(nb, "req%u", pool_no); 
    410         sp->req_size = sizeof (struct req); 
    411         sp->mpl_req = MPL_New(nb, &cache_param->req_pool, &sp->req_size); 
    412         return (sp); 
    413 } 
    414  
    415 void 
    416 SES_DeletePool(struct sesspool *sp, struct worker *wrk) 
    417 { 
    418         struct sessmem *sm; 
    419  
    420         CHECK_OBJ_NOTNULL(sp, SESSPOOL_MAGIC); 
     438        pp->req_size = sizeof (struct req); 
     439        pp->mpl_req = MPL_New(nb, &cache_param->req_pool, &pp->req_size); 
     440        return (pp); 
     441} 
     442 
     443void 
     444SES_DeletePool(struct sesspool *pp, struct worker *wrk) 
     445{ 
     446        struct sessmem *sm; 
     447 
     448        CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC); 
    421449        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC); 
    422         Lck_Lock(&sp->mtx); 
    423         while (!VTAILQ_EMPTY(&sp->freelist)) { 
    424                 sm = VTAILQ_FIRST(&sp->freelist); 
     450        Lck_Lock(&pp->mtx); 
     451        while (!VTAILQ_EMPTY(&pp->freelist)) { 
     452                sm = VTAILQ_FIRST(&pp->freelist); 
    425453                CHECK_OBJ_NOTNULL(sm, SESSMEM_MAGIC); 
    426                 VTAILQ_REMOVE(&sp->freelist, sm, list); 
     454                VTAILQ_REMOVE(&pp->freelist, sm, list); 
    427455                FREE_OBJ(sm); 
    428456                wrk->stats.sessmem_free++; 
    429                 sp->nsess--; 
     457                pp->nsess--; 
    430458        } 
    431         AZ(sp->nsess); 
    432         Lck_Unlock(&sp->mtx); 
    433         Lck_Delete(&sp->mtx); 
    434         MPL_Destroy(&sp->mpl_req); 
    435         FREE_OBJ(sp); 
    436 } 
     459        AZ(pp->nsess); 
     460        Lck_Unlock(&pp->mtx); 
     461        Lck_Delete(&pp->mtx); 
     462        MPL_Destroy(&pp->mpl_req); 
     463        FREE_OBJ(pp); 
     464} 
  • bin/varnishd/waiter/cache_waiter.c

    rae3733 rc0442f  
    6969        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC); 
    7070        CHECK_OBJ_NOTNULL(sp->wrk, WORKER_MAGIC); 
     71        AZ(sp->req); 
    7172        AZ(sp->vcl); 
    7273        assert(sp->fd >= 0); 
Note: See TracChangeset for help on using the changeset viewer.