SMBJ chunked write async

[rrj12]

I have been playing around with this library for a use case. In order to gain write/upload performance I divided my inputstream into chunks and tried to write to the SMBJ file with correct offset. I expected this change to provide good performance gain, but to my surprise the performance is same as compared to writing these chunks sequentially.

When I tried to measure the time taken for each chunks I found out that in sequential chunk write each chunk took around 1.3 secs , while the parallel chunk writes are taking upto 10-12 secs.

On further investigation I saw that the Connection.java#send is sequentialising the write requests.

     * send a packet.
     *
     * @param packet SMBPacket to send
     * @return a Future to be used to retrieve the response packet
     * @throws TransportException When a transport level error occurred
     */
    public <T extends SMB2Packet> Future<T> send(SMB2Packet packet) throws TransportException {
        lock.lock();
        Future<T> f = null;
        try {
            if (!(packet.getPacket() instanceof SMB2Cancel)) {
                int availableCredits = sequenceWindow.available();
                int grantCredits = calculateGrantedCredits(packet, availableCredits);
                if (availableCredits == 0) {
                    logger.warn(
                        "There are no credits left to send {}, will block until there are more credits available.",
                        packet.getHeader().getMessage());
                }
                long[] messageIds = sequenceWindow.get(grantCredits);
                packet.getHeader().setMessageId(messageIds[0]);
                logger.debug("Granted {} (out of {}) credits to {}", grantCredits, availableCredits, packet);
                packet.getHeader().setCreditRequest(Math
                    .max(SequenceWindow.PREFERRED_MINIMUM_CREDITS - availableCredits - grantCredits, grantCredits));

                Request request = new Request(packet.getPacket(), messageIds[0], UUID.randomUUID());
                outstandingRequests.registerOutstanding(request);
                f = request.getFuture(new CancelRequest(request, packet.getHeader().getSessionId()));
            }
            transport.write(packet);
            return f;
        } finally {
            lock.unlock();
        }
    }

Is this an expected behaviour?
Is there a way I can further improve the write performance?

File size used: 500mb
Chunk size used: 64mb
WriteApi used: File.java#writeAsync
Provider used: ArrayByteChunkProvider.java

[rrj12]

@hierynomus did you get a chance to check this? Any recommendation?

[hierynomus]

@rrj12 I've slightly changed the locks, but I don't expect that to give a humongous ROI... However have you tried configuring the async transport layer using: config.withTransportLayerFactory(new AsyncDirectTcpTransportFactory());?

[rohil-raj]

@hierynomus yes, I did configure the async transport layer in my benchmark. The performance results were inclusive of it.

[hierynomus]

Did you try with the improved locking? Did this make a difference?