FilesExpand file tree

main

/

collect_results.rb

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

141 lines (124 loc) · 4.81 KB

main

/

collect_results.rb

Copy path

Top

File metadata and controls

• Code
• Blame

141 lines (124 loc) · 4.81 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

# Loaded with `ruby -r` (through RUBYOPT) when RESULTS_DIR is set. Every

# Benchmark.ips call in a benchmark file also writes its report as JSON to

# RESULTS_DIR/<label>/<benchmark>.json, so the benchmark files stay untouched.

# Each result also records where it ran, so only comparable numbers get

# compared.

#

# Keep this file compatible with the oldest Ruby in the CI matrix (2.1).

#

# JRuby 9.1 can load this file before bundler/setup from RUBYOPT, so set up

# the bundle here to find benchmark-ips either way.

require "bundler/setup"

require "benchmark/ips"

require "fileutils"

require "json"

require "rbconfig"

module CollectResults

@calls = 0

class << self

attr_accessor :calls

def label

env("RESULTS_LABEL") || ["#{RUBY_ENGINE}-#{engine_version}", env("RUBY_VARIANT")].compact.join("+")

end

def engine_version

defined?(RUBY_ENGINE_VERSION) ? RUBY_ENGINE_VERSION : RUBY_VERSION

end

def write(report)

self.calls += 1

benchmark = $0.sub(%r{\A\./}, "")

name = benchmark.sub(%r{\Acode/}, "").sub(/\.rb\z/, "").gsub("/", "--")

name += "--#{calls}" if calls > 1

path = File.join(ENV["RESULTS_DIR"], label, "#{name}.json")

FileUtils.mkdir_p(File.dirname(path))

File.write(path, JSON.pretty_generate({

"benchmark" => benchmark,

"part" => calls,

"label" => label,

"ruby_description" => RUBY_DESCRIPTION,

"engine" => RUBY_ENGINE,

"engine_version" => engine_version,

"ruby_version" => RUBY_VERSION,

"variant" => env("RUBY_VARIANT"),

"flags" => env("RUBY_VARIANT_FLAGS"),

"jit" => jit,

"commit" => env("RESULTS_COMMIT"),

"run_id" => env("GITHUB_RUN_ID"),

"run_attempt" => env("GITHUB_RUN_ATTEMPT"),

"runner" => env("RUNNER_NAME"),

# Set by script/run_cross_ruby.rb, which runs every build on one machine and the reference build between them; nil otherwise.

"shard" => env("RESULTS_SHARD") && env("RESULTS_SHARD").to_i,

"shards" => env("RESULTS_SHARDS") && env("RESULTS_SHARDS").to_i,

"pass" => env("RESULTS_PASS") && env("RESULTS_PASS").to_i,

"reference" => env("RESULTS_REFERENCE") == "1",

# When this report finished, to place it between the reference passes.

"measured_at" => Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"),

"environment" => environment,

"entries" => report.data

}))

end

# An empty value counts as unset: CI passes an empty matrix field (no

# variant) as an empty string.

def env(name)

value = ENV[name]

value unless value.nil? || value.empty?

end

def jit

if defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled?

"yjit"

elsif defined?(RubyVM::ZJIT) && RubyVM::ZJIT.respond_to?(:enabled?) && RubyVM::ZJIT.enabled?

"zjit"

end

end

# The same for every benchmark in a run, so work it out once. A field that

# cannot be read (no /etc/os-release or ldd outside Docker) is nil; the

# others are kept.

def environment

@environment ||= {

"arch" => RbConfig::CONFIG["host_cpu"],

"cpu" => safely { cpu },

"nproc" => safely { nproc },

"os" => safely { File.read("/etc/os-release")[/^PRETTY_NAME="?([^"\n]+)/, 1] },

"glibc" => safely { `ldd --version 2>&1`[/\d+\.\d+/] },

"cc" => cc_version,

"optflags" => RbConfig::CONFIG["optflags"],

"configure_args" => RbConfig::CONFIG["configure_args"]

}

end

def safely

yield

rescue SystemCallError

nil

end

# x86 lists a model name. arm64 only lists implementer and part codes,

# which name the CPU design on servers; inside Docker Desktop's VM on a

# Mac they only say "Apple", so different Macs look the same.

def cpu

model = cpuinfo[/^model name\s*:\s*(.+)$/, 1]

return model if model

implementer = cpuinfo[/^CPU implementer\s*:\s*(\S+)/, 1]

part = cpuinfo[/^CPU part\s*:\s*(\S+)/, 1]

"CPU implementer #{implementer}, part #{part}" if implementer && part

end

def cpuinfo

File.exist?("/proc/cpuinfo") ? File.read("/proc/cpuinfo") : ""

end

# Etc.nprocessors is Ruby 2.2+.

def nproc

require "etc"

Etc.respond_to?(:nprocessors) ? Etc.nprocessors : cpuinfo.scan(/^processor\s*:/).size

end

# CC_VERSION_MESSAGE is only set by newer CRubies; nil elsewhere.

def cc_version

message = RbConfig::CONFIG["CC_VERSION_MESSAGE"]

message && message.lines.first.strip

end

end

def ips(*args, &block)

report = super

CollectResults.write(report) if report.respond_to?(:data)

report

end

end

# Benchmark extends Benchmark::IPS, so the hook goes on Benchmark's singleton

# class. Prepending to Benchmark::IPS would not reach it before Ruby 3.0.

Benchmark.singleton_class.send(:prepend, CollectResults)