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>
Linus Torvalds committed
Jun 22, 2008 at 12:19 UTC
112db553b0db4c4f2b39e5e3e433b2102be10085
3 files changed
+173
-155
Makefile
+1
@@ -467,6 +467,7 @@ LIB_OBJS += unpack-trees.o
467
LIB_OBJS += usage.o
468
LIB_OBJS += utf8.o
469
LIB_OBJS += walker.o
470
+LIB_OBJS += wrapper.o
471
LIB_OBJS += write_or_die.o
472
LIB_OBJS += ws.o
473
LIB_OBJS += wt-status.o
git-compat-util.h
+12
-155
@@ -240,161 +240,18 @@ static inline char *gitstrchrnul(const char *s, int c)
240
241
extern void release_pack_memory(size_t, int);
242
243
-static inline char* xstrdup(const char *str)
244
-{
245
- char *ret = strdup(str);
246
- if (!ret) {
247
- release_pack_memory(strlen(str) + 1, -1);
248
- ret = strdup(str);
249
- if (!ret)
250
- die("Out of memory, strdup failed");
251
- }
252
- return ret;
253
-}
254
-
255
-static inline void *xmalloc(size_t size)
256
-{
257
- void *ret = malloc(size);
258
- if (!ret && !size)
259
- ret = malloc(1);
260
- if (!ret) {
261
- release_pack_memory(size, -1);
262
- ret = malloc(size);
263
- if (!ret && !size)
264
- ret = malloc(1);
265
- if (!ret)
266
- die("Out of memory, malloc failed");
267
- }
268
-#ifdef XMALLOC_POISON
269
- memset(ret, 0xA5, size);
270
-#endif
271
- return ret;
272
-}
273
-
274
-/*
275
- * xmemdupz() allocates (len + 1) bytes of memory, duplicates "len" bytes of
276
- * "data" to the allocated memory, zero terminates the allocated memory,
277
- * and returns a pointer to the allocated memory. If the allocation fails,
278
- * the program dies.
279
- */
280
-static inline void *xmemdupz(const void *data, size_t len)
281
-{
282
- char *p = xmalloc(len + 1);
283
- memcpy(p, data, len);
284
- p[len] = '\0';
285
- return p;
286
-}
287
-
288
-static inline char *xstrndup(const char *str, size_t len)
289
-{
290
- char *p = memchr(str, '\0', len);
291
- return xmemdupz(str, p ? p - str : len);
292
-}
293
-
294
-static inline void *xrealloc(void *ptr, size_t size)
295
-{
296
- void *ret = realloc(ptr, size);
297
- if (!ret && !size)
298
- ret = realloc(ptr, 1);
299
- if (!ret) {
300
- release_pack_memory(size, -1);
301
- ret = realloc(ptr, size);
302
- if (!ret && !size)
303
- ret = realloc(ptr, 1);
304
- if (!ret)
305
- die("Out of memory, realloc failed");
306
- }
307
- return ret;
308
-}
309
-
310
-static inline void *xcalloc(size_t nmemb, size_t size)
311
-{
312
- void *ret = calloc(nmemb, size);
313
- if (!ret && (!nmemb || !size))
314
- ret = calloc(1, 1);
315
- if (!ret) {
316
- release_pack_memory(nmemb * size, -1);
317
- ret = calloc(nmemb, size);
318
- if (!ret && (!nmemb || !size))
319
- ret = calloc(1, 1);
320
- if (!ret)
321
- die("Out of memory, calloc failed");
322
- }
323
- return ret;
324
-}
325
-
326
-static inline void *xmmap(void *start, size_t length,
327
- int prot, int flags, int fd, off_t offset)
328
-{
329
- void *ret = mmap(start, length, prot, flags, fd, offset);
330
- if (ret == MAP_FAILED) {
331
- if (!length)
332
- return NULL;
333
- release_pack_memory(length, fd);
334
- ret = mmap(start, length, prot, flags, fd, offset);
335
- if (ret == MAP_FAILED)
336
- die("Out of memory? mmap failed: %s", strerror(errno));
337
- }
338
- return ret;
339
-}
340
-
341
-/*
342
- * xread() is the same a read(), but it automatically restarts read()
343
- * operations with a recoverable error (EAGAIN and EINTR). xread()
344
- * DOES NOT GUARANTEE that "len" bytes is read even if the data is available.
345
- */
346
-static inline ssize_t xread(int fd, void *buf, size_t len)
347
-{
348
- ssize_t nr;
349
- while (1) {
350
- nr = read(fd, buf, len);
351
- if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
352
- continue;
353
- return nr;
354
- }
355
-}
356
-
357
-/*
358
- * xwrite() is the same a write(), but it automatically restarts write()
359
- * operations with a recoverable error (EAGAIN and EINTR). xwrite() DOES NOT
360
- * GUARANTEE that "len" bytes is written even if the operation is successful.
361
- */
362
-static inline ssize_t xwrite(int fd, const void *buf, size_t len)
363
-{
364
- ssize_t nr;
365
- while (1) {
366
- nr = write(fd, buf, len);
367
- if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
368
- continue;
369
- return nr;
370
- }
371
-}
372
-
373
-static inline int xdup(int fd)
374
-{
375
- int ret = dup(fd);
376
- if (ret < 0)
377
- die("dup failed: %s", strerror(errno));
378
- return ret;
379
-}
380
-
381
-static inline FILE *xfdopen(int fd, const char *mode)
382
-{
383
- FILE *stream = fdopen(fd, mode);
384
- if (stream == NULL)
385
- die("Out of memory? fdopen failed: %s", strerror(errno));
386
- return stream;
387
-}
388
-
389
-static inline int xmkstemp(char *template)
390
-{
391
- int fd;
392
-
393
- fd = mkstemp(template);
394
- if (fd < 0)
395
- die("Unable to create temporary file: %s", strerror(errno));
396
- return fd;
397
-}
243
+extern char *xstrdup(const char *str);
244
+extern void *xmalloc(size_t size);
245
+extern void *xmemdupz(const void *data, size_t len);
246
+extern char *xstrndup(const char *str, size_t len);
247
+extern void *xrealloc(void *ptr, size_t size);
248
+extern void *xcalloc(size_t nmemb, size_t size);
249
+extern void *xmmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);
250
+extern ssize_t xread(int fd, void *buf, size_t len);
251
+extern ssize_t xwrite(int fd, const void *buf, size_t len);
252
+extern int xdup(int fd);
253
+extern FILE *xfdopen(int fd, const char *mode);
254
+extern int xmkstemp(char *template);
255
256
static inline size_t xsize_t(off_t len)
257
{
wrapper.c
new
+160
@@ -0,0 +1,160 @@
1
+/*
2
+ * Various trivial helper wrappers around standard functions
3
+ */
4
+#include "cache.h"
5
+
6
+char *xstrdup(const char *str)
7
+{
8
+ char *ret = strdup(str);
9
+ if (!ret) {
10
+ release_pack_memory(strlen(str) + 1, -1);
11
+ ret = strdup(str);
12
+ if (!ret)
13
+ die("Out of memory, strdup failed");
14
+ }
15
+ return ret;
16
+}
17
+
18
+void *xmalloc(size_t size)
19
+{
20
+ void *ret = malloc(size);
21
+ if (!ret && !size)
22
+ ret = malloc(1);
23
+ if (!ret) {
24
+ release_pack_memory(size, -1);
25
+ ret = malloc(size);
26
+ if (!ret && !size)
27
+ ret = malloc(1);
28
+ if (!ret)
29
+ die("Out of memory, malloc failed");
30
+ }
31
+#ifdef XMALLOC_POISON
32
+ memset(ret, 0xA5, size);
33
+#endif
34
+ return ret;
35
+}
36
+
37
+/*
38
+ * xmemdupz() allocates (len + 1) bytes of memory, duplicates "len" bytes of
39
+ * "data" to the allocated memory, zero terminates the allocated memory,
40
+ * and returns a pointer to the allocated memory. If the allocation fails,
41
+ * the program dies.
42
+ */
43
+void *xmemdupz(const void *data, size_t len)
44
+{
45
+ char *p = xmalloc(len + 1);
46
+ memcpy(p, data, len);
47
+ p[len] = '\0';
48
+ return p;
49
+}
50
+
51
+char *xstrndup(const char *str, size_t len)
52
+{
53
+ char *p = memchr(str, '\0', len);
54
+ return xmemdupz(str, p ? p - str : len);
55
+}
56
+
57
+void *xrealloc(void *ptr, size_t size)
58
+{
59
+ void *ret = realloc(ptr, size);
60
+ if (!ret && !size)
61
+ ret = realloc(ptr, 1);
62
+ if (!ret) {
63
+ release_pack_memory(size, -1);
64
+ ret = realloc(ptr, size);
65
+ if (!ret && !size)
66
+ ret = realloc(ptr, 1);
67
+ if (!ret)
68
+ die("Out of memory, realloc failed");
69
+ }
70
+ return ret;
71
+}
72
+
73
+void *xcalloc(size_t nmemb, size_t size)
74
+{
75
+ void *ret = calloc(nmemb, size);
76
+ if (!ret && (!nmemb || !size))
77
+ ret = calloc(1, 1);
78
+ if (!ret) {
79
+ release_pack_memory(nmemb * size, -1);
80
+ ret = calloc(nmemb, size);
81
+ if (!ret && (!nmemb || !size))
82
+ ret = calloc(1, 1);
83
+ if (!ret)
84
+ die("Out of memory, calloc failed");
85
+ }
86
+ return ret;
87
+}
88
+
89
+void *xmmap(void *start, size_t length,
90
+ int prot, int flags, int fd, off_t offset)
91
+{
92
+ void *ret = mmap(start, length, prot, flags, fd, offset);
93
+ if (ret == MAP_FAILED) {
94
+ if (!length)
95
+ return NULL;
96
+ release_pack_memory(length, fd);
97
+ ret = mmap(start, length, prot, flags, fd, offset);
98
+ if (ret == MAP_FAILED)
99
+ die("Out of memory? mmap failed: %s", strerror(errno));
100
+ }
101
+ return ret;
102
+}
103
+
104
+/*
105
+ * xread() is the same a read(), but it automatically restarts read()
106
+ * operations with a recoverable error (EAGAIN and EINTR). xread()
107
+ * DOES NOT GUARANTEE that "len" bytes is read even if the data is available.
108
+ */
109
+ssize_t xread(int fd, void *buf, size_t len)
110
+{
111
+ ssize_t nr;
112
+ while (1) {
113
+ nr = read(fd, buf, len);
114
+ if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
115
+ continue;
116
+ return nr;
117
+ }
118
+}
119
+
120
+/*
121
+ * xwrite() is the same a write(), but it automatically restarts write()
122
+ * operations with a recoverable error (EAGAIN and EINTR). xwrite() DOES NOT
123
+ * GUARANTEE that "len" bytes is written even if the operation is successful.
124
+ */
125
+ssize_t xwrite(int fd, const void *buf, size_t len)
126
+{
127
+ ssize_t nr;
128
+ while (1) {
129
+ nr = write(fd, buf, len);
130
+ if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
131
+ continue;
132
+ return nr;
133
+ }
134
+}
135
+
136
+int xdup(int fd)
137
+{
138
+ int ret = dup(fd);
139
+ if (ret < 0)
140
+ die("dup failed: %s", strerror(errno));
141
+ return ret;
142
+}
143
+
144
+FILE *xfdopen(int fd, const char *mode)
145
+{
146
+ FILE *stream = fdopen(fd, mode);
147
+ if (stream == NULL)
148
+ die("Out of memory? fdopen failed: %s", strerror(errno));
149
+ return stream;
150
+}
151
+
152
+int xmkstemp(char *template)
153
+{
154
+ int fd;
155
+
156
+ fd = mkstemp(template);
157
+ if (fd < 0)
158
+ die("Unable to create temporary file: %s", strerror(errno));
159
+ return fd;
160
+}