优化实战：提升Ruby与Rails性能

需积分: 10 185 浏览量更新于2024-07-20 收藏 5.85MB PDF 举报

"《Ruby Performance Optimization》（2015年普拉格玛版）是一本深入讲解Ruby和Rails性能优化的权威指南。作者Alex Dymo带领读者探索内存和CPU优化、性能分析、测量、测试、垃圾回收以及调优的复杂领域。本书旨在帮助开发者从性能新手成长为专家，理解如何编写既对CPU效率又对内存友好的代码，避免不必要的垃圾收集，因为垃圾收集往往占用了程序运行时间的大部分，甚至超过50%。书中特别关注了Rails代码中的性能瓶颈，通过介绍选择性属性加载和预加载技术，指导如何降低ActiveRecord操作对性能的影响。作为高级阶段的内容，作者教导读者如何有效地使用性能分析工具，理解分析报告，做出明智的优化决策，并编写性能测试来确保代码不会因性能问题而逐渐恶化。此外，作者还将深入解析Ruby解释器的内部机制，揭示为何垃圾收集成为Ruby性能的瓶颈，并提供调优技巧。这本书获得了来自多位专业人士的高度评价，包括应用开发总监Matt Margolis，他认为这是一本必备的技术书籍，能够填补他在短时间内网络搜索无法获取的信息空白，提升开发技能。Web开发者Charley Stran表示，这本书改变了他开发的方式，促使他在编码前考虑性能优化。资深软件工程师Jeff Holland认为，对于不熟悉代码底层工作机制的程序员，此书将开启他们对代码新层次的理解。Kim Shrier也给出了积极的反馈，强调其在解决复杂性能问题时的参考价值。《Ruby Performance Optimization》不仅提供了全面的优化策略，还提供了实用的技巧和深入的理论知识，是任何希望提升Ruby应用程序性能的开发者的宝贵资源。"

the reason for the slowness, and rewrite the code to avoid the bottleneck.

Rinse and repeat until fast.

Sounds like a good plan, right? However, it doesn’t always work for Ruby

code. Algorithmic complexity can be a major cause for performance problems.

But Ruby has another cause that developers often overlook.

Let me show you what I’m talking about. Let’s consider a simple example that

takes a two-dimensional array of strings and formats it as a CSV.

Let’s jump right in. Key in or download this simple program.

chp1/example_unoptimized.rb

require "benchmark"

num_rows = 100000

num_cols = 10

data = Array.new(num_rows) { Array.new(num_cols) { "x"*1000 } }

time = Benchmark.realtime do

csv = data.map { |row| row.join(",") }.join("\n")

end

puts time.round(2)

We’ll run the program and see how it performs. But before that we need to

set up the execution environment. There are five major Ruby versions in use

today: 1.8.7, 1.9.3, 2.0, 2.1, and 2.2. These versions have very different per-

formance characteristics. Ruby 1.8 is the oldest and the slowest of them, with

a different interpreter architecture and implementation. Ruby 1.9.3 and 2.0

are the current mainstream releases with similar performance. Ruby 2.1 and

2.2 are the only versions that were developed with performance in mind, at

least if we believe their release notes, and thus should be the fastest.

It’s hard to target old software platforms, so I’ll make a necessary simplification

in this book. I will neither write examples nor measure performance for Ruby

1.8. I do this because Ruby 1.8 is not only internally different, it’s also source-

incompatible, making my task extremely complicated. However, even if you

have a legacy system running Ruby 1.8 with no chance to upgrade, you can

still use the performance optimization advice from this book. Everything I

describe in the book applies to 1.8. In fact, you might even get more

improvement. The old interpreter is so inefficient that any little change can

make a big difference. In addition to that I will give 1.8-specific advice where

appropriate.

report erratum • discuss

What Makes Ruby Code Slow • 3

2.22.12.01.9.3

2.432.6511.429.18GC enabled

1.161.191.151.14GC disabled

52%55%90%88%% of time spent in GC

Do you see why the code is so slow? Our program spends the majority of its

execution time in the garbage collector—a whopping 90% of the time in older

Rubys and a significant 50% of the time in modern versions.

I started my career as C++ developer. That’s why I was stunned when I first

realized how much time Ruby GC takes. This surprises even seasoned

developers who have worked with garbage-collected languages like Java and

C#. Ruby GC takes as much time as our code itself or more. Yes, Ruby 2.1

and later perform much better. But even they require half the execution time

for garbage collection in our example.

What’s the deal with the Ruby GC? Did our code use too much memory? Is

the Ruby GC too slow? The answer is a resounding yes to both questions.

High memory consumption is intrinsic to Ruby. It’s a side effect of the language

design. “Everything is an object” means that programs need extra memory to

represent data as Ruby objects. Also, slow garbage collection is a well-known

historical problem with Ruby. Its mark-and-sweep, stop-the-world GC is not

only the slowest known garbage collection algorithm. It also has to stop the

application for the time GC is running. That’s why our application takes

almost a dozen seconds to complete.

You have surely noticed significant performance improvement with Ruby 2.1

and 2.2. These versions feature much improved GC, called restricted genera-

tional GC. We’ll talk about what that means later in Chapter 10, Tune Up the

Garbage Collector, on page 149. For now it’s important to remember that the

latest two Ruby releases are much faster thanks to the better GC.

High GC times are surprising to the uninitiated. Less surprising, but still

important, is the fact that without GC all Ruby versions perform the same,

finishing in about 1.15 seconds. Internally the Ruby VMs are not that different

across the versions starting from 1.9. The biggest improvement relevant to

performance is the restricted generational GC that came with Ruby 2.1. But

that, of course, has no effect on code performance when GC is disabled.

If you’re a Ruby 1.8 user, you shouldn’t expect to get the performance of 1.9

and later, even with GC turned off. Modern Rubys have a virtual machine to

execute precompiled code. Ruby 1.8 executes code in a much slower fashion

by traversing the syntax tree.

Chapter 1. What Makes Ruby Code Fast • 6

report erratum • discuss

剩余196页未读，继续阅读

vanridin

粉丝: 108
资源: 1188

优化实战：提升Ruby与Rails性能

Ruby.Performance.Optimization

Ruby Performance Optimization, Why Ruby is Slow, and How to Fix It

Web Performance Optimization: Speeding Up Your Website

performance optimization numerically intensive codes

linux performance tuning pdf

怎么安装optimization toolbox

mybatisplus

maltab2022添加Toolbox Optimization Toolbox

sata ncq feature

Improving Generalization Performance by Switching from Adam to SGD

最新资源