627 lines
27 KiB
TeX
627 lines
27 KiB
TeX
\documentclass[a4paper]{article}
|
|
\usepackage[utf8]{inputenc}
|
|
\usepackage[T1]{fontenc}
|
|
\usepackage[slovene]{babel}
|
|
\usepackage{amsmath}
|
|
\usepackage{amssymb}
|
|
\usepackage{graphicx}
|
|
\usepackage{longtable}
|
|
\usepackage{fancyvrb}
|
|
\usepackage{booktabs}
|
|
\usepackage{array}
|
|
\usepackage{calc}
|
|
\usepackage{hyperref}
|
|
\usepackage{geometry}
|
|
\geometry{a4paper, margin=2.5cm}
|
|
\usepackage{pmboxdraw}
|
|
\usepackage{newunicodechar}
|
|
\newunicodechar{├}{\textSFviii}
|
|
\newunicodechar{─}{\textSFx}
|
|
\newunicodechar{└}{\textSFii}
|
|
\newunicodechar{│}{\textSFxi}
|
|
\newtheorem{opomba}{Opomba}
|
|
\newcommand{\gitobject}[2]{\texttt{.git/objects/#1/#2}}
|
|
\title{Matematični pogled na Git}
|
|
\author{Martin Vuk}
|
|
\date{\today}
|
|
\begin{document}
|
|
|
|
\maketitle
|
|
\begin{abstract}
|
|
Git je program, ki omogoča vodenje zgodovine različic datotek v neki
|
|
mapi(direktoriju). V glavnem se uporablja za upravljanje z izvorno kodo
|
|
pri razvoju računalniških programov. Mnogi med nami pa ga uporabljajo
|
|
tudi pri pisanju besedil v \LaTeX-u. Poleg tega, da Git hrani
|
|
zgodovino sprememb, tudi olajša združevanje sprememb, ko več ljudi hkrati
|
|
ureja iste datoteke. Ogledali si bomo, kako Git deluje. Opisali bomo,
|
|
kako Git uporabi \emph{zgoščevalne funkcije}, \emph{Merklejeva drevesa}
|
|
in \emph{usmerjene aciklične grafe}, da shrani zgodovino različic in
|
|
olajša hkratno urejanje vsebine. Matematični model, ki ga Git uporablja
|
|
je v resnici zelo preprost in njegovo razumevanje nas lahko reši
|
|
marsikatere zagate, ki nastane med njegovo uporabo.
|
|
\end{abstract}
|
|
|
|
\section{Kaj je Git?}
|
|
|
|
\href{https://git-scm.com/}{Git} je kot \emph{časovni stroj} za
|
|
datoteke. Uporabniku omogoča, da vidi \emph{pretekle različice}
|
|
datotek, spreminja datoteke, brez skrbi, da bi kaj pokvaril in
|
|
jih deli z drugimi. Poleg časovnega stroja je Git
|
|
tudi \emph{razpršeno skladišče datotek}. Omogoča, da datoteke
|
|
hkrati ureja več uporabnikov na različnih računalnikih in
|
|
kasneje spremembe združi.
|
|
|
|
Git hrani vsebino mape z datotekami in celotno zgodovino različic
|
|
datotek iz preteklosti. Za vsako različico hrani Git zapis o avtorju,
|
|
datumu in opis sprememb, ki so nastale v primerjavi s predhodno
|
|
različico. Vse te imformacije dajejo podroben pregled nad zgodovino
|
|
sprememb.
|
|
|
|
Sisteme, ki omogočajo hranjenje preteklih različic datotek, imenujemo
|
|
\href{https://en.wikipedia.org/wiki/Version_control}{sistemi za nadzor
|
|
različic} (angl. version control system (VCS)) ali \emph{sistemi za
|
|
upravljanje z izvorno kodo} (angl. Source Code Management (SCM)).
|
|
Poleg nadzora različic Git omogoča hkratno spreminjanje datotek več
|
|
uporabnikov na različnih računalnikih. Zato je Git
|
|
\href{https://en.wikipedia.org/wiki/Distributed_version_control}{distribuiran
|
|
sistem za nadzor različic} (angl. Distributed Version Control System
|
|
(DVCS)).
|
|
|
|
\begin{opomba}
|
|
Ljudje pogosto mešajo Git in GitHub, ki pa nista eno in isto.
|
|
Git je program, ki si ga lahko vsakdo namesti in poganja na svojem
|
|
računalniku. Program Git je ustvaril Linus Torvalds, da bi lažje
|
|
upravljal z izvorno kodo za jedro operacijskega sistema Linux. GitHub je
|
|
javno spletišče, ki je namenjeno skladiščenju Git repozitorijev.
|
|
\end{opomba}
|
|
|
|
V nadaljevanju si bomo ogledali, kako Git uporablja
|
|
\href{https://sl.wikipedia.org/wiki/Zgo\%C5\%A1\%C4\%8Devalna_funkcija}{zgoščevalno funkcijo}
|
|
(angl. hash function) in posplošitev
|
|
\href{https://en.wikipedia.org/wiki/Merkle_tree}{Merklejevih dreves}
|
|
za hranjenje posnetkov vsebine mape. Kako zgodovino sprememb predstavimo z
|
|
\href{https://en.wikipedia.org/wiki/Directed_acyclic_graph}{usmerjenim
|
|
acikličnim grafom}, v katerem so vozlišča različice, povezave pa
|
|
povežejo različice z njihovimi neposrednimi predhodniki in
|
|
kako preproste reference (kazalci) na vsebino
|
|
omogočajo bliskovito preklaplanje med različicami in preprečijo
|
|
popolno zmešnjavo, ko več ljudi hkrati spreminja iste datoteke?
|
|
|
|
\section{Podatkovno skladišče}
|
|
|
|
Ko ustvarimo nov Git repozitorij, Git ustvari podmapo z imenom
|
|
\texttt{.git} z vsemi podatki, ki jih potrebuje. V mapi
|
|
\texttt{.git} se hranijo različne stvari:
|
|
|
|
\begin{itemize}
|
|
\item
|
|
vsebina datotek, ki smo jih dodali v repozitorij,
|
|
\item
|
|
drevesna struktura korenske mape, ki jo hranimo v repozitoriju,
|
|
\item
|
|
posnetki stanja v različnih trenutkih s podatki o avtoju, datumu in
|
|
opisu sprememb,
|
|
\item
|
|
kazalci na posamezne posnetke stanja.
|
|
\end{itemize}
|
|
|
|
Git repozitorij je vsaka mapa, ki vsebuje podmapo \texttt{.git} z zgoraj
|
|
navedenimi podatki. Kako Git hrani podatke bomo spoznali v
|
|
nadaljevanju, podrobnosti pa si lahko preberete v knjigi Pro Git \cite{chacon_102_nodate}.
|
|
|
|
\section{Zgoščevalna funkcija}
|
|
|
|
Git ne shranjuje datotek z običajnimi imeni, ampak za ime uporabi 160
|
|
bitno število (40 mestno število v 16-tiškem zapisu), ki ga izračuna iz
|
|
vsebine datoteke. Git za izračun imena uporabi \emph{zgoščevalno
|
|
funkcijo}. Naj bo \(B\) množica vseh možnih podatkovnih nizov(besedil),
|
|
\(n\)-bitna zgoščevalna funkcija je funkcija
|
|
\[
|
|
H:B \rightarrow \left\{ 0,1,\ldots,2^{n} - 1 \right\},
|
|
\]
|
|
ki vsakemu besedilu \(b\) priredi \(n\)-bitno vrednost \(H(b)\). Vrednosti
|
|
zgoščevalne funkcije \(H(b)\) pravimo \emph{zgostitev} vsebine \(b\)
|
|
(angl. hash). Git hrani datoteke pod imeni, ki so enaka zgostitvi
|
|
vsebine. Kaj pa če imata dve različni vsebini isto zgostitev? Funkcija
|
|
\(H\) ni injektivna, saj je množica nizov, bistveno večja od množice
|
|
zgostitev. To pomeni, da imata lahko dve različni datoteki enako
|
|
zgostitev. Če se to zgodi, rečemo, da pride do \emph{trka
|
|
zgostitve}. V primeru trka zgostitve bi Git shranil le eno datoteko,
|
|
za drugo pa bi predpostavil da je že shranjena. Zato je funkcija \(H\)
|
|
izbrana tako, da sprememba enega samega bita v besedilu \(b \in B\)
|
|
spremeni vrednost \(H(b)\) in je porazdelitev vrednosti \(H(b)\) čim
|
|
bližje enakomerni porazdelitvi. To pomeni, da so vse vrednosti \(H(b)\)
|
|
približno enako verjetne. Na ta način zmanjšamo verjetnost trka
|
|
(glej poglavje \ref{sec_trk}). Verjetnost trka
|
|
je izjemno majhna, zato Git lahko predpostavi, da je niz \(b\) enolično
|
|
določen z njegovo zgostitvijo \(H(b)\).
|
|
Git uporablja \(160\) bitno zgoščevalno funkcijo \emph{SHA1}, ki se je
|
|
uporabljala v kriptografiji\footnote{Leta 2017 so raziskovalci iz CWI
|
|
Amsterdam in Google Research našli prvi praktični primer dveh
|
|
različnih pdf datotek, ki imata isto SHA1
|
|
zgostitev\cite{stevens_first_2017}. Opisan napad so poimenovali
|
|
\emph{SHAttered}. Git je zato z verzijo \texttt{v2.13.0} začel
|
|
uporabljati verzijo SHA1, ki je odporna proti napadu \emph{SHAttered}.
|
|
Kljub temu razvijalci Gita načrtujejo, da bodo SHA1 postopoma
|
|
nadomestili s $256$ bitno zgoščevalno funkcijo SHA-256.}.
|
|
|
|
Ko datoteko z vsebino \(b\) zabeležimo v Git repozitorij, Git izračuna
|
|
zgostitev vsebine \(H(b)\) in jo shrani v datoteko z imenom \(H(b)\) v
|
|
\texttt{.git/objects}\footnote{V resnici Git shrani vsebino v datoteko z
|
|
imenom \(h_{3}h_{4}\ldots h_{40}\) v mapi \(h_{1}h_{2}\), kjer je
|
|
\(h_{1}h_{2}h_{3}\ldots h_{40}\) zapis \(H(b)\) v 16-tiškem sistemu.
|
|
Datoteka, katere vsebina ima zgostitev \(H(b)\) enako
|
|
\texttt{8dd6d4bdaeff93016bd49474b54a911131759648} bo shranjena v
|
|
\texttt{.git/objects/8d/d6d4bdaeff93016bd49474b54a911131759648}. Zavoljo preglednosti
|
|
bomo v nadaljevanju večrat napačno zatrjevali, da je ime datoteke enako zgostitvi
|
|
njene vsebine.}.
|
|
Vsebina \(b\) je tako vedno dostopna pod imenom, ki je enako njeni
|
|
zgostitvi \(H(b)\). Tako dobimo
|
|
\href{https://en.wikipedia.org/wiki/Content-addressable_storage}{vsebinsko
|
|
naslovljivo shrambo objektov}, ki je ena od bistvenih značilnosti Gita.
|
|
Ta način shranjevanja omogoča, da lahko vedno preverimo, če ima
|
|
shranjenjena vsebina isto zgostitev, kot je njeno ime. Lahko tudi
|
|
shranimo več različic iste datoteke, saj ima vsaka različica drugačno
|
|
zgostitev. Zgostitev služi tudi kot kontrola, če je prišlo do kvaritve
|
|
podatkov, ki so shranjeni v Git repozitoriju.
|
|
|
|
\section{Datotečna drevesa}
|
|
|
|
V vsebinsko naslovljivo shrambo objektov lahko shranimo vsebino datotek
|
|
in njihovih prejšnjih različic. A kako ohranimo informacijo o imenu
|
|
datotek in drevesni strukturi mape? Git za to ustvari nov tip objekta
|
|
\emph{drevo} (angl. \emph{tree}), ki hrani preprost seznam imen datotek
|
|
in naslovov na vsebino datotek v mapi. Naslov na vsebino datoteke \(b\)
|
|
je seveda zgostitev vsebine \(H(b)\).
|
|
\begin{figure}[h]
|
|
\centering
|
|
\begin{Verbatim}[frame=single]
|
|
100644 blob 33476f4951afc28d5ac2dc0d42d82f17ac817de2 bla.txt
|
|
100644 blob 2ce22b4dc77442103f095503f1205937c1b0fcfc blabla.txt
|
|
040000 tree ae247f2a35aadade5863aec2475cf13020304b06 podmapa
|
|
\end{Verbatim}
|
|
\caption{Vsebina mape v Gitu je preprost seznam datotek in podmap ter
|
|
zgostitev njihove vsebine. Številke na začetku določajo dovoljenja za datoteke
|
|
po sistemu Posix.}
|
|
\end{figure}
|
|
|
|
Drevo je preprost seznam v tekstovni datoteki, za katerega lahko prav tako izračunamo zgostitev.
|
|
Zgostitev datotečnega drevesa natanko določa tako imena kot
|
|
tudi vsebino datotek, ki so vsebovane v mapi. Če se katerakoli datoteka
|
|
ali njeno ime v mapi spremeni, se bo spremnila tudi njena zgostitev
|
|
in posledično zgostitev za drevo. Poleg posameznih datotek, lahko drevo
|
|
vsebuje tudi poddrevesa. Tako lahko rekurzivno ustvarimo drevesno
|
|
podatkovno strukturo, ki zajema mapo z datotekami in podmapami v
|
|
poljubni globini.
|
|
|
|
Poglejmo si primer. Denimo, da imamo v korenski mapi naslednje datoteke in
|
|
podmape.
|
|
|
|
\begin{figure}[h]
|
|
\centering
|
|
\begin{Verbatim}
|
|
├── bla.txt (vsebina: bla)
|
|
├── blabla.txt (vsebina: blabla)
|
|
└── podmapa
|
|
└── bla.txt (vsebina: bla)
|
|
\end{Verbatim}
|
|
\caption{Struktura datotek in podmap, ki jo bomo hranili v Gitu.}
|
|
\end{figure}
|
|
|
|
Git bo shranil naslednje objekte v vsebinsko naslovljivo shrambo:
|
|
|
|
\begin{itemize}
|
|
\item
|
|
vsebino datoteke \texttt{bla.txt}
|
|
\begin{Verbatim}[frame=single]
|
|
bla
|
|
\end{Verbatim}
|
|
v \gitobject{bc}{c1382241e267cf790ca6b3afe9fde6dcf1072f}
|
|
\item
|
|
vsebino datoteke \texttt{blabal.txt}
|
|
\begin{Verbatim}[frame=single]
|
|
blabla
|
|
\end{Verbatim}
|
|
v \gitobject{2c}{e22b4dc77442103f095503f1205937c1b0fcfc}
|
|
\item
|
|
seznam datotek v mapi \texttt{podmapa}
|
|
|
|
\begin{Verbatim}[frame=single]
|
|
100644 blob bcc1382241e267cf790ca6b3afe9fde6dcf1072f bla.txt
|
|
\end{Verbatim}
|
|
v \gitobject{ae}{247f2a35aadade5863aec2475cf13020304b06}
|
|
\item
|
|
seznam datotek v korenski mapi
|
|
\begin{Verbatim}[frame=single]
|
|
100644 blob 33476f4951afc28d5ac2dc0d42d82f17ac817de2 bla.txt
|
|
100644 blob 2ce22b4dc77442103f095503f1205937c1b0fcfc blabla.txt
|
|
040000 tree ae247f2a35aadade5863aec2475cf13020304b06 podmapa
|
|
\end{Verbatim}
|
|
v \gitobject{47}{3e0bbfc9de64fdca00e611e5666788ddf664ca}
|
|
\end{itemize}
|
|
|
|
Z uporabo zgostitve kot kazalca na vsebino, Git vsebino mape postavi v
|
|
podatkovno strukturo, ki jo matematično lahko opišemo z \emph{usmerjenim
|
|
grafom}. Če je vsebina datotek enaka(npr. \texttt{bla.txt} in
|
|
\texttt{mapa/bla.txt}), Git shrani le eno kopijo, ki je dostopna v
|
|
datoteki z imenom enakim zgostitvi vsebine.
|
|
Zato datotečno drevo v Gitu ni nujno predstavljeno kot drevo, ampak kot
|
|
\emph{usmerjen (aciklični) graf}\footnote{Teoretično bi lahko dosegli, da bi bili v grafu tudi cikli,
|
|
a je to zelo malo verjetno in zato to možnost ignoriramo.}.
|
|
|
|
\begin{figure}[h]
|
|
\centering
|
|
\includegraphics[width=0.6\linewidth]{slike/file-graph.pdf}
|
|
\caption{Primer datotečnega grafa povezanega z zgostitvami. Zaradi
|
|
preglednosti bomo v slikah izpisali le prvih 6 znakov zgostitve.}
|
|
\end{figure}
|
|
|
|
Posledično lahko vsebino celotne mape opišemo z eno samo zgostitvijo. Če
|
|
spremenimo vsebino, ime ali lokacijo datoteke, bo sprememba vplivala na
|
|
zgostitev spremenjene vsebine in sprememba bo splavala na površje do
|
|
zgostitve za korensko mapo. Zgostitev služi tako kot identifikator
|
|
vsebine, kot tudi kot kontrolna vsota, ki omogoča detekcijo sprememb.
|
|
|
|
\begin{opomba}
|
|
Podatkovna struktura objektov v Gitu je podobna Merklejevim drevesom\cite{merkle_digital_1988}.
|
|
Postopek graditve datotečnega drevesa v Gitu je soroden veriženju blokov, ki se uporablja v
|
|
kriptovalutah.
|
|
\end{opomba}
|
|
|
|
Ponovimo, kar smo spoznali o Gitu. Git hrani vsebino datotek in datotečno strukturo
|
|
v \emph{vsebinsko naslovljivi shrambi} (v mapi \texttt{.git/objects}).
|
|
To pomeni, da je referenca na posamezen objekt v Gitu preprosto zgostitev njegove vsebine
|
|
in da lahko do določene vsebine dostopamo le, če poznamo njeno zgostitev. Po drugi strani
|
|
je vsebina za vse praktične primere določena s svojo zgostitvijo. Tako lahko enostavno
|
|
preverimo verodostojnost vsebine, ki je shranjena v Gitu.
|
|
|
|
\section{Zgodovinski graf sprememb}
|
|
|
|
V prejšnjem poglavju smo videli, kako Git hrani vsebino celotne mape in
|
|
kako zgostitev korenske mape določa vsebino vseh shranjenih datotek.
|
|
Zgodovinsko drevo sprememb je preprosta razširitev omenjene podatkovne strukture.
|
|
|
|
\subsection{Posnetki stanja}
|
|
|
|
Osnovna enota v Gitu je \emph{vnos} (angl. \emph{commit}). Vnos je
|
|
posnetek stanja zabeleženih datotek v trenutku, ko je bil ustvarjen.
|
|
Poleg vsebine datotek vsak vnos vsebuje še metapodatke o avtorju, datumu
|
|
vnosa in opisom sprememb. Podobno kot objekt tipa \emph{drevo}, je tudi
|
|
vnos objekt v vsebinsko naslovljivi shrambi in ima določeno
|
|
\emph{zgostitev vnosa}. Zgostitev vnosa je natanko določena z vsebino
|
|
shranjenih datotek in metapodatkov vnosa.
|
|
|
|
\begin{figure}[h]
|
|
\begin{Verbatim}[frame=single]
|
|
tree 65c47feec7465e80492620a48206793e078702e0
|
|
parent 16f2994757f1213935b8edb9ae7fee3a8e9ec98d
|
|
author MV <mv@example.com> 1765235698 +0100
|
|
committer MV <mv@example.com> 1765235698 +0100
|
|
|
|
Dodaj bla
|
|
\end{Verbatim}
|
|
\caption{Vnos v Gitu je shranjen v podatkovno shrambo pod imenom,
|
|
ki je zgostitev vsebine vnosa: \gitobject{8d}{d6d4bdaeff93016bd49474b54a911131759648}.}
|
|
\end{figure}
|
|
|
|
Vsak vnos je povezan s točno določenim posnetekom vsebine korenskega
|
|
datotečnega drevesa, ki ga identificira zgostitev. Poleg tega so
|
|
posamezni vnosi povezani v \emph{usmerjen acikličen graf}, ki
|
|
predstavlja zgodovino sprememb. Vsak vnos je \emph{vozlišče}
|
|
v grafu in izhaja iz enega ali več starševskih vnosov. Izjema je
|
|
prvi vnos. Povezave v grafu povezujejo vnose z njihovimi
|
|
starši.
|
|
|
|
\begin{figure}[h]
|
|
\centering
|
|
\includegraphics[width=0.6\linewidth]{slike/commit-history.pdf}
|
|
\caption{Vnosi v Gitu kot usmerjen graf. Vsak vnos(razen prvega) ima
|
|
povezavo na vnose iz katerih izhaja.}
|
|
\end{figure}
|
|
Tudi vnose hrani Git v vsebinsko naslovljivi shrambi pod imenom, ki je enako zgostitvi
|
|
vnosa. V shrambi imamo tri vrste objektov: vsebina datotek (blob), datotečna drevesa (tree)
|
|
in vnose (commit). Vsi objekti so dostopni, če poznamo njihovo zgostitev in so med seboj
|
|
povezani v usmerjen aciklični graf. Zgostitve objektov "na vrhu" natanko določajo vsebino
|
|
vseh objektov pod njimi. Na vrhu grafa so vnosi, ki vsebujejo reference na druge vnose in
|
|
na posnetke korenske mape. Posnetek korenske mape vsebuje reference na vsebino datotek in
|
|
posnetke podmap.
|
|
\begin{figure}[h]
|
|
\centering
|
|
\includegraphics[width=0.6\linewidth]{slike/object-storage.pdf}
|
|
\caption{Vsebinsko naslovljiva shramba objektov v Gitu. Naslovi so
|
|
zgostitve vsebine. Shramba vsebuje dva vnosa. V prvem vnosu smo dodali
|
|
dve datoteki \protect\texttt{bla.txt} in \protect\texttt{blabla.txt}, v
|
|
drugem vnosu pa smo spremenili le vsebino datotoeke
|
|
\protect\texttt{bla.txt}.}
|
|
\end{figure}
|
|
|
|
\section{Kazalci: veje in značke}
|
|
|
|
Poleg objektov kot so \emph{vnosi}, \emph{posnetki map} in
|
|
\emph{posnetki datotek} pozna git še reference. Reference so preproste datoteke, ki vsebujejo
|
|
zgostitev za posamezen vnos. Referenc git ne hrani v skladišču objektov, temveč posebej v mapi
|
|
\texttt{.git/refs}.
|
|
|
|
\begin{figure}[h]
|
|
\centering
|
|
\includegraphics[width=0.6\linewidth]{slike/branches-tags.pdf}
|
|
\caption{Veja \texttt{main} in značka \texttt{v-1.0} sta preprosta kazalca
|
|
na posamezen vnos.}
|
|
\end{figure}
|
|
|
|
Git pozna dve vrste referenc. \emph{Veja} (angl. \emph{branch}) je posebne
|
|
vrste referenca, ki se premika, ko dodajamo nove vnose. Vsakič ko ustvarimo nov vnos, se
|
|
trenutno aktivna veja premakne na novo ustvarjeni vnos.
|
|
Veje uporabljamo za vzdrževanje vzporednih razvojnih linij, ki so med sabo neodvisne.
|
|
\emph{Značka} (angl. \emph{tag})
|
|
je referenca, ki je statična.
|
|
Za razliko od veje, se oznaka nikoli ne premika samodejno. Zato se uporablja predvsem
|
|
za označevanje pomembnih mejnikov v zgodovini na primer verzij posameznih izdaj.
|
|
|
|
\begin{figure}[h]
|
|
\centering
|
|
\includegraphics[width=0.6\linewidth]{slike/branch-move.pdf}
|
|
\caption{Ko ustvarimo nov vnos, se aktivna veja \protect\texttt{main}
|
|
premakne naprej, značka \protect\texttt{v-1.0} pa ostane tam, kjer je
|
|
bila.}
|
|
\end{figure}
|
|
|
|
\emph{HEAD} je posebna referenca, ki kaže na trenutno aktiven vnos.
|
|
Vnos, na katerega kaže \emph{HEAD} bo starševski vnos naslednjeg vnosa,
|
|
ki ga bomo dodali. Ko spreminjamo datoteke Git najprej postavi spremenjene datoteke
|
|
v \emph{čakalnico} (angl. \emph{staging area}), ki se imenuje tudi
|
|
\emph{indeks} (angl. \emph{index}). Šele ko ustvarimo vnos, Git indeks trajno
|
|
shrani.
|
|
|
|
\begin{figure}[h]
|
|
\centering
|
|
\includegraphics[width=0.6\linewidth]{slike/head-index.pdf}
|
|
\caption{\emph{HEAD} je referenca na trenutno aktiven vnos.
|
|
\emph{Index} vsebuje spremembe, ki bodo zabeležene v naslednjem vnosu.}
|
|
\end{figure}
|
|
|
|
Veje in značke nimajo v Gitu nobenega posebnega pomena, razen tega, da
|
|
so reference na vnose. Pomen posamenznih vej je stvar dogovora med
|
|
uporabniki. Tako se pogosto uporablja različne veje za različne namene:
|
|
\texttt{main} ali \texttt{master} je navadno glavna veja razvoja, veje z
|
|
imeni \texttt{stable}, \texttt{production}, \texttt{development} in
|
|
podobno označujejo različne stopnje razvoja programske opreme, veje s
|
|
predpono \texttt{feature} označujejo razvoj novih funkcionalnosti.
|
|
Vse te pomene damo vejam ljudje, ki sodelujemo v nekem Git repozitoriju.
|
|
Za Git so vse veje in značke zgolj preprosti kazalci na določen vnos.
|
|
|
|
\section{Povzetek}
|
|
|
|
Povzemimo sedaj, kaj smo spoznali o podatkovnem modelu Gita.
|
|
Git hrani zgodovino sprememb v \emph{vsebinsko naslovljivi shrambi
|
|
objektov}, ki hrani tri vrste objektov:
|
|
|
|
\begin{itemize}
|
|
\item
|
|
\texttt{blob}: vsebina datotek,
|
|
\item
|
|
\texttt{tree}: imena vsebovanih datotek in podmap skupaj z njhovimi zgostitvami,
|
|
\item
|
|
\texttt{commit}: posnetek stanja projekta v nekem trenutku z metapodatki o avtorju,
|
|
času in sporočilom.
|
|
\end{itemize}
|
|
|
|
Naslovi objektov so \emph{zgostitve} vsebine objekta, zato je zagotovljena
|
|
verodostojnost shranjenih podatkov.
|
|
Vnosi so povezani v \emph{usmerjen aciklični graf}, ki opiše zgodovino sprememb.
|
|
Vsak vnos je določen z \emph{zgostitvijo vnosa} (angl. \emph{commit hash}), ki je 40-mestna
|
|
heksadecimalna vrednost, izračunana s SHA1. Zgostitev vnosa je določena na podlagi vsebine
|
|
vseh datotek, kot tudi metapodatkov vnosa.
|
|
|
|
Izven shrambe objektov hrani Git še reference na posamezne vnose. Poznamo dve vrsti referenc:
|
|
|
|
\begin{itemize}
|
|
\item
|
|
\emph{Veja} (angl. \emph{branch}) je premična referenca, ki kaže
|
|
na določen vnos v zgodovini in se samodejno premakne naprej, ko
|
|
dodajamo nove vnose.
|
|
\item
|
|
\emph{Oznaka} (angl. \emph{tag}) je statična referenca, ki trajno
|
|
kaže na določen vnos.
|
|
\item
|
|
\emph{HEAD} je posebna oznaka, ki kaže na trenutno aktiven vnos v
|
|
delovni kopiji.
|
|
\end{itemize}
|
|
|
|
Omenimo še dva pojma, ki jih uporabljamo pri delu z Gitom:
|
|
|
|
\begin{itemize}
|
|
\item
|
|
\emph{Delovna kopija} (angl. \emph{workout copy}) je mapa v kateri
|
|
urejamo datoteke, ki jih nato vnesemo v Git. V delovni kopiji imajo na
|
|
začetku datoteke isto vsebino kot je vsebina trenutno aktivnega vnosa
|
|
(\texttt{HEAD}). Spremembe, ki jih naaredimo na delovni kopiji lahko
|
|
zabeležimo v nov vnos.
|
|
\item
|
|
\emph{Oddaljen repozitorij} (angl. \emph{remote}) je povezava(url)
|
|
na drug repozitorij (ponavadi na drugem računalniku), s
|
|
katerim lahko izmenjujemo vsebino.
|
|
\end{itemize}
|
|
|
|
|
|
\section{Git ukazi kot operacije na grafu}
|
|
|
|
Gitov podatkovni model omogoča, da je večina operacij v Gitu obrnljivih.
|
|
To pomeni, da lahko repozitorij povrnemo v prejšnje stanje. Večina
|
|
operacij le dodaja nove vnose in starih ne briše\footnote{Nekatere operacije vnose tudi brišejo (npr. \texttt{git rebase}).
|
|
Takim operacijam rečemo, da spreminjajo zgodovino. Uporabniki morajo biti
|
|
pri njihovi uporabi posebej pazljivi, da
|
|
česa trajno ne zamočijo.}.
|
|
Zato so stare različice datotek
|
|
vedno na voljo. Git uporabniku daje samozavest, da brez strahu spreminja
|
|
vsebino, saj se lahko vedno vrne v času nazaj. Kot bi imel časovni
|
|
stroj.
|
|
|
|
Opremljeni z razumevanjem podatkovnega modela Gita, lažje razumemo
|
|
posamezne operacije, ki jih Git omogoča. Ukazov ne bom
|
|
prevajal, ampak jih bom navedel kot jih pozna program \texttt{git}.
|
|
|
|
\begin{verbatim}
|
|
git checkout referenca
|
|
\end{verbatim}
|
|
spremeni datoteke v delovni kopiji tako, da se ujemajo z vnosom, na
|
|
katerega kaže \texttt{referenca}. Poleg tega prestavi oznako \texttt{HEAD} na
|
|
isti vnos. Če je referenca veja, jo nastavi, kot aktivno vejo. Če je
|
|
referenca oznaka ali zgostitev vnosa, priedmo v stanje brez aktivne veje
|
|
(angl. \emph{deteached HEAD}).
|
|
|
|
\begin{verbatim}
|
|
git commit -m "Sporočilo za vnos"
|
|
\end{verbatim}
|
|
ustvari nov vnos, ki kaže na stanje v čakalnici (angl. staging area ali
|
|
index). V zgodovinskem grafu ustvari novo vozlišče, ki je povezano s
|
|
prejšnjim vnosom. Poleg tega prestavi aktivno vejo in oznako
|
|
\texttt{HEAD} na novo ustvarjeni vnos.
|
|
|
|
\begin{verbatim}
|
|
git add bla.txt
|
|
\end{verbatim}
|
|
doda vsebino spremenjene datoteke \texttt{bla.txt} v čakalnico. Ukaz ne
|
|
spreminja zgodovinskega grafa, pač pa doda novo vsebino in datotečna
|
|
drevesa, ki vsebujejo spremembe v shrambo objektov. Vsebina čakalnice bo
|
|
zabeležena v naslednjem vnosu.
|
|
|
|
\begin{verbatim}
|
|
git pull
|
|
\end{verbatim}
|
|
pobere vsebino(objekte in reference) iz oddaljenega repozitorija in
|
|
uskladi lokalno vejo z oddaljeno. Shrambi objektov se preprosto doda
|
|
nove objekte, ki so v oddaljeni veji. Če je lokalna veja prednik
|
|
oddaljene, se lokalna veja enostavno prestavi, da kaže na isti vnos, kot
|
|
oddaljena veja. V nasprotnem primeru, mora uporabnik posredovati in
|
|
razrešiti morebitne konflikte.
|
|
|
|
\begin{verbatim}
|
|
git push
|
|
\end{verbatim}
|
|
potisne novo vsebino na oddaljeni repozitorij. Push deluje obratno kot
|
|
\texttt{pull}. Ukaz je uspešno izveden le, če je oddaljena veja predhodnica
|
|
lokalne veje.
|
|
|
|
\begin{verbatim}
|
|
git fetch
|
|
\end{verbatim}
|
|
pobere novo vsebino (vnose, veje in oznake) iz oddaljenega repozitorija.
|
|
Pri tem ne more priti do konfliktov, ker git preprosto doda nove objekte
|
|
v shrambo in obstoječih objektov nikakor ne spreminja. Oddaljenim vejam
|
|
in oznakam preprosto doda predpono z imenom oddaljenega repozitorija.
|
|
|
|
\begin{verbatim}
|
|
git reset referenca
|
|
\end{verbatim}
|
|
spremeni kam kaže trenutno izbrana veja. Trenutno izbrano vejo prestavi na isti vnos, na
|
|
katerega kaže dana \texttt{referenca}. Ukaz ne spremeni zgodovinskega
|
|
drevesa, ampak le to, na kateri vnos kaže trenutno izbrana veja.
|
|
|
|
\begin{verbatim}
|
|
git merge referenca
|
|
\end{verbatim}
|
|
ustvari nov vnos, ki združi dve ločeni veji v eno (trenutno izbrano in
|
|
referenco). Nov vnos ima dva starša: vnos na katerega kaže trenutna veja
|
|
in vnos, na katerega kaže \texttt{referenca}. Če pride do konfliktov, jih mora
|
|
uporabnik sam razrešiti, preden se ustvari nov vnos.
|
|
|
|
\begin{verbatim}
|
|
git rebase referenca
|
|
\end{verbatim}
|
|
prestavi vnose v trenutno izbrani veji tako, da so potomci vnosa, na
|
|
katerega kaže \texttt{referenca}. Med ukazi, ki smo jih spoznali, je ta ukaz
|
|
edini, ki lahko povzroči izgubo podatkov. Običajno ukazi le dodajajo
|
|
nove vnose in prestavljajo reference. Zato je večina ukazov v Gitu
|
|
varna, v smislu, da jih lahko kasneje prekličemo in pridemo nazaj na
|
|
prejšnje stanje. Ukaz \texttt{rebase} pa spremeni zgodovino in ga ne
|
|
moremo preklicati, saj trenutne vnose nadomesti z novimi in stare vnose
|
|
pobriše\footnote{Obstaja enostaven način, kako \texttt{rebase} izvedemo tako, da ga lahko
|
|
kasneje prekličemo. Na vnos, ki ga želimo prestaviti z \texttt{rebase}, preprosto
|
|
postavimo novo vejo ali oznako. To povzroči, da se stari
|
|
vnosi ne pobrišejo, ko se izvede ukaz \texttt{rebase}.}.
|
|
|
|
\section{Trki zgostitev in rojstnodnevni paradoks}\label{sec_trk}
|
|
|
|
Git hrani datoteke pod imeni, ki so enaka zgostitvi vsebine. Če bi imeli
|
|
dve datoteki z različno vsebino isto zgostitev, bi Git shranil le eno
|
|
datoteko in bi prišlo do izgube podatkov. Git se zanaša na to, da je
|
|
verjetnost za to izjemno majhna. Kako bi ocenili to verjetnost?
|
|
|
|
Koliko datotek bi morali shraniti v Git, da bi z znatno verjetnostjo
|
|
prišlo do trka? Vprašanje je povezano z rojstnodnevnim problemom.
|
|
Kako velika naj bo skupina ljudi, da bo vsaj \(50\%\) verjetnost, da
|
|
imata dve osebi na isti dan rojstni dan? Velikost skupine je
|
|
presenetljivo majhna(23), zato rojstnodnevnei problem imenujemo tudi
|
|
rojstnodnevni paradoks. Vprašanje zastavimo matematično. Naključno
|
|
izberemo \(n < d\) števil iz množice \(\left\{ 1,2,\ldots,h \right\}\),
|
|
tako da je vsaka izbira enakomerno porazdeljena. Kolikšna je verjetnost
|
|
\(p(n,h)\), da bosta vsaj dve števili enaki? Verjetnost \(p(n,h)\)
|
|
izračunamo elementarno z verjetnostjo nasprotnega dogodka:
|
|
|
|
\begin{equation}
|
|
1 - p(n,h) = \frac{h \cdot (h - 1)\cdots(h - n + 1)}{h^{n}} =
|
|
\prod_{k = 1}^{n - 1}\left( 1 - \frac{k}{h} \right).
|
|
\end{equation}
|
|
|
|
Če izraz logaritmiramo, dobimo
|
|
\begin{eqnarray}
|
|
\log(1 - p(n,h)) = \sum_{k = 1}^{n - 1}\log(1 - \frac{k}{h}) <
|
|
- \sum_{k = 1}^{n - 1}\frac{k}{h} = \frac{- \left( n(n - 1) \right)}{2h}.
|
|
\label{eq_log_ocena}
|
|
\end{eqnarray}
|
|
|
|
Res! Logaritem je konveksna funkcija, zato so vrednosti manjše od
|
|
vrednosti na tangenti
|
|
\(\log(1 - \frac{k}{h}) = \log(1 - x) < x = \frac{k}{h}\).
|
|
|
|
Od tod izpeljemo oceno za \(p(n,h)\)
|
|
\begin{eqnarray}
|
|
p(n,h) > 1 - e^{\frac{-\left( n(n - 1) \right)}{2h}} \approx 1 - e^{-\frac{n^{2}}{2h}}.
|
|
\label{eq_ocena}
|
|
\end{eqnarray}
|
|
|
|
Za vrednosti \(1 \ll n \ll h\) je \(1 - e^{- \frac{n^{2}}{2h}}\) tudi
|
|
dobra aproksimacija za \(p(n,h)\).
|
|
|
|
Da bi odgovorili kako odporna je zgoščevalna funkcija na morebitne
|
|
trke, moramo rešiti obratno nalogo: največ koliko števil \(n(p,d)\)
|
|
lahko izberemo, da bo verjetnost pojava dveh enakih števil manjša od
|
|
\(p \in \lbrack 0,1\rbrack\)? Natančen odgovor na to vprašanje ni tako
|
|
preprost \cite{brink_probably_2012}. Lahko pa uporabimo oceno
|
|
(\ref{eq_ocena}) in čez palec ocenimo vrednost \(n(p,h)\):
|
|
|
|
\begin{equation}
|
|
\begin{array}{r}
|
|
- n^{2} \approx \log(1 - p) \Rightarrow \\
|
|
n(p,h) \approx \sqrt{2h\log(\frac{1}{1 - p})} \approx \sqrt{2h}.
|
|
\end{array}
|
|
\end{equation}
|
|
|
|
Funkcija \(\sqrt{\log(\frac{1}{1 - p})}\) zelo počasi narašča, ko se
|
|
\(p\) približuje \(1\), zato jo lahko zanemarimo. Če je zgoščevalna
|
|
funkcija \(160\) bitna, kot na primer SHA1, je
|
|
\(n \approx \sqrt{2^{160}} \approx 2^{80}\). Znatna verjetnost, da pride
|
|
do trka zgostitev, bi se pojavila, ko bi shranili \(2^{80}\)
|
|
različnih verzij datotek v Git. Raziskovalci, ki so razvili napad
|
|
\emph{SHAttered}, so se posebej potrudili in so potrebovali ``zgolj''
|
|
približno \(2^{63}\) primerov, da so prišli do trka.
|
|
|
|
\section{Zaključek}
|
|
|
|
Spoznali smo, kako deluje Git in s katerimi matematičnimi pojmi lahko opišemo njegov podatkovni model.
|
|
Upam, da boste s tem znanjem bolj samozavestno uporabljali Git. Opis dela z Gitom presega namen tega
|
|
dokumenta, zato vas raje usmerim na uradno dokumentacijo:
|
|
|
|
{\url{https://git-scm.com/cheat-sheet}}
|
|
|
|
Pri pisanju tega članka sem sevada uporabljal Git. V
|
|
\href{https://git.fri.uni-lj.si/martin.vuk/git-intro}{javno dostopnem
|
|
repozitoriju} \cite{vuk_git-intro_nodate} si lahko ogledate celotno
|
|
zgodovino nastajanja tega članka.
|
|
Pri pripravi dokumenta sem uporabil Gemini 3, a sem vse odgovore skrbno preveril
|
|
in uredil po svoje.
|
|
|
|
\bibliographystyle{plainurl}
|
|
\bibliography{reference}
|
|
\end{document}
|