Current version - par2cmdline 0.4 with Intel Threading Building Blocks 2.2

• This is the standard CPU-only version and is considered stable. An experimental CPU/GPU version is available further down this page.

  Download: [328kB] Source code (GPLv2).

  Download: [197kB] FreeBSD 64-bit x86_64 binary (command line only).

  Download: [225kB] GNU/Linux 64-bit x86_64 binary for kernel 2.6 / GCC 4 (command line only).

  Download: [377kB] Mac OS X 10.4 32-bit Intel and Mac OS X 10.5 64-bit Intel binary (command line only).

  Download: [238kB] 32-bit binary for Windows XP/Vista/7 (command line only). Note: this version is untested under Windows 2000 - it may work, it may not.

  Download: [266kB] 64-bit binary for 64-bit Windows XP, 64-bit Windows Vista, or 64-bit Windows 7 (command line only). Warning: a 64-bit capable CPU is not sufficient to use this binary. You must also have a 64-bit version of Windows installed.

  Download: [180kB 20090203] FreeBSD 32-bit i386/ia32 binary (command line only).

  Download: [188kB 20090203] GNU/Linux 32-bit i386/ia32 binary for kernel 2.6 / GCC 4 (command line only).

  The changes in the 20100203 version are:

  • modified Makefile.am to use "ARCH_SCALAR" instead of "ARCH" to avoid a FreeBSD name clash
  • fixed a 64-bit-only bug in reedsolomon-x86_64-mmx.s where a size of 8 bytes caused a segfault (forgot to test for zero like the reedsolomon-i686-mmx.s file does); this bug only manifests in the 64-bit Mac, 64-bit Linux and 64-bit FreeBSD versions; reproduced by creating/repairing a file of exactly 16384 bytes
  • updated to Intel TBB 2.2 (tbb22_20090809oss)
  • the Mac build no longer includes the PowerPC variants (I don't use a PowerPC Mac anymore)
  • the 32-bit and 64-bit Windows builds of both par2 and the TBB library are now statically linked against the C runtime library to avoid the problem of requiring the installation of the correct CRT library (DLL). As well, par2 is statically linked against the TBB library to allow just one executable file to be installed (i.e., just par2.exe).

• This is the experimental CPU/GPU version. It may be useless to you.

  Download: [316kB] Source code (GPLv2). See CPU-only version (the source files are the same).

  Download: [192kB] Mac OS X 10.5 32-bit Intel binary (command line only).

  Download: [208kB] Windows XP 32-bit binary (command line only).

  The changes in the 20090203 version are:

  • fixed a bug which affected the Linux and Mac versions whereby repairs would fail if the file being repaired was short or had one or two bad blocks (because the async write to the file's last byte was failing).
  • on Windows, the program now stores directory paths in par2 files using '/' as the path separator instead of '\' (as per the Par 2.0 specification document). Note: directory paths are stored only when the '-d' switch is used.
  • merged the sources from the CPU-only and CPU/GPU versions so that both versions now build from the same set of source files using different 'configure' options (Mac, Linux, FreeBSD) or project files (Windows). See the source distribution's README_FIRST.txt for building instructions.

  About the NVIDIA CUDA version

  There is no guarantee that this program will perform correctly. It may not create or repair data files correctly due to unknown bugs in the program code. Even though it has been tested on test data and correctly worked on those files, it may not work on your files since the GPU program is new and may have unknown bugs in it. Caveat emptor.

  This version of the par2 program has been modified to utilise NVIDIA CUDA 2.0 technology, which enables it to process data using the processor (GPU) on certain video cards. Most of the processing is still performed by the computer's CPU but some will be offloaded to the video card's GPU. The amount of offloading depends on how much speed/power the GPU has. After processing all of the data for par2 creation or par2 repair, the program will display, as a percentage, how much of the processing was done by the GPU (or whether the GPU was not available for use).

  There are two factors which determine how much processing the GPU can provide:

  1. the amount of video card memory. Some of the memory will be used for the video display, and this is partly determined by the operating system. For example, if the OS/video-driver performs drawing acceleration using extra video memory, less memory is available for CUDA use. For example, on a 128MB video card running Mac OS X 10.5, only about 22MB was available for use by CUDA applications. If the parity data totals more than 22MB, only a portion of that data can be processed by the GPU. Of course this is only an example and your system will probably have a different amount of memory available for CUDA use. Because of OS use, it is recommended that for Mac OS X, a video card with at least 256MB of video memory is recommended. For Windows XP, a video card of at least 128MB is recommended, and for Windows Vista, at least 256MB is recommended.
  2. the video card's speed, which depends on both the GPU's speed and the video memory's bandwidth. For the GPU, its speed depends on both its clock rate and the number of stream processors it has. For example, a GeForce 8600 GT has 32 stream processors compared to a 9800 GTX which has 128 stream processors. Memory bandwidth depends on both how wide the data path is between the GPU and its memory (for example, a 64-bit wide data bus will transfer data half as quickly as a 128-bit wide data bus), as well as the clock rate of the video memory - the higher the clock rate, the faster the GPU can move data from/to the video memory and this in turn affects how fast it processes data.

  Hardware requirements:

  Requires a "Compute Capability 1.1" device, which is any 200 series GeForce card, any 9 series GeForce card, and most 8 series GeForce card EXCEPT for the first generation cards such as the 8800 Ultra, 8800 GTX, 8800 GTS, and certain Tesla and Quadro cards: search the web for "Compute Capability 1.0" devices. 1.0-only devices are not capable of being used. Cards such as the 8400, 8500, 8600, 8800 GS, 8800 GT, 8800M GTS (mobile), and 8800M GTX (mobile) are capable of being used.

  Mobile variants will also work, for example, 8600 refers to both the desktop and mobile versions such as 8600 GT (desktop) and 8600M GT (mobile).

  Software requirements:

  The CUDA runtime/toolkit may need to be downloaded and installed by you because NVIDIA do not permit redistribution of it with third party executables. If you need to install the runtime, please search for "NVIDIA CUDA toolkit" in your favourite search engine.

  On Windows, it appears that the CUDA runtime/toolkit ships with recent video card driver software from NVIDIA. You can verify this by checking for it at this path: "C:\Windows\system32\nvcuda.dll".

  On Mac OS X 10.5, check for the driver at this path: "/System/Library/Extensions/CUDA.kext", and for the runtime library at this path: "/usr/local/cuda/lib/libcudart.dylib". Mac OS X users will probably need to download and install the CUDA runtime/toolkit. You should be aware that the default install options for the CUDA runtime/toolkit does not install the required CUDA driver, so it needs to be installed by performing a custom install of the runtime/toolkit: be sure to check the checkbox for "CUDA.kext".

  Limitations:

  1. only available as a 32-bit executable for Windows XP and later, and Intel Mac OS X 10.5.2 and later. Due to time constraints, other systems such as GNU/Linux are not available at this time. You are most welcome to modify/build/test it for other systems if you feel up to the challenge :)
  2. "low end" GPUs are "slow", ie, they do not contribute to much of the processing. For example, to create 128MB (256 blocks of 524288 bytes) of parity data on a 128MB 8600M GT in a Core 2 Duo 2.2GHz machine, about 2% of the workload was offloaded to the GPU. For the same 128MB of parity data, a 256MB 8600M GT in a Core 2 Duo 2.4GHz machine offloaded about 5% of the workload to the GPU (mainly because having more memory allowed more data to be processed on the video card). It is expected that "high end" video cards will have even higher GPU offloading, but without access to such a video card (yes, some of us can't splurge on that top-of-the-line video card!), it's mere speculation as to what sort of performance will occur. :) Maybe someone will send an email with some answers :)
  3. sometimes the CUDA runtime reports little or no available memory on the video card for use by programs, which will result in this version not being able to use the GPU for processing. This problem is probably related to video display acceleration by the OS, in which case, closing windows and/or applications will probably free up video memory. It may, however, require a reboot to reset the video card (you should do this only as a last resort).

  See the "--- About the NVIDIA CUDA version ---" section in the distribution's README_FIRST.txt file for more information such as source code building instructions/requirements.

Questions? Remarks? Comments? Please use the contact page.

Copyright 2007-2009, chuchusoft.com

Hosted by www.000webhost.com