2018-04-12 03:21:05 +03:00
|
|
|
#ifndef REPLACE_OBJECT_H
|
|
|
|
#define REPLACE_OBJECT_H
|
|
|
|
|
2018-04-12 03:21:06 +03:00
|
|
|
#include "oidmap.h"
|
|
|
|
#include "repository.h"
|
2018-04-12 03:21:08 +03:00
|
|
|
#include "object-store.h"
|
2018-04-12 03:21:06 +03:00
|
|
|
|
2023-02-24 03:09:33 +03:00
|
|
|
/*
|
|
|
|
* Do replace refs need to be checked this run? This variable is
|
|
|
|
* initialized to true unless --no-replace-object is used or
|
|
|
|
* $GIT_NO_REPLACE_OBJECTS is set, but is set to false by some
|
|
|
|
* commands that do not want replace references to be active.
|
|
|
|
*/
|
|
|
|
extern int read_replace_refs;
|
|
|
|
|
2018-04-12 03:21:05 +03:00
|
|
|
struct replace_object {
|
|
|
|
struct oidmap_entry original;
|
|
|
|
struct object_id replacement;
|
|
|
|
};
|
|
|
|
|
2018-08-20 21:24:27 +03:00
|
|
|
void prepare_replace_object(struct repository *r);
|
|
|
|
|
2018-04-12 03:21:06 +03:00
|
|
|
/*
|
|
|
|
* This internal function is only declared here for the benefit of
|
|
|
|
* lookup_replace_object(). Please do not call it directly.
|
|
|
|
*/
|
2019-04-29 11:28:14 +03:00
|
|
|
const struct object_id *do_lookup_replace_object(struct repository *r,
|
2019-04-29 11:28:23 +03:00
|
|
|
const struct object_id *oid);
|
2018-04-12 03:21:06 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If object sha1 should be replaced, return the replacement object's
|
|
|
|
* name (replaced recursively, if necessary). The return value is
|
|
|
|
* either sha1 or a pointer to a permanently-allocated value. When
|
|
|
|
* object replacement is suppressed, always return sha1.
|
replace-object: make replace operations thread-safe
replace-object functions are very close to being thread-safe: the only
current racy section is the lazy initialization at
prepare_replace_object(). The following patches will protect some object
reading operations to be called threaded, but before that, replace
functions must be protected. To do so, add a mutex to struct
raw_object_store and acquire it before lazy initializing the
replace_map. This won't cause any noticeable performance drop as the
mutex will no longer be used after the replace_map is initialized.
Later, when the replace functions are called in parallel, thread
debuggers might point our use of the added replace_map_initialized flag
as a data race. However, as this boolean variable is initialized as
false and it's only updated once, there's no real harm. It's perfectly
fine if the value is updated right after a thread read it in
replace-map.h:lookup_replace_object() (there'll only be a performance
penalty for the affected threads at that moment). We could cease the
debugger warning protecting the variable reading at the said function.
However, this would negatively affect performance for all threads
calling it, at any time, so it's not really worthy since the warning
doesn't represent a real problem. Instead, to make sure we don't get
false positives (at ThreadSanitizer, at least) an entry for the
respective function is added to .tsan-suppressions.
Signed-off-by: Matheus Tavares <matheus.bernardino@usp.br>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-16 05:39:52 +03:00
|
|
|
*
|
|
|
|
* Note: some thread debuggers might point a data race on the
|
|
|
|
* replace_map_initialized reading in this function. However, we know there's no
|
|
|
|
* problem in the value being updated by one thread right after another one read
|
|
|
|
* it here (and it should be written to only once, anyway).
|
2018-04-12 03:21:06 +03:00
|
|
|
*/
|
2018-04-12 03:21:18 +03:00
|
|
|
static inline const struct object_id *lookup_replace_object(struct repository *r,
|
|
|
|
const struct object_id *oid)
|
2018-04-12 03:21:06 +03:00
|
|
|
{
|
2018-07-18 23:45:20 +03:00
|
|
|
if (!read_replace_refs ||
|
replace-object: make replace operations thread-safe
replace-object functions are very close to being thread-safe: the only
current racy section is the lazy initialization at
prepare_replace_object(). The following patches will protect some object
reading operations to be called threaded, but before that, replace
functions must be protected. To do so, add a mutex to struct
raw_object_store and acquire it before lazy initializing the
replace_map. This won't cause any noticeable performance drop as the
mutex will no longer be used after the replace_map is initialized.
Later, when the replace functions are called in parallel, thread
debuggers might point our use of the added replace_map_initialized flag
as a data race. However, as this boolean variable is initialized as
false and it's only updated once, there's no real harm. It's perfectly
fine if the value is updated right after a thread read it in
replace-map.h:lookup_replace_object() (there'll only be a performance
penalty for the affected threads at that moment). We could cease the
debugger warning protecting the variable reading at the said function.
However, this would negatively affect performance for all threads
calling it, at any time, so it's not really worthy since the warning
doesn't represent a real problem. Instead, to make sure we don't get
false positives (at ThreadSanitizer, at least) an entry for the
respective function is added to .tsan-suppressions.
Signed-off-by: Matheus Tavares <matheus.bernardino@usp.br>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-16 05:39:52 +03:00
|
|
|
(r->objects->replace_map_initialized &&
|
2018-04-12 03:21:18 +03:00
|
|
|
r->objects->replace_map->map.tablesize == 0))
|
2018-04-12 03:21:06 +03:00
|
|
|
return oid;
|
2018-04-12 03:21:18 +03:00
|
|
|
return do_lookup_replace_object(r, oid);
|
2018-04-12 03:21:06 +03:00
|
|
|
}
|
|
|
|
|
2018-04-12 03:21:05 +03:00
|
|
|
#endif /* REPLACE_OBJECT_H */
|