mirror of
https://github.com/git/git.git
synced 2024-05-05 23:27:01 +02:00
Shrink the git binary a bit by avoiding unnecessary inline functions
So I was looking at the disgusting size of the git binary, and even with the debugging removed, and using -Os instead of -O2, the size of the text section was pretty high. In this day and age I guess almost a megabyte of text isn't really all that surprising, but it still doesn't exactly make me think "lean and mean". With -Os, a surprising amount of text space is wasted on inline functions that end up just being replicated multiple times, and where performance really isn't a valid reason to inline them. In particular, the trivial wrapper functions like "xmalloc()" are used _everywhere_, and making them inline just duplicates the text (and the string we use to 'die()' on failure) unnecessarily. So this just moves them into a "wrapper.c" file, getting rid of a tiny bit of unnecessary bloat. The following numbers are both with "CFLAGS=-Os": Before: [torvalds@woody git]$ size git text data bss dec hex filename 700460 15160 292184 1007804 f60bc git After: [torvalds@woody git]$ size git text data bss dec hex filename 670540 15160 292184 977884 eebdc git so it saves almost 30k of text-space (it actually saves more than that with the default -O2, but I don't think that's necessarily a very relevant number from a "try to shrink git" standpoint). It might conceivably have a performance impact, but none of this should be _that_ performance critical. The real cost is not generally in the wrapper anyway, but in the code it wraps (ie the cost of "xread()" is all in the read itself, not in the trivial wrapping of it). Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Linus Torvalds
Junio C Hamano
parent
0bd64f82ba
commit
112db553b0
1
Makefile
1
Makefile
|
|
@ -467,6 +467,7 @@ LIB_OBJS += unpack-trees.o
|
|||
LIB_OBJS += usage.o
|
||||
LIB_OBJS += utf8.o
|
||||
LIB_OBJS += walker.o
|
||||
LIB_OBJS += wrapper.o
|
||||
LIB_OBJS += write_or_die.o
|
||||
LIB_OBJS += ws.o
|
||||
LIB_OBJS += wt-status.o
|
||||
|
|
|
|||
|
|
@ -240,161 +240,18 @@ static inline char *gitstrchrnul(const char *s, int c)
|
|||
|
||||
extern void release_pack_memory(size_t, int);
|
||||
|
||||
static inline char* xstrdup(const char *str)
|
||||
{
|
||||
char *ret = strdup(str);
|
||||
if (!ret) {
|
||||
release_pack_memory(strlen(str) + 1, -1);
|
||||
ret = strdup(str);
|
||||
if (!ret)
|
||||
die("Out of memory, strdup failed");
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline void *xmalloc(size_t size)
|
||||
{
|
||||
void *ret = malloc(size);
|
||||
if (!ret && !size)
|
||||
ret = malloc(1);
|
||||
if (!ret) {
|
||||
release_pack_memory(size, -1);
|
||||
ret = malloc(size);
|
||||
if (!ret && !size)
|
||||
ret = malloc(1);
|
||||
if (!ret)
|
||||
die("Out of memory, malloc failed");
|
||||
}
|
||||
#ifdef XMALLOC_POISON
|
||||
memset(ret, 0xA5, size);
|
||||
#endif
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* xmemdupz() allocates (len + 1) bytes of memory, duplicates "len" bytes of
|
||||
* "data" to the allocated memory, zero terminates the allocated memory,
|
||||
* and returns a pointer to the allocated memory. If the allocation fails,
|
||||
* the program dies.
|
||||
*/
|
||||
static inline void *xmemdupz(const void *data, size_t len)
|
||||
{
|
||||
char *p = xmalloc(len + 1);
|
||||
memcpy(p, data, len);
|
||||
p[len] = '\0';
|
||||
return p;
|
||||
}
|
||||
|
||||
static inline char *xstrndup(const char *str, size_t len)
|
||||
{
|
||||
char *p = memchr(str, '\0', len);
|
||||
return xmemdupz(str, p ? p - str : len);
|
||||
}
|
||||
|
||||
static inline void *xrealloc(void *ptr, size_t size)
|
||||
{
|
||||
void *ret = realloc(ptr, size);
|
||||
if (!ret && !size)
|
||||
ret = realloc(ptr, 1);
|
||||
if (!ret) {
|
||||
release_pack_memory(size, -1);
|
||||
ret = realloc(ptr, size);
|
||||
if (!ret && !size)
|
||||
ret = realloc(ptr, 1);
|
||||
if (!ret)
|
||||
die("Out of memory, realloc failed");
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline void *xcalloc(size_t nmemb, size_t size)
|
||||
{
|
||||
void *ret = calloc(nmemb, size);
|
||||
if (!ret && (!nmemb || !size))
|
||||
ret = calloc(1, 1);
|
||||
if (!ret) {
|
||||
release_pack_memory(nmemb * size, -1);
|
||||
ret = calloc(nmemb, size);
|
||||
if (!ret && (!nmemb || !size))
|
||||
ret = calloc(1, 1);
|
||||
if (!ret)
|
||||
die("Out of memory, calloc failed");
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline void *xmmap(void *start, size_t length,
|
||||
int prot, int flags, int fd, off_t offset)
|
||||
{
|
||||
void *ret = mmap(start, length, prot, flags, fd, offset);
|
||||
if (ret == MAP_FAILED) {
|
||||
if (!length)
|
||||
return NULL;
|
||||
release_pack_memory(length, fd);
|
||||
ret = mmap(start, length, prot, flags, fd, offset);
|
||||
if (ret == MAP_FAILED)
|
||||
die("Out of memory? mmap failed: %s", strerror(errno));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* xread() is the same a read(), but it automatically restarts read()
|
||||
* operations with a recoverable error (EAGAIN and EINTR). xread()
|
||||
* DOES NOT GUARANTEE that "len" bytes is read even if the data is available.
|
||||
*/
|
||||
static inline ssize_t xread(int fd, void *buf, size_t len)
|
||||
{
|
||||
ssize_t nr;
|
||||
while (1) {
|
||||
nr = read(fd, buf, len);
|
||||
if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
|
||||
continue;
|
||||
return nr;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* xwrite() is the same a write(), but it automatically restarts write()
|
||||
* operations with a recoverable error (EAGAIN and EINTR). xwrite() DOES NOT
|
||||
* GUARANTEE that "len" bytes is written even if the operation is successful.
|
||||
*/
|
||||
static inline ssize_t xwrite(int fd, const void *buf, size_t len)
|
||||
{
|
||||
ssize_t nr;
|
||||
while (1) {
|
||||
nr = write(fd, buf, len);
|
||||
if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
|
||||
continue;
|
||||
return nr;
|
||||
}
|
||||
}
|
||||
|
||||
static inline int xdup(int fd)
|
||||
{
|
||||
int ret = dup(fd);
|
||||
if (ret < 0)
|
||||
die("dup failed: %s", strerror(errno));
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline FILE *xfdopen(int fd, const char *mode)
|
||||
{
|
||||
FILE *stream = fdopen(fd, mode);
|
||||
if (stream == NULL)
|
||||
die("Out of memory? fdopen failed: %s", strerror(errno));
|
||||
return stream;
|
||||
}
|
||||
|
||||
static inline int xmkstemp(char *template)
|
||||
{
|
||||
int fd;
|
||||
|
||||
fd = mkstemp(template);
|
||||
if (fd < 0)
|
||||
die("Unable to create temporary file: %s", strerror(errno));
|
||||
return fd;
|
||||
}
|
||||
extern char *xstrdup(const char *str);
|
||||
extern void *xmalloc(size_t size);
|
||||
extern void *xmemdupz(const void *data, size_t len);
|
||||
extern char *xstrndup(const char *str, size_t len);
|
||||
extern void *xrealloc(void *ptr, size_t size);
|
||||
extern void *xcalloc(size_t nmemb, size_t size);
|
||||
extern void *xmmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);
|
||||
extern ssize_t xread(int fd, void *buf, size_t len);
|
||||
extern ssize_t xwrite(int fd, const void *buf, size_t len);
|
||||
extern int xdup(int fd);
|
||||
extern FILE *xfdopen(int fd, const char *mode);
|
||||
extern int xmkstemp(char *template);
|
||||
|
||||
static inline size_t xsize_t(off_t len)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -0,0 +1,160 @@
|
|||
/*
|
||||
* Various trivial helper wrappers around standard functions
|
||||
*/
|
||||
#include "cache.h"
|
||||
|
||||
char *xstrdup(const char *str)
|
||||
{
|
||||
char *ret = strdup(str);
|
||||
if (!ret) {
|
||||
release_pack_memory(strlen(str) + 1, -1);
|
||||
ret = strdup(str);
|
||||
if (!ret)
|
||||
die("Out of memory, strdup failed");
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void *xmalloc(size_t size)
|
||||
{
|
||||
void *ret = malloc(size);
|
||||
if (!ret && !size)
|
||||
ret = malloc(1);
|
||||
if (!ret) {
|
||||
release_pack_memory(size, -1);
|
||||
ret = malloc(size);
|
||||
if (!ret && !size)
|
||||
ret = malloc(1);
|
||||
if (!ret)
|
||||
die("Out of memory, malloc failed");
|
||||
}
|
||||
#ifdef XMALLOC_POISON
|
||||
memset(ret, 0xA5, size);
|
||||
#endif
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* xmemdupz() allocates (len + 1) bytes of memory, duplicates "len" bytes of
|
||||
* "data" to the allocated memory, zero terminates the allocated memory,
|
||||
* and returns a pointer to the allocated memory. If the allocation fails,
|
||||
* the program dies.
|
||||
*/
|
||||
void *xmemdupz(const void *data, size_t len)
|
||||
{
|
||||
char *p = xmalloc(len + 1);
|
||||
memcpy(p, data, len);
|
||||
p[len] = '\0';
|
||||
return p;
|
||||
}
|
||||
|
||||
char *xstrndup(const char *str, size_t len)
|
||||
{
|
||||
char *p = memchr(str, '\0', len);
|
||||
return xmemdupz(str, p ? p - str : len);
|
||||
}
|
||||
|
||||
void *xrealloc(void *ptr, size_t size)
|
||||
{
|
||||
void *ret = realloc(ptr, size);
|
||||
if (!ret && !size)
|
||||
ret = realloc(ptr, 1);
|
||||
if (!ret) {
|
||||
release_pack_memory(size, -1);
|
||||
ret = realloc(ptr, size);
|
||||
if (!ret && !size)
|
||||
ret = realloc(ptr, 1);
|
||||
if (!ret)
|
||||
die("Out of memory, realloc failed");
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void *xcalloc(size_t nmemb, size_t size)
|
||||
{
|
||||
void *ret = calloc(nmemb, size);
|
||||
if (!ret && (!nmemb || !size))
|
||||
ret = calloc(1, 1);
|
||||
if (!ret) {
|
||||
release_pack_memory(nmemb * size, -1);
|
||||
ret = calloc(nmemb, size);
|
||||
if (!ret && (!nmemb || !size))
|
||||
ret = calloc(1, 1);
|
||||
if (!ret)
|
||||
die("Out of memory, calloc failed");
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void *xmmap(void *start, size_t length,
|
||||
int prot, int flags, int fd, off_t offset)
|
||||
{
|
||||
void *ret = mmap(start, length, prot, flags, fd, offset);
|
||||
if (ret == MAP_FAILED) {
|
||||
if (!length)
|
||||
return NULL;
|
||||
release_pack_memory(length, fd);
|
||||
ret = mmap(start, length, prot, flags, fd, offset);
|
||||
if (ret == MAP_FAILED)
|
||||
die("Out of memory? mmap failed: %s", strerror(errno));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* xread() is the same a read(), but it automatically restarts read()
|
||||
* operations with a recoverable error (EAGAIN and EINTR). xread()
|
||||
* DOES NOT GUARANTEE that "len" bytes is read even if the data is available.
|
||||
*/
|
||||
ssize_t xread(int fd, void *buf, size_t len)
|
||||
{
|
||||
ssize_t nr;
|
||||
while (1) {
|
||||
nr = read(fd, buf, len);
|
||||
if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
|
||||
continue;
|
||||
return nr;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* xwrite() is the same a write(), but it automatically restarts write()
|
||||
* operations with a recoverable error (EAGAIN and EINTR). xwrite() DOES NOT
|
||||
* GUARANTEE that "len" bytes is written even if the operation is successful.
|
||||
*/
|
||||
ssize_t xwrite(int fd, const void *buf, size_t len)
|
||||
{
|
||||
ssize_t nr;
|
||||
while (1) {
|
||||
nr = write(fd, buf, len);
|
||||
if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
|
||||
continue;
|
||||
return nr;
|
||||
}
|
||||
}
|
||||
|
||||
int xdup(int fd)
|
||||
{
|
||||
int ret = dup(fd);
|
||||
if (ret < 0)
|
||||
die("dup failed: %s", strerror(errno));
|
||||
return ret;
|
||||
}
|
||||
|
||||
FILE *xfdopen(int fd, const char *mode)
|
||||
{
|
||||
FILE *stream = fdopen(fd, mode);
|
||||
if (stream == NULL)
|
||||
die("Out of memory? fdopen failed: %s", strerror(errno));
|
||||
return stream;
|
||||
}
|
||||
|
||||
int xmkstemp(char *template)
|
||||
{
|
||||
int fd;
|
||||
|
||||
fd = mkstemp(template);
|
||||
if (fd < 0)
|
||||
die("Unable to create temporary file: %s", strerror(errno));
|
||||
return fd;
|
||||
}
|
||||
Loading…
Reference in New Issue