connectionsActive.incrementAndGet();
    }

    /**
     * Record RDMA connection closure
     */
    public void recordConnectionClosed() {
        connectionsActive.decrementAndGet();
    }

    /**
     * Record memory region allocation
     */
    public void recordMemoryRegionAllocated() {
        memoryRegionsAllocated.incrementAndGet();

     */
    static public byte[] getBuffer() {
        // Try to get from cache first - O(1) operation
        byte[] buf = bufferQueue.poll();
        if (buf != null) {
            queueSize.decrementAndGet();
            return buf;
        }

        // Validate buffer size to prevent overflow
        int bufferSize = SmbComTransaction.TRANSACTION_BUF_SIZE;
        if (bufferSize < 0 || bufferSize > MAX_BUFFER_SIZE) {

        return sendCredits.get() > 0 && state == RdmaConnectionState.ESTABLISHED;
    }

    /**
     * Consume a send credit
     */
    public void consumeSendCredit() {
        sendCredits.decrementAndGet();
    }

    /**
     * Grant a send credit
     */
    public void grantSendCredit() {
        sendCredits.incrementAndGet();
    }

    /**
     * Grant a receive credit
     */

            }
            this.connections.remove(trans);
            this.nonPooledConnections.remove(trans);
            activeConnections.decrementAndGet();
            connectionsRemoved.incrementAndGet();
        }
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbTransportPool#close()
     */
    @Override

     * @throws SmbException
     *
     * @see jcifs.SmbFileHandle#release()
     */
    @Override
    public synchronized void release() throws CIFSException {
        final long usage = this.usageCount.decrementAndGet();
        if (usage == 0) {
            closeInternal(0L, false);
        } else if (log.isTraceEnabled()) {
            log.trace(String.format("Release %s (%d)", this, usage));
        }
    }

            this.treeConnection.acquire();
        }
        return this;
    }

    @Override
    public void release() {
        final long us = this.usageCount.decrementAndGet();
        if (us == 0) {
            this.treeConnection.release();
        } else if (us < 0) {
            throw new RuntimeCIFSException("Usage count dropped below zero");
        }
    }

    }

    /**
     * Decrements the access count and returns the new value.
     * @return The decremented access count.
     */
    public long decrementAndGetAccessCount() {
        return accessCount.decrementAndGet();
    }

    /**
     * Returns the crawler status.
     * @return The CrawlerStatus.
     */
    public CrawlerStatus getStatus() {
        return status;
    }

    /**

        }

        public void incrementConnections() {
            activeConnections.incrementAndGet();
        }

        public void decrementConnections() {
            activeConnections.decrementAndGet();
        }

        public boolean isHealthy() {
            return isHealthy;
        }

        public void setHealthy(boolean healthy) {
            this.isHealthy = healthy;

                    throw (CIFSException) e;
                }
                throw new CIFSException("Circuit breaker operation failed", e);
            }
        } finally {
            activeRequests.decrementAndGet();
            if (semaphoreAcquired) {
                requestSemaphore.release();
            }
        }
    }

    /**

        release();
    }

    /**
     * Releases a reference to this transport, decrementing the usage count.
     */
    public void release() {
        final long usage = this.usageCount.decrementAndGet();
        if (log.isTraceEnabled()) {
            log.trace("Release transport " + usage + " " + this);
        }

        if (usage == 0) {
            if (log.isTraceEnabled()) {