世界杯彩票怎么买彩票双色球开奖走势qq彩票和财付通彩票上证综指低开0.32% 多数科创板个股低开

Ruby Enterprise Edition (REE) is a server-oriented distribution of the official Ruby interpreter, and includes various additional enhancements:

  • 發布時間︰

    不要編什麼檢查後備馬匹呀,試騎新馬呀這樣的故事!我實在??我實在再 也受不了連篇謊話,再也受下了你們那些叫人惡心的體貼了!”世界杯彩票怎么买 注意到;這雙手完全是皮包骨,像透明似的——您知道嗎,看死人的手看多 了,在活人的手上看到這種白里泛青的顏色,總叫人驚愕。還有??他動不 動就大動感情,這我也不喜歡︰稍微觸動一下感情,他就眼淚汪汪,略微受 了點驚,他就臉色蒼白。恰恰是開克斯法爾伐這類男子,過去性格堅韌,強 硬有力,如今變得軟弱退讓,這就使人擔憂了。如果硬漢子一下子心腸軟了, 甚至突然之間變得慈悲為懷,可惜總下會有什麼好事,我不喜歡看見這種樣 子。總有什麼東西出了漏子,里面總有什麼東西不協調了。當然——我早就 打算,為他作一次徹底的體格檢查——我不大敢跟他談這件事。因為,我的 天,如果現在還把他的思路引過去,讓他想到他自己病了,甚至想到,他可 能死去,而把癱瘓的女兒撇下,這簡直難以想象!就是不想這些,光是沒完 沒了地想他女兒的病,心急如焚,六神無主,他也會把自己徹底毀了。?? 錯了,錯了,少尉先生,您誤會我的意思了——我主要擔心的不是艾迪特, 而是他本人??我怕,這老人的時間不長了。”彩票双色球开奖走势 的腳為什麼這麼神經質地顛個不停啊?然後她突然急急忙忙他說道︰“您願 不願意至少在現在和我一起出城去吃晚飯呢?” ? ?均為著名的療養地。qq彩票和财付通彩票 ? 歌德老爹,戲指德國大詩人歌德。

    A copy-on-write friendly garbage collector. Phusion Passenger uses this, in combination with a technique called preforking, to reduce Ruby on Rails applications' memory usage by 33% on average.

  • An improved memory allocator called tcmalloc, which improves performance quite a bit.

  • The ability to tweak garbage collector settings for maximum server performance.

  • The ability to inspect the garbage collector’s state and the object heap state, for debugging purposes.

  • The ability to obtain backtraces for all running threads, making it easier for one to debug multithreaded applications.

  • Thread scheduler bug fixes and performance improvements. Threading on Ruby Enterprise Edition can be more than 10 times faster than official Ruby 1.8.

  • Various memory management tweaks so that the Ruby interpreter uses less memory on average, even when copy-on-write is not utilized.

Some of these features are gathered from third party Ruby patches: RailsBench, Sylvain Joyeux’s object allocation patch, caller_for_all_threads, Darryl Gove’s and Miriam Blatt’s Sparc optimization patches, Brent Roman’s MBARI patch set.

2. Installation and uninstallation

2.1. Installation via Debian package or source tarball

To install REE, download either the source tarball or the Debian package from the REE website. The source tarball contains a cross-platform installer. Installation instructions are available on the download page.

Note that this installer is written in Ruby, and thus requires a Ruby interpreter to run. Because not all systems come with a Ruby interpreter by default, the source tarball also contains a number of precompiled Ruby interpreters for various platforms, with the purpose of running the installer. The installer script will automatically use a precompiled Ruby binary for the current platform, if available. Precompiled Ruby interpreters for the following platforms are included:

  • x86 Linux

  • x86_64 Linux

  • x86 FreeBSD 6

  • Solaris

MacOS X and most FreeBSD systems already come with a Ruby interpreter by default.

So if you notice that the installer fails to start, please install Ruby first, then re-run the installer.

Warning It is not recommended to install REE into /usr because it can overwrite your existing Ruby installation in a way that the system doesn’t expect. You should install REE into an isolated place such as /opt.

2.1.1. Installation options

Disabling tcmalloc

If you experience problems with the tcmalloc memory allocator, then you can install REE without tcmalloc by passing --no-tcmalloc to the installer.

Non-interactive installation

You can install REE non-interactively either by using the Debian package, or by passing --auto=DIRECTORY to the REE installer. The latter will instruct the installer to non-interactively install REE into the specified target directory.

More options

You can read about all of the available installation options by passing --help to the REE installer.

2.2. Manual installation (for experts)

If you wish to install REE from source, but do not wish to use the included installer, or if the installer doesn’t work, then you can install REE manually. Please follow the instructions below.

Note that these instructions do not cover installing RubyGems.

2.2.1. Prerequisites

You need to have the following dependencies installed:

  1. A C and C++ compiler, preferrably gcc.

  2. The make tool.

  3. The patch tool.

  4. C development headers for zlib.

  5. C development headers for OpenSSL.

  6. C development headers for GNU Readline.

  7. yacc or bison.

2.2.2. Step 1: Download and extract the source tarball

Type:

tar xzvf ruby-enterprise-x.x.x.tar.gz

A directory called ruby-enterprise-x.x.x will now appear.

2.2.3. Step 2: Decide the prefix you want to install REE to

Please decide on a prefix to install REE to, and put this directory name into the PREFIX environment variable. We’ll need this value later in these instructions.

For example, if you want to install REE into /opt/ruby-enterprise, then run:

PREFIX=/opt/ruby-enterprise

Please note that the rest of this document assumes that REE is installed into /opt/ruby-enterprise. If you installed REE into a different directory then just replace /opt/ruby-enterprise with whatever the real prefix is.

2.2.4. Step 3: Install tcmalloc

Tcmalloc is a memory allocator which is usually more efficient than the platform’s native memory allocator. REE doesn’t require tcmalloc, but it will work better if tcmalloc is installed.

Compile tcmalloc as follows:

cd ruby-enterprise-x.x.x/source/distro/google-perftools-*
./configure --prefix=$PREFIX --disable-dependency-tracking
make libtcmalloc_minimal.la

If compilation fails, then skip to step 5. REE will work fine without tcmalloc.

After compilation, install tcmalloc as follows:

sudo mkdir -p $PREFIX/lib
sudo rm -f $PREFIX/lib/libtcmalloc_minimal*.so*
sudo cp -Rpf .libs/libtcmalloc_minimal*.so* $PREFIX/lib/
Note
MacOS X note
Instead of typing libtcmalloc_minimal*.so*, type libtcmalloc_minimal*.bundle*.
Note The reason why we don’t instruct you to type make and make install is because compiling tcmalloc with make usually doesn’t work on 64-bit platforms. The above instructions are a little bit more complex, but they work on all platforms where tcmalloc is supported.

2.2.5. Step 4: Configure REE

Change the current working directory to ruby-enterprise-x.x.x/source. If you were previously in the google-perftools directory, then type:

cd ../..

Run the configure script:

./configure --prefix=$PREFIX --enable-mbari-api CFLAGS='-g -O2'

2.2.6. Step 5: Compiling and installing the system_allocator library (MacOS X only)

If you are on MacOS X, then compile and install the system_allocator library:

gcc -dynamiclib system_allocator.c -install_name @rpath/libsystem_allocator.dylib -o libsystem_allocator.dylib
sudo install libsystem_allocator.dylib $PREFIX/lib/

2.2.7. Step 6: compiling and installing REE

Open Makefile. Search for a line which starts with:

LIBS =

Append the string $(PRELIBS) to the part after the = sign. For example, on Ubuntu 8.04, the 'LIBS = ' line becomes:

LIBS = $(PRELIBS) -ldl -lcrypt -lm  $(EXTLIBS)

Save the file. Now we can proceed with compiling REE:

make PRELIBS="-Wl,-rpath,$PREFIX/lib -L$PREFIX/lib -ltcmalloc_minimal"

Notes:

  • If you did not install tcmalloc, then you can omit the -ltcmalloc_minimal part.

  • If you are on MacOS X, then you need to append -lsystem_allocator to the PRELIBS option.

  • If you are on FreeBSD, then you need to append -lpthread to the PRELIBS option.

Now that REE has been compiled, install it with:

sudo make install

2.3. RubyCocoa compatibility and --enable-shared

In order to use RubyCocoa, the Ruby interpreter must be compiled with --enable-shared. By default, Ruby Enterprise Edition’s interpreter is not compiled with --enable-shared. You can compile the Ruby Enterprise Edition interpreter with this flag by passing -c --enable-shared to its installer, like this:

./ruby-enterprise-X.X.X/installer -c --enable-shared

Please note that enabling --enable-shared will make the Ruby interpreter about 20% slower. It is for this reason that we don’t recommend enabling --enable-shared on server environments, although it’s fine for desktop environments.

2.4. Tcl/Tk compatibility and --enable-pthread

In order to use Tcl/Tk with threading support, the Ruby interpreter must be compiled with --enable-pthread. By default, Ruby Enterprise Edition’s interpreter is not compiled with --enable-pthread. You can compile the Ruby Enterprise Edition interpreter with this flag by passing -c --enable-pthread to its installer, like this:

./ruby-enterprise-X.X.X/installer -c --enable-pthread

Please note that enabling --enable-pthread will make the Ruby interpreter about 50% slower. It is for this reason that we don’t recommend enabling --enable-shared on server environments, although it’s fine for desktop environments.

2.5. How REE installs itself into the system

By default, REE installs itself into a directory in /opt. If you already had a Ruby interpreter installed (typically in /usr; let’s call this the system Ruby interpreter), then REE will have no effect on it: REE lives in isolation and in parallel to the system Ruby interpreter. This also means that:

  • If you have any software which depends on the system Ruby interpreter, then that software will not break. It will continue to work like before.

  • REE has its own set of Ruby libraries, and its own set of gems and its own set of commands. If you install a new gem using the system Ruby interpreter, then that gem will not show up in REE’s gem list, and vice versa.

  • When running Ruby programs, the system Ruby interpreter will be used unless you explicitly configure the system to use REE by default.

2.5.1. Why doesn’t REE use the system Ruby interpreter’s gems?

REE does not use the system Ruby interpreter’s gems because it can cause problems with native extensions, e.g. RMagick, Mongrel, Hpricot, etc. A native extension compiled for one Ruby installation might crash when used in a different Ruby installation. This is why you must reinstall your gems in REE.

2.6. Upgrading

To upgrade REE through the Debian package, just install the Debian package.

To upgrade REE through the source tarball, run the installer in the source tarball and specify the same destination prefix directory that REE is currently installed in. For example, if REE is currently installed in /opt/ruby-enterprise-20081215, then specify /opt/ruby-enterprise-20081215 in the upgrade source tarball’s installer.

2.7. Uninstallation

If you installed REE through a Debian package, then uninstall the Debian package with dpkg or with apt-get.

If you installed REE through the source tarball, then you can uninstall it by deleting the directory in which REE is installed. For example, if REE was installed to /opt/ruby-enterprise-X.X.X (the default), then just delete that directory. It is for this reason why we recommend installing REE into its own directory.

3. Using Ruby Enterprise Edition

3.1. General usage

Normally one would run a Ruby program by invoking the Ruby interpreter with a source file as its first argument:

$ ruby some_program.rb

To run the same program in REE, invoke the equivalent command in REE’s bin folder:

$ /opt/ruby-enterprise-X.X.X/bin/ruby some_program.rb

The same applies to other Ruby commands such as gem, irb and rake. For example, if you want to install Ruby on Rails for REE, invoke:

$ /opt/ruby-enterprise-X.X.X/bin/gem install rails

3.2. Using REE with Phusion Passenger

To use REE in combination with Phusion Passenger, you must run the Passenger Apache 2 module installer that’s associated with REE. The REE installer installs the Passenger gem by default, so you just have to run the Passenger Apache 2 module installer:

/opt/ruby-enterprise-X.X.X/bin/passenger-install-apache2-module

Then follow the instructions that the installer gives you.

3.3. Configuring REE as the default Ruby interpreter

It is possible to configure REE as the default Ruby interpreter, so that when you type ruby, gem, irb, rake or other Ruby commands, REE’s version is invoked instead of the system Ruby’s version.

To do this, you must add REE’s bin directory to the beginning of the PATH environment variable. This environment variable specifies the command shell’s command search path. For example, you can do this on the command-line:

$ ruby some_program.rb    # <--- some_program.rb is being run
                          #      in the system Ruby interpreter.

$ export PATH=/opt/ruby-enterprise-X.X.X/bin:$PATH
$ ruby some_program.rb    # <--- some_program.rb will now be run in REE!

Invoking export PATH=... on the command-line has no permanent effect: its effects disappear as soon as you exit the shell. To make the effect permanent, add an entry to the file /etc/environment instead. On Ubuntu Linux, /etc/environment looks like this:

PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games"
LANG="en_US.UTF-8"
LANGUAGE="en_US:en"

Add REE’s bin directory to the PATH environment variable, like this:

PATH="/opt/ruby-enterprise-x.x.x/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games"
LANG="en_US.UTF-8"
LANGUAGE="en_US:en"

4. Garbage collector and object space

4.1. Copy-on-write friendliness

By default, REE’s garbage collector is not copy-on-write-friendly, just like a stock Ruby interpreter. Copy-on-write-friendliness can be turned on during runtime by calling: