Long transferred;
        synchronized (transfers) {
            transferred = transfers.get(transferEvent.getResource());
            if (transferred == null) {
                transferred = (long) length;
            } else {
                transferred = transferred + length;
            }
            transfers.put(transferEvent.getResource(), transferred);
        }

    /**
     * The number of <b>content</b> bytes read.
     * <p>
     * This is not guaranteed to be the number of bytes <b>transferred</b>.
     * For example, this resource may be content encoded (e.g. compression, fewer bytes transferred).
     * Or, it might be transfer encoded (e.g. HTTP chunked transfer, more bytes transferred).
     * Or, both.
     * Therefore, it is not necessarily an accurate input into transfer rate (a.k.a. throughput) calculations.

			// the ENOSYS case above, if we see EXDEV, we have
			// not transferred any data, and we can let the caller
			// fall back to generic code.
			//
			// As for EINVAL, that is what we see if, for example,
			// dst or src refer to a pipe rather than a regular
			// file. This is another case where no data has been
			// transferred, so we consider it unhandled.
			//
			// If src and dst are on CIFS, we can see EIO.

   *
   * @param q the blocking queue to be drained
   * @param buffer where to add the transferred elements
   * @param numElements the number of elements to be waited for
   * @param timeout how long to wait before giving up
   * @return the number of elements transferred
   * @throws InterruptedException if interrupted while waiting
   * @since 28.0
   */
  @CanIgnoreReturnValue

// Transfers up to `size` bytes from `dst_fd` to `src_fd`.
//
// This method uses `sendfile` if available (i.e., linux 2.6.33 or later) or an
// intermediate buffer if not.
//
// Returns number of bytes transferred or -1 on failure.
int CopyFileContents(int dst_fd, int src_fd, off_t size);

}  // namespace tf_posix_filesystem

        this.bytesWritten = bytesWritten;
    }

    /**
     * The number of content bytes written. This is not necessarily the same as the number of bytes transferred.
     */
    long getBytesWritten() {
        return bytesWritten;
    }

constexpr float kDequantCost = 2.0;
constexpr float kQuantCost = 2.0;
constexpr float kRequantCost = 2.0;

// TODO(renjieliu): Ideally this should consider different kinds of SOCs as
// well.

// Get total bytes transferred.
int64_t GetTransferredTensorBytes(func::CallOp from_graph,
                                  func::CallOp to_graph) {
  int64_t total_size_transferred = 0;
  for (auto input : to_graph.getOperands()) {

    const QuantizationConfig& user_provided_config);

// Returns a copy of `QuantizationConfig` where presets are expanded and
// transformed into other fields in `QuantizationConfig`.
//
// The expansion rules are as follows:
// * StaticRangePtqPreset
//   - The preset's `representative_datasets` field will be transferred to
//   `QuantizationConfig.calibration_options.representative_datasets`, unless

   * @param q the blocking queue to be drained
   * @param buffer where to add the transferred elements
   * @param numElements the number of elements to be waited for
   * @param timeout how long to wait before giving up, in units of {@code unit}
   * @param unit a {@code TimeUnit} determining how to interpret the timeout parameter
   * @return the number of elements transferred
   * @throws InterruptedException if interrupted while waiting
   */

import org.gradle.internal.remote.internal.inet.MultiChoiceAddress;
import org.gradle.process.internal.worker.WorkerProcessContext;

import java.io.Serializable;

/**
 * All configuration options to be transferred to a worker process during worker startup.
 */
public class WorkerConfig {
    private final LogLevel logLevel;
    private final boolean publishJvmMemoryInfo;
    private final String gradleUserHomeDirPath;