1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
/*
* Copyright (C) 2011, Google Inc. and others
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Distribution License v. 1.0 which is available at
* https://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
package org.eclipse.jgit.internal.storage.dfs;
import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_CORE_SECTION;
import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_DFS_SECTION;
import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_DELTA_BASE_CACHE_LIMIT;
import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_LOAD_REV_INDEX_IN_PARALLEL;
import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_STREAM_BUFFER;
import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_STREAM_FILE_THRESHOLD;
import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_USE_OBJECT_SIZE_INDEX;
import org.eclipse.jgit.lib.Config;
import org.eclipse.jgit.storage.pack.PackConfig;
/**
* Options controlling how objects are read from a DFS stored repository.
*/
public class DfsReaderOptions {
/** 1024 (number of bytes in one kibibyte/kilobyte) */
public static final int KiB = 1024;
/** 1024 {@link #KiB} (number of bytes in one mebibyte/megabyte) */
public static final int MiB = 1024 * KiB;
private int deltaBaseCacheLimit;
private int streamFileThreshold;
private int streamPackBufferSize;
private boolean loadRevIndexInParallel;
private boolean useObjectSizeIndex;
/**
* Create a default reader configuration.
*/
public DfsReaderOptions() {
setDeltaBaseCacheLimit(10 * MiB);
setStreamFileThreshold(PackConfig.DEFAULT_BIG_FILE_THRESHOLD);
}
/**
* Get maximum number of bytes to hold in per-reader DeltaBaseCache.
*
* @return maximum number of bytes to hold in per-reader DeltaBaseCache.
*/
public int getDeltaBaseCacheLimit() {
return deltaBaseCacheLimit;
}
/**
* Set the maximum number of bytes in the DeltaBaseCache.
*
* @param maxBytes
* the new limit.
* @return {@code this}
*/
public DfsReaderOptions setDeltaBaseCacheLimit(int maxBytes) {
deltaBaseCacheLimit = Math.max(0, maxBytes);
return this;
}
/**
* Get the size threshold beyond which objects must be streamed.
*
* @return the size threshold beyond which objects must be streamed.
*/
public int getStreamFileThreshold() {
return streamFileThreshold;
}
/**
* Set new byte limit for objects that must be streamed.
*
* @param newLimit
* new byte limit for objects that must be streamed. Objects
* smaller than this size can be obtained as a contiguous byte
* array, while objects bigger than this size require using an
* {@link org.eclipse.jgit.lib.ObjectStream}.
* @return {@code this}
*/
public DfsReaderOptions setStreamFileThreshold(int newLimit) {
streamFileThreshold = Math.max(0, newLimit);
return this;
}
/**
* Get number of bytes to use for buffering when streaming a pack file
* during copying.
*
* @return number of bytes to use for buffering when streaming a pack file
* during copying. If 0 the block size of the pack is used.
*/
public int getStreamPackBufferSize() {
return streamPackBufferSize;
}
/**
* Set new buffer size in bytes for buffers used when streaming pack files
* during copying.
*
* @param bufsz
* new buffer size in bytes for buffers used when streaming pack
* files during copying.
* @return {@code this}
*/
public DfsReaderOptions setStreamPackBufferSize(int bufsz) {
streamPackBufferSize = Math.max(0, bufsz);
return this;
}
/**
* Check if reverse index should be loaded in parallel.
*
* @return true if reverse index is loaded in parallel for bitmap index.
*/
public boolean shouldLoadRevIndexInParallel() {
return loadRevIndexInParallel;
}
/**
* Enable (or disable) parallel loading of reverse index.
*
* @param loadRevIndexInParallel
* whether to load reverse index in parallel.
* @return {@code this}
*/
public DfsReaderOptions setLoadRevIndexInParallel(
boolean loadRevIndexInParallel) {
this.loadRevIndexInParallel = loadRevIndexInParallel;
return this;
}
/**
* Use the object size index if available.
*
* @return true if the reader should try to use the object size index. if
* false, the reader ignores that index.
*/
public boolean shouldUseObjectSizeIndex() {
return useObjectSizeIndex;
}
/**
* Set if the reader should try to use the object size index
*
* @param useObjectSizeIndex true to use it, false to ignore the object size index
*
* @return {@code this}
*/
public DfsReaderOptions setUseObjectSizeIndex(boolean useObjectSizeIndex) {
this.useObjectSizeIndex = useObjectSizeIndex;
return this;
}
/**
* Update properties by setting fields from the configuration.
* <p>
* If a property is not defined in the configuration, then it is left
* unmodified.
*
* @param rc
* configuration to read properties from.
* @return {@code this}
*/
public DfsReaderOptions fromConfig(Config rc) {
setDeltaBaseCacheLimit(rc.getInt(
CONFIG_CORE_SECTION,
CONFIG_DFS_SECTION,
CONFIG_KEY_DELTA_BASE_CACHE_LIMIT,
getDeltaBaseCacheLimit()));
long maxMem = Runtime.getRuntime().maxMemory();
long sft = rc.getLong(
CONFIG_CORE_SECTION,
CONFIG_DFS_SECTION,
CONFIG_KEY_STREAM_FILE_THRESHOLD,
getStreamFileThreshold());
sft = Math.min(sft, maxMem / 4); // don't use more than 1/4 of the heap
sft = Math.min(sft, Integer.MAX_VALUE); // cannot exceed array length
setStreamFileThreshold((int) sft);
setStreamPackBufferSize(rc.getInt(
CONFIG_CORE_SECTION,
CONFIG_DFS_SECTION,
CONFIG_KEY_STREAM_BUFFER,
getStreamPackBufferSize()));
setUseObjectSizeIndex(rc.getBoolean(CONFIG_CORE_SECTION,
CONFIG_DFS_SECTION, CONFIG_KEY_USE_OBJECT_SIZE_INDEX,
false));
setLoadRevIndexInParallel(
rc.getBoolean(CONFIG_CORE_SECTION, CONFIG_DFS_SECTION,
CONFIG_KEY_LOAD_REV_INDEX_IN_PARALLEL, false));
return this;
}
}
|
