# Chinese (China) translation for gnome-devel-docs.

# Copyright (C) 2010 gnome-devel-docs's COPYRIGHT HOLDER

# This file is distributed under the same license as the gnome-devel-docs package.

# YunQiang Su <wzssyqa@gmail.com>, 2010.

#

msgid ""

msgstr ""

"Project-Id-Version: gnome-devel-docs master\n"

"POT-Creation-Date: 2010-05-14 17:00+0000\n"

"PO-Revision-Date: 2010-07-21 14:01+0800\n"

"Last-Translator: YunQiang Su <wzssyqa@gmail.com>\n"

"Language-Team: Chinese (China) <i18n-zh@googlegroups.com>\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

#: C/optimization-intro.xml:3(title)

msgid "The Quick Guide to Optimizing GNOME Programs"

msgstr "优化文档的快速指南"

#: C/optimization-intro.xml:5(para)

msgid ""

"This is a brief introduction to optimization, both the hows and the whys. "

"Details of individual tools and techniques are left for later articles, but "

"a collection of hints and tricks is provided."

msgstr ""

"这是关于优化的一个简单介绍，以及如何做和为何这么做。每个工具和技术的细节留到"

"未来的文档中，但是提供了一些提示和技巧。"

#: C/optimization-intro.xml:10(title)

msgid "What are we Optimizing?"

msgstr "什么需要优化？"

#: C/optimization-intro.xml:11(para)

msgid ""

"When we optimize for GNOME the first thing to remember is this: we are not "

"trying to make the program better, we are trying to make the person using "

"the computer happier."

msgstr ""

"优化 GNOME 程序时需要记住的第一件事情是：我们在做的不是使程序更好，而是让人们"

"更快乐地使用计算机。"

#: C/optimization-intro.xml:14(para)

msgid ""

"Better programs make people happier, but there are some improvements that "

"will make them a lot happier than others: Responsiveness, start-up time, "

"easy to access commands and not having the computer go into swap the moment "

"more than two programs are open."

msgstr ""

"更好的程序可以使人们更快乐，但是一些改进将使他们比别人更快乐：反应速度、启动"

"时间、更容易找到命令以及在多个程序同时打开时不让计算机卡住。"

#: C/optimization-intro.xml:17(para)

#, fuzzy

msgid ""

"Traditional optimization tackles concepts like CPU use, code size, the "

"number of mouse clicks and the memory use of the program. This second list "

"has been chosen to correlate with the first list, however there is an "

"important difference: The person using GNOME doesn't care about the second "

"list, but they care a lot about the first list. When optimizing GNOME "

"programs we will reduce CPU use, memory use and all those things, but these "

"are the means to the end, not the final goal. We are optimizing for people."

msgstr "传统的优化解决 CPU 使用、代码大小、鼠标点击量以及内存使用。"

#: C/optimization-intro.xml:23(title)

msgid "Doing the Optimization"

msgstr "进行优化"

#: C/optimization-intro.xml:24(para)

msgid ""

"The previous section omitted one important qualifier: To optimize something "

"it has to be measurable. You can't measure happiness. However, you can "

"measure start-up time so you can tell if you have improved it. Happiness "

"will then, hopefully, follow."

msgstr ""

"上面的章节忽略了一个重要的指标：优化的东西必须是可量测的。快乐是无法量测的，"

"但是可以量测启动时间，然后讨论是否需要对其进行优化。希望快乐也能随之而来吧。"

#: C/optimization-intro.xml:27(para)

msgid ""

"Optimization is the process of measurement, refinement and re-measurement. "

"So the first thing you must do is find a way to measure what you are "

"optimizing. Ideally this measurement is a single number, for example: the "

"time taken to perform a task. This is your benchmark, it is the only way to "

"tell if you are winning or losing. There is a big difference between a "

"program that <emphasis>should</emphasis> be fast and a program that "

"<emphasis>is</emphasis> fast."

msgstr ""

"优化是测量、精益求精和重新测量的过程。所以，第一件必须要做的事情就是找到一种"

"测量要优化的事情的方法。这个测量结果最好是一个数字，例如：执行一个任务所需要"

"的时间。这是您的性能测试，这时唯一可以告诉您通过还是失败的方法。在一个程序 "

"<emphasis>应该</emphasis> 快还是 <emphasis>已经</emphasis> 快之间的区别。"

#: C/optimization-intro.xml:30(para)

msgid ""

"Once you have a basic benchmark you need to find out why your code is not "

"doing as well as it should. It is tempting to do this by inspection: just "

"looking at the code and trying to spot something that looks like it needs "

"improvement. You will invariably be wrong. Using a profiler to get a "

"detailed break-down of what your program really does is the only way to be "

"sure."

msgstr ""

"进行了基本的性能测试之后，您需要找出为什么代码没有如其应该的那样快。可以通过"

"这样来尝试：检查代码找出需要改进的地方。您可能总会是错误的。使用一个性能分析"

"器来获取详细的程序每步的工作是唯一可以保证是正确的方法。"

#: C/optimization-intro.xml:33(para)

msgid ""

"Usually the problem is isolated to small sections of code. Pick the worst "

"place and concentrate on that first. Once that is done, rerun the profiler "

"and repeat. As you proceed the gains made at each step will get less and "

"less, at some point you will have to decide that the results are good "

"enough. If your efforts are only extracting 10% improvements then you are "

"well past the point where you should have stopped."

msgstr ""

"程序通常可以分为很小的代码块。找出性能最差的地方并集中精力首先处理。完成之"

"后，重新运行性能分析器然后重复。每进行一次这样的努力将获得的越来越少，您可以"

"在一个点上认为结果已经足够好了。如果您的努力只能获取 10% 的改进，最好略过这个"

"点，并且应该停止。"

#: C/optimization-intro.xml:36(para)

msgid ""

"Don't forget the big picture. For example, rather than just trying to speed "

"up a piece of code, ask yourself if it needs to be run at all. Could it be "

"combined with another piece of code? Can the results of previous "

"calculations be saved and reused? It won't even need to be optimized if it "

"is in a place where the user is never going to notice it. Worse still, the "

"code may already be optimized and is doing the heavy calculations now to "

"avoid doing them later. Code does not run in isolation and neither does the "

"optimization process."

msgstr ""

"不要忘记大图片。例如，在尝试加速一段代码之前，先想想是否真的需要它。是否可以"

"和其它代码块结合？前面计算的结果是否可以保存起来并重用？如果是用户根本不会注"

"意的地方就甚至不需要优化。更糟的是，代码已经优化了，并且正在进行高负载运算，"

"那就需要避免稍候再次进行运算。不孤立运行的代码也不需要优化过程。"

#: C/optimization-intro.xml:41(title)

msgid "Hints"

msgstr "提示"

#: C/optimization-intro.xml:43(title)

msgid "The Fundamentals"

msgstr "基本原理"

#: C/optimization-intro.xml:45(para)

msgid ""

"Re-run your benchmark after every change you make to the code and keep a log "

"of everything you change and how it affects the benchmark. This lets you "

"undo mistakes and also helps you not to repeat mistakes."

msgstr ""

"对代码进行更改之后重新运行性能测试，记录每次的更改及对性能的影响。这可以帮助"

"您修复错误，也可以帮您避免重复犯错。"

#: C/optimization-intro.xml:50(para)

msgid ""

"Make sure your code is correct and bug-free before optimizing it. Check that "

"it remains correct and bug-free after optimization."

msgstr ""

"在进行优化之前确保代码是正确且没有缺陷的。在优化之后检查是否仍然是正确且没有"

"缺陷的。"

#: C/optimization-intro.xml:55(para)

msgid "Optimize at the high level before optimizing the details."

msgstr "在对细节进行优化之前先在高层进行优化。"

#: C/optimization-intro.xml:60(para)

msgid ""

"Use the right algorithm. The classic text-book example is using quick-sort "

"instead of bubble-sort. There are many others, some save memory, some save "

"CPU. Also, see what shortcuts you can make: you can do quicker than quick-"

"sort if you are prepared to make some compromises."

msgstr ""

"使用正确的算法。经典的文本排序使用的是快速排序而不是冒泡排序。还有很多其它，"

"一些可以节省内存，一些可以节省 CPU。同样，寻找您可以走的捷径：如果愿意进行某"

"些组合，甚至可以比快速排序更快。"

#: C/optimization-intro.xml:65(para)

msgid ""

"Optimization is a trade-off. Caching results speeds up calculations, but "

"increases memory use. Saving data to disk saves memory, but costs time when "

"it is loaded back from disk."

msgstr ""

"优化就是折衷。缓存结果可以加速运行，但是会增加内存使用。将数据保存到磁盘可以"

"节省内存，但从磁盘中加载时浪费时间。"

#: C/optimization-intro.xml:70(para)

#, fuzzy

msgid ""

"Make sure you choose a wide variety of inputs to optimize against. If you "

"don't it is easy to end up with a piece of code carefully optimized for one "

"file and no others."

msgstr "确保选择了足够多的输入来再次进行优化。如果不能容易"

#: C/optimization-intro.xml:75(para)

msgid ""

"Avoid expensive operations: Multiple small disk reads. Using up lots of "

"memory so disk swapping becomes necessary. Avoid anything that writes or "

"reads from the hard disk unnecessarily. The network is slow too. Also avoid "

"graphics operations that need a response from the X server."

msgstr ""

"避免高消耗的操作：多次从磁盘读取很少的数据。使用很多内存会需要交换。避免任何"

"不需要的硬盘读写。网络也是很慢的。同样避免需要 X 服务器响应的图形操作。"

#: C/optimization-intro.xml:81(title)

msgid "Traps for the Unwary"

msgstr "粗心造成的陷阱"

#: C/optimization-intro.xml:83(para)

msgid ""

"Beware of side effects. There can often be strange interactions between "

"different sections of code, a speed-up in one part can slow another part "

"down."

msgstr ""

"注意副作用。在不同的代码部分之间经常有奇怪的交互，加速一个部分可能会使另一部"

"分的速度降低。"

#: C/optimization-intro.xml:88(para)

msgid ""

"When timing code, even on a quiet system, events outside the program add "

"noise to the timing results. Average over multiple runs. If the code is very "

"short, timer resolution is also a problem. In this case measure the time the "

"computer takes to run the code 100 or 1000 times. If the times you are "

"recording are longer than a few seconds, you should be OK."

msgstr ""

"测量代码的运行时间时，即使在安静的系统上，程序之外的事件也会对计时产生影响。"

"多次运行取平均值。如果代码非常短，计时精度也是一个问题。这时，测量代码运行 "

"100 甚至 1000 次的时间。如果您记录的时间长达数秒，就可以了。"

#: C/optimization-intro.xml:93(para)

msgid ""

"It is very easy to be misled by the profiler. There are stories of people "

"optimizing the operating system idle-loop because that is where it spent all "

"its time! Don't optimize code that does nothing the user cares about."

msgstr ""

"也很容易被性能分析器误导。有人曾经优化掉了操作系统的 idle-loop，因为它耗费掉"

"了系统所有的时间。不要优化做用户根本不关心的部分。"

#: C/optimization-intro.xml:98(para)

msgid ""

"Remember the resources on the X server. Your program's memory usage doesn't "

"include the pixmaps that are stored in the X server's process, but they are "

"still using up memory. Use xrestop to see what resources your program is "

"using."

msgstr ""

"别忘记了 X 服务器上的时间。您的程序的内存使用量并没有包含在 X 服务器进程中存"

"储的像素影射，但它们仍然使用内存。使用 xrestop 查看您的程序使用的资源。"

#: C/optimization-intro.xml:104(title)

msgid "Low Level Hints"

msgstr "底层提示"

#: C/optimization-intro.xml:106(para)

msgid ""

"When optimizing memory use, be wary of the difference between peak usage and "

"average memory usage. Some memory is almost always allocated, this is "

"usually bad. Some is only briefly allocated, this may be quite acceptable. "

"Tools like massif use the concept of space-time, the product of memory used "

"and the duration it was allocated for, instead."

msgstr ""

"优化内存使用时，警惕高峰使用量和平均使用量的区别。总是持有申请的内存是不好"

"的。一些仅仅是简单的申请，还是可以接受的。类似于 massif 的工具使用时空 (内存"

"使用量和使用时间的乘积) 的概念来代替。"

#: C/optimization-intro.xml:111(para)

msgid ""

"Time simplified bits of code that do only the things you know are essential, "

"this gives an absolute lower limit on the time your code will take. For "

"example, when optimizing a loop time the empty loop. If that is still too "

"long no amount of micro-optimization will help and you will have to change "

"your design. Make sure the compiler doesn't optimize away your empty loop."

msgstr ""

#: C/optimization-intro.xml:116(para)

#, fuzzy

msgid ""

"Move code out from inside loops. A slightly more complicated piece of code "

"that is executed once is far quicker than a simple piece of code executed a "

"thousand times. Avoid calling slow code often."

msgstr "去除内部循环的代码。"

#: C/optimization-intro.xml:121(para)

msgid ""

"Give the compiler as many hints as possible. Use the const keyword. Use "

"<envar>G_INLINE_FUNC</envar> for short, frequently called, functions. Look "

"up <envar>G_GNUC_PURE</envar>, <envar>G_LIKELY</envar> and the other glib "

"miscellaneous macros. Use the macros instead of gcc-specific keywords to "

"ensure portability."

msgstr ""

"给编译器尽可能多的提示。使用常量关键字。使用 <envar>G_INLINE_FUNC</envar> 作"

"为经常调用的函数的简称。查看 <envar>G_GNUC_PURE</envar>，<envar>G_LIKELY</"

"envar> 和其它 glib 杂项宏。使用这些宏代替 gcc 专用的关键字，以确保可移植性。"

#: C/optimization-intro.xml:126(para)

msgid ""

"Don't use assembly language. It is not portable and, while it may be fast on "

"one processor, it is not even guaranteed to be fast on every processor that "

"supports that architecture (e.g. Athlon vs. Pentium 4)."

msgstr ""

"不要使用汇编语言。汇编语言不可移植，而且虽然可能在一个处理器上很快，但是甚至"

"在支持同样处理器架构的处理器上也不能保证可以很快 (例如速龙和奔四的区别)。"

#: C/optimization-intro.xml:131(para)

msgid ""

"Don't rewrite an existing library routine unless you are sure it is "

"unnecessarily slow. Many CPU-intensive library routines have already been "

"optimized. Conversely, some library routines are slow, especially ones that "

"make system calls to the operating system."

msgstr ""

"不要重写已有的库函数，除非确定库函数不可接受得慢。很多 CPU 敏感的库函数都是优"

"化过的。相反地，一些库函数也是慢的，尤其是那些使用系统调用的。"

#: C/optimization-intro.xml:136(para)

msgid ""

"Minimize the number of libraries you link to. The fewer libraries to link "

"in, the faster the program starts. This is a difficult thing to do with "

"GNOME."

msgstr "使用尽量少的库。链接到的库越少，程序启动越快。对于 GNOME，这很难达到。"

#: C/optimization-intro.xml:142(title)

msgid "High Level Tricks"

msgstr "高层技巧"

#: C/optimization-intro.xml:144(para)

msgid ""

"Take advantage of concurrency. This doesn't just mean using multiple "

"processors, it also means taking advantage of the time the user spends "

"thinking about what they are going to do next to perform some calculations "

"in anticipation. Do calculations while waiting for data to be loaded off "

"disk. Take advantage of multiple resources, use them all at once."

msgstr ""

"发挥并发的优势。这并不仅仅意味着使用多处理器，也意味着减少用户执行一些计算所"

"预期的时间。在等待从磁盘上加载数据是进行计算。充分使用多种资源，同时使用它"

"们。"

#: C/optimization-intro.xml:149(para)

msgid ""

"Cheat. The user only has to think that the computer is fast, it doesn't "

"matter whether it actually is or not. It is the time between the command and "

"the answer that is important, it doesn't matter if the response is pre-"

"calculated, cached, or will in fact be worked out later at a more convenient "

"time, as long as the user gets what they expect."

msgstr ""

"欺骗。用户仅仅认为计算机很快，而不管实际上是否如此。命令和结果之间的时间很重"

"要，而无论是提前计算的、缓存的还是在稍候方便的时间进行实际计算，尽快地给出用"

"户期望的结果。"

#: C/optimization-intro.xml:154(para)

msgid ""

"Do things in the idle loop. It is easier to program than using full multi-"

"threading but still gets things done out of the users eye. Be careful "

"though, if you spend too long in the idle loop your program will become "

"sluggish. So regularly give control back to the main loop."

msgstr ""

"在空闲循环中进行某些工作。这比多线程更容易编程但仍然在用户视线之外进行了工"

"作。仍然需要注意，如果在空闲循环中花费太多时间，程序将变卡。所以需要经常返回"

"主循环。"

#: C/optimization-intro.xml:159(para)

msgid ""

"If all else fails, tell the user that the code is going to be slow and put "

"up a progress bar. They won't be as happy as if you had just presented the "

"results, but they will at least know the program hasn't crashed and they can "

"go get a cup of coffee."

msgstr ""

"如果都失败了，告诉用户代码将会比较慢并且使用进度条。如果仅仅给出结果，用户并"

"不会高兴，他们至少会知道程序没有崩溃，他们可以去喝杯咖啡。"

#. When image changes, this message will be marked fuzzy or untranslated for you.

#. It doesn't matter what you translate it to: it's not used at all.

#: C/optimization-massif.xml:52(None)

msgid ""

"@@image: 'figures/massif-before.png'; md5=1a6b2ace548e6789ab8bfacb3727b345"

msgstr ""

"@@image: 'figures/massif-before.png'; md5=1a6b2ace548e6789ab8bfacb3727b345"

#. When image changes, this message will be marked fuzzy or untranslated for you.

#. It doesn't matter what you translate it to: it's not used at all.

#: C/optimization-massif.xml:114(None)

msgid ""

"@@image: 'figures/massif-after.png'; md5=36d1b4ad7ab49b28b69ad3eabbaa7069"

msgstr ""

"@@image: 'figures/massif-after.png'; md5=36d1b4ad7ab49b28b69ad3eabbaa7069"

#: C/optimization-massif.xml:3(title)

msgid ""

"Using <application>Massif</application> for Profiling Memory Use in GNOME "

"Software"

msgstr "使用 <application>Massif</application> 分析 GNOME 软件的内存使用"

#: C/optimization-massif.xml:5(para)

msgid ""

"This article describes how to use the <application>Massif</application> heap "

"profiler with GNOME applications. We describe how to invoke, interpret, and "

"act on the output of <application>Massif</application>. The "

"<application>Same GNOME</application> game is used as an example."

msgstr ""

"这篇文章描述怎样在 GNOME 程序中使用 <application>Massif</application> 堆分析"

"器，解释怎样调用、理解已经对 <application>Massif</application> 的输出进行操"

"作。"

#: C/optimization-massif.xml:10(title)

msgid "Introduction"

msgstr "简介"

#: C/optimization-massif.xml:11(para)

msgid ""

"<application>Massif</application> is a member of the 

"url=\"http://valgrind.org/\">valgrind</ulink> suite of memory-profiling "

"tools. Its purpose is to give a detailed view of dynamic memory usage during "

"the lifetime of the program. Specifically it records the memory use of the "

"heap and the stack."

msgstr ""

"<application>Massif</application> 是 

"valgrind.org/\">valgrind</ulink> 内存分析套件的一个成员。它的目的是在程序的生"

"命期里给出动态内存使用的细节。它会专门记录堆栈的内存使用。"

#: C/optimization-massif.xml:14(para)

msgid ""

"The heap is the region of memory which is allocated with functions like "

"malloc. It grows on demand and is usually the largest region of memory in a "

"program. The stack is where all the local data for functions is stored. This "

"includes the \"automatic\" variables in C and the return address for "

"subroutines. The stack is typically a lot smaller and a lot more active than "

"the heap. We won't consider the stack explicitly since <application>Massif</"

"application> treats it as though it were just another part of the heap. "

"<application>Massif</application> also gives information about how much "

"memory is used to manage the heap."

msgstr ""

"堆是使用类似于 malloc 的函数分配内存的地方。它根据需要增长，而且通常是程序中"

"最大的内存区域。栈是存放函数的本地数据的地方，包括 C 语言中的自动变量和子函数"

"的返回地址。栈通常比堆更小更活跃。我们并没有显式地考虑栈，因为 "

"<application>Massif</application> 将其认定为堆的另外一部分。"

"<application>Massif</application> 也给出管理堆所使用的内存量。"

#: C/optimization-massif.xml:17(para)

msgid ""

"<application>Massif</application> produces two output files: a graphical "

"overview in a postscript file and a detailed breakdown in a text file."

msgstr ""

"<application>Massif</application> 产生两个输出文件：一个 postscript 格式的概"

"况以及一个文本格式的细节详述。"

#: C/optimization-massif.xml:22(title)

msgid "Using <application>Massif</application> with GNOME"

msgstr "在 GNOME 中使用 <application>Massif</application>"

#: C/optimization-massif.xml:23(para)

msgid ""

"<application>Massif</application> has very few options and for many programs "

"does not need them. However for GNOME applications, where memory allocation "

"might be buried deep in either glib or GTK, the number of levels down the "

"call-stack Massif descends needs to be increased. This is achieved using the "

"--depth parameter. By default this is 3; increasing it to 5 will guarantee "

"the call-stack reaches down to your code. One or two more levels may also be "

"desirable to provide your code with some context. Since the level of detail "

"becomes quickly overwhelming it is best to start with the smaller depth "

"parameter and only increase it when it becomes apparent that it isn't "

"sufficient."

msgstr ""

#: C/optimization-massif.xml:26(para)

msgid ""

"It is also useful to tell <application>Massif</application> which functions "

"allocate memory in glib. It removes an unnecessary layer of function calls "

"from the reports and gives you a clearer idea of what code is allocating "

"memory. The allocating functions in glib are g_malloc, g_malloc0, g_realloc, "

"g_try_malloc, and g_mem_chunk_alloc. You use the --alloc-fn option to tell "

"Masiff about them."

msgstr ""

#: C/optimization-massif.xml:29(para)

msgid "Your command-line should therefore look something like:"

msgstr "因此，您的命令行应该类似于："

#: C/optimization-massif.xml:32(programlisting)

#, no-wrap

msgid ""

"\n"

"valgrind --tool=massif --depth=5  --alloc-fn=g_malloc --alloc-fn=g_realloc --alloc-fn=g_try_malloc \\\n"

"         --alloc-fn=g_malloc0 --alloc-fn=g_mem_chunk_alloc same-gnome\n"

"        "

msgstr ""

"\n"

"valgrind --tool=massif --depth=5  --alloc-fn=g_malloc --alloc-fn=g_realloc --alloc-fn=g_try_malloc \\\n"

"         --alloc-fn=g_malloc0 --alloc-fn=g_mem_chunk_alloc same-gnome\n"

"        "

#: C/optimization-massif.xml:36(para)

msgid ""

"<application>Same GNOME</application> is the program we will be using as an "

"example. Be warned that, since valgrind emulates the CPU, it will run "

"<emphasis>very</emphasis> slowly. You will also need a lot of memory."

msgstr ""

"<application>Same GNOME</application> 是我们用来作为范例的程序。必须要警告："

"因为 valgrind 仿真 CPU，它运行得将会<emphasis>非常</emphasis> 慢，同时也需要"

"很多内存。"

#: C/optimization-massif.xml:41(title)

msgid "Interpreting the Results"

msgstr "对结果的解释"

#: C/optimization-massif.xml:42(para)

#, fuzzy

msgid ""

"The graphical output of <application>Massif</application> is largely self "

"explanatory. Each band represents the memory allocated by one function over "

"time. Once you identify which bands are using the most memory, usually the "

"big thick ones at the top you will have to consult the text file for the "

"details."

msgstr "<application>Massif</application> 的输出很大程度上是自解释的。"

#: C/optimization-massif.xml:45(para)

msgid ""

"The text file is arranged as a hierarchy of sections, at the top is a list "

"of the worst memory users arranged in order of decreasing spacetime. Below "

"this are further sections, each breaking the results down into finer detail "

"as you proceed down the call-stack. To illustrate this we will use the "

"output of the command above."

msgstr ""

#: C/optimization-massif.xml:49(title)

msgid ""

"<application>Massif</application> output for the unoptimized version of the "

"<application>Same GNOME</application> program."

msgstr ""

"未优化版本的 <application>Same GNOME</application> 程序的 "

"<application>Massif</application> 输出。"

#: C/optimization-massif.xml:56(para)

msgid ""

"<xref linkend=\"optimization-massif-FIG-output-unoptimized\"/> shows a "

"typical postscript output from <application>Massif</application>. This is "

"the result you would get from playing a single game of <application>Same "

"GNOME</application> (version 2.8.0) and then quitting. The postscript file "

"will have a name like <filename>massif.12345.ps</filename> and the text file "

"will be called <filename>massif.12345.txt</filename>. The number in the "

"middle is the process ID of the program that was examined. If you actually "

"try this example you will find two versions of each file, with slightly "

"different numbers, this is because <application>Same GNOME</application> "

"starts a second process and <application>Massif</application> follows that "

"too. We will ignore this second process, it consumes very little memory."

msgstr ""

#: C/optimization-massif.xml:59(para)

msgid ""

"At the top of the graph we see a large yellow band labelled gdk_pixbuf_new. "

"This seems like an ideal candidate for optimization, but we will need to use "

"the text file to find out what is calling gdk_pixbuf_new. The top of the "

"text file will look something like this:"

msgstr ""

#: C/optimization-massif.xml:62(programlisting)

#, no-wrap

msgid ""

"\n"

"Command: ./same-gnome \n"

"\n"

"== 0 ===========================\n"

"Heap allocation functions accounted for 90.4% of measured spacetime\n"

"\n"

"Called from:\n"

"  28.8% : 0x6BF83A: gdk_pixbuf_new (in /usr/lib/libgdk_pixbuf-2.0.so.0.400.9)\n"

"\n"

"    6.1% : 0x5A32A5: g_strdup (in /usr/lib/libglib-2.0.so.0.400.6)\n"

"\n"

"    5.9% : 0x510B3C: (within /usr/lib/libfreetype.so.6.3.7)\n"

"\n"

"    3.5% : 0x2A4A6B: __gconv_open (in /lib/tls/libc-2.3.3.so)\n"

"        "

msgstr ""

#: C/optimization-massif.xml:77(para)

msgid ""

"The line with the '=' signs indicates how far down the stack trace we are, "

"in this case we are at the top. After this it lists the heaviest users of "

"memory in order of decreasing spacetime. Spacetime is the product of the "

"amount of memory used and how long it was used for. It corresponds to the "

"area of the bands in the graph. This part of the file tells us what we "

"already know: most of the spacetime is dedicated to gdk_pixbuf_new. To find "

"out what called gdk_pixbuf_new we need to search further down the text file:"

msgstr ""

#: C/optimization-massif.xml:80(programlisting)

#, no-wrap

msgid ""

"\n"

"== 4 ===========================\n"

"Context accounted for 28.8% of measured spacetime\n"

"  0x6BF83A: gdk_pixbuf_new (in /usr/lib/libgdk_pixbuf-2.0.so.0.400.9)\n"

"  0x3A998998: (within /usr/lib/gtk-2.0/2.4.0/loaders/libpixbufloader-png.so)\n"

"  0x6C2760: (within /usr/lib/libgdk_pixbuf-2.0.so.0.400.9)\n"

"  0x6C285E: gdk_pixbuf_new_from_file (in /usr/lib/libgdk_pixbuf-2.0.so.0.400.9)\n"

"\n"

"Called from:\n"

"  27.8% : 0x804C1A3: load_scenario (same-gnome.c:463)\n"

"\n"

"    0.9% : 0x3E8095E: (within /usr/lib/libgnomeui-2.so.0.792.0)\n"

"\n"

"  and 1 other insignificant place\n"

"        "

msgstr ""

#: C/optimization-massif.xml:95(para)

msgid ""

"The first line tells us we are now four levels deep into the stack. Below it "

"is a listing of the function calls that leads from here to gdk_pixbuf_new. "

"Finally there is a list of functions that are at the next level down and "

"call these functions. There are, of course, also entries for levels 1, 2, "

"and 3, but this is the first level to reach right down through the GDK code "

"to the <application>Same GNOME</application> code. From this listing, we can "

"see instantly that the problem code is load_scenario."

msgstr ""

#: C/optimization-massif.xml:98(para)

msgid ""

"Now that we know what part of our code is using all the spacetime we can "

"look at it and find out why. It turns out that the load_scenario is loading "

"a pixbuf from file and then never freeing that memory. Having identified the "

"problem code, we can start to fix it."

msgstr ""

#: C/optimization-massif.xml:103(title)

msgid "Acting on the Results"

msgstr ""

#: C/optimization-massif.xml:104(para)

msgid ""

"Reducing spacetime consumption is good, but there are two ways of reducing "

"it and they are not equal. You can either reduce the amount of memory "

"allocated, or reduce the amount of time it is allocated for. Consider for a "

"moment a model system with only two processes running. Both processes use up "

"almost all the physical RAM and if they overlap at all then the system will "

"swap and everything will slow down. Obviously if we reduce the memory usage "

"of each process by a factor of two then they can peacefully coexist without "

"the need for swapping. If instead we reduce the time the memory is allocated "

"by a factor of two then the two programs can coexist, but only as long as "

"their periods of high memory use don't overlap. So it is better to reduce "

"the amount of memory allocated."

msgstr ""

#: C/optimization-massif.xml:107(para)

msgid ""

"Unfortunately, the choice of optimization is also constrained by the needs "

"of the program. The size of the pixbuf data in <application>Same GNOME</"

"application> is determined by the size of the game's graphics and cannot be "

"easily reduced. However, the amount of time it spends loaded into memory can "

"be drastically reduced. 

"optimized\"/> shows the <application>Massif</application> analysis of "

"<application>Same GNOME</application> after being altered to dispose of the "

"pixbufs once the images have been loaded into the X server."

msgstr ""

#: C/optimization-massif.xml:111(title)

msgid ""

"<application>Massif</application> output for the optimized <application>Same "

"GNOME</application> program."

msgstr ""

"优化后的 <application>Same GNOME</application> 程序的 <application>Massif</"

"application> 输出。"

#: C/optimization-massif.xml:118(para)

msgid ""

"The spacetime use of gdk_pixbuf_new is now a thin band that only spikes "

"briefly (it is now the sixteenth band down and shaded magenta). As a bonus, "

"the peak memory use has dropped by 200 kB since the spike occurs before "

"other memory is allocated. If two processes like this where run together the "

"chances of the peak memory usage coinciding, and hence the risk of swapping, "

"would be quite low."

msgstr ""

#: C/optimization-massif.xml:121(para)

msgid ""

"Can we do better ? A quick examination of <application>Massif</"

"application>'s text output reveals: g_strdup to be the new major offender."

msgstr ""

"我们可以做得更好吗？快速检查 <application>Massif</application> 的文本输出揭"

"示：g_strdup 是新的主犯。"

#: C/optimization-massif.xml:124(programlisting)

#, no-wrap

msgid ""

"\n"

"Command: ./same-gnome \n"

"\n"

"== 0 ===========================\n"

"Heap allocation functions accounted for 87.6% of measured spacetime\n"

"\n"

"Called from:\n"

"    7.7% : 0x5A32A5: g_strdup (in /usr/lib/libglib-2.0.so.0.400.6)\n"

"\n"

"    7.6% : 0x43BC9F: (within /usr/lib/libgdk-x11-2.0.so.0.400.9)\n"

"\n"

"    6.9% : 0x510B3C: (within /usr/lib/libfreetype.so.6.3.7)\n"

"\n"

"    5.2% : 0x2A4A6B: __gconv_open (in /lib/tls/libc-2.3.3.so)\n"

"        "

msgstr ""

#: C/optimization-massif.xml:139(para)

msgid ""

"If we look closer though we see that it is called from many, many, places."

msgstr "如果我们更自习的查看，我们发现它从很多很多地方调用。"

#: C/optimization-massif.xml:142(programlisting)

#, no-wrap

msgid ""

"\n"

"== 1 ===========================\n"

"Context accounted for  7.7% of measured spacetime\n"

"  0x5A32A5: g_strdup (in /usr/lib/libglib-2.0.so.0.400.6)\n"

"\n"

"Called from:\n"

"    1.8% : 0x8BF606: gtk_icon_source_copy (in /usr/lib/libgtk-x11-2.0.so.0.400.9)\n"

"\n"

"    1.1% : 0x67AF6B: g_param_spec_internal (in /usr/lib/libgobject-2.0.so.0.400.6)\n"

"\n"

"    0.9% : 0x91FCFC: (within /usr/lib/libgtk-x11-2.0.so.0.400.9)\n"

"\n"

"    0.8% : 0x57EEBF: g_quark_from_string (in /usr/lib/libglib-2.0.so.0.400.6)\n"

"\n"

"  and 155 other insignificant places\n"

"        "

msgstr ""

#: C/optimization-massif.xml:158(para)

msgid ""

"We now face diminishing returns for our optimization efforts. The graph "

"hints at another possible approach: Both the \"other\" and \"heap admin\" "

"bands are quite large. This tells us that there are a lot of small "

"allocations are being made from a variety of places. Eliminating these will "

"be difficult, but if they can be grouped then the individual allocations can "

"be larger and the \"heap admin\" overhead can be reduced."

msgstr ""

#: C/optimization-massif.xml:163(title)

msgid "Caveats"

msgstr "注意事项"

#: C/optimization-massif.xml:164(para)

msgid ""

"There are a couple of things to watch out for: Firstly, spacetime is only "

"reported as a percentage, you have to compare it to the overall size of the "

"program to decide if the amount of memory is worth pursuing. The graph, with "

"its kilobyte vertical axis, is good for this."

msgstr ""

#: C/optimization-massif.xml:167(para)

msgid ""

"Secondly, <application>Massif</application> only takes into account the "

"memory used by your own program. Resources like pixmaps are stored in the X "

"server and aren't considered by <application>Massif</application>. In the "

"<application>Same GNOME</application> example we have actually only moved "

"the memory consumption from client-side pixbufs to server-side pixmaps. Even "

"though we cheated there are performance gains. Keeping the image data in the "

"X server makes the graphics routines quicker and removes a lot of inter-"

"process communication. Also, the pixmaps will be stored in a native graphics "

"format which is often more compact than the 32-bit RGBA format used by "

"gdk_pixbuf. To measure the effect of pixmaps, and other X resources use the "

"

"\">xrestop</ulink> program."

msgstr ""

#: C/optimization-harmful.xml:3(title)

msgid "Disk Seeks Considered Harmful"

msgstr ""

#: C/optimization-harmful.xml:5(para)

msgid ""

"Disk seeks are one of the most expensive operations you can possibly "

"perform. You might not know this from looking at how many of them we "

"perform, but trust me, they are. Consequently, please refrain from the "

"following suboptimal behavior:"

msgstr ""

"磁盘寻道是您可能遇到的最昂贵的操作之一。从查看执行的数量，可能不能了解到，但"

"这是真的。相应地，请避免如下次优的选择："

#: C/optimization-harmful.xml:10(para)

msgid "Placing lots of small files all over the disk."

msgstr "在磁盘中到处存放很多小文件。"

#: C/optimization-harmful.xml:15(para)

msgid "Opening, stating, and reading lots of files all over the disk"

msgstr "在磁盘中，到处打开、查看、读取很多小文件。"

#: C/optimization-harmful.xml:20(para)

msgid ""

"Doing the above on files that are laid out at different times, so as to "

"ensure that they are fragmented and cause even more seeking."

msgstr ""

#: C/optimization-harmful.xml:25(para)

msgid ""

"Doing the above on files that are in different directories, so as to ensure "

"that they are in different cylinder groups and and cause even more seeking."

msgstr ""

#: C/optimization-harmful.xml:30(para)

msgid "Repeatedly doing the above when it only needs to be done once."

msgstr ""

#: C/optimization-harmful.xml:35(para)

msgid "Ways in which you can optimize your code to be seek-friendly:"

msgstr ""

#: C/optimization-harmful.xml:40(para)

msgid "Consolidate data into a single file."

msgstr ""

#: C/optimization-harmful.xml:45(para)

msgid "Keep data together in the same directory."

msgstr "将数据保持在同一个目录中。"

#: C/optimization-harmful.xml:50(para)

msgid "Cache data so as to not need to reread constantly."

msgstr "缓存数据以避免定期重读数据。"

#: C/optimization-harmful.xml:55(para)

msgid ""

"Share data so as not to have to reread it from disk when each application "

"loads."

msgstr "共享数据以便不必每个程序需要时都从硬盘读取。"

#: C/optimization-harmful.xml:60(para)

msgid ""

"Consider caching all of the data in a single binary file that is properly "

"aligned and can be mmaped."

msgstr ""

"考虑将所有的数据缓存在单个二进制文件中，并使文件正确对齐并可以将其 mmap。"

#: C/optimization-harmful.xml:65(para)

msgid ""

"The trouble with disk seeks are compounded for reads, which is unfortunately "

"what we are doing. Remember, reads are generally synchronous while writes "

"are asynchronous. This only compounds the problem, serializing each read, "

"and contributing to program latency."

msgstr ""

#: C/optimization-guide.xml:5(title)

msgid "Optimizing GNOME Software"

msgstr "优化 GNOME 软件"

#: C/optimization-guide.xml:8(publishername) C/optimization-guide.xml:56(para)

msgid "GNOME Documentation Project"

msgstr "GNOME 文档项目"

#: C/optimization-guide.xml:11(year) C/optimization-guide.xml:15(year)

msgid "2004-2005"

msgstr "2004-2005"

#: C/optimization-guide.xml:12(holder)

msgid "Callum McKenzie"

msgstr "Callum McKenzie"

#: C/optimization-guide.xml:16(holder)

msgid "Robert Love"

msgstr "Robert Love"

#: C/optimization-guide.xml:20(firstname)

msgid "Callum"

msgstr "Callum"

#: C/optimization-guide.xml:21(surname)

msgid "McKenzie"

msgstr "McKenzie"

#: C/optimization-guide.xml:24(firstname)

msgid "Robert"

msgstr "Robert"

#: C/optimization-guide.xml:25(surname)

msgid "Love"

msgstr "Love"

#: C/optimization-guide.xml:29(para)

msgid ""

"Permission is granted to copy, distribute and/or modify this document under "

"the terms of the <citetitle>GNU Free Documentation License</citetitle>, "

"Version 1.1 or any later version published by the Free Software Foundation "

"with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. "

"You may obtain a copy of the <citetitle>GNU Free Documentation License</"