@libp2p/perf 1.1.15-dfbe0cc0 → 2.0.0-fb8a6f188

package/dist/src/perf-service.js

@@ -0,0 +1,169 @@
+import { logger } from '@libp2p/logger';
+import { pushable } from 'it-pushable';
+import { MAX_INBOUND_STREAMS, MAX_OUTBOUND_STREAMS, PROTOCOL_NAME, RUN_ON_TRANSIENT_CONNECTION, WRITE_BLOCK_SIZE } from './constants.js';
+const log = logger('libp2p:perf');
+export class PerfService {
+    protocol;
+    components;
+    started;
+    databuf;
+    writeBlockSize;
+    maxInboundStreams;
+    maxOutboundStreams;
+    runOnTransientConnection;
+    constructor(components, init = {}) {
+        this.components = components;
+        this.started = false;
+        this.protocol = init.protocolName ?? PROTOCOL_NAME;
+        this.writeBlockSize = init.writeBlockSize ?? WRITE_BLOCK_SIZE;
+        this.databuf = new ArrayBuffer(this.writeBlockSize);
+        this.maxInboundStreams = init.maxInboundStreams ?? MAX_INBOUND_STREAMS;
+        this.maxOutboundStreams = init.maxOutboundStreams ?? MAX_OUTBOUND_STREAMS;
+        this.runOnTransientConnection = init.runOnTransientConnection ?? RUN_ON_TRANSIENT_CONNECTION;
+    }
+    async start() {
+        await this.components.registrar.handle(this.protocol, (data) => {
+            void this.handleMessage(data).catch((err) => {
+                log.error('error handling perf protocol message', err);
+            });
+        }, {
+            maxInboundStreams: this.maxInboundStreams,
+            maxOutboundStreams: this.maxOutboundStreams,
+            runOnTransientConnection: this.runOnTransientConnection
+        });
+        this.started = true;
+    }
+    async stop() {
+        await this.components.registrar.unhandle(this.protocol);
+        this.started = false;
+    }
+    isStarted() {
+        return this.started;
+    }
+    async handleMessage(data) {
+        const { stream } = data;
+        try {
+            const writeBlockSize = this.writeBlockSize;
+            let bytesToSendBack;
+            for await (const buf of stream.source) {
+                if (bytesToSendBack == null) {
+                    // downcast 64 to 52 bits to avoid bigint arithmetic performance penalty
+                    bytesToSendBack = Number(buf.getBigUint64(0, false));
+                }
+                // Ingest all the bufs and wait for the read side to close
+            }
+            if (bytesToSendBack == null) {
+                throw new Error('bytesToSendBack was not set');
+            }
+            const uint8Buf = new Uint8Array(this.databuf);
+            await stream.sink(async function* () {
+                while (bytesToSendBack > 0) {
+                    let toSend = writeBlockSize;
+                    if (toSend > bytesToSendBack) {
+                        toSend = bytesToSendBack;
+                    }
+                    bytesToSendBack = bytesToSendBack - toSend;
+                    yield uint8Buf.subarray(0, toSend);
+                }
+            }());
+        }
+        catch (err) {
+            stream.abort(err);
+        }
+    }
+    async *measurePerformance(ma, sendBytes, receiveBytes, options = {}) {
+        log('opening stream on protocol %s to %a', this.protocol, ma);
+        const uint8Buf = new Uint8Array(this.databuf);
+        const writeBlockSize = this.writeBlockSize;
+        // start time should include connection establishment
+        const initialStartTime = Date.now();
+        const connection = await this.components.connectionManager.openConnection(ma, {
+            ...options,
+            force: options.reuseExistingConnection !== true
+        });
+        const stream = await connection.newStream(this.protocol, options);
+        let lastAmountOfBytesSent = 0;
+        let lastReportedTime = Date.now();
+        let totalBytesSent = 0;
+        // tell the remote how many bytes we will send. Up cast to 64 bit number
+        // as if we send as ui32 we limit total transfer size to 4GB
+        const view = new DataView(this.databuf);
+        view.setBigUint64(0, BigInt(receiveBytes), false);
+        log('sending %i bytes to %p', sendBytes, connection.remotePeer);
+        try {
+            const sendOutput = pushable({
+                objectMode: true
+            });
+            void stream.sink(async function* () {
+                // Send the number of bytes to receive
+                yield uint8Buf.subarray(0, 8);
+                while (sendBytes > 0) {
+                    options.signal?.throwIfAborted();
+                    let toSend = writeBlockSize;
+                    if (toSend > sendBytes) {
+                        toSend = sendBytes;
+                    }
+                    sendBytes = sendBytes - toSend;
+                    yield uint8Buf.subarray(0, toSend);
+                    if (Date.now() - lastReportedTime > 1000) {
+                        sendOutput.push({
+                            type: 'intermediary',
+                            timeSeconds: (Date.now() - lastReportedTime) / 1000,
+                            uploadBytes: lastAmountOfBytesSent,
+                            downloadBytes: 0
+                        });
+                        // record last reported time after `console.log` because it can
+                        // affect benchmark timings
+                        lastReportedTime = Date.now();
+                        lastAmountOfBytesSent = 0;
+                    }
+                    lastAmountOfBytesSent += toSend;
+                    totalBytesSent += toSend;
+                }
+                sendOutput.end();
+            }())
+                .catch(err => {
+                sendOutput.end(err);
+            });
+            yield* sendOutput;
+            // Read the received bytes
+            let lastAmountOfBytesReceived = 0;
+            lastReportedTime = Date.now();
+            let totalBytesReceived = 0;
+            for await (const buf of stream.source) {
+                options.signal?.throwIfAborted();
+                if (Date.now() - lastReportedTime > 1000) {
+                    yield {
+                        type: 'intermediary',
+                        timeSeconds: (Date.now() - lastReportedTime) / 1000,
+                        uploadBytes: 0,
+                        downloadBytes: lastAmountOfBytesReceived
+                    };
+                    // record last reported time after `console.log` because it can
+                    // affect benchmark timings
+                    lastReportedTime = Date.now();
+                    lastAmountOfBytesReceived = 0;
+                }
+                lastAmountOfBytesReceived += buf.byteLength;
+                totalBytesReceived += buf.byteLength;
+            }
+            if (totalBytesReceived !== receiveBytes) {
+                throw new Error(`Expected to receive ${receiveBytes} bytes, but received ${totalBytesReceived}`);
+            }
+            yield {
+                type: 'final',
+                timeSeconds: (Date.now() - initialStartTime) / 1000,
+                uploadBytes: totalBytesSent,
+                downloadBytes: totalBytesReceived
+            };
+            log('performed %s to %p', this.protocol, connection.remotePeer);
+            await stream.close();
+        }
+        catch (err) {
+            log('error sending %s bytes to %p: %s', totalBytesSent, connection.remotePeer, err);
+            stream.abort(err);
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=perf-service.js.map

package/dist/src/perf-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"perf-service.js","sourceRoot":"","sources":["../../src/perf-service.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/perf",
-  "version": "1.1.15-dfbe0cc0",
+  "version": "2.0.0-fb8a6f188",
   "description": "Implementation of Perf Protocol",
   "author": "@maschad / @marcopolo",
   "license": "Apache-2.0 OR MIT",
@@ -48,22 +48,17 @@
     "renderResults": "node dist/src/renderResults.js"
   },
   "dependencies": {
-    "@chainsafe/libp2p-noise": "^13.0.0",
-    "@chainsafe/libp2p-yamux": "^5.0.0",
-    "@libp2p/crypto": "2.0.7-dfbe0cc0",
-    "@libp2p/interface": "0.1.5-dfbe0cc0",
-    "@libp2p/interface-compliance-tests": "4.1.3-dfbe0cc0",
-    "@libp2p/interface-internal": "0.1.8-dfbe0cc0",
-    "@libp2p/interfaces": "3.3.2",
-    "@libp2p/logger": "3.0.5-dfbe0cc0",
-    "@libp2p/peer-id-factory": "3.0.7-dfbe0cc0",
-    "@libp2p/tcp": "8.0.11-dfbe0cc0",
-    "@multiformats/multiaddr": "^12.1.5",
-    "libp2p": "0.46.18-dfbe0cc0",
-    "uint8arrays": "^4.0.6",
-    "yargs": "^17.7.2"
+    "@libp2p/interface": "0.1.5-fb8a6f188",
+    "@libp2p/interface-internal": "0.1.8-fb8a6f188",
+    "@libp2p/logger": "3.0.5-fb8a6f188",
+    "@multiformats/multiaddr": "^12.1.10",
+    "it-pushable": "^3.2.1"
   },
   "devDependencies": {
-    "aegir": "^41.0.2"
+    "@libp2p/interface-compliance-tests": "4.1.4-fb8a6f188",
+    "aegir": "^41.0.2",
+    "it-last": "^3.0.3",
+    "it-pair": "^2.0.6",
+    "sinon-ts": "^2.0.0"
   }
 }

package/src/constants.ts

@@ -1,2 +1,5 @@
 export const PROTOCOL_NAME = '/perf/1.0.0'
-export const WRITE_BLOCK_SIZE = BigInt(64 << 10)
+export const WRITE_BLOCK_SIZE = 64 << 10
+export const MAX_INBOUND_STREAMS = 1
+export const MAX_OUTBOUND_STREAMS = 1
+export const RUN_ON_TRANSIENT_CONNECTION = false

package/src/index.ts

@@ -1,71 +1,95 @@
 /**
  * @packageDocumentation
  *
- * The `performanceService` implements the [perf protocol](https://github.com/libp2p/specs/blob/master/perf/perf.md), which is used to measure performance within and across libp2p implementations
- * addresses.
+ * The {@link PerfService} implements the [perf protocol](https://github.com/libp2p/specs/blob/master/perf/perf.md), which can be used to measure transfer performance within and across libp2p implementations.
  *
  * @example
  *
  * ```typescript
- * import { createLibp2p } from 'libp2p'
- * import { perfService } from '@libp2p/perf'
+ * import { noise } from '@chainsafe/libp2p-noise'
+ * import { yamux } from '@chainsafe/libp2p-yamux'
+ * import { mplex } from '@libp2p/mplex'
+ * import { tcp } from '@libp2p/tcp'
+ * import { createLibp2p, type Libp2p } from 'libp2p'
+ * import { plaintext } from 'libp2p/insecure'
+ * import { perfService, type PerfService } from '@libp2p/perf'
  *
- * const node = await createLibp2p({
- *   service: [
- *     perfService()
- *   ]
- * })
- * ```
- *
- * The `measurePerformance` function can be used to measure the latency and throughput of a connection.
- * server.  This will not work in browsers.
+ * const ONE_MEG = 1024 * 1024
+ * const UPLOAD_BYTES = ONE_MEG * 1024
+ * const DOWNLOAD_BYTES = ONE_MEG * 1024
  *
- * @example
- *
- * ```typescript
- * import { createLibp2p } from 'libp2p'
- * import { perfService } from 'libp2p/perf'
+ * async function createNode (): Promise<Libp2p<{ perf: PerfService }>> {
+ *   return createLibp2p({
+ *     addresses: {
+ *       listen: [
+ *         '/ip4/0.0.0.0/tcp/0'
+ *       ]
+ *     },
+ *     transports: [
+ *       tcp()
+ *     ],
+ *     connectionEncryption: [
+ *       noise(), plaintext()
+ *     ],
+ *     streamMuxers: [
+ *       yamux(), mplex()
+ *     ],
+ *     services: {
+ *       perf: perfService()
+ *     }
+ *   })
+ * }
  *
- * const node = await createLibp2p({
- *   services: [
- *     perf: perfService()
- *   ]
- * })
+ * const libp2p1 = await createNode()
+ * const libp2p2 = await createNode()
  *
- * const connection = await node.dial(multiaddr(multiaddrAddress))
- *
- * const startTime = Date.now()
- *
- * await node.services.perf.measurePerformance(startTime, connection, BigInt(uploadBytes), BigInt(downloadBytes))
+ * for await (const output of libp2p1.services.perf.measurePerformance(libp2p2.getMultiaddrs()[0], UPLOAD_BYTES, DOWNLOAD_BYTES)) {
+ *   console.info(output)
+ * }
  *
+ * await libp2p1.stop()
+ * await libp2p2.stop()
  * ```
  */
 
-import { logger } from '@libp2p/logger'
-import { PROTOCOL_NAME, WRITE_BLOCK_SIZE } from './constants.js'
-import type { Connection } from '@libp2p/interface/connection'
-import type { Startable } from '@libp2p/interface/startable'
+import { PerfService as PerfServiceClass } from './perf-service.js'
+import type { AbortOptions } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
-import type { IncomingStreamData, Registrar } from '@libp2p/interface-internal/registrar'
-import type { AbortOptions } from '@libp2p/interfaces'
-
-const log = logger('libp2p:perf')
-
-export const defaultInit: PerfServiceInit = {
-  protocolName: '/perf/1.0.0',
-  writeBlockSize: BigInt(64 << 10)
+import type { Registrar } from '@libp2p/interface-internal/registrar'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+export interface PerfOptions extends AbortOptions {
+  /**
+   * By default measuring perf should include the time it takes to establish a
+   * connection, so a new connection will be opened for every performance run.
+   *
+   * To override this and re-use an existing connection if one is present, pass
+   * `true` here. (default: false)
+   */
+  reuseExistingConnection?: boolean
 }
 
 export interface PerfService {
-  measurePerformance(startTime: number, connection: Connection, sendBytes: bigint, recvBytes: bigint, options?: AbortOptions): Promise<number>
+  measurePerformance(multiaddr: Multiaddr, sendBytes: number, recvBytes: number, options?: PerfOptions): AsyncGenerator<PerfOutput>
+}
+
+export interface PerfOutput {
+  type: 'intermediary' | 'final'
+  timeSeconds: number
+  uploadBytes: number
+  downloadBytes: number
 }
 
 export interface PerfServiceInit {
   protocolName?: string
   maxInboundStreams?: number
   maxOutboundStreams?: number
-  timeout?: number
-  writeBlockSize?: bigint
+  runOnTransientConnection?: boolean
+
+  /**
+   * Data sent/received will be sent in chunks of this size (default: 64KiB)
+   */
+  writeBlockSize?: number
 }
 
 export interface PerfServiceComponents {
@@ -73,122 +97,6 @@ export interface PerfServiceComponents {
   connectionManager: ConnectionManager
 }
 
-class DefaultPerfService implements Startable, PerfService {
-  public readonly protocol: string
-  private readonly components: PerfServiceComponents
-  private started: boolean
-  private readonly databuf: ArrayBuffer
-  private readonly writeBlockSize: bigint
-
-  constructor (components: PerfServiceComponents, init: PerfServiceInit) {
-    this.components = components
-    this.started = false
-    this.protocol = init.protocolName ?? PROTOCOL_NAME
-    this.writeBlockSize = init.writeBlockSize ?? WRITE_BLOCK_SIZE
-    this.databuf = new ArrayBuffer(Number(init.writeBlockSize))
-  }
-
-  async start (): Promise<void> {
-    await this.components.registrar.handle(this.protocol, (data: IncomingStreamData) => {
-      void this.handleMessage(data).catch((err) => {
-        log.error('error handling perf protocol message', err)
-      })
-    })
-    this.started = true
-  }
-
-  async stop (): Promise<void> {
-    await this.components.registrar.unhandle(this.protocol)
-    this.started = false
-  }
-
-  isStarted (): boolean {
-    return this.started
-  }
-
-  async handleMessage (data: IncomingStreamData): Promise<void> {
-    const { stream } = data
-
-    const writeBlockSize = this.writeBlockSize
-
-    let bytesToSendBack: bigint | null = null
-
-    for await (const buf of stream.source) {
-      if (bytesToSendBack === null) {
-        bytesToSendBack = BigInt(buf.getBigUint64(0, false))
-      }
-      // Ingest all the bufs and wait for the read side to close
-    }
-
-    const uint8Buf = new Uint8Array(this.databuf)
-
-    if (bytesToSendBack === null) {
-      throw new Error('bytesToSendBack was not set')
-    }
-
-    await stream.sink(async function * () {
-      while (bytesToSendBack > 0n) {
-        let toSend: bigint = writeBlockSize
-        if (toSend > bytesToSendBack) {
-          toSend = bytesToSendBack
-        }
-        bytesToSendBack = bytesToSendBack - toSend
-        yield uint8Buf.subarray(0, Number(toSend))
-      }
-    }())
-  }
-
-  async measurePerformance (startTime: number, connection: Connection, sendBytes: bigint, recvBytes: bigint, options: AbortOptions = {}): Promise<number> {
-    log('opening stream on protocol %s to %p', this.protocol, connection.remotePeer)
-
-    const uint8Buf = new Uint8Array(this.databuf)
-
-    const writeBlockSize = this.writeBlockSize
-
-    const stream = await connection.newStream([this.protocol], options)
-
-    // Convert sendBytes to uint64 big endian buffer
-    const view = new DataView(this.databuf)
-    view.setBigInt64(0, recvBytes, false)
-
-    log('sending %i bytes to %p', sendBytes, connection.remotePeer)
-    try {
-      await stream.sink((async function * () {
-        // Send the number of bytes to receive
-        yield uint8Buf.subarray(0, 8)
-        // Send the number of bytes to send
-        while (sendBytes > 0n) {
-          let toSend: bigint = writeBlockSize
-          if (toSend > sendBytes) {
-            toSend = sendBytes
-          }
-          sendBytes = sendBytes - toSend
-          yield uint8Buf.subarray(0, Number(toSend))
-        }
-      })())
-
-      // Read the received bytes
-      let actualRecvdBytes = BigInt(0)
-      for await (const buf of stream.source) {
-        actualRecvdBytes += BigInt(buf.length)
-      }
-
-      if (actualRecvdBytes !== recvBytes) {
-        throw new Error(`Expected to receive ${recvBytes} bytes, but received ${actualRecvdBytes}`)
-      }
-    } catch (err) {
-      log('error sending %i bytes to %p: %s', sendBytes, connection.remotePeer, err)
-      throw err
-    } finally {
-      log('performed %s to %p', this.protocol, connection.remotePeer)
-      await stream.close()
-    }
-
-    // Return the latency
-    return Date.now() - startTime
-  }
-}
-
 export function perfService (init: PerfServiceInit = {}): (components: PerfServiceComponents) => PerfService {
-  return (components) => new DefaultPerfService(components, init)
+  return (components) => new PerfServiceClass(components, init)
 }