jspurefix 5.9.1 → 5.9.2

package/src/jsfix-bench.ts

@@ -0,0 +1,204 @@
+import 'reflect-metadata'
+
+import * as path from 'path'
+import * as fs from 'fs'
+import minimist = require('minimist')
+import buildOptions from 'minimist-options'
+
+import { AsciiChars } from './buffer/ascii'
+import { IJsFixConfig } from './config'
+import { DefinitionFactory } from './util'
+import { SessionContainer } from './runtime'
+import { DITokens } from './runtime/di-tokens'
+import {
+  BenchRunner,
+  IBenchCase,
+  IBenchOptions,
+  IBenchSuiteResult,
+  ParseCase,
+  ParseDepth,
+  defaultBenchOptions,
+  formatComparison,
+  formatSuite
+} from './benchmark'
+
+const options = buildOptions({
+  dict: {
+    type: 'string',
+    alias: 'd',
+    default: 'qf44'
+  },
+
+  fix: {
+    type: 'string',
+    alias: 'f',
+    default: 'data/examples/FIX.4.4/quickfix/execution-report/fix.txt'
+  },
+
+  session: {
+    type: 'string',
+    alias: 's',
+    default: 'data/session/test-initiator.json'
+  },
+
+  delimiter: {
+    type: 'string',
+    alias: 'l',
+    default: '|'
+  },
+
+  depth: {
+    type: 'string',
+    default: 'view,object'
+  },
+
+  rounds: {
+    type: 'number',
+    default: defaultBenchOptions.rounds
+  },
+
+  msgs: {
+    type: 'number',
+    default: defaultBenchOptions.operationsPerRound
+  },
+
+  warmup: {
+    type: 'number',
+    default: defaultBenchOptions.warmupOperations
+  },
+
+  label: {
+    type: 'string',
+    default: 'jspurefix'
+  },
+
+  save: {
+    type: 'string'
+  },
+
+  baseline: {
+    type: 'string'
+  },
+
+  json: {
+    type: 'boolean',
+    default: false
+  },
+
+  help: {
+    type: 'boolean',
+    alias: 'h',
+    default: false
+  }
+})
+
+const argv: any = minimist(process.argv.slice(2), options)
+
+const root: string = path.join(__dirname, '../')
+
+function norm (p: string): string {
+  return path.isAbsolute(p) ? p : path.join(root, p)
+}
+
+function usage (): void {
+  console.log('measure the parse path and what it costs in time and in garbage')
+  console.log()
+  console.log('  --fix=<path>        fix log to parse, defaults to a 4.4 execution report')
+  console.log('  --dict=<name>       dictionary, e.g. qf44, repo44, qf50sp2')
+  console.log('  --delimiter=<char>  field delimiter in the log, defaults to |')
+  console.log('  --depth=view,object which stages to measure, comma separated')
+  console.log('  --rounds=<n>        measured rounds, one sample each')
+  console.log('  --msgs=<n>          messages per round')
+  console.log('  --warmup=<n>        messages discarded before measuring')
+  console.log('  --save=<path>       write the suite to json')
+  console.log('  --baseline=<path>   compare against a previously saved suite')
+  console.log('  --json              print the suite as json instead of a report')
+  console.log()
+  console.log('run under --expose-gc so rounds can be isolated and heap read cleanly:')
+  console.log('  node --expose-gc dist/jsfix-bench --fix=data/examples/FIX.4.4/quickfix/execution-report/fix.txt')
+  console.log('  npm run bench')
+}
+
+async function makeConfig (): Promise<IJsFixConfig> {
+  const sys = new SessionContainer()
+  sys.registerGlobal('error')
+  const sessionDescription = require(norm(argv.session))
+  const container = await sys.makeSystem(sessionDescription)
+  const config = container.resolve<IJsFixConfig>(DITokens.IJsFixConfig)
+  config.definitions = await new DefinitionFactory().getDefinitions(argv.dict)
+  // the parser reads the delimiter when it is constructed, so this has to be
+  // settled before any case is built
+  config.delimiter = AsciiChars.firstChar(argv.delimiter)
+  return config
+}
+
+function requestedDepths (): ParseDepth[] {
+  const known = new Map<string, ParseDepth>([
+    ['view', ParseDepth.View],
+    ['object', ParseDepth.Object]
+  ])
+  const asked = String(argv.depth).split(',').map(d => d.trim().toLowerCase()).filter(d => d.length > 0)
+  return asked.map(d => {
+    const depth = known.get(d)
+    if (!depth) {
+      throw new Error(`unknown depth ${d}, expected view or object`)
+    }
+    return depth
+  })
+}
+
+function readSuite (p: string): IBenchSuiteResult {
+  return JSON.parse(fs.readFileSync(norm(p), 'utf8'))
+}
+
+async function main (): Promise<void> {
+  if (argv.help) {
+    usage()
+    return
+  }
+  const fixPath = norm(argv.fix)
+  if (!fs.existsSync(fixPath)) {
+    throw new Error(`no such fix log ${fixPath}`)
+  }
+  const contents = fs.readFileSync(fixPath, 'utf8')
+  const config = await makeConfig()
+
+  const cases: ParseCase[] = requestedDepths().map(depth =>
+    new ParseCase(`parse:${depth}`, { config, contents, depth }))
+
+  // every case walks the same input, so one alignment covers the suite and all
+  // of them stay directly comparable
+  const perInvocation = cases[0].operationsPerInvocation
+  const operationsPerRound = cases[0].alignOperations(argv.msgs)
+  const benchOptions: IBenchOptions = {
+    warmupOperations: cases[0].alignOperations(argv.warmup),
+    rounds: argv.rounds,
+    operationsPerRound,
+    gcBetweenRounds: true
+  }
+
+  console.log(`${path.relative(root, fixPath)}  ${perInvocation} msg/pass  dict ${argv.dict}`)
+  const suite = await new BenchRunner(benchOptions).runAll(argv.label, cases as IBenchCase[])
+
+  if (argv.json) {
+    console.log(JSON.stringify(suite, null, 2))
+  } else {
+    console.log()
+    console.log(formatSuite(suite))
+  }
+  if (argv.baseline) {
+    console.log()
+    console.log(formatComparison(readSuite(argv.baseline), suite))
+  }
+  if (argv.save) {
+    const target = norm(argv.save)
+    fs.mkdirSync(path.dirname(target), { recursive: true })
+    fs.writeFileSync(target, JSON.stringify(suite, null, 2), 'utf8')
+    console.log(`saved ${path.relative(root, target)}`)
+  }
+}
+
+main().catch(e => {
+  console.error(e instanceof Error ? e.message : e)
+  process.exit(1)
+})

package/src/store/file-session-store.ts

@@ -22,7 +22,7 @@ export class FileSessionStore implements IFixSessionStore {
   private creationTimeValue: Date = new Date()
 
   // In-memory index: seqnum -> { offset, length }
-  private readonly headerIndex: Map<number, { offset: number, length: number }> = new Map()
+  private readonly headerIndex = new Map<number, { offset: number, length: number }>()
 
   /**
    * Creates a FileSessionStore with the default file-based stream provider.
@@ -285,7 +285,7 @@ export class FileSessionStore implements IFixSessionStore {
    */
   static parseSessionTime (str: string): Date | null {
     // Format: YYYYMMDD-HH:MM:SS.ffffff
-    const match = str.match(/^(\d{4})(\d{2})(\d{2})-(\d{2}):(\d{2}):(\d{2})\.(\d{3,6})$/)
+    const match = /^(\d{4})(\d{2})(\d{2})-(\d{2}):(\d{2}):(\d{2})\.(\d{3,6})$/.exec(str)
     if (!match) return null
     const [, y, M, d, h, m, s, frac] = match
     const ms = parseInt(frac.substring(0, 3), 10)

package/src/store/file-session-stream-provider.ts

@@ -32,28 +32,34 @@ export class FileSessionStreamProvider implements ISessionStreamProvider {
   }
 
   openBody (): void {
-    if (this.bodyFd !== null) return
-    this.bodyFd = fs.openSync(this.bodyPath, 'a+')
-    const stat = fs.fstatSync(this.bodyFd)
-    this.bodySize = stat.size
+    this.openBodyFd()
   }
 
-  async appendBody (data: Buffer): Promise<number> {
+  /**
+   * open the body file on first use and hand back the descriptor - returning it
+   * keeps callers free of a null check the compiler cannot see through.
+   */
+  private openBodyFd (): number {
     if (this.bodyFd === null) {
-      this.openBody()
+      this.bodyFd = fs.openSync(this.bodyPath, 'a+')
+      const stat = fs.fstatSync(this.bodyFd)
+      this.bodySize = stat.size
     }
+    return this.bodyFd
+  }
+
+  async appendBody (data: Buffer): Promise<number> {
+    const fd = this.openBodyFd()
     const offset = this.bodySize
-    fs.writeSync(this.bodyFd!, data, 0, data.length, offset)
+    fs.writeSync(fd, data, 0, data.length, offset)
     this.bodySize += data.length
     return offset
   }
 
   async readBody (offset: number, length: number): Promise<Buffer> {
-    if (this.bodyFd === null) {
-      this.openBody()
-    }
+    const fd = this.openBodyFd()
     const buf = Buffer.alloc(length)
-    fs.readSync(this.bodyFd!, buf, 0, length, offset)
+    fs.readSync(fd, buf, 0, length, offset)
     return buf
   }
 

package/src/store/fix-session-store-factory.ts

@@ -7,7 +7,7 @@ import { FileSessionStore } from './file-session-store'
  * Factory for creating session stores.
  */
 export interface IFixSessionStoreFactory {
-  create (sessionId: SessionId): IFixSessionStore
+  create: (sessionId: SessionId) => IFixSessionStore
 }
 
 /**

package/src/store/fix-session-store.ts

@@ -14,24 +14,24 @@ export interface IFixSessionStore {
   readonly sessionId: SessionId
 
   // Message Operations
-  put (record: IFixMsgStoreRecord): Promise<void>
-  get (seqNum: number): Promise<IFixMsgStoreRecord | null>
-  getRange (fromSeqNum: number, toSeqNum: number): Promise<IFixMsgStoreRecord[]>
+  put: (record: IFixMsgStoreRecord) => Promise<void>
+  get: (seqNum: number) => Promise<IFixMsgStoreRecord | null>
+  getRange: (fromSeqNum: number, toSeqNum: number) => Promise<IFixMsgStoreRecord[]>
 
   // Sequence Number Operations
   senderSeqNum: number
   targetSeqNum: number
-  setSenderSeqNum (value: number): Promise<void>
-  setTargetSeqNum (value: number): Promise<void>
-  nextSenderSeqNum (): Promise<number>
-  nextTargetSeqNum (): Promise<number>
+  setSenderSeqNum: (value: number) => Promise<void>
+  setTargetSeqNum: (value: number) => Promise<void>
+  nextSenderSeqNum: () => Promise<number>
+  nextTargetSeqNum: () => Promise<number>
 
   // Session Operations
   readonly creationTime: Date
-  reset (): Promise<void>
+  reset: () => Promise<void>
 
   // Lifecycle
-  initialize (): Promise<void>
-  flush (): Promise<void>
-  dispose (): Promise<void>
+  initialize: () => Promise<void>
+  flush: () => Promise<void>
+  dispose: () => Promise<void>
 }

package/src/store/memory-session-store.ts

@@ -7,7 +7,7 @@ import { IFixMsgStoreRecord } from './fix-msg-store-record'
  * Not persistent - all data lost on dispose.
  */
 export class MemorySessionStore implements IFixSessionStore {
-  private readonly messages: Map<number, IFixMsgStoreRecord> = new Map()
+  private readonly messages = new Map<number, IFixMsgStoreRecord>()
   private senderSeqNumValue: number = 1
   private targetSeqNumValue: number = 1
   private creationTimeValue: Date = new Date()

package/src/store/session-stream-provider.ts

@@ -7,68 +7,68 @@ export interface ISessionStreamProvider {
    * Opens or creates a read-write buffer for the message body file.
    * Must support random-access reads (by offset+length).
    */
-  openBody (): void
+  openBody: () => void
 
   /**
    * Appends data to the body. Returns the offset at which data was written.
    */
-  appendBody (data: Buffer): Promise<number>
+  appendBody: (data: Buffer) => Promise<number>
 
   /**
    * Reads data from the body at the given offset and length.
    */
-  readBody (offset: number, length: number): Promise<Buffer>
+  readBody: (offset: number, length: number) => Promise<Buffer>
 
   /**
    * Gets the current body size (for calculating offsets).
    */
-  getBodySize (): number
+  getBodySize: () => number
 
   /**
    * Appends a line to the header index file.
    */
-  appendHeaderLine (line: string): Promise<void>
+  appendHeaderLine: (line: string) => Promise<void>
 
   /**
    * Reads all lines from the header index file.
    * Returns empty array if no data exists.
    */
-  readHeaderLines (): Promise<string[]>
+  readHeaderLines: () => Promise<string[]>
 
   /**
    * Reads the sequence numbers string.
    * Returns null if no data exists.
    */
-  readSeqNums (): Promise<string | null>
+  readSeqNums: () => Promise<string | null>
 
   /**
    * Writes the sequence numbers string.
    */
-  writeSeqNums (content: string): Promise<void>
+  writeSeqNums: (content: string) => Promise<void>
 
   /**
    * Reads the session time string.
    * Returns null if no data exists.
    */
-  readSessionTime (): Promise<string | null>
+  readSessionTime: () => Promise<string | null>
 
   /**
    * Writes the session time string.
    */
-  writeSessionTime (content: string): Promise<void>
+  writeSessionTime: (content: string) => Promise<void>
 
   /**
    * Resets all streams/files for a new session.
    */
-  reset (): Promise<void>
+  reset: () => Promise<void>
 
   /**
    * Flushes any pending writes.
    */
-  flush (): Promise<void>
+  flush: () => Promise<void>
 
   /**
    * Disposes of all resources.
    */
-  dispose (): Promise<void>
+  dispose: () => Promise<void>
 }

package/src/transport/session/fix-clock.ts

@@ -1,5 +1,5 @@
 export interface IFixClock {
-  now (): Date
+  now: () => Date
 }
 
 export class DefaultFixClock implements IFixClock {

package/src/transport/session/resend-request-manager.ts

@@ -46,7 +46,7 @@ export class ResendAction {
 }
 
 export class PendingResendRange {
-  private readonly receivedSeqs: Set<number> = new Set()
+  private readonly receivedSeqs = new Set<number>()
 
   constructor (
     public readonly begin: number,
@@ -190,11 +190,11 @@ export class ResendRequestManager {
     // keep requestHistory for debugging
   }
 
-  get pending (): ReadonlyArray<PendingResendRange> {
+  get pending (): readonly PendingResendRange[] {
     return this.pendingRequests.slice()
   }
 
-  get history (): ReadonlyArray<ResendRequestRecord> {
+  get history (): readonly ResendRequestRecord[] {
     return this.requestHistory.slice()
   }
 
@@ -240,7 +240,7 @@ export class ResendRequestManager {
       return { begin: gapBegin, end: gapEnd }
     }
 
-    const covered: Set<number> = new Set()
+    const covered = new Set<number>()
     for (const pending of this.pendingRequests) {
       for (let seq = pending.begin; seq <= pending.end; seq++) {
         covered.add(seq)

package/src/transport/session/session-sequence-coordinator.ts

@@ -160,7 +160,7 @@ export class SessionSequenceCoordinator {
     this.resendManager.recordRequestSent(begin, end, now)
   }
 
-  get pendingResendRequests (): ReadonlyArray<PendingResendRange> {
+  get pendingResendRequests (): readonly PendingResendRange[] {
     return this.resendManager.pending
   }
 

package/src/transport/session/session-sequence-store.ts

@@ -6,9 +6,9 @@
 export interface ISessionSequenceStore {
   senderSeqNum: number
   targetSeqNum: number
-  setSenderSeqNum (value: number): Promise<void>
-  setTargetSeqNum (value: number): Promise<void>
-  reset (): Promise<void>
+  setSenderSeqNum: (value: number) => Promise<void>
+  setTargetSeqNum: (value: number) => Promise<void>
+  reset: () => Promise<void>
 }
 
 /**

package/src/transport/tcp/tcp-initiator.ts

@@ -198,7 +198,7 @@ export class TcpInitiator extends FixInitiator {
       const timeoutPromise = promisify(setTimeout)
       const reconnectSeconds = application?.reconnectSeconds ?? 5
       let retries = 0
-      let lastError: Error = initialError as Error
+      let lastError: Error | undefined = initialError
       const name = application?.name ?? 'initiator'
       this.th = setInterval(() => {
         ++retries