httpd-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dgau...@hyperreal.org
Subject cvs commit: apache-1.3/src/main alloc.c buff.c
Date Sun, 29 Mar 1998 09:35:45 GMT
dgaudet     98/03/29 01:35:44

  Modified:    src/ap   ap_snprintf.c
               src/include ap.h
               src/main alloc.c buff.c
  Log:
  Revamp the apapi_vformatter interface to reduce copies.  In this interface
  the callers hand apapi_vformatter pointers into their own private buffers,
  and are called back for flushing when appropriate.  This is more efficient
  and seems somewhat more clean.
  
  Revision  Changes    Path
  1.16      +23 -44    apache-1.3/src/ap/ap_snprintf.c
  
  Index: ap_snprintf.c
  ===================================================================
  RCS file: /export/home/cvs/apache-1.3/src/ap/ap_snprintf.c,v
  retrieving revision 1.15
  retrieving revision 1.16
  diff -u -r1.15 -r1.16
  --- ap_snprintf.c	1998/03/28 21:58:38	1.15
  +++ ap_snprintf.c	1998/03/29 09:35:40	1.16
  @@ -266,10 +266,11 @@
   #define INS_CHAR(c, sp, bep, cc)				\
   	    {							\
   		if (sp == bep) {				\
  -		    if (write_func(write_data, staging_buf, 	\
  -			sizeof(staging_buf)) != 0)		\
  +		    vbuff->curpos = sp;                         \
  +		    if (flush_func(vbuff))			\
   			return -1;				\
  -		    sp = staging_buf; 				\
  +		    sp = vbuff->curpos;				\
  +		    bep = vbuff->endpos;			\
   		} 						\
   		*sp++ = (c);					\
   		cc++; 						\
  @@ -503,9 +504,8 @@
   /*
    * Do format conversion placing the output in buffer
    */
  -API_EXPORT(int) apapi_vformatter(
  -    int (*write_func)(void *, const char *, size_t),
  -    void *write_data, const char *fmt, va_list ap)
  +API_EXPORT(int) apapi_vformatter(int (*flush_func)(apapi_vformatter_buff *),
  +    apapi_vformatter_buff *vbuff, const char *fmt, va_list ap)
   {
       register char *sp;
       register char *bep;
  @@ -531,8 +531,6 @@
       char num_buf[NUM_BUF_SIZE];
       char char_buf[2];		/* for printing %% and %<unknown> */
   
  -    char staging_buf[MAX_STRING_LEN];
  -
       /*
        * Flag variables
        */
  @@ -544,8 +542,8 @@
       boolean_e adjust_width;
       bool_int is_negative;
   
  -    sp = staging_buf;
  -    bep = sp + sizeof(staging_buf);
  +    sp = vbuff->curpos;
  +    bep = vbuff->endpos;
   
       while (*fmt) {
   	if (*fmt != '%') {
  @@ -875,33 +873,14 @@
   	}
   	fmt++;
       }
  -    if (sp > staging_buf) {
  -	if (write_func(write_data, staging_buf, sp - staging_buf) != 0) {
  -	    return -1;
  -	}
  -    }
  +    vbuff->curpos = sp;
       return cc;
   }
   
   
  -struct snprintf_write_data {
  -    char *strp;
  -    char *end_buf;
  -};
  -
  -static int snprintf_write(void *vdata, const char *inp, size_t len)
  +static int snprintf_flush(apapi_vformatter_buff *vbuff)
   {
  -    struct snprintf_write_data *wd;
  -    size_t amt;
  -
  -    wd = vdata;
  -    amt = wd->end_buf - wd->strp;
  -    if (len > amt) {
  -	len = amt;
  -    }
  -    memcpy(wd->strp, inp, len);
  -    wd->strp += len;
  -    return 0;
  +    return -1;
   }
   
   
  @@ -909,19 +888,19 @@
   {
       int cc;
       va_list ap;
  -    struct snprintf_write_data wd;
  +    apapi_vformatter_buff vbuff;
   
       if (len == 0)
   	return 0;
   
       /* save one byte for nul terminator */
  -    wd.strp = buf;
  -    wd.end_buf = buf + len - 1;
  +    vbuff.curpos = buf;
  +    vbuff.endpos = buf + len - 1;
       va_start(ap, format);
  -    cc = apapi_vformatter(snprintf_write, &wd, format, ap);
  -    *wd.strp = '\0';
  +    cc = apapi_vformatter(snprintf_flush, &vbuff, format, ap);
       va_end(ap);
  -    return (cc);
  +    *vbuff.curpos = '\0';
  +    return (cc == -1) ? len : cc;
   }
   
   
  @@ -929,15 +908,15 @@
   			     va_list ap)
   {
       int cc;
  -    struct snprintf_write_data wd;
  +    apapi_vformatter_buff vbuff;
   
       if (len == 0)
   	return 0;
   
       /* save one byte for nul terminator */
  -    wd.strp = buf;
  -    wd.end_buf = buf + len - 1;
  -    cc = apapi_vformatter(snprintf_write, &wd, format, ap);
  -    *wd.strp = '\0';
  -    return (cc);
  +    vbuff.curpos = buf;
  +    vbuff.endpos = buf + len - 1;
  +    cc = apapi_vformatter(snprintf_flush, &vbuff, format, ap);
  +    *vbuff.curpos = '\0';
  +    return (cc == -1) ? len : cc;
   }
  
  
  
  1.9       +41 -11    apache-1.3/src/include/ap.h
  
  Index: ap.h
  ===================================================================
  RCS file: /export/home/cvs/apache-1.3/src/include/ap.h,v
  retrieving revision 1.8
  retrieving revision 1.9
  diff -u -r1.8 -r1.9
  --- ap.h	1998/03/28 11:58:17	1.8
  +++ ap.h	1998/03/29 09:35:41	1.9
  @@ -80,21 +80,51 @@
   /* apapi_vformatter() is a generic printf-style formatting routine
    * with some extensions.
    *
  - * The write_func() is called when there is data available to be
  - * output.  write_func() should return 0 when it wishes apapi_vformatter
  - * to continue, and non-zero otherwise.  apapi_vformatter will stop
  - * immediately and return -1 when a non-zero return from
  - * write_func().
  + * The apapi_vformatter_buff has two elements curpos and endpos.
  + * curpos is where apapi_vformatter will write the next byte of output.
  + * It proceeds writing output to curpos, and updating curpos, until
  + * either the end of output is reached, or curpos == endpos (i.e. the
  + * buffer is full).
    *
  - * If write_func() always returns 0 then apapi_vformatter will return
  - * the number of characters written.
  + * If the end of output is reached, apapi_vformatter returns the
  + * number of bytes written.
  + *
  + * When the buffer is full, the flush_func is called.  The flush_func
  + * can return -1 to indicate that no further output should be attempted,
  + * and apapi_vformatter will return immediately with -1.  Otherwise
  + * the flush_func should flush the buffer in whatever manner is
  + * appropriate, re-initialize curpos and endpos, and return 0.
  + *
  + * Note that flush_func is only invoked as a result of attempting to
  + * write another byte at curpos when curpos == endpos.  So for
  + * example, it's possible when the output exactly matches the buffer
  + * space available that curpos == endpos will be true when
  + * apapi_vformatter returns.
    */
   
  -API_EXPORT(int) apapi_vformatter(
  -    int (*write_func)(void *write_data, const char *outp, size_t len),
  -    void *write_data, const char *fmt, va_list ap);
  +typedef struct {
  +    char *curpos;
  +    char *endpos;
  +} apapi_vformatter_buff;
   
  -/* These are snprintf implementations based on apapi_vformatter(). */
  +API_EXPORT(int) apapi_vformatter(int (*flush_func)(apapi_vformatter_buff *),
  +    apapi_vformatter_buff *, const char *fmt, va_list ap);
  +
  +/* These are snprintf implementations based on apapi_vformatter().
  + *
  + * Note that various standards and implementations disagree on the return
  + * value of snprintf, and side-effects due to %n in the formatting string.
  + * ap_snprintf behaves as follows:
  + *
  + * Process the format string until the entire string is exhausted, or
  + * the buffer fills.  If the buffer fills then stop processing immediately
  + * (so no further %n arguments are processed), and return the buffer
  + * length.  In all cases the buffer is NUL terminated.
  + *
  + * In no event does ap_snprintf return a negative number.  It's not possible
  + * to distinguish between an output which was truncated, and an output which
  + * exactly filled the buffer.
  + */
   API_EXPORT(int) ap_snprintf(char *buf, size_t len, const char *format,...)
   			    __attribute__((format(printf,3,4)));
   API_EXPORT(int) ap_vsnprintf(char *buf, size_t len, const char *format,
  
  
  
  1.82      +31 -40    apache-1.3/src/main/alloc.c
  
  Index: alloc.c
  ===================================================================
  RCS file: /export/home/cvs/apache-1.3/src/main/alloc.c,v
  retrieving revision 1.81
  retrieving revision 1.82
  diff -u -r1.81 -r1.82
  --- alloc.c	1998/03/28 21:35:41	1.81
  +++ alloc.c	1998/03/29 09:35:42	1.82
  @@ -779,68 +779,52 @@
    */
   
   struct psprintf_data {
  -    pool *p;
  +    apapi_vformatter_buff vbuff;
   #ifdef ALLOC_USE_MALLOC
       char *base;
  -    size_t len;
   #else
       union block_hdr *blok;
  -    char *strp;
       int got_a_new_block;
   #endif
   };
   
  -static int psprintf_write(void *vdata, const char *inp, size_t len)
  +static int psprintf_flush(apapi_vformatter_buff *vbuff)
   {
  +    struct psprintf_data *ps = (struct psprintf_data *)vbuff;
   #ifdef ALLOC_USE_MALLOC
  -    struct psprintf_data *ps;
       int size;
       char *ptr;
   
  -    ps = vdata;
  -
  -    size = ps->len + len + 1;
  -    ptr = realloc(ps->base, size);
  +    size = ps->vbuff.curpos - ps->base;
  +    ptr = realloc(ps->base, 2*size);
       if (ptr == NULL) {
   	fputs("Ouch!  Out of memory!\n", stderr);
   	exit(1);
       }
       ps->base = ptr;
  -    memcpy(ptr + ps->len, inp, len);
  -    ps->len += len;
  +    ps->vbuff.curpos = ptr + size;
  +    ps->vbuff.endpos = ptr + 2*size - 1;
       return 0;
   #else
  -    struct psprintf_data *ps;
       union block_hdr *blok;
       union block_hdr *nblok;
       size_t cur_len;
       char *strp;
   
  -    ps = vdata;
  -
  -    /* does it fit in the current block? */
       blok = ps->blok;
  -    strp = ps->strp;
  -    if (strp + len + 1 < blok->h.endp) {
  -	memcpy(strp, inp, len);
  -	ps->strp = strp + len;
  -	return 0;
  -    }
  -
  +    strp = ps->vbuff.curpos;
       cur_len = strp - blok->h.first_avail;
   
       /* must try another blok */
       block_alarms();
       (void) acquire_mutex(alloc_mutex);
  -    nblok = new_block((cur_len + len)*2);
  +    nblok = new_block(2 * cur_len);
       (void) release_mutex(alloc_mutex);
       unblock_alarms();
  -    strp = nblok->h.first_avail;
  -    memcpy(strp, blok->h.first_avail, cur_len);
  -    strp += cur_len;
  -    memcpy(strp, inp, len);
  -    strp += len;
  -    ps->strp = strp;
  +    memcpy(nblok->h.first_avail, strp, cur_len);
  +    strp = nblok->h.first_avail + cur_len;
  +    ps->vbuff.curpos = strp;
  +    ps->vbuff.endpos = nblok->h.endp - 1;
   
       /* did we allocate the current blok? if so free it up */
       if (ps->got_a_new_block) {
  @@ -865,16 +849,23 @@
       void *ptr;
   
       block_alarms();
  -    ps.p = p;
  -    ps.base = NULL;
  -    ps.len = CLICK_SZ;	/* need room at beginning for allocation_list */
  -    apapi_vformatter(psprintf_write, &ps, fmt, ap);
  +    ps.base = malloc(512);
  +    if (ps.base == NULL) {
  +	fputs("Ouch!  Out of memory!\n", stderr);
  +	exit(1);
  +    }
  +    /* need room at beginning for allocation_list */
  +    ps.vbuff.curpos = ps.base + CLICK_SZ;
  +    ps.vbuff.endpos = ps.base + 511;
  +    apapi_vformatter(psprintf_flush, &ps.vbuff, fmt, ap);
  +    *ps.vbuff.curpos++ = '\0';
       ptr = ps.base;
  +    /* shrink */
  +    ptr = realloc(ptr, ps.vbuff.curpos - ptr);
       if (ptr == NULL) {
  -	unblock_alarms();
  -	return pstrdup(p, "");
  +	fputs("Ouch!  Out of memory!\n", stderr);
  +	exit(1);
       }
  -    *((char *)ptr + ps.len) = '\0';	/* room was saved for this */
       *(void **)ptr = p->allocation_list;
       p->allocation_list = ptr;
       unblock_alarms();
  @@ -884,14 +875,14 @@
       char *strp;
       int size;
   
  -    ps.p = p;
       ps.blok = p->last;
  -    ps.strp = ps.blok->h.first_avail;
  +    ps.vbuff.curpos = ps.blok->h.first_avail;
  +    ps.vbuff.endpos = ps.blok->h.endp - 1;
       ps.got_a_new_block = 0;
   
  -    apapi_vformatter(psprintf_write, &ps, fmt, ap);
  +    apapi_vformatter(psprintf_flush, &ps.vbuff, fmt, ap);
   
  -    strp = ps.strp;
  +    strp = ps.vbuff.curpos;
       *strp++ = '\0';
   
       size = strp - ps.blok->h.first_avail;
  
  
  
  1.68      +35 -5     apache-1.3/src/main/buff.c
  
  Index: buff.c
  ===================================================================
  RCS file: /export/home/cvs/apache-1.3/src/main/buff.c,v
  retrieving revision 1.67
  retrieving revision 1.68
  diff -u -r1.67 -r1.68
  --- buff.c	1998/03/28 11:58:22	1.67
  +++ buff.c	1998/03/29 09:35:43	1.68
  @@ -1445,11 +1445,24 @@
       fb->error_data = data;
   }
   
  -static int bprintf_write(void *vdata, const char *inp, size_t len)
  +struct bprintf_data {
  +    apapi_vformatter_buff vbuff;
  +    BUFF *fb;
  +};
  +
  +static int bprintf_flush(apapi_vformatter_buff *vbuff)
   {
  -    if (bwrite(vdata, inp, len) != len) {
  -	return -1;
  +    struct bprintf_data *b = (struct bprintf_data *)vbuff;
  +    BUFF *fb = b->fb;
  +
  +    fb->outcnt += b->vbuff.curpos - (char *)&fb->outbase[fb->outcnt];
  +    if (fb->outcnt == fb->bufsiz) {
  +	if (bflush(fb)) {
  +	    return -1;
  +	}
       }
  +    vbuff->curpos = &fb->outbase[fb->outcnt];
  +    vbuff->endpos = &fb->outbase[fb->bufsiz];
       return 0;
   }
   
  @@ -1457,14 +1470,31 @@
   {
       va_list ap;
       int res;
  +    struct bprintf_data b;
   
  +    b.vbuff.curpos = &fb->outbase[fb->outcnt];
  +    b.vbuff.endpos = &fb->outbase[fb->bufsiz];
  +    b.fb = fb;
       va_start(ap, fmt);
  -    res = apapi_vformatter(bprintf_write, fb, fmt, ap);
  +    res = apapi_vformatter(bprintf_flush, &b.vbuff, fmt, ap);
       va_end(ap);
  +    if (res != -1) {
  +	fb->outcnt += b.vbuff.curpos - (char *)&fb->outbase[fb->outcnt];
  +    }
       return res;
   }
   
   API_EXPORT(int) vbprintf(BUFF *fb, const char *fmt, va_list ap)
   {
  -    return apapi_vformatter(bprintf_write, fb, fmt, ap);
  +    struct bprintf_data b;
  +    int res;
  +
  +    b.vbuff.curpos = &fb->outbase[fb->outcnt];
  +    b.vbuff.endpos = &fb->outbase[fb->bufsiz];
  +    b.fb = fb;
  +    res = apapi_vformatter(bprintf_flush, &b.vbuff, fmt, ap);
  +    if (res != -1) {
  +	fb->outcnt += b.vbuff.curpos - (char *)&fb->outbase[fb->outcnt];
  +    }
  +    return res;
   }
  
  
  

Mime
View raw message