Provided by: manpages-hu_20010119-5_all bug

NÉV

       bzip2, bunzip2 - 'block-sorting' eljárással dolgozó tömörítőprogram, v0.9.0
       bzcat - stdout-ra csomagolja ki az állományt
       bzip2recover - sérült bzip2 adatait próbálja megmenteni

ÁTTEKINTÉS

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

LEÍRÁS

       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.

MEMÓRIAKEZELÉS

       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

OPCIÓK

       -c --stdout
              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.

       -d --decompress
              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.

       -z --compress
              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.

       -t --test
              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.

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

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

       -s --small
              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)

       -v --verbose
              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.

       -L --license -V --version
              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

       --repetitive-fast
              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.

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

ADATMENTÉS SÉRÜLT FÁJLOKBÓL

       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 TELJESÍTMÉNYRŐL

       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.

FIGYELMEZTETÉS

       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ó.

SZERZŐ

       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.

                                                                                         bzip2(1)