mwindow.c 5.79 KB
Newer Older
1
/*
schu committed
2
 * Copyright (C) 2009-2012 the libgit2 contributors
3
 *
Vicent Marti committed
4 5
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
6 7 8 9 10 11 12
 */

#include "common.h"
#include "mwindow.h"
#include "vector.h"
#include "fileops.h"
#include "map.h"
13
#include "global.h"
14 15 16

#define DEFAULT_WINDOW_SIZE \
	(sizeof(void*) >= 8 \
Vicent Marti committed
17
		? 1 * 1024 * 1024 * 1024 \
18 19 20
		: 32 * 1024 * 1024)

#define DEFAULT_MAPPED_LIMIT \
21
	((1024 * 1024) * (sizeof(void*) >= 8 ? 8192ULL : 256UL))
22 23

/*
24 25
 * These are the global options for mmmap limits.
 * TODO: allow the user to change these
26
 */
27 28 29 30
static struct {
	size_t window_size;
	size_t mapped_limit;
} _mw_options = {
31
	DEFAULT_WINDOW_SIZE,
32
	DEFAULT_MAPPED_LIMIT,
33 34 35 36 37 38 39 40
};

/*
 * Free all the windows in a sequence, typically because we're done
 * with the file
 */
void git_mwindow_free_all(git_mwindow_file *mwf)
{
41
	git_mwindow_ctl *ctl = &GIT_GLOBAL->mem_ctl;
42 43 44 45
	unsigned int i;
	/*
	 * Remove these windows from the global list
	 */
46 47 48
	for (i = 0; i < ctl->windowfiles.length; ++i){
		if (git_vector_get(&ctl->windowfiles, i) == mwf) {
			git_vector_remove(&ctl->windowfiles, i);
49 50 51 52
			break;
		}
	}

53 54 55
	if (ctl->windowfiles.length == 0) {
		git_vector_free(&ctl->windowfiles);
		ctl->windowfiles.contents = NULL;
56 57 58 59 60 61
	}

	while (mwf->windows) {
		git_mwindow *w = mwf->windows;
		assert(w->inuse_cnt == 0);

62 63
		ctl->mapped -= w->window_map.len;
		ctl->open_windows--;
64 65 66 67

		git_futils_mmap_free(&w->window_map);

		mwf->windows = w->next;
68
		git__free(w);
69 70 71 72 73 74
	}
}

/*
 * Check if a window 'win' contains the address 'offset'
 */
75
int git_mwindow_contains(git_mwindow *win, git_off_t offset)
76
{
77
	git_off_t win_off = win->offset;
78
	return win_off <= offset
79
		&& offset <= (git_off_t)(win_off + win->window_map.len);
80 81 82 83 84 85 86 87 88 89 90 91
}

/*
 * Find the least-recently-used window in a file
 */
void git_mwindow_scan_lru(
	git_mwindow_file *mwf,
	git_mwindow **lru_w,
	git_mwindow **lru_l)
{
	git_mwindow *w, *w_l;

92
	puts("LRU");
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
	for (w_l = NULL, w = mwf->windows; w; w = w->next) {
		if (!w->inuse_cnt) {
			/*
			 * If the current one is more recent than the last one,
			 * store it in the output parameter. If lru_w is NULL,
			 * it's the first loop, so store it as well.
			 */
			if (!*lru_w || w->last_used < (*lru_w)->last_used) {
				*lru_w = w;
				*lru_l = w_l;
			}
		}
		w_l = w;
	}
}

/*
 * Close the least recently used window. You should check to see if
 * the file descriptors need closing from time to time.
 */
113
static int git_mwindow_close_lru(git_mwindow_file *mwf)
114
{
115
	git_mwindow_ctl *ctl = &GIT_GLOBAL->mem_ctl;
116
	unsigned int i;
117
	git_mwindow *lru_w = NULL, *lru_l = NULL, **list = &mwf->windows;
118

119
	/* FIXME: Does this give us any advantage? */
120 121 122
	if(mwf->windows)
		git_mwindow_scan_lru(mwf, &lru_w, &lru_l);

123
	for (i = 0; i < ctl->windowfiles.length; ++i) {
124
		git_mwindow *last = lru_w;
125
		git_mwindow_file *cur = git_vector_get(&ctl->windowfiles, i);
126 127 128
		git_mwindow_scan_lru(cur, &lru_w, &lru_l);
		if (lru_w != last)
			list = &cur->windows;
129 130
	}

131 132 133 134
	if (!lru_w) {
		giterr_set(GITERR_OS, "Failed to close memory window. Couldn't find LRU");
		return -1;
	}
135

136 137
	ctl->mapped -= lru_w->window_map.len;
	git_futils_mmap_free(&lru_w->window_map);
138

139 140 141 142
	if (lru_l)
		lru_l->next = lru_w->next;
	else
		*list = lru_w->next;
143

144 145
	git__free(lru_w);
	ctl->open_windows--;
146

147
	return 0;
148 149
}

150 151 152 153 154
static git_mwindow *new_window(
	git_mwindow_file *mwf,
	git_file fd,
	git_off_t size,
	git_off_t offset)
155
{
156 157
	git_mwindow_ctl *ctl = &GIT_GLOBAL->mem_ctl;
	size_t walign = _mw_options.window_size / 2;
158
	git_off_t len;
159 160 161 162
	git_mwindow *w;

	w = git__malloc(sizeof(*w));
	if (w == NULL)
163
		return NULL;
164 165 166 167 168

	memset(w, 0x0, sizeof(*w));
	w->offset = (offset / walign) * walign;

	len = size - w->offset;
169 170
	if (len > (git_off_t)_mw_options.window_size)
		len = (git_off_t)_mw_options.window_size;
171

172
	ctl->mapped += (size_t)len;
173

174
	while (_mw_options.mapped_limit < ctl->mapped &&
175
			git_mwindow_close_lru(mwf) == 0) /* nop */;
176

177
	/*
178
	 * We treat _mw_options.mapped_limit as a soft limit. If we can't find a
179 180 181
	 * window to close and are above the limit, we still mmap the new
	 * window.
	 */
182

183 184 185 186
	if (git_futils_mmap_ro(&w->window_map, fd, w->offset, (size_t)len) < 0) {
		git__free(w);
		return NULL;
	}
187

188 189
	ctl->mmap_calls++;
	ctl->open_windows++;
190

191 192
	if (ctl->mapped > ctl->peak_mapped)
		ctl->peak_mapped = ctl->mapped;
193

194 195
	if (ctl->open_windows > ctl->peak_open_windows)
		ctl->peak_open_windows = ctl->open_windows;
196 197 198 199 200 201 202 203

	return w;
}

/*
 * Open a new window, closing the least recenty used until we have
 * enough space. Don't forget to add it to your list
 */
204 205 206 207
unsigned char *git_mwindow_open(
	git_mwindow_file *mwf,
	git_mwindow **cursor,
	git_off_t offset,
208
	size_t extra,
209
	unsigned int *left)
210
{
211
	git_mwindow_ctl *ctl = &GIT_GLOBAL->mem_ctl;
212 213
	git_mwindow *w = *cursor;

214

215 216 217 218 219 220
	if (!w || !git_mwindow_contains(w, offset + extra)) {
		if (w) {
			w->inuse_cnt--;
		}

		for (w = mwf->windows; w; w = w->next) {
221
			if (git_mwindow_contains(w, offset + extra)) {
222
				break;
223
			}
224 225 226 227 228 229 230
		}

		/*
		 * If there isn't a suitable window, we need to create a new
		 * one.
		 */
		if (!w) {
231
			w = new_window(mwf, mwf->fd, mwf->size, offset);
232 233 234 235 236 237 238 239 240
			if (w == NULL)
				return NULL;
			w->next = mwf->windows;
			mwf->windows = w;
		}
	}

	/* If we changed w, store it in the cursor */
	if (w != *cursor) {
241
		w->last_used = ctl->used_ctr++;
242 243 244 245 246 247 248 249
		w->inuse_cnt++;
		*cursor = w;
	}

	offset -= w->offset;
	assert(git__is_sizet(offset));

	if (left)
250
		*left = (unsigned int)(w->window_map.len - offset);
251

252
	fflush(stdout);
253 254 255 256 257
	return (unsigned char *) w->window_map.data + offset;
}

int git_mwindow_file_register(git_mwindow_file *mwf)
{
258
	git_mwindow_ctl *ctl = &GIT_GLOBAL->mem_ctl;
259

260
	if (ctl->windowfiles.length == 0 &&
261 262
		git_vector_init(&ctl->windowfiles, 8, NULL) < 0)
		return -1;
263

264
	return git_vector_insert(&ctl->windowfiles, mwf);
265 266 267 268 269 270 271 272 273 274
}

void git_mwindow_close(git_mwindow **window)
{
	git_mwindow *w = *window;
	if (w) {
		w->inuse_cnt--;
		*window = NULL;
	}
}