#include "progress.h"
#include "refs.h"
-#ifdef THREADED_DELTA_SEARCH
+#ifndef NO_PTHREADS
#include "thread-utils.h"
#include <pthread.h>
#endif
static const char *base_name;
static int progress = 1;
static int window = 10;
-static uint32_t pack_size_limit, pack_size_limit_cfg;
+static unsigned long pack_size_limit, pack_size_limit_cfg;
static int depth = 50;
static int delta_search_threads;
static int pack_to_stdout;
return stream.total_out;
}
-/*
- * The per-object header is a pretty dense thing, which is
- * - first byte: low four bits are "size", then three bits of "type",
- * and the high bit is "size continues".
- * - each byte afterwards: low seven bits are size continuation,
- * with the high bit being "size continues"
- */
-static int encode_header(enum object_type type, unsigned long size, unsigned char *hdr)
-{
- int n = 1;
- unsigned char c;
-
- if (type < OBJ_COMMIT || type > OBJ_REF_DELTA)
- die("bad type %d", type);
-
- c = (type << 4) | (size & 15);
- size >>= 4;
- while (size) {
- *hdr++ = c | 0x80;
- c = size & 0x7f;
- size >>= 7;
- n++;
- }
- *hdr = c;
- return n;
-}
-
/*
* we are going to reuse the existing object data as is. make
* sure it is not corrupt.
type = entry->type;
- /* write limit if limited packsize and not first object */
+ /* apply size limit if limited packsize and not first object */
if (!pack_size_limit || !nr_written)
limit = 0;
else if (pack_size_limit <= write_offset)
* The object header is a byte of 'type' followed by zero or
* more bytes of length.
*/
- hdrlen = encode_header(type, size, header);
+ hdrlen = encode_in_pack_object_header(type, size, header);
if (type == OBJ_OFS_DELTA) {
/*
if (entry->delta)
type = (allow_ofs_delta && entry->delta->idx.offset) ?
OBJ_OFS_DELTA : OBJ_REF_DELTA;
- hdrlen = encode_header(type, entry->size, header);
+ hdrlen = encode_in_pack_object_header(type, entry->size, header);
offset = entry->in_pack_offset;
revidx = find_pack_revindex(p, offset);
/* offset is non zero if object is written already. */
if (e->idx.offset || e->preferred_base)
- return 1;
+ return -1;
/* if we are deltified, write out base object first. */
if (e->delta && !write_one(f, e->delta, offset))
if (written != nr_result)
die("wrote %"PRIu32" objects while expecting %"PRIu32,
written, nr_result);
- /*
- * We have scanned through [0 ... i). Since we have written
- * the correct number of objects, the remaining [i ... nr_objects)
- * items must be either already written (due to out-of-order delta base)
- * or a preferred base. Count those which are neither and complain if any.
- */
- for (j = 0; i < nr_objects; i++) {
- struct object_entry *e = objects + i;
- j += !e->idx.offset && !e->preferred_base;
- }
- if (j)
- die("wrote %"PRIu32" objects as expected but %"PRIu32
- " unwritten", written, j);
}
static int locate_object_entry_hash(const unsigned char *sha1)
return 0;
}
-#ifdef THREADED_DELTA_SEARCH
+#ifndef NO_PTHREADS
static pthread_mutex_t read_mutex;
#define read_lock() pthread_mutex_lock(&read_mutex)
/*
* Handle memory allocation outside of the cache
* accounting lock. Compiler will optimize the strangeness
- * away when THREADED_DELTA_SEARCH is not defined.
+ * away when NO_PTHREADS is defined.
*/
free(trg_entry->delta_data);
cache_lock();
free(array);
}
-#ifdef THREADED_DELTA_SEARCH
+#ifndef NO_PTHREADS
/*
* The main thread waits on the condition that (at least) one of the workers
if (delta_search_threads < 0)
die("invalid number of threads specified (%d)",
delta_search_threads);
-#ifndef THREADED_DELTA_SEARCH
+#ifdef NO_PTHREADS
if (delta_search_threads != 1)
warning("no threads support, ignoring %s", k);
#endif
continue;
}
if (!prefixcmp(arg, "--max-pack-size=")) {
- char *end;
pack_size_limit_cfg = 0;
- pack_size_limit = strtoul(arg+16, &end, 0) * 1024 * 1024;
- if (!arg[16] || *end)
+ if (!git_parse_ulong(arg+16, &pack_size_limit))
usage(pack_usage);
continue;
}
delta_search_threads = strtoul(arg+10, &end, 0);
if (!arg[10] || *end || delta_search_threads < 0)
usage(pack_usage);
-#ifndef THREADED_DELTA_SEARCH
+#ifdef NO_PTHREADS
if (delta_search_threads != 1)
warning("no threads support, "
"ignoring %s", arg);
if (!pack_to_stdout && !pack_size_limit)
pack_size_limit = pack_size_limit_cfg;
-
if (pack_to_stdout && pack_size_limit)
die("--max-pack-size cannot be used to build a pack for transfer.");
+ if (pack_size_limit && pack_size_limit < 1024*1024) {
+ warning("minimum pack size limit is 1 MiB");
+ pack_size_limit = 1024*1024;
+ }
if (!pack_to_stdout && thin)
die("--thin cannot be used to build an indexable pack.");