Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -114,6 +114,19 @@ void resetToInitialCapacity() throws IOException {
lastShrinkTime = System.currentTimeMillis();
}

long trimToInitialCapacity() {
if (closed || array.length <= initialCapacity) {
return 0;
}
long releasedBytes = accountedCapacity - initialCapacity;
array = Arrays.copyOf(array, initialCapacity);
memoryAccount.release(releasedBytes);
accountedCapacity = initialCapacity;
bufTooLargeCounter = RpcUtils.MAX_BUFFER_OVERSIZE_TIME;
lastShrinkTime = System.currentTimeMillis();
return releasedBytes;
}

@Override
public void close() {
if (!closed) {
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -21,8 +21,16 @@

import org.apache.iotdb.rpc.i18n.RpcMessages;

import org.apache.thrift.transport.TTransport;

import java.io.IOException;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;

public final class AutoResizingBufferMemoryManager {
Expand All @@ -47,6 +55,11 @@ public void release(long sizeInBytes) {
DEFAULT_MEMORY_ALLOCATE_RETRY_INTERVAL_IN_MS;
private static final AtomicLong memoryAllocationCount = new AtomicLong();
private static final AtomicLong memoryAllocationFailureCount = new AtomicLong();
private static final Set<ServerConnectionState> serverConnections = ConcurrentHashMap.newKeySet();
private static final Map<TTransport, ServerConnectionState> serverConnectionsByTransport =
new IdentityHashMap<>();
private static final Object serverConnectionLock = new Object();
private static final AtomicBoolean reclaimingServerBuffers = new AtomicBoolean();

private AutoResizingBufferMemoryManager() {
// Utility class.
Expand Down Expand Up @@ -82,6 +95,9 @@ private static void allocate(AutoResizingBufferMemoryControl memoryControl, long
memoryAllocationCount.incrementAndGet();
return;
}
if (reclaimIdleServerBuffers() > 0) {
continue;
}
try {
Thread.sleep(memoryAllocateRetryIntervalInMs);
} catch (InterruptedException e) {
Expand All @@ -98,6 +114,52 @@ private static void allocate(AutoResizingBufferMemoryControl memoryControl, long
MEMORY_ALLOCATE_MAX_RETRIES));
}

static void registerServerTransport(TElasticFramedTransport transport) {
synchronized (serverConnectionLock) {
if (transport.getServerConnectionState() != null) {
return;
}
TTransport socket = transport.getSocket();
ServerConnectionState state = serverConnectionsByTransport.get(socket);
if (state == null) {
state = new ServerConnectionState();
serverConnectionsByTransport.put(socket, state);
serverConnections.add(state);
}
state.registerTransport(transport);
transport.setServerConnectionState(state);
}
}

static void unregisterServerTransport(TElasticFramedTransport transport) {
synchronized (serverConnectionLock) {
ServerConnectionState state = transport.getServerConnectionState();
if (state == null) {
return;
}
if (state.unregisterTransport(transport)) {
serverConnections.remove(state);
serverConnectionsByTransport.remove(transport.getSocket());
}
transport.setServerConnectionState(null);
}
}

private static long reclaimIdleServerBuffers() {
if (!reclaimingServerBuffers.compareAndSet(false, true)) {
return 0;
}
try {
long reclaimedBytes = 0;
for (ServerConnectionState connection : serverConnections) {
reclaimedBytes += connection.reclaimIdleBuffers();
}
return reclaimedBytes;
} finally {
reclaimingServerBuffers.set(false);
}
}

private static void release(AutoResizingBufferMemoryControl memoryControl, long sizeInBytes) {
if (sizeInBytes <= 0) {
return;
Expand Down Expand Up @@ -140,4 +202,33 @@ void release(long sizeInBytes) {
AutoResizingBufferMemoryManager.release(memoryControl, sizeInBytes);
}
}

static final class ServerConnectionState {
private final Set<TElasticFramedTransport> transports = new HashSet<>();
private boolean requestInProgress;

private synchronized void registerTransport(TElasticFramedTransport transport) {
transports.add(transport);
}

private synchronized boolean unregisterTransport(TElasticFramedTransport transport) {
transports.remove(transport);
return transports.isEmpty();
}

synchronized void setRequestInProgress(boolean requestInProgress) {
this.requestInProgress = requestInProgress;
}

private synchronized long reclaimIdleBuffers() {
if (requestInProgress) {
return 0;
}
long reclaimedBytes = 0;
for (TElasticFramedTransport transport : transports) {
reclaimedBytes += transport.trimBuffersForReclamation();
}
return reclaimedBytes;
}
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -136,4 +136,14 @@ public void limit(int newLimit) {
public void position(int newPosition) {
this.pos = newPosition;
}

long trimToInitialCapacity() {
if (pos != limit) {
return 0;
}
temporaryBuffer = null;
pos = 0;
limit = 0;
return buf.trimToInitialCapacity();
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -177,4 +177,12 @@ public void updateKnownMessageSize(long size) throws TTransportException {
public void checkReadBytesAvailable(long numBytes) throws TTransportException {
// do Nothing
}

long trimToInitialCapacity() {
if (pos != 0) {
return 0;
}
temporaryBuffer = null;
return buf.trimToInitialCapacity();
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -77,6 +77,12 @@ protected void closeAllocatedBuffers() {
}
}

@Override
protected long trimAdditionalBuffers() {
return (writeCompressBuffer == null ? 0 : writeCompressBuffer.trimToInitialCapacity())
+ (readCompressBuffer == null ? 0 : readCompressBuffer.trimToInitialCapacity());
}

@Override
protected int getMaxWriteBufferSize() {
// Preserve the wire-size limit: a compressible payload may exceed thriftMaxFrameSize before
Expand All @@ -87,8 +93,10 @@ protected int getMaxWriteBufferSize() {
@Override
protected void readFrame() throws TTransportException {
// Discard the previous frame's budget before reading the next frame header and payload.
endServerRequest();
resetMessageSizeAndConsumedBytes();
underlying.readAll(i32buf, 0, 4);
beginServerRequest();
int size = TFramedTransport.decodeFrameSize(i32buf);
validateFrame(size);
readBuffer.fill(underlying, size);
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -146,23 +146,35 @@ private void alignUnderlyingConfiguration() throws TTransportException {
protected AutoScalingBufferWriteTransport writeBuffer;
protected final byte[] i32buf = new byte[4];
private final boolean copyBinary;
private boolean serverManaged;
private volatile AutoResizingBufferMemoryManager.ServerConnectionState serverConnectionState;

@Override
public boolean isOpen() {
return underlying.isOpen();
}

@Override
public void open() throws TTransportException {
public synchronized void open() throws TTransportException {
underlying.open();
if (serverManaged) {
AutoResizingBufferMemoryManager.registerServerTransport(this);
}
}

@Override
public void close() {
public synchronized void close() {
if (serverManaged) {
AutoResizingBufferMemoryManager.unregisterServerTransport(this);
}
try {
underlying.close();
} finally {
closeAllocatedBuffers();
try {
closeAllocatedBuffers();
} finally {
serverConnectionState = null;
}
}
}

Expand All @@ -175,6 +187,45 @@ protected void closeAllocatedBuffers() {
}
}

public synchronized void registerForServerBufferReclamation() {
serverManaged = true;
AutoResizingBufferMemoryManager.registerServerTransport(this);
}

public void beginServerRequest() {
setServerRequestInProgress(true);
}

public void endServerRequest() {
setServerRequestInProgress(false);
}

AutoResizingBufferMemoryManager.ServerConnectionState getServerConnectionState() {
return serverConnectionState;
}

void setServerConnectionState(
AutoResizingBufferMemoryManager.ServerConnectionState serverConnectionState) {
this.serverConnectionState = serverConnectionState;
}

long trimBuffersForReclamation() {
return readBuffer.trimToInitialCapacity()
+ writeBuffer.trimToInitialCapacity()
+ trimAdditionalBuffers();
}

protected long trimAdditionalBuffers() {
return 0;
}

private void setServerRequestInProgress(boolean requestInProgress) {
AutoResizingBufferMemoryManager.ServerConnectionState state = serverConnectionState;
if (state != null) {
state.setRequestInProgress(requestInProgress);
}
}

@Override
public int read(byte[] buf, int off, int len) throws TTransportException {
int got = readBuffer.read(buf, off, len);
Expand Down Expand Up @@ -233,8 +284,10 @@ public int read(byte[] buf, int off, int len) throws TTransportException {

protected void readFrame() throws TTransportException {
// Discard the previous frame's budget before reading the next frame header and payload.
endServerRequest();
resetMessageSizeAndConsumedBytes();
underlying.readAll(i32buf, 0, 4);
beginServerRequest();
int size = TFramedTransport.decodeFrameSize(i32buf);
validateFrame(size);
readBuffer.fill(underlying, size);
Expand Down
Loading
Loading