1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.hadoop.hbase.util;
20
21 import java.nio.ByteBuffer;
22 import java.util.concurrent.locks.Lock;
23 import java.util.concurrent.locks.ReentrantLock;
24
25 import org.apache.commons.logging.Log;
26 import org.apache.commons.logging.LogFactory;
27 import org.apache.hadoop.classification.InterfaceAudience;
28 import org.apache.hadoop.util.StringUtils;
29
30
31
32
33
34
35 @InterfaceAudience.Private
36 public final class ByteBufferArray {
37 static final Log LOG = LogFactory.getLog(ByteBufferArray.class);
38
39 static final int DEFAULT_BUFFER_SIZE = 4 * 1024 * 1024;
40 private ByteBuffer buffers[];
41 private Lock locks[];
42 private int bufferSize;
43 private int bufferCount;
44
45
46
47
48
49
50
51
52 public ByteBufferArray(long capacity, boolean directByteBuffer) {
53 this.bufferSize = DEFAULT_BUFFER_SIZE;
54 if (this.bufferSize > (capacity / 16))
55 this.bufferSize = (int) roundUp(capacity / 16, 32768);
56 this.bufferCount = (int) (roundUp(capacity, bufferSize) / bufferSize);
57 LOG.info("Allocating buffers total=" + StringUtils.byteDesc(capacity)
58 + " , sizePerBuffer=" + StringUtils.byteDesc(bufferSize) + ", count="
59 + bufferCount);
60 buffers = new ByteBuffer[bufferCount + 1];
61 locks = new Lock[bufferCount + 1];
62 for (int i = 0; i <= bufferCount; i++) {
63 locks[i] = new ReentrantLock();
64 if (i < bufferCount) {
65 buffers[i] = directByteBuffer ? ByteBuffer.allocateDirect(bufferSize)
66 : ByteBuffer.allocate(bufferSize);
67 } else {
68 buffers[i] = ByteBuffer.allocate(0);
69 }
70
71 }
72 }
73
74 private long roundUp(long n, long to) {
75 return ((n + to - 1) / to) * to;
76 }
77
78
79
80
81
82
83
84 public void getMultiple(long start, int len, byte[] dstArray) {
85 getMultiple(start, len, dstArray, 0);
86 }
87
88
89
90
91
92
93
94
95
96 public void getMultiple(long start, int len, byte[] dstArray, int dstOffset) {
97 multiple(start, len, dstArray, dstOffset, new Visitor() {
98 public void visit(ByteBuffer bb, byte[] array, int arrayIdx, int len) {
99 bb.get(array, arrayIdx, len);
100 }
101 });
102 }
103
104
105
106
107
108
109
110 public void putMultiple(long start, int len, byte[] srcArray) {
111 putMultiple(start, len, srcArray, 0);
112 }
113
114
115
116
117
118
119
120
121
122 public void putMultiple(long start, int len, byte[] srcArray, int srcOffset) {
123 multiple(start, len, srcArray, srcOffset, new Visitor() {
124 public void visit(ByteBuffer bb, byte[] array, int arrayIdx, int len) {
125 bb.put(array, arrayIdx, len);
126 }
127 });
128 }
129
130 private interface Visitor {
131
132
133
134
135
136
137
138
139
140 void visit(ByteBuffer bb, byte[] array, int arrayOffset, int len);
141 }
142
143
144
145
146
147
148
149
150
151
152
153
154 void multiple(long start, int len, byte[] array, int arrayOffset, Visitor visitor) {
155 assert len >= 0;
156 long end = start + len;
157 int startBuffer = (int) (start / bufferSize), startOffset = (int) (start % bufferSize);
158 int endBuffer = (int) (end / bufferSize), endOffset = (int) (end % bufferSize);
159 assert array.length >= len + arrayOffset;
160 assert startBuffer >= 0 && startBuffer < bufferCount;
161 assert endBuffer >= 0 && endBuffer < bufferCount
162 || (endBuffer == bufferCount && endOffset == 0);
163 if (startBuffer >= locks.length || startBuffer < 0) {
164 String msg = "Failed multiple, start=" + start + ",startBuffer="
165 + startBuffer + ",bufferSize=" + bufferSize;
166 LOG.error(msg);
167 throw new RuntimeException(msg);
168 }
169 int srcIndex = 0, cnt = -1;
170 for (int i = startBuffer; i <= endBuffer; ++i) {
171 Lock lock = locks[i];
172 lock.lock();
173 try {
174 ByteBuffer bb = buffers[i];
175 if (i == startBuffer) {
176 cnt = bufferSize - startOffset;
177 if (cnt > len) cnt = len;
178 bb.limit(startOffset + cnt).position(
179 startOffset );
180 } else if (i == endBuffer) {
181 cnt = endOffset;
182 bb.limit(cnt).position(0);
183 } else {
184 cnt = bufferSize ;
185 bb.limit(cnt).position(0);
186 }
187 visitor.visit(bb, array, srcIndex + arrayOffset, cnt);
188 srcIndex += cnt;
189 } finally {
190 lock.unlock();
191 }
192 }
193 assert srcIndex == len;
194 }
195 }