bytesTransferred.addAndGet(bytes);
        totalSendTime.addAndGet(durationNanos);
    }

    /**
     * Record an RDMA receive operation
     *
     * @param bytes number of bytes received
     * @param durationNanos operation duration in nanoseconds
     */
    public void recordRdmaReceive(int bytes, long durationNanos) {
        rdmaReceives.incrementAndGet();
        bytesTransferred.addAndGet(bytes);

                        long start = System.nanoTime();
                        mockBytesEncrypted.addAndGet(1024); // Simulate 1KB message
                        long end = System.nanoTime();

                        totalTime.addAndGet(end - start);
                        operations.incrementAndGet();
                    }
                } catch (InterruptedException e) {

   */
  @CanIgnoreReturnValue
  public long incrementAndGet(K key) {
    return addAndGet(key, 1);
  }

  /**
   * Decrements by one the value currently associated with {@code key}, and returns the new value.
   */
  @CanIgnoreReturnValue
  public long decrementAndGet(K key) {
    return addAndGet(key, -1);
  }

  /**

    assertFalse(map.containsKey(key));

    assertEquals(value, map.addAndGet(key, value));
    assertEquals(value, map.get(key));

    assertEquals(0L, map.addAndGet(key, -1 * value));
    assertEquals(0L, map.get(key));
    assertTrue(map.containsKey(key));

    assertEquals(value, map.addAndGet(key, value));
    assertEquals(value, map.get(key));
  }

  public void testGetAndAdd() {

     *
     * @param bytes number of bytes
     */
    public void addBytesSent(long bytes) {
        bytesSent.addAndGet(bytes);
    }

    /**
     * Add bytes received
     *
     * @param bytes number of bytes
     */
    public void addBytesReceived(long bytes) {
        bytesReceived.addAndGet(bytes);
    }

    /**
     * Increment requests sent counter
     */

       */
      int frequency = requireNonNull(currentEntry).getValue().get();
      if (frequency <= 0) {
        throw new ConcurrentModificationException();
      }
      if (currentEntry.getValue().addAndGet(-1) == 0) {
        entryIterator.remove();
      }
      size--;
      canRemove = false;
    }
  }

  @Override
  public int count(@Nullable Object element) {

    
    public void recordRdmaRead(int bytes) {
        rdmaReads.incrementAndGet();
        bytesTransferred.addAndGet(bytes);
    }
    
    public void recordRdmaWrite(int bytes) {
        rdmaWrites.incrementAndGet();
        bytesTransferred.addAndGet(bytes);
    }
    
    public void recordError() {
        operationErrors.incrementAndGet();
    }
    

                                allUrls.add(polled.getUrl());
                            }
                        }
                    }
                    totalPolled.addAndGet(count);
                } catch (final InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    doneLatch.countDown();
                }

            k -> new ChannelStatistics());
            
        stats.operations.incrementAndGet();
        stats.latencyTotal.addAndGet(latency);
        
        if (success) {
            stats.bytesReceived.addAndGet(bytes);
        } else {
            stats.errors.incrementAndGet();
        }
    }
    
    public double getAggregatedThroughput() {

          public void onRemoval(RemovalNotification<Integer, AtomicInteger> notification) {
            if (notification.wasEvicted()) {
              evictionCount.incrementAndGet();
              totalSum.addAndGet(notification.getValue().get());
            }
          }
        };

    CacheLoader<Integer, AtomicInteger> loader =
        new CacheLoader<Integer, AtomicInteger>() {
          @Override