Ubuntu Manpages

NÉV

ÁTTEKINTÉS

bzip2 [ -cdfkstvzVL123456789 ] [ fájlnevek ... ]
bunzip2 [ -fkvsVL ] [ fájlnevek ... ]
bzcat [ -s ] [ fájlnevek ... ]
bzip2recover fájlnév

A bzip2 Burrows-Wheeler-féle blokkrendezõ algoritmussal és Huffman-kódolással tömörít szöveges állományokat. A tömörítés mértéke általában lényegesen jobb, mint ami a legtöbb hagyományos LZ77/LZ78 alapú tömörítõvel elérhetõ, és megközelíti a statisztikus módszerrel dolgozó PPM család teljesítményét.

A parancssori opciók szándékosan igen hasonlóak a GNU Gzip opcióihoz, de nem azonosak azokkal.

A bzip2 állománynevek listáját várja a hozzájuk tartozó parancssori kapcsolókkal. Minden fájlt azok "eredeti_név.bz2" nevû tömörített változatára cserél ki. A tömörített fájlokhoz tartozó dátumok és jogok az eredetivel megegyeznek, így ezek a tulajdonságok kicsomagoláskor helyesen állíthatók vissza. A fájlnevek kezelése egyszerû abban az értelemben, hogy nincs lehetõség az eredeti fájlnevek, jogok és dátumok megõrzésére az ezeket nem támogató, vagy a MS-DOS-hoz hasonlóan szigorúan kötött hosszúságú neveket kezelõ fájlrendszerekben.

A bzip2 és a bunzip2 alapértelmezés szerint nem írnak felül már létezõ fájlokat; erre a -f kapcsoló használatával lehet rávenni õket.

Fájlnevek hiányában a bzip2 a szabványos bemenetrõl a szabványos kimenetre dolgozik. Ebben az esetben azonban a bzip2 nem fogja a tömörített adatokat a terminálra írni, mert az feldolgozhatatlan, így értelmetlen volna.

A bunzip2 (vagy a bzip2 -d ) kicsomagolja és visszaállítja a felsorolt fájlok közül a ".bz2"-re végzõdõ nevûket. A nem erre végzõdõ nevû fájlokat nem veszi figyelembe. Ismételten: ha nem adunk meg fájlnevet, a tömörítés standard inputról szabványos kimenetre történik.

A bunzip2 helyesen fogja kicsomagolni azokat a fájlokat, melyek két vagy több tömörített fájl összevonásával (összemásolásával) keletkeznek. Az eredmény a kicsomagolt fájlok egybemásolt láncolata lesz. A fájlok sértetlenségének ellenõrzése (-t) az összeláncolt archívumokon is mûködik.

A szabványos kimenetre is lehet be- illetve kicsomagolni fájlokat a -c kapcsoló megadásával. Egyszerre több fájllal is lehet így dolgozni. A keletkezõ kimenetek sorban a szabványos kimenetre kerülnek. Több fájl ily módon történõ tömörítése egy olyan adatfolyamot eredményez, melyben az egyes fájlok tömörítve szerepelnek. Egy ilyen állomány helyesen csak a bzip2 0.9.0-s vagy újabb verziójával csomagolható ki. A bzip2 régebbi verziói az elsõ fájl kibontása után megállnak.

A bzcat (vagy a bzip2 -dc ) a megadott fájlokat a szabványos kimenetre csomagolja ki.

A tömörítés mindig megtörténik, még akkor is, ha a tömörített fájl esetleg valamivel nagyobb, mint az eredeti. A kb. 100 bájtnál kisebb fájlok hajlamosak erre, mivel a tömörítõ mechanizmus maga is hozzáad úgy 50 bájtot az archívumhoz.

Az olyan adathalmazra, melyben az egyes elemek elõfordulása véletlenszerû (ilyen a legtöbb tömörítõprogram kimenete), a kódolás kb. 8.05 bit/bájt aránnyal történik, ami megközelítõleg 0.5%-os méretnövekedést eredményez.

Önellenõrzésként az adatok védelmére a bzip2 32 bites CRC-ket (ellenõrzõ összegeket) használ, így biztosítva, hogy a kitömörített állomány az eredetivel megegyezzen. Ez egyrészt a tömörített adatok sérülése ellen, másrészt pedig a bzip2 eddig fel nem derített (és remélhetõleg igen valószínûtlen) hibái ellen véd. Annak az esélye, hogy a tömörített adatban elõforduló hiba észrevétlen marad, igen kicsi, megközelítõleg egy a négybillióhoz minden egyes tömörített fájl esetében. Lényeges azonban, hogy az ellenõrzés kicsomagoláskor történik, és csak arra hívja fel a figyelmet, hogy valami nincs rendben, az eredeti adatot visszaállítani nem tudja. A bzip2recover -rel lehet megpróbálni az adatok visszaállítását a sérült fájlból.

Visszatérési értékek: 0 ha a program futása rendesen befejezõdött 1 ha környezeti problémába futott (nem találja a fájlt, rossz kapcsolót kapott, I/O hiba esetén, stb.) 2 ha a tömörített fájl hibás 3 ha belsõ hiba (pl. bug) miatt a bzip2 azonnal felfüggesztette futását.

A Bzip2 a nagy fájlokat blokkokban kezeli. A blokkméret meghatározza mind az elérhetõ tömörítési arányt, mind pedig a be- és kicsomagoláshoz szükséges memória mennyiségét. A -1 ... -9 kapcsolók az egyes blokkméreteket 100,000 ... 900,000 bájt értékekre állítják. Kibontáskor a program az arhívum fejlécébõl olvassa ki a tömörítéskor használt blokkméretet, és a bunzip2 ennek megfelelõen éppen annyi memóriát foglal le magának, amennyi a kibontáshoz szükséges. Mivel a blokkméret a tömörített fájlban van, a -1 ... -9 kapcsolóknak nincs jelentõségük és azokat a program kibontáskor figyelmen kívül hagyja.

A be- és kicsomagolás memóriaigénye bájtban megközelítõleg a


Tömörítés: 400k + ( 7 x blokkméret)


Kibontás: 100k + ( 4 x blokkméret), vagy
100k + ( 2.5 x blokkméret) képletekkel becsülhetõ meg,

Nagyobb blokkméret gyorsan csökkenõ mellékes nyereséget ad; a tömörítés jelentõs részét a blokkméret elsõ 2-300k-ja adja. Ezt érdemes fejben tartani a bzip2 kis gépeken történõ használatakor. Arról sem szabad megfeledkezni, hogy a kibontás memóriaigényét a tömörítéskor választott blokkméret határozza meg.

Az alapértelmezett 900k méretû blokkokkal tömörített fájlok esetében a bunzip2 a kibontáshoz kb. 3700k memóriát fog használni. Hogy minden fájl kibontható legyen még egy 4 megabájtos gépen is, a bunzip2 lehetõvé teszi a kibontást kb. feleennyi, megközelítõleg 2300k memória felhasználásával is. Ezzel a kibontás sebessége is felezõdik, így csak akkor érdemes használni ezt a lehetõséget, amikor valóban szükséges. Az idevonatkozó kapcsoló a -s.

Általában, ha a rendelkezésre álló memória mennyisége engedi, érdemes megpróbálkozni a legnagyobb blokkméret használatával, mivel így érhetõ el a legjobb tömörítési arány. A tömörítés és kibontás sebességét a blokkméret gyakorlatilag nem befolyásolja.

Másik lényeges pont azoknak a fájloknak az esete, melyek egyetlen blokkba beleférnek - nagy blokkméret használatakor ez a legtöbb fájlra fennáll. A ténylegesen felhasznált memória mennyisége a fájl méretével arányos, mivel a fájl kisebb, mint egy blokk. Egy 20,000 bájt hosszú fájl -9 kapcsolóval történõ tömörítésekor például kb. 6700k memóriát foglal le a tömörítõprogram, de csak 400k + 20000 * 7 = 540k-t használ belõle. Kibontáskor ehhez hasonlóan 3700k-t foglal le, de csak 100k + 20000 * 4 = 180k-t használ.

A következõ táblázat a különbözõ blokkméretekhez tartozó maximális memóriafelhasználást, valamint a Calgary Szövegtömörítés Dokumentáció összesen 3,141,622 bájtos 14 fájljának tömörített méretét tartalmazza. Ez az oszlop némi áttekintést ad arról, hogyan változik a tömörítés mértéke a blokkméret függvényében. Ezek a számok nem igazán mutatják a nagy blokkméret elõnyeit nagyobb fájlokra, mivel a Dokumentációban a kisméretû fájlok túlsúlyban vannak.


Tömörítés Kibontás Kibontás Dokumentáció
Kapcsoló mem.haszn. mem.haszn. -s -sel mérete


-1 1100k 500k 350k 914704
-2 1800k 900k 600k 877703
-3 2500k 1300k 850k 860338
-4 3200k 1700k 1100k 846899
-5 3900k 2100k 1350k 845160
-6 4600k 2500k 1600k 838626
-7 5400k 2900k 1850k 834096
-8 6000k 3300k 2100k 828642
-9 6700k 3700k 2350k 828642

Tömörítés vagy kibontás a szabványos kimenetre. A -c -vel több fájl bontható ki egyszerre, de csak egyetlen fájl tömöríthetõ a stdout-ra.

Kibontás. A bzip2, bunzip2 és a bzcat tulajdonképpen ugyanaz a program, ami annak alapján dönti el, hogy mit kell tennie, hogy melyik nevét használjuk. Ez a kapcsoló felülbírálja ezt a döntést, és a bzip2 kibontóként fog mûködni.

A -d ellentéte: a tömörítést erõlteti, függetlenül attól, hogy a programot melyik nevével indítottuk.

A megadott fájlok sértetlenségét ellenõrzi, de nem bontja ki õket. Valójában egy "próbakibontást" végez, és az eredményt eldobja.

Felülírja a kimeneti állományokat. Rendes esetben a bzip2 nem ír felül már létezõ kimeneti fájlokat.

Megtartja (nem törli le) a bemenõ állományokat be- és kitömörítéskor.

Csökkenti a memóriahasználatot, tömörítéskor, kibontáskor, és teszteléskor. A fájlok kibontása és tesztelése egy módosított algoritmussal történik, amelynek csupán 2.5 bájtra van szüksége bájtonként a blokkban. Ez azt jelenti, hogy bármelyik fájl kibontható 2300k memóriában, igaz, a normál sebességnek csaknem felével.

Tömörítéskor a -s 200k blokkméretet állít be, ami a memóriahasználatot megközelítõleg ugyanezekre az értékekre korlátozza, a tömörítés mértékének rovására. Röviden: kevés memóriával (8 megabájt vagy kevesebb) rendelkezõ gép esetében mindig használjuk a -s kapcsolót. (ld. még: MEMÓRIAKEZELÉS)

Bõbeszédû mód -- megmutatja a tömörítés mértékét minden feldolgozott fájl esetében. További -v-k a "bõbeszédûség" mértékét növelik, rengeteg olyan információt adva, melyek fõként diagnosztikai célból lehetnek érdekesek.

A program verziószámát, felhasználói engedélyeket és feltételeket jeleníti meg.

-1 to -9
Tömörítéskor a blokkméretet állítja 100k, 200k ... 900k-ra. Kibontáskor semmilyen hatása nincs. Lásd még: MEMÓRIAKEZELÉS

bzip2 Némi ál-véletlenszerû variációt visz az erõsen ismétlõdõ jellegû blokkokba, hogy tömörítéskor csökkentse a "legrosszabb eset" esetén elõálló teljesítményromlás valószínûségét. Ha a rendezés nehézségekbe ütközik, a program a blokkot összekeveri, és a rendezést újraindítja. Durván, a bzip2 háromszor annyi ideig tart ki az újrarendezés elõtt az összekeverésig, mint ameddig egy "jó" bemenet feldolgozása tartana. Ezzel a kapcsolóval sokkal hamarabb feladja.

A --repetitive-fast ellentéte; sokkal keményebben próbálkozik az összekeverésig a rendezés elõtt.

A bzip2 a fájlokat rendszerint 900 kilobájtos blokkokban tömöríti. Minden blokkot külön kezel. Ha az adathordozó vagy az átvitel hibája miatt egy több blokkból álló .bz2 fájl megsérül, elképzelhetõ az adatok megmentése az állomány sértetlen blokkjaiból.

Minden blokk tömörített megfelelõjét egy-egy 48 bites minta határolja, ami elég jó biztonsággal teszi lehetõvé a blokkhatárok megállapítását. Minden blokk tartalmazza a saját 32 bites CRC-jét, így a sérült és a sértetlen blokkok egymástól megkülönböztethetõk.

A bzip2recover egy egyszerû program, aminek célja az egyes blokkok megtalálása a .bz2 archívumban, és különálló .bz2 fájlokként való kiírása. Ezek között a bzip2 -t segítségével megkereshetõk és kibonthatók a sértetlen blokkok.

A bzip2recover egyetlen, egyszerû argumentumot fogad el, ez pedig a sérült állomány neve, és a különálló blokkokat tartalmazó fájlokat hoz létre "rec0001file.bz2", "rec0002file.bz2", stb. néven. A keletkezõ fájlok nevei olyanok, hogy az egymást követõ feldolgozásoknál a joker karakterek használatakor, például a "bzip2 -dc rec*file.bz2 > javított_adat" esetén a fájlok a helyes sorrendben jelennek meg.

A bzip2recover nagy .bz2 fájlok esetén lehet hasznos, mivel ezek több blokkot tartalmaznak. Teljesen hiábavaló a használata az egy blokkot tartalmazó sérült fájloknál, mivel sérült blokk nem állítható helyre. Az adathordozó vagy az átvitel hibáiból adódó adatvesztés lehetõségének a lehetõ legkisebbre csökkentéséhez megfontolandó esetleg a kisebb blokkméret használata.

A tömörítés rendezés fázisában a fájl hasonló részeinek összegyûjtése történik. Emiatt az ismétlõdõ szimbólumok igen hosszú láncolatát (mint pl. a több százszor ismétlõdõ "aabaabaabaab ...") tartalmazó fájl tömörítése szélsõségesen lassú lehet. Ilyenkor a -vvvvv opcióval esetleg részletesen nyomon követhetõ a folyamat. A kibontás sebességét ez nem befolyásolja.

Az ilyen beteges esetek a gyakorlatban ritkának tûnnek, fõleg tesztcélokra mesterségesen összeállított fájlokban, és alacsony szintû disk image-ekben (egy hajlékony- vagy merevlemez tartalma fájlba írva) fordulnak elõ. Ez utóbbiak bzip2 -vel történõ tömörítése nem javasolt.

Ha egy fájl tömörítésekor jelentõs lassulás tapasztalható, érdemes megpróbálni a legkisebb blokkméret beállítását a -1 kapcsolóval.

A bzip2 rendszerint pár megabájt memóriát foglal le magának, amiben dolgozhat, aztán az egészet eléggé össze-vissza módon töltögeti fel. Ez azt jelenti, hogy mind a tömörítés, mind pedig a kibontás esetén a teljesítményt nagyban az határozza meg, hogy a rendszer milyen gyorsan tudja kiszolgálni a cache-ben nem található adatokra irányuló kéréseket. Emiatt a programkód ilyen esetek arányának csökkentését célzó kis változtatására aránytalanul nagy teljesítménynövekedés figyelhetõ meg. A bzip2
így valószínûleg a nagyon nagy cache-sel rendelkezõ gépeken teljesít a legjobban.

Az I/O hibajelzések nem olyan hasznosak, amilyenek lehetnének. A bzip2 keményen próbálkozik, hogy az I/O hibákat észrevegye, és tisztán lépjen ki, de annak a részletei, hogy tulajdonképpen mi is volt a probléma, gyakran félrevezetõnek tûnnek.

Ez a kézikönyvoldal a bzip2 0.9.0-ás verzióra vonatkozik. Az ezen verzióval készített tömörített adat teljes mértékben kompatíbilis az ezt megelõzõ, szabadon terjeszthetõ 0.1pl2 verzióval készítettel, egyetlen kivétellel: 0.9.0 helyesen bontja ki a több archívumot tartalmazó összevont fájlokat. A 0.1pl2 ezt nem tudja megtenni: az elsõ fájl kibontása után megáll.

Windows 95 és NT alatt a joker karakterek használata nem tökéletes.

A bzip2recover 32 bites egészeket használ a tömörített fájlokban a bitpozíciók ábrázolására, így nem képes kezelni az 512 megabájtnál nagyobb archívumokat. Ez a probléma egyszerûen javítható.

Julian Seward, jseward@acm.org.

http://www.muraroa.demon.co.uk

A bzip2 -ben megtestesült ötletek a következõknek tulajdoníthatók: Michael Burrows és David Wheeler (blokkrendezõ transzformáció) David Wheeler (Huffman kódoló) Peter Fenwick (strukturált programozási modell az eredeti bzip -ben és több finomítás) és Alistair Moffat, Radford Neal valamint Ian Witten (az eredeti bzip aritmetikai kódolója). Köszönet illeti õket segítségükért, támogatásukért és tanácsaikért.

A program forráskódjához mellékelt dokumentációban találhatók még hivatkozások további dokumentációforrásokra. Christian von Roques ösztökélt gyorsabb rendezõ algoritmus keresésére, és a tömörítés gyorsítására. Bela Lubkin biztatott a tömörítõ "legrosszabb eset"-i teljesítményének növelésére. Több ember küldött hibajavításokat, segített hordozhatósági problémák megoldásában, adott kölcsön gépeket, adott tanácsot és volt általában segítségemre.