Implement a more performant code cache

packages/client/bin/cli.ts

@@ -266,6 +266,11 @@ const args: ClientOpts = yargs(hideBin(process.argv))
     number: true,
     default: Config.STORAGE_CACHE,
   })
+  .option('codeCache', {
+    describe: 'Size for the code cache (max number of contracts)',
+    number: true,
+    default: Config.CODE_CACHE,
+  })
   .option('trieCache', {
     describe: 'Size for the trie cache (max number of trie nodes)',
     number: true,
@@ -802,6 +807,7 @@ async function run() {
     numBlocksPerIteration: args.numBlocksPerIteration,
     accountCache: args.accountCache,
     storageCache: args.storageCache,
+    codeCache: args.codeCache,
     trieCache: args.trieCache,
     dnsNetworks: args.dnsNetworks,
     extIP: args.extIP,

packages/client/src/config.ts

@@ -208,6 +208,11 @@ export interface ConfigOptions {
    */
   storageCache?: number
 
+  /**
+   * Size for the code cache (max number of contracts)
+   */
+  codeCache?: number
+
   /**
    * Size for the trie cache (max number of trie nodes)
    */
@@ -337,6 +342,7 @@ export class Config {
   public static readonly NUM_BLOCKS_PER_ITERATION = 100
   public static readonly ACCOUNT_CACHE = 400000
   public static readonly STORAGE_CACHE = 200000
+  public static readonly CODE_CACHE = 200000
   public static readonly TRIE_CACHE = 200000
   public static readonly DEBUGCODE_DEFAULT = false
   public static readonly SAFE_REORG_DISTANCE = 100
@@ -374,6 +380,7 @@ export class Config {
   public readonly numBlocksPerIteration: number
   public readonly accountCache: number
   public readonly storageCache: number
+  public readonly codeCache: number
   public readonly trieCache: number
   public readonly debugCode: boolean
   public readonly discDns: boolean
@@ -437,6 +444,7 @@ export class Config {
     this.numBlocksPerIteration = options.numBlocksPerIteration ?? Config.NUM_BLOCKS_PER_ITERATION
     this.accountCache = options.accountCache ?? Config.ACCOUNT_CACHE
     this.storageCache = options.storageCache ?? Config.STORAGE_CACHE
+    this.codeCache = options.codeCache ?? Config.CODE_CACHE
     this.trieCache = options.trieCache ?? Config.TRIE_CACHE
     this.debugCode = options.debugCode ?? Config.DEBUGCODE_DEFAULT
     this.mine = options.mine ?? false

packages/client/src/execution/vmexecution.ts

@@ -57,6 +57,7 @@ export class VMExecution extends Execution {
 
       this.config.logger.info(`Initializing account cache size=${this.config.accountCache}`)
       this.config.logger.info(`Initializing storage cache size=${this.config.storageCache}`)
+      this.config.logger.info(`Initializing code cache size=${this.config.codeCache}`)
       this.config.logger.info(`Initializing trie cache size=${this.config.trieCache}`)
       const stateManager = new DefaultStateManager({
         trie,
@@ -71,6 +72,11 @@ export class VMExecution extends Execution {
           type: CacheType.LRU,
           size: this.config.storageCache,
         },
+        codeCacheOpts: {
+          deactivate: false,
+          type: CacheType.LRU,
+          size: this.config.codeCache,
+        },
       })
 
       this.vm = new (VM as any)({
@@ -680,15 +686,25 @@ export class VMExecution extends Execution {
   stats(vm: VM) {
     this.statsCount += 1
     if (this.statsCount === this.STATS_NUM_BLOCKS) {
-      let stats = (vm.stateManager as any)._accountCache.stats()
+      const sm = vm.stateManager as any
+      const disactivatedStats = { size: 0, reads: 0, hits: 0, writes: 0 }
+      let stats
+      // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+      stats = !sm._accountCacheSettings.deactivate ? sm._accountCache.stats() : disactivatedStats
       this.config.logger.info(
         `Account cache stats size=${stats.size} reads=${stats.reads} hits=${stats.hits} writes=${stats.writes}`
       )
-      stats = (vm.stateManager as any)._storageCache.stats()
+      // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+      stats = !sm._storageCacheSettings.deactivate ? sm._storageCache.stats() : disactivatedStats
       this.config.logger.info(
         `Storage cache stats size=${stats.size} reads=${stats.reads} hits=${stats.hits} writes=${stats.writes}`
       )
-      const tStats = ((vm.stateManager as any)._trie as Trie).database().stats()
+      // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+      stats = !sm._codeCacheSettings.deactivate ? sm._codeCache.stats() : disactivatedStats
+      this.config.logger.info(
+        `Code cache stats size=${stats.size} reads=${stats.reads} hits=${stats.hits} writes=${stats.writes}`
+      )
+      const tStats = (sm._trie as Trie).database().stats()
       this.config.logger.info(
         `Trie cache stats size=${tStats.size} reads=${tStats.cache.reads} hits=${tStats.cache.hits} ` +
           `writes=${tStats.cache.writes} readsDB=${tStats.db.reads} hitsDB=${tStats.db.hits} writesDB=${tStats.db.writes}`

packages/client/src/types.ts

@@ -140,6 +140,7 @@ export interface ClientOpts {
   numBlocksPerIteration?: number
   accountCache?: number
   storageCache?: number
+  codeCache?: number
   trieCache?: number
   dnsNetworks?: string[]
   executeBlocks?: string

packages/client/test/cli/cli.spec.ts

@@ -402,6 +402,21 @@ describe('[CLI]', () => {
     }
     await clientRunHelper(cliArgs, onData)
   }, 30000)
+  it('should start client with custom input for code cache size', async () => {
+    const cliArgs = ['--codeCache=2000', '--port=30313']
+    const onData = async (
+      message: string,
+      child: ChildProcessWithoutNullStreams,
+      resolve: Function
+    ) => {
+      if (message.includes('code cache')) {
+        assert.ok(message.includes('2000'), 'code cache option works')
+        child.kill(9)
+        resolve(undefined)
+      }
+    }
+    await clientRunHelper(cliArgs, onData)
+  }, 30000)
   it('should start client with custom input for trie cache size', async () => {
     const cliArgs = ['--trieCache=2000', '--port=30312']
     const onData = async (