Remove trace / add git_diff_perfdata struct + api

include/git2/diff.h

@@ -391,14 +391,13 @@ typedef struct {
 * Initializes a `git_diff_options` with default values. Equivalent to
 * creating an instance with GIT_DIFF_OPTIONS_INIT.
 *
-* @param opts the `git_diff_options` instance to initialize.
-* @param version the version of the struct; you should pass
-* `GIT_DIFF_OPTIONS_VERSION` here.
+* @param opts The `git_diff_options` instance to initialize.
+* @param version Version of struct; pass `GIT_DIFF_OPTIONS_VERSION`
 * @return Zero on success; -1 on failure.
 */
 GIT_EXTERN(int) git_diff_init_options(
-	git_diff_options* opts,
-	int version);
+	git_diff_options *opts,
+	unsigned int version);
 
 /**
  * When iterating over a diff, callback that will be made per file.
@@ -632,14 +631,13 @@ typedef struct {
 * Initializes a `git_diff_find_options` with default values. Equivalent to
 * creating an instance with GIT_DIFF_FIND_OPTIONS_INIT.
 *
-* @param opts the `git_diff_find_options` instance to initialize.
-* @param version the version of the struct; you should pass
-* `GIT_DIFF_FIND_OPTIONS_VERSION` here.
+* @param opts The `git_diff_find_options` instance to initialize.
+* @param version Version of struct; pass `GIT_DIFF_FIND_OPTIONS_VERSION`
 * @return Zero on success; -1 on failure.
 */
 GIT_EXTERN(int) git_diff_find_init_options(
-	git_diff_find_options* opts,
-	int version);
+	git_diff_find_options *opts,
+	unsigned int version);
 
 /** @name Diff Generator Functions
  *
@@ -1223,17 +1221,17 @@ GIT_EXTERN(int) git_diff_commit_as_email(
 	const git_diff_options *diff_opts);
 
 /**
-* Initializes a `git_diff_format_email_options` with default values. Equivalent to
-* creating an instance with GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT.
+* Initializes a `git_diff_format_email_options` with default values.
 *
-* @param opts the `git_diff_format_email_options` instance to initialize.
-* @param version the version of the struct; you should pass
-* `GIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSION` here.
+* Equivalent to creating an instance with GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT.
+*
+* @param opts Uhe `git_diff_format_email_options` instance to initialize.
+* @param version Version of struct; pass `GIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSION`
 * @return Zero on success; -1 on failure.
 */
 GIT_EXTERN(int) git_diff_format_email_init_options(
 	git_diff_format_email_options *opts,
-	int version);
+	unsigned int version);
 
 GIT_END_DECL
 

include/git2/status.h

@@ -184,14 +184,13 @@ typedef struct {
  * Initializes a `git_status_options` with default values. Equivalent to
  * creating an instance with GIT_STATUS_OPTIONS_INIT.
  *
- * @param opts the `git_status_options` instance to initialize.
- * @param version the version of the struct; you should pass
- *        `GIT_STATUS_OPTIONS_VERSION` here.
+ * @param opts The `git_status_options` instance to initialize.
+ * @param version Version of struct; pass `GIT_STATUS_OPTIONS_VERSION`
  * @return Zero on success; -1 on failure.
  */
 GIT_EXTERN(int) git_status_init_options(
-	git_status_options* opts,
-	int version);
+	git_status_options *opts,
+	unsigned int version);
 
 /**
  * A status entry, providing the differences between the file as it exists

include/git2/sys/diff.h

@@ -10,6 +10,8 @@
 #include "git2/common.h"
 #include "git2/types.h"
 #include "git2/oid.h"
+#include "git2/diff.h"
+#include "git2/status.h"
 
 /**
  * @file git2/sys/diff.h
@@ -58,6 +60,32 @@ GIT_EXTERN(int) git_diff_print_callback__to_file_handle(
 	const git_diff_line *line,
 	void *payload); /*< payload must be a `FILE *` */
 
+
+typedef struct {
+	unsigned int version;
+	size_t stat_calls;
+	size_t oid_calculations;
+} git_diff_perfdata;
+
+#define GIT_DIFF_PERFDATA_VERSION 1
+#define GIT_DIFF_PERFDATA_INIT {GIT_DIFF_PERFDATA_VERSION,0,0}
+
+/**
+ * Get performance data for a diff object.
+ *
+ * @param out Structure to be filled with diff performance data
+ * @param diff Diff to read performance data from
+ * @return 0 for success, <0 for error
+ */
+GIT_EXTERN(int) git_diff_get_perfdata(
+	git_diff_perfdata *out, const git_diff *diff);
+
+/**
+ * Get performance data for diffs from a git_status_list
+ */
+GIT_EXTERN(int) git_status_list_get_perfdata(
+	git_diff_perfdata *out, const git_status_list *status);
+
 /** @} */
 GIT_END_DECL
 #endif

include/git2/trace.h

@@ -20,64 +20,47 @@
 GIT_BEGIN_DECL
 
 /**
- * Available tracing messages.  Each tracing level can be enabled
- * independently or pass GIT_TRACE_ALL to enable all levels.
+ * Available tracing levels.  When tracing is set to a particular level,
+ * callers will be provided tracing at the given level and all lower levels.
  */
 typedef enum {
 	/** No tracing will be performed. */
-	GIT_TRACE_NONE = 0x0000u,
-
-	/** All tracing messages will be sent. */
-	GIT_TRACE_ALL = 0xFFFFu,
+	GIT_TRACE_NONE = 0,
 
 	/** Severe errors that may impact the program's execution */
-	GIT_TRACE_FATAL = 0x0001u,
+	GIT_TRACE_FATAL = 1,
 
 	/** Errors that do not impact the program's execution */
-	GIT_TRACE_ERROR = 0x0002u,
-	GIT_TRACE_ERROR_AND_BELOW = 0x0003u,
+	GIT_TRACE_ERROR = 2,
 
 	/** Warnings that suggest abnormal data */
-	GIT_TRACE_WARN = 0x0004u,
-	GIT_TRACE_WARN_AND_BELOW = 0x0007u,
+	GIT_TRACE_WARN = 3,
 
 	/** Informational messages about program execution */
-	GIT_TRACE_INFO = 0x0008u,
-	GIT_TRACE_INFO_AND_BELOW = 0x000Fu,
+	GIT_TRACE_INFO = 4,
 
 	/** Detailed data that allows for debugging */
-	GIT_TRACE_DEBUG = 0x0010u,
+	GIT_TRACE_DEBUG = 5,
 
 	/** Exceptionally detailed debugging data */
-	GIT_TRACE_TRACE = 0x0020u,
-
-	/** Performance tracking related traces */
-	GIT_TRACE_PERF = 0x0040u,
+	GIT_TRACE_TRACE = 6
 } git_trace_level_t;
 
 /**
  * An instance for a tracing function
  */
-typedef void (*git_trace_callback)(
-	git_trace_level_t level, /* just one bit will be sent */
-	void *cb_payload,
-	void *msg_payload,
-	const char *msg);
+typedef void (*git_trace_callback)(git_trace_level_t level, const char *msg);
 
 /**
  * Sets the system tracing configuration to the specified level with the
  * specified callback.  When system events occur at a level equal to, or
  * lower than, the given level they will be reported to the given callback.
  *
- * @param level Bitmask of all enabled trace levels
- * @param cb Function to call with trace messages
- * @param cb_payload Payload to pass when callback is invoked
+ * @param level Level to set tracing to
+ * @param cb Function to call with trace data
  * @return 0 or an error code
  */
-GIT_EXTERN(int) git_trace_set(
-	git_trace_level_t level,
-	git_trace_callback cb,
-	void *cb_payload);
+GIT_EXTERN(int) git_trace_set(git_trace_level_t level, git_trace_callback cb);
 
 /** @} */
 GIT_END_DECL

src/diff.c

@@ -14,7 +14,6 @@
 #include "index.h"
 #include "odb.h"
 #include "submodule.h"
-#include "trace.h"
 
 #define DIFF_FLAG_IS_SET(DIFF,FLAG) (((DIFF)->opts.flags & (FLAG)) != 0)
 #define DIFF_FLAG_ISNT_SET(DIFF,FLAG) (((DIFF)->opts.flags & (FLAG)) == 0)
@@ -555,7 +554,8 @@ int git_diff__oid_for_entry(
 	if (!entry.mode) {
 		struct stat st;
 
-		git_trace(GIT_TRACE_PERF, NULL, "stat");
+		diff->perf.stat_calls++;
+
 		if (p_stat(full_path.ptr, &st) < 0) {
 			error = git_path_set_error(errno, entry.path, "stat");
 			git_buf_free(&full_path);
@@ -570,7 +570,6 @@ int git_diff__oid_for_entry(
 	if (S_ISGITLINK(entry.mode)) {
 		git_submodule *sm;
 
-		git_trace(GIT_TRACE_PERF, NULL, "submodule_lookup");
 		if (!git_submodule_lookup(&sm, diff->repo, entry.path)) {
 			const git_oid *sm_oid = git_submodule_wd_id(sm);
 			if (sm_oid)
@@ -583,8 +582,8 @@ int git_diff__oid_for_entry(
 			giterr_clear();
 		}
 	} else if (S_ISLNK(entry.mode)) {
-		git_trace(GIT_TRACE_PERF, NULL, "oid_calculation");
 		error = git_odb__hashlink(out, full_path.ptr);
+		diff->perf.oid_calculations++;
 	} else if (!git__is_sizet(entry.file_size)) {
 		giterr_set(GITERR_OS, "File size overflow (for 32-bits) on '%s'",
 			entry.path);
@@ -596,10 +595,10 @@ int git_diff__oid_for_entry(
 		if (fd < 0)
 			error = fd;
 		else {
-			git_trace(GIT_TRACE_PERF, NULL, "oid_calculation");
 			error = git_odb__hashfd_filtered(
 				out, fd, (size_t)entry.file_size, GIT_OBJ_BLOB, fl);
 			p_close(fd);
+			diff->perf.oid_calculations++;
 		}
 
 		git_filter_list_free(fl);
@@ -655,8 +654,6 @@ static int maybe_modified_submodule(
 		ign == GIT_SUBMODULE_IGNORE_ALL)
 		return 0;
 
-	git_trace(GIT_TRACE_PERF, NULL, "submodule_lookup");
-
 	if ((error = git_submodule_lookup(
 			&sub, diff->repo, info->nitem->path)) < 0) {
 
@@ -965,8 +962,6 @@ static int handle_unmatched_new_item(
 		delta_type = GIT_DELTA_ADDED;
 
 	else if (nitem->mode == GIT_FILEMODE_COMMIT) {
-		git_trace(GIT_TRACE_PERF, NULL, "submodule_lookup");
-
 		/* ignore things that are not actual submodules */
 		if (git_submodule_lookup(NULL, info->repo, nitem->path) != 0) {
 			giterr_clear();
@@ -1119,6 +1114,8 @@ int git_diff__from_iterators(
 			error = 0;
 	}
 
+	diff->perf.stat_calls += old_iter->stat_calls + new_iter->stat_calls;
+
 cleanup:
 	if (!error)
 		*diff_ptr = diff;
@@ -1313,6 +1310,22 @@ int git_diff_is_sorted_icase(const git_diff *diff)
 	return (diff->opts.flags & GIT_DIFF_IGNORE_CASE) != 0;
 }
 
+static int diff_options_bad_version(int version, const char *thing)
+{
+	giterr_set(GITERR_INVALID, "Invalid version %d for %s", version, thing);
+	return -1;
+}
+
+int git_diff_get_perfdata(git_diff_perfdata *out, const git_diff *diff)
+{
+	if (!out || out->version != GIT_DIFF_PERFDATA_VERSION)
+		return diff_options_bad_version(
+			out ? out->version : 0, "git_diff_perfdata");
+	out->stat_calls = diff->perf.stat_calls;
+	out->oid_calculations = diff->perf.oid_calculations;
+	return 0;
+}
+
 int git_diff__paired_foreach(
 	git_diff *head2idx,
 	git_diff *idx2wd,
@@ -1615,38 +1628,29 @@ int git_diff_commit_as_email(
 	return error;
 }
 
-int git_diff_init_options(git_diff_options* opts, int version)
+int git_diff_init_options(git_diff_options* opts, unsigned int version)
 {
-	if (version != GIT_DIFF_OPTIONS_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_diff_options", version);
-		return -1;
-	} else {
-		git_diff_options o = GIT_DIFF_OPTIONS_INIT;
-		memcpy(opts, &o, sizeof(o));
-		return 0;
-	}
+	git_diff_options o = GIT_DIFF_OPTIONS_INIT;
+	if (version != o.version)
+		return diff_options_bad_version(version, "git_diff_options");
+	memcpy(opts, &o, sizeof(o));
+	return 0;
 }
 
-int git_diff_find_init_options(git_diff_find_options* opts, int version)
+int git_diff_find_init_options(git_diff_find_options* opts, unsigned int version)
 {
-	if (version != GIT_DIFF_FIND_OPTIONS_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_diff_find_options", version);
-		return -1;
-	} else {
-		git_diff_find_options o = GIT_DIFF_FIND_OPTIONS_INIT;
-		memcpy(opts, &o, sizeof(o));
-		return 0;
-	}
+	git_diff_find_options o = GIT_DIFF_FIND_OPTIONS_INIT;
+	if (version != o.version)
+		return diff_options_bad_version(version, "git_diff_find_options");
+	memcpy(opts, &o, sizeof(o));
+	return 0;
 }
 
-int git_diff_format_email_init_options(git_diff_format_email_options* opts, int version)
+int git_diff_format_email_init_options(git_diff_format_email_options* opts, unsigned int version)
 {
-	if (version != GIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_diff_format_email_options", version);
-		return -1;
-	} else {
-		git_diff_format_email_options o = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
-		memcpy(opts, &o, sizeof(o));
-		return 0;
-	}
+	git_diff_format_email_options o = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
+	if (version != o.version)
+		return diff_options_bad_version(version, "git_diff_format_email_options");
+	memcpy(opts, &o, sizeof(o));
+	return 0;
 }

src/diff.h

@@ -8,6 +8,7 @@
 #define INCLUDE_diff_h__
 
 #include "git2/diff.h"
+#include "git2/sys/diff.h"
 #include "git2/oid.h"
 
 #include <stdio.h>
@@ -62,6 +63,7 @@ struct git_diff {
 	git_iterator_type_t old_src;
 	git_iterator_type_t new_src;
 	uint32_t diffcaps;
+	git_diff_perfdata perf;
 
 	int (*strcomp)(const char *, const char *);
 	int (*strncomp)(const char *, const char *, size_t);

src/iterator.c

@@ -11,7 +11,6 @@
 #include "ignore.h"
 #include "buffer.h"
 #include "submodule.h"
-#include "trace.h"
 #include <ctype.h>
 
 #define ITERATOR_SET_CB(P,NAME_LC) do { \
@@ -1017,8 +1016,7 @@ static int fs_iterator__expand_dir(fs_iterator *fi)
 		fs_iterator__free_frame(ff);
 		return GIT_ENOTFOUND;
 	}
-
-	git_trace(GIT_TRACE_PERF, &ff->entries.length, "stat");
+	fi->base.stat_calls += ff->entries.length;
 
 	fs_iterator__seek_frame_start(fi, ff);
 
@@ -1310,7 +1308,6 @@ static int workdir_iterator__enter_dir(fs_iterator *fi)
 		if (!S_ISDIR(entry->st.st_mode) || !strcmp(GIT_DIR, entry->path))
 			continue;
 
-		git_trace(GIT_TRACE_PERF, entry->path, "submodule_lookup");
 		if (git_submodule__is_submodule(fi->base.repo, entry->path)) {
 			entry->st.st_mode = GIT_FILEMODE_COMMIT;
 			entry->path_len--;

src/iterator.h

@@ -52,6 +52,7 @@ struct git_iterator {
 	char *start;
 	char *end;
 	int (*prefixcomp)(const char *str, const char *prefix);
+	size_t stat_calls;
 	unsigned int flags;
 };
 

src/status.c

@@ -518,14 +518,38 @@ int git_status_should_ignore(
 	return git_ignore_path_is_ignored(ignored, repo, path);
 }
 
-int git_status_init_options(git_status_options* opts, int version)
+int git_status_init_options(git_status_options* opts, unsigned int version)
 {
-	if (version != GIT_STATUS_OPTIONS_VERSION) {
+	git_status_options o = GIT_STATUS_OPTIONS_INIT;
+	if (version != o.version) {
 		giterr_set(GITERR_INVALID, "Invalid version %d for git_status_options", version);
 		return -1;
-	} else {
-		git_status_options o = GIT_STATUS_OPTIONS_INIT;
-		memcpy(opts, &o, sizeof(o));
-		return 0;
 	}
+	memcpy(opts, &o, sizeof(o));
+	return 0;
+}
+
+int git_status_list_get_perfdata(
+	git_diff_perfdata *out, const git_status_list *status)
+{
+	if (!out || out->version != GIT_DIFF_PERFDATA_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_diff_perfdata",
+				   out ? out->version : 0);
+		return -1;
+	}
+
+	out->stat_calls = 0;
+	out->oid_calculations = 0;
+
+	if (status->head2idx) {
+		out->stat_calls += status->head2idx->perf.stat_calls;
+		out->oid_calculations += status->head2idx->perf.oid_calculations;
+	}
+	if (status->idx2wd) {
+		out->stat_calls += status->idx2wd->perf.stat_calls;
+		out->oid_calculations += status->idx2wd->perf.oid_calculations;
+	}
+
+	return 0;
 }
+

src/trace.c

@@ -17,25 +17,22 @@ struct git_trace_data git_trace__data = {0};
 
 #endif
 
-int git_trace_set(
-	git_trace_level_t level, git_trace_callback cb, void *cb_payload)
+int git_trace_set(git_trace_level_t level, git_trace_callback callback)
 {
 #ifdef GIT_TRACE
-	assert(level == 0 || cb != NULL);
+	assert(level == 0 || callback != NULL);
 
 	git_trace__data.level = level;
-	git_trace__data.callback = cb;
-	git_trace__data.callback_payload = cb_payload;
+	git_trace__data.callback = callback;
 	GIT_MEMORY_BARRIER;
 
 	return 0;
 #else
 	GIT_UNUSED(level);
-	GIT_UNUSED(cb);
-	GIT_UNUSED(cb_payload);
+	GIT_UNUSED(callback);
 
-	giterr_set(
-		GITERR_INVALID, "This version of libgit2 was not built with tracing.");
+	giterr_set(GITERR_INVALID,
+		"This version of libgit2 was not built with tracing.");
 	return -1;
 #endif
 }

src/trace.h

@@ -15,16 +15,13 @@
 struct git_trace_data {
 	git_trace_level_t level;
 	git_trace_callback callback;
-	void *callback_payload;
 };
 
 extern struct git_trace_data git_trace__data;
 
 GIT_INLINE(void) git_trace__write_fmt(
 	git_trace_level_t level,
-	void *message_payload,
-	const char *fmt,
-	...)
+	const char *fmt, ...)
 {
 	git_trace_callback callback = git_trace__data.callback;
 	git_buf message = GIT_BUF_INIT;
@@ -34,18 +31,18 @@ GIT_INLINE(void) git_trace__write_fmt(
 	git_buf_vprintf(&message, fmt, ap);
 	va_end(ap);
 
-	callback(
-		level, git_trace__data.callback_payload, message_payload,
-		git_buf_cstr(&message));
+	callback(level, git_buf_cstr(&message));
 
 	git_buf_free(&message);
 }
 
 #define git_trace_level()		(git_trace__data.level)
-#define git_trace(l, p, ...)	do { \
-	if ((git_trace__data.level & (l)) != 0 && git_trace__data.callback) { \
-		git_trace__write_fmt((l), (p), __VA_ARGS__); \
-	} } while (0)
+#define git_trace(l, ...)		{ \
+									if (git_trace__data.level >= l && \
+										git_trace__data.callback != NULL) { \
+										git_trace__write_fmt(l, __VA_ARGS__); \
+									} \
+								}
 
 #else
 

tests/diff/diff_helpers.c

@@ -229,22 +229,3 @@ void diff_print_raw(FILE *fp, git_diff *diff)
 		git_diff_print(diff, GIT_DIFF_FORMAT_RAW,
 			git_diff_print_callback__to_file_handle, fp ? fp : stderr));
 }
-
-void diff_perf_track_stats(
-	git_trace_level_t level,
-	void *cb_payload,
-	void *msg_payload,
-	const char *msg)
-{
-	diff_perf *data = cb_payload;
-
-	if (!(level & GIT_TRACE_PERF))
-		return;
-
-	if (!strcmp("stat", msg))
-		data->stat_calls += msg_payload ? *((size_t *)msg_payload) : 1;
-	else if (!strcmp("submodule_lookup", msg))
-		data->submodule_lookups++;
-	else if (!strcmp("oid_calculation", msg))
-		data->oid_calcs++;
-}

tests/diff/diff_helpers.h

@@ -62,17 +62,3 @@ extern int diff_foreach_via_iterator(
 
 extern void diff_print(FILE *fp, git_diff *diff);
 extern void diff_print_raw(FILE *fp, git_diff *diff);
-
-#include "git2/trace.h"
-
-typedef struct {
-	size_t stat_calls;
-	size_t oid_calcs;
-	size_t submodule_lookups;
-} diff_perf;
-
-extern void diff_perf_track_stats(
-	git_trace_level_t level,
-	void *cb_payload,
-	void *msg_payload,
-	const char *msg);

tests/diff/workdir.c

 #include "clar_libgit2.h"
 #include "diff_helpers.h"
 #include "repository.h"
+#include "git2/sys/diff.h"
 
 static git_repository *g_repo = NULL;
 
-#ifdef GIT_TRACE
-static diff_perf g_diff_perf;
-#endif
-
-void test_diff_workdir__initialize(void)
-{
-#ifdef GIT_TRACE
-	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
-	cl_git_pass(git_trace_set(
-		GIT_TRACE_PERF, diff_perf_track_stats, &g_diff_perf));
-#endif
-}
-
 void test_diff_workdir__cleanup(void)
 {
 	cl_git_sandbox_cleanup();
-#ifdef GIT_TRACE
-	cl_git_pass(git_trace_set(GIT_TRACE_NONE, NULL, NULL));
-#endif
 }
 
 void test_diff_workdir__to_index(void)
@@ -70,13 +55,14 @@ void test_diff_workdir__to_index(void)
 		cl_assert_equal_i(5, exp.line_ctxt);
 		cl_assert_equal_i(4, exp.line_adds);
 		cl_assert_equal_i(5, exp.line_dels);
+	}
 
-#ifdef GIT_TRACE
+	{
+		git_diff_perfdata perf = GIT_DIFF_PERFDATA_INIT;
+		cl_git_pass(git_diff_get_perfdata(&perf, diff));
 		cl_assert_equal_sz(
-			13 /* in root */ + 3 /* in subdir */, g_diff_perf.stat_calls);
-		cl_assert_equal_sz(5, g_diff_perf.oid_calcs);
-		cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
-#endif
+			13 /* in root */ + 3 /* in subdir */, perf.stat_calls);
+		cl_assert_equal_sz(5, perf.oid_calculations);
 	}
 
 	git_diff_free(diff);
@@ -1532,10 +1518,6 @@ static void basic_diff_status(git_diff **out, const git_diff_options *opts)
 {
 	diff_expects exp;
 
-#ifdef GIT_TRACE
-	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
-#endif
-
 	cl_git_pass(git_diff_index_to_workdir(out, g_repo, NULL, opts));
 
 	memset(&exp, 0, sizeof(exp));
@@ -1555,6 +1537,7 @@ void test_diff_workdir__can_update_index(void)
 {
 	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
 	git_diff *diff = NULL;
+	git_diff_perfdata perf = GIT_DIFF_PERFDATA_INIT;
 
 	g_repo = cl_git_sandbox_init("status");
 
@@ -1569,11 +1552,10 @@ void test_diff_workdir__can_update_index(void)
 	opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
 
 	basic_diff_status(&diff, &opts);
-#ifdef GIT_TRACE
-	cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
-	cl_assert_equal_sz(5, g_diff_perf.oid_calcs);
-	cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
-#endif
+
+	cl_git_pass(git_diff_get_perfdata(&perf, diff));
+	cl_assert_equal_sz(13 + 3, perf.stat_calls);
+	cl_assert_equal_sz(5, perf.oid_calculations);
 
 	git_diff_free(diff);
 
@@ -1581,22 +1563,20 @@ void test_diff_workdir__can_update_index(void)
 	opts.flags |= GIT_DIFF_UPDATE_INDEX;
 
 	basic_diff_status(&diff, &opts);
-#ifdef GIT_TRACE
-	cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
-	cl_assert_equal_sz(5, g_diff_perf.oid_calcs);
-	cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
-#endif
+
+	cl_git_pass(git_diff_get_perfdata(&perf, diff));
+	cl_assert_equal_sz(13 + 3, perf.stat_calls);
+	cl_assert_equal_sz(5, perf.oid_calculations);
 
 	git_diff_free(diff);
 
 	/* now if we do it again, we should see fewer OID calculations */
 
 	basic_diff_status(&diff, &opts);
-#ifdef GIT_TRACE
-	cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
-	cl_assert_equal_sz(0, g_diff_perf.oid_calcs); /* Yay */
-	cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
-#endif
+
+	cl_git_pass(git_diff_get_perfdata(&perf, diff));
+	cl_assert_equal_sz(13 + 3, perf.stat_calls);
+	cl_assert_equal_sz(0, perf.oid_calculations);
 
 	git_diff_free(diff);
 }

tests/status/worktree.c

@@ -6,19 +6,7 @@
 #include "util.h"
 #include "path.h"
 #include "../diff/diff_helpers.h"
-
-#ifdef GIT_TRACE
-static diff_perf g_diff_perf;
-#endif
-
-void test_status_worktree__initialize(void)
-{
-#ifdef GIT_TRACE
-	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
-	cl_git_pass(git_trace_set(
-		GIT_TRACE_PERF, diff_perf_track_stats, &g_diff_perf));
-#endif
-}
+#include "git2/sys/diff.h"
 
 /**
  * Cleanup
@@ -29,9 +17,6 @@ void test_status_worktree__initialize(void)
 void test_status_worktree__cleanup(void)
 {
 	cl_git_sandbox_cleanup();
-#ifdef GIT_TRACE
-	cl_git_pass(git_trace_set(GIT_TRACE_NONE, NULL, NULL));
-#endif
 }
 
 /**
@@ -903,38 +888,50 @@ void test_status_worktree__long_filenames(void)
  * while reducing the amount of work that needs to be done
  */
 
+static void check_status0(git_status_list *status)
+{
+	size_t i, max_i = git_status_list_entrycount(status);
+	cl_assert_equal_sz(entry_count0, max_i);
+	for (i = 0; i < max_i; ++i) {
+		const git_status_entry *entry = git_status_byindex(status, i);
+		cl_assert_equal_i(entry_statuses0[i], entry->status);
+	}
+}
+
 void test_status_worktree__update_stat_cache_0(void)
 {
 	git_repository *repo = cl_git_sandbox_init("status");
+	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
+	git_status_list *status;
+	git_diff_perfdata perf = GIT_DIFF_PERFDATA_INIT;
 
-	assert_show(entry_count0, entry_paths0, entry_statuses0,
-		repo, GIT_STATUS_SHOW_INDEX_AND_WORKDIR, 0);
+	opts.flags = GIT_STATUS_OPT_DEFAULTS;
 
-#ifdef GIT_TRACE
-	cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
-	cl_assert_equal_sz(5, g_diff_perf.oid_calcs);
-	cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
+	cl_git_pass(git_status_list_new(&status, repo, &opts));
+	check_status0(status);
+	cl_git_pass(git_status_list_get_perfdata(&perf, status));
+	cl_assert_equal_sz(13 + 3, perf.stat_calls);
+	cl_assert_equal_sz(5, perf.oid_calculations);
 
-	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
-#endif
+	git_status_list_free(status);
 
-	assert_show(entry_count0, entry_paths0, entry_statuses0,
-		repo, GIT_STATUS_SHOW_INDEX_AND_WORKDIR, GIT_STATUS_OPT_UPDATE_INDEX);
+	opts.flags |= GIT_STATUS_OPT_UPDATE_INDEX;
+
+	cl_git_pass(git_status_list_new(&status, repo, &opts));
+	check_status0(status);
+	cl_git_pass(git_status_list_get_perfdata(&perf, status));
+	cl_assert_equal_sz(13 + 3, perf.stat_calls);
+	cl_assert_equal_sz(5, perf.oid_calculations);
 
-#ifdef GIT_TRACE
-	cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
-	cl_assert_equal_sz(5, g_diff_perf.oid_calcs);
-	cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
+	git_status_list_free(status);
 
-	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
-#endif
+	opts.flags &= ~GIT_STATUS_OPT_UPDATE_INDEX;
 
-	assert_show(entry_count0, entry_paths0, entry_statuses0,
-		repo, GIT_STATUS_SHOW_INDEX_AND_WORKDIR, 0);
+	cl_git_pass(git_status_list_new(&status, repo, &opts));
+	check_status0(status);
+	cl_git_pass(git_status_list_get_perfdata(&perf, status));
+	cl_assert_equal_sz(13 + 3, perf.stat_calls);
+	cl_assert_equal_sz(0, perf.oid_calculations);
 
-#ifdef GIT_TRACE
-	cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
-	cl_assert_equal_sz(0, g_diff_perf.oid_calcs);
-	cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
-#endif
+	git_status_list_free(status);
 }

tests/trace/trace.c

@@ -3,49 +3,44 @@
 
 static int written = 0;
 
-static void trace_callback(
-	git_trace_level_t level,
-	void *cb_payload,
-	void *msg_payload,
-	const char *msg)
+static void trace_callback(git_trace_level_t level, const char *message)
 {
-	GIT_UNUSED(level); GIT_UNUSED(msg_payload);
+	GIT_UNUSED(level);
 
-	cl_assert(strcmp(msg, "Hello world!") == 0);
+	cl_assert(strcmp(message, "Hello world!") == 0);
 
-	if (cb_payload)
-		*((int *)cb_payload) = 1;
+	written = 1;
 }
 
 void test_trace_trace__initialize(void)
 {
-	git_trace_set(GIT_TRACE_INFO_AND_BELOW, trace_callback, &written);
+	git_trace_set(GIT_TRACE_INFO, trace_callback);
 	written = 0;
 }
 
 void test_trace_trace__cleanup(void)
 {
-	git_trace_set(GIT_TRACE_NONE, NULL, NULL);
+	git_trace_set(GIT_TRACE_NONE, NULL);
 }
 
 void test_trace_trace__sets(void)
 {
 #ifdef GIT_TRACE
-	cl_assert(git_trace_level() == GIT_TRACE_INFO_AND_BELOW);
+	cl_assert(git_trace_level() == GIT_TRACE_INFO);
 #endif
 }
 
 void test_trace_trace__can_reset(void)
 {
 #ifdef GIT_TRACE
-	cl_assert(git_trace_level() == GIT_TRACE_INFO_AND_BELOW);
-	cl_git_pass(git_trace_set(GIT_TRACE_ERROR, trace_callback, &written));
+	cl_assert(git_trace_level() == GIT_TRACE_INFO);
+	cl_git_pass(git_trace_set(GIT_TRACE_ERROR, trace_callback));
 
 	cl_assert(written == 0);
-	git_trace(GIT_TRACE_INFO, NULL, "Hello %s!", "world");
+	git_trace(GIT_TRACE_INFO, "Hello %s!", "world");
 	cl_assert(written == 0);
 
-	git_trace(GIT_TRACE_ERROR, NULL, "Hello %s!", "world");
+	git_trace(GIT_TRACE_ERROR, "Hello %s!", "world");
 	cl_assert(written == 1);
 #endif
 }
@@ -53,13 +48,13 @@ void test_trace_trace__can_reset(void)
 void test_trace_trace__can_unset(void)
 {
 #ifdef GIT_TRACE
-	cl_assert(git_trace_level() == GIT_TRACE_INFO_AND_BELOW);
-	cl_git_pass(git_trace_set(GIT_TRACE_NONE, NULL, NULL));
+	cl_assert(git_trace_level() == GIT_TRACE_INFO);
+	cl_git_pass(git_trace_set(GIT_TRACE_NONE, NULL));
 
 	cl_assert(git_trace_level() == GIT_TRACE_NONE);
 
 	cl_assert(written == 0);
-	git_trace(GIT_TRACE_FATAL, NULL, "Hello %s!", "world");
+	git_trace(GIT_TRACE_FATAL, "Hello %s!", "world");
 	cl_assert(written == 0);
 #endif
 }
@@ -68,7 +63,7 @@ void test_trace_trace__skips_higher_level(void)
 {
 #ifdef GIT_TRACE
 	cl_assert(written == 0);
-	git_trace(GIT_TRACE_DEBUG, NULL, "Hello %s!", "world");
+	git_trace(GIT_TRACE_DEBUG, "Hello %s!", "world");
 	cl_assert(written == 0);
 #endif
 }
@@ -77,7 +72,7 @@ void test_trace_trace__writes(void)
 {
 #ifdef GIT_TRACE
 	cl_assert(written == 0);
-	git_trace(GIT_TRACE_INFO, NULL, "Hello %s!", "world");
+	git_trace(GIT_TRACE_INFO, "Hello %s!", "world");
 	cl_assert(written == 1);
 #endif
 }
@@ -86,7 +81,7 @@ void test_trace_trace__writes_lower_level(void)
 {
 #ifdef GIT_TRACE
 	cl_assert(written == 0);
-	git_trace(GIT_TRACE_ERROR, NULL, "Hello %s!", "world");
+	git_trace(GIT_TRACE_ERROR, "Hello %s!", "world");
 	cl_assert(written == 1);
 #endif
 }