2018 ZV tételek kidolgozások
@@ -0,0 +1,158 @@
|
||||
\documentclass[margin=0px]{article}
|
||||
|
||||
\usepackage{listings}
|
||||
\usepackage[utf8]{inputenc}
|
||||
\usepackage{graphicx}
|
||||
\usepackage{float}
|
||||
\usepackage[a4paper, margin=1in]{geometry}
|
||||
\usepackage{amsthm}
|
||||
\usepackage{amssymb}
|
||||
\usepackage{amsmath}
|
||||
|
||||
|
||||
\newenvironment{tetel}[1]{\paragraph{#1 \\}}{}
|
||||
% A dokument itt kezdődik
|
||||
|
||||
\title{Záróvizsga tételsor \\ \large 1. Függvények határértéke, folytonossága}
|
||||
\date{}
|
||||
\author{Fekete Dóra}
|
||||
|
||||
\begin{document}
|
||||
\maketitle
|
||||
|
||||
\begin{tetel}{Függvények határértéke, folytonossága}
|
||||
Függvények határértéke, folytonossága. Kompakt halmazon folytonos függvények tulajdonságai: Heine-tétel, Weierstrass-tétel, Bolzano-tétel. A hatványsor fogalma, Cauchy--Hadamard-tétel, analitikus függvények.
|
||||
\end{tetel}
|
||||
|
||||
\section{Függvények határértéke}
|
||||
|
||||
Adott $f \in \mathbb{K}_{1} \to \mathbb{K}_{2}, a \in \mathcal{D}'_{f}$ (torlódási pont). Az $f$ függvénynek az $a$ helyen van határértéke, ha $\exists A \in \overline{\mathbb{K}}_{2}$, ahol $\overline{\mathbb{K}} = \mathbb{C} \vee \mathbb{R} \vee +\infty \vee -\infty$, amelyre tetszőleges $K(A) \subset \mathbb{K}_{2}$ környezetet is véve megadható az $a$-nak egy alkalmas $k(a) \subset \mathbb{K}_{1}$ környezete, amellyel $f[(k(a) \backslash \{a\}) \cap \mathcal{D}_{f}] \subset K(A)$ teljesül. \\
|
||||
Másképp: $f(x) \in K(A), (a \neq x \in k(a) \cap \mathcal{D}_{f})$. \\
|
||||
Ekkor az egyértelműen létező $A \in \overline{\mathbb{K}}_{2}$ számot vagy valamelyik végtelent az $f$ függvény $a$ helyen vett határértékének nevezzük. \\
|
||||
Jelölés: $\lim\limits_{x \to a}{f(x)} = \lim\limits_{a}{f} = A$
|
||||
|
||||
\subsection{Torlódási pont}
|
||||
|
||||
$A \subset \mathbb{K}$, ekkor az $\alpha \in \overline{\mathbb{K}}$ torlódási pontja az $A$ halmaznak, ha bármely $K(\alpha)$ környezetre $(K(\alpha) \backslash \{\alpha\}) \cap A \neq \emptyset$. \\
|
||||
Egyenlőtlenségekkel: $A \subset \mathbb{K}$, ekkor $\alpha \in \mathbb{K}$ szám torlódási pontja az $A$ halmaznak, ha $\forall \varepsilon > 0$ esetén $\exists x \in A$, hogy $0 < |x-\alpha| < \varepsilon$.
|
||||
|
||||
\subsection{Környezet}
|
||||
|
||||
$A \subset \mathbb{K}, a \in A, r > 0: K_{r}(a) = K(a) = \{x \in A: |x-a| < r\}$.
|
||||
|
||||
\subsection{Függvény}
|
||||
|
||||
$\emptyset \neq A, B$ halmazok, $f \subset A \times B$ reláció. Valamely $x \in A$ elemre legyen $f_{x} := \{y \in B: (x,y) \in f\}$. $f$ reláció függvény, ha $\forall x \in A$-ra az $f_{x}$ halmaz legfeljebb egy elemű.
|
||||
|
||||
\section{Függvények folytonossága}
|
||||
|
||||
Az $f \in \mathbb{K}_{1} \to \mathbb{K}_{2}$ függvény az $a \in \mathcal{D}_{f}$ pontban folytonos, ha $\forall \varepsilon > 0$ számhoz megadható olyan $\delta > 0$ szám, amellyel bármely $x \in \mathcal{D}_{f}, |x-a| < \delta$ esetén $|f(x)-f(a)| < \varepsilon$. \\
|
||||
Jelölés: $f \in \mathcal{C}\{a\}$, ha $\forall x \in \mathcal{D}_{f} : f \in \mathcal{C}\{x\}$, akkor $f \in \mathcal{C}$.
|
||||
|
||||
\section{Összefüggés határérték és folytonosság között}
|
||||
|
||||
Legyen $f \in \mathbb{K}_{1} \to \mathbb{K}_{2}, a \in \mathcal{D}_{f} \cap \mathcal{D}'_{f}$. Ekkor $f \in \mathcal{C}\{a\} \iff \lim\limits_{a}{f} = f(a)$.
|
||||
|
||||
\section{Fogalmak}
|
||||
|
||||
\subsection{Kompakt halmaz}
|
||||
|
||||
$A \subset \mathbb{K}$ kompakt, ha bármely $(x_{n}): \mathbb{N} \to A$ sorozatnak van olyan $(x_{\nu_{n}})$ részsorozata, amely konvergens és $\lim{(x_{\nu_{n}})} \in A$. \\
|
||||
Ekkor $A$ korlátos és zárt.
|
||||
|
||||
\subsection{Konvergens}
|
||||
|
||||
Egy $x = (x_{n}) : \mathbb{N} \to \mathbb{K}$ számsorozatot konvergensnek nevezünk, ha $\exists \alpha \in \mathbb{K}, \forall \varepsilon > 0, \exists N \in \mathbb{N}, \forall n \in \mathbb{N}, n > N : |x_{n}-\alpha| < \varepsilon$. \\
|
||||
$\alpha$ az $x$ sorozat határértéke.
|
||||
|
||||
\subsection{Korlátos}
|
||||
|
||||
Sorozatra: $x_{n}$ korlátos $\Rightarrow \exists \nu : x \circ \nu$ konvergens \\
|
||||
Halmazra: $\emptyset \neq A \subset \mathbb{K}$ korlátos, ha $\exists q \in \mathbb{R} : |x| \leq q, (x \in A)$
|
||||
|
||||
\subsection{Zárt halmaz}
|
||||
|
||||
Komplementere nyílt halmaz.
|
||||
|
||||
\subsection{Nyílt halmaz}
|
||||
|
||||
$A$ nyílt halmaz $\iff \forall a \in A, \exists K(a): K(a) \subset A$, vagyis az $A$ halmaz minden pontja belső pont.
|
||||
|
||||
\section{Heine-tétel}
|
||||
|
||||
Ha az $f \in \mathbb{K}_{1} \to \mathbb{K}_{2}$ függvény folytonos és $\mathcal{D}_{f}$ kompakt, akkor $f$ egyenletesen folytonos.
|
||||
|
||||
\subsection{Egyenletesen folytonos}
|
||||
|
||||
$f \in \mathbb{K}_{1} \to \mathbb{K}_{2}$ függvény egyenletesen folytonos, ha $\forall \varepsilon > 0, \exists \delta > 0 : |f(x)-f(t)| < \varepsilon, (x,t \in \mathcal{D}_{f}, |x-t| < \delta)$.
|
||||
|
||||
\section{Weierstrass-tétel}
|
||||
|
||||
Tegyük fel, hogy az $f \in \mathbb{K} \to \mathbb{R}$ függvény folytonos és $\mathcal{D}_{f}$ kompakt. Ekkor az $\mathcal{R}_{f}$ értékkészletnek van legnagyobb és legkisebb eleme $(\exists \max{\mathcal{R}_{f}}, \exists \min{\mathcal{R}_{f}})$.
|
||||
|
||||
\section{Bolzano-tétel}
|
||||
|
||||
Tegyük fel, hogy valamely $-\infty < a < b < +\infty$ esetén az $f:[a,b] \to \mathbb{R}$ függvény folytonos, és $f(a) \cdot f(b) < 0$ (ellenkező előjelű). \\
|
||||
Ekkor van olyan $\xi \in (a,b)$, amelyre $f(\xi) = 0$.
|
||||
|
||||
\section{A hatványsor fogalma}
|
||||
|
||||
Legyen adott az $a \in \mathbb{K}$ középpont és az $(a_{n}): \mathbb{N} \to \mathbb{K}$ együttható-sorozat, továbbá ezek segítségével tekintsük az alábbi függvényeket: $f_{n}(t) := a_{n}(t-a)^{n}, (t \in \mathcal{D} := \mathbb{K}, n \in \mathbb{N})$. Ekkor a $\sum{(f_{n})}$ függvénysort hatványsornak nevezzük.
|
||||
|
||||
\subsection{Sorozat}
|
||||
|
||||
Az $f$ függvényt sorozatnak nevezzük, ha $\mathcal{D}_{f} = \mathbb{N}$.
|
||||
|
||||
\subsection{Függvénysorozat, függvénysor}
|
||||
|
||||
$(f_{n})$ sorozat függvénysorozat, ha $\forall n \in \mathbb{N}$ esetén $f_{n}$ függvény, és valamilyen $\mathcal{D} \neq \emptyset$ halmazzal $\mathcal{D}_{f_{n}} = \mathcal{D}, (n \in \mathbb{N})$. \\
|
||||
Ha a szóban forgó $(f_{n})$ függvénysorozatra $\mathcal{R}_{f_{n}} \subset \mathbb{K}, (n \in \mathbb{N})$ is igaz, akkor az $(f_{n})$ függvénysorozat által meghatározott $\sum{(f_{n})}$ függvénysor a következő függvénysorozat: $\sum{(f_{n})} := (\sum\limits_{k=0}^{n}{f_{k}})$.
|
||||
|
||||
\section{Cauchy--Hadamard-tétel}
|
||||
|
||||
Tegyük fel, hogy az $(a_{n}) : \mathbb{N} \to \mathbb{K}$ sorozat esetén létezik a $\lim{(\sqrt[n]{|a_{n}|})}$ határérték, és legyen
|
||||
$$ r := \left\{\begin{array} {lr}
|
||||
+\infty & ha \lim{(\sqrt[n]{|a_{n}|})} = 0 \\
|
||||
\dfrac{1}{\lim{(\sqrt[n]{|a_{n}|})}} & ha \lim{(\sqrt[n]{|a_{n}|})} > 0
|
||||
\end{array}\right.$$
|
||||
$r$-t a konvergenciasugárnak nevezzük.
|
||||
Ekkor bármely $a \in \mathbb{K}$ mellett a $\sum{(a_{n}(t-a)^{n})}$ hatványsorról a következőket mondhatjuk:
|
||||
\begin{enumerate}
|
||||
\item Ha $r > 0$, akkor minden $x \in \mathbb{K}, |x-a| < r$ helyen a $\sum{(a_{n}(t-a)^{n})}$ hatványsor az $x$ helyen abszolút konvergens.
|
||||
\item Ha $r < +\infty$, akkor tetszőleges $x \in \mathbb{K}, |x-a| > r$ mellett a $\sum{(a_{n}(t-a)^{n})}$ hatványsor az $x$ helyen divergens.
|
||||
\end{enumerate}
|
||||
|
||||
\subsection{Abszolút konvergens}
|
||||
|
||||
A $\sum\limits_{n=1}^{\infty}{a_{n}}$ végtelen sort abszolút konvergensnek nevezzük, ha a $\sum\limits_{n=1}^{\infty}{|a_{n}|}$ sor konvergens.
|
||||
|
||||
\subsection{Divergens}
|
||||
|
||||
Ha a $\lim\limits_{n \to \infty}{a_{n}}$ nem létezik, vagy nem véges, akkor a $\sum{a_{n}}$ végtelen sor divergens.
|
||||
|
||||
\subsection{Cauchy--Hadamard-tételből következik}
|
||||
|
||||
\begin{enumerate}
|
||||
\item Ha $r = +\infty$, akkor $\mathcal{D}_{0} = \mathbb{K}$, és $\forall x \in \mathbb{K}$-ra a hatványsor abszolút konvergens.
|
||||
\item Ha $r = 0$, akkor $\mathcal{D}_{0} = \{a\}$ és $\sum\limits_{n=0}^{\infty}{a_{n}(a-a)^{n}} = a_{0}$.
|
||||
\item Ha $0 < r < +\infty$, akkor $K_{r}(a) \subset \mathcal{D}_{0} \subset G_{r}(a) = \{x \in \mathbb{K} : |x-a| \leq r\}$ és a $K_{r}(a)$ környezet $\forall x$ pontjára a hatványsor az $x$ helyen abszolút konvergens.
|
||||
\item Ha $r > 0$, akkor tetszőleges $0 \leq \rho < r$ számhoz válasszuk az $x \in K_{r}(a)$ elemet úgy, hogy $|x-a| = \rho$. Ekkor $\sum\limits_{n=0}^{\infty}{|a_{n}(x-a)^{n}|} = \sum\limits_{n=0}^{\infty}{|a_{n}||x-a|^{n})} = \sum\limits_{n=0}^{\infty}{|a_{n}|\rho^{n})} < +\infty$
|
||||
\end{enumerate}
|
||||
|
||||
\section{Analitikus függvények}
|
||||
|
||||
Tegyük fel, hogy a $\sum{(a_{n}(t-a)^{n})}$ hatványsor $r$ konvergenciasugara (ld. C--H-tétel) nem nulla. Ekkor értelmezhetjük az alábbi függvényt: $f(x) := \sum\limits_{n=0}^{\infty}{a_{n}(x-a)^{n}}, (x \in K_{r}(a))$, ami nem más, mint a $\sum{(a_{n}(t-a)^{n})}$ függvénysor $F(x) := \sum\limits_{n=0}^{\infty}{a_{n}(x-a)^{n}}, (x \in \mathcal{D}_{0})$ összegfüggvényének a leszűkítése a $K_{r}(a)$ környezetre: $f = F|_{K_{r}(a)}$, ($f$ a hatványsor összegfüggvénye). Az ilyen szerkezetű $f$ függvényt analitikusnak nevezzük. \\
|
||||
Megjegyzés: $\mathcal{D}_{0}$ a $\sum{(a_{n}(t-a)^{n})}$ hatványsor konvergenciatartományát jelöli.
|
||||
|
||||
\subsection{Fontos analitikus függvények}
|
||||
|
||||
Olyan $a_{n}$-ek, amire $\lim{(\sqrt[n]{|a_{n}|})} = 0$, tehát $r = +\infty$ a $\sum{(a_{n}t^{n})}$ hatványsorok esetén. Ezek az $a_{n}$-ek: $\dfrac{1}{n!}, \dfrac{(-1)^n}{(2n+1)!}, \dfrac{(-1)^n}{(2n)!}, \dfrac{1}{(2n+1)!}, \dfrac{1}{(2n)!}$.
|
||||
\begin{itemize}
|
||||
\item $\exp{x} := \exp{(x)} = e^{x} = \sum\limits_{n=0}^{\infty}{\dfrac{x^n}{n!}, (x \in \mathbb{K})}$
|
||||
\item $\sin{x} := \sin{(x)} = \sum\limits_{n=0}^{\infty}{(-1)^n\dfrac{x^{2n+1}}{(2n+1)!}, (x \in \mathbb{K})}$
|
||||
\item $\cos{x} := \cos{(x)} = \sum\limits_{n=0}^{\infty}{(-1)^n\dfrac{x^{2n}}{(2n)!}, (x \in \mathbb{K})}$
|
||||
\item $\sinh{x} := \sinh{(x)} = \sum\limits_{n=0}^{\infty}{\dfrac{x^{2n+1}}{(2n+1)!}, (x \in \mathbb{K})}$
|
||||
\item $\cosh{x} := \cosh{(x)} = \sum\limits_{n=0}^{\infty}{\dfrac{x^{2n}}{(2n)!}, (x \in \mathbb{K})}$
|
||||
\end{itemize}
|
||||
|
||||
\end{document}
|
After Width: | Height: | Size: 24 KiB |
@@ -0,0 +1,775 @@
|
||||
\documentclass[margin=0px]{article}
|
||||
|
||||
\usepackage{listings}
|
||||
\usepackage[utf8]{inputenc}
|
||||
\usepackage{graphicx}
|
||||
\usepackage{float}
|
||||
\usepackage[a4paper, margin=1in]{geometry}
|
||||
\usepackage{amsthm}
|
||||
\usepackage{amssymb}
|
||||
|
||||
\renewcommand{\figurename}{ábra}
|
||||
\makeatletter
|
||||
\renewcommand\paragraph{%
|
||||
\@startsection{paragraph}{4}{0mm}%
|
||||
{-\baselineskip}%
|
||||
{.5\baselineskip}%
|
||||
{\normalfont\normalsize\bfseries}}
|
||||
\makeatother
|
||||
\renewcommand{\figurename}{ábra}
|
||||
\newenvironment{tetel}[1]{\paragraph{#1}}{}
|
||||
% A dokument itt kezdődik
|
||||
|
||||
|
||||
\title{Záróvizsga tételsor \\ \large 10. Programnyelvi alapok}
|
||||
\date{}
|
||||
\author{Ancsin Ádám}
|
||||
|
||||
\begin{document}
|
||||
|
||||
\maketitle
|
||||
|
||||
\begin{tetel}{Programnyelvi alapok}
|
||||
Kifejezések kiértékelésének szabályai. Vezérlési szerkezetek: utasítások, rekurzió. Típusok: tömb, rekord, osztály, öröklődés, statikus és dinamikus kötés, polimorfizmus. Generikusok. Hatókör/láthatóság. Automatikus, statikus és dinamikus élettartam, szemétgyűjtés. Konstruktor, destruktor. Objektumok másolása, összehasonlítása. Alprogramok, paraméterátadás, túlterhelés.
|
||||
\end{tetel}
|
||||
|
||||
\section{Kifejezések kiértékelésének szabályai}
|
||||
|
||||
\noindent Fogalmak:
|
||||
\begin{itemize}
|
||||
\item Operandusok: Változók, konstansok, függvény- és eljáráshívások.
|
||||
|
||||
\item Operátorok: Műveleti jelek, amelyek összekapcsolják egy kifejezésben az operandusokat és valamilyen
|
||||
műveletet jelölnek.
|
||||
|
||||
\item Kifejezés: operátorok és operandusok sorozata
|
||||
|
||||
\item Precedencia: A műveletek kiértékelési sorrendjét határozza meg.
|
||||
|
||||
\item Asszociativitás iránya: Az azonos precedenciájú operátorokat tartalmazó kifejezésekben a kiértékelés iránya.
|
||||
Megkülönböztetünk bal-asszociatív és jobb-asszociatív operátorokat.
|
||||
\end{itemize}
|
||||
|
||||
\noindent Az operátorokat háromféleképpen írhatjuk az operandusokhoz képest:
|
||||
|
||||
\begin{itemize}
|
||||
\item Infix : Egy operátort a két operandusa közé kell írni (tehát csak kétoperandusú műveletek operátorait
|
||||
lehet így írni).
|
||||
Amikor egy kifejezésben több operátor is szerepel, akkor a különböző operátorok végrehajtási
|
||||
sorrendjét az operátorok precedenciája dönti el. Amelyik operátor precedenciája magasabb (pl. a
|
||||
szorzásé magasabb, mint az összeadásé), az általa jelölt műveletet értékeljük ki először. Ugyanazon
|
||||
operátorok végrehajtási sorrendjét pedig az asszociativitás iránya dönti el (pl. a bal-asszociatív azt
|
||||
jelenti, hogy balról jobbra haladva kell végrehajtani). Ezeket a (programozási nyelvekbe beépített)
|
||||
szabályokat zárójelek segítségével lehet felülírni.\\
|
||||
Példa: A * (B + C) / D
|
||||
|
||||
\item Postfix (Lengyelforma) : Az operátorokat az operandusaik mögé írjuk. A kiértékelés sorrendje mindig balról jobbra
|
||||
történik – tehát egy n operandusú operátor a tőle balra levő első n operandusra érvényes.\\
|
||||
Példa: A B C + * D /\\
|
||||
Ugyanez zárójelezve (felesleges): ((A (B C +) *) D /)
|
||||
|
||||
\item Prefix : Az operátorokat az operandusuk elé írjuk. A kiértékelés sorrendje balról
|
||||
jobbra történik.\\
|
||||
Példa: / * A + B C D\\
|
||||
Ugyanez zárójelezve (felesleges): (/ (* A (+ B C) ) D)\\
|
||||
Habár a prefix operátorok esetén is balról jobbra történik a kiértékelés, viszont ha egy operátortól
|
||||
jobbra egy másik operátor következik, akkor értelemszerűen az ehhez az operátorhoz tartozó
|
||||
műveletet kell először végrehajtani, hogy a bal oldalit is végre tudjuk hajtani. A fenti példában is a
|
||||
szorzást az osztás előtt, az összeadást pedig a szorzás előtt kell elvégezni.
|
||||
\end{itemize}
|
||||
|
||||
\paragraph{Logikai operátorokat tartalmazó kifejezések kiértékelése}
|
||||
|
||||
\noindent Az ilyen kifejezéseknek kétféle kiértékelése létezik:
|
||||
\begin{itemize}
|
||||
\item Lusta kiértékelés : Ha az első argumentumból meghatározható a kifejezés értéke, akkor a másodikat
|
||||
már nem értékeli ki.
|
||||
\item Mohó kiértékelés : Mindenféleképpen megállapítja mindkét argumentum logikai értékét.
|
||||
\end{itemize}
|
||||
|
||||
\noindent A két kiértékelési módszer bizonyos esetekben különböző eredményt adhat:
|
||||
\begin{itemize}
|
||||
\item A 2. argumentum nem mindig értelmes\\
|
||||
Példa (C++):
|
||||
\begin{verbatim}
|
||||
if ((i>=0) && (T[i]>=10))
|
||||
{
|
||||
//...
|
||||
}
|
||||
\end{verbatim}
|
||||
Tegyük fel, hogy a T egy \texttt{int} tömb, 0-tól indexelődik.
|
||||
Itt ha az $i>=0$ hamis, akkor T-t alul indexelnénk. Ez mohó kiértékelés esetén futási idejű hibát okozna.
|
||||
Lusta kiértékelés esetén (a C++ alapértelmezetten ezt használja) viszont tudhatjuk, hogy a feltétel már nem lehet igaz, emiatt $T[i]>=10$-et már nem kell kiértékelni.
|
||||
\item A 2. argumentumnak van valamilyen mellékhatása.\\
|
||||
Példa (C++):
|
||||
\begin{verbatim}
|
||||
if ((i>0) || (++j>0))
|
||||
{
|
||||
T[j] = 100;
|
||||
}
|
||||
\end{verbatim}
|
||||
Ebben az esetben ha $i>0$ igaz, akkor a feltétel biztosan igaz, viszont a $++j>0$ kifejezés mellékhatásos, növeli j értékét.
|
||||
Mivel a C++ lusta kiértékelést használ a $||$ operátor esetén ($|$ operátor esetén mohó a kiértékelés), ezért ebben az esetben nem növeli j értékét. (csak akkor, ha $i>0$ hamis).
|
||||
\end{itemize}
|
||||
|
||||
\section{Utasítások, vezérlési szerkezetek}
|
||||
|
||||
\subsection{Egyszerű utasítások}
|
||||
|
||||
\begin{itemize}
|
||||
\item Értékadás : Az értékadás bal oldalán egy változó, a jobb oldalán bármilyen kifejezés állhat. Az
|
||||
értékadással a változóhoz rendeljük a jobb oldali kifejezést. Figyelni kell arra, hogy a bal oldali
|
||||
változó típusának megfelelő kifejezés álljon a jobb oldalon (vagy létezik implicit konverzió, pl. C++-ban
|
||||
az egész és logikai típus között). A legtöbb nyelvben az értékadás operátora az \texttt{=} (például C++, Java, C\#),
|
||||
vagy a \texttt{:=} (például Pascal, Ada).
|
||||
|
||||
\item Üres utasítás : Nem mindenhol lehet ilyet írni. A lényege, hogy nem csinál semmit.
|
||||
Azokban a nyelvekben lehet létjogosultsága, ahol üres blokkot nem írhatunk,
|
||||
muszáj legalább 1 utasításnak szerepelnie benne. (pl. Ada) Erre szolgál az üres utasítás.
|
||||
(Ada-ban ez a \texttt{null} utasítás)
|
||||
|
||||
\item Alprogramhívás : Alprogramokat nevük és paramétereik megadásával hívhatunk.
|
||||
Példák:
|
||||
\begin{itemize}
|
||||
\item \texttt{System.out.println("Hello”);}
|
||||
\item \texttt{int x = sum(3,4);}
|
||||
\end{itemize}
|
||||
\item Visszatérés utasítás : Az utasítás hatására az alprogram végrehajtása befejeződik. Ha az alprogram egy
|
||||
függvény, akkor meg kell adni a visszatérési értéket is.
|
||||
|
||||
\noindent Példák (C++):
|
||||
\begin{itemize}
|
||||
\item Ebben a példában a \texttt{doSomething} egy eljárás, nincs visszatérési értéke. A paraméterül kapott
|
||||
x változót értékül adjuk a j-nek. Ha ez az érték nem 0, akkor visszatérünk, azaz megszakítjuk az alprogram
|
||||
végrehajtását (konkrét értéket viszont nem adunk vissza). Ha ez az érték 0, akkor a végrehajtás folytatódik tovább,
|
||||
meghívjuk a \texttt{doSomethingElse} függvényt a j paraméterrel.
|
||||
\begin{verbatim}
|
||||
void doSomething(int x)
|
||||
{
|
||||
int j;
|
||||
if(j=x)
|
||||
return; // j!=0, do nothing
|
||||
|
||||
doSomethingElse(j);
|
||||
}
|
||||
\end{verbatim}
|
||||
|
||||
\item Ebben a példában az \texttt{isOdd} egy függvény, \texttt{int} visszatérési értékkel. Megmondja a paraméterül kapott
|
||||
x egész számról, hogy páratlan-e. Ehhez bitenkénti ÉS művelettel "összeéseli" az x-et az 1-gyel (0...01). Ha az eredmény
|
||||
nem 0, akkor páratlan, visszatérünk igaz értékkel. Különben folytatjuk a működést, majd visszatérünk hamis értékkel.
|
||||
\begin{verbatim}
|
||||
int isOdd(int x)
|
||||
{
|
||||
if(x & 1) //bitwise AND with 0...01 is not 0...0
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
\end{verbatim}
|
||||
\end{itemize}
|
||||
|
||||
\item Utasításblokk: A blokkon belüli utasítások "összetartoznak”.
|
||||
Ez több esetben is jól alkalmazható nyelvi elem:
|
||||
\begin{itemize}
|
||||
\item Vezérlési szerkezetekben: Az adott vezérlési szerkezetekhez tartozó utasításokat különíthetjük el.
|
||||
|
||||
\item Az olyan nyelvekben, amelyekben deklaráció csak a program elején található deklarációs
|
||||
blokkokban lehetséges (pl. Ada), van lehetőség arra, hogy a programkód későbbi részében nyissunk
|
||||
egy blokkot, ahol deklarációk is szerepelhetnek.
|
||||
|
||||
\item Osztályok inicializáló blokkja pl. Java-ban (konstruktor előtt hajtódik végre):
|
||||
\begin{verbatim}
|
||||
public class MyClass{
|
||||
private ResourceSet resourceSet;
|
||||
|
||||
{
|
||||
resourceSet = new ResourceSetImpl();
|
||||
UMLResourcesUtil.init(resourceSet);
|
||||
}
|
||||
|
||||
/* ... */
|
||||
}
|
||||
\end{verbatim}
|
||||
\item Osztályok statikus inicializáló blokkja pl. Java-ban:
|
||||
\begin{verbatim}
|
||||
public class MyClass{
|
||||
private static ResourceSet resourceSet;
|
||||
|
||||
static{
|
||||
resourceSet = new ResourceSetImpl();
|
||||
UMLResourcesUtil.init(resourceSet);
|
||||
}
|
||||
|
||||
/* ... */
|
||||
}
|
||||
\end{verbatim}
|
||||
|
||||
\end{itemize}
|
||||
|
||||
\end{itemize}
|
||||
|
||||
\subsection{Vezérlési szerkezetek}
|
||||
|
||||
\begin{itemize}
|
||||
\item Elágazás : Az elágazás egy olyan vezérlési szerkezet, amellyel meghatározhatjuk, hogy bizonyos
|
||||
(blokkban megadott) utasítások csak a megadott feltétellel jöhessenek létre.
|
||||
Általában több feltételt is megadhatunk egymás után (if L1 then … else if L2 then … else if L3 then …).
|
||||
Megadhatjuk azt is, hogy mi történjen, ha egyik feltétel sem teljesül (if L then … else …).
|
||||
|
||||
Elágazásokat lehet egymásba ágyazni (if … then if ...).
|
||||
|
||||
"Csellengő else” ("Dangling else”) probléma: Azokban a nyelvekben lép fel, ahol egy feltétel egy
|
||||
utasításblokkját nem zárja le külön kódszó (pl. endif). Ekkor abban az esetben, ha elágazásokat
|
||||
egymásba ágyazunk, a következő probléma léphet fel:\\
|
||||
Példa: \texttt{if (A>B) then if (C>D) then E:=100; else F:=100;}
|
||||
|
||||
A fenti esetben nem lehet megállapítani, hogy a programozó az else kulcsszót melyik elágazásra
|
||||
értette.
|
||||
|
||||
\item Ciklus : Egy utasításblokk (ciklusmag) valahányszori végrehajtását jelenti.
|
||||
\begin{itemize}
|
||||
\item Feltétel nélküli ciklus : Végtelen ciklust kódol, kilépni belőle a strukturálatlan utasításokkal lehet
|
||||
(ld. lentebb), vagy return-nel, esetleg hiba fellépése esetén.
|
||||
|
||||
Példa (ADA):
|
||||
\begin{verbatim}
|
||||
loop
|
||||
null;
|
||||
end loop;
|
||||
\end{verbatim}
|
||||
|
||||
\item Elöltesztelő ciklus : A ciklus a ciklusmag minden végrehajtása előtt megvizsgálja, hogy az adott
|
||||
feltétel teljesül-e. Ha teljesül, akkor végrehajtja a magot, majd újra ellenőriz. Különben a ciklus
|
||||
után folytatódik a futás.
|
||||
|
||||
Példák:
|
||||
\begin{itemize}
|
||||
\item C++:
|
||||
\begin{verbatim}
|
||||
int x=0,y=0;
|
||||
while(x<5 && y<5)
|
||||
{
|
||||
x+=y+1;
|
||||
y=x-1;
|
||||
}
|
||||
cout<<x+y<<endl;
|
||||
\end{verbatim}
|
||||
|
||||
\item ADA:
|
||||
\begin{verbatim}
|
||||
declare
|
||||
X,Y: Integer;
|
||||
begin
|
||||
X:=0;
|
||||
Y:=0;
|
||||
while X<5 and Y<5 loop
|
||||
X:=X+Y+1;
|
||||
Y:=X-1;
|
||||
end loop;
|
||||
end;
|
||||
\end{verbatim}
|
||||
\end{itemize}
|
||||
|
||||
\item Számlálásos ciklus : Ebben a vezérlési szerkezetben megadhatjuk, hogy a ciklusmag hányszor
|
||||
hajtódjon végre.
|
||||
Példa (ADA):
|
||||
\begin{verbatim}
|
||||
for i in 1..10 loop
|
||||
null;
|
||||
end loop;
|
||||
\end{verbatim}
|
||||
A számlálás úgy történik, hogy egy változóban (ciklusváltozó) tároljuk, hogy "hol tartunk” - ezt hasonlítjuk
|
||||
össze minden ciklus elején a kifejezéssel, amit meg kell haladnia a változónak (i). Tehát
|
||||
felfogható egy elöltesztelő ciklusként is, ahol a ciklusfeltétel az \texttt{i<=10} és a ciklusmag végén
|
||||
növelni kell i-t.
|
||||
|
||||
\item Hátultesztelő ciklus : Az a különbség az elöltesztelőhöz képest, hogy a feltételt a ciklusmag
|
||||
végrehajtása után ellenőrizzük – tehát itt a ciklusmag 1-szer mindenképpen lefut.
|
||||
|
||||
Példa (C++):
|
||||
|
||||
\begin{verbatim}
|
||||
int i=0;
|
||||
do
|
||||
{
|
||||
++i;
|
||||
} while(i<5);
|
||||
\end{verbatim}
|
||||
|
||||
Megjegyzés: vannak olyan nyelvek (pl. Pascal), amelyekben a hátultesztelő ciklus feltétele nem bennmaradási, hanem
|
||||
leállási feltétel. Azaz nem azt adjuk meg, hogy minek kell teljesülnie ahhoz, hogy még egyszer végrehajtásra kerüljön
|
||||
a ciklusmag, hanem azt, hogy minek kell teljesülnie ahhoz, hogy a ciklusmag ne hajtódjon végre többször.
|
||||
|
||||
Az előbbi C++-os példa Pascal-os megfelelője:
|
||||
\begin{verbatim}
|
||||
i:=0;
|
||||
repeat
|
||||
i:=i+1;
|
||||
until i=5;
|
||||
\end{verbatim}
|
||||
|
||||
Megjegyzés: ADA-ban nincs igazi hátultesztelős ciklus. Ebben a nyelvben hátultesztelő ciklust úgy írhatunk, hogy ha
|
||||
írunk egy feltétel nélküli ciklust, amelynek utolsó utasítása egy feltételhez kötött kilépés.
|
||||
|
||||
Példa:
|
||||
\begin{verbatim}
|
||||
i:=0;
|
||||
loop
|
||||
i:=i+1;
|
||||
exit when i=5;
|
||||
end loop;
|
||||
\end{verbatim}
|
||||
|
||||
|
||||
\item foreach : Akkor használatos, ha egy adatszerkezet minden elemére végre akarjuk hajtani a magot.
|
||||
Tulajdonképpen ez is egy elöltesztelő ciklus (a ciklusfeltétel az, hogy a végére értünk-e az
|
||||
adatszerkezetnek).
|
||||
Példa:
|
||||
\begin{verbatim}
|
||||
foreach (int v in Vect)
|
||||
{
|
||||
++v;
|
||||
}
|
||||
\end{verbatim}
|
||||
|
||||
Megjegyzések:
|
||||
\begin{enumerate}
|
||||
\item Nincs minden programozási nyelvben ilyen ciklus. Leginkább az újabb nyelvekben terjedt el.
|
||||
\item Nem minden programozási nyelvben a foreach a kulcsszó ehhez a ciklushoz.
|
||||
Például Java-ban, C++11-ben (régebbi változatokban nincs ilyen) a for ciklust használhatjuk foreach-ként:
|
||||
\begin{verbatim}
|
||||
int x=0;
|
||||
for (int v : vect){
|
||||
x+=v;
|
||||
}
|
||||
\end{verbatim}
|
||||
\end{enumerate}
|
||||
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
|
||||
\subsection{Strukturálatlan utasítások}
|
||||
|
||||
\begin{itemize}
|
||||
\item Ciklus megszakítása : A ciklusból való "kiugrásra” (tehát annak azonnali befejezésére) használható.
|
||||
Gyakran végtelen ciklus megszakítására használjuk, vagy hátultesztelő ciklus kódolására (ahol nincs
|
||||
erre beépített vezérlési szerkezet, például Ada).
|
||||
|
||||
Ilyen utasítás pl. C/C++/C\#-ban, vagy Java-ban a \texttt{break}, illetve Ada-ban az \texttt{exit}.
|
||||
|
||||
\item \texttt{goto} utasítás : A programkódban címkéket definiálhatunk, majd a \texttt{goto} utasítással egy
|
||||
ilyen címkéhez irányíthatjuk a vezérlést. Vezérlési szerkezeteket is lehet vele kódolni. Túlzott
|
||||
használata olvashatatlan kódhoz vezethet.
|
||||
\end{itemize}
|
||||
|
||||
\subsection{Rekurzió}
|
||||
|
||||
Rekurzív alprogram: Olyan alprogram, amelynek kódjában szerepel önmagának a meghívása.
|
||||
Mindenképpen kell, hogy legyen a rekurziónak megállási feltétele – tehát egy olyan feltétel (egy elágazással
|
||||
együtt), amelynek teljesülése esetén nem történik rekurzív hívás, így az összes, folyamatban levő rekurzív hívás
|
||||
végre tud hajtódni (ellenkező esetben végtelen rekurzió lép fel, ilyenkor általában előbb-utóbb betelik a stack és leáll a program).\\
|
||||
|
||||
\noindent Példák (faktoriális):
|
||||
|
||||
\begin{itemize}
|
||||
\item C++:
|
||||
\begin{verbatim}
|
||||
int fact (int n)
|
||||
{
|
||||
if(n>0)
|
||||
return n * fact (n-1);
|
||||
else
|
||||
return 1;
|
||||
}
|
||||
\end{verbatim}
|
||||
|
||||
\item Haskell:
|
||||
\begin{verbatim}
|
||||
fact :: (Integral a) => a -> a
|
||||
fact n
|
||||
| n>0 = n * fact (n - 1)
|
||||
| otherwise = 0
|
||||
\end{verbatim}
|
||||
|
||||
\end{itemize}
|
||||
|
||||
|
||||
|
||||
\section{Típusok}
|
||||
|
||||
\subsection{Tömb}
|
||||
|
||||
A tömb (angolul array) olyan adatszerkezet, amelyet nevesített elemek csoportja alkot, melyekre sorszámukkal (indexükkel) lehet hivatkozni. Vektornak is nevezik, ha egydimenziós, mátrixnak esetenként, ha többdimenziós. A legtöbb programozási nyelvben minden egyes elemnek azonos adattípusa van és a tömb folytonosan helyezkedik el a számítógép memóriájában. A készítés módja alapján lehet:
|
||||
|
||||
\begin{itemize}
|
||||
\item statikus :a méret fix, deklarációban szabályozott
|
||||
\item dinamikus tömb: a mérete változik, folyamatosan bővíthető
|
||||
\end{itemize}
|
||||
|
||||
\subsection{Rekord}
|
||||
|
||||
A rekord egy összetett értékek leírásához használható konstrukció. Névvel és típussal ellátott összetevői vannak, ezeket mezőknek nevezzük.
|
||||
Értékhalmaz a mezők értéktípusai által meghatározott alaphalmazok direktszorzata.
|
||||
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.7\linewidth]{img/rekord}
|
||||
\caption{A rekord-típuskonstrukciók általános szintaxisa.}
|
||||
\label{fig:rekord}
|
||||
\end{figure}
|
||||
|
||||
\noindent Műveletek:
|
||||
\begin{itemize}
|
||||
\item Szelekciós függvény (.mezőszelektor szintaxisú);
|
||||
|
||||
\item konstrukciós függvény (Rekordtípus(mezőértékek) szintaxisú);
|
||||
|
||||
\item elképzelhetők transzformációs függvények, amelyek a teljes rekordstruktúrát érintik.
|
||||
\end{itemize}
|
||||
|
||||
\noindent Példa rekordra és használatára C-ben:
|
||||
\begin{verbatim}
|
||||
//definition of Point
|
||||
struct Point
|
||||
{
|
||||
int xCoord;
|
||||
int yCoord;
|
||||
};
|
||||
|
||||
const struct Point ORIGIN = {0,0};
|
||||
|
||||
\end{verbatim}
|
||||
|
||||
\subsection{Osztály}
|
||||
|
||||
Az osztály egy felhasználói típus, amelynek alapján példányok (objektumok)
|
||||
hozhatók létre. Az osztály alapvetően attribútum és metódus (művelet) definíciókat
|
||||
tartalmaz. Az osztály írja le az objektum típusát: megadja a tulajdonságait és azok
|
||||
lehetséges értékeit (azaz a típusértékeket), valamint az objektumon végrehajtható műveleteket (típusműveletek).\\
|
||||
|
||||
\noindent Példa C++-ban:
|
||||
\begin{verbatim}
|
||||
//definition of Point
|
||||
class Point {
|
||||
private:
|
||||
int xCoord;
|
||||
int yCoord;
|
||||
public:
|
||||
//constructor
|
||||
Point(int xCoord, int yCoord) : xCoord(xCoord),yCoord(yCoord) {}
|
||||
|
||||
void Translate(int dx, int dy) {
|
||||
xCoord+=dx;
|
||||
yCoord+=dy;
|
||||
}
|
||||
|
||||
void Translate(Point delta) {
|
||||
xCoord+=delta.xCoord;
|
||||
yCoord+=delta.yCoord;
|
||||
}
|
||||
|
||||
int getX() { return xCoord; }
|
||||
|
||||
int getY() { return yCoord; }
|
||||
};
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
Point point(0,0);
|
||||
point.Translate(5,-2);
|
||||
cout<<point.getX()<<","<<point.getY()<<endl; //5,-2
|
||||
Point delta(-2,1);
|
||||
point.Translate(delta);
|
||||
cout<<point.getX()<<","<<point.getY()<<endl; //3,-1
|
||||
|
||||
return 0;
|
||||
}
|
||||
\end{verbatim}
|
||||
|
||||
Megjegyzés: A nem objektum-orientált nyelvekben nincsenek osztályok, pl. régebbi nyelvekben, mint a C, ADA, Pascal, vagy
|
||||
funkcionális nyelvekben (Haskell, Clean, stb.).
|
||||
|
||||
\subsection{Öröklődés}
|
||||
|
||||
Egy osztály legegyszerűbben adattagjainak és metódusainak felsorolásával hozható létre. Azonban az objektum-orientált paradigma lehetőséget ad egy másik, hatékonyabb módszerre is, az öröklődésre. Az öröklődés az újrafelhasználhatóságot szem előtt tartva arra ad lehetőséget, hogy már meglévő (szülő-, ős-) osztályból kiindulva hozzunk létre új (gyermek-, leszármazott-, al-) osztályt. Az öröklés két osztály között fennálló olyan kapcsolat, amely során a leszármazott osztály rendelkezik a szülő osztály majdnem összes tulajdonságával (nem privát adattagjait és metódusait sajátjaként kezeli), s ezeket újabbakkal egészítheti ki. Az így létrehozott osztály is lehet más osztályok őse (kivéve pl. Java-ban a \texttt{final} kulcsszóval ellátott osztályok, ezekből már nem származtathatunk), így ezek az osztályok egy öröklési hierarchiába szerveződnek. Attól függően, hogy egy osztálynak egy- vagy több őse van, beszélünk egyszeres- ill. többszörös öröklődésről. A Java az egyszeres öröklődést támogatja, de pl. C++-ban van többszörös öröklődés.
|
||||
|
||||
A Java-ban az osztályhierarchia legfelső eleme az Object osztály, amelyből minden más osztály (közvetve vagy közvetlenül) származik.
|
||||
|
||||
Egy alosztály az örökölt metódusokat újraimplementálhatja. Ilyenkor az adott metódus ugyanolyan néven, de más, módosított (alosztályra specifikált) tartalommal kerül megvalósításra. Az ilyen metódusokat polimorfnak nevezzük. Java-ban minden olyan metódust, ami nincs ellátva a \texttt{final} kulcsszóval, újra lehet definiálni. (C++-ban mindent, ami nem privát)\\
|
||||
|
||||
\noindent Példák:
|
||||
\begin{itemize}
|
||||
\item C++:
|
||||
\begin{verbatim}
|
||||
class RegularPolygon
|
||||
{
|
||||
protected:
|
||||
const double radius;
|
||||
public:
|
||||
RegularPolygon(double radius) : radius(radius) {}
|
||||
virtual double area() = 0;
|
||||
};
|
||||
|
||||
class EquilateralTriangle : public RegularPolygon
|
||||
{
|
||||
public:
|
||||
EquilateralTriangle(double radius) : RegularPolygon(radius) {}
|
||||
virtual double area()
|
||||
{
|
||||
return 0.75*sqrt(3.0)*radius*radius;
|
||||
}
|
||||
};
|
||||
\end{verbatim}
|
||||
|
||||
\item Java:
|
||||
\begin{verbatim}
|
||||
public abstract class RegularPolygon{
|
||||
protected final double radius;
|
||||
|
||||
public RegularPolygon(double radius){
|
||||
this.radius = radius;
|
||||
}
|
||||
public abstract double area();
|
||||
}
|
||||
|
||||
public class EquilateralTriangle extends RegularPolygon{
|
||||
public EquilateralTriangle(double radius){
|
||||
super(radius);
|
||||
}
|
||||
public double area(){
|
||||
return 0.75*Math.sqrt(3.0)*radius*radius;
|
||||
}
|
||||
}
|
||||
|
||||
\end{verbatim}
|
||||
\end{itemize}
|
||||
|
||||
\subsection{Statikus és dinamikus kötés}
|
||||
|
||||
\begin{itemize}
|
||||
\item statikus típus: A változó deklarációjában megadott típus. Fordítás során egyértelműen eldől, nem változhat
|
||||
futás során. A statikus típus határozza meg, hogy mit szabad csinálni az objektummal (pl. hogy milyen
|
||||
műveletek hívhatók meg rá).
|
||||
|
||||
\item dinamikus típus: A változó által hivatkozott objektum típusa. Vagy a statikus típus leszármazottja, vagy maga
|
||||
a statikus típus. Futás során változhat.
|
||||
\end{itemize}
|
||||
|
||||
\noindent Példa(Java):
|
||||
\begin{verbatim}
|
||||
Object o = new String("Hello”);
|
||||
\end{verbatim}
|
||||
Itt az o változó statikus típusa \texttt{Object}, dinamikus típusa pedig \texttt{String}.\\
|
||||
|
||||
\noindent Kötések:
|
||||
\begin{itemize}
|
||||
\item statikus kötés: A változó statikus típusa szerinti adattagokra lehet hivatkozni.
|
||||
\item dinamikus kötés: A változó dinamikus típusa szerinti adattagok használhatók.
|
||||
\end{itemize}
|
||||
|
||||
A kötés akkor fontos, ha a hívott művelet, vagy a hivatkozott változó a statikus és a dinamikus típusban
|
||||
különbözik, vagy esetleg a statikus típusban nem is létezik (ekkor a dinamikus típusban sem hivatkozhatunk
|
||||
az adattagra).\\
|
||||
|
||||
\noindent Többféleképpen lehet a kötéseket meghatározni a különböző nyelvekben:
|
||||
\begin{itemize}
|
||||
\item Java : Minden esetben dinamikus kötés van (az örökölt metódusok törzsében is).
|
||||
\item C++ : A művelet definiálásakor lehet jelezni, ha dinamikus kötést szeretnénk (\texttt{virtual}).
|
||||
\item Ada : A híváskor lehet jelezni, ha dinamikus kötést szeretnénk.
|
||||
\end{itemize}
|
||||
|
||||
|
||||
\section{Generikusok}
|
||||
|
||||
Generikus programozás: Algoritmusok, adatszerkezetek általánosított, több típusra is működő
|
||||
leprogramozása (pl. generikus rendezés, generikus verem, …). Ezt az általános kódot nevezzük sablonnak
|
||||
(template).
|
||||
|
||||
Bizonyos nyelvekben (Ada, C++) egy sablont példányosítani kell – ekkor a kívánt típusokat, objektumokat
|
||||
(a sablon definíciónak megfelelően) a sablonnak paraméterként megadva példányosul a szóban forgó sablon.
|
||||
(Ugyanúgy, mint pl. amikor egy függvénynek megadjuk az aktuális paraméterét.) Ezt nevezzük generatív
|
||||
programozásnak: a program a megadott sablon alapján létrehoz egy "igazi” programegységet (program
|
||||
generál programot).
|
||||
|
||||
Példa: Egy verem sablon példányosításakor megadjuk, hogy milyen típusú elemeket tároljon a verem (típus
|
||||
paraméter) és hogy hány elem fér a verembe (objektum paraméter).
|
||||
C++ és Ada esetén egy sablon paramétere alprogram is lehet.
|
||||
|
||||
Példa: Egy rendezésnek megadjuk, hogy milyen művelet alapján rendezzen.
|
||||
Természetesen lehet alapértelmezett sablonparaméter is.
|
||||
|
||||
Egy sablon definiálása esetén természetesen a sablont nem lehet minden típusra használni. Egy sablon attól
|
||||
lesz sablon, hogy több típusra is működik. Azonban megszorításokat tehetünk (és tennünk is kell) arra, hogy
|
||||
milyen típusokra lehessen azt használni, hogyan lehessen a sablont példányosítani.
|
||||
|
||||
Jó példa erre az Ada nyelv, ahol a sablon specifikációja egy "szerződés” a sablon törzse és a példányosítás
|
||||
között:
|
||||
|
||||
\begin{itemize}
|
||||
\item A sablon törzse nem használhat mást, csak amit a sablon specifikációja megenged neki. (A törzset
|
||||
nem feltétlenül kell, hogy ismerjük példányosításkor.)
|
||||
\begin{verbatim}
|
||||
generic
|
||||
type Element_T is private;
|
||||
with function "*" (X, Y: Element_T) return Element_T is <>;
|
||||
function Square (X : Element_T) return Element_T;
|
||||
\end{verbatim}
|
||||
Itt a \texttt{with function} kezdetű sor végén az \texttt{is <>} azt jelenti, hogy ha az adott típusra már létezik *
|
||||
művelet (pl. egész számokra), akkor nem kell külön megadni példányosításkor, a program automatikusan azt használja.
|
||||
|
||||
A törzs:
|
||||
\begin{verbatim}
|
||||
function Square (X: Element_T) return Element_T is
|
||||
begin
|
||||
return X * X; -- The formal operator "*".
|
||||
end Square;
|
||||
\end{verbatim}
|
||||
|
||||
\item A példányosításnak biztosítania kell mindent, amit a sablon specifikációja megkövetel tőle.
|
||||
A következő példában a négyzetre emelő függvényt mátrixokra alkalmazzuk, feltéve, hogy definiáltuk a
|
||||
mátrixszorzást.
|
||||
\begin{verbatim}
|
||||
with Square;
|
||||
with Matrices;
|
||||
procedure Matrix_Example is
|
||||
function Square_Matrix is new Square
|
||||
(Element_T => Matrices.Matrix_T, "*" => Matrices.Product);
|
||||
A : Matrices.Matrix_T := Matrices.Identity;
|
||||
begin
|
||||
A := Square_Matrix (A);
|
||||
end Matrix_Example;
|
||||
\end{verbatim}
|
||||
\end{itemize}
|
||||
|
||||
Például a C++-ban a sablonszerződés nem így működik. Ott a sablon specifikációja az egész
|
||||
definíció (emiatt sablonosztályokat csak teljes egészében header fájlokban definiálhatunk).
|
||||
Példányosításkor ezt is ismerni kell, hogy tudjuk, hogyan példányosíthatunk. Az információelrejtés
|
||||
elve tehát sérül.
|
||||
|
||||
Más nyelvekben (pl. Java, funkcionális nyelvek) nem kell a sablonokat példányosítani – mindig ugyanaz a
|
||||
megírt kód hajtódik végre, csak épp az aktuális paraméterekkel. Pl. Java-ban a típusparaméter fordításkor "elveszik",
|
||||
csak futási időben derül ki.
|
||||
|
||||
\section{Hatókör/láthatóság}
|
||||
|
||||
\begin{enumerate}
|
||||
\item Hatókör: Deklarációkor a programozó összekapcsol egy entitást (például egy változót vagy függvényt) egy névvel. A hatókör alatt a forrásszöveg azt a részét értjük, amíg ez az összekapcsolás érvényben van. Ez általában annak a blokknak a végéig tart, amely tartalmazza az adott deklarációt.
|
||||
|
||||
\item A láthatóság a hatókör részhalmaza, a programszöveg azon része, ahol a deklarált névhez a megadott entitás tartozik. Mivel az egymásba ágyazott blokkokban egy korábban már bevezetett nevet más entitáshoz kapcsolhatunk, ezért ilyenkor a külső blokkban deklarált entitás a nevével már nem elérhető. Ezt nevezzük a láthatóság elfedésének.
|
||||
|
||||
Egyes nyelvekben (például C++) bizonyos esetekben (például osztályszintű adattagok) a külső blokkban deklarált entitáshoz minősített névvel hozzá lehet férni ekkor is.
|
||||
\end{enumerate}
|
||||
|
||||
\section{Automatikus, statikus és dinamikus élettartam, szemétgyűjtés}
|
||||
Élettartam: A változók élettartama alatt a program végrehajtási idejének azt a szakaszát értjük, amíg a változó számára lefoglalt tárhely a változóé.
|
||||
|
||||
\subsection{Automatikus élettartam}
|
||||
|
||||
A blokkokban deklarált lokális változók automatikus élettartamúak, ami azt jelenti, hogy a deklarációtól a tartalmazó blokk végéig tart, azaz egybeesik a hatókörrel. A helyfoglalás számukra a végrehajtási verem aktuális aktivációs rekordjában történik meg.
|
||||
|
||||
\subsection{Statikus élettartam}
|
||||
|
||||
A globális változók, illetve egyes nyelvekben a statikusként deklarált változók (például C/C++ esetén a \texttt{static} kulcsszóval) statikus élettartamúak. Az ilyen változók élettartama a program teljes végrehajtási idejére kiterjed, számukra a helyfoglalás már a fordítási időben megtörténhet.
|
||||
|
||||
\subsection{Dinamikus élettartam}
|
||||
|
||||
A dinamikus élettartamú változók esetén a programozó foglal helyet számukra a dinamikus tárterületen (heap), és a programozó feladata gondoskodni arról is, hogy ezt a tárterületet később felszabadítsa. Amennyiben utóbbiról megfeledkezik, azt nevezzük memóriaszivárgásnak (memory leak).
|
||||
Mint látjuk, a dinamikus élettartam esetén a hatókör semmilyen módon nem kapcsolódik össze az élettartammal, az élettartam szűkebb vagy tágabb is lehet a hatókörnél.
|
||||
|
||||
\subsection{Szemétgyűjtő}
|
||||
|
||||
A szemétgyűjtő másik neve a hulladékgyűjtő, az angol Garbage Collector név után pedig gyakran csak GC-nek rövidítik. Feladata a dinamikus memóriakezeléshez kapcsolódó tárhelyfelszabadítás automatizálása, és a felelősség levétele a programozó válláról, így csökkentve a hibalehetőséget.
|
||||
|
||||
A szemétgyűjtő figyeli, hogy mely változók kerültek ki a hatókörükből, és azokat felszabadíthatóvá nyilvánítja. A módszer hátránya a számításigényessége, illetve a nemdeterminisztikussága. A szemétgyűjtő ugyanis nem szabadítja fel egyből a hatókörükből kikerült változókat, és a felszabadítás sorrendje sem ugyanaz, amilyen sorrendben a változók felszabadíthatóvá váltak.
|
||||
|
||||
Azt, hogy a hulladékgyűjtő mikor és mely változót szabadítja fel, egy programozási nyelvenként egyedi, összetett algoritmus határozza meg, amelyben rendszerint szerepet játszik a rendelkezésre álló memória telítettsége, illetve a felszabadításhoz szükséges becsült idő. (Például ha egy objektum rendelkezik destruktorral, akkor általában a GC később szabadítja csak fel.)
|
||||
|
||||
Összességében a szemétgyűjtő csak annyit garantál, hogy előbb-utóbb (legkésőbb a program futásának végeztével) minden dinamikusan allokált változót felszabadít.
|
||||
|
||||
Szemétgyűjtést használó nyelvek pl. Java, C\#, Ada. C/C++-ban nincs szemétgyűjtés, a programozónak kell gondoskodni a dinamikusan allokált memóriaterületek felszabadításáról.
|
||||
\section{Konstruktor, destruktor}
|
||||
|
||||
\subsection{Konstruktor}
|
||||
|
||||
A konstruktor az objektumok inicializáló eljárása, akkor fut le, ha egy osztályból új objektumot példányosítunk. Alapértelmezett konstruktor alatt a paraméter nélküli konstruktort értjük, a legtöbb programozási nyelv esetén ezt a fordítóprogram automatikusan generálja üres törzzsel, amennyiben nem lett megadva egy konstruktor sem egy osztályban.
|
||||
Többek között a konstruktorban szokás gondoskodni arról, hogy az objektum dinamikus élettartamú változói számára tárhelyet foglaljunk.
|
||||
|
||||
\subsection{Destruktor}
|
||||
|
||||
A destruktor a konstruktor ellentétes párja, ez az eljárás az objektumok felszabadításakor fut le. Meghívása automatikusan megtörténik, attól függetlenül, hogy az objektum felszabadítása automatikusan történik a hatókör végeztével (lokális objektumok esetén), manuálisan a programozó által (dinamikus élettartamú objektumok esetén) vagy a szemétgyűjtő által (szintén dinamikus élettartamú objektumok esetén).
|
||||
|
||||
A desktruktorban szokás többek között az objektum dinamikus helyfoglalású adattagjait és a lefoglalt erőforrásokat felszabadítani.
|
||||
|
||||
\section{Objektumok másolása, összehasonlítása}
|
||||
|
||||
Az objektumok másolása egy speciális konstruktorral, az úgynevezett másoló konstruktorral (copy constructor) történik. Ez paraméterül az adott osztály egy példányát kapja meg, és azt a programozó által megadott működési logika szerint lemásolja az éppen inicializált objektumba.
|
||||
|
||||
Több programozási nyelv (például C++) fordítóprogramja automatikusan elkészít egy másoló konstruktort, ha a programozó nem definiál sajátot. Ez az alapértelmezett másoló konstruktor lemásolja a forrásobjektum összes adattagjának értékét, ezt nevezzük sekély másolatnak (shallow copy). Ha az objektum dinamikus foglalású adattagokat is tartalmaz, akkor azoknak nem az értéke, hanem csak a hivatkozása lesz lemásolva, ami általában nem a kívánt működés. Ez esetben saját másoló konstruktor írása szükséges, ami mély másolatot (deep copy) készít.
|
||||
|
||||
\section{Alprogramok, paraméterátadás, túlterhelés}
|
||||
|
||||
\subsection{Alprogramok}
|
||||
|
||||
Alprogramoknak a függvényeket, eljárásokat és műveleteket nevezzük. Segítségükkel a program feladatonként tagolható, a főprogramból az önálló feladatok kiszervezhetőek.
|
||||
|
||||
\subsection{Paraméterátadás}
|
||||
|
||||
Az alprogramoknak szüksége lehet bemenő adatokra és vissza is adhat értékeket. Az alprogramokat általános írjuk meg, saját változónevekkel, ezek a formális paraméterek. Az alprogram meghívásakor az átadott aktuális paraméterek alapján a formális paraméterek értéket kapnak. Az, hogy a formális paraméterek értéke mi lesz, a paraméterátadás módjától függ.
|
||||
|
||||
\subsubsection{Szövegszerű paraméterátadás}
|
||||
|
||||
A makrókban használatosak mind a mai napig. A makró törzsében a formális paraméter helyére beíródik az aktuális paraméter szövege.
|
||||
|
||||
\subsubsection{Név szerinti paraméterátadás}
|
||||
|
||||
Az aktuális paraméter kifejezést újra és újra kiértékeljük, ahányszor hivatkozás történik a formálisra. A paramétert a törzs kontextusában értékeljük ki, így a formális paraméter különböző előfordulásai mást és mást jelenthetnek az alprogramon belül.
|
||||
Alkalmazása archaikus (például: Algol 60, Simula 67).
|
||||
|
||||
\subsubsection{Érték szerinti paraméterátadás}
|
||||
|
||||
Az egyik legelterjedtebb paraméterátadási mód (például: C, C++, Pascal, Ada, Java), bemeneti szemantikájú. A formális paraméter az alprogram lokális változója, híváskor a vermen készül egy másolat az aktuális paraméterről, ez lesz a formális. Az alprogram végén a formális paraméter megszűnik
|
||||
|
||||
\subsubsection{Cím szerinti paraméterátadás}
|
||||
|
||||
A másik legelterjedtebb paraméterátadási mód (például: Pascal, C++, C\#), be- és kimeneti szemantikájú. A híváskor az aktuális paraméter címe adódik át, azaz a formális és az aktuális paraméter ugyanazt az objektumot jelentik, egy alias jön létre.\\
|
||||
|
||||
Megjegyzés: A Java-ban nincs cím szerinti paraméterátadás, csak érték szerinti. A Java ugyanis a primitív típusoknak az értékét tárolja,
|
||||
objektumok esetén pedig egy referenciát az adott objektumra (mint C++-ban a referencia típus). Objektum átadásakor ez a referencia másolódik le, azaz a referencia adódik át érték szerint.\\
|
||||
|
||||
\noindent Például:
|
||||
\begin{verbatim}
|
||||
public static void BadSwap(Object x, Object y)
|
||||
{
|
||||
Object tmp = x;
|
||||
x = y;
|
||||
y = tmp;
|
||||
}
|
||||
\end{verbatim}
|
||||
|
||||
A fenti függvény nem cseréli ki az x-et és y-t, csak lokálisan (a függvénytörzsön belül), viszont a hívás helyén
|
||||
x és y is helyben maradnak.
|
||||
|
||||
\subsubsection{Eredmény szerinti paraméterátadás}
|
||||
|
||||
Kimeneti szemantikájú paraméterátadási mód. A formális paraméter az alprogram lokális változója, az alprogram végén a formális paraméter értéke bemásolódik az aktuálisba. Azonban az alprogram meghívásakor az aktuális értéke nem másolódik be a formálisba. (Használja például az Ada.)
|
||||
|
||||
\subsubsection{Érték/eredmény szerinti paraméterátadás}
|
||||
|
||||
Az érték és eredmény szerinti paraméterátadás összekombinálása, így egy be- és kimeneti szemantikájú paraméterátadási módot kapunk. (Használja például az Algol-W vagy az Ada.)
|
||||
|
||||
\subsubsection{Megosztás szerinti paraméterátadás}
|
||||
|
||||
Objektumorientált programozási nyelvek (például: CLU, Eiffel) paraméterátadási módja. Lényege, hogy ha a formális paraméter megváltoztatható és az aktuális paraméter egy megváltoztatható változó, akkor cím szerinti paraméterátadás történik, egyébként pedig érték szerinti. A paraméterátadás módját külön megadni nem lehet.
|
||||
Megváltoztatható (mutable) objektum alatt azt értjük, hogy tulajdonságai, ezáltal állapota megváltoztatható.
|
||||
|
||||
\subsubsection{Igény szerinti paraméterátadás}
|
||||
|
||||
Ezt a paraméterátadási módot a lusta kiértékelésű funkcionális nyelvek (például: Clean, Haskell, Miranda) alkalmazzák. Az aktuális paramétert nem híváskor értékeli ki, hanem akkor, amikor először szüksége van rá a számításokhoz.
|
||||
|
||||
\subsection{Túlterhelés}
|
||||
|
||||
A túlterhelés (overloading) segítségével azonos nevű alprogramokat hozhatunk létre eltérő szignatúrával. A szignatúra a legtöbb programozási nyelvben az alprogram nevét és a formális paraméterek számát és típusát jelenti, de egyes nyelvekben (például Ada) a visszatérési érték típusa is beletartozik. A túlterhelés elsődleges felhasználási területe, hogy ugyanazt a tevékenységet különböző paraméterezéssel is elvégezhessük.
|
||||
|
||||
A fordító az alprogramhívásból el tudja dönteni, hogy a túlterhelt változatok közül melyiket kell meghívni. Ha egyik sem illeszkedik vagy több is illeszkedik, akkor fordítási hiba lép fel.
|
||||
|
||||
\end{document}
|
@@ -0,0 +1,399 @@
|
||||
\documentclass[margin=0px]{article}
|
||||
|
||||
\usepackage{listings}
|
||||
\usepackage[utf8]{inputenc}
|
||||
\usepackage{graphicx}
|
||||
\usepackage{float}
|
||||
\usepackage[a4paper, margin=1in]{geometry}
|
||||
\usepackage{subcaption}
|
||||
\usepackage{amsthm}
|
||||
\usepackage{amssymb}
|
||||
\usepackage{amsmath}
|
||||
|
||||
\renewcommand{\figurename}{ábra}
|
||||
\newenvironment{tetel}[1]{\paragraph{#1 \\}}{}
|
||||
|
||||
% A dokument itt kezdődik
|
||||
|
||||
\title{Záróvizsga tételsor \\ \large 11. Formális nyelvek}
|
||||
\date{}
|
||||
\author{Dobreff András}
|
||||
|
||||
\begin{document}
|
||||
\maketitle
|
||||
|
||||
\begin{tetel}{Formális nyelvek}
|
||||
Formális nyelvtanok és a Chomsky-féle nyelvosztályok. Automaták: véges automata, veremautomata. Reguláris nyelvek tulajdonságai és alkalmazásai. Környezetfüggetlen nyelvek tulajdonságai és elemzésük.
|
||||
\end{tetel}
|
||||
|
||||
\section{Formális nyelvtanok és a Chomsky-féle nyelvosztályok}
|
||||
\subsection{Alapfogalmak}
|
||||
\begin{description}
|
||||
\item[Ábécé, szó] \hfill \\
|
||||
Szimbólumok véges nemüres halmazát ábécének nevezzük.
|
||||
|
||||
Egy $V$ ábécé elemeiből képzett véges sorozatokat $V$ feletti szavaknak vagy sztringeknek nevezzük. A 0 hosszúságú sorozatot üres szónak nevezzük és
|
||||
$\varepsilon$-nal jelöljük.
|
||||
|
||||
A $V$ ábécé feletti szavak halmazát (beleértve az üres szót is) $V^*$-gal, a nemüres szavak halmazát $V^+$-szal jelöljük.
|
||||
|
||||
\item[Konkatenáció] \hfill \\
|
||||
Az $ x = uv$ szót az $u,v \in V$ szavak konkatenációjának nevezzük.
|
||||
|
||||
A konkatenáció asszociatív, de (általában) nem kommutatív.
|
||||
|
||||
$V^*$ zárt a konkatenációra. Azaz:
|
||||
\begin{align*}
|
||||
u,v \in V^* \Rightarrow uv \in V^*
|
||||
\end{align*}
|
||||
Továbbá $\varepsilon$ egységelemnek tekinthető $V^*$-gal és a konkatenációval. Azaz:
|
||||
\begin{align*}
|
||||
u \in V^* \Rightarrow u\varepsilon \in V^* \textrm{, és }\varepsilon u \in V^*
|
||||
\end{align*}
|
||||
\item[Egyéb definíciók] \hfill
|
||||
\begin{itemize}
|
||||
\item $u,v \in V$. Az $u$ szót a $v$ részszavának nevezzük, ha $ v = xuy , \ (x,y \in V)$ teljesül. Ha még $xy\neq\varepsilon$, akkor $u$ valódi részszó.
|
||||
|
||||
\item $ v = xuy \ (x,y,u,v \in V)$. Ekkor:
|
||||
\begin{itemize}
|
||||
\item Ha $x=\varepsilon$, akkor $u$-t a $v$ szó prefixének nevezzük
|
||||
\item Ha $y=\varepsilon$, akkor $u$-t a $v$ szó szufixének nevezzük
|
||||
\end{itemize}
|
||||
|
||||
\item Egy $u\in V$ szó tükörképe alatt a szimbólumai fordított sorrendben való felírását értjük. (Jele: $u^{-1}$)
|
||||
\end{itemize}
|
||||
\end{description}
|
||||
\subsection{Formális nyelvtanok}
|
||||
\begin{description}
|
||||
\item[Nyelv] \hfill \\
|
||||
Ha $L \subset V^*$, akkor $L$-et $V$ feletti nyelvnek tekintjük.
|
||||
|
||||
Az üres nyelv (egy szót sem tartalmaz) jele: $\emptyset$
|
||||
|
||||
$L$ nyelv véges nyelv, ha véges számú szót tartalmaz, különben végtelen nyelv.
|
||||
|
||||
Nyelvekre vonatkozó műveletek:
|
||||
\begin{itemize}
|
||||
\item $ L_1 \cup L_2 = \{u | \ u \in L_1 $ vagy $ u \in L_2\}$ : az $L_1$ és $L_2$ nyelv uniója
|
||||
\item $ L_1 \cap L_2 = \{u | \ u \in L_1 $ és $ u \in L_2\}$ : az $L_1$ és $L_2$ nyelv metszete
|
||||
\item $ L_1 - L_2 = \{u | \ u \in L_1 $ és $ u \notin L_2\}$ : az $L_1$ és $L_2$ nyelv különbsége
|
||||
\item $\overline{L} = V^* - L$ : az $L \subseteq V^*$ komplementere
|
||||
\item $L_1L_2 = \{u_1u_2 | \ u_1 \in L_1, u_2 \in L_2\}$ : az $L_1$ és $L_2$ nyelv konkatenációja\\
|
||||
Minden nyelvre fennáll: $\emptyset L = L \emptyset = \emptyset$ illetve $\{\varepsilon\}L = L\{\varepsilon\} = L$
|
||||
\item $L^i$ : az $L$ nyelv $i$-edik ($i \geq 1$) iterációja (a konkatenációra nézve), és $L^0 = \{\varepsilon\}$
|
||||
\item $ L^* = \bigcup\limits_{i\geq1} L^i$ : az $L$ nyelv iteratív lezártja
|
||||
\end{itemize}
|
||||
Az unió, konkatenáció és iteráció lezárása műveleteket reguláris művelteknek nevezzük.
|
||||
\item[Grammatika] \hfill \\
|
||||
Nyelvek sokféle módon előállíthatók. A produkciós rendszerekkel való előállítás egyik módja a nyelvek generálása grammatikával.
|
||||
|
||||
A $G$ generatív grammatikán egy $(N,T,P,S)$ négyest értünk, ahol:
|
||||
\begin{itemize}
|
||||
\item $N$ és $T$ diszjunkt ábécék, a nemterminális ($N$) és terminális ($T$) szimbólumok ábécéi.
|
||||
\item $S\in N$ a kezdőszimbólum.
|
||||
\item $P$ az $(x,y)$ rendezett párok halmaza, ahol $x,y \in (N \cup T)^*$ és $x$ legalább egy nemterminális szimbólumot tartalmaz. \\
|
||||
A $P$ halmaz elemeit átírási szabályoknak nevezzük.
|
||||
\end{itemize}
|
||||
Az $(x,y)$ jelölés helyett az $x \rightarrow y$ jelölést alkalmazzuk. (Ha $\rightarrow \notin (N\cup T)$ )
|
||||
\item[Levezetés] \hfill \\
|
||||
$ G = (N,T,P,S) $, és $u,v \in (N\cup T)^*$. A $v$ szó közvelenül (egy lépésben) levezethető $u$ szóból $G$-ben, ha
|
||||
\begin{align*}
|
||||
u = u_1xu_2, \ v = u_1yu_2 \ \textrm{és} \ x \rightarrow y \in P \quad (u_1, u_2 \in (N \cup T)^*)
|
||||
\end{align*}
|
||||
Ezt $ u \Longrightarrow_G v$ jelöljük.
|
||||
|
||||
Azt mondjuk, hogy a $v$ szó $k \ (\geq 1)$ lépésben levezethető az $u$ szóból $G$-ben, ha
|
||||
\begin{align*}
|
||||
\exists u_1, ... , u_{k+1} \in (N\cup T)^*: u = u_1, v = u_{k+1} \ \textrm{és} \ u_i \Longrightarrow_G u_{i+1} \quad (1 \leq i \leq k)
|
||||
\end{align*}
|
||||
|
||||
A $v$ szó levezethető az $u$ szóból G-ben, ha $u=v$ vagy $\exists k \geq 1$ szám, hogy $v$ $k$ lépésben levezethető $u$-ból.\\
|
||||
Másképp: A $v$ szó levezethető az $u$ szóból G-ben (jele: $ u \Longrightarrow_G^* v $), ha $u=v$ vagy $\exists z \in (N\cup T)^*$ szó, hogy $ u \Longrightarrow_G^* z $ és $ z \Longrightarrow_G v $
|
||||
\item[Generált nyelv] \hfill \\
|
||||
$L(G)$ a $G=(N,T,P,S)$ grammatika által generált nyelv, ha:
|
||||
\begin{align*}
|
||||
L(G) = \{w | \ S \Longrightarrow_G^* w, w \in T^*\}
|
||||
\end{align*}
|
||||
\end{description}
|
||||
\subsection{Chomsky-féle hierarchia}
|
||||
$G = (N,T,P,S)$ generatív grammatika $i$-típusú ($i=0,1,2,3$), ha $P$ szabályhalmazára a következők teljesülnek:
|
||||
\begin{description}
|
||||
\item[Mondatszerkezetű grammatika (i=0)] \hfill \\
|
||||
Nincs korlátozás
|
||||
\item[Környezetfüggő grammatika (i=1)] \hfill \\
|
||||
$P$ minden szabálya $u_1Au_2 \rightarrow u_1vu_2$ alakú, ahol, $A\in N$ és $ v \neq \varepsilon $, ($u_1,u_2, v \in (N \cup T)^*$).
|
||||
Kivéve az $S \rightarrow \varepsilon$ szabályt (ha létezik). Ekkor $S$ nem fordul elő egyetlen szabály jobboldalán sem.
|
||||
\item[Környezetfüggetlen grammatika (i=2)] \hfill \\
|
||||
$P$ minden szabálya $A \rightarrow v$ alakú, ahol, $A\in N, v \in (N \cup T)^*$.
|
||||
\item[Reguláris grammatika (i=3)] \hfill \\
|
||||
$P$ minden szabálya $A \rightarrow vB$ vagy $A \rightarrow v$ alakú, ahol, $A,B\in N, v \in T^*$.
|
||||
\end{description}
|
||||
|
||||
\noindent
|
||||
$L$ nyelv $i$-típusú, ha $i$-típusú grammatikával generálható. Az $i$-típusú nyelvek osztályát $\mathcal{L}_i$ jelöljük.
|
||||
|
||||
\noindent
|
||||
Az $i$-típusú nyelvosztályok a következő tulajdonságokkal rendelkeznek:
|
||||
\begin{itemize}
|
||||
\item $ \mathcal{L}_3 \subset \mathcal{L}_2 \subset \mathcal{L}_1 \subset \mathcal{L}_0 $
|
||||
\item Az $\mathcal{L}_i \ (i=0,1,2,3)$ nyelvosztályok mindegyike zárt a reguláris műveletekre.
|
||||
\end{itemize}
|
||||
\section{Automaták}
|
||||
Formális nyelvek megadása nemcsak generatív, hanem felismerő eszközökkel is lehetséges, azaz olyan számítási eszközök segítségével, amelyek szavak feldolgozására és azonosítására alkalmasak.
|
||||
Ilyen eszköz például az automata, amely egy szó, mint input hatására kétféleképpen viselkedhet: vagy elfogadja, vagy elutasítja.
|
||||
\subsection{Véges Automata}
|
||||
\begin{description}
|
||||
\item[Definíció] \hfill \\
|
||||
A véges automata egy rendezett ötös,
|
||||
\[A=(Q,T,\delta,q_0, F)\]
|
||||
ahol:
|
||||
\begin{itemize}
|
||||
\item Q - állapotok véges nemüres halmaza
|
||||
\item T - input szimbólumok ábécéje
|
||||
\item $\delta : Q \times T \rightarrow Q$ - állapot-átementi függvény
|
||||
\item $q_0 \in Q$ - kezdőállapot
|
||||
\item $F \subseteq Q$ - elfogadó állapotok halmaza
|
||||
\end{itemize}
|
||||
|
||||
Működés:\\
|
||||
A véges automata diszkrét időintervallumokban végrehajtott lépések sorozata által működik. Minden egyes lépés során az automata elolvassa a következő input szimbólumot és átmegy egy olyan állapotba, amelyet az állapotátmeneti függvény meghatároz (az aktuális állapot és input szimbólum alapján).
|
||||
|
||||
Kezdetben az $A$ véges automata a $q_0$ kezdőállapotban van és az olvasófej az input szalagon levő $u \in T^*$ szó első betűjét dolgozza fel. Ezután a véges automata lépések sorozatát végrehajtva elolvassa az input $u$ szót; betűről betűre haladva olvas és új állapotba kerül.
|
||||
|
||||
Miután az $u$ input szó utolsó betűjét is elolvasta a véges automata, vagy $q \in F,$ azaz elfogadó állapotba kerül, és akkor az $u$ szót az automata elfogadja, vagy az új állapot nem lesz eleme $F$-nek, és ekkor az automata a szót nem fogadja el.
|
||||
|
||||
|
||||
\item[VDA - Véges determinisztikus automata] \hfill \\
|
||||
A $\delta$ függvény egyértékű, ezért minden egyes $(q, a)$ párra, ahol $(q, a) \in Q \times T$ egyetlen olyan $s$ állapot létezik, amelyre $\delta(q, a) = s$ teljesül. Ezért ezt a véges automatát determinisztikusnak nevezzük.
|
||||
\item[VNDA - Véges nemdeterminisztikus automata] \hfill \\
|
||||
Ha többértékű állapot-átmeneti függvényt is megengedünk, azaz $\delta : Q \times T \rightarrow 2^Q$, akkor nemdeterminisztikus véges automatáról beszélünk. (Ebben az esetben aktuális állapotnak egy állapothalmaz valamely elemét, mintsem egyetlen állapotot tekinthetünk.)
|
||||
|
||||
Ez azt jelenti, hogy a kezdeti állapot helyettesíthető egy $Q_0 \subseteq Q$ kezdőállapot halmazzal.
|
||||
(És az is előfordulhat, hogy egy a input szimbólum esetén $\delta(q, a)$ üres az aktuális állapotok mindegyikére.)
|
||||
\item[Tulajdonságok] \hfill \\
|
||||
Az állapot-átmeneteket
|
||||
\[qa \rightarrow p\]
|
||||
alakú szabályok formájában is írhatjuk $p \in \delta(q, a) $ esetén. Jelöljük $M_\delta$-val az $A = (Q, T, \delta,Q_0, F)$ nemdeterminisztikus véges automata $\delta$ állapot-átmenet függvénye által az előbbi módon származó szabályok halmazát.
|
||||
|
||||
Ha minden egyes $(q, a)$ párra egyetlen $qa \rightarrow p$ szabály van $M_\delta$-ban, akkor a véges automata determinisztikus, egyébként nemdeterminisztikus.
|
||||
|
||||
\begin{itemize}
|
||||
\item Közvetlen redukció: \\
|
||||
Legyen $A = (Q, T, \delta, q_0, F)$ egy véges automata és legyenek $u, v \in QT^*$ szavak. Azt mondjuk, hogy az $A$ automata az $u$ szót a $v$ szóra redukálja egy lépésben/közvetlenül. Ha van olyan $qa \rightarrow p$ szabály $M_\delta$-ban, és van olyan $w \in T^*$ szó, amelyre $u = qaw$ és $v = pw$ teljesül.
|
||||
|
||||
\item Redukció:\\
|
||||
Az $A = (Q, T, \delta, q_0, F)$ véges automata az $u \in QT^*$ szót a $v \in QT^*$ szóra redukálja $(u \Longrightarrow_A^* v)$, ha $u = v$, vagy $ \exists z \in QT^*$, amelyre $u \Longrightarrow_A^* z$ és $z \Longrightarrow_A v$ teljesül.
|
||||
|
||||
\item Az automata által elfogadott nyelv:\\
|
||||
Az $A = (Q, T, \delta, q_0, F)$ véges automata által elfogadott/felismert nyelv alatt az \[ L(A) = \{u \in T^* | \ q_0u \Longrightarrow_A^* p, \quad q_0 \in Q_0 \textrm{ és } p \in F\} \] szavak halmazát értjük. (Az üres szó, akkor és csak akkor van benne az automata által elfogadott $L(A)$ nyelvben, ha $Q_0 \cap F \neq \emptyset$).
|
||||
|
||||
\item Tétel:\\
|
||||
Minden $A$ nemdeterminisztikus véges automatához meg tudunk adni egy 3-típusú $G$ grammatikát úgy, hogy $L(G) = L(A)$ teljesül.
|
||||
|
||||
\item Tétel: \\
|
||||
Minden 3-típusú G grammatikához meg tudunk adni egy $A$ véges automatát úgy, hogy $L(A) = L(G)$ teljesül. \\
|
||||
|
||||
|
||||
Ezek után fenáll a kérdés: Létezik-e olyan reguláris nyelv, amely VNDA-val felismerhető, de nem ismerhető fel VDA-val? \\
|
||||
Válasz: Nincs.
|
||||
|
||||
\item Tétel:\\
|
||||
Minden $A = (Q, T, \delta,Q_0, F)$ VNDA-hoz meg tudunk konstruálni egy $A' = (Q', T, \delta', q_0', F')$ VDA-t úgy, hogy $L(A) = L(A')$ teljesül.
|
||||
\end{itemize}
|
||||
\end{description}
|
||||
\subsection{Veremautomata}
|
||||
\begin{description}
|
||||
\item[Definíció] \hfill \\
|
||||
A veremautomata egy rendezett hetes
|
||||
\[A = (Z,Q, T, \delta, z_0, q_0, F)\]
|
||||
ahol
|
||||
\begin{itemize}
|
||||
\item Z - a veremszimbólumok véges halmaza,
|
||||
\item Q - az állapotok véges halmaza,
|
||||
\item T - az inputszimbólumok véges halmaza,
|
||||
\item $\delta : Z \times Q \times (T \cup \{\varepsilon\}) \rightarrow 2^{Z^* \times Q}$ - átmeneti függvény
|
||||
\item $z_0 \in Z $ - a kezdeti veremszimbólum,
|
||||
\item $q_0 \in Q $ - a kezdeti állapot,
|
||||
\item $F \subseteq Q$ - az elfogadó állapotok halmaza
|
||||
\end{itemize}
|
||||
|
||||
A veremautomata konfigurációja alatt egy $uq$ alakú szót értünk, ahol $u \in Z^*$ a verem aktuális tartalma és $q \in Q$ az aktuális állapot. \\
|
||||
A kezdeti konfiguráció $z_0q_0$.
|
||||
|
||||
Működés: \\
|
||||
Tegyük fel, hogy az $A$ veremautomata olvasófeje az $a$ inputszimbólumon áll, a veremautomata $q$ állapotban van, valamint a verem tetején levő szimbólum $z$. Legyen $ \delta(z, q, a) = {(u_1, r_1), . . . , (u_n, r_n)}$, ahol $u_i \in Z^*$ és $r_i \in Q, 1 \leq i \leq n$. Ekkor $A$ következő állapota valamely $r_i$ lesz és egyidejűleg $z$-t helyettesíti az $u_i$ szóval, továbbá az olvasófej egy cellával jobbra lép az input szalagon.\\
|
||||
Ha $\delta(z, q, \varepsilon)$ nem üres, akkor ún. $\varepsilon$-átmenet hajtható végre.
|
||||
|
||||
Ha az input szalag a $w \in T^*$ szót tartalmazza és a $z_0q_0$ kezdeti konfigurációból kiindulva a lépések sorozatát végrehajtva az $A$ veremautomata egy $up$ konfigurációba ér, ahol $p$ elfogadó állapot, akkor azt mondjuk, hogy $A$ elfogadta a $w$ szó.
|
||||
|
||||
\item[Tulajdonságok] \hfill
|
||||
\begin{itemize}
|
||||
\item Közvetlen redukció: \\
|
||||
$\alpha, \beta \in Z^*QT^*$\\
|
||||
Az $A$ veremautomata az $\alpha $ szót a $\beta$ szóra redukálja egy lépésben ($\alpha \Longrightarrow_A \beta$), ha:
|
||||
\[\exists z \in Z, \ p,q \in Q, \ a \in T \cup \{\varepsilon\}, \ r,u \in Z^* \textrm{ és } w\in T^*\]
|
||||
hogy:
|
||||
\[(u,p) \in \delta(z,q,a) \textrm{ és } \alpha = rzqaw \textrm{ és } \beta = rupw\]
|
||||
\item Redukció: \\
|
||||
Az A veremautomata az $\alpha$ szót a $\beta$ szóra redukálja ($\alpha \Longrightarrow_A^* \beta$), ha vagy $\alpha = \beta$, vagy
|
||||
$ \exists \gamma_1,...,\gamma_n \in Z^*QT^*$ szavakból álló véges sorozat, hogy $\alpha = \gamma_1, \ \beta = \gamma_n, \quad \textrm{ és } \quad \\ {\gamma_i \Longrightarrow_A \gamma_{i+1} \quad (i=1,...,n-1)}$
|
||||
\item A veremautomata által elfogadott nyelv: \\
|
||||
Az A veremautomata által (elfogadó állapottal) elfogadott nyelv:
|
||||
\[L(A) = \{ w \in T^* | \ z_0q_0w \Longrightarrow_A^* up, \textrm{ ahol } u \in Z^*, p \in F \} \]
|
||||
\item Determinizmus: \\
|
||||
A $\delta$ leképezést szabályok formájában is megadhatjuk. Az így nyert szabályhalmazt $M_\delta$-val jelöljük. Tehát
|
||||
\begin{enumerate}
|
||||
\item $zqa \rightarrow up \in M_\delta$ ha $(u, p) \in \delta(z, q, a)$
|
||||
\item $zq \rightarrow up \in M_\delta$ ha $(u, p) \in \delta(z, q, \varepsilon)$
|
||||
\end{enumerate}
|
||||
|
||||
Az $A = (Z,Q, T,\delta, z_0, q_0, F)$ veremautomatát determinisztikusnak mondjuk, ha minden $(z, q) \in Z \times Q$ pár esetén:
|
||||
\begin{enumerate}
|
||||
\item $\forall a \in T: |\delta(z, q, a)| = 1$ és $\delta(z, q, \varepsilon) = \emptyset$
|
||||
|
||||
vagy
|
||||
\item $|(z, q, \varepsilon)| = 1 $ és $\forall a \in T: \delta(z, q, a) = \emptyset$
|
||||
\end{enumerate}
|
||||
\item Üres veremmel elfogadott nyelv: \\
|
||||
Az $N(A)$ nyelvet az $A$ veremautomata üres veremmel fogadja el, ha
|
||||
\[ N(A) = \{w \in T^* | \ z_0q_0w \Longrightarrow_A^* p, \textrm{ ahol } p \in Q \} \]
|
||||
\item Tétel: \\
|
||||
Bármely $G$ környezetfüggetlen grammatikához meg tudunk adni egy olyan $A$ veremautomatát, amelyre $L(A) = L(G)$ teljesül.
|
||||
\item Tétel: \\
|
||||
Minden $A$ veremautomatához meg tudunk adni egy környezetfüggetlen $G$ grammatikát úgy, hogy $L(G) = N(A)$ teljesül.
|
||||
\end{itemize}
|
||||
\end{description}
|
||||
\section{Reguláris nyelvek tulajdonságai és alkalmazásai}
|
||||
\subsection{3-típusú grammatikák normálformája}
|
||||
Minden 3-típusú, azaz reguláris nyelv generálható egy olyan grammatikával, amelynek szabályai:
|
||||
\begin{itemize}
|
||||
\item $ X \rightarrow aY$, ahol $X,Y \in N$ és $a \in T$
|
||||
\item $X \rightarrow \varepsilon$, ahol $X \in N$
|
||||
\end{itemize}
|
||||
\subsection{Reguláris kifejzések}
|
||||
\begin{description}
|
||||
\item[Motiváció] \hfill \\
|
||||
Ismeretes, hogy minden véges nyelv reguláris. Tudjuk továbbá, hogy az $\mathcal{L}_3$ nyelvosztály (a reguláris nyelvek osztálya) zárt az unió, a konkatenáció és az iteráció lezártja műveletekre nézve.
|
||||
|
||||
Következésképpen, kiindulva véges számú véges nyelvből és az előzőekben felsorolt, ún. reguláris műveleteket véges sokszor alkalmazva reguláris nyelvet kapunk.
|
||||
|
||||
Kérdés az, hogy vajon ezzel az eljárással minden reguláris nyelvet
|
||||
elő tudunk-e állítani, azaz, ez a módszer elégséges-e az $\mathcal{L}_3$ nyelvosztály leírására?
|
||||
\item[Definíció] \hfill \\
|
||||
Legyenek $V$ és $V' = \{\varepsilon, \cdot, +, *, (, )\}$ diszjunkt ábécék. A $V$ ábécé feletti reguláris kifejezéseket rekurzív módon a következőképpen definiáljuk:
|
||||
\begin{enumerate}
|
||||
\item $\varepsilon$ reguláris kifejezés $V$ felett.
|
||||
\item Minden $a \in V$ reguláris kifejezés $V$ felett.
|
||||
\item Ha R reguláris kifejezés V felett, akkor $(R)^*$ is reguláris kifejezés $V$ felett. [iteratív lezárás]
|
||||
\item Ha $Q$ és $R$ reguláris kifejezések $V$ felett, akkor $(Q) \cdot (R)$ [konkatenáció] és $(Q) + (R)$ [unió] is reguláris kifejezés $V$ felett.
|
||||
\end{enumerate}
|
||||
|
||||
\textit{Megjegyzés: Minden reguláris kifejezés jelöl (meghatároz) valamely reguláris nyelvet. (Pl.: $\varepsilon$ a $\{\varepsilon\}$ nyelvet, $a+b$ az $\{a\} \cup \{b\} = \{a,b\}$ és $a\cdot b$ az $\{a\}\{b\} = \{ab\}$ nyelvet.) A reguláris kifejezés a szintaxis, az, hogy hogyan értelmezzük, a szemantika.}
|
||||
\item[Axiómák]\hfill \\
|
||||
$P,Q,R$ reguláris kifejezések. Ekkor fennállnak a következő tulajdonságok:
|
||||
\begin{itemize}
|
||||
\item Asszociativitás:
|
||||
\[P+(Q+R) = (P+Q)+R\]
|
||||
\[P\cdot(Q\cdot R) = (P\cdot Q)\cdot R\]
|
||||
\item Kommutativitás:
|
||||
\[P+Q = Q+P\]
|
||||
\item Disztributivitás:
|
||||
\[P\cdot (Q+R) = P\cdot Q + P\cdot R\]
|
||||
\[(P+Q)\cdot R = P\cdot R + Q\cdot R\]
|
||||
\item Egységelem:
|
||||
\[\varepsilon\cdot P = P\cdot\varepsilon = P\]
|
||||
\[P^* = \varepsilon + P \cdot P^*\]
|
||||
\[P^* = (\varepsilon+P)^*\]
|
||||
\end{itemize}
|
||||
|
||||
A fenti axiómák azonban még önmagukban nem elegendőek az összes reguláris kifejezés előállítására (helyettesítés segítségével). Szükség van még az alábbi inferencia szabályra:
|
||||
\[P=R+P\cdot Q \quad \land \quad \varepsilon \notin Q \quad \Longrightarrow \quad P = R\cdot Q^*\]
|
||||
|
||||
Vegyük még hozzá az $\emptyset$ szimbólumot a reguláris kifejezések halmazához, amely az üres nyelvet jelöli. (Ebben az esetben nincs szükségünk az $\varepsilon$ szimbólumra, mivel $\emptyset^* = \{\varepsilon\}$). Így, a definícióban helyettesíthetjük az $\varepsilon$ szimbólumot az $\emptyset$ szimbólummal. Ekkor helyettesítjük $\varepsilon$-t a megelőző axióma rendszerben $(\emptyset)^*$-gal és még egy további
|
||||
axiómát tekintünk:
|
||||
\[\emptyset\cdot P = P\cdot\emptyset = \emptyset\]
|
||||
A fenti szabályok elégségesek ahhoz, hogy levezessünk minden érvényes egyenlőséget
|
||||
reguláris kifejezések között.
|
||||
\item[Reguláris kifejezések és reguláris nyelvek] \hfill \\
|
||||
Minden reguláris kifejezés egy reguláris (3-típusú) nyelvet jelöl, és megfordítva, minden reguláris nyelvhez megadható egy, ezen nyelvet jelölő reguláris kifejezés.\\ (Ezzel választ adtunk a motivációban feltett kérdésre.)
|
||||
\end{description}
|
||||
\subsection{Lineáris grammatikák és nyelvek}
|
||||
\begin{description}
|
||||
\item[Definíció] \hfill \\
|
||||
Egy $G=(N,T,P,S)$ környezetfüggetlen grammatikát lineárisnak nevezünk, ha minden szabálya:
|
||||
\begin{enumerate}
|
||||
\item $A\rightarrow u, \quad A \in N, u \in T^*$
|
||||
\item $A\rightarrow u_1Bu_2, \quad A,B\in N, u_1,u_2 \in T^*$
|
||||
\end{enumerate}
|
||||
Továbbá $G$-t bal-lineárisnak, illetve jobb-lineárisnak mondjuk, ha $u_1 = \varepsilon$, illetve $u_2 = \varepsilon$ minden 2. alakú szabályra.
|
||||
|
||||
Egy $L$ nyelvet lineárisnak, bal-lineárisnak, illetve jobb-lineárisnak mondunk,
|
||||
ha van olyan $G$ lineáris, bal-lineáris, illetve jobb-lineáris grammatika,
|
||||
amelyre $L = L(G)$ teljesül.
|
||||
\item[Lineáris és reguláris grammatikák, nyelvek] \hfill \\
|
||||
A jobb-lineáris grammatikák azonosak a reguláris grammatikákkal (3-típusúak).
|
||||
|
||||
Tétel: \\
|
||||
Minden bal-lineáris grammatika reguláris (3-típusú) nyelvet generál.
|
||||
\end{description}
|
||||
\section{Környezetfüggetlen nyelvek tulajdonságai és elemzésük}
|
||||
\subsection{Környezetfüggetlen grammatikák normálformái}
|
||||
Környezetfüggetlen grammatikák normálformái olyan grammatikai transzformációval előállított grammatikák, melyek:
|
||||
\begin{itemize}
|
||||
\item bizonyos szintaktikai feltételeknek/tulajdonságoknak tesznek eleget
|
||||
\item (általában) valamilyen szempontból egyszerűbbek, mint az eredeti grammatikák
|
||||
\item ugyanazt a nyelvet generálják (így ugyanazon típusba tartoznak)
|
||||
\end{itemize}
|
||||
Tétel:\\
|
||||
Minden $G = (N, T, P, S)$ környezetfüggetlen grammatikához meg tudunk konstruálni egy vele ekvivalens $G' = (N', T, P', S')$ környezetfüggetlen grammatikát úgy, hogy: $G'$ minden szabályának jobboldala nemüres szó [kivéve azt az esetet, mikor $\varepsilon \in L(G)$, ekkor $S' \rightarrow \varepsilon$ az egyetlen szabály, melynek jobboldala az üres szó és ekkor $S'$ nem fordul elő $G'$ egyetlen szabályának jobboldalán sem.]
|
||||
\begin{description}
|
||||
\item[$\varepsilon$-mentes grammatika] \hfill \\
|
||||
A $G$ grammatika $\varepsilon$-mentes, ha egyetlen szabályának jobboldala sem az üres szó.
|
||||
|
||||
Tétel:\\
|
||||
Minden környezetfüggetlen $G$ grammatikához meg tudunk konstruálni egy $G'$ $\varepsilon$-mentes környezetfüggetlen grammatikát, amelyre $L(G') = L(G) - \{\varepsilon\}$ teljesül.
|
||||
\item[Chomsky normálforma] \hfill \\
|
||||
A $G = (N, T, P, S)$ környezetfüggetlen grammatikát Chomsky-normálformájúnak mondjuk, ha minden egyes szabálya:
|
||||
\begin{itemize}
|
||||
\item $X \rightarrow a$, ahol $X \in N, a \in T$
|
||||
\item $X \rightarrow YZ$, ahol $X,Y,Z \in N$
|
||||
\end{itemize}
|
||||
Tétel:\\
|
||||
Minden $\varepsilon$-mentes $G=(N,T,P,S)$ környezetfüggetlen grammatikához meg tudunk konstruálni egy vele ekvivalens $G' = (N', T, P', S)$ Chomsky-normálformájú környezetfüggetlen grammatikát.
|
||||
|
||||
Tétel (az előző következménye):\\
|
||||
Minden $G$ környezetfüggetlen grammatika esetében eldönthető, hogy egy $u$ szó benne van-e $G$ grammatika által generált nyelvben.
|
||||
\item[Redukált grammatika] \hfill
|
||||
\begin{itemize}
|
||||
\item A környezetfüggetlen grammatika egy nemterminálisát inaktívnak/nem aktívnak nevezzük, ha nem vezethető le belőle terminális szó.
|
||||
\item A környezetfüggetlen grammatika egy nemterminálisát nem elérhetőnek nevezzük, ha nem fordul elő egyetlen olyan szóban sem, amely a kezdőszimbólumból levezethető.
|
||||
\item Egy nemterminálist nem hasznosnak mondunk, ha vagy inaktív, és/vagy nem elérhető.
|
||||
\item Az, hogy egy $A$ nemterminális elérhető-e vagy aktív-e, az eldönthető.
|
||||
\item Egy környezetfüggetlen grammatika redukált, ha minden nemterminálisa aktív és elérhető.
|
||||
\end{itemize}
|
||||
Tétel:\\
|
||||
Minden környezetfüggetlen grammatikához meg tudunk konstruálni egy vele ekvivalens redukált környezetfüggetlen grammatikát.
|
||||
|
||||
\end{description}
|
||||
\subsection{Levezetési fa}
|
||||
A környezetfüggetlen grammatikák levezetéseit fákkal is jellemezhetjük. A levezetési fa egy szó előállításának lehetőségeiről ad információkat. A levezetési fa egy irányított gráf, amely speciális tulajdonságoknak tesz eleget:
|
||||
\begin{itemize}
|
||||
\item A gyökér cimkéje: $S$
|
||||
\item A többi csúcs cimkéje ($N\cup T$) valamely eleme
|
||||
\end{itemize}
|
||||
A levezetési fa nem minden esetben adja meg a levezetés során alkalmazott szabályok sorrendjét. Két levezetés lényegében azonos, ha csak a szabályok alkalmazásának sorrendjében különbözik.
|
||||
|
||||
Egy környezetfüggetlen grammatika minden levezetési fája egy egyértelmű (egyetlen) legbaloldalibb levezetést határoz meg. A legbaloldalibb levezetés során minden levezetési lépésben a legbaloldalibb nemterminálist kell helyettesítenünk.
|
||||
\\\\
|
||||
Tétel:\\
|
||||
Minden környezetfüggetlen grammatikáról eldönthető, hogy az általa generált nyelv az üres nyelv-e vagy sem.
|
||||
\subsection{Bar-Hillel Lemma}
|
||||
Minden $L$ környezetfüggetlen nyelvhez meg tudunk adni két $p$ és $q$ természetes számot úgy, hogy minden olyan szó $L$-ben, amely hosszabb, mint $p$
|
||||
\[uxwyz\]
|
||||
alakú, ahol $|xwy| \leq q$, $xy \neq \varepsilon$ , és minden
|
||||
\[ux^iwy^iv\]
|
||||
szó is benne van az $L$ nyelvben minden $i \geq 0$ egész számra ($u,x,w,y,v \in T^*$).
|
||||
\\\\
|
||||
Tétel:\\
|
||||
Eldönthető, hogy egy környezetfüggetlen grammatika végtelen nyelvet generál-e vagy sem.
|
||||
\end{document}
|
After Width: | Height: | Size: 11 KiB |
After Width: | Height: | Size: 12 KiB |
After Width: | Height: | Size: 15 KiB |
After Width: | Height: | Size: 16 KiB |
After Width: | Height: | Size: 14 KiB |
After Width: | Height: | Size: 12 KiB |
After Width: | Height: | Size: 6.8 KiB |
After Width: | Height: | Size: 13 KiB |
After Width: | Height: | Size: 14 KiB |
After Width: | Height: | Size: 4.2 KiB |
After Width: | Height: | Size: 24 KiB |
After Width: | Height: | Size: 40 KiB |
After Width: | Height: | Size: 13 KiB |
After Width: | Height: | Size: 5.7 KiB |
After Width: | Height: | Size: 16 KiB |
After Width: | Height: | Size: 26 KiB |
After Width: | Height: | Size: 7.8 KiB |
After Width: | Height: | Size: 29 KiB |
After Width: | Height: | Size: 24 KiB |
After Width: | Height: | Size: 12 KiB |
After Width: | Height: | Size: 15 KiB |
After Width: | Height: | Size: 20 KiB |
After Width: | Height: | Size: 20 KiB |
After Width: | Height: | Size: 18 KiB |
After Width: | Height: | Size: 28 KiB |
After Width: | Height: | Size: 20 KiB |
After Width: | Height: | Size: 8.7 KiB |
After Width: | Height: | Size: 21 KiB |
After Width: | Height: | Size: 13 KiB |
After Width: | Height: | Size: 13 KiB |
After Width: | Height: | Size: 13 KiB |
After Width: | Height: | Size: 5.2 KiB |
@@ -0,0 +1,268 @@
|
||||
\documentclass[margin=0px]{article}
|
||||
|
||||
\usepackage{listings}
|
||||
\usepackage[utf8]{inputenc}
|
||||
\usepackage{graphicx}
|
||||
\usepackage{float}
|
||||
\usepackage[a4paper, margin=1in]{geometry}
|
||||
\usepackage{amsthm}
|
||||
\usepackage{amssymb}
|
||||
\usepackage{t1enc}
|
||||
|
||||
\newenvironment{tetel}[1]{\paragraph{#1 \\}}{}
|
||||
% A dokument itt kezdődik
|
||||
|
||||
\title{Záróvizsga tételsor \\ \large 13. Alapvető algoritmusok és adatszerkezetek}
|
||||
\date{}
|
||||
\author{Fekete Dóra}
|
||||
|
||||
\begin{document}
|
||||
|
||||
\maketitle
|
||||
|
||||
\begin{tetel}{Alapvető algoritmusok és adatszerkezetek}
|
||||
Egyszerű adattípusok ábrázolásai, műveletei és fontosabb alkalmazásai. A hatékony adattárolás és visszakeresés néhány megvalósítása (bináris keresőfa, AVL-fa, 2-3-fa és B-fa, hasítás (,,hash-elés”)). Összehasonlító rendező algoritmusok (buborék és beszúró rendezés, ill. verseny, kupac, gyors és összefésülő rendezés); a műveletigény alsó korlátja.
|
||||
\end{tetel}
|
||||
|
||||
\section{Egyszerű adattípusok ábrázolásai, műveletei és fontosabb alkalmazásai}
|
||||
|
||||
\subsection{Adattípus}
|
||||
|
||||
\textit{Adatszerkezet}: $\sim$ struktúra. \\
|
||||
\textit{Adattípus}: adatszerkezet és a hozzá tartozó műveletek. \\
|
||||
\textit{Adatszerkezetek}:
|
||||
\begin{itemize}
|
||||
\item \textit{Tömb}: azonos típusú elemek sorozata, fix méretű.
|
||||
\item \textit{Verem}: Mindig a verem tetejére rakjuk a következő elemet, csak a legfelsőt kérdezhetjük le, és vehetjük ki.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.3\textwidth]{img/Verembe.jpg}
|
||||
\includegraphics[width=0.3\textwidth]{img/Verembol.jpg}
|
||||
\caption{Verem műveletei}
|
||||
\end{figure}
|
||||
\item \textit{Sor}: Egyszerű, elsőbbségi és kétvégű. A prioritásos sornál az elemekhez tartozik egy érték, ami alapján rendezhetjük őket.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.3\textwidth]{img/Sorba.jpg}
|
||||
\includegraphics[width=0.3\textwidth]{img/Sorbol.jpg}
|
||||
\caption{Sor műveletei}
|
||||
\end{figure}
|
||||
\item \textit{Lista}: Láncolt ábrázolással reprezentáljuk. 3 szempont szerint különböztethetjük meg a listákat: fejelem van/nincs, láncolás iránya egy/kettő, ciklusosság van/nincs. Ha fejelemes a listánk, akkor a fejelem akkor is létezik, ha üres a lista. \\
|
||||
A lista node-okból áll, minden node-nak van egy, a következőre mutató pointere, illetve lehet az előzőre is, ha kétirányú. Ezen kívül van egy első és egy aktuális node-ra mutató pointer is, és az utolsó elem mutatója NIL. A listát megvalósíthatjuk úgy, hogy tetszőleges helyre lehessen elemet beszúrni, illetve törölni.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.3\textwidth]{img/Listaba.jpg}
|
||||
\includegraphics[width=0.3\textwidth]{img/Torol.jpg}
|
||||
\caption{Lista műveletei}
|
||||
\end{figure}
|
||||
\item \textit{Fa}: Egyszerű, bináris és speciális (kupac, bináris keresőfa, AVL-fa). A bináris fát rekurzívan definiáljuk: $t \in T(E)$ [bin. fák típusérték halmaza(alaptípus)] $\iff$ $t$ üres fa (jele: $\Omega$), vagy $t$-nek van gyökéreleme, $bal(t)$, $jobb(t)$ részfája. Láncoltan ábrázoljuk, tömbösen csak teljes fák, illetve kupac esetén.
|
||||
\item \textit{Kupac}: Olyan bináris fa, melynek alakja majdnem teljes és balra rendezett. Tömbösen ábrázoljuk, mert pointeresen a bonyolult lépkedést nem teszi lehetővé, tömbösen indexösszefüggésekkel könnyen megoldható.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.3\textwidth]{img/KupacbaBeszur.jpg}
|
||||
\caption{Kupac műveletei}
|
||||
\end{figure}
|
||||
\item \textit{Hasítótábla}
|
||||
\item \textit{Gráf} [Nem egyszerű adattípus.]
|
||||
\end{itemize}
|
||||
|
||||
\subsection{Ábrázolásai}
|
||||
|
||||
Absztrakciós szintek:
|
||||
\begin{enumerate}
|
||||
\item \textit{absztrakt adattípus (ADT)}: specifikáció szintje, itt nincs szerkezeti összefüggés, csak matematikai fogalmak, műveletek logikai axiómákkal vagy előfeltételekkel.
|
||||
\begin{itemize}
|
||||
\item algebrai (axiomatikus) specifikáció, példa: $Verembe : V \times E \to V$. Axióma, példa: $Felso(Verembe(v,e)) = e$
|
||||
\item funkcionális (elő- és utófeltételes) specifikáció, példa: (elsőbbségi) sor $S(E), s \in S$ egy konkrét sor, $s = \{(e_1, t_1), ..., (e_n, t_n)\}$, $n \geq 0$. Ha $n=0$, akkor a sor üres. \\
|
||||
$\forall i,j \in [1..n]: i \neq j \to t_i \neq t_j$. \\
|
||||
$Sorbol: S \to S \times E$, $\mathcal{D}_{Sorbol} = S \backslash \{ures\}$. Előfeltétel: $Q = (s = s' \wedge s' \neq \emptyset)$, utófeltétel: $R = (s = s' \backslash \{(e,t)\} \wedge (e,t) \in s' \wedge \forall i (e_i, t_i) \in s' : t \leq t_i)$.
|
||||
\end{itemize}
|
||||
\item \textit{absztrakt adatszerkezet (ADS)}: kognitív pszichológia szintje, ábrák. Az alapvető szerkezeti tulajdonságokat tartalmazza (nem mindet). Ennek a szintnek is része a műveletek halmaza. Példák: az ábra egy irányított gráf, művelet magyarázata, adatszerkezet definiálása.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=1\textwidth]{img/ads.png}
|
||||
\caption{ADS}
|
||||
\end{figure}
|
||||
\item \textit{ábrázolás/reprezentáció}: döntések (tömbös vagy pointeres ábrázolás), a nyitva hagyott szerkezeti kérdések. Egy adatszerkezetet többféle reprezentációval is meg lehet valósítani (pl. prioritásos sor lehet rendezetlen tömb, rendezett tömb, kupac).
|
||||
\begin{itemize}
|
||||
\item \textit{tömbös ábrázolás}: takarékos ábrázolás, elhelyezése, tetszőleges rákövetkezések, bejárások, de ezeket meg kell adni.
|
||||
\item \textit{pointeres ábrázolás}: minden pointer egy összetett rekord elejére mutat.
|
||||
\end{itemize}
|
||||
\item \textit{implementálás}
|
||||
\item \textit{fizikai szint}
|
||||
\end{enumerate}
|
||||
|
||||
\subsection{Műveletei}
|
||||
|
||||
\begin{itemize}
|
||||
\item Üres adatszerkezet létrehozása
|
||||
\item Annak lekérdezése, hogy üres-e az adatszerkezet
|
||||
\item Elem berakása, itt ellenőrizni kell, hogy nem telt-e még meg
|
||||
\item Elem kivétele vagy törlése, itt ellenőrizni kell, hogy nem üres-e
|
||||
\item Adott tulajdonságú elem (például maximum, veremben a felső) lekérdezése, itt is ellenőrizni kell, hogy üres-e az adatszerkezet
|
||||
\item Bejárások (preorder, inorder, postorder, szintfolytonos), listáknál az első, előző vagy következő elemre lépés
|
||||
\item Elem módosítása bizonyos adatszerkezeteknél (pl. listák)
|
||||
\end{itemize}
|
||||
|
||||
\subsection{Fontosabb alkalmazásai}
|
||||
|
||||
\textit{Prioritásos sor}: nagygépes programfuttatásnál az erőforrásokat a prioritás arányában osszuk el, adott pillanatban a maximális prioritásút válasszuk. Sürgősségi ügyeleten, gráfalgoritmusoknál is alkalmazható.
|
||||
\textit{B-fa}: ipari méretekben adatbázisokban használják.
|
||||
|
||||
\section{A hatékony adattárolás és visszakeresés néhány megvalósítása (bináris keresőfa, AVL-fa, 2-3-fa és B-fa, hasítás (,,hash-elés”))}
|
||||
|
||||
\subsection{Bináris keresőfa}
|
||||
|
||||
Nincsenek benne azonos kulcsok, a követendő elv: ,,kisebb balra, nagyobb jobbra". Inorder bejárással növekvő kulcssorozatot kapunk. \\
|
||||
Műveletigénye fa magasságú nagyságrendű. \\
|
||||
Az a cél, hogy a bináris keresőfa ne nyúljon meg láncszerűen, erre jó az AVL-fa és a 2-3-fa.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.3\textwidth]{img/Beszur.jpg}
|
||||
\includegraphics[width=0.3\textwidth]{img/Kovetkezo.jpg}
|
||||
\caption{Bináris keresőfa műveletei}
|
||||
\end{figure}
|
||||
|
||||
\subsection{AVL-fa}
|
||||
|
||||
Cél: a $t$ bináris keresőfa magasságának $\log_2(n)$ közelében tartása, azaz $h(t) \leq c \cdot \log_2(n)$, ahol $c$ elfogadhatóan kicsi. Az ilyen fát kiegyensúlyozottnak nevezzük. \\
|
||||
\textit{AVL}: Adelszon-Velszkij, Landisz 1962-ben alkották meg. \\
|
||||
A $t$ bináris keresőfát egyúttal AVL-fának nevezzük $\iff$ $t$ minden $x$ csúcsára $|h(bal(x))-h(jobb(x))| \leq 1$. \\
|
||||
Minden csúcsnak van egy címkéje $+,-,=$ (gyerekek magasságának különbsége). A beszúrás helyétől felfelé ellenőrizzük ezeket, és ha kell, akkor módosítjuk. Ha valahol $++$ vagy $--$ alakul ki, akkor ott elromlik az AVL-tulajdonság, egy vagy több forgatással vagy átkötéssel konstans műveletigénnyel helyre lehet hozni. \\
|
||||
Többféle séma is van: $(++,+), (++,-), (++,=)$ és a tükörképeik.
|
||||
|
||||
\subsection{2-3-fa és B-fa}
|
||||
|
||||
2-3-fa kis méretben az elmélet számára jó, a B-fa a gyakorlati változat adatbázisban. \\
|
||||
$t$ 2-3-fa $\iff$ minden belső csúcsnak 2 vagy 3 gyereke van, a levelek azonos szinten helyezkednek el, adatrekordok csak a levelekben vannak, belső pontokban kulcsok és mutatók, levelekben a kulcsok balról jobbra nőnek. \\
|
||||
Ha 4 gyerek lenne a beszúrás után, akkor csúcsot kell vágni. Ha törlésnél 1 gyerek lenne valahol, akkor csúcsösszevonásokat és gyerekátadást alkalmazunk. \\
|
||||
B-fa nagyobb méretű, itt két határ között mozog a gyerekszám: $\lceil\frac{r}{2}\rceil$ és $r$, ahol $50 \leq r \leq 1000$.
|
||||
|
||||
\subsection{Hasítás}
|
||||
|
||||
Kulcsos rekordokat tárol.
|
||||
\begin{itemize}
|
||||
\item \textit{Hasítás láncolással}: a kulcsütközést láncolással oldja fel. Van egy hasítófüggvény: $h: U \to [0..m-1]$, elvárás vele kapcsolatban, hogy gyorsan számolható és egyenletes legyen. $m$-et úgy választjuk meg $n$ nagyságrendjének ismeretében, hogy $\alpha = \frac{n}{m}$ lesz a várható listahossz, ha egyenletes hasítást feltételezünk.\\
|
||||
Például kétirányú listát használhatunk a hasításhoz. Műveletek: beszúrás, keresés, törlés. \\
|
||||
Gyakorlatban érdemes $m$-et úgy megválasztani, hogy olyan prímszám legyen, ami nem esik 2-hatvány közelébe.
|
||||
\item \textit{Hasítás nyitott/nyílt címzéssel}: A kulcsokat lehessen egészként értelmezni, ekkor vannak jó hasítófüggvények. \\
|
||||
Próbálkozás általános képlete: $h(k) + h_i(k)$ $(mod$ $M)$, $0 \leq i \leq M-1$. Egész addig alkalmazza, amíg üres helyet nem talál.
|
||||
\begin{enumerate}
|
||||
\item \textit{Lineáris próba}: $h_i(k) = -i$ $(mod$ $M)$, egyesével balra lépegetve keressük az üres helyet. Hátránya az elsődleges csomósodás, ez jelentős lassulást okoz beszúrásnál és keresésnél.
|
||||
\item \textit{Négyzetes próba}: $h_i(k) = (-1)^i(\lceil\frac{i}{2}\rceil)^2$ $(mod$ $M)$, a négyzetszámokkal lépegetünk balra-jobbra, ezek az eltolások kiadják $\{0,1,...,M-1\}$-et. Hátrány: másodlagos csomósodás.
|
||||
\item \textit{Kettős hash-elés}: $h_i(k) =-ih'(k)$ $(mod$ $M)$, $h'(k)$ a $k$-hoz tartozó egyedi lépésköz, $(h'(k),M)=1$ relatív prímek. Ha az $M$ elég nagy, akkor nincs csomósodás.
|
||||
\end{enumerate}
|
||||
\item \textit{Hasítófüggvények}: Leggyakoribb: $k$ egész, kongruencia reláció. Általánosan: $h(k) = (ak +b$ $(mod$ $p))$ $(mod$ $M)$, az univerzális hasítás családja. Tapasztalat: $k$ egyenletesen hasít.
|
||||
\end{itemize}
|
||||
|
||||
\section{Összehasonlító rendező algoritmusok (buborék és beszúró rendezés, ill. verseny, kupac, gyors és összefésülő rendezés)}
|
||||
|
||||
Buborék- és beszúró rendezés klasszikusak, $n^2$-es műveletigényűek, a többi hatékony, $n\log(n)$-es idejűek.
|
||||
|
||||
\subsection{Buborékrendezés}
|
||||
|
||||
A legnagyobb értéket cserékkel a végéig felbuborékozza, ezt minden ciklus végén elhagyjuk. A gyakorlatban nem használják.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.3\textwidth]{img/Buborekrendezes.png}
|
||||
\caption{Buborékrendezés}
|
||||
\end{figure}
|
||||
|
||||
\subsection{Beszúró rendezés}
|
||||
|
||||
Kis $n$-re (kb 30) ez a rendezés a legjobb. \\
|
||||
Itt az elemmozgatás mindig 1 értékadás (buborékrendezésnél a csere 3 értékadás). Listára is implementálni lehet, ez esetben a pointereket állítjuk át, az elemek helyben maradnak. \\
|
||||
$A[1..j]$ rendezett, $j=1..n$.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.3\textwidth]{img/Beszurorend.jpg}
|
||||
\caption{Beszúró rendezés}
|
||||
\end{figure}
|
||||
|
||||
\subsection{Versenyrendezés}
|
||||
|
||||
Gyakorlatban nem használják. \\
|
||||
Teljes bináris fa az alapja, egy versenyfa. Szintfolytonosan ábrázoljuk tömbösen.\\
|
||||
\begin{enumerate}
|
||||
\item A versenyfa kitöltése (a verseny lejátszása). Maximum a gyökérben, ennek kiírása az outputra.
|
||||
\item $(n-1)$-szer
|
||||
\begin{itemize}
|
||||
\item[a)] gyökérben szereplő maximális elem helyének megkeresése a levélszinten és $-\infty$ írása a helyére
|
||||
\item[b)] az egészet újrajátsszuk (azt az ágat, ahol volt) $\to$ 2. legjobb feljut a gyökérbe
|
||||
\end{itemize}
|
||||
\end{enumerate}
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.3\textwidth]{img/Versenyrend.jpg}
|
||||
\includegraphics[width=0.3\textwidth]{img/VFaKitolt.jpg}
|
||||
\includegraphics[width=0.3\textwidth]{img/VFaMax.jpg}
|
||||
\caption{Versenyrendezés}
|
||||
\end{figure}
|
||||
|
||||
\subsection{Kupacrendezés}
|
||||
|
||||
\begin{enumerate}
|
||||
\item Kezdő kupac kialakítása. Rendezetlen input tömbből tartalmi invariánst készítünk, ami már kupac struktúrájú. Elv: cserékkel lesüllyesztjük az elemet a nagyobb gyerek irányába, ha kisebb a nagyobbik gyereknél. A süllyesztés eljuthat ahhoz a csúcshoz, amelynek nincs jobb gyereke.
|
||||
\item $(n-1)$-szer
|
||||
\begin{itemize}
|
||||
\item[a)] gyökérelem és az alsó szint jobb szélső (=utolsó) aktív elemének cseréje, és a csere után lekerült elem inaktívvá tétele
|
||||
\item[b)] a gyökérbe került elem süllyesztése az aktív kupacon
|
||||
\end{itemize}
|
||||
\end{enumerate}
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.3\textwidth]{img/Kezdokupac.jpg}
|
||||
\includegraphics[width=0.3\textwidth]{img/Sully.jpg}
|
||||
\includegraphics[width=0.3\textwidth]{img/KupacRend.jpg}
|
||||
\caption{Kupacrendezés}
|
||||
\end{figure}
|
||||
|
||||
A kezdőkupac kialakításánál, és a ciklus közben a süllyesztés módja kicsit különbözik, hiszen az első esetben a változó elem süllyed le a teljes kupacon, a másodikban a gyökér süllyed az aktív kupacon. A képen látható algoritmus mindkét műveletet teljesíti.
|
||||
|
||||
\subsection{Gyorsrendezés}
|
||||
|
||||
Elve: véletlenül választunk egy elemet. A nála kisebb elemeket tőle balra, a nagyobbakat jobbra rakjuk, az elemet berakjuk a két rész közé. Rekurzív algoritmus.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.3\textwidth]{img/GyorsRend.jpg}
|
||||
\includegraphics[width=0.3\textwidth]{img/Helyrevisz.jpg}
|
||||
\caption{Gyorsrendezés}
|
||||
\end{figure}
|
||||
|
||||
\subsection{Összefésülő rendezés}
|
||||
|
||||
Alapja: 2 rendezett sorozat összefésülése. Ezt alkalmazhatjuk felülről lefelé (rekurzív) vagy alulról felfelé (iteratív), ez utóbbit szekvenciális fájloknál.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.3\textwidth]{img/OFRend.jpg}
|
||||
\caption{Összefésülő rendezés}
|
||||
\end{figure}
|
||||
|
||||
\section{A műveletigény alsó korlátja összehasonlító rendezésekre}
|
||||
|
||||
\subsection{Műveletigény}
|
||||
|
||||
Kijelöljük a domináns műveleteket, és az $n$ inputméret függvényében hányszor hajtódnak végre, ezt nézzük. Jelölés általánosan $T(n)$, de lehet konkrétan is, pl $Cs(n)$ [csere]. $mT(n)$ a minimális műveletigény, $MT(n)$ a maximális és $AT(n)$ az átlagos.
|
||||
\begin{itemize}
|
||||
\item[$\Theta$]: nagyságrendileg azonos, két konstans közé beszorítható
|
||||
\item[$\mathcal{O}$]: nagyságrendi felső becslés, $o$: nincs megengedve az egyenlőség
|
||||
\item[$\Omega$]: nagyságrendi alsó becslés, $\omega$: nincs megengedve az egyenlőség
|
||||
\end{itemize}
|
||||
|
||||
\subsection{Alsókorlát}
|
||||
|
||||
Például: $n$ elem maximumkiválasztása legalább $(n-1)$ összehasonlítást igényel. Bizonyítása: Ha ennél kevesebb összehasonlítás lenne, akkor legalább 1 elem kimaradt, és ezzel ellentmondásba kerülhetünk. \\
|
||||
\textit{Döntési fa}: Algoritmus $n$ méretű inputra. Kiegyenesednek a ciklusok véges hosszú lánccá, a végrehajtás nyoma egy fa struktúrát ad. Tökéletes fa: minden belső pontnak 2 gyereke van. Ennél az algoritmusnál nincs jobb, mert $2^{h(t)} \geq n!$, összehasonlító rendezés esetén, $n!$ input.
|
||||
|
||||
\subsection{Alsókorlát legrosszabb esetben}
|
||||
|
||||
Tétel: $MO_R(n) = \Omega(n\log{n})$ A legkedvezőtlenebb permutációra legalább $n\log{n}$ összehasonlítás. Bizonyítás: $\log_2{n!} \leq n\log_2{n} = \Omega(n\log{n})$, és $MO_R(n)=h(t) \geq \log_2{n!}$ (lemma miatt) $\Rightarrow$ $MO_R(n)=\Omega(n\log{n})$.
|
||||
|
||||
\subsection{Alsókorlát átlagos esetben}
|
||||
|
||||
Legyen minden input egyformán valószínű ($\frac{1}{n!}$). \\
|
||||
$AO_R(n) = \frac{1}{n!}\sum_{p \in Perm(n)}{O_R(p)}$, és könnyű belátni, hogy $\sum_{p}{O_R(p)} = lhsum(h(t_R(n)))$ [levél-magasság-összeg]. \\
|
||||
Lemma: Az $n!$ levelet tartalmazó tökéletes fák közül azokra a legkisebb az $lhsum(h(t_R(n)))$ érték, amelyek majdnem teljesek. \\
|
||||
Tétel: $AO_R(n) = \Omega(n\log{n})$.
|
||||
|
||||
\end{document}
|
After Width: | Height: | Size: 29 KiB |
After Width: | Height: | Size: 13 KiB |
After Width: | Height: | Size: 5.6 KiB |
After Width: | Height: | Size: 7.0 KiB |
After Width: | Height: | Size: 11 KiB |
After Width: | Height: | Size: 28 KiB |
After Width: | Height: | Size: 22 KiB |
After Width: | Height: | Size: 6.9 KiB |
After Width: | Height: | Size: 34 KiB |
After Width: | Height: | Size: 8.2 KiB |
@@ -0,0 +1,381 @@
|
||||
\documentclass[margin=0px]{article}
|
||||
|
||||
\usepackage{listings}
|
||||
\usepackage[utf8]{inputenc}
|
||||
\usepackage{graphicx}
|
||||
\usepackage{float}
|
||||
\usepackage[a4paper, margin=1in]{geometry}
|
||||
\usepackage{subcaption}
|
||||
\usepackage{amsthm}
|
||||
\usepackage{amssymb}
|
||||
\usepackage{amsmath}
|
||||
|
||||
\renewcommand{\figurename}{ábra}
|
||||
\newenvironment{tetel}[1]{\paragraph{#1 \\}}{}
|
||||
\newcommand{\R}{\mathbb{R}}
|
||||
|
||||
% A dokument itt kezdődik
|
||||
|
||||
\title{Záróvizsga tételsor \\ \large 14. Haladó algoritmusok}
|
||||
\date{}
|
||||
\author{Dobreff András}
|
||||
|
||||
\begin{document}
|
||||
\maketitle
|
||||
|
||||
\begin{tetel}{Haladó algoritmusok}
|
||||
Gráfalgoritmusok: gráfok ábrázolás, szélességi bejárás, minimális költségű utak keresése, minimális költségű feszítőfa keresése, mélységi bejárás, DAG topologikus rendezése. Adattömörítések (Huffman- és LZW-algoritmus). Mintaillesztés módszerei.
|
||||
\end{tetel}
|
||||
|
||||
\section{Gráfalgoritmusok}
|
||||
\subsection{Gráf ábrázolás}
|
||||
\begin{description}
|
||||
\item[Láncolt listás ábrázolás] \hfill \\
|
||||
A gráf csúcsait helyezzük el egy tömbben (vagy láncolt listában). Minden elemhez rendeljünk hozzá egy láncolt listát, melyben az adott csúcs szomszédjait (az esetleges élsúlyokkal) soroljuk fel.
|
||||
\item[Mátrixos ábrázolás] \hfill \\
|
||||
Legyen a csúcsok elemszáma $n$. Ekkor egy $A^{n\times n}$ mátrixban jelöljük, hogy mely csúcsok vannak összekötve. Ekkor mind a sorokban, mind az oszlopokban a csúcsok szerepelnek, és az $a_{ij}$ cellában a $i$ csúcsból $j$ csúcsba vezető él súlya szerepel, ha nincs él a két csúcs között, akkor $-\infty$ (súlyozatlan esetben $1$ és $0$)
|
||||
|
||||
Amennyiben a gráf irányítatlan nyilván $a_{ij} = a_{ji}$
|
||||
\end{description}
|
||||
\subsection{Szélességi bejárás}
|
||||
$G$ gráf (irányított/irányítatlan) $s$ startcsúcsából a távolság sorrendjében érjük el a csúcsokat. A legrövidebb utak feszítőfáját adja meg, így csak a távolság számít, a súly nem.
|
||||
|
||||
A nyilvántartott csúcsokat egy sor adatszerkezetben tároljuk, az aktuális csúcs gyerekeit a sor-ba tesszük. A következő csúcs pedig a sor legelső eleme lesz.
|
||||
|
||||
A csúcsok távolságát egy $d$, szüleiket egy $\pi$ tömbbe írjuk, és $\infty$ illetve $0$ értékekkel inicializáljuk.
|
||||
|
||||
Az algoritmus:
|
||||
\begin{enumerate}
|
||||
\item Az $s$ startcsúcsot betesszük a sorba
|
||||
\item A következő lépéseket addig ismételjük, míg a sor üres nem lesz
|
||||
\item Kivesszük a sor legelső ($u$) elemét
|
||||
\item Azokat a gyerekcsúcsokat, melyeknek a távolsága nem $\infty$ figyelmen kívül hagyjuk (ezeken már jártunk)
|
||||
\item A többi gyerekre ($v$): beállítjuk a szülőjét ($\pi[v] = u$), és a távolságát ($d[v] = d[u]+1$). Majd berakjuk a sorba.
|
||||
\end{enumerate}
|
||||
\subsection{Minimális költségű utak keresése}
|
||||
\begin{description}
|
||||
\item[Dijkstra algoritmus] \hfill \\
|
||||
Egy $G$ irányított, pozitív élsúlyokkal rendelkező gráfban keres $s$ startcsúcsból minimális költségű utakat minden csúcshoz.
|
||||
|
||||
Az algoritmus a szélességi bejárás módosított változata. Mivel itt egy hosszabb útnak lehet kisebb a költsége, mint egy rövidebbnek, egy már megtalált csúcsot nem szabad figyelmen kívül hagyni. Ezért minden csúcs rendelkezik három állapottal (nem elért, elért, kész). A $d$ és $\pi$ tömböket a szélességi bejáráshoz hasonlóan kezeljük.
|
||||
|
||||
A még nem kész csúcsokat egy prioritásos sorba helyezzük, vagy minden esetben minimumkeresést alkalmazunk.
|
||||
|
||||
Az algoritmus:
|
||||
\begin{enumerate}
|
||||
\item Az $s$ startcsúcs súlyát 0-ra állítjuk eltároljuk
|
||||
\item A következő lépéseket addig ismételjük, míg a konténerünk üres nem lesz
|
||||
\item Kivesszük a sor legjobb ($u$) elemét, és "kész"-re állítjuk
|
||||
\item Ha egy gyerekcsúcs ($v$) nem kész, és a jelenleg hozzávezető út súlya kisebb, mint az eddigi, akkor: a szülőjét $u$-ra állítjuk ($\pi[v] = u$), és a súlyát frissítjük ($d[v] = d[u]+d(u,v)$).
|
||||
\item A többi csúcsot kihagyjuk.
|
||||
\end{enumerate}
|
||||
|
||||
\item[Bellman-Ford algoritmus] \hfill \\
|
||||
Egy $G$ élsúlyozott (akár negatív) irányított gráf $s$ startcsúcsából keres minden élhez minimális költségű utakat, illetve felismeri, ha negatív költségű kör van a gráfban. A $d$ és $\pi$ tömböket az előzőekhez hasonlóan kezeljük.
|
||||
|
||||
Az algoritmus:
|
||||
\begin{enumerate}
|
||||
\item A startcsúcs súlyát állítsuk be 0-ra.
|
||||
\item $n-1$ iterációban menjünk végig az összes csúcson, és minden csúcsot ($u$) vessünk össze minden csúccsal ($v$). Ha olcsóbb utat találtunk akkor $v$-be felülírjuk a súlyát ($d[v] = d[u]+d(u,v)$), és a szülőjét ($\pi[v] = u$).
|
||||
\item Ha az $n$-edik iterációban is történt módosítás, negatív kör van a gráfban
|
||||
\end{enumerate}
|
||||
\end{description}
|
||||
\subsection{Minimális költség feszítőfa keresése}
|
||||
A Prim algoritmus egy irányítatlan élsúlyozott (akár negatív) gráf $s$ startcsúcsából keres minimális költségű feszítőfát. A $d$ és $\pi$ tömböket az előzőekhez hasonlóan kezeljük. Az algoritmus egy prioritásos sorba helyezi a csúcsokat.
|
||||
|
||||
Az algoritmus:
|
||||
\begin{enumerate}
|
||||
\item A startcsúcs súlyát állítsuk be 0-ra.
|
||||
\item A csúcsokat behelyezzük a prioritásos sorba.
|
||||
\item A következő lépéseket addig végezzük, míg a prioritásos sor ki nem ürül.
|
||||
\item Kiveszünk egy csúcsot ($u$) a sorból.
|
||||
\item Minden gyerekére ($v$), amely még a sorban és a nyilvántartott $v$-be vezető él súlya nagyobb, mint a most megtalált: A $v$ szülőjét $u$-ra változtatjuk, a nyilvántartott súlyt felülírjuk $d[v] = d(u,v)$. Majd felülírjuk a $v$ állapotát a prioritásos sorban.
|
||||
\item Azokkal a gyerekekkel, melyek nincsenek a sorban, vagy a súlyukon nem tudunk javítani, nem változtatunk.
|
||||
\end{enumerate}
|
||||
\subsection{Mélységi bejárás}
|
||||
$G$ irányított (nem feltétlenül összefüggő) gráf mélységi bejárásával egy mélységi fát (erdőt) kapunk. Az algoritmus a következő:
|
||||
\begin{itemize}
|
||||
\item Az élsúlyok nem játszanak szerepet
|
||||
\item Nincs startcsúcs, a gráf minden csúcsára elindítjuk az algoritmust. (Természetesen ekkor, ha már olyan csúcsot választunk, amin már voltunk, az algoritmus nem indul el.)
|
||||
\item A csúcsokat mohón választjuk, azaz minden csúcs gyerekei közül az elsőt választva haladunk előre, amíg csak lehet. (Olyan csúcsot találunk, amelynek nincs gyereke, vagy minden gyerekén jártunk már.)
|
||||
\item Ha már nem lehet előre haladni visszalépünk.
|
||||
\item Minden csúcshoz hozzárendelünk két értéket. Az egyik a mélységi sorszám, mely azt jelöli, hogy hanyadiknak értük el. A másik a befejezési szám, mely azt jelzi, hogy hanyadiknak léptünk vissza belőle.
|
||||
\end{itemize}
|
||||
A gráf éleit a mélységi bejárás közben osztályozhatjuk. (Inicializáláskor minden értéket 0-ra állítottunk)
|
||||
\begin{itemize}
|
||||
\item Faél: A következő csúcs mélységi száma 0
|
||||
\item Visszaél: A következő csúcs mélységi száma nagyobb, mint 0, és befejezési száma 0 (Tehát az aktuális út egy előző csúcsára kanyarodunk vissza)
|
||||
\item Keresztél: A következő csúcs mélységi száma nagyobb, mint 0, és befejezési száma is nagyobb, mint 0, továbbá az aktuális csúcs mélységi száma nagyobb, mint a következő csúcs mélységi száma. (Ekkor egy az aktuális csúcsot megelőző csúcsból induló, már megtalált útba mutató éllel van dolgunk)
|
||||
\item Előreél: A következő csúcs mélységi száma nagyobb, mint 0, és befejezési száma is nagyobb, mint 0, továbbá az aktuális csúcs mélységi száma kisebb, mint a következő csúcs mélységi száma. (Ekkor egy az aktuális csúcsból induló, már megtalált útba mutató éllel van dolgunk)
|
||||
\end{itemize}
|
||||
\subsection{DAG Topologikus rendezése}
|
||||
\begin{description}
|
||||
\item[Alapfogalmak] \hfill
|
||||
\begin{itemize}
|
||||
\item Topologikus rendezés: \\
|
||||
Egy $G(V,E)$ gráf topologikus rendezése a csúcsok olyan sorrendje, melyben $\forall (u\rightarrow v) \in E$ élre $u$ előbb van a sorrendben , mint $v$
|
||||
\item DAG - Directed Acyclic Graph: \\
|
||||
Irányított körmentes gráf. \\
|
||||
Legtöbbször munkafolyamatok irányítására illetve függőségek analizálására használják.
|
||||
|
||||
Tulajdonságok:
|
||||
\begin{itemize}
|
||||
\item Ha $G$ gráfra a mélységi bejárás visszaélt talál (Azaz kört talált) $\Longrightarrow$ $G$ nem DAG
|
||||
\item Ha $G$ nem DAG (van benne kör) $\Longrightarrow$ Bármely mélységi bejárás talál visszaélt
|
||||
\item Ha $G$-nek van topologikus rendezések $\Longrightarrow$ $G$ DAG
|
||||
\item Minden DAG topologikusan rendezhető.
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
\item[DAG topologikus rendezése] \hfill \\
|
||||
Egy $G$ gráf mélységi bejárása során tegyük verembe azokat a csúcsokat, melyekből visszaléptünk. Az algoritmus után a verem tartalmát kiírva megkapjuk a gráf egy topologikus rendezését.
|
||||
\end{description}
|
||||
\section{Adattömörítések}
|
||||
\subsection{Huffman-algoritmus}
|
||||
A Huffman-algoritmussal való tömörítés lényege, hogy a gyakrabban előforduló elemeket (karaktereket) rövidebb, míg a ritkábban előfordulókar hosszabb kódszavakkal kódoljuk.
|
||||
|
||||
Ehhez tisztában kell lennünk az egyes karakterek gyakoriságával (vagy relatív gyakoriságával). Ezek alapján egy ún. Huffman-fát építünk, melyben az éleket a kód betűivel címkézzük, a fa levelein a kódolandó betűk helyezkednek el, a gyökérből a levelekig vezető út címkéi alapján rajuk össze a kódszavakat.\\
|
||||
|
||||
\noindent
|
||||
Az algoritmus (spec. bináris Huffman fára):
|
||||
\begin{enumerate}
|
||||
\item A kódolandó szimbólumokat gyakoriságaik alapján sorba rendezzük.
|
||||
\item A következő redukciós lépéseket addig hajtjuk végre, míg egy csoportunk marad.
|
||||
\item Kiválasztjuk az utolsó két elemet (legritkább), összevonjuk őket egy új csoportba, és ennek a csoportnak a gyakorisága a gyakoriságok összege lesz.
|
||||
\item A csoportot visszahelyezzük a rendezett sorba (gyakoriság alapján rendezve).
|
||||
\item A csoportból új csúcsot képezünk, mely csúcs az őt alkotó két elem szülője lesz.
|
||||
\end{enumerate}
|
||||
|
||||
\noindent
|
||||
Példa:\\
|
||||
Legyen a következő 5 betű, mely a megadott gyakorisággal fordul elő:\\
|
||||
|
||||
\begin{tabular}{|c|c|c|c|c|}
|
||||
\hline A & B & C & D & E \\
|
||||
\hline 5 & 4 & 3 & 2 & 1 \\
|
||||
\hline
|
||||
\end{tabular}\\
|
||||
|
||||
Ekkor a redukciós lépések a következők:
|
||||
|
||||
\begin{itemize}
|
||||
\item \begin{tabular}{|c|c|c|c|}
|
||||
\hline A & B & C & D, E \\
|
||||
\hline 5 & 4 & 3 & 3 \\
|
||||
\hline
|
||||
\end{tabular}
|
||||
|
||||
\item \begin{tabular}{|c|c|c|}
|
||||
\hline C, D, E & A & B \\
|
||||
\hline 6 & 5 & 4\\
|
||||
\hline
|
||||
\end{tabular}
|
||||
|
||||
\item \begin{tabular}{|c|c|}
|
||||
\hline A , B & C, D, E\\
|
||||
\hline 9 & 6\\
|
||||
\hline
|
||||
\end{tabular}
|
||||
|
||||
\item \begin{tabular}{|c|}
|
||||
\hline A , B , C, D, E\\
|
||||
\hline 15\\
|
||||
\hline
|
||||
\end{tabular}
|
||||
\end{itemize}
|
||||
|
||||
A huffman-fa a XY. ábrán látható.
|
||||
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.3\textwidth]{img/Huffman_fa.png}
|
||||
\caption{Huffman-fa példa}
|
||||
\label{fig:Huffman_fa}
|
||||
\end{figure}
|
||||
|
||||
Tehát a kódszavak:
|
||||
|
||||
\begin{tabular}{|c|c|c|c|c|}
|
||||
\hline A & B & C & D & E \\
|
||||
\hline 00 & 01 & 10 & 110 & 111 \\
|
||||
\hline
|
||||
\end{tabular}
|
||||
\subsection{LZW-algoritmus}
|
||||
Az LZW (Lempel-Ziv-Welch) tömörítésnek a lényege, hogy egy szótárat bővítünk folyamatosan, és az egyes kódolandó szavakhoz szótárindexeket rendelünk.
|
||||
\begin{description}
|
||||
\item[Kódolás] \hfill \\
|
||||
A kódolás algoritmusa a következő lépésekből áll:
|
||||
\begin{enumerate}
|
||||
\item A szótárt inicializáljuk az összes 1 hosszú szóval
|
||||
\item \label{itm:szotar} Kikeressük a szótárból a leghosszabb, jelenlegi inputtal összeillő $W$ sztringet
|
||||
\item $W$ szótárindexét kiadjuk, és $W$-t eltávolítjuk az inputról
|
||||
\item A $W$ szó és az input következő szimbólumának konkatenációját felvesszük a szótárba
|
||||
\item A \ref{itm:szotar}. lépéstől ismételjük
|
||||
\end{enumerate}
|
||||
\item[Dekódolás] \hfill \\
|
||||
A dekódolás során is építenünk kell a szótárat. Ezt már azonban csak a dekódolt szöveg(rész) segítségével tudjuk megtenni, mivel egy megkapott kód dekódolt szava és az utána lévő szó első karakteréből áll össze a szótár következő eleme.
|
||||
|
||||
Tehát a dekódolás lépései:
|
||||
\begin{enumerate}
|
||||
\item Kikeressük a kapott kódhoz tartozó szót a szótárból ($u$), az output-ra rakjuk
|
||||
\item Kikeressük a következő szót ($v$) a szótárból, az első szimbólumát $u$-hoz konkatenálva a szótárba rakjuk a következő indexszel.
|
||||
\item Amennyiben már nincs következő szó, dekódolunk, de nem írunk a szótárba.
|
||||
\end{enumerate}
|
||||
|
||||
Megtörténhet az az eset, hogy mégis kapunk olyan kódszót, mely még nincs benne a szótárban. Ez akkor fordulhat elő, ha a kódolásnál az aktuálisan szótárba írt szó következik.\\
|
||||
|
||||
Példa:
|
||||
|
||||
Szöveg: AAA\\
|
||||
Szótár: A - 1
|
||||
|
||||
Ekkor a kódolásnál vesszük az első karaktert, a szótárbeli indexe 1, ezt kiküldjük az outputra. A következő karakter A, így AA-t beírjuk a szótárba 2-es indexszel. Az első karaktert töröljük az inputról. Addig olvasunk, míg szótárbeli egyezést találunk, így AA-t olvassuk (amit pont az előbb raktunk be), ennek indexe 2, tehát ezt küldjük az outputra. AA-t töröljük az inputról, és ezzel végeztünk is. Az output: 1,2
|
||||
|
||||
Dekódoljuk az 1,2 inputot! Jelenleg a szótárban csak A van 1-es indexszel. Vegyük az input első karakterét, az 1-et, ennek szótárbeli megfelelője A. Ezt tegyük az outputra. A következő index a 2, de ilyen bejegyzés még nem szerepel a szótárban. \\
|
||||
|
||||
Ebben az esetben a dekódolásnál, egy trükköt vetünk be. A szótárba írás pillanatában még nem ismert a beírandó szó utolsó karaktere (A példában A-t találtuk, de nem volt 2-es bejegyzés). Ekkor ?-et írunk a szótárba írandó szó utolsó karakterének helyére. (Tehát A? - 2 kerül a szótárba). De mostmár tudni lehet az új bejegyzés első betűjét ( A? - 2 az új bejegyzés, ennek első betűje A). Cseréljük le a ?-et erre a betűre. (Tehát AA - 2 lesz a szótárban).
|
||||
\end{description}
|
||||
\section{Mintaillesztés}
|
||||
\subsection{Knuth-Morris-Pratt algoritmus}
|
||||
A Knuth-Morris-Pratt eljárásnak a Brute-Force (hasonlítsuk össze, toljunk egyet, stb..) módszerrel szemben az az előnye, hogy egyes esetekben, ha a mintában vannak ismétlődő elemek, akkor egy tolásnál akár több karakternyit is ugorhatunk.
|
||||
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.4\textwidth]{img/KMP_sample.png}
|
||||
\caption{KMP algoritmus több karakter tolás estén}
|
||||
\label{fig:KMP_sample}
|
||||
\end{figure}
|
||||
|
||||
Az ugrás megállapítását a következőképp tesszük: Az eddig megvizsgált egyező mintarész elején (prefix) és végén (suffix) olyan kartersorozatot keresünk, melyek megegyeznek. Ha találunk ilyet, akkor a mintát annyival tolhatjuk, hogy az elején lévő része ráilleszkedjen a végén levőre.
|
||||
|
||||
Azt, hogy ez egyes esetekben mekkorát tolhatunk nem kell minden elromlás alkalmával vizsgálni. Ha a mintára önmagával lefuttatjuk az algoritmus egy módosított változatát (\ref{fig:KMP_initnext}. ábra), kitölthetünk egy tömböt, mely alapján a tolásokat végezni fogjuk.
|
||||
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.3\textwidth]{img/KMP_initnext.jpg}
|
||||
\caption{KMP tolásokat szabályzó tömb kitöltése}
|
||||
\label{fig:KMP_initnext}
|
||||
\end{figure}
|
||||
|
||||
Az algoritmus (ld \ref{fig:KMP}. ábra):
|
||||
\begin{itemize}
|
||||
\item Két indexet $i$ és $j$ futtatunk a szövegen illetve a mintán.
|
||||
\item Ha az $i+1$-edik és $j+1$-edik karakterek megegyeznek, akkor léptetjük mind a kettőt.
|
||||
\item Ha nem egyeznek meg, akkor:
|
||||
\begin{itemize}
|
||||
\item Ha a minta első elemét vizsgáltuk, akkor egyet tolunk a mintán, magyarul a minta indexe marad az első betűn, és a szövegben lévő indexet növeljük eggyel ($i=i+1$)
|
||||
\item Ha nem a minta első elemét vizsgáltuk, akkor annyit tolunk, amennyit szabad. Ez azt jelenti, hogy csak a mintán lévő indexet helyezzük egy kisebb helyre ($j = next[j]$)
|
||||
\end{itemize}
|
||||
\item Addig megyünk, míg vagy a minta, vagy a szöveg végére nem érünk. Ha a minta végére értünk, akkor megtaláltuk a mintát a szövegben, ha a szöveg végére értünk, akkor pedig nem.
|
||||
\end{itemize}
|
||||
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.3\textwidth]{img/KMP.jpg}
|
||||
\caption{KMP algoritmus}
|
||||
\label{fig:KMP}
|
||||
\end{figure}
|
||||
\subsection{Boyer-Moore | Quick search algoritmus}
|
||||
Míg a KMP algoritmus az elromlás helye előtti rész alapján döntött a tolásról, addig a QS a minta utáni karakter alapján. Tehát elromlás esetén:
|
||||
\begin{itemize}
|
||||
\item Ha a minta utáni karakter benne van a mintában, akkor jobbról az első előfordulására illesztjük. (\ref{fig:BoyerMoore_shift1}. ábra)
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.4\textwidth]{img/BoyerMoore_shift1.png}
|
||||
\caption{QS - eltolás ha a minta utáni karakter benne van a mintában}
|
||||
\label{fig:BoyerMoore_shift1}
|
||||
\end{figure}
|
||||
\item Ha a minta utáni karakter nincs benne a mintában, akkor a mintát ezen karakter után illesztjük. (\ref{fig:BoyerMoore_shift2}. ábra)
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.6\textwidth]{img/BoyerMoore_shift2.png}
|
||||
\caption{QS - eltolás ha a minta utáni karakter nincs benne a mintában}
|
||||
\label{fig:BoyerMoore_shift2}
|
||||
\end{figure}
|
||||
\end{itemize}
|
||||
|
||||
Az eltolás kiszámítását megint elő lehet segíteni egy tömbbel, most azonban, mivel nem a minta az érdekes, és nem tudjuk pontosan mely karakterek szerepelnek a szövegben, így a tömbbe az egész abc-t fel kell vennünk (\ref{fig:BoyerMoore_initshift}. ábra)
|
||||
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.3\textwidth]{img/BoyerMoore_initshift.jpg}
|
||||
\caption{QS - Az eltolást elősegítő tömb ($Shift['a'...'z']$) konstruálása}
|
||||
\label{fig:BoyerMoore_initshift}
|
||||
\end{figure}
|
||||
|
||||
Az algoritmus (ld. \ref{fig:BoyerMoore}. ábra):
|
||||
\begin{itemize}
|
||||
\item Két indexet $k$ és $j$ futtatunk a szövegen illetve a mintán.
|
||||
\item Ha a szöveg $k+j$-edik eleme megegyezik a minta $j$-edik karakterével, akkor léptetjük $j$-t (mivel a szövegben $k+j$-edik elemet nézzük, így elég $j$-t növelni).
|
||||
\item Ha nem egyeznek meg, akkor:
|
||||
\begin{itemize}
|
||||
\item Ha a minta már a szöveg végén van ($k=n-m$), akkor csak növeljük $k$-t eggyel, ami hamissá teszi a ciklus feltételt.
|
||||
\item Ha még nem vagyunk a szöveg végén $k$-t toljuk annyival, amennyivel lehet (ezt az előre beállított $Shift$ tömb határozza meg). És a $j$-t visszaállítjuk 1-re.
|
||||
\end{itemize}
|
||||
\item Addig megyünk, míg vagy a minta végére érünk $j$-vel, vagy a mintát továbbtoltuk a szöveg végénél. Előbbi esetben egyezést találtunk, míg az utóbbiban nem.
|
||||
\end{itemize}
|
||||
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.4\textwidth]{img/BoyerMoore.jpg}
|
||||
\caption{QS}
|
||||
\label{fig:BoyerMoore}
|
||||
\end{figure}
|
||||
\subsection{Rabin-Karp algoritmus}
|
||||
A Rabin-Karp algoritmus lényege, hogy minden betűhöz az ábécéből egy számjegyet rendelünk, és a keresést számok összehasonlításával végezzük. Világos, hogy ehhez egy ábécé méretnek megfelelő számrendszerre lesz szükségünk. A szövegből mindig a minta hosszával egyező részeket szelünk ki, és ezeket hasonlítjuk össze.\\
|
||||
|
||||
\noindent
|
||||
Példa:\\
|
||||
Minta: BBAC $\rightarrow$ 1102 \\
|
||||
Szöveg: DACABBAC $\rightarrow$ 30201102, amiből a következő számokat állítjuk elő: 3020, 0201, 2011, 0110, 1102\\
|
||||
|
||||
\noindent
|
||||
A fent látható szeletek lesznek az $s_i$-k.\\
|
||||
|
||||
\noindent
|
||||
Az algoritmus működéséhez azonban számos apró ötletet alkalmazunk:
|
||||
\begin{enumerate}
|
||||
\item A minta számokká alakítását Horner-módszer segítségével végezzük.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.3\textwidth]{img/RK_Horner.jpg}
|
||||
\caption{RK - Horner-módszer}
|
||||
\label{fig:RK_Horner}
|
||||
\end{figure}
|
||||
Az $ord()$ függvény az egyes betűknek megfelelő számot adja vissza. A $d$ a számrendszer alapszáma.
|
||||
\item A szöveg mintával megegyező hosszú szeleteinek ($s_i$) előállítása: \\
|
||||
$s_0$-t a Horner-módszerrel ki tudjuk számolni. Ezek után $s_{i+1}$ a következőképp számolandó:
|
||||
\[s_{i+1} = (s_i - ord(S[i])\cdot d^{m-1})\cdot d + ord(S[i+1])\]
|
||||
\textit{Magyarázat: $s_i$ elejéről levágjuk az első számjegyet ($s_i - ord(S[i])\cdot d^{m-1}$), majd a maradékot eltoljuk egy helyiértékkel (szorzás $d$-vel), végül az utolsó helyiértékre beírjuk a következő betűnek megfelelő számjegyet ($+ord(S[i+1])$)}
|
||||
|
||||
Példa:
|
||||
|
||||
Az előző példa szövegével és mintájával ($d=10$ elemű ábécé és $m=4$ hosszú minta): \\
|
||||
$s_0 = 3020$, ekkor: $s_{0+1} = s_1 = (3020 - ord(D) \cdot 10^3)\cdot 10 + ord(B) = (3020-3000)\cdot 10 +1 = 0201$
|
||||
\item Felmerülhet a kérdés, hogy az ilyen magas alapszámú számrendszerek nem okoznak-e gondot az ábrázolásnál? A kérdés jogos. Vegyük a következő életszerű példát:
|
||||
|
||||
4 bájton ábrázoljuk a számainkat ($2^{32}$). Az abc legyen 32 elemű ($d=32$), a minta 8 hosszú ($m=8$). Ekkor a $d^{m-1}$ kiszámítása: $32^7 = (2^5)^7 = 2^{35}$ , ami már nem ábrázolható 4 bájton.
|
||||
|
||||
Ennek kiküszöbölésére vezessünk be egy nagy $p$ prímet, melyre $d\cdot p$ még ábrázolható. És a műveleteket számoljuk $\mod{p}$. Ekkor természetesen a kongruencia miatt lesz olyan eset, amikor az algoritmus egyezést mutat, mikor valójában nincs. Ez nem okoz gondot, mivel ilyen esetben karakterenkénti egyezést vizsgálva ezt a problémát kezelni tudjuk. (Fordított eset nem fordul elő tehát nem lesz olyan eset, mikor karakterenkénti egyezés van, de numerikus nincs). [Ha $p$ kellően nagy, a jelenség nagyon ritkán fordul elő.]
|
||||
|
||||
\item A $\mod{p}$ számítás egy másik problémát is felvet. Ugyanis a kivonás alkalmával negatív számokat is kaphatunk.
|
||||
|
||||
Például: Legyen $p=7$, ekkor, ha $ord(S[i]) = 9$, akkor előző számítás után $s_i = 2...$, de ebből $ord(S[i])\cdot d^{m-1} = 9\cdot 10^3 = 9000$-et vonunk ki negatív számot kapunk.
|
||||
|
||||
Megoldásként $s_{i+1}$-et két lépésben számoljuk:
|
||||
\[s := (s_i+d\cdot p - ord(S[i])\cdot d^{m-1}) \mod{p} \]
|
||||
\[s_{i+1} := (s\cdot d + ord(S[i+1])) \mod{p} \]
|
||||
\end{enumerate}
|
||||
A fentiek alapján az algoritmus a következő (ld. \ref{fig:RK}. ábra)
|
||||
\begin{enumerate}
|
||||
\item Kiszámoljuk $d^{m-1}$-et ($dm1$)
|
||||
\item Egy iterációban meghatározzuk Horner-módszerrel a minta számait ($x$) és $s_0$-t
|
||||
\item Ellenőrizzük, hogy egyeznek-e
|
||||
\item Addig számolgatjuk $s_i$ értékét míg a minta nem egyezik $s_i$-vel, vagy a minta a szöveg végére nem ért.
|
||||
\end{enumerate}
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.3\textwidth]{img/RK.jpg}
|
||||
\caption{RK}
|
||||
\label{fig:RK}
|
||||
\end{figure}
|
||||
\end{document}
|
After Width: | Height: | Size: 20 KiB |
After Width: | Height: | Size: 21 KiB |
After Width: | Height: | Size: 51 KiB |
After Width: | Height: | Size: 56 KiB |
After Width: | Height: | Size: 13 KiB |
After Width: | Height: | Size: 82 KiB |
After Width: | Height: | Size: 7.8 KiB |
After Width: | Height: | Size: 50 KiB |
After Width: | Height: | Size: 15 KiB |
After Width: | Height: | Size: 53 KiB |
After Width: | Height: | Size: 70 KiB |
After Width: | Height: | Size: 19 KiB |
After Width: | Height: | Size: 40 KiB |
@@ -0,0 +1,662 @@
|
||||
\documentclass[margin=0px]{article}
|
||||
|
||||
\usepackage{listings}
|
||||
\usepackage[utf8]{inputenc}
|
||||
\usepackage{graphicx}
|
||||
\usepackage{float}
|
||||
\usepackage[a4paper, margin=1in]{geometry}
|
||||
\usepackage{amsthm}
|
||||
\usepackage{amssymb}
|
||||
\usepackage{t1enc}
|
||||
|
||||
\newenvironment{tetel}[1]{\paragraph{#1 \\}}{}
|
||||
% A dokument itt kezdődik
|
||||
|
||||
\title{Záróvizsga tételsor \\ \large 15. Operációs rendszerek}
|
||||
\date{}
|
||||
\author{Fekete Dóra}
|
||||
|
||||
\begin{document}
|
||||
|
||||
\maketitle
|
||||
|
||||
\begin{tetel}{Operációs rendszerek}
|
||||
Folyamatok megvalósítása, ütemező algoritmusaik. Párhuzamosság, kritikus szekciók, kölcsönös kizárás megvalósítása. Szemaforok, osztott memória, üzenetküldés. Be- és kimeneti eszközök ütemezési lehetőségei, holtpontok. Memóriakezelés, virtuális memória fogalma. Lapozás és szegmentálás. Lapcserélési algoritmusok. Lemezterület-szervezés, redundáns tömbök, fájlrendszerek szolgáltatásai és jellemző megvalósításaik.
|
||||
\end{tetel}
|
||||
\\
|
||||
\\
|
||||
\textit{Operációs rendszer}: olyan programrendszer, amely a számítógépes rendszerben a programok végrehajtását vezérli: így például ütemezi a programok végrehajtását, elosztja az erőforrásokat, biztosítja a felhasználó és a számítógépes rendszer közötti kommunikációt. Olyan program, ami egyszerű felhasználói felületet nyújt, eltakarva a számítógép(rendszer) eszközeit. \\
|
||||
|
||||
\section{Folyamatok megvalósítása, ütemező algoritmusaik}
|
||||
|
||||
\subsection{Folyamatok megvalósítása}
|
||||
|
||||
\textit{Program}: fájlrendszerben egy bájthalmaz. \\
|
||||
\textit{Folyamat}(processz): futó program a memóriában (kód + I/O adatok + állapot). \\
|
||||
Egyszerre hány folyamat működik? \\
|
||||
Valódi multitask esetén egymástól teljesen függetlenül mennek a folyamatok. Operációs rendszerek egy szekvenciális modellt követnek, ami álmultitasking. Itt egyidejűleg a memóriához csak egy folyamat fér hozzá, gyorsan váltogat a dolgok között (multiprogramozás). \\
|
||||
Az operációs rendszernek ahhoz, hogy ezeket a folyamatokat helyesen tudja kezelni, felügyelnie kell a folyamatokat. Az operációs rendszerünk így minden egyes folyamatot nyilvántart, és az operációs rendszer lelkének is nevezett ütemező (scheduler) segítségével szépen sorban minden egyes folyamatnak ad egy kis processzor- (CPU) időszeletet, amíg az adott folyamat dolgozik, azaz a processzorra kerülhet.
|
||||
\textit{Rendszer modell}: 1 processzor + 1 rendszer memória + 1 I/O eszköz = 1 feladat-végrehajtás \\
|
||||
Interaktív (ablakos) rendszerekben több program, processz fut.
|
||||
\begin{itemize}
|
||||
\item Környezetváltásos rendszer: csak az előtérben lévő alkalmazás fut
|
||||
\item Kooperatív rendszer: az aktuális processz bizonyos időközönként, vagy időkritikus műveletnél önként lemond a CPU-ról (Win 3.1)
|
||||
\item Preemptív rendszer: az aktuális processztől a kernel bizonyos idő után elveszi a vezérlést, és a következő várakozó folyamatnak adja.
|
||||
\item Real time rendszer: egy operációs rendszer nyújtson lehetőséget az időfaktor figyelembe vételéhez. A mai OR-ek kezdenek ilyen tulajdonságokkal is kiegészülni.
|
||||
\end{itemize}
|
||||
|
||||
\textit{Folyamatok létrehozása}: ma tipikusan preemptív rendszereket használunk. Létrehozás oka lehet: rendszer inicializálás, folyamatot eredményező rendszerhívás (másolat az eredetiről [fork], az eredeti cseréje [execve]), felhasználói kérés (parancs\&), nagy rendszerek kötegelt feladatai. \\
|
||||
A folyamatok futhatnak az előtérben, illetve a háttérben. Ez utóbbiakat hívjuk démonoknak.\\
|
||||
\textit{Folyamatok kapcsolata}: Szülő-gyermek kapcsolat, folyamatfa: egy folyamatnak egy szülője van, egy folyamatnak viszont lehet több gyereke is, vannak összetartozó folyamatcsoportok. \\ Reinkarnációs szerver: meghajtó programok, kiszolgálók elindítója, ha elhal az egyik, akkor azt újraszüli, reinkarnálja. \\
|
||||
\textit{Folyamatok befejezése}: Egy folyamat az elindulása után a megadott időkeretben (el)végzi a feladatát. A befejezés lehet önkéntes vagy önkéntelen.
|
||||
\begin{itemize}
|
||||
\item Önkéntes befejezések: Szabályos kilépés (exit, return stb.), Kilépés valamilyen hiba miatt, amit a program felfedez (szintén pl. return utasítással).
|
||||
\item Önkéntelen befejezések: Illegális utasítás, végzetes hiba (0-val osztás, nem létező memória használat, stb), Külső segítséggel: Másik processz, netán mi ,,lőjük” ki az adott folyamatot.
|
||||
\end{itemize}
|
||||
\textit{Folyamatok állapota}: A folyamat önálló programegység, saját utasításszámlálóval, veremmel stb. Általában nem függetlenek a folyamatok, egyik-másik eredményétől függ a tevékenység. Egy folyamat három állapotban lehet:
|
||||
\begin{itemize}
|
||||
\item Futó
|
||||
\item Futásra kész, ideiglenesen leállították, arra vár, hogy az ütemező CPU időt adjon a folyamatnak
|
||||
\item Blokkolt, ha logikailag nem lehet folytatni a tevékenységet, mert pl. egy másik eredményére vár. (catFradi.txt|grepFradi|sort, grep és sort blokkolt az elején)
|
||||
\end{itemize}
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.6\textwidth]{img/allapot.png}
|
||||
\caption{Állapotátmenetek}
|
||||
\end{figure}
|
||||
|
||||
\textit{További állapotok}: alvó, megállított, zombi (ha egy gyermek folyamat befejeződik, de szülője nem hív wait(\&st) hívást, akkor a gyermek bent marad a processztáblában, init folyamat törli ezeket). \\
|
||||
\textit{\textbf{Folyamatok megvalósítása}}: A processzor csak végrehajtja az aktuális utasításokat. Egyszerre egy folyamat aktív. Folyamatokról nem tud a processzor. Ha lecseréljük az aktív folyamatot a következőre, akkor mindent meg kell őrizni, hogy visszatérhessünk a folytatáshoz. A ,,minden": utasításszámláló, regiszterek, lefoglalt memória állapot, nyitott fájl infók, stb. Ezeket az adatokat az úgynevezett folyamatleíró táblában tároljuk (processz tábla, processz vezérlő blokk). Van egy I/O megszakításvektor is. \\
|
||||
A folyamatokat úgy is osztályozhatjuk, hogy számításigényes vagy input/output-igényes (avagy beviteli/kiviteli, röviden B/K vagy I/O) folyamatról van-e szó. Könnyen belátható, hogy a számításigényes folyamatoknak az a legjobb, ha az ütemező általában hosszú időperiódusra adja meg nekik a processzort, míg az input/output-igényes folyamatoknak a rövidebb periódusidő a megfelelőbb.
|
||||
|
||||
\subsection{Ütemező algoritmusok}
|
||||
|
||||
\textit{Folyamatok váltása}: Kezdeményezheti időzítő, megszakítás, esemény, rendszerhívás kezdeményezés. Az ütemező elmenti az aktuális folyamat jellemzőket a folyamatleíró táblába. Betölti a következő folyamat állapotát, a processzor folytatja a munkát. Nem lehet menteni a gyorsítótárakat. Gyakori váltás többleterőforrást igényel. A folyamatváltási idő „jó” megadása nem egyértelmű. \\
|
||||
\textit{Folyamatleíró táblázat}(Process Control Block - PCB): A rendszer inicializálásakor létrejön; 1 elem, rendszerindító már bent van, mikor a rendszer elindul. Tömbszerű szerkezet (PID alapon), de egy-egy elem egy összetett processzus adatokat tartalmazó struktúra. Egy folyamat fontosabb adatai: Azonosítója (ID), neve (programnév); Tulajdonos, csoport azonosító; Memória, regiszter adatok stb. \\
|
||||
\textit{Szálak}: Önállóan működő programegységek (thread), egy folyamaton belüli különálló utasítássor. Általában egy folyamat = egy utasítássorozat = egy szál. Néha szükséges lehet, hogy egy folyamaton belül ,,több utasítássorozat" legyen. Gyakran ,,lightweight process"-nek nevezik a több utasítássorozatos folyamatot. Egy folyamaton belül több egymástól ,,független" végrehajtási sor lehet. Lehet egy folyamaton belül egy szál vagy egy folyamaton belül több szál. Ez utóbbi esetben, ha egy szál blokkolódik, a folyamat is blokkolva lesz. Van külön száltáblázat. \\
|
||||
Folyamatnak önálló címtartománya van, globális változói, megnyitott fájlleírói, gyermekfolyamatai, szignálkezelői, ébresztői stb., szálnak ezek nincsenek; viszont mindkettőnek vannak utasításszámlálói, regiszterei, van verme. \\ \\
|
||||
|
||||
Egyszerre csak 1 folyamat tud futni. Az ütemező hozza meg a döntést. Ütemezési algoritmus alapján dönti el, hogy melyik fusson. \\
|
||||
Folyamatváltás biztosan van: ha befejeződik egy folyamat, vagy ha egy folyamat blokkolt állapotba kerül (I/O vagy szemafor miatt). Általában van váltás: ha új folyamat jön létre, I/O megszakítás bekövetkezés (I/O megszakítás után jellemzően egy blokkolt folyamat, ami erre várt, folytathatja futását), időzítő megszakítás (nem megszakítható ütemezés, megszakítható ütemezés). \\
|
||||
Ütemezések csoportosítása:
|
||||
\begin{itemize}
|
||||
\item Minden rendszerre jellemző a pártatlanság, hogy mindenki hozzáférhet a CPU-hoz, ugyanazok az elvek érvényesek mindenkire, és ,,azonos” terhelést kapnak.
|
||||
\item Kötegelt rendszerek: Áteresztőképesség, áthaladási idő, CPU kihasználtság
|
||||
\item Interaktív rendszerek: Válaszidő, megfelelés a felhasználói igényeknek
|
||||
\item Valós idejű rendszerek: Határidők betartása, adatvesztés, minőségromlás
|
||||
elkerülése
|
||||
\end{itemize}
|
||||
\textbf{Ütemezés kötegelt rendszerekben}:
|
||||
\begin{itemize}
|
||||
\item Sorrendi ütemezés, nem megszakítható
|
||||
\begin{itemize}
|
||||
\item First Come First Served - (FCFS)
|
||||
\item Egy folyamat addig fut, amíg nem végez, vagy nem blokkolódik.
|
||||
\item Ha blokkolódik, a sor végére kerül.
|
||||
\item Pártatlan, egyszerű, láncolt listában tartjuk a folyamatokat.
|
||||
\item Hátránya: I/O igényes folyamatok nagyon lassan végeznek.
|
||||
\end{itemize}
|
||||
\item Legrövidebb feladat először, nem megszakítható ez se (shortest job first -- SJB)
|
||||
\begin{itemize}
|
||||
\item Kell előre ismerni a futási időket
|
||||
\item Akkor optimális, ha kezdetben mindenki elérhető
|
||||
\end{itemize}
|
||||
\item Legrövidebb maradék futási idejű következzen
|
||||
\begin{itemize}
|
||||
\item Megszakítható, minden új belépéskor vizsgálat.
|
||||
\end{itemize}
|
||||
\item Háromszintű ütemezés
|
||||
\begin{itemize}
|
||||
\item Bebocsátó ütemező: A feladatokat válogatva engedi be a memóriába.
|
||||
\item Lemez ütemező: Ha a bebocsátó sok folyamatot enged be és elfogy a memória, akkor lemezre kell írni valamennyit, meg vissza. Ez ritkán fut.
|
||||
\item CPU ütemező: A korábban említett algoritmusok közül választhatunk.
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
\textbf{Ütemezés interaktív rendszerekben}:
|
||||
\begin{itemize}
|
||||
\item Körben járó ütemezés -- Round Robin
|
||||
\begin{itemize}
|
||||
\item Mindenkinek időszelet, aminek végén, vagy blokkolás esetén jön a következő folyamat
|
||||
\item Időszelet végén a körkörös listában következő lesz az aktuális folyamat
|
||||
\item Pártatlan, egyszerű
|
||||
\item Egy listában tárolhatjuk a folyamatokat (jellemzőit), és ezen megyünk körbe-körbe.
|
||||
\item Időszelet mérete lehet probléma, mert a processz átkapcsolás időigényes. Ha kicsi az idő, akkor sok CPU megy el a kapcsolgatásra, ha pedig túl nagy, akkor interaktív felhasználóknak lassúnak tűnhet pl a billentyűkezelés.
|
||||
\end{itemize}
|
||||
\item Prioritásos ütemezés
|
||||
\begin{itemize}
|
||||
\item Fontosság, prioritás bevezetése. Unix: 0-49 nem megszakítható (kernel) prioritás, 50-127 user prioritás
|
||||
\item Legmagasabb prioritású futhat. Dinamikus prioritás módosítás, különben éhenhalás
|
||||
\item Prioritási osztályok használata. Egy osztályon belül Round Robin. Ki kell igazítani a folyamatok prioritását, különben az alacsonyak nagyon ritkán jutnak CPU-hoz. Tipikusan minden 100 időszeletnél a prioritásokat újraértékeli és ilyenkor jellemzően a magas prioritások alacsonyabbra kerülnek, majd ezen a soron megy RR. A végén újra felállnak az eredeti osztályok.
|
||||
\end{itemize}
|
||||
\item Többszörös sorok
|
||||
\begin{itemize}
|
||||
\item Szintén prioritásos és RR
|
||||
\item Legmagasabb szinten minden folyamat 1 időszeletet kap
|
||||
\item Következő 2-t, majd 4-et, 8, 16,32,64-et.
|
||||
\item Ha elhasználta a legmagasabb szintű folyamat az idejét egy szinttel lejjebb kerül.
|
||||
\end{itemize}
|
||||
\item Legrövidebb folyamat előbb
|
||||
\begin{itemize}
|
||||
\item Bár nem tudjuk a hátralévő időt, de becsüljük meg az előzőekből.
|
||||
\item Öregedés, súlyozott átlag az időszeletre: T0, T0/2+T1/2, T0/4+T1/4+T2/2, T0/8+T1/8+T2/4+T3/2
|
||||
\end{itemize}
|
||||
\item Garantált ütemezés
|
||||
\begin{itemize}
|
||||
\item Minden aktív folyamat arányos CPU időt kap.
|
||||
\item Nyilván kell tartani, hogy egy folyamat már mennyi időt kapott, ha valaki arányosan kevesebb időt kapott, az kerül előbbre.
|
||||
\end{itemize}
|
||||
\item Sorsjáték ütemezés
|
||||
\begin{itemize}
|
||||
\item Mint az előző, csak a folyamatok között ,,sorsjegyeket" osztunk szét, az kapja a vezérlést, akinél a kihúzott jegy van
|
||||
\item Arányos CPU időt könnyű biztosítani, hasznos pl. video szervereknél
|
||||
\end{itemize}
|
||||
\item Arányos ütemezés
|
||||
\begin{itemize}
|
||||
\item Vegyük figyelembe a felhasználókat is. Olyan, mint a garantált, csak a felhasználókra vonatkoztatva.
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
\textbf{Ütemezés valós idejű rendszerekben} \\
|
||||
A valós idejű rendszerben az idő kulcsszereplő. Garantálni kell adott határidőre a tevékenység, válasz megadását.
|
||||
\begin{itemize}
|
||||
\item Hard Real Time (szigorú), abszolút, nem módosíthatóhatáridők.
|
||||
\item Soft Real Time (toleráns), léteznek a határidők, de ezek kis mértékű elmulasztása tolerálható.
|
||||
\end{itemize}
|
||||
A programokat több kisebb folyamatra bontják. Külső esemény észlelésekor, adott határidőre válasz
|
||||
kell. Ütemezhető: ha egységnyi időre eső n esemény CPU válaszidő összege <=1. \\
|
||||
Gyakori a gyermek folyamatok jelenléte a rendszerben. A szülőnek nem biztos, hogy minden
|
||||
gyermekével azonos prioritásra van szüksége. Tipikusan a kernel \textit{prioritásos ütemezést}
|
||||
használ (+RR):
|
||||
\begin{itemize}
|
||||
\item Biztosít egy rendszerhívást, amivel a szülő a gyermek prioritását adhatja meg
|
||||
\item Kernel ütemez -- felhasználói folyamat szabja meg az elvet, prioritást.
|
||||
\end{itemize}
|
||||
|
||||
\textbf{Szálütemezés}:
|
||||
\begin{itemize}
|
||||
\item Felhasználói szintű szálak
|
||||
\begin{itemize}
|
||||
\item Kernel nem tud róluk, a folyamat kap időszeletet, ezen belül a szálütemező dönt ki fusson
|
||||
\item Gyors váltás a szálak között
|
||||
\item Alkalmazásfüggő szálütemezés lehetséges
|
||||
\end{itemize}
|
||||
\item Kernel szintű szálak
|
||||
\begin{itemize}
|
||||
\item Kernel ismeri a szálakat, kernel dönt melyik folyamat melyik szála következzen
|
||||
\item Lassú váltás, két szál váltása között teljes környezetátkapcsolás kell
|
||||
\item Ezt figyelembe is veszik.
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
|
||||
\section{Párhuzamosság, kritikus szekciók, kölcsönös kizárás megvalósítása}
|
||||
|
||||
\subsection{Párhuzamosság és megvalósítása}
|
||||
|
||||
Ütemező a folyamatok gyors váltogatásával ,,teremt" párhuzamos végrehajtás érzetet. \\
|
||||
Többprocesszoros rendszerekben több processzor van egy gépben, nagyobb a teljesítmény, de a megbízhatóságot általában nem növeli. \\
|
||||
Klaszterek: megbízhatóság növelése elsősorban a cél.
|
||||
|
||||
\subsection{Kritikus szekciók}
|
||||
|
||||
Azokat az utasításokat, azt a programrészt, amelyben a programunk a közös adatokat használja, kritikus területnek, kritikus szekciónak vagy kritikus blokknak nevezzük. \\
|
||||
Kulcskérdés: a közös erőforrások használata, amikor két folyamat ugyanazt a memóriát használja. Kritikus programterület, szekció, az a rész, mikor a közös erőforrást (memóriát) használjuk. \\
|
||||
Versenyhelyzet: két vagy több folyamat közös memóriát ír vagy olvas, a végeredmény a futási időpillanattól függ. Nehezen felderíthető hibát okoz. \\
|
||||
Megoldás: Módszer, ami biztosítja, hogy a közös adatokat egyszerre csak egy folyamat tudja használni.
|
||||
|
||||
\subsection{Kölcsönös kizárás és megvalósítása}
|
||||
|
||||
Kölcsönös kizárásnak nevezzük azt a módszert, ami biztosítja, hogy ha egy folyamat használ valamilyen megosztott, közös adatot, akkor más folyamatok ebben az időben ne tudják azt elérni. \\
|
||||
A jó kölcsönös kizárás az alábbi feltételeknek felel meg:
|
||||
\begin{itemize}
|
||||
\item Nincs két folyamat egyszerre a kritikus szekciójában.
|
||||
\item Nincs sebesség, CPU paraméter függőség.
|
||||
\item Egyetlen kritikus szekción kívül levő folyamat sem blokkolhat másik folyamatot.
|
||||
\item Egy folyamat sem vár örökké, hogy a kritikus szekcióba tudjon belépni.
|
||||
\end{itemize}
|
||||
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.9\textwidth]{img/mutex.png}
|
||||
\caption{A megkívánt kölcsönös kizárás viselkedése}
|
||||
\end{figure}
|
||||
|
||||
\subsubsection{Megvalósítások}
|
||||
|
||||
\begin{itemize}
|
||||
\item Megszakítások tiltása (összes): Belépéskor az összes megszakítás tiltása, Kilépéskor azok engedélyezése. Ez nem igazán jó, mivel a felhasználói folyamatok kezében lenne a megszakítások tiltása, persze a kernel használja.
|
||||
\item Osztott, ún. zárolás változó használata: 0 (senki) és 1 (valaki) kritikus szekcióban van. Két folyamat is kritikus szekcióba tud kerülni! Egyik folyamat belép a kritikus szekcióba, de éppen az 1-re állítás előtt a másik folyamat kerül ütemezésre.
|
||||
\item Szigorú váltogatás: Több folyamatra is általánosítható. A kölcsönös kizárás feltételeit teljesíti a 3. kivételével, ugyanis ha pl 1 folyamat a lassú, nem kritikus szekcióban van, és a 0 folyamat gyorsan belép a kritikus szekcióba, majd befejezi a nem kritikus szekciót is, akkor ez a folyamat blokkolódik mert a kovetkezo=1 lesz!(Saját magát blokkolja!)
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.9\textwidth]{img/szigoru.png}
|
||||
\caption{Szigorú váltogatás}
|
||||
\end{figure}
|
||||
\item G. L. Peterson javította a szigorú váltogatást. A kritikus szekció előtt minden folyamat meghívja a belépés, majd utána kilépés függvényt.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.6\textwidth]{img/peterson.png}
|
||||
\includegraphics[width=0.3\textwidth]{img/petersonhiba.png}
|
||||
\caption{Peterson javítása és a benne rejlő hiba}
|
||||
\end{figure}
|
||||
Ez a javítás viszont nagy hibát okozhat. Tegyük fel proc=0. A jelölt ütemezés váltásnál a proc=1 belépése jön. Mivel akarja[0] értéke 0, ezért az 1-es process belép a kritikus szakaszba! Ekkor újra váltson az ütemező, akarja[1]=1, a következő értéke szintén 1, így a következo==proc hamis, azaz a 0. proc is belép a kritikus szakaszba!
|
||||
\item Tevékeny várakozás gépi kódban: TSL utasítás, Test and Set Lock. Ez atomi művelet, vagyis megszakíthatatlan.
|
||||
\item Tevékeny várakozás: A korábbi Peterson megoldás is, a TSL használata is jó, csak ciklusban várakozunk. A korábbi megoldásokat, tevékeny várakozással (aktív várakozás) megoldottnak hívjuk, mert a CPU-t ,,üres" ciklusban járatjuk a várakozás során.De ez a CPU időt pazarolja. Helyette jobb lenne az, ha a kritikus szekcióba lépéskor blokkolna a folyamat, ha nem szabad belépnie. Az aktív várakozás nem igazán hatékony. Megoldás: blokkoljuk(alvás) várakozás helyett a folyamatot, majd ha megengedett ébresszük fel. Különböző paraméter megadással is implementálhatók. Tipikus probléma: Gyártó-Fogyasztó probléma vagy másképp korlátos tároló probléma. PL: Pék-pékség-Vásárló háromszög:
|
||||
\begin{itemize}
|
||||
\item A pék süti a kenyeret, amíg a pékség polcain van hely.
|
||||
\item Vásárló tud venni, ha a pékség polcain van kenyér.
|
||||
\item Ha tele van kenyérrel a pékség, akkor ,,a pék elmegy pihenni".
|
||||
\item Ha üres a pékség, akkor a vásárló várakozik a kenyérre.
|
||||
\end{itemize}
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.9\textwidth]{img/pekvasarlo.png}
|
||||
\caption{Gyártó-fogyasztó probléma egy megvalósítása}
|
||||
\end{figure}
|
||||
Ennél a megvalósításnál probléma lehet, hogy A ,,hely" változó elérése nem korlátozott, így ez okozhat versenyhelyzetet.
|
||||
\begin{itemize}
|
||||
\item Vásárló látja, hogy a hely 0 és ekkor az ütemező átadja a vezérlést a péknek, aki süt egy kenyeret. Majd látja, hogy a hely 1, ébresztőt küld a vásárlónak. Ez elveszik, mert még a vásárló nem alszik.
|
||||
\item Vásárló visszakapja az ütemezést, a helyet korábban beolvasta, az 0, megy aludni.
|
||||
\item A pék az első után megsüti a maradék N-1 kenyeret és ő is aludni megy
|
||||
\end{itemize}
|
||||
Lehet ébresztő bittel javítani, de több folyamatnál a probléma nem változik.
|
||||
\end{itemize}
|
||||
|
||||
\section{Szemaforok, osztott memória, üzenetküldés}
|
||||
|
||||
\subsection{Szemaforok}
|
||||
|
||||
E.W. Dijkstra(1965) javasolta ezen új változótípus bevezetését.
|
||||
\begin{itemize}
|
||||
\item Ez valójában egy egész változó.
|
||||
\item A szemafor tilosat mutat, ha értéke 0. Ekkor a folyamat elalszik, megáll a tilos jelzés előtt.
|
||||
\item Ha a szemafor >0, szabad a pálya, beléphetünk a kritikus szakaszra. Két művelet tartozik hozzá: ha beléptünk, csökkentjük szemafor értékét (down); ha kilépünk, növeljük a szemafor értékét (up). Ezeket Dijkstra P és V műveletnek nevezte.
|
||||
\end{itemize}
|
||||
Elemi művelet: a szemafor változó ellenőrzése, módosítása, esetleges elalvás oszthatatlan művelet, nem lehet megszakítani. Ez garantálja, hogy ne alakuljon ki versenyhelyzet. \\
|
||||
Ha a szemafor tipikus vasutas helyzetet jelöl, azaz 1 vonat mehet át csak a jelzőn, a szemafor értéke ekkor 0 vagy 1 lehet. Ez a \textit{bináris szemafor}, vagy más néven MUTEX (Mutual Exclusion), és kölcsönös kizárásra használjuk. \\
|
||||
Rendszerhívással, felhasználói szinten nem biztosítható a műveletek atomiságának megvalósítása. Művelet elején például letiltunk minden megszakítást. Ha több CPU van, akkor az ilyen szemafort védeni tudjuk a TSL utasítással. Viszont ezek a szemafor műveletek kernel szintű, rendszerhívás műveletek. A fejlesztői környezetek biztosítják.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.45\textwidth]{img/gyarto_szemafor.png}
|
||||
\includegraphics[width=0.45\textwidth]{img/fogyaszto_szemafor.png}
|
||||
\caption{Gyártó-fogyasztó probléma megoldása szemaforokkal}
|
||||
\end{figure}
|
||||
\textit{Szabad}: kenyér polcot (boltot) védi, hogy egy időben csak egy folyamat tudja használni (vagy a pék, vagy a vásárló): Kölcsönös kizárás, Elemi műveletek (up, down). \\
|
||||
\textit{Tele, üres szemafor}: szinkronizációs szemaforok, a gyártó álljon meg ha a tároló tele van, illetve a fogyasztó is várjon ha a tároló üres. \\ \\
|
||||
Szemafornál két utasítás felcserélése is gondot okozhat. \\
|
||||
\textit{Monitor}: magasabb szintű, nyelvű konstrukció. Eljárások, adatszerkezetek
|
||||
lehetnek benne. Egy időben csak egy folyamat lehet aktív a monitoron belül.
|
||||
|
||||
\subsection{Osztott memória}
|
||||
|
||||
Elosztott közös memória: Hálózatban futó folyamatok közti memóriamegosztás. \\
|
||||
Lehetőségünk van egy programon belüli különböző folyamatok, szálak által használt memóriaterületek közössé tételére, vagyis használhatjuk ugyanazt a memóriarészt, ,,időosztásos" üzemmódban. Különböző, egymással valamilyen módon ,,összekapcsolt" programrészekhez, folyamokhoz, szálakhoz ugyanazt a memóriaterület kapcsoljuk.
|
||||
|
||||
\subsection{Üzenetküldés}
|
||||
|
||||
A folyamatok jellemzően két primitívet használnak: \textit{Send(célfolyamat, üzenet)}, \textit{Receive(forrás, üzenet)}. Ezek rendszerhívások, nem nyelvi konstrukciók. \\
|
||||
Ha küldő-fogadó nem azonos gépen van, szükséges ún. nyugtázó üzenet. Így ha küldő nem kapja meg a nyugtát, ismét elküldi az üzenetet. Ha a nyugta veszik el, a küldő újra küld. Ismételt üzenetek megkülönböztetése sorszám segítségével történik. \\
|
||||
\textit{Összegzés}: Ideiglenes tároló helyek (levelesláda) létrehozása mindkét helyen. El lehet hagyni, ekkor ha send előtt van receive, a küldő blokkolódik, illetve fordítva. Ezt hívják randevú stratégiának. Például a Minix 3 is randevút használ, rögzített méretű üzenetekkel. \\
|
||||
Adatcső kommunikáció hasonló, csak az adatcsőben nincsenek üzenethatárok, ott csak bájtsorozat van. Az üzenetküldés a párhuzamos rendszerek általános technikája. Pl. MPI \\
|
||||
Klasszikus IPC (inter-process communication) problémák:
|
||||
\begin{itemize}
|
||||
\item Étkező filozófusok esete: körben felváltva 5 villa, tányér. 2 villa kell a spagetti
|
||||
evéshez. A tányér melletti villákra pályáznak. Esznek-gondolkoznak. A legegyszerűbb megoldás (végtelen ciklusban gondolkodik, felveszi a két villáját egymás után, eszik, leteszi a villákat) pár hibát rejt magában, hogy pl. holtpont lehet, ha egyszerre megszerzik a bal villát és mind várnak a jobbra. Illetve ha leteszi a bal villát és újra próbálkozik, még az
|
||||
se az igazi, hiszen folyamatosan felveszik a bal villát, majd leteszik. (Éhezés)
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.3\textwidth]{img/filo.png}
|
||||
\caption{Étkező filozófusok, javított megoldás: 5 villa szemafor van, és egy maximum. Korlátozott erőforrás megszerzésre példa}
|
||||
\end{figure}
|
||||
\item Író-olvasó probléma: Adatbázist egyszerre többen olvashatják, de csak 1 folyamat írhatja.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.3\textwidth]{img/iro.png}
|
||||
\includegraphics[width=0.3\textwidth]{img/olvaso.png}
|
||||
\caption{Író-olvasó probléma megvalósítása}
|
||||
\end{figure}
|
||||
\end{itemize}
|
||||
|
||||
\section{Be- és kimeneti eszközök ütemezési lehetőségei, holtpontok}
|
||||
|
||||
\subsection{Be- és kimeneti eszközök ütemezési lehetőségei}
|
||||
|
||||
Input-Output eszközök:
|
||||
\begin{itemize}
|
||||
\item \textit{Blokkos eszközök}. Adott méretű blokkban tároljuk az információt. Blokkméret 512 byte - 32768 byte között. Egymástól függetlenül írhatók vagy olvashatók. Blokkonként címezhetőek. Ilyen eszköz: HDD, szalagos egység
|
||||
\item \textbf{Karakteres eszközök}. Nem címezhető, csak jönnek-mennek sorban a
|
||||
,,karakterek" (bájtok)
|
||||
\item \textbf{Időzítő}: kivétel, nem blokkos és nem
|
||||
karakteres
|
||||
\end{itemize}
|
||||
\textit{Megszakítások}: Általában az eszközöknek van állapotbitjük, jelezve, hogy az adat készen van. \\
|
||||
Megszakítás használat (IRQ):
|
||||
\begin{enumerate}
|
||||
\item CPU tevékenység megszakítása
|
||||
\item a kért sorszámú kiszolgáló végrehajtása
|
||||
\item a kívánt adat beolvasása, a szorosan hozzátartozó tevékenység elvégzése
|
||||
\item visszatérés a megszakítás előtti állapothoz.
|
||||
\end{enumerate}
|
||||
\textit{Közvetlen memória elérés}(DMA): Direct Memory Access, tartalmaz memória cím regisztert, átvitel irány jelzésre, mennyiségre regisztert. Ezeket szabályos in, out portokon lehet elérni. \\
|
||||
Működés lépései:
|
||||
\begin{enumerate}
|
||||
\item CPU beállítja a DMA vezérlőt. (Regisztereket.)
|
||||
\item A DMA a lemezvezérlőt kéri a megadott műveletre.
|
||||
\item Miután a lemezvezérlő beolvasta a pufferébe, a rendszersínen keresztül a memóriába(ból) írja, olvassa az adatot.
|
||||
\item Lemezvezérlő nyugtázza, hogy kész a kérés teljesítése.
|
||||
\item DMA megszakítással jelzi, befejezte a műveletet.
|
||||
\end{enumerate}
|
||||
|
||||
\subsection{Holtpontok (deadlock)}
|
||||
|
||||
Két vagy több folyamat egy erőforrás megszerzése során olyan helyzetbe kerül, hogy egymást blokkolják a további végrehajtásban. Pontos definíció: Folyamatokból álló halmaz holtpontban van, ha minden folyamat olyan eseményre vár, amit csak a halmaz egy másik folyamata okozhat. Nem csak az I/O eszközökhöz kötődik, pl párhuzamos rendszerek, adatbázisok, stb. \\
|
||||
Coffman E.G. szerint 4 feltétel szükséges a holtpont kialakulásához:
|
||||
\begin{enumerate}
|
||||
\item \textit{Kölcsönös kizárás feltétel.} Minden erőforrás hozzá van rendelve 1 folyamathoz vagy szabad.
|
||||
\item \textit{Birtoklás és várakozás feltétel.} Korábban kapott erőforrást birtokló folyamat kérhet újabbat.
|
||||
\item \textit{Megszakíthatatlanság feltétel.} Nem lehet egy folyamattól elvenni az erőforrást, csak a folyamat engedheti el.
|
||||
\item \textit{Ciklikus várakozás feltétel.} Két vagy több folyamatlánc kialakulása, amiben minden folyamat olyan erőforrásra vár, amit egy másik tart fogva.
|
||||
\end{enumerate}
|
||||
Irányított gráffal lehet modellezni a folyamatokat és erőforrásokat. Ha van kör, akkor az holtpontot jelent. \\ \\
|
||||
Stratégiék holtpont esetén:
|
||||
\begin{enumerate}
|
||||
\item A probléma figyelmen kívül hagyása.
|
||||
\begin{itemize}
|
||||
\item Nem törődünk vele, nagy valószínűséggel Ő sem talál meg bennünket.
|
||||
\item Ezt a módszert gyakran strucc algoritmus néven is ismerjük.
|
||||
\item Vizsgálatok szerint a holtpont probléma és az egyéb (fordító, op.rendszer, hw, sw hiba) összeomlások aránya 1:250.
|
||||
\item A Unix, Windows világ is ezt a „módszert” használja. De túl nagy az ár a várható haszonért cserébe.
|
||||
\end{itemize}
|
||||
\item Felismerés és helyreállítás.
|
||||
\begin{itemize}
|
||||
\item Engedjük a holtpontot megjelenni (kör), ezt észrevesszük és cselekszünk.
|
||||
\item Folyamatosan figyeljük az erőforrás igényeket, elengedéseket.
|
||||
\item Kezeljük az erőforrás gráfot folyamatosan. Ha kör keletkezik, akkor egy körbeli folyamatot megszüntetünk.
|
||||
\item Másik módszer, nem foglalkozunk az erőforrás gráffal, ha x (fél óra?) ideje blokkolt egy folyamat, egyszerűen megszüntetjük. Ez nagygépes rendszereknél ismert módszer.
|
||||
\end{itemize}
|
||||
\item Megelőzés.
|
||||
\begin{itemize}
|
||||
\item A 4 szükséges feltétel egyikének meghiúsítása.
|
||||
\item A Coffman féle 4 feltétel valamelyikére mindig él egy megszorítás.
|
||||
\begin{itemize}
|
||||
\item Kölcsönös kizárás. Ha egyetlen erőforrás soha nincs kizárólag 1 folyamathoz rendelve, akkor nincs holtpont se. De ez nehézkes, míg pl. nyomtató használatnál a
|
||||
nyomtató démon megoldja a problémát, de ugyanitt a nyomtató puffer egy lemezterület, itt már kialakulhat holtpont.
|
||||
\item Ha nem lehet olyan helyzet, hogy erőforrásokat birtokló folyamat további erőforrásra várjon, akkor szintén nincs holtpont. Ezt kétféle módon érhetjük el: Előre kell tudni egy folyamat összes erőforrásigényét vagy ha erőforrást akar egy folyamat, először engedje el az összes birtokoltat.
|
||||
\item A Coffman féle harmadik feltétel a megszakíthatatlanság. Ennek elkerülése eléggé
|
||||
nehéz. Pl nyomtatás közben nem szerencsés a nyomtatót másnak adni.
|
||||
\item A negyedik feltétel, a ciklikus várakozás már könnyebben megszüntethető. Egyszerű mód: Minden folyamat egyszerre csak 1 erőforrást birtokolhat. Másik módszer: Sorszámozzuk az erőforrásokat, és a folyamatok csak ezen sorrendben kérhetik az erőforrásokat. Ez jó elkerülési mód, csak megfelelő sorrend nincs.
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
\item Dinamikus elkerülés.
|
||||
\begin{itemize}
|
||||
\item Erőforrások foglalása csak ,,óvatosan".
|
||||
\item Bankár algoritmus (Dijkstra, 1965) Mint a kisvárosi bankár hitelezési gyakorlata. A bankár algoritmus minden kérés megjelenésekor azt nézi, hogy a kérés teljesítése biztonságos
|
||||
állapothoz vezet-e. Ha igen, jóváhagyja, ha nem, a kérést elhalasztja. Eredetileg 1 erőforrásra tervezett. \\
|
||||
A korábbi megelőzés is, meg ez az elkerülés is olyan információt kér (az erőforrás pontos igényeket, a folyamatok számát előre), ami nehezen megadható. (Folyamatok dinamikusan jönnek létre, erőforrások dinamikusan módosulnak.) Ezért a gyakorlatban kevesen alkalmazzák.
|
||||
\item Biztonságos állapotok, olyan helyzetek, melyekből létezik olyan kezdődő állapotsorozat, melynek eredményeként mindegyik folyamat megkapja a kívánt erőforrásokat és befejeződik.
|
||||
\end{itemize}
|
||||
\end{enumerate}
|
||||
|
||||
\section{Memóriakezelés, virtuális memória fogalma}
|
||||
|
||||
\textit{Monoprogramozás}: A legegyszerűbb memóriakezelési módszer, időben csak egyetlen programot futtatunk. \\
|
||||
\textit{Multiprogramozás}: multiprogramozás rögzített partíciókkal: Ekkor a rendelkezésre álló memóriát felosztják több, általában nem egyforma hosszúságú részre. Működéséhez minden partíciónak szüksége van egy úgynevezett várakozási sorra. Ha beérkezik egy igény, az operációs rendszer berakja annak a legkisebb méretű, partíciónak nevezett rész várakozási sorába, ahová még befér. Ilyenkor elvész a partíciónak az a része – nem használható –, amit az éppen futó processz nem használ. Ha az adott szeletben befejeződik a munka, a legrégebben várakozó megkapja a területet, és elkezd működni.
|
||||
|
||||
\subsection{Memóriakezelés}
|
||||
|
||||
A memóriakezelő az operációs rendszer része, gyakran a kernelben. Feladata: a memória nyilvántartása, melyek szabadok, foglaltak; memóriát foglaljon folyamatok számára; memóriát felszabadítson; csere vezérlése a RAM és a (Merev)Lemez között. \\
|
||||
Kétféle algoritmus csoport:
|
||||
\begin{itemize}
|
||||
\item Szükséges a folyamatok mozgatása, cseréje a memória és a lemez között. (swap)
|
||||
\item Nincs erre szükség, ha elegendő memória van.
|
||||
\end{itemize}
|
||||
|
||||
\textit{Multiprogramozás rögzített memóriaszeletekkel}: Osszuk fel a memóriát n (nem egyenlő) szeletre. (Fix szeletek) Pl. rendszerindításnál ez megtehető. Egy közös várakozási sor van, minden szeletre külön-külön várakozási sor. Kötegelt rendszerek tipikus megoldása. \\
|
||||
\textit{Relokáció}: Nem tudjuk hova kerül egy folyamat, így a memória hivatkozások nem fordíthatók fix értékekre. \\
|
||||
\textit{Védelem}: Nem kívánatos, ha egy program a másik memóriáját ,,éri el". \\
|
||||
Másik megoldás: Bázis+határregiszter használata, ezeket a programok nem módosíthatják, de minden címhivatkozásnál ellenőrzés: lassú. \\
|
||||
\textit{Multiprogramozás memóriacsere használattal}: A korábbi kötegelt rendszerek tipikus megoldása a rögzített memória szeletek használata (IBM OS/MFT). Időosztásos, grafikus felületek esetén ez nem az igazi. Itt a teljes folyamatot mozgatjuk a memória-lemez között. Nincs rögzített memória partíció, mindegyik dinamikusan változik, ahogy az op. rendszer oda-vissza rakosgatja a folyamatokat. Dinamikus, jobb memória kihasználtságú lesz a rendszer, de a sok csere lyukakat hoz létre, ezért memória tömörítést kell végezni. (Sok esetben ez az időveszteség nem megengedhető.) \\
|
||||
\textit{Dinamikus memóriafoglalás}: Általában nem ismert, hogy egy programnak mennyi dinamikus adatra, veremterületre van szüksége. A program ,,kód" része fix szeletet kap, míg az adat és verem része változót. Ezek tudnak nőni (csökkenni). Ha elfogy a memória, akkor a folyamat leáll, vár a
|
||||
folytatásra, vagy kikerül a lemezre, hogy a többi még futó folyamat memóriához jusson. Ha van a memóriában már várakozó folyamat, az is cserére kerülhet. \\
|
||||
A ,,dinamikus" memória nyilvántartása:
|
||||
\begin{itemize}
|
||||
\item Allokációs egység definiálása. Ennek mérete kérdés. Ha kicsi, akkor kevésbé lyukasodik a memória, viszont nagy a nyilvántartási ,,erőforrás (memória) igény". Ha nagy az egység, akkor túl sok lesz az egységen belüli maradékokból adódó memóriaveszteség.
|
||||
\item A nyilvántartás megvalósítása: Bittérkép használattal vagy Láncolt lista használattal. Ha egy folyamat befejeződik, akkor szükség lehet az egymás melletti memória lyukak egyesítésére. Külön lista a lyukak és folyamatok listája.
|
||||
\end{itemize}
|
||||
\textit{Memóriafoglalási stratégiák}: Új vagy swap partícióról behozott folyamat számára, több memória elhelyezési algoritmus ismert (hasonlóak a lemezhez):
|
||||
\begin{itemize}
|
||||
\item First Fit (első helyre, ahova befér, leggyorsabb, legegyszerűbb)
|
||||
\item Next Fit (nem az elejéről, hanem az előző befejezési pontjából indul a keresés, kevésbé hatékony, mint a first fit)
|
||||
\item Best Fit (lassú, sok kis lyukat produkál)
|
||||
\item Worst Fit (nem lesz sok kis lyuk, de nem hatékony)
|
||||
\item Quick Fit (méretek szerinti lyuklista, a lyukak összevonása költséges)
|
||||
\end{itemize}
|
||||
|
||||
\subsection{Virtuális memória fogalma}
|
||||
|
||||
\textit{Multiprogramozás virtuális memóriahasználattal}: Egy program használhat több memóriát,
|
||||
mint a rendelkezésre álló fizikai méret. Az operációs rendszer csak a ,,szükséges részt" tartja a fizikai memóriában. Egy program a ,,virtuálismemória-térben" tartózkodik. Az elv akár a monoprogramozás környezetben is használható. \\
|
||||
\textit{Memory Management Unit (MMU)}: A virtuális címtér ,,lapokra" van osztva. (Ezt laptáblának
|
||||
nevezzük). Van jelenlét/hiány bit. Virtuális-fizikai lapokat összerendeljük. Ha az MMU látja, hogy egy lap nincs a memóriában, laphibát okoz, op.rendszer kitesz egy lapkeretet, majd behozza a szükséges lapot.
|
||||
|
||||
\section{Lapozás és szegmentálás}
|
||||
|
||||
\subsection{Lapozás}
|
||||
|
||||
\textit{Lapozástervezési szempontok}:
|
||||
\begin{itemize}
|
||||
\item Munkahalmaz modell
|
||||
\begin{itemize}
|
||||
\item A szükséges lapok betöltése. (Induláskor-előlapozás) A folyamat azon lapjainak fizikai memóriában tartása, melyeket használ. Ez az idővel változik.
|
||||
\item Nyilván kell tartani a lapokat. Ha egy lapra az utolsó N időegységben nem hivatkoznak, laphiba esetén kidobjuk.
|
||||
\item Óra algoritmus javítása: Vizsgáljuk meg, hogy a lap eleme a munkahalmaznak? (WSClock algoritmus)
|
||||
\end{itemize}
|
||||
\item Lokális, globális helyfoglalás
|
||||
\begin{itemize}
|
||||
\item Egy laphibánál ha az összes folyamatot (globális), vagy csak a folyamathoz tartozó (lokális) lapokat vizsgáljuk.
|
||||
\item Globális algoritmus esetén minden folyamatot elláthatunk méretéhez megfelelő lappal, amit aztán dinamikusan változtatunk.
|
||||
\item Page Fault Frequency (PFF) algoritmus, laphiba/másodperc arány, ha sok a laphiba, növeljük a folyamat memóriában lévő lapjainak a számát. Ha sok a folyamat, akár teljes folyamatot lemezre vihetünk.(teherelosztás)
|
||||
\end{itemize}
|
||||
\item Helyes lapméret meghatározása.
|
||||
\begin{itemize}
|
||||
\item Kicsi lapméret: A ,,lapveszteség" kicsi, viszont nagy laptábla kell a nyilvántartáshoz.
|
||||
\item Nagy lapméret: Fordítva, ,,lapveszteség" nagy, kicsi laptábla.
|
||||
\item Jellemzően: n x 512 bájt a lapméret, XP, Linuxok 4KB a lapméret. 8KB is használt (szerverek).
|
||||
\end{itemize}
|
||||
\item Közös memória
|
||||
\begin{itemize}
|
||||
\item Foglalhatunk memóriaterületet, amit több folyamat használhat.
|
||||
\item Elosztott közös memória: Hálózatban futó folyamatok közti memóriamegosztás.
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
|
||||
\subsection{Szegmentálás}
|
||||
|
||||
Virtuális memória: egy dimenziós címtér, 0-tól a maximum címig (4,8,16 GB, ...). \\
|
||||
Több programnak van dinamikus területe, melyek növekedhetnek, bizonytalan mérettel. Hozzunk létre egymástól független címtereket, ezeket szegmensnek nevezzük. \\
|
||||
Ebben a világban egy cím 2 részből áll: szegmens szám, és ezen belüli cím. (eltolás) \\
|
||||
Szegmentálás lehetővé teszi osztott könyvtárak ,,egyszerű" megvalósítását. Logikailag szét lehet szedni a programot, adat szegmens, kód szegmens stb. Védelmi szintet is megadhatunk egy szegmensre. Lapok fix méretűek, a szegmensek nem. Szegmens töredezettség megjelenése. Ez töredezettség-összevonással javítható.
|
||||
|
||||
\section{Lapcserélési algoritmusok}
|
||||
|
||||
Ha nincs egy virtuális című lap a memóriában, akkor egy lapot ki kell dobni, berakni ezt az új lapot. A processzor gyorsító tár (cache) memória használatnál, vagy a böngésző helyi gyorsítótáránál is hasonló a helyzet.
|
||||
Optimális lapcserélés: Címkézzünk meg minden lapot azzal a számmal, ahány CPU utasítás végrehajtódik, mielőtt hivatkozunk rá. Dobjuk ki azt a lapot, amelyikben legkisebb ez a szám. Egy baj van, nem lehet megvalósítani, viszont kétszeres futásnál tesztelési célokat szolgálhat.
|
||||
\begin{itemize}
|
||||
\item NRU (Not Recently Used) algoritmus:
|
||||
\begin{itemize}
|
||||
\item Használjuk a laptábla bejegyzés módosítás (Modify) és hivatkozás (Reference) bitjét. A hivatkozás bitet időnként (óramegszakításnál, kb. 0.02 sec) állítsuk 0-ra, ezzel azt jelezzük, hogy az ,,utóbbi időben" volt-e használva, hivatkozva.
|
||||
\begin{itemize}
|
||||
\item 0.osztály: nem hivatkozott, nem módosított
|
||||
\item 1.osztály: nem hivatkozott, módosított. Ide akkor lehet kerülni, ha az óramegszakítás állítja 0-ra a hivatkozás bitet.
|
||||
\item 2.osztály: hivatkozott, nem módosított
|
||||
\item 3.osztály: hivatkozott, módosított
|
||||
\end{itemize}
|
||||
\item Válasszunk véletlenszerűen egy lapot a legkisebb nem üres osztályból. Egyszerű, nem igazán hatékony implementálni, megfelelő eredményt ad.
|
||||
\end{itemize}
|
||||
\item FIFO lapcserélés. Egyszerű FIFO, más területekről is ismert, ha szükség van egy új lapra akkor a legrégebbi lapot dobjuk ki. Listában az érkezés sorrendjében a lapok, egy lap a lista elejére érkezik, és a végéről távozik. Ennek javítása a Második Lehetőség lapcserélő algoritmus.
|
||||
\item Második Lehetőség lapcserélő algoritmus. Olyan, mint a FIFO, csak ha a lista végén lévő lapnak a hivatkozás bitje 1, akkor kap egy második esélyt, a lista elejére kerül és a hivatkozás bitet 0-ra állítjuk.
|
||||
\item Óra algoritmus: olyan, mint a második lehetőség, csak ne a lapokat mozgassuk körbe egy
|
||||
listában, hanem rakjuk körbe őket és egy mutatóval körbe járunk. A mutató a legrégebbi lapra mutat. Laphibánál, ha a mutatott lap hivatkozás bitje 1, nullázzuk azt, és a következő lapot
|
||||
vizsgáljuk. Ha vizsgált lap hivatkozás bitje 0, akkor kitesszük.
|
||||
\item LRU (Least Recently Used) algoritmus: Legkevésbé (legrégebben) használt lap kidobása. HW vagy SW megvalósítás.
|
||||
\begin{itemize}
|
||||
\item HW1: Vegyünk egy számlálót, ami minden memória hivatkozásnál 1-gyel nő. Minden laptáblában tudjuk ezt a számlálót tárolni. Minden memóriahivatkozásnál ezt a számlálót beírjuk a lapba. Laphibánál megkeressük a legkisebb számlálóértékű lapot.
|
||||
\item HW2: LRU bitmátrix használattal, n lap, n x n bitmátrix. Egy k. lapkeret hivatkozásnál állítsuk a mátrix k. sorát 1-re, míg a k. oszlopát 0-ra. Laphibánál a legkisebb értékű sor a legrégebbi.
|
||||
\end{itemize}
|
||||
\item NFU (Not Frequently Used) algoritmus:
|
||||
\begin{itemize}
|
||||
\item Minden laphoz tegyünk egy számlálót. Minden óramegszakításnál ehhez adjuk hozzá a lap
|
||||
hivatkozás (R) bitjét.
|
||||
\item Laphibánál a legkisebb számlálóértékű lapot dobjuk ki. (A leginkább nem használt lap)
|
||||
\item Hiba, hogy az NFU nem felejt, egy program elején gyakran használt lapok megőrzik nagy értéküket.
|
||||
\item Módosítsuk: Minden óramegszakításnál csináljunk jobbra egy biteltolást a számlálón, balról pedig hivatkozás bitet tegyük be (shr).(Öregítő algoritmus)
|
||||
\item Ez jól közelíti az LRU algoritmust.
|
||||
\item Ez a lapszámláló véges bitszámú (n), így n időegység előtti eseményeket biztosan nem tud megkülönböztetni.
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
|
||||
\section{Lemezterület-szervezés, redundáns tömbök, fájlrendszerek szolgáltatásai és jellemző megvalósításaik}
|
||||
|
||||
\subsection{Lemezterület-szervezés}
|
||||
|
||||
\subsection{Redundáns tömbök}
|
||||
|
||||
RAID -- Redundant Array of Inexpensive Disks. Ha operációs rendszer nyújtja, gyakran Soft Raidnek nevezik. Ha intelligens (külső) vezérlőegység nyújtja, gyakran Hardver Raid-nek, vagy csak Raid diszkrendszernek nevezik. Bár nevében olcsó (Inexpensive), valójában inkább nem az. Több lemezt fog össze, és egy logikai egységként látja az operációs rendszer. Többféle ,,összefogási" elv létezik: RAID 0-6.
|
||||
\begin{itemize}
|
||||
\item RAID 0(striping)
|
||||
\begin{itemize}
|
||||
\item Ez az a Raid, ami nem is redundáns
|
||||
\item Több lemez logikai összefűzésével egy meghajtót kapunk.
|
||||
\item A lemezkapacitások összege adja az új meghajtó kapacitását.
|
||||
\item A logikai meghajtó blokkjait szétrakja a lemezekre (striping), ezáltal egy fájl írása több lemezre kerül.
|
||||
\item Gyorsabb I/O műveletek.
|
||||
\item Nincs meghibásodás elleni védelem.
|
||||
\end{itemize}
|
||||
\item RAID 1(tükrözés)
|
||||
\begin{itemize}
|
||||
\item Két független lemezből készít egy logikai egységet.
|
||||
\item Minden adatot párhuzamosan kiír mindkét lemezre.(Tükrözés, mirror)
|
||||
\item Tárolókapacitás felére csökken.
|
||||
\item Drága megoldás.
|
||||
\item Jelentős hibatűrő képesség. Mindkét lemez egyszerre történő meghibásodása okoz adatvesztést.
|
||||
\end{itemize}
|
||||
\item RAID 1+0, RAID 0+1
|
||||
\begin{itemize}
|
||||
\item RAID 1+0: Tükrös diszkekből vonjunk össze többet.
|
||||
\item RAID 0+1: RAID 0 összevont lemezcsoportból vegyünk kettőt.
|
||||
\item A vezérlők gyakran nyújtják egyiket, másikat, mivel így is, úgy is tükrözés van, azaz drága, így ritkán használt.
|
||||
\end{itemize}
|
||||
\item RAID 2: Adatbitek mellett hibajavító biteket is tartalmaz. (ECC: Error Correction Code) Pl. 4 diszkhez 3 javító diszk
|
||||
\item RAID 3: Elég egy plusz ,,paritásdiszk", n+1 diszk, $\sum{n}$ a kapacitás
|
||||
\item RAID 4: RAID 0 kiegészítése paritásdiszkkel.
|
||||
\item Ma ezen megoldások (RAID 2,3,4) nem gyakran használatosak.
|
||||
\item RAID 5
|
||||
\begin{itemize}
|
||||
\item Nincs paritásdiszk, ez el van osztva a tömb összes elemére. (stripe set)
|
||||
\item Adatok is elosztva kerülnek tárolásra.
|
||||
\item Intenzív CPU igény (vezérlő CPU!!!)
|
||||
\item Redundáns tárolás, 1 lemez meghibásodása nem okoz adatvesztést. A paritásbitből meg a többiből az egy eltűnt kiszámítható. 2 lemez egyidejű meghibásodása már okoz adatvesztést.
|
||||
\item N lemez RAID 5 tömbben (N>=3), n-1 lemez méretű logikai meghajtót ad.
|
||||
\end{itemize}
|
||||
\item RAID 6
|
||||
\begin{itemize}
|
||||
\item A RAID 5 paritásblokkhoz, hibajavító kód kerül tárolásra.(+1 diszk)
|
||||
\item Még intenzívebb CPU igény.
|
||||
\item Két diszk egyidejű kiesése sem okoz adatvesztést.
|
||||
\item Relatív drága
|
||||
\item N diszk RAID 6-os tömbjének kapacitása, N-2 diszk kapacitással azonos.
|
||||
\item Elvileg általánosítható a módszer (3 diszk kiesése)
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
Ma leggyakrabban a RAID 1,5 verziókat használják. A RAID 6 vezérlők az utóbbi 1-2 évben jelentek meg. Bár olcsó diszkekről szól a RAID, de valójában ezek nem mindig olcsók. RAID 6-nl már 2 lemez kiesik, így ez még inkább drága. \\
|
||||
Hot-Swap(forró csere) RAID vezérlő: működés közben a meghibásodott lemezt egyszerűen kicseréljük.
|
||||
|
||||
\subsection{Fájlrendszerek szolgáltatásai}
|
||||
|
||||
\textit{Fájl}: adatok egy logikai csoportja, névvel egyéb paraméterekkel ellátva. A fájl az információtárolás egysége, névvel hivatkozunk rá. Jellemzően egy lemezen helyezkedik el, de általánosan az adathalmaz, adatfolyam akár képernyőhöz, billentyűzethez is köthető. \\
|
||||
A lemezen általában 3 féle fájl, állomány található:
|
||||
\begin{itemize}
|
||||
\item Rendes felhasználói állomány.
|
||||
\item Ideiglenes állomány
|
||||
\item Adminisztratív állomány. Ez a működéshez szükséges, általában rejtett.
|
||||
\end{itemize}
|
||||
\textit{Könyvtár}: fájlok (könyvtárak) logikai csoportosítása. \\
|
||||
\textit{Fájlrendszer}: módszer, a fizikai lemezünkön, kötetünkön a fájlok és könyvtárak elhelyezés rendszerének kialakítására. \\
|
||||
Fájlok elhelyezése: A partíció elején, az ún. Szuperblokk (pl. FAT esetén a 0. blokk ) leírja a rendszer jellemzőit. Általában következik a helynyilvántartás (FAT, láncolt listás nyilvántartás). Ezután a könyvtárszerkezet (inode), a könyvtár bejegyzésekkel, fájl adatokkal. (FAT16-nál a könyvtár előbb van, majd utána a fájl adatok.) \\
|
||||
Elhelyezési stratégiák:
|
||||
\begin{itemize}
|
||||
\item Folytonos tárkiosztás: First Fit, Best Fit, Worst Fit (olyan memória szakaszba tesszük, hogy a lehető legnagyobb rész maradjon szabadon). Veszteséges lemezkihasználás.
|
||||
\item Láncolt elhelyezkedés: Nincs veszteség (csak a blokkméretből adódóan). Fájl adatok (blokkokra bontva) láncolt lista tábla. Az n. blokk olvasása lassú lesz. Szabad-foglalt szektorok: File Allocation Table,FAT. Ez nagy lehet, a FAT-nak a memóriában kell lenni fájl műveletnél.
|
||||
\item Indextáblás elhelyezés: Katalógus tartalmazza a fájlhoz tartozó kis tábla (inode) címét. Egy inode címből elérhető a fájl.
|
||||
\end{itemize}
|
||||
|
||||
Fájlrendszer típusok:
|
||||
\begin{itemize}
|
||||
\item Merevlemezen alkalmazott fájlrendszer: FAT, NTFS, EXT2FS, XFS, stb
|
||||
\item Szalagos rendszereken (elsősorban backup) alkalmazott fájlrendszer: Tartalomjegyzék, majd a tartalom szekvenciálisan
|
||||
\item CD, DVD, Magneto-opto Disc fájlrendszer: CDFS, UDF (Universal Disc Format), kompatibilitás
|
||||
\item RAM lemezek (ma már kevésbé használtak)
|
||||
\item FLASH memória meghajtó (FAT32)
|
||||
\item Hálózati meghajtó: NFS
|
||||
\item Egyéb pszeudó fájlrendszerek: Zip, tar.gz, ISO
|
||||
\end{itemize}
|
||||
|
||||
\textit{Naplózott fájlrendszerek}: A fájlrendszer sérülés, áramszünet stb. esetén inkonzisztens állapotba kerülhet. Gyakran nevezik: LFS-nek (Log-structured File System) vagy JFS-nek(Journaled). Adatbázis-kezelők mintájára: művelet + log naplózódik. Tranzakciós alapra épül. Leállás, hiba esetén a log alapján helyre lehet állítani. Célszerűen a log másik lemez (másik partíció). Nagyobb erőforrás igényű, de nagyobb a megbízhatóság. \\
|
||||
A mai operációs rendszerek ,,rengeteg" típust támogatnak, pl: Linux 2.6 kernel több mint 50-et.
|
||||
A fájlrendszert csatolni többféleképpen is lehet:
|
||||
\begin{itemize}
|
||||
\item Mount, eredményeképpen a fájlrendszer állományok elérhetők lesznek.
|
||||
\item Automatikus csatolás (pl. USB drive)
|
||||
\item Kézi csatolás (Linux, mount parancs)
|
||||
\end{itemize}
|
||||
Külön névtérbeli elérhetőség a Windowsnál az A, B, C stb lemezek. Egységes névtér a UNIX-nál van.
|
||||
|
||||
\subsection{Fájlrendszerek szolgáltatásainak jellemző megvalósításai}
|
||||
|
||||
\begin{itemize}
|
||||
\item FAT
|
||||
\begin{itemize}
|
||||
\item File Allocation Table. Talán a legrégebbi, ma is élő fájlrendszer.
|
||||
\item A FAT tábla a lemez foglaltsági térképe, annyi eleme van, ahány blokk a lemezen. Pl: Fat12, FDD, Cluster méret 12 bites. Ha értéke 0, szabad, ha nem, foglalt. Biztonság kedvéért 2 tábla van.
|
||||
\item Láncolt elhelyezés. A katalógusban a file adatok (név stb) mellett csak az első fájl blokk sorszáma van megadva. A FAT blokk azonosító mutatja a következő blokk címét. Ha nincs tovább, FFF az érték.
|
||||
\item Rögzített bejegyzés méret, 32 bájt (max. 8.3 név)
|
||||
\item System, Hidden, Archive, Read only, könyvtár attribútumok
|
||||
\item A fájl utolsó módosítás ideje is tárolva van.
|
||||
\item \textit{FAT16}, 16 bites cluster leíró, 4 bájt (2x2) írja le a fájl kezdőblokkját. Max. 4 GB partíciós méret (64kb blokk méretnél), jellemzően 2 GB. Fájlméret maximum is a 4 (2) GB. Külön könyvtári terület (FDD-nez a 0. sáv). FDD-n 512 könyvtári bejegyzés. HDD-n 32736 könyvtári bejegyzés (16 bit előjelesen)
|
||||
\item \textit{FAT32} (1996-tól elérhető): 28 bites clusterleíró, 2 TB partíciós méret (alap szektor mérettel), 32 MB-ig 1 blokk = 1 szektor(512bájt). 64 MB: 1 blokk=1KB (2 szektor), 128MB: 1 blokk=2KB. 1 blokk max. 64 KB lehet.
|
||||
\item Támogatták már a hosszú fájl neveket is. Többszörös 8.3 részre fenntartott bejegyzésekkel.
|
||||
\item Töredezettségmentesítés szükséges.
|
||||
\end{itemize}
|
||||
\item NTFS
|
||||
\begin{itemize}
|
||||
\item New Technology File System
|
||||
\item FAT-NTFS hatékonysági határ: kb. 400 MB.
|
||||
\item 255 karakteres fájl név, 8+3 másodlagos név
|
||||
\item Kifinomult biztonsági beállítások
|
||||
\item Ahogy a FAT esetén, itt is szükséges a töredezettségmentesítés.
|
||||
\item Titkosított fájlrendszer támogatása, naplózás
|
||||
\item POSIX támogatás. Hardlink (fsutil parancs), időbélyegek, kis-nagybetűk különböznek
|
||||
\item Tömörített fájl, mappa, felhasználói kvóta kezelés
|
||||
\item Az NTFS csak klasztereket tart nyilván, szektort (512bájt) nem
|
||||
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.9\textwidth]{img/ntfs.png}
|
||||
\caption{NTFS partíció. A Master File Table és a File System Data egy-egy táblázat}
|
||||
\end{figure}
|
||||
|
||||
\item MFT: NTFS partíció az MFT (Master File Table) táblázattal kezdődik. 16 attribútum ad egy fájl bejegyzést. Minden attribútum max. 1kb. Ha ez nem elég, akkor egy attribútum mutat a folytatásra. Az adat is egyfajta attribútum, így egy bejegyzés több adatsort tartalmazhat. (PL: Betekintő kép) Elvi fájlméret $2^64$ bájt lehet. Ha a fájl < 1kb, belefér az attribútumba, közvetlen fájl. Nincs fájlméret maximum.
|
||||
\end{itemize}
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.6\textwidth]{img/ntfs2.png}
|
||||
\caption{Az NTFS partíció felépítése}
|
||||
\end{figure}
|
||||
\item ext, az ext2 és az ext3
|
||||
\begin{itemize}
|
||||
\item Az „ext” kifejezés a fájlrendszerek neveiben az extended (magyarul kiterjesztett) kifejezést takarja. Az extended fájlrendszer volt az első kifejezetten a UNIX-szerű GNU/LINUX operációs rendszerekhez készített fájlrendszer, amely örökölte az UFS (UNIX File System) fájlrendszer metaadat-szerkezetét, és arra készült, hogy a Minix operációs rendszer fájlrendszerének a hibáit kiküszöbölje. A hibák kiküszöbölése többek között a Minix operációs rendszer fájlrendszer-határainak kiterjesztése.
|
||||
\item Az ext2 fájlrendszer, amely a GNU/LINUX operációs rendszereken kívül más rendszereken is megjelent, több Linux disztribúció alapértelmezett fájlrendszere volt, amíg az utódja, az „ext3” fájlrendszer (third extended filesystem – harmadik kiterjesztett fájlrendszer) el nem készült.
|
||||
\item Az ext3 fájlrendszer (third extended filesystem – harmadik kiterjesztett fájlrendszer) az ext2 fájlrendszer utódja, amely már az ext2 fájlrendszerhez képest naplózást is tartalmaz. Ez a naplózás elsősorban a biztonságot növeli, és lehetővé teszi azt, hogy szabálytalan leállás bekövetkezése után ne kelljen az egész fájlrendszert újra ellenőrizni.
|
||||
\end{itemize}
|
||||
\item ReiserFS: A ReiserFS fájlrendszer lehetővé teszi egy blokkos eszközön (block device) változó méretű fájlok tárolását és könyvtárstruktúrába rendezését. A kezdeti UNIX és UNIX-szerű operációs rendszerek (így pl. a GNU/LINUX operációs rendszer is) csak egyfajta fájlrendszert támogattak, a saját formátumukat. A modern operációs rendszerek viszont többféle fájlrendszert is támogatnak, és vannak olyan fájlrendszerek is, amelyeket több operációs rendszer is támogat. A ReiserFS fájlrendszer egyáltalán nem ilyen. A ReiserFS fájlrendszer egy olyan fájlrendszer, amely csak és kizárólag a GNU/LINUX operációs rendszer alatt használható jelenleg korlátozás nélkül.
|
||||
\end{itemize}
|
||||
|
||||
\end{document}
|
After Width: | Height: | Size: 11 KiB |
After Width: | Height: | Size: 18 KiB |
After Width: | Height: | Size: 47 KiB |
After Width: | Height: | Size: 24 KiB |
After Width: | Height: | Size: 137 KiB |
After Width: | Height: | Size: 13 KiB |
After Width: | Height: | Size: 34 KiB |
After Width: | Height: | Size: 8.9 KiB |
After Width: | Height: | Size: 2.5 KiB |
After Width: | Height: | Size: 22 KiB |
After Width: | Height: | Size: 32 KiB |
After Width: | Height: | Size: 114 KiB |
After Width: | Height: | Size: 37 KiB |
After Width: | Height: | Size: 115 KiB |
After Width: | Height: | Size: 3.6 KiB |
After Width: | Height: | Size: 5.1 KiB |
After Width: | Height: | Size: 4.4 KiB |
After Width: | Height: | Size: 5.2 KiB |
After Width: | Height: | Size: 15 KiB |
After Width: | Height: | Size: 12 KiB |
After Width: | Height: | Size: 12 KiB |
After Width: | Height: | Size: 12 KiB |
After Width: | Height: | Size: 14 KiB |
After Width: | Height: | Size: 15 KiB |
After Width: | Height: | Size: 11 KiB |
After Width: | Height: | Size: 43 KiB |
After Width: | Height: | Size: 31 KiB |
After Width: | Height: | Size: 29 KiB |
After Width: | Height: | Size: 18 KiB |
@@ -0,0 +1,983 @@
|
||||
\documentclass[margin=0px]{article}
|
||||
|
||||
\usepackage{listings}
|
||||
\usepackage[utf8]{inputenc}
|
||||
\usepackage{graphicx}
|
||||
\usepackage{float}
|
||||
\usepackage[a4paper, margin=1in]{geometry}
|
||||
\usepackage{subcaption}
|
||||
\usepackage{amsthm}
|
||||
\usepackage{amssymb}
|
||||
\usepackage{amsmath}
|
||||
\usepackage{color}
|
||||
|
||||
\renewcommand{\figurename}{ábra}
|
||||
\newenvironment{tetel}[1]{\paragraph{#1 \\}}{}
|
||||
\newcommand{\R}{\mathbb{R}}
|
||||
|
||||
% A dokument itt kezdődik
|
||||
|
||||
\title{Záróvizsga tételsor \\ \large 16. Számítógépes hálózatok és Internet eszközök}
|
||||
\date{}
|
||||
\author{Dobreff András}
|
||||
|
||||
\begin{document}
|
||||
\maketitle
|
||||
|
||||
\begin{tetel}{Számítógépes hálózatok és Internet eszközök}
|
||||
Fizikai réteg, adatkapcsolati réteg, hálózati réteg, szállítói réteg – feladatok, módszerek, protokollok
|
||||
\end{tetel}
|
||||
|
||||
\section{Hálózatok modelljei}
|
||||
\begin{description}
|
||||
\item[TCP/IP modell] \hfill \\
|
||||
\textbf{T}ransmission \textbf{C}ontrol \textbf{P}rotocol/\textbf{I}nternet \textbf{P}rotocol. Röviden TCP/IP. A TCP/IP modell 1982-ben lett az amerikai hadászati célú számítógépes hálózatok standardja. 1985-től népszerűsítették kereskedelmi használatra.
|
||||
|
||||
4 Réteget különböztet meg:
|
||||
\begin{enumerate}
|
||||
\item Kapcsolati réteg
|
||||
\item Hálózati réteg
|
||||
\item Szállítói réteg
|
||||
\item Alkalmazási réteg
|
||||
\end{enumerate}
|
||||
\item[OSI modell] \hfill \\
|
||||
\textbf{O}pen \textbf{S}ystem \textbf{I}nterconnection Reference Model. Röviden OSI referencia modell. Standard koncepcionális modellt definiál kommunikációs hálózatok belső funkcionalitásához.
|
||||
|
||||
7 Réteget különböztet meg:
|
||||
\begin{enumerate}
|
||||
\item Fizikai réteg
|
||||
\item Adatkapcsolati réteg
|
||||
\item Hálózati réteg
|
||||
\item Szállítási réteg
|
||||
\item Munkamenet réteg
|
||||
\item Megjelenítési réteg
|
||||
\item Alkalmazási réteg
|
||||
\end{enumerate}
|
||||
\end{description}
|
||||
\section{Fizikai réteg}
|
||||
\begin{description}
|
||||
\item[Definíció] \hfill \\
|
||||
A fizikai réteg feladata a bitek továbbítása a kommunikációs csatornán keresztül. Azaz a korrekt bit átvitel biztosítása, a kapcsolat kezelése és az átvitelhez szükséges idő és egyéb részletek tisztázása. \\
|
||||
Tehát a tervezési szempontok az interfész mechanikai, elektromos és eljárási kérdéseire, illetve az átviteli közegre vonatkoznak.
|
||||
\item[Adatátvitel] \hfill
|
||||
\begin{description}
|
||||
\item[Vezetékes] \hfill \\
|
||||
Adatátvitel vezeték esetén valamilyen fizikai jellemző változtatásával lehetséges (pl.: feszültség, áramerősség). Ezt egy $g(t)$ periodikus függvénnyel jellemezhetjük.
|
||||
\begin{align*}
|
||||
g(t) = \frac{1}{2}c+ \sum\limits_{n=1}^\infty a_nsin(2\pi n f t) + \sum\limits_{n=1}^\infty b_ncos(2\pi n f t)
|
||||
\end{align*}
|
||||
ahol $f=\frac{1}{T}$ az alapfrekvencia, $a_n$ és $b_n$ pedig az $n$-edik harmonikus szinuszos illetve koszinuszos amplitúdók
|
||||
\item[Vezetékes nélküli] \hfill \\
|
||||
Vezeték nélküli adatátvitelre sok helyen használnak elektormágneses hullámokat. A hullámoknak van frekvenciája és hullámhossza.
|
||||
\begin{itemize}
|
||||
\item Frekvencia:
|
||||
A hullám másodpercenkénti rezgésszáma. Jele: $f$, mértékegysége: Hz (Hertz)
|
||||
\item Hullámhossz: két egymást követő hullámcsúcs (v. hullámvölgy) közötti távolság. Jele: $\lambda$
|
||||
\end{itemize}
|
||||
\begin{align*}
|
||||
\lambda f = c
|
||||
\end{align*}
|
||||
ahol $c$ a fénysebesség, azaz az elektromágneses hullámok terjedési sebessége vákuumban.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.6\textwidth]{img/elektromagneses.png}
|
||||
\caption{Elektromágneses spektrum}
|
||||
\end{figure}
|
||||
\item[Szimbólumok] \hfill \\
|
||||
Bitek helyett szimbólumokat küldünk át. (Pl. 4 szimbólum: A - 00, B - 01, C - 10, D - 11)\\
|
||||
Baud: szimbólum/másodperc \\
|
||||
Adatráta: bit/másodperc
|
||||
\item[Szinkronizáció] \hfill \\
|
||||
Kérdés: Mikor kell szignálokat mérni, illetve mikor kezdődik egy szimbólum? Ehhez szinkronizáció kell a felek között.
|
||||
\begin{itemize}
|
||||
\item Explicit órajel \\
|
||||
Párhuzamos átviteli csatornák használata, szinkronizált adatok, rövid átvitel esetén alkalmas.
|
||||
\item Kritikus időpontok \\
|
||||
Szinkronizáljunk például egy szimbólum vagy blokk kezdetén, a kritikus időpontokon kívül szabadon futnak az órák, feltesszük, hogy az órák rövid ideig szinkronban futnak.
|
||||
\item Szimbólum kódok \\
|
||||
Önütemező jel–külön órajel szinkronizáció nélkül dekódolható jel, a szignál tartalmazza a szinkronizáláshoz szükséges információt.
|
||||
\end{itemize}
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.6\textwidth]{img/szinkronizacio.png}
|
||||
\caption{Szinkronizáció szükségessége}
|
||||
\end{figure}
|
||||
\end{description}
|
||||
\item[Átviteli közegek] \hfill \\
|
||||
\begin{description}
|
||||
\item[Vezetékes] \hfill
|
||||
\begin{itemize}
|
||||
\item mágneses adathordozók \\
|
||||
sávszélesség jó, késleltetés nagy
|
||||
\item sodort érpár \\
|
||||
Főként távbeszélőrendszerekben használatos; dupla rézhuzal; analóg és digitális jelátvitel
|
||||
\item Koaxális kábel\\
|
||||
Nagyobb sebesség és távolság érhető el, mint a sodorttal; analóg és
|
||||
digitális jelátvitel
|
||||
\item Fényvezető szálak\\
|
||||
Fényforrás, átviteli közeg és detektor; fényimpulzus 1-es bit, nincs
|
||||
fényimpulzus 0-s bit
|
||||
\end{itemize}
|
||||
\item[Vezetékes nélküli] \hfill
|
||||
\begin{itemize}
|
||||
\item Rádiófrekvenciás átvitel \\
|
||||
egyszerűen előállíthatóak; nagy távolság; kültéri és beltéri alkalmazhatóság; frekvenciafüggő terjedési jellemzők
|
||||
\item Mikrohullámú átvitel\\
|
||||
egyenes vonal mentén terjed; elhalkulás problémája; nem drága
|
||||
\item Infravörös és milliméteres hullámú átvitel \\
|
||||
kistávolságú átvitel esetén; szilárd tárgyakon nem hatol át
|
||||
\item Látható fényhullámú átvitel\\
|
||||
lézerforrás + fényérzékelő; nagy sávszélesség, olcsó, nem engedélyköteles; időjárás erősen befolyásolhatja
|
||||
\end{itemize}
|
||||
\end{description}
|
||||
\item[Jelátvitel] \hfill
|
||||
\begin{itemize}
|
||||
\item Alapsáv \\
|
||||
A digitális jel direkt árammá vagy feszültséggé alakul. A jel minden frekvencián átvitelre kerül. Átviteli korlátok
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.8\textwidth]{img/alapsav.png}
|
||||
\caption{Digitális alapsávú átvitel struktúrája}
|
||||
\end{figure}
|
||||
\item Szélessáv \\
|
||||
Széles frekvencia tartományban történik az átvitel. A jel modulálására az alábbi lehetőségeket használhatjuk.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.8\textwidth]{img/szelessav.png}
|
||||
\caption{Digitális szélessávú átvitel struktúrája}
|
||||
\end{figure}
|
||||
|
||||
Modulációk:\\
|
||||
Egy szinuszos rezgés ábrázolása $T$ periódus idejű függvényre $g(t)=Asin(2\pi f t + \varphi)$ , ahol $A$ az amplitúdó, $f = \frac{1}{T}$ a frekvencia és $\varphi $ a fáziseltolás
|
||||
\begin{itemize}
|
||||
\item Amplitúdó moduláció \\
|
||||
Az $s(t)$ szignált a szinusz görbe amplitúdójaként kódoljuk, azaz:
|
||||
\begin{align*}
|
||||
f_A(t) = s(t) \cdot sin(2\pi f t + \varphi)
|
||||
\end{align*}
|
||||
Analóg szignál: amplitúdó moduláció\\
|
||||
Digitális szignál: amplitúdó keying(szignál erőssége egy diszkrét halmaz értékeinek megfelelően változik)
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.5\textwidth]{img/amplitudo_mod.png}
|
||||
\caption{Amplitúdó moduláció}
|
||||
\end{figure}
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.5\textwidth]{img/amplitudo_key.png}
|
||||
\caption{Amplitúdó keying}
|
||||
\end{figure}
|
||||
\item Frekvencia moduláció \\
|
||||
Az $s(t)$ szignált a szinusz görbe frekvenciájában kódoljuk, azaz:
|
||||
\begin{align*}
|
||||
f_F(t) = a \cdot sin(2\pi s(t) t + \varphi)
|
||||
\end{align*}
|
||||
Analóg szignál: frekvencia moduláció\\
|
||||
Digitális szignál: frekvencia-eltolás keying(például egy diszkrét halmaz szimbólumaihoz különböző frekvenciák hozzárendelésével)
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.5\textwidth]{img/frekvencia_mod.png}
|
||||
\caption{Frekvencia moduláció}
|
||||
\end{figure}
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.5\textwidth]{img/frekvencia_key.png}
|
||||
\caption{Frekvencia keying}
|
||||
\end{figure}
|
||||
\item Fázis moduláció \\
|
||||
Az $s(t)$ szignált a szinusz görbe fázisában kódoljuk, azaz:
|
||||
\begin{align*}
|
||||
f_P(t) = a \cdot sin(2\pi f t + s(t))
|
||||
\end{align*}
|
||||
Analóg szignál: fázis moduláció (nem igazán használják)\\
|
||||
Digitális szignál: fázis-eltolás keying ( például egy diszkrét halmaz szimbólumaihoz különböző fázisok hozzárendelésével)
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.5\textwidth]{img/fazis_mod.png}
|
||||
\caption{Fázis moduláció}
|
||||
\end{figure}
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.5\textwidth]{img/fazis_key.png}
|
||||
\caption{Fázis-eltolás keying}
|
||||
\end{figure}
|
||||
\end{itemize}
|
||||
|
||||
Digitális és analóg jelek összehasonlítása: \\
|
||||
Digitális átvitel: Diszkrét szignálok véges halmazát
|
||||
használja (például feszültség vagy áramerősség
|
||||
értékek).\\
|
||||
Analóg átvitel: Szignálok folytonos halmazát használja
|
||||
(például feszültség vagy áramerősség a vezetékben) \\
|
||||
Digitális esetében lehetőség van a vételpontosság helyreállítására illetve az eredeti jel helyreállítására, míg az analógnál a fellépő hibák önmagukat erősíthetik.
|
||||
\end{itemize}
|
||||
\end{description}
|
||||
\section{Adatkapcsolati réteg}
|
||||
\begin{description}
|
||||
\item[Definíció] \hfill \\
|
||||
Az adatkapcsolati réteg feladata jól definiált szolgálati interfész biztosítása a hálózati rétegnek, melynek három fázisa van:
|
||||
\begin{itemize}
|
||||
\item nyugtázatlan összeköttetés alapú szolgálat
|
||||
\item nyugtázott összeköttetés nélküli szolgálat
|
||||
\item nyugtázott összeköttetés alapú szolgálat
|
||||
\end{itemize}
|
||||
Továbbá az átviteli hibák kezelése és az adatforgalom szabályozása (elárasztás elkerülése).
|
||||
\item[Keretképzés] \hfill \\
|
||||
A fizikai réteg nem garantál hibamentességet, az adatkapcsolati réteg feladata a hibajelzés illetve a szükség szerint javítás. Erre megoldás: keretekre tördelése a bitfolyamnak, és ellenőrző összegek számítása. A keretezés nem egyszerű feladat, mivel megbízható időzítésre nem nagyon van lehetőség. Négy lehetséges módszer:
|
||||
\begin{enumerate}
|
||||
\item Karakterszámlálás \\
|
||||
A keretben lévő karakterek számát a keret fejlécében adjuk meg. Így a vevő adatkapcsolati rétege tudni fogja a keret végét. Probléma: nagyon érzékeny a hibára a módszer.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.7\textwidth]{img/karakterszamlalas.png}
|
||||
\caption{Karakterszámlálás}
|
||||
\end{figure}
|
||||
\item Kezdő és végkarakterek karakterbeszúrással \\
|
||||
Különleges bájtokat helyezünk el a keret elejének és végének jelzésére, aminek a neve jelző bájt(flagbyte). Az adatfolyamban szereplő speciális bájtokhoz ESC bájtot használnak.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.6\textwidth]{img/karakterbeszuras.png}
|
||||
\caption{Kezdő és végkarakterek karakterbeszúrással}
|
||||
\end{figure}
|
||||
\item Kezdő és végjelek bitbeszúrása \\
|
||||
Minden keret egy speciális bitmintával kezdődik (flagbájt, 01111110) és minden egymást követő 5 hosszú folytonos 1-es bit sorozat után beszúr egy 0-át.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.9\textwidth]{img/bitbeszuras.png}
|
||||
\caption{Kezdő és végjelek bitbeszúrásal}
|
||||
\end{figure}
|
||||
\item Fizikai rétegbeli kódolás-sértés \\
|
||||
Olyan hálózatokban használható, ahol a fizikai rétegbeli kódolás redundanciát tartalmaz.
|
||||
\end{enumerate}
|
||||
\item[Hibakezelés] \hfill \\
|
||||
Hibakezelés szempontjából a következő két esetet kell vizsgálnunk. A keretek megérkeztek-e a célállomás hálózati rétegéhez, illetve helyes sorrendben érkeztek-e meg. Ehhez valamilyen visszacsatolás szükséges a vevő és az adó között. (például nyugták). Időkorlátokat vezetünk be az egyes lépésekhez. Hiba estén a csomagot újraküldjük. Többszörös vétel lehet, amin segíthet a sorszámok használata. Az adatkapcsolati réteg feladata a hibakezelés szempontjából, hogy az időzítőket és számlálókat úgy kezelje, hogy biztosítani tudja a keretek pontosan egyszeri (nem több és nem kevesebb) megérkezését a célállomás hálózati rétegéhez.
|
||||
|
||||
Bithibák:
|
||||
\begin{itemize}
|
||||
\item egyszerű bithiba \\
|
||||
Az adategység 1 bitje nulláról egyre avagy egyről nullára változik.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.2\textwidth]{img/egyszeru_bithiba.png}
|
||||
\caption{Egyszerű bithiba}
|
||||
\end{figure}
|
||||
\item csoportos bithiba \\
|
||||
Egy olyan folytonos szimbólum sorozatot, amelynek az első és utolsó szimbóluma hibás, és nem létezik ezen két szimbólummal határolt részsorozatban olyan $m$ hosszú részsorozat, amelyet helyesen fogadtunk, $m$ hosszú csoportos bithibának nevezünk.
|
||||
\end{itemize}
|
||||
|
||||
Hiba jelzés és javítás:\\
|
||||
Kétféle hibakezelési stratégia létezik. Ezek a hibajelző (redundáns információ mellékelése) és hibajavító kódok (adatok közé iktatott redundancia).
|
||||
[Megbízható csatornákon a hibajelzés olcsóbb. (csomagot inkább újraküldjük). A kevésbé megbízható csatornákon a hibajavításos módszer célszerűbb]
|
||||
\begin{itemize}
|
||||
\item Hamming-távolság, Hamming-korlát \\
|
||||
Küldendő keret $m$ bitet tartalmaz. Redundáns bitek száma $r$. Tehát az elküldött keret: $n = m+r$ bit.
|
||||
|
||||
Hamming-távolság: \\
|
||||
Az olyan bitpozíciók számát, amelyeken a két kódszóban különböző bitek állnak, a két kódszó Hamming távolságának nevezzük. Jelölés: $d(x,y)$\\
|
||||
Legyen $S$ az egyenlő hosszú bitszavak halmaza. $S$ Hamming-távolsága:
|
||||
\begin{align*}
|
||||
d(S) := \min_{x,y, \in S \ \land \ x \neq y} d(x,y)
|
||||
\end{align*}
|
||||
|
||||
d(S) = 1 esetén: \\
|
||||
Nincs hibafelismerés, ugyanis megengedett kódszóból 1 bit megváltoztatásával megengedett kódszó áll elő.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.4\textwidth]{img/hamming1.png}
|
||||
\caption{Kód Hamming-távolsága = 1}
|
||||
\end{figure}
|
||||
d(S) = 2 esetén: \\
|
||||
Ha az $x$ kódszóhoz létezik olyan $v$ nem megengedett kódszó, amelyre $d(u,x)=1$, akkor hiba történt. Ha $x$ és $y$ megengedett kódszavak (távolságuk minimális = 2), akkor a következő összefüggésnek teljesülnie kell:
|
||||
\begin{align*}
|
||||
2 = d(x,y) \leq d(x,v)+d(v,y)
|
||||
\end{align*}
|
||||
Azaz egy bithiba felismerhető, de nem javítható.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.4\textwidth]{img/hamming2.png}
|
||||
\caption{Kód Hamming-távolsága = 2}
|
||||
\end{figure}
|
||||
|
||||
d(S) = 3 esetén: \\
|
||||
Ekkor minden $u$, melyre $d(x,u)=1$ és $d(u,y) > 1$ nem megengedett. Ekkor három lehetőség áll fent:
|
||||
\begin{itemize}
|
||||
\item x került átvitelre és 1 bit hibával érkezett
|
||||
\item y került átvitelre és 2 bit hibával érkezett
|
||||
\item valami más került átvitelre és legalább 2 bit hibával érkezett
|
||||
\end{itemize}
|
||||
De valószínűbb, hogy $x$ került átvitelre, tehát ez egy 1 bit hiba javító, 2 bit hiba felismerő kód.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.4\textwidth]{img/hamming3.png}
|
||||
\caption{Kód Hamming-távolsága = 3}
|
||||
\end{figure}
|
||||
|
||||
Hamming-korlát: \\
|
||||
$ C \subseteq \{0,1\}^n$ és $d(C) = k$. Ekkor a kódszavak $\frac{k-1}{2}$ sugarú környezeteiben található bitszavak egymással diszjunkt halmazainak uniója legfeljebb az $n$-hosszú bitszavak halmazát adhatja ki. Vagyis formálisan:
|
||||
\begin{align*}
|
||||
|C|\sum_{i=0}^{\lfloor\frac{k-1}{2}\rfloor}\dbinom{n}{i} \leq 2^n
|
||||
\end{align*}
|
||||
|
||||
\begin{itemize}
|
||||
\item Hibafelismerés: \\
|
||||
$d$ bit hiba felismeréséhez a keretek halmazában legalább $d+1$ Hamming távolság szükséges.
|
||||
|
||||
\item Hibajavítás: \\
|
||||
$d$ bit hiba javításához a megengedett keretek halmazában legalább $2d+1$ Hamming távolság szükséges.
|
||||
|
||||
\item Kód rátája: \\
|
||||
$R_S = \frac{log_2|S|}{n}$ a kód rátája ($S \subseteq \{0,1\}^n$) - hatékonyságot karakterizálja
|
||||
|
||||
\item Kód távolsága: \\
|
||||
$\delta_S = \frac{d(S)}{n}$ a kód távolsága ($S \subseteq \{0,1\}^n$) - hibakezelést karakterizálja
|
||||
\end{itemize}
|
||||
A jó kódnak a rátája és a távolsága is nagy.
|
||||
\item Paritásbit \\
|
||||
A paritásbit olyan bit, melyet a kódszóban lévő egyesek száma alapján választunk.
|
||||
\begin{itemize}
|
||||
\item Odd Parity - ha az egyesek száma páratlan, akkor 0 befűzése; egyébként 1-es befűzése
|
||||
\item Even Parity - ha az egyesek száma páros, akkor 0 befűzése; egyébként 1-es befűzése
|
||||
\end{itemize}
|
||||
Egy paritást használó módszer az ún. Hamming módszer:\\
|
||||
A kódszó bitjeit számozzuk meg (1-gyel kezdődően). A 2 hatványú pozíciókon az ellenőrző bitek kapnak helyet, a maradék helyekre az üzenet bitjei kerülnek. Mindegyik ellenőrző bit a bitek egy csoportjának (beleértve önmagát is) a paritását állítja be párosra (vagy páratlanra).\\
|
||||
A csoportok a következőképp alakulnak:
|
||||
\begin{itemize}
|
||||
\item 1. bit: Minden első egyhosszú bitsorozat az első bittől kezdve (tehát: 1,3,5,7,...)
|
||||
\item 2. bit: Minden első kéthosszú bitsorozat a második bittől kezdve (tehát: 2-3,6-7,10-11)
|
||||
\item 4. bit: Minden első négyhosszú bitsorozat a negyedik bittől kezdve (tehát: 4-7,12-15)
|
||||
\item stb.
|
||||
\end{itemize}
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.8\textwidth]{img/paritasbit.png}
|
||||
\caption{Paritásbitek csoportjai}
|
||||
\end{figure}
|
||||
Példa:\\
|
||||
Legyen az átküldendő üzenet: 1000101 \\
|
||||
Ekkor a kódszó a következőképp alakul: \\
|
||||
{\color[rgb]{1,0,0}$\heartsuit\heartsuit$}1{\color[rgb]{1,0,0}$\heartsuit$}000{\color[rgb]{1,0,0}$\heartsuit$}101\\
|
||||
A 8. bit a 8-11 bitsorozat paritását állítja be párosra:\\
|
||||
{\color[rgb]{1,0,0}$\heartsuit\heartsuit$}1{\color[rgb]{1,0,0}$\heartsuit$}000{\color[rgb]{0,0,1}0101}\\
|
||||
A 4. bit a 4-7 bitsorozat paritását állítja be párosra:\\
|
||||
{\color[rgb]{1,0,0}$\heartsuit\heartsuit$}1{\color[rgb]{0,0,1}0000}0101\\
|
||||
A 2. bit a 2-3, 6-7, 10-11 bitsorozat paritását állítja be párosra:\\
|
||||
{\color[rgb]{1,0,0}$\heartsuit$}{\color[rgb]{0,0,1}01}00{\color[rgb]{0,0,1}00}01{\color[rgb]{0,0,1}01}\\
|
||||
Az 1. bit az 1,3,5,7,9,11 bitsorozat paritását állítja be párosra: \\
|
||||
{\color[rgb]{0,0,1}1}0{\color[rgb]{0,0,1}1}0{\color[rgb]{0,0,1}0}0{\color[rgb]{0,0,1}0}0{\color[rgb]{0,0,1}1}0{\color[rgb]{0,0,1}1}\\
|
||||
|
||||
Tehát a elküldendő bitsorozat:
|
||||
{\color[rgb]{1,0,0}10}1{\color[rgb]{1,0,0}0}000{\color[rgb]{1,0,0}0}101\\
|
||||
|
||||
\item CRC - Polinom-kód, azaz ciklikus redundancia \\
|
||||
A bitsorozatokat egy $\mathbb{Z}_2$ feletti polinom ($M(x)$) együtthatóinak tekintjük. Definiálunk egy $G(x)$ $r$ fokú generátorpolinomot, melyet a vevő és küldő egyaránt ismer.
|
||||
\begin{enumerate}
|
||||
\item Fűzzünk $r$ darab 0 bitet a keret alacsony helyi értékű végéhez. Azaz vegyük az $x^rM(x)$ polinomot (ez már $m+r$ fokú)
|
||||
\item Osszuk el $x^rM(x)$-et $G(x)$-szel (mod 2).
|
||||
\item A maradékot (mely mindig r vagy kevesebb bitet tartalmaz) vonjuk ki $x^rM(x)$-ből (mod 2). Így az eredeti keret végére egy r hosszú ellenőrző összeg kerül. Legyen ez a polinom $T(x)$.
|
||||
\item A vevő egy $T(x)+E(x)$-nek megfelelő polinomot kap (ahol $E(x)$ a hiba polinom). Ezt elosztva a generátorpolinommal egy $R(x)$ polinomot kapunk. Ha ez a polinom nem nulla, akkor hiba történt.
|
||||
\end{enumerate}
|
||||
A $G(x)$ többszöröseinek megfelelő bithibákat nem ismerjük fel.
|
||||
\end{itemize}
|
||||
\item[Protokollok] \hfill
|
||||
\begin{description}
|
||||
\item[Elemi adatkapcsolati protokollok] \hfill
|
||||
\begin{itemize}
|
||||
\item Korlátozás nélküli szimplex protokoll\\
|
||||
Környezet:
|
||||
\begin{itemize}
|
||||
\item Adó, vevő: mindig kész.
|
||||
\item Nincs feldolgozási idő
|
||||
\item Végtelen puffer
|
||||
\item Nincs keret rontás, vesztés
|
||||
\end{itemize}
|
||||
|
||||
Protokoll:
|
||||
\begin{itemize}
|
||||
\item Nincs sorszám/nyugta
|
||||
\item Küldő végtelen ciklusban küldi kifele a kereteket folyamatosan
|
||||
\item A vevő kezdetben várakozik az első keret megérkezésére, keret érkezésekor a hardver puffer tartalmát változóba teszi és az adatrészt továbbküldi a hálózati rétegnek.
|
||||
\end{itemize}
|
||||
\item Szimplex megáll és vár protokoll \\
|
||||
Környezet:
|
||||
\begin{itemize}
|
||||
\item Adó, vevő hálózati rétegei: mindig kész.
|
||||
\item A vevőnek $\delta t$ időre van szüksége a bejövő keret feldolgozására.
|
||||
\item Nincs pufferelés és sorban állás sem
|
||||
\item Nincs keret rontás, vesztés
|
||||
\end{itemize}
|
||||
|
||||
Protokoll:
|
||||
\begin{itemize}
|
||||
\item Nincs sorszám/nyugta
|
||||
\item Küldő egyesével küld, következőt csak a nyugtát követően.
|
||||
\item A vevő kezdetben várakozik az első keret megérkezésére, keret érkezésekor a hardver puffer tartalmát változóba teszi és az adatrészt továbbküldi a hálózati rétegnek, végül nyugtázza a keretet.
|
||||
\end{itemize}
|
||||
\item Szimplex protokoll zajos csatornához\\
|
||||
Környezet:
|
||||
\begin{itemize}
|
||||
\item Adó, vevő hálózati rétegei: mindig kész.
|
||||
\item A vevőnek $\delta t$ időre van szüksége a bejövő keret feldolgozására.
|
||||
\item Nincs pufferelés és sorban állás sem
|
||||
\item Keret sérülhet, elveszhet
|
||||
\end{itemize}
|
||||
|
||||
Protokoll:
|
||||
\begin{itemize}
|
||||
\item Nincs sorszám/nyugta
|
||||
\item Küldő egyesével küld, addig nem küld újat, míg határidőn belül nyugtát nem kap. Határidő után újraküldi a keretet.
|
||||
\item A vevő kezdetben várakozik az első keret megérkezésére, keret érkezésekor a hardver puffer tartalmát változóba teszi, leellenőrzi a kontroll összeget:
|
||||
\begin{itemize}
|
||||
\item Nincs hiba: az adatrészt továbbküldi a hálózati rétegnek, végül nyugtázza a keretet.
|
||||
\item Van hiba: eldobja a keretet és nem nyugtáz
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
\item[Csúszóablakos protokoll] \hfill \\
|
||||
Egy adott időpontban egyszerre több keret is átviteli állapotban lehet. A fogadó $n$ keretnek megfelelő méretű puffert allokál. A küldőnek legfeljebb $n$, azaz ablak méretnyi, nyugtázatlan keretet küldése engedélyezett. A keret sorozatbeli pozíciója adja a keret címkéjét. (sorozatszám).
|
||||
A fogadónak a hibás, illetve a nem megengedett sorozatszámmal érkező kereteket el kell dobnia. A küldő nyilvántartja a küldhető sorozatszámok halmazát (adási ablak). A fogadó nyilvántartja a fogadható sorozatszámok halmazát (vételi ablak). Az adási ablak minden küldéssel szűkül, illetve nő egy nyugta érkezésével.
|
||||
|
||||
Mi van ha egy hosszú folyam közepén történik egy keret hiba?
|
||||
\begin{enumerate}
|
||||
\item "visszalépés N-nel" stratégia\\
|
||||
Az összes hibás keret utáni keretet eldobja és nyugtát sem küld róluk. Mikor az adónak lejár az időzítője, akkor újraküldi az összes nyugtázatlan keretet, kezdve a sérült vagy elveszett kerettel. Hátrány: Nagy sávszélességet pazarolhat el, ha nagy a hibaarány.
|
||||
\item "szelektív ismétlés" stratégia \\
|
||||
A hibás kereteket eldobja, de a jó kereteket a hibás után puffereli. Mikor az adónak lejár az időzítője, akkor a legrégebbi nyugtázatlan keretet küldi el újra. Hátrány: Nagy memória igény nagy vételi ablak esetén.
|
||||
\end{enumerate}
|
||||
|
||||
\item[Példák adatkapcsolati protokollokra] \hfill
|
||||
\begin{itemize}
|
||||
\item HDLC - High-level Data Link Control \\
|
||||
A HDLC protokoll 3 bites csúszó-ablak protokollt alkalmaz a sorszámozáshoz.
|
||||
Három típusú keretet használ:
|
||||
\begin{itemize}
|
||||
\item információs
|
||||
\item felügyelő
|
||||
\begin{itemize}
|
||||
\item nyugtakeret (RECIEVE READY)
|
||||
\item negatív nyugta keret (REJECT)
|
||||
\item vételre nem kész (RECIEVE NOT READY) - nyugtáz minden keretet a következőig
|
||||
\item szelektív elutasítás (SELECTIVE REJECT) - egy gy adott keret újraküldésére szólít fel
|
||||
\end{itemize}
|
||||
\item Számozatlan
|
||||
\end{itemize}
|
||||
|
||||
Általános keretfelépítése:
|
||||
\begin{itemize}
|
||||
\item FLAG bájt a keret határok jelzésére
|
||||
\item \textit{cím} mező - több vonallal rendelkező terminálok esetén van jelentősége
|
||||
\item \textit{vezérlés} mező - sorszámozás, nyugtázás és egyéb feladatok ellátására
|
||||
\item \textit{adat} mező - tetszőleges hosszú adat lehet
|
||||
\item \textit{ellenőrző összeg} mező - CRC kontrollösszeg (CRC-CCITT generátor polinom felhasználásával)
|
||||
\end{itemize}
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.8\textwidth]{img/hdlc_keret.png}
|
||||
\caption{HDLC keret felépítése}
|
||||
\end{figure}
|
||||
\item PPP - Point-to Point Protocol \\
|
||||
A PPP protokoll három dolgot biztosít:
|
||||
\begin{itemize}
|
||||
\item Keretezési módszert (egyértelmű kerethatárok)
|
||||
\item Kapcsolatvezérlő protokollt (a vonalak felélesztésére, tesztelésére, az opció egyeztetésére és a vonalak elengedésére.)
|
||||
\item Olyan módot a hálózati réteg-opciók megbeszélésére, amely független az alkalmazott hálózati réteg-protokolltól.
|
||||
\end{itemize}
|
||||
Bájt alapú keretszerkezet használ (azaz a legkisebb adategység a bájt).
|
||||
Vezérlő mező alapértéke a számozatlan keretet jelzi. Protokoll mezőben protokoll kód lehet az LCP, NCP, IP, IPX, AppleTalkvagy más protokollhoz.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.8\textwidth]{img/ppp_keret.png}
|
||||
\caption{PPP keret felépítése}
|
||||
\end{figure}
|
||||
\end{itemize}
|
||||
\item[MAC - Media Access Control] \hfill \\
|
||||
Eddigi tárgyalásaink során pont-pont összeköttetést feltételeztünk. Most az adatszóró csatornát használó hálózatok tárgykörével foglalkozunk majd. A csatorna kiosztás történhet statikus vagy dinamikus módon.
|
||||
|
||||
Statikus esetben vagy Frekvenciaosztásos nyalábolást vagy időosztásos nyalábolást használnak. Frekvenciaosztásos esetben a sávszélességet osztják $N$ részre, és mindegyik felhasználó egy sávot kap. Időosztásos esetben az időegységet osztják $N$ részre és ezeket adják a felhasználóknak. Mind a két módszer löketszerű forgalom esetén nem tud hatékony lenni.
|
||||
|
||||
A továbbiakban a dinamikus csatorna kiosztási módszereket vizsgáljuk.
|
||||
\begin{itemize}
|
||||
\item Verseny protokollok \\
|
||||
N független állomás van, amelyeken egy program vagy egy felhasználó továbbítandó kereteket generál. Ha egy állomás generált egy keretet, akkor blokkolt állapotban marad mindaddig, amíg a keretet sikeresen nem továbbította. Egyetlen csatorna van, melyen mindenféle kommunikáció zajlik. Minden állomás tud adatot küldeni és fogadni ezen a csatornán. Ha két keret egy időben kerül átvitelre, akkor átlapolódnak, és az eredményül kapott jel értelmezhetetlenné válik. Ezt nevezzük ütközésnek. Ez minden állomás számára felismerhető. Az ütközésben érintett kereteket később újra kell küldeni. (Ezen a hibán kívül egyéb hiba nem történhet.)
|
||||
|
||||
Kétféle időmodellt különböztetünk meg:
|
||||
\begin{enumerate}
|
||||
\item Folytonos – Mindegyik állomás tetszőleges időpontban megkezdheti a küldésre kész keretének sugárzását.
|
||||
\item Diszkrét – Az időt diszkrét résekre osztjuk. Keret továbbítás csak időrés elején lehetséges. Az időrés lehet üres, sikeres vagy ütközéses
|
||||
\end{enumerate}
|
||||
|
||||
Az egyes állomások vagy rendelkeznek vivőjel érzékeléssel vagy nem. Ha nem, akkor az állomások nem tudják megvizsgálni a közös csatorna állapotát, ezért egyszerűen elkezdenek küldeni, ha van rá lehetőségük. Ha igen, akkor az állomások meg tudják vizsgálni a közös csatorna állapotát a küldés előtt. A csatorna lehet: foglalt vagy szabad. Ha a foglalt a csatorna, akkor nem próbálják használni az állomások, amíg fel nem szabadul
|
||||
|
||||
\begin{itemize}
|
||||
\item Egyszerű ALOHA \\
|
||||
A felhasználó akkor vihet át adatot, amikor csak szeretne. Ütközés esetén véletlen ideig várakozik az állomás, majd újra próbálkozik.
|
||||
|
||||
Keret idő–egy szabványos, fix hosszúságú keret átviteléhez szükséges idő
|
||||
|
||||
Egy keret akkor nem szenved ütközést, ha elküldésének első pillanatától kezdve egy keretideig nem próbálkozik más állomás keretküldéssel.
|
||||
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.6\textwidth]{img/egyszeru_aloha.png}
|
||||
\caption{Egyszerű ALOHA keret ütközések}
|
||||
\end{figure}
|
||||
\item Réselt ALOHA \\
|
||||
Az idő diszkrét, keretidőhöz igazodó időszeletek-re osztásával az ALOHA rendszer kapacitása megduplázható. A csatorna terhelésének kis növekedése is drasztikusan csökkentheti a médium teljesítményét.
|
||||
\item 1-prezisztens CSMA \\
|
||||
Vivőjel érzékelés van, azaz minden állomás belehallgathat a csatornába. Folytonos időmodellt használ a protokoll.
|
||||
|
||||
Algoritmus:
|
||||
\begin{enumerate}
|
||||
\item Keret leadása előtt belehallgat a csatornába:
|
||||
\begin{enumerate}
|
||||
\item Ha foglalt, akkor addig vár, amíg fel nem szabadul. Szabad csatorna esetén azonnal küld. (perzisztens)
|
||||
\item Ha szabad, akkor küld.
|
||||
\end{enumerate}
|
||||
\item Ha ütközés történik, akkor az állomás véletlen hosszú ideig vár, majd újrakezdi a keret leadását.
|
||||
\end{enumerate}
|
||||
\item Nem-prezisztens CSMA \\
|
||||
Vivőjel érzékelés van, azaz minden állomás belehallgathat a csatornába. Folytonos időmodellt használ a protokoll. Mohóságot kerüli, azaz nem küld azonnal, ha foglalt.
|
||||
|
||||
Algoritmus:
|
||||
\begin{enumerate}
|
||||
\item Keret leadása előtt belehallgat a csatornába:
|
||||
\begin{enumerate}
|
||||
\item Ha foglalt, akkor véletlen ideig vár (nem figyeli a forgalmat), majd kezdi előröl a küldési algoritmust. (nem-perzisztens)
|
||||
\item Ha szabad, akkor küld.
|
||||
\end{enumerate}
|
||||
\item Ha ütközés történik, akkor az állomás véletlen hosszú ideig vár, majd újrakezdi a keret leadását.
|
||||
\end{enumerate}
|
||||
\item p-prezisztens CSMA \\
|
||||
Vivőjel érzékelés van, azaz minden állomás belehallgathat a csatornába. Diszkrét időmodellt használ a protokoll.
|
||||
|
||||
Algoritmus:
|
||||
\begin{enumerate}
|
||||
\item Adás kész állapotban az állomás belehallgat a csatornába:
|
||||
\begin{enumerate}
|
||||
\item Ha foglalt, akkor vár a következő időrésig, majd megismétli az algoritmust.
|
||||
\item Ha szabad, akkor $p$ valószínűséggel küld, illetve $1-p$ valószínűséggel visszalép a szándékától a következő időrésig. Várakozás esetén a következő időrésben megismétli az algoritmust. Ez addig folytatódik, amíg el nem küldi a keretet, vagy amíg egy másik állomás el nem kezd küldeni, mert ilyenkor úgy viselkedik, mintha ütközés történt volna.
|
||||
\end{enumerate}
|
||||
\item Ha ütközés történik, akkor az állomás véletlen hosszú ideig vár, majd újrakezdi a keret leadását.
|
||||
\end{enumerate}
|
||||
\item CSMA/CD \\
|
||||
Ütközés érzékelés esetén meg lehessen szakítani az adást. Minden állomás küldés közben megfigyeli a csatornát, ha ütközést tapasztalna, akkor megszakítja az adást, és véletlen ideig várakozik, majd újra elkezdi leadni a keretét
|
||||
\end{itemize}
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.7\textwidth]{img/aloha_csma.jpg}
|
||||
\caption{ALOHA és CSMA protokollok összehasonlítása}
|
||||
\end{figure}
|
||||
\item Verseny mentes protokollok \\
|
||||
Motiváció: Az ütközések hátrányosan hatnak a rendszer teljesítményére, és a CSMA/CD nem mindenhol alkalmazható.
|
||||
|
||||
N állomás van. Az állomások 0-ától N-ig egyértelműen sorszámozva vannak. Réselt időmodellt feltételezünk.
|
||||
\begin{itemize}
|
||||
\item Egy helyfoglalásos protokoll \\
|
||||
Ha az i-edikállomás küldeni szeretne, akkor a i-edikversengési időrésben egy 1-es bit elküldésével jelezheti. Így a versengési időszak végére minden állomás ismeri a küldőket. A küldés a sorszámok szerinti sorrendben történik meg.
|
||||
\item Bináris visszaszámlálás protokoll \\
|
||||
Minden állomás azonos hosszú bináris azonosítóval rendelkezik. A forgalmazni kívánó állomás elkezdi a bináris címét bitenként elküldeni a legnagyobb helyi értékű bittel kezdve. Az azonos pozíciójú bitek logikai VAGY kapcsolatba lépnek ütközés esetén. Ha az állomás nullát küld, de egyet hall vissza, akkor feladja a küldési szándékát, mert van nála nagyobb azonosítóval rendelkező küldő.
|
||||
\end{itemize}
|
||||
\item Korlátozott verseny protokollok \\
|
||||
Olyan protokoll, amely kis terhelés esetén versenyhelyzetes technikát használ a kis késleltetés érdekében, illetve nagy terhelés mellett ütközésmentes technikát alkalmaz a csatorna jó kihasználása érdekében.
|
||||
\begin{itemize}
|
||||
\item Adaptív fabejárás \\
|
||||
Minden állomást egy egyértelmű, bináris ID reprezentál. Az ID-k egy (bináris) fa leveleinek felelnek meg. Az időrések a fa egyes csomópontjaihoz vannak rendelve Minden időrésben megvizsgáljuk az adott csomópont alatti részfát. A fa egy $u$ csomópontjánál 3 esetet
|
||||
különböztethetünk meg:
|
||||
\begin{itemize}
|
||||
\item Egy állomás sem küld az $u$ részfában.
|
||||
\item Pontosan egy állomás küld az $u$ részfában.
|
||||
\item Több állomás küld az $u$ részfában. Ezt nevezzük kollíziónak.
|
||||
\end{itemize}
|
||||
Kollízió esetén hajtsuk végre az ellenőrzést $u$ bal, és jobb oldali gyerekére egyaránt.
|
||||
|
||||
Ezzel a módszerrel könnyen megállapítható, hogy melyik állomás küldhet az adott időszeletben.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.5\textwidth]{img/adaptivfa.png}
|
||||
\caption{Adaptív fabejárás protokoll bináris fája}
|
||||
\end{figure}
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
\end{description}
|
||||
\end{description}
|
||||
\section{Hálózati réteg}
|
||||
\begin{description}
|
||||
\item[Definíció] \hfill \\
|
||||
A hálózati réteg fő feladata a csomagok továbbítása a forrás és a cél között. Ez a legalacsonyabb olyan réteg, amely két végpont közötti átvitellel foglalkozik. Ismernie kell a kommunikációs alhálózat topológiáját. Ügyelni kell, hogy ne terheljen túl se bizonyos kommunikációs útvonalakat, se bizonyos routereket úgy, hogy mások tétlen maradnak.
|
||||
|
||||
A szállítási réteg felé nyújtott szolgálatok:
|
||||
\begin{itemize}
|
||||
\item Függetlenek az alhálózatok kialakításától
|
||||
\item Eltakarják a jelen lévő alhálózatok számát, típusát és topológiáját
|
||||
\item A szállítási réteg számára rendelkezésre bocsájtott hálózati címek egységes számozási rendszert kell alkotnak
|
||||
\end{itemize}
|
||||
\item[Forgalom irányítás típusai] \hfill
|
||||
\begin{itemize}
|
||||
\item Hierarchikus forgalomirányítás\\
|
||||
Routhereket tartományokra osztjuk. A saját tartományát az összes router ismeri, de a többi belső szerkezetéről nincs tudomása. Nagy hálózatok esetén többszintű hierarchia lehet szükséges.
|
||||
\item Adatszóró forgalomirányítás\\
|
||||
egy csomag mindenhová történő egyidejű küldése.
|
||||
\item Többküldéses forgalomirányítás\\
|
||||
Egy csomag meghatározott csoporthoz történő egyidejű küldése.
|
||||
|
||||
\end{itemize}
|
||||
|
||||
\item[Forgalom irányító algoritmusok] \hfill \\
|
||||
A hálózati réteg szoftverének azon része, amely azért a döntésért felelős, hogy a bejövő csomag melyik kimeneti vonalon kerüljön továbbításra. A folyamat két lépésre bontható:
|
||||
\begin{enumerate}
|
||||
\item Forgalomirányító táblázatok feltöltése és karbantartása.
|
||||
\item Továbbítás
|
||||
\end{enumerate}
|
||||
|
||||
A forgalomirányító algoritmusok osztályai:
|
||||
\begin{enumerate}
|
||||
\item Adaptív algoritmusok
|
||||
\begin{enumerate}
|
||||
\item távolság alapú
|
||||
\item kapcsolat alapú
|
||||
\end{enumerate}
|
||||
A topológia és rendszerint a forgalom is befolyásolhatja a döntést.
|
||||
\item Nem-adaptív algoritmusok \\
|
||||
Offline meghatározás, betöltés a router-ekbe induláskor
|
||||
\end{enumerate}
|
||||
|
||||
\begin{description}
|
||||
\item[Dijkstra algoritmus] \hfill \\
|
||||
A Dijkstra algoritmus egy statikus algoritmus, melynek célja két csomópont közötti legrövidebb út meghatározása.
|
||||
|
||||
Minden csomópontot felcímkézünk a kezdőpontból az addig megtalált legrövidebb út hosszával. Az algoritmus működése során a címkék változhatnak az utak megtalálásával. Két fajta címkét különböztetünk meg: ideiglenes és állandó. Kezdetben minden címke ideiglenes. A legrövidebb út megtalálásakor a címke állandó címkévé válik, és továbbá nem változik.
|
||||
\item[Elárasztás algoritmus] \hfill \\
|
||||
Elárasztás algoritmusa egy statikus algoritmus.
|
||||
|
||||
Minden bejövő csomagot minden kimenő vonalon továbbítunk kivéve azon, amin érkezett. Így azonban nagyon sok duplikátum keletkezne. Ezért
|
||||
\begin{itemize}
|
||||
\item Ugrásszámlálót vezetünk be, melyet minden állomás eggyel csökkent. Ha 0-ra csönnen, eldobják.
|
||||
\item Az állomások nyilvántartják a már kiküldött csomagokat. Így egy csomagot nem küldenek ki többször.
|
||||
\end{itemize}
|
||||
\item[Elosztott Bellman-Ford algoritmus] \hfill \\
|
||||
Az Elosztott Bellman-Ford algoritmus adaptív, távolság alapú forgalomirányító algoritmus. Minden csomópont csak a közvetlen szomszédjaival kommunikálhat. Minden állomásnak van saját távolság vektora. Ezt periodikusan elküldi a direkt szomszédoknak. Minden router ismeri a közvetlen szomszédjaihoz a költséget. A kapott távolság vektorok alapján minden csomópont aktualizálja a saját vektorát.
|
||||
\item[Kapcsolatállapot alapú forgalomirányítás] \hfill \\
|
||||
A kapcsolatállapot alapú forgalomirányító algoritmusnak a motivációja, hogy a távolság alapú algoritmusok lassan konvergáltak, illetve az eltérő sávszélek figyelembevétele. \\
|
||||
A kapcsolatállapot alapú forgalomirányító algoritmus lépései:
|
||||
\begin{enumerate}
|
||||
\item Szomszédok felkutatása, és hálózati címeik meghatározása
|
||||
\item Megmérni a késleltetést vagy költséget minden szomszédhoz
|
||||
\item Egy csomag összeállítása a megismert információkból
|
||||
\item Csomag elküldése az összes többi router-nek
|
||||
\item Kiszámítani a legrövidebb utat az összes többi router-hez.
|
||||
\end{enumerate}
|
||||
\end{description}
|
||||
\item[Hálózat réteg az Interneten] \hfill \\
|
||||
A hálózati réteg szintjén az internet autonóm rendszerek összekapcsolt együttesének tekinthető. Nincs igazi szerkezete, de számos főbb gerinchálózata létezik. A gerinchálózatokhoz csatlakoznak a területi illetve regionális hálózatok. A regionális és területi hálózatokhoz csatlakoznak az egyetemeken, vállalatoknál és az internet szolgáltatóknál lévő LAN-ok.
|
||||
|
||||
Az internet protokollja, az IP.
|
||||
|
||||
Az Interneten a kommunikáció az alábbi módon működik:
|
||||
\begin{enumerate}
|
||||
\item A szállítási réteg viszi az adatfolyamokat és datagramokra tördeli azokat.
|
||||
\item Minden datagram átvitelre kerül az Interneten, esetleg menet közben kisebb egységekre darabolva.
|
||||
\item A célgép hálózati rétege összeállítja az eredeti datagramot, majd átadja a szállítási rétegének.
|
||||
\item A célgép szállítási rétege beilleszti a datagramot a vételi folyamat bemeneti adatfolyamába.
|
||||
\end{enumerate}
|
||||
|
||||
Internet Protokoll - IP
|
||||
\begin{itemize}
|
||||
\item Az IP fejrésze:
|
||||
\begin{itemize}
|
||||
\item verzió:\\
|
||||
IP melyik verzióját használja
|
||||
\item IHL: \\
|
||||
a fejléc hosszát határozza meg
|
||||
\item szolgálat típusa: \\
|
||||
szolgálati osztályt jelöl
|
||||
\item teljes hossz: \\
|
||||
fejléc és adatrész együttes hossza bájtokban
|
||||
\item azonosítás: \\
|
||||
egy datagram minden darabja ugyanazt az azonosításértéket hordozza.
|
||||
\item DF: \\
|
||||
"ne darabold" flag a router-eknek
|
||||
\item MF: \\
|
||||
"több darab" flag minden darabban be kell legyen állítva, kivéve az utolsót.
|
||||
\item darabeltolás: \\
|
||||
a darab helyét mutatja a datagramon belül.
|
||||
\item élettartam: \\
|
||||
másodpercenként kellene csökkenteni a mező értékét, minden ugrásnál csökkentik eggyel az értékét
|
||||
\item protokoll: \\
|
||||
szállítási réteg protokolljának azonosítóját tartalmazza
|
||||
\item ellenőrző összeg: \\
|
||||
a router-eken belüli rossz memóriaszavak által előállított hibák kezelésére használt ellenőrző összeg a fejrészre, amelyet minden ugrásnál újra kell számolni
|
||||
\item forrás cím és cél cím: \\
|
||||
IP cím
|
||||
\item opciók: \\
|
||||
következő verzió bővíthetősége miatt hagyták benne.
|
||||
\end{itemize}
|
||||
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.8\textwidth]{img/ip_fejresz.png}
|
||||
\caption{IPv4 fejléce}
|
||||
\end{figure}
|
||||
|
||||
\item IP cím \\
|
||||
Minden hoszt és minden router az Interneten rendelkezik egy IP-címmel, amely a hálózat számát és a hoszt számát kódolja. 4 bájton ábrázolják az IP-címet. Az IP-t pontokkal elválasztott decimális rendszerben írják. (Például: 192.168.0.1) Van pár speciális cím (ábra \ref{fig:ip_spec_cimek}).
|
||||
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.8\textwidth]{img/ip_spec_cimek.png}
|
||||
\caption{Speciális IP címek}
|
||||
\label{fig:ip_spec_cimek}
|
||||
\end{figure}
|
||||
|
||||
Alhálózatok:\\
|
||||
Az azonos hálózatban lévő hosztok ugyanazzal a hálózatszámmal rendelkeznek. Egy hálózat belső felhasználás szempontjából több részre osztódhat, de a külvilág számára egyetlen hálózatként jelenik meg. Azonosításnál az alhálózati maszk ismerete kell a routernek. A forgalomirányító táblázatba a router-eknél (hálózat,0) és (saját hálózat, hoszt) alakú bejegyzések. Ha nincs találat, akkor az alapértelmezett router felé továbbítják a csomagot.\\
|
||||
|
||||
IP címek fogyása:\\
|
||||
Az IP címek gyorsan fogytak. Megoldás: osztályok nélküli környezetek közötti forgalomirányítás (CIDR). A forgalomirányítás megbonyolódik: Minden bejegyzés egy 32-bites maszkkal egészül ki. Egy bejegyzés innentől egy hármassal jellemezhető: (ip-cím, alhálózati maszk, kimeneti vonal). Új csomag esetén a cél címből kimaszkolják az alhálózati címet, és találat esetén a leghosszabb illeszkedés felé továbbítják.
|
||||
|
||||
Másik módszer a NAT, ami gyors javítás az IP címek elfogyásának problémájára. Az internet forgalomhoz minden cégnek egy vagy legalábbis kevés IP-címet adnak, míg vállalaton belül minden számítógéphez egyedi IP-címet használnak a belső forgalomirányításra: \\
|
||||
10.0.0.0 – 10.255.255.255 : 16 777 216 egyedi cím\\
|
||||
172.16.0.0 – 172.31.255.255 : 1 048 576 egyedi cím\\
|
||||
192.168.0.0 – 192.168.255.255 : 65 536 egyedi cím\\
|
||||
|
||||
IPv6:\\
|
||||
Az IPv4-gyel szemben 16 bájt hosszú címeket használ; 8 darab, egyenként négy-négy hexadecimális számjegyből álló csoportként írjuk le. (Például: 8000:0000:0000:0000:0123:4567:89AB:CDEF) Az IP fejléc egyszerűsödött, amely lehetővé teszi a router-eknek a gyorsabb feldolgozást. A biztonság irányába jelentős lépés történt.
|
||||
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.8\textwidth]{img/ipv6.png}
|
||||
\caption{IPv6 fejléce}
|
||||
\end{figure}
|
||||
|
||||
|
||||
\end{itemize}
|
||||
\item[Protokollok] \hfill
|
||||
\begin{itemize}
|
||||
\item Internet Control Message Protocol - ICMP \\
|
||||
Feladata a váratlan események jelentése. Többféle ICMP-üzenetet definiáltak:
|
||||
\begin{itemize}
|
||||
\item Elérhetetlen cél
|
||||
\item Időtúllépés
|
||||
\item Paraméterprobléma
|
||||
\item Forráslefojtás
|
||||
\item Visszhang kérés
|
||||
\item Visszhang válasz
|
||||
\item etc.
|
||||
\end{itemize}
|
||||
\item Address Resolution Protocol - ARP \\
|
||||
Feladata az IP cím megfeleltetése egy fizikai címnek. Egy "Kié a 192.60.34.12-es IP-cím?" csomagot küld ki az Ethernet-re adatszórással az alhálózaton. Minden egyes host ellenőrzi,hogy övé-e a kérdéses IP-cím. Ha egyezik az IP a hoszt saját IP-jével, akkor a saját Ethernet címével válaszol.
|
||||
\item Reverse Address Resolution Protocol - RARP \\
|
||||
Feladatat a fizikai cím megfeleltetése egy IP címnek. Az újonnan indított állomás adatszórással csomagot küld ki az Ethernetre: "A 48-bites Ethernet-címem 14.04.05.18.01.25. Tudja valaki az IP címemet?" Az RARP-szerver pedig válaszol a megfelelő IP címmel, mikor meglátja a kérést.
|
||||
\item Open Shortest Path First - OSPF \\
|
||||
Az OSPF az AS-eken (Autonomus System) belüli forgalomirányításért felel. A hálózat topológiáját térképezi fel, és érzékeli a változásokat. A topológiát egy súlyozott irányított gráffal reprezentálja, melyben legolcsóbb utakat keres.
|
||||
\item Border Gateway Protocol - BGP \\
|
||||
Feladata hogy a politikai szempontok szerepet játsszanak az AS-ek közötti forgalomirányítási döntésekben (Pl. Az IBM-nél kezdődő illetve végződő forgalom ne menjen át a Microsoft-on vagy Csak akkor haladjunk át Albánián, ha nincs más út a célhoz.)\\
|
||||
A BGP router szempontjából a világ AS-ekből és a közöttük átmenő vonalakból áll. (Két AS összekötött, ha van köztük a BGP-router-eiket összekötő vonal.)
|
||||
Az átmenő forgalom szempontjából 3 féle hálózat van:
|
||||
\begin{itemize}
|
||||
\item Csonka hálózatok, amelyeknek csak egyetlen összeköttetésük van a BGP gráffal
|
||||
\item Többszörösen bekötött hálózatok, amelyeket használhatna az átmenő forgalom, de ezek ezt megtagadják
|
||||
\item Tranzit hálózatok, amelyek némi megkötéssel, illetve általában fizetség ellenében, készek kezelni harmadik fél csomagjait
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
\end{description}
|
||||
\section{Szállítói réteg}
|
||||
\begin{description}
|
||||
\item[Definíció] \hfill \\
|
||||
A szállítási réteg biztosítja, hogy a felhasználók közötti adatátvitel transzparens (átlátszó) legyen. A réteg biztosítja, és ellenőrzi egy adott kapcsolat megbízhatóságát. Az alkalmazási rétegtől kapott adat elejére egy úgynevezett fejlécet csatol, mely jelzi, hogy melyik szállítási rétegbeli protokollal küldik az adatot. Néhány protokoll kapcsolat orientált. Ez azt jelenti, hogy a réteg nyomon követi az adatcsomagokat, és hiba esetén gondoskodik a csomag vagy csomagok újraküldéséről.
|
||||
|
||||
\item[Kapcsolat nélküli és kapcsolatorientált] \hfill \\
|
||||
A kapcsolatorientált protokoll elfedi az alkalmazások előtt az átvitel esetleges hibáit, nem kell törődnünk az elveszett, vagy duplán megérkezett, illetve sérült csomagokkal, és azzal sem, hogy milyen sorrendben érkeztek meg. Viszont ez rontja a teljesítményét.
|
||||
|
||||
Kapcsolat nélküli esetben nincs szükség az adat keretekre bontására, és nincs csomagújraküldés.
|
||||
\item[Megbízhatóság] \hfill \\
|
||||
A megbízhatóság ismérvei:
|
||||
\begin{itemize}
|
||||
\item Minden csomag megérkezése nyugtázásra kerül.
|
||||
\item A nem nyugtázott adatcsomagokat újraküldik.
|
||||
\item A fejléchez és a csomaghoz ellenőrzőösszeg van rendelve.
|
||||
\item A csomagokat számozza, és a fogadónál sorba rendezésre kerülnek a csomagok a sorszámaik alapján.
|
||||
\item Duplikátumokat törli.
|
||||
\end{itemize}
|
||||
\item[Torlódásfelügyelet] \hfill \\
|
||||
Minden hálózaton korlátos az átviteli sávszélessége. Ha több adatot vezetünk a hálózatba, akkor az torlódáshoz (congestion) vezet, vagy akár a hálózat összeomlásához (congestive collapse). Következmény: Az adatcsomagok nem érkeznek meg.
|
||||
|
||||
Lavina jelenség: \\
|
||||
A hálózat túlterhelése csomagok elvesztését okozza, ami csomag újraküldését eredményezi. Az újraküldés tovább növeli a hálózat terhelését így még nagyobb lesz csomagvesztés. Ez még több újraküldött csomagot eredményez. ... \\
|
||||
A torlódás felügyelet feladata a lavina jelenség elkerülése.
|
||||
|
||||
Követelmények a torlódásfelügyelettel szemben:
|
||||
\begin{itemize}
|
||||
\item Hatékonyság: \\
|
||||
Az átvitel nagy, míg a késés kicsi.
|
||||
\item Fairness: \\
|
||||
Minden folyamat megközelítőleg azonos részt kap a sávszélességből. (Priorizálás lehetősége fennáll)
|
||||
\end{itemize}
|
||||
|
||||
A torlódásfelügyelet eszközei:
|
||||
\begin{itemize}
|
||||
\item Kapacitásnövelés
|
||||
\item Erőforrás foglalás és hozzáférés szabályzás
|
||||
\item Terhelés csökkentése és szabályzása
|
||||
\end{itemize}
|
||||
|
||||
Stratégiák:
|
||||
\begin{itemize}
|
||||
\item Csúszóablak \\
|
||||
Adatráta szabályozása ablak segítségével. A fogadó határozza meg az ablak (wnd) méretét. Ha a fogadási puffere tele van, lecsökkenti 0-ra, egyébként \textgreater0-t küld. A küldő nem küld több csomagot, ha az elküldött még nem nyugtázott csomagok száma elérte az ablak méretét.
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.6\textwidth]{img/csuszoablak.png}
|
||||
\caption{Csúszóablak}
|
||||
\end{figure}
|
||||
\item Slow-start \\
|
||||
A küldőnek nem szabad a fogadó által küldött ablakméretet azonnal kihasználni. Meghatároz egy másik ablakot (cwnd - Congestion Window), melyet ő választ. Ezután végül amiben küld: min\{wnd, cwnd\}. Kezdetben cwnd = MSS (Maximum Segment Size). Minden csomagnál a megkapott nyugta után növeli: cwnd = cwnd + MSS (azaz minden RTT után duplázódik). Ez addig megy, míg a nyugta egyszer kimarad.
|
||||
\item TCP-Nagle \\
|
||||
Biztosítani kell, hogy a kis csomagok időben egymáshoz közel kerüljenek kiszállításkor, illetve hogy sok adat esetén a nagy csomagok részesüljenek előnyben. \\
|
||||
Ehhez: A kis csomagok nem kerülnek kiküldésre, míg nyugták hiányoznak (egy csomag kicsi, ha az adathossz \textless MSS). Ha a korábban küldött csomag nyugtája megérkezik, küldi a következőt.
|
||||
\item TCP Tahoe és Reno
|
||||
A TCP csúszóablakot és a Slow-start mechanizmusát is használja. Habár a kezdő ráta kicsi, az ablak mérete rohamosan nő. Amikor a cwnd eléri az ssthresh (slow start threshold) értéket átvált torlódás elkerülési állapotba. A TCP Tahoe és Reno torlódás elkerülési algoritmusok. A két algoritmus abban különbözik, hogy hogyan detektálják és kezelik a csomag vesztést. \\
|
||||
\underline{TCP Tahoe}: A torlódás detektálására egy időzítőt állít a várt nyugta megérkezésére.
|
||||
\begin{itemize}
|
||||
\item Kapcsolatfelvételkor: cwnd = MSS, ssthresh = $2^{16}$
|
||||
\item Csomagvesztésnél : Multiplicative decrease \\
|
||||
cwns = MSS, ssthresh = max\{2MSS, $\frac{min\{cwnd, wnd\}}{2}$\}
|
||||
\item cwnd $\leq $ ssthresh : Slow-start \\
|
||||
cwnd = cwnd + MSS
|
||||
\item cwnd \textgreater ssthresh : Additive Increase \\
|
||||
cwnd = cwnd + MSS$frac{MSS}{cwnd}$
|
||||
\end{itemize}
|
||||
\underline{TCP Reno}: A torlódás detektálásához időzítőt és gyors újraadást is használ. [Gyors újraadás: ugyanazon csomaghoz 3 nyugta duplikátum érkezik (4 azonos nyugta), akkor újraküldi a csomagot és Slow-start fázisba lép.] \\
|
||||
Gyors újraadás után: ssthresh = max\{$\frac{min\{wnd,cwnd\}}{2}$, 2MSS\}, cwnd = sstresh + 3MSS. \\
|
||||
Gyors visszaállítás a gyors újraadás után minden további nyugta után növeli a rátát : cwnd = cwnd + MSS.
|
||||
\end{itemize}
|
||||
|
||||
Hatékonyság és Fairness: \\
|
||||
Az átvitel maximális, ha a terhelés a hálózat kapacitását majdnem eléri. Ha a terhelés tovább nő, túlcsordulnak a pufferek, csomagok vesznek el, újra kell küldeni, drasztikusan nő a válaszidő. Ezt a torlódásnak nevezzük. Ezért a maximális terhelés helyett, ajánlatos a hálózat terhelését a könyök közelében beállítani. Itt a válaszidő csak lassan emelkedik, míg az adatátvitel már a maximum közelében van
|
||||
|
||||
Egy jó torlódáselkerülési (angolul congestion avoidance) stratégia a hálózat terhelését a könyök közelében tartja: \textit{hatékonyság}. Emellett fontos, hogy minden résztvevőt egyforma rátával szolgáljunk ki: \textit{fairness}
|
||||
|
||||
Jelölje az $i$-edik résztvevő adatrátáját a $t$ időpontban $x_i(t)$.
|
||||
Minden résztvevő aktualizálja az adatrátáját a $t+1$-ik fordulóban:
|
||||
\begin{align*}
|
||||
x_i(t+1) = f_0(t) \quad ha \ \sum_{i=1}^{n}x_i(t) \leq K \\
|
||||
x_i(t+1) = f_1(t) \quad ha \ \sum_{i=1}^{n}x_i(t) > K
|
||||
\end{align*}
|
||||
ahol $f_0(x) = a_I + b_Ix$ a növelési, $f_1(x) = a_D + b_Dx$ a csökkentési stratégia.
|
||||
|
||||
Speciálsi esetek:
|
||||
\begin{itemize}
|
||||
\item \textbf{M}ultiplcative \textbf{I}ncrease \textbf{M}ultiplcative \textbf{D}ecrease - MIMD:
|
||||
\begin{align*}
|
||||
f_0(x) = b_Ix \quad (b_I > 1)\\
|
||||
f_1(x) = b_Dx \quad (b_D < 1)
|
||||
\end{align*}
|
||||
\item \textbf{A}dditive \textbf{I}ncrease \textbf{A}dditive \textbf{D}ecrease - AIAD:
|
||||
\begin{align*}
|
||||
f_0(x) = a_I+x \quad (a_I > 0)\\
|
||||
f_1(x) = a_D+x \quad (a_D < 0)
|
||||
\end{align*}
|
||||
\item \textbf{A}dditive \textbf{I}ncrease \textbf{M}ultiplcative \textbf{D}ecrease - AIMD:
|
||||
\begin{align*}
|
||||
f_0(x) = a_I+x \quad (a_I > 0)\\
|
||||
f_1(x) = b_Dx \quad (b_D < 1)
|
||||
\end{align*}
|
||||
\end{itemize}
|
||||
|
||||
\item[Multiplexálás, demultiplexálás] \hfill \\
|
||||
Multiplexelés alatt a telekommunikációban azt az eljárást értik, amikor két vagy több csatornát összefognak egy csatornába úgy, hogy az inverz multiplexelés művelettel, vagy demultiplexeléssel, vagy demuxálással elő tudják állítani az eredeti csatornákat. Az eredeti csatornák egy úgynevezett kódolási sémával azonosíthatóak.
|
||||
\item[Interakciós modellek] \hfill
|
||||
\begin{itemize}
|
||||
\item Kétirányú bájtfolyam \\
|
||||
Az adatok két egymással ellentétes irányú bájt-sorozatként kerülnek átvitelre. A tartalom nem interpretálódik Az adatcsomagok időbeli viselkedése megváltozhat: átvitel sebessége növekedhet, csökkenhet, más késés, más sorrendben is megérkezhetnek. Megpróbálja az adatcsomagokat időben egymáshoz közel kiszállítani. Megpróbálja az átviteli közeget hatékonyan használni.
|
||||
|
||||
\item RPC \\
|
||||
A távoli gépen futtatandó eljárás eléréséhez hálózati kommunikációra van szükség, ezt az eljáráshívási mechanizmust az RPC (Remote Procedure Call) fedi el.
|
||||
|
||||
A hívás lépései:
|
||||
\begin{enumerate}
|
||||
\item A kliensfolyamat lokálisan meghívja a
|
||||
klienscsonkot.
|
||||
\item Az becsomagolja az eljárás azonosítóját
|
||||
és paramétereit, meghívja az OS-t.
|
||||
\item Az átküldi az üzenetet a távoli OS-nek.
|
||||
\item Az átadja az üzenetet a
|
||||
szervercsonknak.
|
||||
\item Az kicsomagolja a paramétereket,
|
||||
átadja a szervernek.
|
||||
\item A szerver lokálisan meghívja az eljárást,
|
||||
megkapja a visszatérési értéket.
|
||||
\item Ennek visszaküldése a klienshez
|
||||
hasonlóan zajlik, fordított irányban.
|
||||
\end{enumerate}
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.6\textwidth]{img/rpc.png}
|
||||
\caption{RPC}
|
||||
\end{figure}
|
||||
\end{itemize}
|
||||
\item[Protokollok] \hfill
|
||||
\begin{itemize}
|
||||
\item TCP
|
||||
\begin{itemize}
|
||||
\item Megbízható adatfolyam létrehozása két végpont között
|
||||
\item Az alkalmazási réteg adatáramát osztja csomagokra
|
||||
\item A másik végpont a csomagok fogadásról nyugtát küld
|
||||
\end{itemize}
|
||||
A TCP fejléc tartalma:
|
||||
\begin{itemize}
|
||||
\item küldő port(16 bit)\\
|
||||
A küldő folyamatot azonosítja
|
||||
\item cél port(16 bit)\\
|
||||
A címzett folyamat azonosítója
|
||||
\item sorszám(32 bit)\\
|
||||
Az első adatbájt sorszáma az aktuális szegmensen belül. Ha a SYN jelzőbit értéke 1, akkor ez a sorszám a kezdeti sorszám, azaz az első adatbájt sorszáma a kezdeti sorszám + 1 lesz.
|
||||
\item nyugtaszám(32 bit)\\
|
||||
Ha az ACK jelzőbit értéke 1, akkor a fogadó által következőnek fogadni kívánt sorszámot tartalmazza. Minden kapcsolat felépítés esetén elküldésre kerül.
|
||||
\item fejléc hossza (4 bit)\\
|
||||
A TCP fejléc hossza 32-bites egységekben.
|
||||
\item Ablak(16 bit)\\
|
||||
A nyugtázott bájttal kezdődően hány bájtot lehet elküldeni. (A 0 érték is érvényes.)
|
||||
\item Ellenőrzőösszeg(16 bit)\\
|
||||
Az adat-, fej-, és pszeudofejrész ellenőrzésére.
|
||||
\item Opciók(0-40 bájt)\\
|
||||
A szabványos fejlécen kívüli lehetőségekre tervezték. Legfontosabb ilyen lehetőség az MSS, azaz a legnagyobb szegmens méret megadása. További opciók: MD5-aláírás, TCP-AO, "usertimeout", stb.
|
||||
\item sürgősségi mutató(16 bit) \\
|
||||
A sürgős adat bájtban mért helyét jelzi a jelenlegi bájtsorszámhoz viszonyítva.
|
||||
\item Jelző bitek (6)
|
||||
\begin{enumerate}
|
||||
\item URG – Sürgős jelzőbit.
|
||||
\item ACK – nyugta jelzés.
|
||||
\item PSH – Az jelzi, hogy gyors adattovábbítás kell a felhasználói rétegnek.
|
||||
\item RST – Kapcsolat egyoldalú bontását jelzi.
|
||||
\item SYN – Sorszám szinkronizációtjelez.
|
||||
\item FIN – Adatfolyam végét jelzi.
|
||||
\end{enumerate}
|
||||
\end{itemize}
|
||||
\begin{figure}[H]
|
||||
\centering
|
||||
\includegraphics[width=0.8\textwidth]{img/tcp_fejlec.png}
|
||||
\caption{TCP Fejléc}
|
||||
\end{figure}
|
||||
TCP jellemzői:
|
||||
\begin{itemize}
|
||||
\item Kapcsolatorientált
|
||||
\item Megbízható
|
||||
\item Kétirányú bájtfolyam
|
||||
\end{itemize}
|
||||
\item UDP
|
||||
\begin{itemize}
|
||||
\item Egyszerű, nem megbízható szolgáltatás csomagok küldésére
|
||||
\item Az alkalmazási réteg határozza meg a csomag méretét
|
||||
\item Az inputot egy datagrammá alakítja
|
||||
\end{itemize}
|
||||
Összeköttetés nélküli protokoll. Olyan szegmenseket használ az átvitelhez, amelyek egy 8 bájtos fejrészből, valamint a felhasználói adatokból állnak.\\
|
||||
A Fejrész tartalmaz:
|
||||
\begin{itemize}
|
||||
\item egy forrásportot(2 bájt);
|
||||
\item egy célportot(2 bájt);
|
||||
\item egy UDP szegmens hossz értéket (2 bájt);
|
||||
\item egy UDP ellenőrzőösszeget (2 bájt)
|
||||
\end{itemize}
|
||||
Az UDP nem végez forgalomszabályozást, hibakezelést vagy újraküldést egy rossz szegmens fogadása után. Kliens-szerver alkalmazások esetén kifejezetten hasznos lehet az UDP a rövid üzenetek miatt.
|
||||
\end{itemize}
|
||||
\end{description}
|
||||
\end{document}
|
After Width: | Height: | Size: 50 KiB |
After Width: | Height: | Size: 13 KiB |
After Width: | Height: | Size: 41 KiB |
After Width: | Height: | Size: 36 KiB |
After Width: | Height: | Size: 23 KiB |
After Width: | Height: | Size: 18 KiB |
After Width: | Height: | Size: 14 KiB |