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 ] [ fjlnevek ...  ]
       bunzip2 [ -fkvsVL ] [ fjlnevek ...  ]
       bzcat [ -s ] [ fjlnevek ...  ]
       bzip2recover fjlnv

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)