Steep memory benchmark for reforking feature

steep_memory_benchmark.rb

require "language_server-protocol"
require 'open3'
require 'securerandom'


class SteepRunner
  LSP = LanguageServer::Protocol

  attr_reader :writer, :reader, :initialize_id, :initialize_finished, :typecheck_finished, :wait_thr

  def initialize
    stdin, stdout, @wait_thr = Open3.popen2("steep langserver --log-output tmp/steep-log #{ARGV.join(' ')}")

    @writer = LSP::Transport::Io::Writer.new(stdin)
    @reader = LSP::Transport::Io::Reader.new(stdout)

    @initialize_id = SecureRandom.uuid
    @initialize_finished = Queue.new
    @typecheck_finished = Queue.new

    Thread.new do
      Thread.abort_on_exception = true

      reader.read do |request|
        case request[:method]
        when nil
          if request[:id] == initialize_id
            initialize_finished << true
          end
        when '$/progress'
          if request.dig(:params, :value, :kind) == 'end'
            typecheck_finished << true
          end
        end
      end
    end
  end

  def exec_initialize
    result = LSP::Interface::InitializeResult.new(
      capabilities: LSP::Interface::ClientCapabilities.new(
        window: { workDoneProgress: true },
      )
    )
    writer.write(id: initialize_id, method: 'initialize', params: result)
    initialize_finished.pop
    typecheck_finished.pop # for loading projects
    p 'initialize finished'
  end

  def exec_typecheck
    writer.write(id: SecureRandom.uuid, method: '$/steep/typecheck/groups', params: { groups: ['graphql'] })

    typecheck_finished.pop # for the type checking
    p 'typecheck finished'
  end

  def pid
    wait_thr.pid
  end
end

system('free -h')
r = SteepRunner.new
r.exec_initialize
r.exec_typecheck
sleep 5 # wait reforking
r.exec_typecheck
sleep 5

system('free -h')
system('ps auxf')
Process.kill 'TERM', r.pid