Changeset 3776

Show
Ignore:
Timestamp:
10/16/08 12:54:28
Author:
svillar
Message:
  • only write in chunks to sockets
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/ChangeLog

    r3775 r3776  
     12008-10-16  Sergio Villar Senin  <svillar@igalia.com> 
     2 
     3        * libtinymail-camel/camel-lite/camel/camel-file-utils.c: (camel_write) 
     4        only write in chunks when writing to sockets, do not do it when 
     5        writing to a local filesystem. This speeds up writings a lot. 
     6 
    172008-09-23  Rob Taylor  <rob.taylor@codethink.co.uk> 
    28 

  • trunk/libtinymail-camel/camel-lite/camel/camel-file-utils.c

    r3678 r3776  
    570570} 
    571571 
    572  
    573 /** 
    574  * camel_write: 
    575  * @fd: file descriptor 
    576  * @buf: buffer to write 
    577  * @n: number of bytes of @buf to write 
    578  * 
    579  * Cancellable libc write() replacement. 
    580  * 
    581  * Code that intends to be portable to Win32 should call this function 
    582  * only on file descriptors returned from open(), not on sockets. 
    583  * 
    584  * Returns number of bytes written or -1 on fail. On failure, errno will 
    585  * be set appropriately. 
    586  **/ 
    587 ssize_t 
    588 camel_write (int fd, const char *buf, size_t n) 
     572static ssize_t 
     573camel_write_shared (int fd, const char *buf, size_t n, gboolean write_in_chunks) 
    589574{ 
    590575        ssize_t w, written = 0; 
    …… 
    602587        if (cancel_fd == -1) { 
    603588                do { 
    604                         /* Write in chunks of max WRITE_CHUNK_SIZE bytes */ 
    605                         ssize_t actual = MIN (n - written, WRITE_CHUNK_SIZE); 
    606  
    607                         do { 
    608                                 w = write (fd, buf + written, actual /* n - written */); 
    609                         } while (w == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK)); 
     589                        if (write_in_chunks) { 
     590                                /* Write in chunks of max WRITE_CHUNK_SIZE bytes */ 
     591                                ssize_t actual = MIN (n - written, WRITE_CHUNK_SIZE); 
     592                                do { 
     593                                        w = write (fd, buf + written, actual); 
     594                                } while (w == -1 && (errno == EINTR || errno == EAGAIN ||  
     595                                                     errno == EWOULDBLOCK));                     
     596                        } else { 
     597                                do { 
     598                                        w = write (fd, buf + written, n - written); 
     599                                } while (w == -1 && (errno == EINTR || errno == EAGAIN ||  
     600                                                     errno == EWOULDBLOCK));             
     601                        } 
    610602                        if (w > 0) 
    611603                                written += w; 
    …… 
    625617                        struct timeval tv; 
    626618                        int res; 
    627  
    628                         /* Write in chunks of max WRITE_CHUNK_SIZE bytes */ 
    629                         ssize_t actual = MIN (n - written, WRITE_CHUNK_SIZE); 
    630619 
    631620                        FD_ZERO (&rdset); 
    …… 
    646635                                errno = EINTR; 
    647636                        else { 
    648                                 do { 
    649                                         w = write (fd, buf + written, actual /*n - written*/); 
    650                                 } while (w == -1 && errno == EINTR); 
    651  
     637                                if (write_in_chunks) { 
     638                                        /* Write in chunks of max WRITE_CHUNK_SIZE bytes */ 
     639                                        ssize_t actual = MIN (n - written, WRITE_CHUNK_SIZE); 
     640                                        do { 
     641                                                w = write (fd, buf + written, actual); 
     642                                        } while (w == -1 && (errno == EINTR || errno == EAGAIN ||  
     643                                                             errno == EWOULDBLOCK));                     
     644                                } else { 
     645                                        do { 
     646                                                w = write (fd, buf + written, n - written); 
     647                                        } while (w == -1 && (errno == EINTR || errno == EAGAIN ||  
     648                                                             errno == EWOULDBLOCK));     
     649                                } 
    652650                                if (w == -1) { 
    653651                                        if (errno == EAGAIN || errno == EWOULDBLOCK) 
    …… 
    668666 
    669667        return written; 
     668} 
     669 
     670 
     671/** 
     672 * camel_write: 
     673 * @fd: file descriptor 
     674 * @buf: buffer to write 
     675 * @n: number of bytes of @buf to write 
     676 * 
     677 * Cancellable libc write() replacement. 
     678 * 
     679 * Code that intends to be portable to Win32 should call this function 
     680 * only on file descriptors returned from open(), not on sockets. 
     681 * 
     682 * Returns number of bytes written or -1 on fail. On failure, errno will 
     683 * be set appropriately. 
     684 **/ 
     685ssize_t 
     686camel_write (int fd, const char *buf, size_t n) 
     687{ 
     688        camel_write_shared (fd, buf, n, FALSE); 
    670689} 
    671690 
    …… 
    907926{ 
    908927#ifndef G_OS_WIN32 
    909         return camel_write (fd, buf, n); 
     928        return camel_write_shared (fd, buf, n, TRUE); 
    910929#else 
    911930        ssize_t w, written = 0;