SI Wiki - Кориснички доприноси [sr]

Програмски преводиоци 1/Јануар 2022

2023-06-28T19:20:14Z

WikiEditor: /* z -> y */

{{tocright}}
'''Ispit u januarskom roku 2022. godine''' održan je 28. januara. Postavka roka je dostupna [http://ir4pp1.etf.rs/Rokovi/2021-2022/pp1-januar-2021-22.pdf sa stranice predmeta.]

== 1. zadatak ==
{{delimično rešeno}}
=== Postavka ===
Odrediti minimalni konačni deterministički automat koji prihvata one i samo one ulazne sekvence koje NE prihvata konačni automat sa slike ali kada se čitaju sa desna u levo. Na primer, dati automat ne prihvata sekvencu ab, to znači da traženi automat treba da prihvati sekvencu ba. Postupak izložiti po koracima, na generalan način koji bi se mogao primeniti i na svaki drugi automat.
{| class="wikitable"
! Stanje !! a !! b !! Prihvata
|-
| → A || B || || 0
|-
| B || C || D || 0
|-
| C || || || 1
|-
| D || || F || 0
|-
| F || F || F || 1
|}

=== Rešenje ===

== 2. zadatak ==
=== Postavka ===
<div class="abc-list">
# Za smene 1 i 2 date gramatike navesti koje atribute treba računati i od kojih drugih atributa oni mogu da zavise da bi cela gramatika bila L-atributivna. Pravila navoditi u obliku aa = f(bb, cc, dd,..) gde je aa atribut koji mora da se računa, dok su bb, cc, dd, itd svi drugi atributi od kojih posmatrani može da zavisi. Neterminal <S> ima sintetizovan atribut.
# Navesti pseudokod za proceduru A u parseru na bazi rekurzivnog spusta. Ostale delove parsera ne navoditi. Preimenovati promenljive da se minimizuje broj pravila kopiranja vrednosti atributa.
</div>
# <S>x → ay <A>z,v,w <S>p {bq}
# <S>x1 → dy1 {cz1} <A>v1, w1, p1
# <A>x,y,z1 → aq {cv} <A>x1,z,u <A>u,t,y1
## <math>v \larr x - q</math>
## <math>x_1 \larr x</math>
## <math>y \larr y_1</math>
## <math>z_1 \larr z</math>
# <A>t,s,s1 → dq {bt1} as2
## <math>t_1 \larr t</math>
## <math>(s,s_1) \larr s_2</math>

=== Rešenje ===
Iz date gramatike možemo zaključiti sledeće o tipovima atributa:
* Akcije <code>b</code> i <code>c</code> sadrže nasleđene atribute.
* Neterminal <code><A></code> sadrži tri atributa, od kojih je prvi nasleđen a druga dva sintetizovana.
Na osnovu toga, u prvoj smeni vidimo da atributi mogu imati sledeće vrednosti:
* <math>x = f(y, z, v, w, p, q)</math>
* <math>z = f(y)</math>
* <math>q = f(y, z, v, w, p)</math>
a u drugoj smeni sledeće:
* <math>x1 = f(y_1, z_1, v_1, w_1, p_1)</math>
* <math>z1 = f(y_1)</math>
* <math>v1 = f(y_1, z_1)</math>
Kod parsera sa adekvatno preimenovanim atributima dat je ispod:
<syntaxhighlight lang="cpp">
void A(int x, int& y, int& z) {
switch (input) {
case 'a':
input = advance();
int q = getInputValue();
out('c', x - q);
int u;
A(x, z, u);
int t;
A(u, t, y);
break;
case 'd':
input = advance();
out('b', x);
input = advance();
y = z = getInputValue();
break;
}
}
</syntaxhighlight>

== 3. zadatak ==
=== Postavka ===
Zadata je gramatika
# <S> → <S> b <A>
# <S> → <A> a b
# <A> → c d
# <A> → ε
# → ε
<div class="abc-list">
# Konstruisati karaketristični[sic] automat LR(0) parsera kao i odgovarajuću kontrolnu tabelu. Da li ima konflikata?
# Konstruisati kontrolnu tabelu SLR(1) parsera. Da li ima konflikata?
</div>

=== Rešenje ===
[[Датотека:PPR januar 2022 zadatak 3 automat.svg|thumb|Karakteristični LR(0) automat u trećem zadatku.]]
{| class="wikitable"
|+ Kontrolna tabela LR(0) parsera
! Stanje !! Akcija
|-
| <S'>0 || '''R/R konflikt'''
|-
| <A>2 || SHIFT
|-
| 31 || SHIFT
|-
| <S>x || SHIFT
|-
| c3 || REDUCE(5)
|-
| 32 || SHIFT
|-
| d3 || REDUCE(3)
|-
| a2 || REDUCE(5)
|-
| 2 || SHIFT
|-
| b2 || REDUCE(2)
|-
| ─┤0 || ACCEPT
|-
| b1 || '''R/R konflikt'''
|-
| <A>1 || REDUCE(1)
|}
FOLLOW skupovi su sledeći:
* FOLLOW(<S>) = {─┤, b}
* FOLLOW() = {b, c, d}
* FOLLOW(<A>) = {a} ∪ FOLLOW(<S>) = {─┤, a, b}
{| class="wikitable"
|+ Kontrolna tabela SLR(0) parsera
! Stanje !! a !! b !! c !! d !! ─┤
|-
| <S'>0 || REDUCE(4) || '''R/R konflikt''' || REDUCE(5) || REDUCE(5) || REDUCE(4)
|-
| <A>2 || SHIFT || || || ||
|-
| 31 || || || SHIFT || ||
|-
| <S>x || || SHIFT || || || SHIFT
|-
| c3 || || REDUCE(5) || REDUCE(5) || REDUCE(5) ||
|-
| 32 || || || || SHIFT ||
|-
| d3 || REDUCE(3) || REDUCE(3) || || || REDUCE(3)
|-
| a2 || || REDUCE(5) || REDUCE(5) || REDUCE(5) ||
|-
| 2 || || SHIFT || || ||
|-
| b2 || || REDUCE(2) || || || REDUCE(2)
|-
| ─┤0 || || || || || ACCEPT
|-
| b1 || REDUCE(4) || '''R/R konflikt''' || REDUCE(5) || REDUCE(5) || REDUCE(4)
|-
| <A>1 || || REDUCE(1) || || || REDUCE(1)
|}

== 4. zadatak ==
=== Postavka ===
Dat je listing programa Januar2022, napisan na programskom jeziku Mikrojava. Sve metode unutrašnjih klasa su virtuelne. Globalne metode se pozivaju statički. Napisati kompletan Mikrojava bajtkod prevoda funkcije <code>f</code> za dati program
<syntaxhighlight lang="java">
program Januar2022
const int K = 2;
int add;
class A {
int fld;
{
int m(int a)
{ return fld * 2; }
void met()
{ fld = fld + 3; }
} }
class B extends A {
{
int m(int b)
{ /*T1*/
return fld + b;
}
}
}
A arr[];
{
int f(int index){
add = arr[index].m(K);
arr[index].met();
return add + K;
}
void main()
B b;
int ret;
{
/*T2*/
arr = new A[2];
arr[0] = new B;
arr[1] = new A;
ret = f(0) + f(1);
print(arr[0].m(ret));
}
}
</syntaxhighlight>

=== Rešenje ===
<pre>
enter 1, 1
getstatic 1
load_0
aload
const_2
getstatic 1
load_0
aload
getfield 0
invokevirtual 'm' -1
putstatic 0
getstatic 1
load_0
aload
dup
getfield 0
invokevirtual 'm' 'e' 't' -1
getstatic 0
const_2
add
exit
return
</pre>

== 5. zadatak ==
=== Postavka ===
Prikazati izgled tabele simbola u trenucima T1 i T2 na osnovu izvornog koda iz zadatka 4 prema formatu čvorova tabele simbola iz priloga. Universe opseg ne treba crtati. Za T2 dovoljno je naznačiti izmene u odnosu na prethodno stanje tabele.

=== Rešenje ===
<gallery widths="500" heights="500" class="transparent-svg">
PPR januar 2022 zadatak 5 T1.svg | Tabela simbola u stanju T1.
PPR januar 2022 zadatak 5 T2.svg | Tabela simbola u stanju T2.
</gallery>

== 6. zadatak ==
=== Postavka ===
Za dati programski fragment napisati odgovarajući međukod u SSA formi i nacrtati graf toka kontrole na nivou osnovnih blokova.
<syntaxhighlight lang="c">
a = 1;
b = 2;
c = 3;
for (a = 4; b < c || a < 10; a++) {
if (a > b + c) {
c++;
break;
} else if (a > b * c) {
b--;
continue;
}
else return a;
}
a = b * c;
return a;
</syntaxhighlight>

=== Rešenje ===
[[Датотека:PPR januar 2022 zadatak 6 graf.svg|thumb|Karakteristični LR(0) automat u trećem zadatku.]]
# a1 := 1
# b1 := 2
# c1 := 3
# a2 := 4
# t1 := Ф(b1, b2)
# if t1 < c1 goto 8
# if a2 >= 10 goto 17
# t2 := t1 + c1
# if a <= t2 goto 12
# c2 := c1 + 1
# goto 17
# t3 := t1 * c1
# if a <= t3 goto 16
# b2 := t1 - 1
# goto 5
# return a2
# t4 := Ф(b1, b2)
# t5 := Ф(c1, c2)
# t6 := t1 * t2
# a3 := t6
# return a3

[[Категорија:Рокови]]
[[Категорија:Програмски преводиоци 1]]

Програмски преводиоци 1/Јануар 2020

2023-06-28T11:37:50Z

WikiEditor: /* ispravka */

{{tocright}}
'''Januarski rok 2021. godine''' održan je 22. januara. Postavka roka je dostupna [http://ir4pp1.etf.rs/Rokovi/2019-2020/pp1-1920-januar.pdf sa stranice predmeta.]

== 1. zadatak ==
=== Postavka ===
Data gramatika opisuje regularne izraze sa operatorima konkatenacije ● i unije |.
# <E> → <E> | <T>
# <E> → <T>
# <T> → <T> ● 
# <T> → 
# → slovo
# → epsilon
<div class="abc-list">
# Konstruisati SLR(1) parser za datu gramatiku.
# Dopuniti datu gramatiku S-atributivnim pravilima tako da svaki neterminal date gramatike poseduje atribute koji predstavljaju vrednosti funkcija poništiv i prva_pozicija iz algoritma za konstrukciju determinističkog konačnog automata iz regularnog izraza. Terminal <code>slovo</code> poseduje atribut koji označava poziciju tog terminala u izrazu. Napomena: <code>epsilon</code> je terminal, a ne oznaka prazne sekvence. Takođe su | i ● terminalni simboli.
</div>

=== Rešenje ===
[[Датотека:PPR januar 2020 zadatak 1 automat.svg|thumb|Automat iz prvog zadatka pod a.]]
Relevantni FIRST i FOLLOW skupovi SLR(1) parsera su:
* FOLLOW(<E>) = {|, ─┤}
* FOLLOW(<T>) = {●} ∪ FOLLOW(<E>) = {●, |, ─┤}
* FOLLOW() = FOLLOW(<T>) = {●, |, ─┤}
{| class="wikitable"
|+ Potisna tabela SLR(1) parsera
! Stanje
! <E> !! <T> !! !! slovo !! epsilon !! ● !! | !! ─┤
|-
! ∇
| <E>x || <T>x1 !! 4 || slovo5 || epsilon6 || || ||
|-
! <T>x1
| || || || || || ●3 || ||
|-
! <E>x
| || || || || || || |1 || ─┤0
|-
! 4
| || || || || || || ||
|-
! slovo5
| || || || || || || ||
|-
! epsilon6
| || || || || || || ||
|-
! ●3
| || || 3 || slovo5 || epsilon6 || || ||
|-
! |1
| || <T>x2 || 4 || slovo5 || epsilon6 || || ||
|-
! ─┤0
| || || || || || || ||
|-
! 3
| || || || || || || ||
|-
! <T>x2
| || || || || || ●3 || ||
|}
{| class="wikitable"
|+ Kontrolna tabela SLR(1) parsera
! Stanje
! slovo !! epsilon !! ● !! | !! ─┤
|-
! ∇
| SHIFT || SHIFT || || ||
|-
! <T>x1
| || || SHIFT || REDUCE(2) || REDUCE(2)
|-
! <E>x
| || || || SHIFT || SHIFT
|-
! 4
| || || REDUCE(4) || REDUCE(4) || REDUCE(4)
|-
! slovo5
| || || REDUCE(5) || REDUCE(5) || REDUCE(5)
|-
! epsilon6
| || || REDUCE(6) || REDUCE(6) || REDUCE(6)
|-
! ●3
| SHIFT || SHIFT || || ||
|-
! |1
| SHIFT || SHIFT || || ||
|-
! ─┤0
| || || || || ACCEPT
|-
! 3
| || || REDUCE(3) || REDUCE(3) || REDUCE(3)
|-
! <T>x2
| || || SHIFT || REDUCE(1) || REDUCE(1)
|}
Dopunjena gramatika sa atributima izgleda:
# <E>pon,prva → <E>pon1,prva1 | <T>pon2,prva2
#: <math>pon \larr pon_1 or pon_2</math>
#: <math>prva \larr \{prva_1, prva_2\}</math>
# <E>pon,prva → <T>pon1,prva1
#: <math>pon \larr pon_1</math>
#: <math>prva \larr prva_1</math>
# <T>pon,prva → <T>pon1,prva1 ● pon2,prva2
#: <math>pon \larr pon_1 and pon_2</math>
#: <math>prva \larr pon_1 ? \{prva_1, prva_2\} : prva_1</math>
# <T>pon,prva → pon1,prva1
#: <math>pon \larr pon_1</math>
#: <math>prva \larr prva_1</math>
# pon,prva → slovopoz
#: <math>pon \larr 0</math>
#: <math>prva \larr poz</math>
# pon,prva → epsilon
#: <math>pon \larr 1</math>

== 2. zadatak ==
=== Postavka ===
U standardnoj Mikrojavi, lokalno definisana promenljiva sakriva globalnu promenljivu sa istim imenom. Želimo da uvedemo sledeću modifikaciju: Ako se želi pristupiti sakrivenoj globalnoj promenljivoj, mora se ispred imena navesti operator <code>::</code>.

Na primer:
<syntaxhighlight lang="java">
program P {
int X[];
void main() int X; { ::X = new int[5]; X = ::X[0];}
}
</syntaxhighlight>
<div class="abc-list">
# Promeniti Mikrojava gramatiku da se dodaju opisane mogućnosti (relevantan deo gramatike dat je u prilogu u EBNF notaciji). Jasno označiti šta je promenjeno.
# Dodati u mikrojava tabelu simbola metod <syntaxhighlight lang="java" inline>find_hidden(String name)</syntaxhighlight> koji se poziva za traženje imena pod dejstvom operatora <code>::</code>. Navesti kompletnu implementaciju ovog metoda. U prilogu je (na sledećoj strani) kao podsetnik dat deo postojeće implementacije klase <code>Tab</code>.
# Gde u Mikrojava kompajleru treba ugraditi poziv metoda <code>find_hidden</code>?
</div>
Mikrojava gramatika:
<pre>
DesignatorStatement := Designator "=" Expr.
DesignatorStatement := Designator "++".
DesignatorStatement := Designator "--".
Statement := DesignatorStatement ";".
Statement := "read" "(" Designator ")" ";".
Statement := "print" "(" Expr [“,” number] ")" ";".
Expr := ["‐"] Term {Addop Term}.
Term := Factor {Mulop Factor}.
Factor := numConst | charConst | "(" Expr ")" | boolConst | "new" Type [ "[" Expr "]" ].
Factor := Designator [ "(" ")" ].
Designator := ident ["[" Expr "]" ].
Addop := "+" | "‐" .
Mulop := "*" | "/" | "%".
</pre>
Implementacija klase <code>Tab</code>:
<syntaxhighlight lang="java">
public class Tab {
public static final Struct
noType = new Struct(Struct.None),
intType = new Struct(Struct.Int),
charType = new Struct(Struct.Char),
nullType = new Struct(Struct.Class);
public static final Obj noObj = new Obj(Obj.Var, "noObj", noType);
public static Obj chrObj, ordObj, lenObj;
public static Scope currentScope; //tekuci opseg
private static int currentLevel; //nivo ugnezdavanja tekuceg opsega
public static void init() {
Scope universe = currentScope = new Scope(null);
. . . . .
currentLevel = -1;
}
public static void openScope() {
currentScope = new Scope(currentScope);
currentLevel++;
}
public static void closeScope() {
currentScope = currentScope.getOuter();
currentLevel--;
}
public static Obj insert(int kind, String name, Struct type) {
Obj newObj=new Obj(kind,name,type,0,((currentLevel!=0)?1:0));
. . . . .
}
public static Obj find(String name) {
Obj resultObj = null;
for (Scope s = currentScope; s != null; s = s.getOuter()) {
if (s.getLocals() != null) {
resultObj = s.getLocals().searchKey(name);
if (resultObj != null) break;
}
}
return (resultObj != null) ? resultObj : noObj;
}
public static Scope currentScope() {
return currentScope;
}
}
</syntaxhighlight>

=== Rešenje ===
U gramatici je potrebno izmeniti sledeću smenu:
<pre>
Designator := ["::"] ident ["[" Expr "]" ].
</pre>
Metoda <code>find_hidden</code> koja pronalazi promenljive iz globalnog dosega programa može da izgleda ovako:
<syntaxhighlight lang="java">
public static Obj find_hidden(String name) {
Scope scope = currentScope;
for (int level = currentLevel; level > 0; --level) {
scope = scope.getOuter();
}
Obj resultObj = null;
if (scope.getLocals() != null) {
resultObj = scope.getLocals().searchKey(name);
}
return (resultObj != null) ? resultObj : noObj;
}
</syntaxhighlight>
U Mikrojava kompajleru poziv ove metode treba ugraditi tokom semantičke analize, kako bi se odgovarajućem čvoru u apstraktnom sintaksnom stablu dodelio simbol koji odgovara promenljivoj iz globalnog opsega.

== 3. zadatak ==
=== Postavka ===

=== Rešenje ===
{| class="wikitable"
|+ Nedeterministički konačni automat sa dešifrovanim stanjima.
! Stanje !! a !! b !! c !! Prihvata
|-
| → A || A || || C || 0
|-
| B || B, C || D || || 0
|-
| C || A || || D || 1
|-
| D || || B, C || || 0
|}
{| class="wikitable"
|+ Deterministički konačni automat sa dešifrovanim stanjima
! Stanje !! a !! b !! c !! Prihvata
|-
| → A, B || A, B, C || D || C || 0
|-
| A, B, C || A, B, C || D || C, D || 1
|-
| D || || B, C || || 0
|-
| C || A || || D || 1
|-
| C, D || A || B, C || D || 1
|-
| B, C || A, B, C || D || D || 1
|-
| A || A || || C || 0
|}

== 4. zadatak ==
=== Postavka ===
Data je gramatika:
# <S> → a <S> b
# <S> → b <S> c
# <S> → bc
# <S> → <S> a
<div class="abc-list">
# Transformisati gramatiku u LL(1) i odrediti SELECT skupove tako dobijene gramatike.
# Konstruisati parser na bazi rekurzivnog spusta za gramatiku dobijenu u tački a).
</div>

=== Rešenje ===
Transformisana gramatika može izgledati ovako:
# <S> → a <S> b <S'<nowiki />'>
#: SELECT(1) = {a}
# <S> → b <S'> c <S'<nowiki />'>
#: SELECT(2) = {b}
# <S'> → <S>
#: SELECT(3) = {a, b}
# <S'> → ε
#: SELECT(3) = {c}
# <S'<nowiki />'> → a <S'<nowiki />'>
#: SELECT(4) = {a}
# <S'<nowiki />'> → ε
#: SELECT(5) = {c, ─┤}
Parser na bazi rekurzivnog spusta na gornju gramatiku izgleda ovako:
<syntaxhighlight lang="java">
char input;

void terminal(char c) {
if (input == c) {
input = advance();
} else {
reject();
}
}

void S2() {
switch (input) {
case 'a':
terminal('a');
S2();
break;
case 'c':
case EOF:
break;
default:
reject();
}
}

void S();

void S1() {
switch (input) {
case 'a':
case 'b':
S();
break;
case 'c':
break;
default:
reject();
}
}

void S() {
switch (input) {
case 'a':
terminal('a');
S();
terminal('b');
S2();
break;
case 'b':
terminal('b');
S1();
terminal('c');
S2();
break;
default:
reject();
}
}

void main() {
input = advance();
S();
terminal(EOF);
}
</syntaxhighlight>

== 5. zadatak ==
=== Postavka ===
Dat je sledeći deo program na jeziku sličnom Pascal-u:
<syntaxhighlight lang="pascal">
procedure proc0;
var x, y: integer;
procedure proc1(z: integer);
procedure proc2;
begin
y := x + z;
end;
begin
proc2;
end;
procedure proc3(z: integer);
var x: integer;
procedure proc4;
begin
proc1(x);
end;
begin
x := z + 1;
proc4;
end;
begin
x := 5;
proc3(x);
end;
</syntaxhighlight>
<div class="abc-list">
# Ako je statičko okruženje za nelokalne promenljive realizovano preko pristupnih veza, nacrtati izgled steka nakon izvršavanja naredbe <code>y := x + z;</code> iz procedure <code>proc2</code>.
# Napisati 80x86 asemblerski kod za naredbu <code>y := x + z;</code> iz procedure <code>proc2</code>.
</div>

=== Rešenje ===
[[Датотека:PPR januar 2020 zadatak 5 stek.svg|thumb|Stek iz petog zadatka pod a.]]
<syntaxhighlight lang="asm">
MOV DI, [BP+04]
MOV AX, [DI+06]
MOV DI, [DI+04]
MOV BX, [DI-02]
ADD AX, BX
MOV [DI-04], AX
</syntaxhighlight>

== 6. zadatak ==
=== Postavka ===
Za dati programski fragment:
<div class="abc-list">
# Napisati odgovarajući međukod i graf toka kontrole na nivou osnovnih blokova.
# Napisati međukod u SSA formi.
</div>
<syntaxhighlight lang="java">
x = 1;
y = 0;
z = 0;
for (x = 2; y > z; z = z + 1) {
if (x - 2 > y) {
x = y - 1;
} else if(x > y) {
x = z - 1;
} else break;
y = x * 2;
}
x = y + z;
</syntaxhighlight>

=== Rešenje ===
[[Датотека:PPR januar 2020 zadatak 6 graf.svg|thumb|Graf iz šestog zadatka pod a.]]
Međukod:
# x1 := 1
# y1 := 0
# z1 := 0
# x2 := 2
# t1 := Ф(y1, y2)
# if t1 <= z goto 22
# t2 := Ф(x2, x3, x4)
# t3 := t2 - 2
# if t3 <= t1 goto 13
# t4 := t1 - 1
# x3 := t4
# goto 18
# if t2 <= t1 goto 17
# t5 := z1 - 1
# x4 := t3
# goto 18
# goto 22
# t6 := Ф(x3, x4)
# t7 := t6 * 2
# y2 := t7
# goto 5
# t8 := t1 + z1
# x5 := t8

[[Категорија:Рокови]]
[[Категорија:Програмски преводиоци 1]]

Програмски преводиоци 1/Јануар 2021

2023-06-28T10:14:12Z

WikiEditor: /* ispravka */

{{tocright}}
'''Januarski rok 2021. godine''' održan je 22. januara. Postavka roka je dostupna [http://ir4pp1.etf.rs/Rokovi/2020-2021/pp1_jan2021_ispit.pdf sa stranice predmeta.]

== 1. zadatak ==
=== Postavka ===
Dat je fragmet[sic] gramatike jednog programskog jezika.
# <var_decl> ::= <type> : <id_list>
# <id_list> ::= <id_list> , Ident | Ident
# <type> ::= int | char
<div class="abc-list">
# Napisati atributivnu gramatiku kojom se određuje tip za svaki identifikator u listi (Ident). Jasno naznačiti koji atributi su sintetizovani, a koji nasleđeni.
# Da li je dobijena gramatika S-atributivna ili L-atributivna?
# Dobijenoj atributivnoj gramatici (pod a) dodati neophodne akcije koje obezbeđuju dodavanje simbola u tabelu simbola i postavljanje njihovih tipova. Za pisanje akcija koristiti programski jezik Java i sledeći interfejs tabele simbola.
</div>
<syntaxhighlight lang="java">
class Struct {
static final int None = 0, Int = 1, Char = 2, Arr = 3, Class = 4;
int kind; // None, Int, Char, Arr, Class
boolean equals (Struct other);
}
class Tab {
Obj insert (String name, Struct type) throws AlreadyDeclaredException;
Obj findSymbol (String name) throws SymbolNotFoundException;
}
public class Obj {
public static final int Con = 0, Var = 1, Type = 2, Prog = 5;
public int kind; // Con, Var, Type, Meth, Fld, Prog
public String name;
public Struct type;
}
</syntaxhighlight>

=== Rešenje ===
Atribut <code>t</code> je u sledećoj gramatici sintetizovan, dok su atributi <code>type</code> i <code>idtype</code> nasleđeni. Ispod je prikazana gramatika sa označenim atributima i dodatim akcijama.
# <type>t → int
#: t ← Struct.Int
# <type>t → char
#: t ← Struct.Char
# <id_list>type → <id_list>type1, Identidtype {: <syntaxhighlight lang="java" inline>Tab.insert(new Obj(Obj.Var, ident, new Struct(type)));</syntaxhighlight> :}
#: idtype ← type
#: type1 ← type
# <id_list>type → Identidtype {: <syntaxhighlight lang="java" inline>Tab.insert(new Obj(Obj.Var, ident, new Struct(type)));</syntaxhighlight> :}
#: idtype ← type
# <var_decl> → <type>t : <id_list>type
#: type ← t
Dobijena gramatika je L-atributivna, ali nije S-atributivna.

== 2. zadatak ==
=== Postavka ===
Za sve sekvence oblika ak(bc)pa2p, k ≥ 0, p > 0
<div class="abc-list">
# Napisati gramatiku koja opisuje date sekvence.
# Prikazati potisni automat kojim se prepoznaje isključivo dati skup sekvenci.
</div>

=== Rešenje ===
Gramatika koja opisuje date sekvence bi bila:
# <S> → <A> 
# <A> → ε
# <A> → <A> a
# → bc aa
# → bcaa
{| class="wikitable"
|+ Stanje S1 potisnog automata za opisivanje sekvenci iz drugog zadatka.
! Stanje
! a
! b
! c
! ─┤
|-
! ∇
| ADVANCE
|
* PUSH(A)
* ADVANCE
| REJECT
| REJECT
|-
! A
| REJECT
| REJECT
|
* PUSH(B)
* ADVANCE
| REJECT
|-
! B
| STATE(S2)
|
* PUSH(A)
* ADVANCE
| REJECT
| REJECT
|}
{| class="wikitable"
|+ Stanje S2 potisnog automata za opisivanje sekvenci iz drugog zadatka.
! Stanje
! a
! b
! c
! ─┤
|-
! ∇
| REJECT
| REJECT
| REJECT
| ACCEPT
|-
! A
|
* POP
* ADVANCE
| REJECT
| REJECT
| REJECT
|-
! B
|
* POP
* ADVANCE
| REJECT
| REJECT
| REJECT
|}

== 3. zadatak ==
=== Postavka ===
Formirati parser na principu rekurzivnog spusta koji prepoznaje skup sekvenci predstavljenih sledećim produkcijama.
# <S’> → <S> ─┤
# <S> → <A> a 
# <A> → a b b
# → <C> a
# → <D> <C> a
# → ε
# <C> → c <C>
# <C> → ε
# <D> → d

=== Rešenje ===
<syntaxhighlight lang="cpp">
char input;

void terminal(char t) {
if (input == t) {
input = advance();
} else {
reject();
}
}

void A() {
terminal('a');
terminal('b');
B();
terminal('b');
}

void C() {
switch (input) {
case 'c':
terminal('c');
C();
break;
case 'a':
break;
default:
reject();
}
}

void D() {
terminal('d');
}

void B() {
switch (input) {
case 'a':
case 'c':
C();
terminal('a');
break;
case 'd':
D();
C();
terminal('a');
break;
case 'b':
case EOF:
break;
default:
reject();
}
}

void S() {
A();
terminal('a');
B();
}

void main() {
input = advance();
S();
terminal(EOF);
}
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
<div class="abc-list">
# Dat je listing programa napisanog na programskom jeziku Mikrojava. Sve metode unutrašnjih klasa su virtuelne. Globalne metode se pozivaju statički. Napisati kompletan Mikrojava bajtkod prevoda datog programa. Za svaku liniju koda jasno naznačiti koji deo bajtkoda se odnosi na nju.
# Odrediti deo koda koji se nalazi na mestu komentara u datom programu, a kome odgovara dati Mikrojava bajtkod.
</div>
<syntaxhighlight lang="java">
program Januar2021
const int K = 3;
class CL { int p; }
CL global;
{
void m(CL arg)
int y;
{
if(y >= K || y == 0)
global.p++;
else arg.p = K;
}
void main()
int x; int arr[];
{
global = new CL;
arr = new int[3];
arr[K-2] = -arr[x];
m(global);
/* ??? */
}
}
</syntaxhighlight>
<syntaxhighlight lang="asm">
getstatic 0
const_2
load_0
load_1
const_0
aload
mul
add
putfield 1
</syntaxhighlight>

=== Rešenje ===
Prevedeni bajtkod može da izgleda ovako:
<syntaxhighlight lang="asm">
enter 1 2 # void m(CL arg) int y; {
load_1 # if (
const_3
jge 8 # y >= K
load_1
const_0
jne 18 # y == 0)
getstatic 0 # global.p++;
dup
getfield 1
const_1
add
putfield 1
jmp 8 # else
load_0 # arg.p = K;
const_3
putfield 1
exit # }
return
enter 0 2 # void main() int x; int arr[]; {
new 8 # global = new CL;
putstatic 0
const_3 # arr = new int[3];
newarray 1
store_1
load_1 # arr[K-2] = -arr[x];
const_3
const_2
sub
load_1
load_0
aload
neg
astore
getstatic 0 # m(global);
call ??? (=m) # Verovatno nisu tražili tačan pomeraj?
exit # }
return
</syntaxhighlight>
Linija koda koja fali u programu je:
<syntaxhighlight lang="java">
global.p = 2 + x * arr[0];
</syntaxhighlight>

== 5. zadatak ==
=== Postavka ===
Dat je sledeći fragment (bazični blok) međukoda:
# x = 2
# z = x + 3
# y = z – x
# x = y
# z = x + y
# x = z – y
# z = y – x
<div class="abc-list">
# Za svaku instrukciju u kodu odrediti koje su promenljive žive.
# Korišćenjem algoritma getreg generisati mašinski kod za 80x86 arhitekturu na osnovu datog međukoda i informacija iz tačke a). Pretpostaviti da se koriste dvoadresne mašinske instrukcije gde je prvi operand odredište operacije (oblika ADD dst, src) i da se koriste samo dva registra AX i BX. Rešenje ČITKO upisati u datu tabelu.
</div>

=== Rešenje ===
{| class="wikitable"
|+ Tabela sa traženim informacijama iz zadatka.
! rowspan="2" | Redni broj
! rowspan="2" | Ulaz
! colspan="3" | Život i sledeća upotreba
! colspan="2" | Deskriptori
! rowspan="2" | ''getreg''
! rowspan="2" | Generisani kod
|-
! x
! y
! z
! AX
! BX
|-
| 1. || x = 2 || ž2 || m- || m- || x || - || AX || MOV AX, 2
|-
| 2. || z = x + 3 || ž3 || m- || ž3 || x || z || BX || MOV BX, AX; ADD BX, 3
|-
| 3. || y = z - x || m- || ž4 || m- || x || y || BX || SUB BX, AX
|-
| 4. || x = y || ž5 || ž5 || m- || x || y || AX || MOV AX, BX
|-
| 5. || z = x + y || m- || ž6 || ž6 || z || y || AX || ADD AX, BX
|-
| 6. || x = z - y || ž7 || ž7 || m- || x || y || AX || SUB AX, BX
|-
| 7. || z = y - x || ž- || ž- || ž- || x || z || BX || MOV y, BX; SUB BX, AX
|-
| colspan="8" |
| MOV x, AX; MOV z, BX
|}

[[Категорија:Рокови]]
[[Категорија:Програмски преводиоци 1]]

Програмски преводиоци 1/Јануар 2021

2023-06-28T01:01:17Z

WikiEditor: /* ispravka */

{{tocright}}
'''Januarski rok 2021. godine''' održan je 22. januara. Postavka roka je dostupna [http://ir4pp1.etf.rs/Rokovi/2020-2021/pp1_jan2021_ispit.pdf sa stranice predmeta.]

== 1. zadatak ==
=== Postavka ===
Dat je fragmet[sic] gramatike jednog programskog jezika.
# <var_decl> ::= <type> : <id_list>
# <id_list> ::= <id_list> , Ident | Ident
# <type> ::= int | char
<div class="abc-list">
# Napisati atributivnu gramatiku kojom se određuje tip za svaki identifikator u listi (Ident). Jasno naznačiti koji atributi su sintetizovani, a koji nasleđeni.
# Da li je dobijena gramatika S-atributivna ili L-atributivna?
# Dobijenoj atributivnoj gramatici (pod a) dodati neophodne akcije koje obezbeđuju dodavanje simbola u tabelu simbola i postavljanje njihovih tipova. Za pisanje akcija koristiti programski jezik Java i sledeći interfejs tabele simbola.
</div>
<syntaxhighlight lang="java">
class Struct {
static final int None = 0, Int = 1, Char = 2, Arr = 3, Class = 4;
int kind; // None, Int, Char, Arr, Class
boolean equals (Struct other);
}
class Tab {
Obj insert (String name, Struct type) throws AlreadyDeclaredException;
Obj findSymbol (String name) throws SymbolNotFoundException;
}
public class Obj {
public static final int Con = 0, Var = 1, Type = 2, Prog = 5;
public int kind; // Con, Var, Type, Meth, Fld, Prog
public String name;
public Struct type;
}
</syntaxhighlight>

=== Rešenje ===
Atribut <code>t</code> je u sledećoj gramatici sintetizovan, dok su atributi <code>type</code> i <code>idtype</code> nasleđeni. Ispod je prikazana gramatika sa označenim atributima i dodatim akcijama.
# <type>t → int
#: t ← Struct.Int
# <type>t → char
#: t ← Struct.Char
# <id_list>type → <id_list>type1, Identidtype {: <syntaxhighlight lang="java" inline>Tab.insert(new Obj(Obj.Var, ident, new Struct(type)));</syntaxhighlight> :}
#: idtype ← type
#: type1 ← type
# <id_list>type → Identidtype {: <syntaxhighlight lang="java" inline>Tab.insert(new Obj(Obj.Var, ident, new Struct(type)));</syntaxhighlight> :}
#: idtype ← type
# <var_decl> → <type>t : <id_list>type
#: type ← t
Dobijena gramatika je L-atributivna, ali nije S-atributivna.

== 2. zadatak ==
=== Postavka ===
Za sve sekvence oblika ak(bc)pa2p, k ≥ 0, p > 0
<div class="abc-list">
# Napisati gramatiku koja opisuje date sekvence.
# Prikazati potisni automat kojim se prepoznaje isključivo dati skup sekvenci.
</div>

=== Rešenje ===
Gramatika koja opisuje date sekvence bi bila:
# <S> → <A> 
# <A> → ε
# <A> → <A> a
# → bc aa
# → bcaa
{| class="wikitable"
|+ Stanje S1 potisnog automata za opisivanje sekvenci iz drugog zadatka.
! Stanje
! a
! b
! c
! ─┤
|-
! ∇
| ADVANCE
|
* PUSH(A)
* ADVANCE
| REJECT
| REJECT
|-
! A
| REJECT
| REJECT
|
* PUSH(B)
* ADVANCE
| REJECT
|-
! B
| STATE(S2)
| PUSH(A)
| REJECT
| REJECT
|}
{| class="wikitable"
|+ Stanje S2 potisnog automata za opisivanje sekvenci iz drugog zadatka.
! Stanje
! a
! b
! c
! ─┤
|-
! ∇
| REJECT
| REJECT
| REJECT
| ACCEPT
|-
! A
|
* POP
* ADVANCE
| REJECT
| REJECT
| REJECT
|-
! B
|
* POP
* ADVANCE
| REJECT
| REJECT
| REJECT
|}

== 3. zadatak ==
=== Postavka ===
Formirati parser na principu rekurzivnog spusta koji prepoznaje skup sekvenci predstavljenih sledećim produkcijama.
# <S’> → <S> ─┤
# <S> → <A> a 
# <A> → a b b
# → <C> a
# → <D> <C> a
# → ε
# <C> → c <C>
# <C> → ε
# <D> → d

=== Rešenje ===
<syntaxhighlight lang="cpp">
char input;

void terminal(char t) {
if (input == t) {
input = advance();
} else {
reject();
}
}

void A() {
terminal('a');
terminal('b');
B();
terminal('b');
}

void C() {
switch (input) {
case 'c':
terminal('c');
C();
break;
case 'a':
break;
default:
reject();
}
}

void D() {
terminal('d');
}

void B() {
switch (input) {
case 'a':
case 'c':
C();
terminal('a');
break;
case 'd':
D();
C();
terminal('a');
break;
case 'b':
case EOF:
break;
default:
reject();
}
}

void S() {
A();
terminal('a');
B();
}

void main() {
input = advance();
S();
terminal(EOF);
}
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
<div class="abc-list">
# Dat je listing programa napisanog na programskom jeziku Mikrojava. Sve metode unutrašnjih klasa su virtuelne. Globalne metode se pozivaju statički. Napisati kompletan Mikrojava bajtkod prevoda datog programa. Za svaku liniju koda jasno naznačiti koji deo bajtkoda se odnosi na nju.
# Odrediti deo koda koji se nalazi na mestu komentara u datom programu, a kome odgovara dati Mikrojava bajtkod.
</div>
<syntaxhighlight lang="java">
program Januar2021
const int K = 3;
class CL { int p; }
CL global;
{
void m(CL arg)
int y;
{
if(y >= K || y == 0)
global.p++;
else arg.p = K;
}
void main()
int x; int arr[];
{
global = new CL;
arr = new int[3];
arr[K-2] = -arr[x];
m(global);
/* ??? */
}
}
</syntaxhighlight>
<syntaxhighlight lang="asm">
getstatic 0
const_2
load_0
load_1
const_0
aload
mul
add
putfield 1
</syntaxhighlight>

=== Rešenje ===
Prevedeni bajtkod može da izgleda ovako:
<syntaxhighlight lang="asm">
enter 1 2 # void m(CL arg) int y; {
load_1 # if (
const_3
jge 8 # y >= K
load_1
const_0
jne 18 # y == 0)
getstatic 0 # global.p++;
dup
getfield 1
const_1
add
putfield 1
jmp 8 # else
load_0 # arg.p = K;
const_3
putfield 1
exit # }
return
enter 0 2 # void main() int x; int arr[]; {
new 8 # global = new CL;
putstatic 0
const_3 # arr = new int[3];
newarray 1
store_1
load_1 # arr[K-2] = -arr[x];
const_3
const_2
sub
load_1
load_0
aload
neg
astore
getstatic 0 # m(global);
call ??? (=m) # Verovatno nisu tražili tačan pomeraj?
exit # }
return
</syntaxhighlight>
Linija koda koja fali u programu je:
<syntaxhighlight lang="java">
global.p = 2 + x * arr[0];
</syntaxhighlight>

== 5. zadatak ==
=== Postavka ===
Dat je sledeći fragment (bazični blok) međukoda:
# x = 2
# z = x + 3
# y = z – x
# x = y
# z = x + y
# x = z – y
# z = y – x
<div class="abc-list">
# Za svaku instrukciju u kodu odrediti koje su promenljive žive.
# Korišćenjem algoritma getreg generisati mašinski kod za 80x86 arhitekturu na osnovu datog međukoda i informacija iz tačke a). Pretpostaviti da se koriste dvoadresne mašinske instrukcije gde je prvi operand odredište operacije (oblika ADD dst, src) i da se koriste samo dva registra AX i BX. Rešenje ČITKO upisati u datu tabelu.
</div>

=== Rešenje ===
{| class="wikitable"
|+ Tabela sa traženim informacijama iz zadatka.
! rowspan="2" | Redni broj
! rowspan="2" | Ulaz
! colspan="3" | Život i sledeća upotreba
! colspan="2" | Deskriptori
! rowspan="2" | ''getreg''
! rowspan="2" | Generisani kod
|-
! x
! y
! z
! AX
! BX
|-
| 1. || x = 2 || ž2 || m- || m- || x || - || AX || MOV AX, 2
|-
| 2. || z = x + 3 || ž3 || m- || ž3 || x || z || BX || MOV BX, AX; ADD BX, 3
|-
| 3. || y = z - x || m- || ž4 || m- || x || y || BX || SUB BX, AX
|-
| 4. || x = y || ž5 || ž5 || m- || x || y || AX || MOV AX, BX
|-
| 5. || z = x + y || m- || ž6 || ž6 || z || y || AX || ADD AX, BX
|-
| 6. || x = z - y || ž7 || ž7 || m- || x || y || AX || SUB AX, BX
|-
| 7. || z = y - x || ž- || ž- || ž- || x || z || BX || MOV y, BX; SUB BX, AX
|-
| colspan="8" |
| MOV x, AX; MOV z, BX
|}

[[Категорија:Рокови]]
[[Категорија:Програмски преводиоци 1]]

Програмски преводиоци 1/Јануар 2021

2023-06-28T00:18:27Z

WikiEditor: /* Postavka */

{{tocright}}
'''Januarski rok 2021. godine''' održan je 22. januara. Postavka roka je dostupna [http://ir4pp1.etf.rs/Rokovi/2020-2021/pp1_jan2021_ispit.pdf sa stranice predmeta.]

== 1. zadatak ==
=== Postavka ===
Dat je fragmet[sic] gramatike jednog programskog jezika.
# <var_decl> ::= <type> : <id_list>
# <id_list> ::= <id_list> , Ident | Ident
# <type> ::= int | char
<div class="abc-list">
# Napisati atributivnu gramatiku kojom se određuje tip za svaki identifikator u listi (Ident). Jasno naznačiti koji atributi su sintetizovani, a koji nasleđeni.
# Da li je dobijena gramatika S-atributivna ili L-atributivna?
# Dobijenoj atributivnoj gramatici (pod a) dodati neophodne akcije koje obezbeđuju dodavanje simbola u tabelu simbola i postavljanje njihovih tipova. Za pisanje akcija koristiti programski jezik Java i sledeći interfejs tabele simbola.
</div>
<syntaxhighlight lang="java">
class Struct {
static final int None = 0, Int = 1, Char = 2, Arr = 3, Class = 4;
int kind; // None, Int, Char, Arr, Class
boolean equals (Struct other);
}
class Tab {
Obj insert (String name, Struct type) throws AlreadyDeclaredException;
Obj findSymbol (String name) throws SymbolNotFoundException;
}
public class Obj {
public static final int Con = 0, Var = 1, Type = 2, Prog = 5;
public int kind; // Con, Var, Type, Meth, Fld, Prog
public String name;
public Struct type;
}
</syntaxhighlight>

=== Rešenje ===
Atribut <code>t</code> je u sledećoj gramatici sintetizovan, dok su atributi <code>type</code> i <code>idtype</code> nasleđeni. Ispod je prikazana gramatika sa označenim atributima i dodatim akcijama.
# <type>t → int
#: t ← Struct.Int
# <type>t → char
#: t ← Struct.Char
# <id_list>type → <id_list>type1, Identidtype {: <syntaxhighlight lang="java" inline>Tab.insert(new Obj(Obj.Var, ident, new Struct(type)));</syntaxhighlight> :}
#: idtype ← type
#: type1 ← type
# <id_list>type → Identidtype {: <syntaxhighlight lang="java" inline>Tab.insert(new Obj(Obj.Var, ident, new Struct(type)));</syntaxhighlight> :}
#: idtype ← type
# <var_decl> → <type>t : <id_list>type
#: type ← t
Dobijena gramatika je L-atributivna, ali nije S-atributivna.

== 2. zadatak ==
=== Postavka ===
Za sve sekvence oblika ak(bc)pa2p, k ≥ 0, p > 0
<div class="abc-list">
# Napisati gramatiku koja opisuje date sekvence.
# Prikazati potisni automat kojim se prepoznaje isključivo dati skup sekvenci.
</div>

=== Rešenje ===
Gramatika koja opisuje date sekvence bi bila:
# <S> → <A> 
# <A> → ε
# <A> → <A> a
# → bc aa
# → bcaa
{| class="wikitable"
|+ Stanje S1 potisnog automata za opisivanje sekvenci iz drugog zadatka.
! Stanje
! a
! b
! c
! ─┤
|-
! ∇
| ADVANCE
|
* PUSH(A)
* ADVANCE
| REJECT
| REJECT
|-
! A
| REJECT
| REJECT
|
* PUSH(B)
* ADVANCE
| REJECT
|-
! B
| STATE(S2)
| PUSH(A)
| REJECT
| REJECT
|}
{| class="wikitable"
|+ Stanje S2 potisnog automata za opisivanje sekvenci iz drugog zadatka.
! Stanje
! a
! b
! c
! ─┤
|-
! ∇
| REJECT
| REJECT
| REJECT
| ACCEPT
|-
! A
|
* POP
* ADVANCE
| REJECT
| REJECT
| REJECT
|-
! B
|
* POP
* ADVANCE
| REJECT
| REJECT
| REJECT
|}

== 3. zadatak ==
=== Postavka ===
Formirati parser na principu rekurzivnog spusta koji prepoznaje skup sekvenci predstavljenih sledećim produkcijama.
# <S’> → <S> ─┤
# <S> → <A> a 
# <A> → a b b
# → <C> a
# → <D> <C> a
# → ε
# <C> → c <C>
# <C> → ε
# <D> → d

=== Rešenje ===
<syntaxhighlight lang="cpp">
char input;

void terminal(char t) {
if (input == t) {
input = advance();
} else {
reject();
}
}

void A() {
terminal('a');
terminal('b');
B();
terminal('b');
}

void C() {
switch (input) {
case 'c':
terminal('c');
C();
break;
case 'a':
break;
default:
reject();
}
}

void D() {
terminal('d');
}

void B() {
switch (input) {
case 'a':
case 'c':
C();
terminal('a');
break;
case 'd':
D();
C();
terminal('a');
break;
case 'b':
case EOF:
break;
default:
reject();
}
}

void S() {
A();
terminal('a');
B();
}

void main() {
input = advance();
S();
terminal(EOF);
}
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
<div class="abc-list">
# Dat je listing programa napisanog na programskom jeziku Mikrojava. Sve metode unutrašnjih klasa su virtuelne. Globalne metode se pozivaju statički. Napisati kompletan Mikrojava bajtkod prevoda datog programa. Za svaku liniju koda jasno naznačiti koji deo bajtkoda se odnosi na nju.
# Odrediti deo koda koji se nalazi na mestu komentara u datom programu, a kome odgovara dati Mikrojava bajtkod.
</div>
<syntaxhighlight lang="java">
program Januar2021
const int K = 3;
class CL { int p; }
CL global;
{
void m(CL arg)
int y;
{
if(y >= K || y == 0)
global.p++;
else arg.p = K;
}
void main()
int x; int arr[];
{
global = new CL;
arr = new int[3];
arr[K-2] = -arr[x];
m(global);
/* ??? */
}
}
</syntaxhighlight>
<syntaxhighlight lang="asm">
getstatic 0
const_2
load_0
load_1
const_0
aload
mul
add
putfield 1
</syntaxhighlight>

=== Rešenje ===
Prevedeni bajtkod može da izgleda ovako:
<syntaxhighlight lang="asm">
enter 1 2 # void m(CL arg) int y; {
load_1 # if (
const_3
jge 8 # y >= K
load_1
const_0
jne 20 # y == 0)
getstatic 0 # global.p++;
getfield 1
const_1
add
getstatic 0
putfield 1
jmp 8 # else
load_0 # arg.p = K;
const_3
putfield 1
exit # }
return
enter 0 2 # void main() int x; int arr[]; {
new 8 # global = new CL;
putstatic 0
const_3 # arr = new int[3];
newarray 1
store_1
load_1 # arr[K-2] = -arr[x];
const_3
const_2
sub
load_1
load_0
aload
neg
astore
getstatic 0 # m(global);
call ??? (=m) # Verovatno nisu tražili tačan pomeraj?
exit # }
return
</syntaxhighlight>
Linija koda koja fali u programu je:
<syntaxhighlight lang="java">
global.p = 2 + x * arr[0];
</syntaxhighlight>

== 5. zadatak ==
=== Postavka ===
Dat je sledeći fragment (bazični blok) međukoda:
# x = 2
# z = x + 3
# y = z – x
# x = y
# z = x + y
# x = z – y
# z = y – x
<div class="abc-list">
# Za svaku instrukciju u kodu odrediti koje su promenljive žive.
# Korišćenjem algoritma getreg generisati mašinski kod za 80x86 arhitekturu na osnovu datog međukoda i informacija iz tačke a). Pretpostaviti da se koriste dvoadresne mašinske instrukcije gde je prvi operand odredište operacije (oblika ADD dst, src) i da se koriste samo dva registra AX i BX. Rešenje ČITKO upisati u datu tabelu.
</div>

=== Rešenje ===
{| class="wikitable"
|+ Tabela sa traženim informacijama iz zadatka.
! rowspan="2" | Redni broj
! rowspan="2" | Ulaz
! colspan="3" | Život i sledeća upotreba
! colspan="2" | Deskriptori
! rowspan="2" | ''getreg''
! rowspan="2" | Generisani kod
|-
! x
! y
! z
! AX
! BX
|-
| 1. || x = 2 || ž2 || m- || m- || x || - || AX || MOV AX, 2
|-
| 2. || z = x + 3 || ž3 || m- || ž3 || x || z || BX || MOV BX, AX; ADD BX, 3
|-
| 3. || y = z - x || m- || ž4 || m- || x || y || BX || SUB BX, AX
|-
| 4. || x = y || ž5 || ž5 || m- || x || y || AX || MOV AX, BX
|-
| 5. || z = x + y || m- || ž6 || ž6 || z || y || AX || ADD AX, BX
|-
| 6. || x = z - y || ž7 || ž7 || m- || x || y || AX || SUB AX, BX
|-
| 7. || z = y - x || ž- || ž- || ž- || x || z || BX || MOV y, BX; SUB BX, AX
|-
| colspan="8" |
| MOV x, AX; MOV z, BX
|}

[[Категорија:Рокови]]
[[Категорија:Програмски преводиоци 1]]

Програмски преводиоци 1/Јануар 2021

2023-06-28T00:16:39Z

WikiEditor: /* 2 -> 3 */

{{tocright}}
'''Januarski rok 2021. godine''' održan je 22. januara. Postavka roka je dostupna [http://ir4pp1.etf.rs/Rokovi/2020-2021/pp1_jan2021_ispit.pdf sa stranice predmeta.]

== 1. zadatak ==
=== Postavka ===
Dat je fragmet[sic] gramatike jednog programskog jezika.
# <var_decl> ::= <type> : <id_list>
# <id_list> ::= <id_list> , Ident | Ident
# <type> ::= int | char
<div class="abc-list">
# Napisati atributivnu gramatiku kojom se određuje tip za svaki identifikator u listi (Ident). Jasno naznačiti koji atributi su sintetizovani, a koji nasleđeni.
# Da li je dobijena gramatika S-atributivna ili L-atributivna?
# Dobijenoj atributivnoj gramatici (pod a) dodati neophodne akcije koje obezbeđuju dodavanje simbola u tabelu simbola i postavljanje njihovih tipova. Za pisanje akcija koristiti programski jezik Java i sledeći interfejs tabele simbola.
</div>
<syntaxhighlight lang="java">
class Struct {
static final int None = 0, Int = 1, Char = 2, Arr = 3, Class = 4;
int kind; // None, Int, Char, Arr, Class
boolean equals (Struct other);
}
class Tab {
Obj insert (String name, Struct type) throws AlreadyDeclaredException;
Obj findSymbol (String name) throws SymbolNotFoundException;
}
public class Obj {
public static final int Con = 0, Var = 1, Type = 2, Prog = 5;
public int kind; // Con, Var, Type, Meth, Fld, Prog
public String name;
public Struct type;
}
</syntaxhighlight>

=== Rešenje ===
Atribut <code>t</code> je u sledećoj gramatici sintetizovan, dok su atributi <code>type</code> i <code>idtype</code> nasleđeni. Ispod je prikazana gramatika sa označenim atributima i dodatim akcijama.
# <type>t → int
#: t ← Struct.Int
# <type>t → char
#: t ← Struct.Char
# <id_list>type → <id_list>type1, Identidtype {: <syntaxhighlight lang="java" inline>Tab.insert(new Obj(Obj.Var, ident, new Struct(type)));</syntaxhighlight> :}
#: idtype ← type
#: type1 ← type
# <id_list>type → Identidtype {: <syntaxhighlight lang="java" inline>Tab.insert(new Obj(Obj.Var, ident, new Struct(type)));</syntaxhighlight> :}
#: idtype ← type
# <var_decl> → <type>t : <id_list>type
#: type ← t
Dobijena gramatika je L-atributivna, ali nije S-atributivna.

== 2. zadatak ==
=== Postavka ===
Za sve sekvence oblika ak(bc)pa2p, k ≥ 0, p > 0
<div class="abc-list">
# Napisati gramatiku koja opisuje date sekvence.
# Prikazati potisni automat kojim se prepoznaje isključivo dati skup sekvenci.
</div>

=== Rešenje ===
Gramatika koja opisuje date sekvence bi bila:
# <S> → <A> 
# <A> → ε
# <A> → <A> a
# → bc aa
# → bcaa
{| class="wikitable"
|+ Stanje S1 potisnog automata za opisivanje sekvenci iz drugog zadatka.
! Stanje
! a
! b
! c
! ─┤
|-
! ∇
| ADVANCE
|
* PUSH(A)
* ADVANCE
| REJECT
| REJECT
|-
! A
| REJECT
| REJECT
|
* PUSH(B)
* ADVANCE
| REJECT
|-
! B
| STATE(S2)
| PUSH(A)
| REJECT
| REJECT
|}
{| class="wikitable"
|+ Stanje S2 potisnog automata za opisivanje sekvenci iz drugog zadatka.
! Stanje
! a
! b
! c
! ─┤
|-
! ∇
| REJECT
| REJECT
| REJECT
| ACCEPT
|-
! A
|
* POP
* ADVANCE
| REJECT
| REJECT
| REJECT
|-
! B
|
* POP
* ADVANCE
| REJECT
| REJECT
| REJECT
|}

== 3. zadatak ==
=== Postavka ===
Formirati parser na principu rekurzivnog spusta koji prepoznaje skup sekvenci predstavljenih sledećim produkcijama.
# <S’> → <S> ─┤
# <S> → <A> a 
# <A> → a b b
# → <C> a
# → <D> <C> a
# → ε
# <C> → c <C>
# <C> → ε
# <D> → d

=== Rešenje ===
<syntaxhighlight lang="cpp">
char input;

void terminal(char t) {
if (input == t) {
input = advance();
} else {
reject();
}
}

void A() {
terminal('a');
terminal('b');
B();
terminal('b');
}

void C() {
switch (input) {
case 'c':
terminal('c');
C();
break;
case 'a':
break;
default:
reject();
}
}

void D() {
terminal('d');
}

void B() {
switch (input) {
case 'a':
case 'c':
C();
terminal('a');
break;
case 'd':
D();
C();
terminal('a');
break;
case 'b':
case EOF:
break;
default:
reject();
}
}

void S() {
A();
terminal('a');
B();
}

void main() {
input = advance();
S();
terminal(EOF);
}
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
<div class="abc-list">
# Dat je listing programa napisanog na programskom jeziku Mikrojava. Sve metode unutrašnjih klasa su virtuelne. Globalne metode se pozivaju statički. Napisati kompletan Mikrojava bajtkod prevoda datog programa. Za svaku liniju koda jasno naznačiti koji deo bajtkoda se odnosi na nju.
# Odrediti deo koda koji se nalazi na mestu komentara u datom programu, a kome odgovara dati Mikrojava bajtkod.
</div>
<syntaxhighlight>
program Januar2021
const int K = 3;
class CL { int p; }
CL global;
{
void m(CL arg)
int y;
{
if(y >= K || y == 0)
global.p++;
else arg.p = K;
}
void main()
int x; int arr[];
{
global = new CL;
arr = new int[3];
arr[K-2] = -arr[x];
m(global);
/* ??? */
}
}
</syntaxhighlight>
<syntaxhighlight lang="asm">
getstatic 0
const_2
load_0
load_1
const_0
aload
mul
add
putfield 1
</syntaxhighlight>

=== Rešenje ===
Prevedeni bajtkod može da izgleda ovako:
<syntaxhighlight lang="asm">
enter 1 2 # void m(CL arg) int y; {
load_1 # if (
const_3
jge 8 # y >= K
load_1
const_0
jne 20 # y == 0)
getstatic 0 # global.p++;
getfield 1
const_1
add
getstatic 0
putfield 1
jmp 8 # else
load_0 # arg.p = K;
const_3
putfield 1
exit # }
return
enter 0 2 # void main() int x; int arr[]; {
new 8 # global = new CL;
putstatic 0
const_3 # arr = new int[3];
newarray 1
store_1
load_1 # arr[K-2] = -arr[x];
const_3
const_2
sub
load_1
load_0
aload
neg
astore
getstatic 0 # m(global);
call ??? (=m) # Verovatno nisu tražili tačan pomeraj?
exit # }
return
</syntaxhighlight>
Linija koda koja fali u programu je:
<syntaxhighlight lang="java">
global.p = 2 + x * arr[0];
</syntaxhighlight>

== 5. zadatak ==
=== Postavka ===
Dat je sledeći fragment (bazični blok) međukoda:
# x = 2
# z = x + 3
# y = z – x
# x = y
# z = x + y
# x = z – y
# z = y – x
<div class="abc-list">
# Za svaku instrukciju u kodu odrediti koje su promenljive žive.
# Korišćenjem algoritma getreg generisati mašinski kod za 80x86 arhitekturu na osnovu datog međukoda i informacija iz tačke a). Pretpostaviti da se koriste dvoadresne mašinske instrukcije gde je prvi operand odredište operacije (oblika ADD dst, src) i da se koriste samo dva registra AX i BX. Rešenje ČITKO upisati u datu tabelu.
</div>

=== Rešenje ===
{| class="wikitable"
|+ Tabela sa traženim informacijama iz zadatka.
! rowspan="2" | Redni broj
! rowspan="2" | Ulaz
! colspan="3" | Život i sledeća upotreba
! colspan="2" | Deskriptori
! rowspan="2" | ''getreg''
! rowspan="2" | Generisani kod
|-
! x
! y
! z
! AX
! BX
|-
| 1. || x = 2 || ž2 || m- || m- || x || - || AX || MOV AX, 2
|-
| 2. || z = x + 3 || ž3 || m- || ž3 || x || z || BX || MOV BX, AX; ADD BX, 3
|-
| 3. || y = z - x || m- || ž4 || m- || x || y || BX || SUB BX, AX
|-
| 4. || x = y || ž5 || ž5 || m- || x || y || AX || MOV AX, BX
|-
| 5. || z = x + y || m- || ž6 || ž6 || z || y || AX || ADD AX, BX
|-
| 6. || x = z - y || ž7 || ž7 || m- || x || y || AX || SUB AX, BX
|-
| 7. || z = y - x || ž- || ž- || ž- || x || z || BX || MOV y, BX; SUB BX, AX
|-
| colspan="8" |
| MOV x, AX; MOV z, BX
|}

[[Категорија:Рокови]]
[[Категорија:Програмски преводиоци 1]]

Програмски преводиоци 1/Јануар 2021

2023-06-28T00:16:15Z

WikiEditor: /* 4. zadatak - fali deo postavke*/

{{tocright}}
'''Januarski rok 2021. godine''' održan je 22. januara. Postavka roka je dostupna [http://ir4pp1.etf.rs/Rokovi/2020-2021/pp1_jan2021_ispit.pdf sa stranice predmeta.]

== 1. zadatak ==
=== Postavka ===
Dat je fragmet[sic] gramatike jednog programskog jezika.
# <var_decl> ::= <type> : <id_list>
# <id_list> ::= <id_list> , Ident | Ident
# <type> ::= int | char
<div class="abc-list">
# Napisati atributivnu gramatiku kojom se određuje tip za svaki identifikator u listi (Ident). Jasno naznačiti koji atributi su sintetizovani, a koji nasleđeni.
# Da li je dobijena gramatika S-atributivna ili L-atributivna?
# Dobijenoj atributivnoj gramatici (pod a) dodati neophodne akcije koje obezbeđuju dodavanje simbola u tabelu simbola i postavljanje njihovih tipova. Za pisanje akcija koristiti programski jezik Java i sledeći interfejs tabele simbola.
</div>
<syntaxhighlight lang="java">
class Struct {
static final int None = 0, Int = 1, Char = 2, Arr = 3, Class = 4;
int kind; // None, Int, Char, Arr, Class
boolean equals (Struct other);
}
class Tab {
Obj insert (String name, Struct type) throws AlreadyDeclaredException;
Obj findSymbol (String name) throws SymbolNotFoundException;
}
public class Obj {
public static final int Con = 0, Var = 1, Type = 2, Prog = 5;
public int kind; // Con, Var, Type, Meth, Fld, Prog
public String name;
public Struct type;
}
</syntaxhighlight>

=== Rešenje ===
Atribut <code>t</code> je u sledećoj gramatici sintetizovan, dok su atributi <code>type</code> i <code>idtype</code> nasleđeni. Ispod je prikazana gramatika sa označenim atributima i dodatim akcijama.
# <type>t → int
#: t ← Struct.Int
# <type>t → char
#: t ← Struct.Char
# <id_list>type → <id_list>type1, Identidtype {: <syntaxhighlight lang="java" inline>Tab.insert(new Obj(Obj.Var, ident, new Struct(type)));</syntaxhighlight> :}
#: idtype ← type
#: type1 ← type
# <id_list>type → Identidtype {: <syntaxhighlight lang="java" inline>Tab.insert(new Obj(Obj.Var, ident, new Struct(type)));</syntaxhighlight> :}
#: idtype ← type
# <var_decl> → <type>t : <id_list>type
#: type ← t
Dobijena gramatika je L-atributivna, ali nije S-atributivna.

== 2. zadatak ==
=== Postavka ===
Za sve sekvence oblika ak(bc)pa2p, k ≥ 0, p > 0
<div class="abc-list">
# Napisati gramatiku koja opisuje date sekvence.
# Prikazati potisni automat kojim se prepoznaje isključivo dati skup sekvenci.
</div>

=== Rešenje ===
Gramatika koja opisuje date sekvence bi bila:
# <S> → <A> 
# <A> → ε
# <A> → <A> a
# → bc aa
# → bcaa
{| class="wikitable"
|+ Stanje S1 potisnog automata za opisivanje sekvenci iz drugog zadatka.
! Stanje
! a
! b
! c
! ─┤
|-
! ∇
| ADVANCE
|
* PUSH(A)
* ADVANCE
| REJECT
| REJECT
|-
! A
| REJECT
| REJECT
|
* PUSH(B)
* ADVANCE
| REJECT
|-
! B
| STATE(S2)
| PUSH(A)
| REJECT
| REJECT
|}
{| class="wikitable"
|+ Stanje S2 potisnog automata za opisivanje sekvenci iz drugog zadatka.
! Stanje
! a
! b
! c
! ─┤
|-
! ∇
| REJECT
| REJECT
| REJECT
| ACCEPT
|-
! A
|
* POP
* ADVANCE
| REJECT
| REJECT
| REJECT
|-
! B
|
* POP
* ADVANCE
| REJECT
| REJECT
| REJECT
|}

== 3. zadatak ==
=== Postavka ===
Formirati parser na principu rekurzivnog spusta koji prepoznaje skup sekvenci predstavljenih sledećim produkcijama.
# <S’> → <S> ─┤
# <S> → <A> a 
# <A> → a b b
# → <C> a
# → <D> <C> a
# → ε
# <C> → c <C>
# <C> → ε
# <D> → d

=== Rešenje ===
<syntaxhighlight lang="cpp">
char input;

void terminal(char t) {
if (input == t) {
input = advance();
} else {
reject();
}
}

void A() {
terminal('a');
terminal('b');
B();
terminal('b');
}

void C() {
switch (input) {
case 'c':
terminal('c');
C();
break;
case 'a':
break;
default:
reject();
}
}

void D() {
terminal('d');
}

void B() {
switch (input) {
case 'a':
case 'c':
C();
terminal('a');
break;
case 'd':
D();
C();
terminal('a');
break;
case 'b':
case EOF:
break;
default:
reject();
}
}

void S() {
A();
terminal('a');
B();
}

void main() {
input = advance();
S();
terminal(EOF);
}
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
<div class="abc-list">
# Dat je listing programa napisanog na programskom jeziku Mikrojava. Sve metode unutrašnjih klasa su virtuelne. Globalne metode se pozivaju statički. Napisati kompletan Mikrojava bajtkod prevoda datog programa. Za svaku liniju koda jasno naznačiti koji deo bajtkoda se odnosi na nju.
# Odrediti deo koda koji se nalazi na mestu komentara u datom programu, a kome odgovara dati Mikrojava bajtkod.
</div>
<syntaxhighlight>
program Januar2021
const int K = 3;
class CL { int p; }
CL global;
{
void m(CL arg)
int y;
{
if(y >= K || y == 0)
global.p++;
else arg.p = K;
}
void main()
int x; int arr[];
{
global = new CL;
arr = new int[3];
arr[K-2] = -arr[x];
m(global);
/* ??? */
}
}
</syntaxhighlight>
<syntaxhighlight lang="asm">
getstatic 0
const_2
load_0
load_1
const_0
aload
mul
add
putfield 1
</syntaxhighlight>

=== Rešenje ===
Prevedeni bajtkod može da izgleda ovako:
<syntaxhighlight lang="asm">
enter 1 2 # void m(CL arg) int y; {
load_1 # if (
const_3
jge 8 # y >= K
load_1
const_0
jne 20 # y == 0)
getstatic 0 # global.p++;
getfield 1
const_1
add
getstatic 0
putfield 1
jmp 8 # else
load_0 # arg.p = K;
const_3
putfield 1
exit # }
return
enter 0 2 # void main() int x; int arr[]; {
new 8 # global = new CL;
putstatic 0
const_3 # arr = new int[3];
newarray 1
store_1
load_1 # arr[K-2] = -arr[x];
const_3
const_2
sub
load_1
load_0
aload
neg
astore
getstatic 0 # m(global);
call ??? (=m) # Verovatno nisu tražili tačan pomeraj?
exit # }
return
</syntaxhighlight>
Linija koda koja fali u programu je:
<syntaxhighlight lang="java">
global.p = 2 + x * arr[0];
</syntaxhighlight>

== 5. zadatak ==
=== Postavka ===
Dat je sledeći fragment (bazični blok) međukoda:
# x = 2
# z = x + 3
# y = z – x
# x = y
# z = x + y
# x = z – y
# z = y – x
<div class="abc-list">
# Za svaku instrukciju u kodu odrediti koje su promenljive žive.
# Korišćenjem algoritma getreg generisati mašinski kod za 80x86 arhitekturu na osnovu datog međukoda i informacija iz tačke a). Pretpostaviti da se koriste dvoadresne mašinske instrukcije gde je prvi operand odredište operacije (oblika ADD dst, src) i da se koriste samo dva registra AX i BX. Rešenje ČITKO upisati u datu tabelu.
</div>

=== Rešenje ===
{| class="wikitable"
|+ Tabela sa traženim informacijama iz zadatka.
! rowspan="2" | Redni broj
! rowspan="2" | Ulaz
! colspan="3" | Život i sledeća upotreba
! colspan="2" | Deskriptori
! rowspan="2" | ''getreg''
! rowspan="2" | Generisani kod
|-
! x
! y
! z
! AX
! BX
|-
| 1. || x = 2 || ž2 || m- || m- || x || - || AX || MOV AX, 2
|-
| 2. || z = x + 3 || ž3 || m- || ž3 || x || z || BX || MOV BX, AX; ADD BX, 2
|-
| 3. || y = z - x || m- || ž4 || m- || x || y || BX || SUB BX, AX
|-
| 4. || x = y || ž5 || ž5 || m- || x || y || AX || MOV AX, BX
|-
| 5. || z = x + y || m- || ž6 || ž6 || z || y || AX || ADD AX, BX
|-
| 6. || x = z - y || ž7 || ž7 || m- || x || y || AX || SUB AX, BX
|-
| 7. || z = y - x || ž- || ž- || ž- || x || z || BX || MOV y, BX; SUB BX, AX
|-
| colspan="8" |
| MOV x, AX; MOV z, BX
|}

[[Категорија:Рокови]]
[[Категорија:Програмски преводиоци 1]]

Заштита података/Јул 2021

2023-04-20T00:28:48Z

WikiEditor: /* 1. zadatak */

{{tocright}}
{{nerešeno}}
{{rešenja}}

== 1. zadatak ==
Ana i Branko razmenjuju ključ Diffie-Hellman algoritmom. Za tu svrhu koriste prost broj 10007 i njegov primitivni koren 3073. Ana je za svoj privatni broj odredila 3072, a Branko 520. Odrediti:
<div class="abc-list">
# Javni broj koji je izračunala Ana 3374
# Javni broj koji je izračunao Branko 5388
# Ključ koji je razmenjen 1876
</div>

== 2. zadatak ==
Marko treba da plati uslugu n bitkoina u blokčejnu koji koristi SHA-256 heš funkciju i stoga formira transakciju t1 sa iznosom n kojim se plaća usluga. Kako bi smanjio svoju obavezu i prevario prodavca usluge Marko želi da napravi drugu transakciju t2 čija je vrednost manja od n i da je podmetne umesto t1. Koliko če različitih transakcija Marko morati da napravi da bi sa verovatnoćom 0.5 uspeo da napravi zadovoljavajuću transakciju t2?

Podrazumeva se da zamena transakcije treba da bude takva da nema novog rudarenja. Odgovor upisati u polje, operacija stepenovanja treba da se
označi simbolom ^.

Odgovor: nerešeno

Ako se zna da blokčejn ima u svakom bloku 2048 transakcija, koliko je heš operacija potrebno da se izvrši da bi se izračunao "Transaction hash" ?

Odgovor: nerešeno

== 3. zadatak ==
Na slici je dat prvi deo Kerberos v4 autentikacije:

<math> (1) \quad \mathbf{C \rightarrow AS} \quad ID_c \parallel ID_{tgs} \parallel TS_1 </math>

<math> (2) \quad \mathbf{AS \rightarrow C} \quad E\left( K_c, \left[ \qquad \parallel TS_2 \parallel Lifetime_2 \parallel Ticket_{tgs} \right] \right) </math>

<math> \qquad Ticket_{tgs} = E\left( K_{tgs}, \left[ \qquad \parallel TS_2 \parallel Lifetime_2 \right] \right) </math>

Elementi koji nedostaju u poruci (2) (ne i u Tickettgs) su:
<div class="abc-list" data-solution="multiple">
# identifikator servera AS
# identifikator TGS
# identifikator klijenta C
# IP adresa servera V
# IP adresa klijenta C
# IP adresa servera AS
# ključ kojim komuniciraju klijent i autentikacioni server AS
# ključ kojim komuniciraju klijent i server V
# identifikator servera V
# ključ kojim komuniciraju klijent i TGS
</div>

== 4. zadatak ==
: ''Isti zadatak kao sa [[Заштита података/К 2022#5. zadatak|kolokvijuma za RTI 2022. godine]].''

== 5. zadatak ==
MAC algoritam koji daje MAC kod veličine 32 bita ima ključ veličine 100 bita. Ako je raspodela MAC kodova koji daje algoritam uniformna i sve vrednosti su jednako verovatne, da bi otkrio ključ koji se koristi za generisanje MAC kodova napadaču će trebati:

nerešeno različita para/različitih parova (poruka,MAC(poruka)).

Da izvrši nerešeno MAC operacija (za prikaz operacije stepenovanja koristiti simbol ^).

== 6. zadatak ==
Firma F ima centralu koja se nalazi u Helsinkiju. Na centralnoj lokaciji se nalazi 5 web aplikacija kojima se pružaju interne poslovne usluge. Sve aplikacije koriste HTTPS. F ima 10 zaposlenih u svojoj ispostavi u Pragu. Ako se zna da svi zaposleni u ispostavi svakog radnog dana koriste svih 5 aplikacija na centralnoj lokaciji i da se povezuju na svaku od aplikacija dva puta: jednom na početku radnog dana i jednom nakon pauze, tokom svakog
radnog dana će se:
<div class="abc-list">
# generisati ukupno nerešeno različitih kriptografskih ključeva potrebnih za zaštitu web saobraćaja TLS-om svih web sesija (uneti broj)
# izvršiti nerešeno razmena ključeva (uneti broj)
# Ako se između lokacija firme u Helsinkiju i Pragu za zaštitu podataka između radnika i web aplikacija koristi site-to-site IPsec sa main modom razmene koji se vrši svake prve nedelje u mesecu u 23:00 i quick modom koji se vrši svaki dan u ponoć i ne koristi se TLS na web aplikacijama, onda če se svaki dan izvršiti nerešeno razmena ključeva. (uneti broj)
</div>

== 7. zadatak ==
Kod kojih od navedenih kriptografskih algoritama učestanost pojavljivanja simbola/slova u šifrovanom tekstu ima istu raspodelu kao učestanost
pojavljivanja slova u originalnom tekstu?
<div class="abc-list" data-solution="multiple">
# RSA algoritam
# ''Row transposition'' algoritam
# ''Vigenere'' algoritam sa autokey poboljšanjem
# Rotor mašina/Enigma
# Monoalfabetska šifra sa Gausovim poboljšanjem
# Monoalfabetska šifra
# ''Playfair'' algoritam
# ''Rail-fence'' algoritam
# ''Vigenere'' algoritam
# ''One-time pad''
# ''Hill''-ov algoritam
# Cezarov algoritam
</div>

== 8. zadatak ==
Data je šema El Gamalovog algoritma za digitalno potpisivanje (m je hash poruke M):
Za ovako formiran digitalni potpis važi sledeće:

<math> S_1 = \alpha^K mod q </math>

<math> S_2 = K^{-1}\left( m - X_AS_1 \right) mod (q-1) </math>

Izaberite jedan ili više odgovora:
<div class="abc-list" data-solution="multiple">
# Vrednosti koje su potrebne prijemnoj strani za proveru digitalnog potpisa su: k, α i q
# Za jednu poruku M može da postoji više različitih ispravnih vrednosti digitalnog potpisa (S1 ,S2)
# Vrednosti koje su potrebne prijemnoj strani za proveru digitalnog potpisa su: α, q,i YA
# Ukoliko se promeni poruka M, promeniće se vrednost celog digitalnog potpisa i S1 i S2
# Potpis je ispravan ukoliko je S1=S2
# Ukoliko se promeni poruka M, promeniće se vrednost S2
# Za jednu poruku M postoji tačno jedna ispravna vrednost digitalnog potpisa (S1 ,S2)
# Vrednosti koje su potrebne prijemnoj strani za proveru digitalnog potpisa su: k, α, q i YA
# Ukoliko se promeni poruka M, promeniće se vrednost S1
# Vrednosti koje su potrebne prijemnoj strani za proveru digitalnog potpisa su: α i q
</div>

== 9. zadatak ==
Originalnu poruku 00111100b propustiti kroz SDES algoritam korišćenjem ključa 0011001100b. Detalji algoritma dati su u nastavku.
{| class="wikitable"
|+ PC1:
| 3 || 5 || 2 || 7 || 4 || 10 || 1 || 9 || 8 || 6
|}
Rotacija: 1. iteracija za 1, 2. iteracija za 2
{| class="wikitable"
|+ PC2:
| 6 || 3 || 7 || 4 || 8 || 5 || 10 || 9
|}
{| class="wikitable"
|+ IP:
| 2 || 6 || 3 || 1 || 4 || 8 || 5 || 7
|}
{| class="wikitable"
|+ IP-1:
| 4 || 1 || 3 || 5 || 7 || 2 || 8 || 6
|}
{| class="wikitable"
|+ E:
| 4 || 1 || 2 || 3 || 2 || 3 || 4 || 1
|}
{| class="wikitable"
|+ S1:
| 1 || 0 || 3 || 2
|-
| 3 || 2 || 1 || 0
|-
| 0 || 2 || 1 || 3
|-
| 3 || 1 || 0 || 2
|}
{| class="wikitable"
|+ S2:
| 0 || 1 || 2 || 3
|-
| 2 || 0 || 1 || 3
|-
| 3 || 0 || 1 || 2
|-
| 2 || 1 || 0 || 3
|}
{| class="wikitable"
|+ P:
| 2 || 4 || 3 || 1
|}
Napomena: Sve vrednosti pisati u binarnom obliku bez sufiksa "b".
<div class="abc-list">
# Koja je vrednost ključa prve iteracije 01011100
# Koja je vrednost ključa druge iteracije 11000000
# Koja je vrednost poruke nakon inicijalne permutacije 01101010
# Koja je vrednost poruke nakon prolaska kroz funkciju iteracije za prvu iteraciju 11001010
# Koja je vrednost poruke nakon prve iteracije 10101100
# Koja je vrednost šifrovane poruke 11010001
</div>
Objašnjenje: Pretpostavlja se da se u stavci pod d mislilo na izlaz <math>f_K</math> bloka, a u stavci pod e na izlaz <math>SW</math> bloka.

== 10. zadatak ==
Na slici je dat deo PGP šeme na strani slanja za obezbeđivanje nerešeno poruke.

Z predstavlja operaciju kompresije, a operacije EC i EP su operacije šifrovanja.
[[Датотека:ZP jul 2021 zadatak 10.svg|center|frame|PGP šema u desetom zadatku.]]
Ako stranu slanja označimo sa X, a stranu prijema sa Y onda:
<div class="abc-list" data-solution="select" data-options="Ks,PUx,PUy,PRx,PRy">
# na mestu označenom brojem 1 se koristi ključ nerešeno
# na mestu označenom brojem 2 se koristi ključ nerešeno
</div>
Ukoliko se šemom obezbeđuje i kompresija tada se poruka propušta kroz ZIP algoritam na poziciji nerešeno

== 11. zadatak ==

== 12. zadatak ==
Za svaki od sledećih scenarija, odrediti o kom malicioznom softveru je reč.
<div class="abc-list" data-solution="select" data-options="logička bomba,zadnja vrata,zombi,keylogger,flooder,downloader,adware,ransomware">
# Dati maliciozni kod se propagira na druge mašine korišćenjem crva. Nakon propagacije, cilj datog softvera je da koristi zaraženu mašinu za napade na druge mašine. Maliciozni softver koji je opisan je nerešeno.
# Nikoli, studentu Elektrotehničkog fakulteta, poslat je mejl sa linkom ka sajtu preko kojeg može da preuzme desktop verziju eStudent aplikacije. Kada je Nikola preuzeo i pokrenuo aplikaciju, svi podaci sa Nikolinog računara su postali ograničeni samo na napadače, koji poseduju odgovarajući ključ. Maliciozni softver koji je Nikola iskoristio je ransomware.
# Marina je preko USBa postavila maliciozni softver na nastavnički računar u sale 309 u toku pauze između časova. Dok je trajao čas, nastavnik se prijavio na Moodle sistem kako bi studentima pokazao rešenja zadataka sa kolokvijuma. Maliciozni softver je zapamtio podatke koje je uneo nastavnik i omogućio Marini da vidi pitanja za popravni kolokvijum. Maliciozni softver koji je Marina iskoristila je keylogger. Koji tip napadača je Marina? nerešeno
</div>

== 13. zadatak ==

[[Категорија:Рокови]]
[[Категорија:Заштита података]]

Веб дизајн

2022-07-14T13:39:23Z

WikiEditor: Веб дизајн

{{Предмет
| шифра = 13С112ВД, 13С113ВД
| семестар = 4, 6, 8
| статус = изборни
| страница = [https://rti.etf.bg.ac.rs/rti/si2vd/ rti.etf.rs/rti/si2vd]
}}
'''Веб дизајн''' је изборни предмет у четвртом, шестом и осмом семестру на СИ.

== Корисне везе ==
{{непотпун одељак}}



== Настава ==
Настава се одржава у три блока (подељено по колоквијумима):
* '''Први блок:''' ''HTML'', ''CSS'' и ''Bootstrap 5'' (предавања и вежбе обрађују исто градиво, али су вежбе довољне)
На колоквијуму долази један задатак тежине сличне као што је рађено на последњим вежбама, време израде је 90 минута, вреди 25 поена. Доступна online документација, као и презентације са предавања и вежби. Презентације са вежби су јако корисне. Често може доћи нешто одатле.
* '''Други блок:''' ''JavaScript'' и ''JQuery'' (предавања и вежбе обрађују исто градиво, али су вежбе довољне)
На колоквијуму долази један задатак, на пример у виду игрице, време израде је 90 минута, вреди 25 поена. HTML је веома једноставан и дизајн се уопште не тражи, док је акценат на ''JavaScript''. Одређен део задатка је обавезно урадити коришћењем ''JQuery'' библиотеке. За овај део градива не постоје тако корисне презентације са вежби као за први блок, али су на колоквијуму доступне све презентације са предавања и вежби и online документација.
* '''Трећи блок:''' ''Vue.js framework'' (само на вежбама) и основе графичког дизајна (само на предавањима).
На колоквијуму долази један задатак из ''Vue'', тежине јако сличне као што је рађено на последњим вежбама, вреди 15 поена и један задатак који покрива градиво са предавања из овог блока градива, вреди 10 поена. Укупно време израде је 90 минута. Од материјала на самом колоквијуму, доступно је оно што је доступно за први и други колоквијум. Никакви материјали ни документација нису били доступни за ''Vue'', као ни презентације са предавања за трећи блок.

Презентације са предавања и вежби могу се наћи на страници предмета, у одељку Материјали.

== Пројекат ==
Пројекат вреди 15 поена. Потребно је направити веб сајт на задату тему. Ради се у пару или самостално. Излази у мају и могуће је бранити га у јуну и јулу. Одбрана представља кратко презентовање пројекта.

== Лабораторијске вежбе ==
Лабораторијска вежба вреди 10 поена и се састоји од једног домаћег задатка који је потребно одрадити коришћењем ''JavaScript''-а. Оцењује се и дизајн и захтеване функционалности. Постоји само један рок за предају, у мају. Не постоји одбрана, већ асистетни оцењују предат домаћи.

== Испитни рокови ==
На страници предмета су доступне [https://rti.etf.bg.ac.rs/rti/si2vd/rokovi/ поставке рокова,] али решења нису доступна за сваки рок. Следећи рокови су доступни са викија:
{{#dpl:
| namespace =
| category = Веб дизајн
| category = Рокови
| format = ,\n* [[%PAGE%|²{#invoke:String|sub|%PAGE%|12|-1}²]],,
| ordermethod = title
}}

== Начин оцењивања ==
* <math>K_1, K_2</math> — бодови са првог и другог колоквијума (сваки по 25 бодова)
* <math>L_2</math> — бодови са друге лабораторијске вежбе (10 бодова)
* <math>Pr</math> — бодови са пројекта (15 бодова)
* <math>K_3</math> — бодови са испита (25 бодова)
* Коначни бодови: <math>P = K_1 + K_2 + L_2 + Pr + K_3</math>

У јунском року је могуће поправити <math>K_1</math> и <math>K_2</math>, док је од јулског рока могуће радити само <math>K_3</math> или интегрални испит.

== Потребна помоћ ==
* {{zadaci|postavke}}

ОС1/Јун 2018

2021-09-22T22:28:18Z

WikiEditor: /* i ovde ide prev */

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2018/jun/Jun%202018.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Objasniti razliku između pojmova ''proces'' i ''nit'' (engl. ''thread'').

=== Rešenje ===
Proces je jedno izvršavanje programa sa jednim adresnim prostorom. Nit (''thread'') ili laki proces je tok kontrole koji teče uporedo sa drugim tokovima kontrole, ali koji deli virtuelni adresni prostor sa nekim drugim tokom ili tokovima kontrole.

== 2. zadatak ==
=== Postavka ===
Korišćenjem standardnih bibliotečnih operacija <code>setjmp</code> i <code>longjmp</code>, implementirati operaciju ''wait'' na binarnom semaforu koji je realizovan klasom <code>Event</code> poput one u školskom jezgru.

=== Rešenje ===
<syntaxhighlight lang="cpp">
void Event::wait() {
if (val == 1) {
val = 0;
} else {
if (setjmp(Thread::running->context) == 0) {
blocked.put(running);
Thread::running = Scheduler::get();
longjmp(Thread::running->context, 1);
}
}
}
</syntaxhighlight>

== 3. zadatak ==
=== Postavka ===
Korišćenjem sistemskih poziva <code>fork</code> i <code>exec</code>, napisati funkciju <code>run</code> koja kreira proces nad programom u fajlu sa zadatom putanjom i vraća negativnu vrednost u slučaju greške, a <code>pid</code> kreiranog procesa u slučaju uspeha pri <code>fork</code>. Ukoliko ne uspe <code>exec</code>, kreirani proces-dete treba ugasiti.

=== Rešenje ===
<syntaxhighlight lang="cpp">
int run(char* path) {
pid_t pid = fork();
if (pid < 0) {
return -1;
}
if (pid == 0) {
int t = exec(path);
if (t < 0) {
exit(-2);
}
}
return pid;
}
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
Dva procesa pristupaju kritičnoj sekciji. Dat je presudokod jednog od njih, koji bi trebalo da obezbedi međusobno isključenje uposlenim čekanjem (kod drugog procesa izgleda analogno). Da li ovo rešenje obezbeđuje međusobno isključenje? Da li ima neki problem (ako ima, koji)?
<syntaxhighlight lang="milo">
process P1
begin
loop
flag1 := true;
while flag2 = true do null end;
<critical section>
flag1 := false;
<non-critical section>
end
end P1;
</syntaxhighlight>

=== Rešenje ===
Ovo rešenje ne valja jer se dešava ''livelock'' odnosno oba procesa se međusobno zaključaju i ni jedan ni drugi se neće dalje izvršavati. To se desi kada proces P1 postavi <code>flag1</code> na <code>true</code> a zatim se desi promena konteksta i P2 postavi <code>flag2</code> na <code>true</code>.

== 5. zadatak ==
=== Postavka ===
Za koju od ove dve tehnike, dinamičko učitavanje (''dynamic loading'') ili preklopi (''overlays''), se može očekivati duže izvršavanje istog programa u najgorem slučaju? Precizno obrazložiti.

=== Rešenje ===
Duže vreme izvršavanja u najgorem slučaju se može očekivati kod preklopa jer će program stalno učitavati iz memorije iznova i iznova, dok će dinamičko učitavanje zauzeti više memorije, svaki potreban modul će učitati po jednom.

== 6. zadatak ==
=== Postavka ===
U nekom sistemu primenjuje se ''worst-fit'' algoritam kontinualne alokacije memorije. Inicijalno je prostor veličine 256KB potpuno slobodan za alokaciju korisničkih procesa. Potom su različiti procesi zadavali sledeće zahteve (slovna oznaka označava proces koji je postavio zahtev, brojna oznaka označava veličinu alociranog prostora u KB, a minus označava gašenje procesa i oslobađanje njegove memorije): A64, B16, C128, D32, A-, E8, F32, B-

Odgovoriti na sledeća pitanja koja se odnose na stanje memorije nakon ove sekvence zahteva:
# Koliko je ukupno slobodnih fragmenata?
# Kolika je veličina najmanjeg slobodnog fragmenta?
# Kolika je veličina najvećeg slobodnog fragmenta?

=== Rešenje ===
Jedno slovo označava 8KB prostora.
AAAAAAAA------------------------
AAAAAAAABB----------------------
AAAAAAAABBCCCCCCCCCCCCCCCC------
AAAAAAAABBCCCCCCCCCCCCCCCCDDDD--
--------BBCCCCCCCCCCCCCCCCDDDD--
E-------BBCCCCCCCCCCCCCCCCDDDD--
EFFFF---BBCCCCCCCCCCCCCCCCDDDD--
EFFFF-----CCCCCCCCCCCCCCCCDDDD--
* Slobodnih fragmenata: 2
* Najmanji slobodan fragment: 16KB
* Najveći slobodan fragment: 40KB

== 7. zadatak ==
=== Postavka ===
Prilikom preslikavanja virtuelne adrese, procesor je generisao izuzetak zbog pokušaja upisa na tu adresu koji je u deskriptoru stranice označen kao zabranjen. Operativni sistem ipak neće ugasiti taj proces. Precizno objasniti zašto.

=== Rešenje ===
Neće ugasiti program jer se zapravo radi o tehnici ''copy-on-write'' odnosno kopiranja na upis. U ovoj tehnici, MMU vidi tu memoriju kao zabranjenu za upis. Prilikom generisanja greške, OS proverava da li je zabranjena, i kako vidi da zapravo nije nije, to znači da se radi o tehnici kopiranja na upis pa će operativni sistem kopirati stranicu i reći MMU da je dozvoljena za upis.

== 8. zadatak ==
=== Postavka ===
Navesti tri usluge vezane za realno vreme koje operativni sistem može da nudi i predložiti i kratko objasniti funkcije – sistemske pozive za te usluge.

=== Rešenje ===
# Informacija o tekućem realnom vremenu:
#: <syntaxhighlight lang="c" inline>time_t time (time_t* tloc);</syntaxhighlight>
#: Vraća broj sekundi koje su protekle od 1. 1. 1970. u 0 časova. Postoje i bibliotečke funkcije u <code>time.h</code> koje vraćaju “kalendarsko” vreme, rastavljeno na datum i sat itd, a oslanjaju se na ovaj sistemski poziv: <code>asctime</code>, <code>ctime</code>, <code>gmtime</code>, <code>localtime</code>.
# Suspenzija pozivajućeg procesa (“uspavljivanje”) za zadato vreme
#: <syntaxhighlight lang="c" inline>unsigned int sleep (unsigned int seconds);</syntaxhighlight>
# Čekanje na događaje, uslove ili na sinhronizacione primitive, ali vremenski ograničeno (tzv. ''timeout'' kontrole); ako se proces ne deblokira u zadatom vremenu, biće deblokiran zbog isteka vremenske kontrole; npr. za semafore:
#: <syntaxhighlight lang="c" inline>int sem_timedwait (sem_t *sem, const struct timespec *abs_timeout);</syntaxhighlight>

== 9. zadatak ==
=== Postavka ===
Ako je tekući direktorijum nekog procesa <code>/a/b/c</code>, koja je apsolutna putanja do fajla koji taj proces otvara davanjem putanje <code>d/../../e/f.txt</code>?

=== Rešenje ===
Raščlanimo relativnu putanju na delove:
* <code>d</code>: idemo u direktorijum <code>d</code>, sada je putanja <code>/a/b/c/d</code>
* <code>..</code> idemo jedan direktorijum iznad, sada je putanja <code>/a/b/c</code>
* <code>..</code> idemo jedan direktorijum iznad, sada je putanja <code>/a/b</code>
* <code>e</code> idemo u direktorijum <code>e</code>, sada je putanja <code>/a/b/e</code>
* <code>f.txt</code> posećujemo fajl <code>f.txt</code>, krajnja putanja je <code>/a/b/e/f.txt</code>

== 10. zadatak ==
=== Postavka ===
Fajl sistem primenjuje ulančanu alokaciju, s tim da se i slobodni blokovi ulančavaju u listu. U strukturi FCB polje <code>head</code> sadrži broj prvog bloka sa sadržajem fajla, a polje <code>size</code> veličinu sadržaja. Funkcija jezgra <code>free</code> prima kao argument broj prvog bloka u lancu blokova koje treba proglasiti slobodnim. Napisati funkciju jezgra <code>truncate</code> koja briše sadržaj fajla na čiji <code>FCB</code> ukazuje argument.

=== Rešenje ===
Pretpostavimo da <code>free_head</code> i <code>free_tail</code> predstavljaju pokazivače na početak i kraj ulančane liste slobodnih blokova.
<syntaxhighlight lang="c">
void truncate(FCB *f) {
if (f->head == NULL) return;
int numOfBlocks = f->size / BLOCK_SIZE, i = 0, cur = f->head, tmp_head = f->head, prev;
while (i < numOfBlocks) {
free(cur);
prev = cur;
cur = cur->next;
i++;
}
if (free_head == NULL) free_head = tmp_head;
else free_tail->next = prev;
free_tail = prev;
}
</syntaxhighlight>
[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Јун 2018

2021-09-22T15:40:47Z

WikiEditor: /* 10. zadatak */

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2018/jun/Jun%202018.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Objasniti razliku između pojmova ''proces'' i ''nit'' (engl. ''thread'').

=== Rešenje ===
Proces je jedno izvršavanje programa sa jednim adresnim prostorom. Nit (''thread'') ili laki proces je tok kontrole koji teče uporedo sa drugim tokovima kontrole, ali koji deli virtuelni adresni prostor sa nekim drugim tokom ili tokovima kontrole.

== 2. zadatak ==
=== Postavka ===
Korišćenjem standardnih bibliotečnih operacija <code>setjmp</code> i <code>longjmp</code>, implementirati operaciju ''wait'' na binarnom semaforu koji je realizovan klasom <code>Event</code> poput one u školskom jezgru.

=== Rešenje ===
<syntaxhighlight lang="cpp">
void Event::wait() {
if (val == 1) {
val = 0;
} else {
if (setjmp(Thread::running->context) == 0) {
blocked.put(running);
Thread::running = Scheduler::get();
longjmp(Thread::running->context, 1);
}
}
}
</syntaxhighlight>

== 3. zadatak ==
=== Postavka ===
Korišćenjem sistemskih poziva <code>fork</code> i <code>exec</code>, napisati funkciju <code>run</code> koja kreira proces nad programom u fajlu sa zadatom putanjom i vraća negativnu vrednost u slučaju greške, a <code>pid</code> kreiranog procesa u slučaju uspeha pri <code>fork</code>. Ukoliko ne uspe <code>exec</code>, kreirani proces-dete treba ugasiti.

=== Rešenje ===
<syntaxhighlight lang="cpp">
int run(char* path) {
pid_t pid = fork();
if (pid < 0) {
return -1;
}
if (pid == 0) {
int t = exec(path);
if (t < 0) {
exit(-2);
}
}
return pid;
}
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
Dva procesa pristupaju kritičnoj sekciji. Dat je presudokod jednog od njih, koji bi trebalo da obezbedi međusobno isključenje uposlenim čekanjem (kod drugog procesa izgleda analogno). Da li ovo rešenje obezbeđuje međusobno isključenje? Da li ima neki problem (ako ima, koji)?
<syntaxhighlight lang="milo">
process P1
begin
loop
flag1 := true;
while flag2 = true do null end;
<critical section>
flag1 := false;
<non-critical section>
end
end P1;
</syntaxhighlight>

=== Rešenje ===
Ovo rešenje ne valja jer se dešava ''livelock'' odnosno oba procesa se međusobno zaključaju i ni jedan ni drugi se neće dalje izvršavati. To se desi kada proces P1 postavi <code>flag1</code> na <code>true</code> a zatim se desi promena konteksta i P2 postavi <code>flag2</code> na <code>true</code>.

== 5. zadatak ==
=== Postavka ===
Za koju od ove dve tehnike, dinamičko učitavanje (''dynamic loading'') ili preklopi (''overlays''), se može očekivati duže izvršavanje istog programa u najgorem slučaju? Precizno obrazložiti.

=== Rešenje ===
Duže vreme izvršavanja u najgorem slučaju se može očekivati kod preklopa jer će program stalno učitavati iz memorije iznova i iznova, dok će dinamičko učitavanje zauzeti više memorije, svaki potreban modul će učitati po jednom.

== 6. zadatak ==
=== Postavka ===
U nekom sistemu primenjuje se ''worst-fit'' algoritam kontinualne alokacije memorije. Inicijalno je prostor veličine 256KB potpuno slobodan za alokaciju korisničkih procesa. Potom su različiti procesi zadavali sledeće zahteve (slovna oznaka označava proces koji je postavio zahtev, brojna oznaka označava veličinu alociranog prostora u KB, a minus označava gašenje procesa i oslobađanje njegove memorije): A64, B16, C128, D32, A-, E8, F32, B-

Odgovoriti na sledeća pitanja koja se odnose na stanje memorije nakon ove sekvence zahteva:
# Koliko je ukupno slobodnih fragmenata?
# Kolika je veličina najmanjeg slobodnog fragmenta?
# Kolika je veličina najvećeg slobodnog fragmenta?

=== Rešenje ===
Jedno slovo označava 8KB prostora.
AAAAAAAA------------------------
AAAAAAAABB----------------------
AAAAAAAABBCCCCCCCCCCCCCCCC------
AAAAAAAABBCCCCCCCCCCCCCCCCDDDD--
--------BBCCCCCCCCCCCCCCCCDDDD--
E-------BBCCCCCCCCCCCCCCCCDDDD--
EFFFF---BBCCCCCCCCCCCCCCCCDDDD--
EFFFF-----CCCCCCCCCCCCCCCCDDDD--
* Slobodnih fragmenata: 2
* Najmanji slobodan fragment: 16KB
* Najveći slobodan fragment: 40KB

== 7. zadatak ==
=== Postavka ===
Prilikom preslikavanja virtuelne adrese, procesor je generisao izuzetak zbog pokušaja upisa na tu adresu koji je u deskriptoru stranice označen kao zabranjen. Operativni sistem ipak neće ugasiti taj proces. Precizno objasniti zašto.

=== Rešenje ===
Neće ugasiti program jer se zapravo radi o tehnici ''copy-on-write'' odnosno kopiranja na upis. U ovoj tehnici, MMU vidi tu memoriju kao zabranjenu za upis. Prilikom generisanja greške, OS proverava da li je zabranjena, i kako vidi da zapravo nije nije, to znači da se radi o tehnici kopiranja na upis pa će operativni sistem kopirati stranicu i reći MMU da je dozvoljena za upis.

== 8. zadatak ==
=== Postavka ===
Navesti tri usluge vezane za realno vreme koje operativni sistem može da nudi i predložiti i kratko objasniti funkcije – sistemske pozive za te usluge.

=== Rešenje ===
# Informacija o tekućem realnom vremenu:
#: <syntaxhighlight lang="c" inline>time_t time (time_t* tloc);</syntaxhighlight>
#: Vraća broj sekundi koje su protekle od 1. 1. 1970. u 0 časova. Postoje i bibliotečke funkcije u <code>time.h</code> koje vraćaju “kalendarsko” vreme, rastavljeno na datum i sat itd, a oslanjaju se na ovaj sistemski poziv: <code>asctime</code>, <code>ctime</code>, <code>gmtime</code>, <code>localtime</code>.
# Suspenzija pozivajućeg procesa (“uspavljivanje”) za zadato vreme
#: <syntaxhighlight lang="c" inline>unsigned int sleep (unsigned int seconds);</syntaxhighlight>
# Čekanje na događaje, uslove ili na sinhronizacione primitive, ali vremenski ograničeno (tzv. ''timeout'' kontrole); ako se proces ne deblokira u zadatom vremenu, biće deblokiran zbog isteka vremenske kontrole; npr. za semafore:
#: <syntaxhighlight lang="c" inline>int sem_timedwait (sem_t *sem, const struct timespec *abs_timeout);</syntaxhighlight>

== 9. zadatak ==
=== Postavka ===
Ako je tekući direktorijum nekog procesa <code>/a/b/c</code>, koja je apsolutna putanja do fajla koji taj proces otvara davanjem putanje <code>d/../../e/f.txt</code>?

=== Rešenje ===
Raščlanimo relativnu putanju na delove:
* <code>d</code>: idemo u direktorijum <code>d</code>, sada je putanja <code>/a/b/c/d</code>
* <code>..</code> idemo jedan direktorijum iznad, sada je putanja <code>/a/b/c</code>
* <code>..</code> idemo jedan direktorijum iznad, sada je putanja <code>/a/b</code>
* <code>e</code> idemo u direktorijum <code>e</code>, sada je putanja <code>/a/b/e</code>
* <code>f.txt</code> posećujemo fajl <code>f.txt</code>, krajnja putanja je <code>/a/b/e/f.txt</code>

== 10. zadatak ==
=== Postavka ===
Fajl sistem primenjuje ulančanu alokaciju, s tim da se i slobodni blokovi ulančavaju u listu. U strukturi FCB polje <code>head</code> sadrži broj prvog bloka sa sadržajem fajla, a polje <code>size</code> veličinu sadržaja. Funkcija jezgra <code>free</code> prima kao argument broj prvog bloka u lancu blokova koje treba proglasiti slobodnim. Napisati funkciju jezgra <code>truncate</code> koja briše sadržaj fajla na čiji <code>FCB</code> ukazuje argument.

=== Rešenje ===
Pretpostavimo da <code>free_head</code> i <code>free_tail</code> predstavljaju pokazivače na početak i kraj ulančane liste slobodnih blokova.
<syntaxhighlight lang="c">
void truncate(FCB *f) {
if (f->head == NULL) return;
int numOfBlocks = size / BLOCK_SIZE, i = 0, cur = f->head, tmp_head = f->head;
while (i < numOfBlocks) {
free(cur);
cur = cur->next;
i++;
}
if (free_head == NULL) free_head = tmp_head;
else free_tail->next = tmp_head;
free_tail = tmp_head;
}
</syntaxhighlight>
[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Септембар 2015

2021-09-22T15:32:34Z

WikiEditor: dodato resenje za 6.

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2015/sep/Sep%202015.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Prvi interaktivni računarski sistemi uveli su jednu značajnu novinu u operativne sisteme. Koja je to novina? Objasniti ukratko njenu suštinu.

=== Rešenje ===
Novina koja je uvedena je interakcija sa korisnicima preko terminala. Ona je u početku imala probleme sporog i neravnomernog odziva za korisnike, pa su uvedeni koncepti preotimanja procesora i ''time sharing'' mehanizam, koji su omogućili brz i ravnomeran odziv korisnicima.

== 2. zadatak ==
=== Postavka ===
Korišćenjem standardnih bibliotečnih funkcija <code>setjmp()</code> i <code>longjmp()</code>, u školskom jezgru implementirati operaciju <code>yield(Thread* old, Thread* new)</code> koja prebacuje kontekst izvršavanja sa jedne (<code>old</code>) na drugu (<code>new</code>) nit.

=== Rešenje ===
<syntaxhighlight lang = "c">
void yield(Thread* old, Thread* new) {
if(setjmp(old->context) == 0)
longjmp(new->context, 1);
}
</syntaxhighlight>

== 3. zadatak ==
=== Postavka ===
Кorišćenjem školskog jezgra, napraviti nit koja se inicijalizuje celobrojnim parametrom ''n'' i koja kreira jednu istu takvu nit-dete, ova nit-dete kreira jednu svoju nit-dete, i tako dalje, rekurzivno, ali tako da ukupno bude kreirano ''n'' niti.

=== Rešenje ===
<syntaxhighlight lang = "c">
class myThread : public Thread {
public:
myThread(int val) {
n = val;
start();
}
protected:
void run() {
if(n <= 0) return;
else new myThread(n - 1);
}
private:
int n;
};
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
Dato je jedno moguće rešenje za međusobno isključenje dva procesa uposlenim čekanjem. Da li ovo rešenje obezbeđuje međusobno isključenje? Da li ima neki drugi problem?
<syntaxhighlight lang = "ada">
shared var turn : integer = 1;
process P1 process P2
begin begin
loop loop
while turn = 2 do null end; while turn = 1 do null end;
<critical section> <critical section>
turn := 2; turn := 1;
<non-critical section> <non-critical section>
end end
end P1; end P2;
</syntaxhighlight>

=== Rešenje ===
Rešenje obezbeđuje međusobno isključenje ali je problem stroga naizmeničnost što je suvišna sinhronizacija.

== 5. zadatak ==
=== Postavka ===
Šta znači kad je proces ''swapped out''?

Ako je proces swapped out, u kom stanju se od sledećih on nalazi?
# created
# ready
# running
# suspended
# terminated

=== Rešenje ===
Swapped out proces je proces koji je bio izbačen iz memorije i upisan na disk kako bi se u memoriju učitao neki drugi koji se ubacuje memoriju.

Nalazi se u ''suspended'' stanju kada se swap-out-uje.

== 6. zadatak ==
=== Postavka ===
Data je definicija strukture <code>FreeSegment</code> koja predstavlja jedan segment slobodne memorije. Ove strukture uvezane su u dvostruko ulančanu, neuređenu listu čija je glava <code>freeSegHead</code>. Implementirati funkciju <code>getBestFit(size_t)</code> koja treba da pronađe i vrati (ali ne menja ni njega ni listu) segment slobodne memorije u koji se može smestiti blok date veličine, po ''best fit'' algoritmu.
<syntaxhighlight lang = "c">
struct FreeSegment {
size_t size;
FreeSegment *prev, *next;
};
</syntaxhighlight>

=== Rešenje ===
<syntaxhighlight lang = "c">
FreeSegment* getBestFit(size_t s) {
int minDif = INT_MAX;
FreeSegment *tmp = freeSeghead, *ans = 0;
while (tmp) {
if (tmp->size == s) return tmp;
if (tmp->size > s) {
if (tmp->size - s < minDif) {
minDif = tmp->size - s;
ans = tmp;
}
}
tmp = tmp->next;
}
return ans;
}
</syntaxhighlight>

== 7. zadatak ==
=== Postavka ===
Memorija nekog računara organizovana je stranično, sa stranicom veličine 4KB. Adresibilna jedinica je bajt, a virtuelna adresa je 32-bitna. Fizička adresa je veličine 32 bita. Ako je PMT organizovana u dva nivoa, s tim da su veličine polja za broj ulaza u tabele oba nivoa isti, kolika je veličina (u bajtovima) PMT prvog nivoa?

=== Rešenje ===
<code>page: 4KB -> 12b</code>

<code>VA(32) : page1(10) : page2(10) : offset(12)</code>

<code>pmt1_size</code> = <math>2^{10} \cdot 4B = 4KB</math>

== 8. zadatak ==
=== Postavka ===
Kojom tehnikom se nedeljivi uređaj može učiniti virtuelno deljivim?

=== Rešenje ===
Spooling-om.

== 9. zadatak ==
=== Postavka ===
U nekom sistemu simbol <code>.</code> označava tekući, a <code>..</code> roditeljski direktorijum. Koja od sledećih naredbi (svaka se izvršava uspešno) ''sigurno neće'' promeniti tekući direktorijum? (Zaokružiti jedan ili više tačnih odgovora.)
# <code>cd ./../../x/y/z</code>
# <code>cd ./x/y/z/../..</code>
# <code>cd ./../../../x/y/z</code>
# <code>cd ./x/y/z/../../..</code>

=== Rešenje ===
4. naredba sigurno neće promeniti tekući direktorijum.

== 10. zadatak ==
=== Postavka ===
Neki fajl sistem primenjuje FAT za alokaciju sadržaja fajla. FAT je cela keširana u memoriji, na nju ukazuje pokazivač <code>fat</code>, i ima <code>FATSIZE</code> ulaza tipa <code>unsigned</code>. Prilikom ulančavanja blokova sa sadržajem fajla, ''null'' vrednost se označava vrednošću 0 u odgovarajućem ulazu u FAT, dok se slobodni blokove ne ulančavaju posebno, već su njima odgovarajući ulazi u FAT označeni vrednostima <code>~0U</code> (sve jedinice binarno); blokovi broj 0 i broj <code>~0U</code> se ne koriste u fajl sistemu. U FCB polje <code>head</code> tipa <code>unsigned</code> sadrži broj prvog bloka sa sadržajem fajla (0 ako je sadržaj prazan). Napisati kod kojim se oslobađaju svi blokovi sa sadržajem fajla.

=== Rešenje ===
<syntaxhighlight lang = "c">
void clearAll(FCB* file) {
if(file == 0 || file->sizeInBlocks == 0 || file->head == 0) return;
while(file->head) {
auto tmp = file->head;
file->head = file->head->next;
tmp->value = ~0U;
}
}
</syntaxhighlight>

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Фебруар 2014

2021-09-22T15:22:10Z

WikiEditor:

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2014/feb/OS1%20Feb%202014.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Objasniti zašto je i kako uvođenje magnetnih diskova bilo od ključnog značaja kod prelaska sa paketnih sistema na sisteme sa multiprogramiranjem.

=== Rešenje ===
OS može da pristupa disku direktno, u proizvoljnom redosledu, bez značajnih razlika u vremenu odziva kao kod traka (zbog premotavanja) bez obzira na to kako su podaci smešteni na samom disku. Disk je blokovski orijentisan ulazno-izlazni uređaj. Podaci se mogu i učitavati sa diska i upisivati na njega, ali se prenose isključivo u blokovima fiksne veličine. Zbog ovoga je skup poslova koji su podneti na izvršavanje mogao da se snimi na disk a da OS sa njega učitava one koje odluči da će se izvršavati, na osnovu zauzeća procesora i memorije, a ne na osnovu redosleda kojim su podneti.

== 2. zadatak ==
=== Postavka ===
Objasniti kako se međusobno isključenje kritičnih sekcija jezgra operativnog sistema može
obezbediti kod jednosprocesorskih, a kako kod višeprocesorskih sistema.

=== Rešenje ===
#jednosprocesorski sistemi:
#*maskirati prekide
#*zabraniti preuzimanje
#*optimistički pristup
#višeprocesorski sistemi:
#*test-and-set
#*swap

== 3. zadatak ==
=== Postavka ===
Korišćenjem standardnih sistemskih poziva <code>fork()</code> i <code>wait()</code> napisati C program koji kreira tačno ''N'' procesa svoje dece, gde je ''N'' parametar programa, a potom čeka da se sva deca završe. Procesi-deca samo ispišu neku poruku na standardni izlaz i potom se završavaju.

=== Rešenje ===
<syntaxhighlight lang="c">
#include <stdio.h>
int main(int argc, char* argv[]) {
if(argc < 2)
return -1;
int N = atoi(argv[1]);
int pid[N];
for(int i = 0; i < N; i++) {
pid[i] = fork();
if(pid[i] < 0)
return -2;
else if(pid[i] == 0) {
printf("Child %d", i);
exit(0);
}
}
for(int i = 0; i < N; i++)
wait(pid[i]);
return 0;
}
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
Korišćenjem standardnih brojačkih semafora napisati kod za sinhronizaciju proizvođača i potrošača sa neograničenim baferom. (Kod za smeštanje i uzimanje elemenata ne treba pisati, već samo naznačiti njegovo mesto.)

=== Rešenje ===
<syntaxhighlight lang="c">
Semaphore mutex(1), spaceAvailable(N), itemAvailable(0);

void append(Data* d) {
spaceAvailable.wait();
mutex.wait();
<add>
mutex.signal();
itemAvailable.signal();
}

Data* take() {
itemAvailable.wait();
mutex.wait();
<get data>
mutex.signal();
spaceAvailable.signal();
return data;
}
</syntaxhighlight>

== 5. zadatak ==
=== Postavka ===
Ukratko objasniti osnovnu razliku između tehnika dinamičkog učitavanja (''dynamic loading'') i preklopa (''overlays'').

=== Rešenje ===
Videti zadatak iz [[ОС1/Јул 2011#5. zadatak|julskog roka 2011]].

== 6. zadatak ==
=== Postavka ===
Šta je eksterna fragmentacija kod alokacije memorije? Da li je ona moguća kod segmentno-stranične alokacije memorije?

=== Rešenje ===
Eksterna fragmentacija nastaje kada se procesi učitavaju u memoriju a zatim dealociraju. Kako se delovi proizvoljnih dimenzija zauzimaju i oslobađaju dinamički, slobodni fragmenti se stvaraju i nazivaju eksternim.
Nije moguća eksterna fragmentacija kod segmentno-stranične organizacije jer alociraju blokovi iste veličine.

== 7. zadatak ==
=== Postavka ===
U nekom sistemu sa straničnom organizacijom virtuelne memorije virtuelna i fizička adresa su 32-bitne, adresibilna jedinica je bajt, a stranica je veličine 64 KB. PMT je organizovana u dva nivoa i jedan ulaz u PMT oba nivoa zauzima po jednu 32-bitnu reč. PMT oba nivoa su iste veličine. Koliko ukupno zauzimaju PMT za proces koji je alocirao samo svoju prvu i poslednju stranicu?

=== Rešenje ===
Videti zadatak iz [[ОС1/Јануар 2015#7. zadatak|januarskog roka 2015]].

== 8. zadatak ==
=== Postavka ===
Ukratko objasniti tehniku ''spooling''.

=== Rešenje ===
Kada neki nedeljivi spori uređaj želi da odradi posao, prvo se zatraži korišćenje tog uređaja sistemskim pozivom, OS tada pravi poseban fajl na određenom mestu u svom fajl sistemu u koji će preusmeriti sve ulazne operacije tog procesa sa štampačem i vraća kontrolu procesu. OS predaje fajl na obradu posebnom procesu ili niti (spuleru) koji će jedan po jedan fajl da uzima i njihove sadržaje da šalje datom uređaju.

== 9. zadatak ==
=== Postavka ===
Dati procenu kompleksnosti u najgorem slučaju sledećih operacija sa direktorijumom u odnosu na broj postojećih fajlova n u direktorijumu, za navedene implementacije direktorijuma.

=== Rešenje ===
{{delimično rešeno}}

== 10. zadatak ==
=== Postavka ===
Koliko pristupa blokovima na disku treba izvršiti za pristup ''n''-tom logičkom bloku sadržaja fajla ako je alokacija fajla a) indeksna, pri čemu je indeks fajla uvek u dva nivoa, a na blok sa indeksom prvog nivoa ukazuje polje u FCB, b) FAT, pri čemu je cela FAT u memoriji? FCB fajla je u memoriji.

=== Rešenje ===
a) 3
b) 1

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Јануар 2014

2021-09-22T15:18:57Z

WikiEditor:

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2014/jan/OS1%20Jan%202014.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Šta označava termin ''multiprogramiranje'', a šta termin ''multiprocesiranje''?

=== Rešenje ===
Multiprogramiranje označava izvršavanje uporedo više procesa na jednom procesoru. Dok jedan proces čeka na izvršavanje I/O operacije, procesor izvršava druge poslove.

Multiprocesiranje označava izvršavanje procesa fizički paralelno na više procesora.

== 2. zadatak ==
=== Postavka ===
Korišćenjem funkcija <code>setjmp()</code> i <code>longjmp()</code> iz standardne C biblioteke, realizovati operaciju <code>yield(jmp_buf old, jmp_buf new)</code> koja čuva kontekst niti čiji je <code>jmp_buf</code> dat kao prvi argument, oduzima joj procesor i restaurira kontekst niti čiji je <code>jmp_buf</code> dat kao drugi argument, kojoj predaje procesor.

=== Rešenje ===
<syntaxhighlight lang="c">
void yield(jump_buf old, jump_buf new) {
if(setjmp(old) == 0) {
longjmp(new, 1);
}
}
</syntaxhighlight>

== 3. zadatak ==
=== Postavka ===
Na programskom jeziku Java implementirati nit (''thread'') koja izvršava praznu petlju sve dok joj se pozivom operacije ne kaže da stane. Napisati i kod koji pravi i pokreće ''N'' takvih uporednih niti.

=== Rešenje ===
<syntaxhighlight lang="java">
public class Main() {
public static void main(string[] args) {
int n = Integer.ParseInt(args[0]);
for(int i = 0; i < n; i++) {
Thread thread = new Thread() {
@Override
public void run() {
try {
while(!isInterrupted) {}
} catch(InterruptedException e) {};
}
}
thread.start();
}
}
}
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
Korišćenjem standardnih brojačkih semafora napisati kod za uslovnu sinhronizaciju dva uporedna procesa od kojih jedan ispunjava neki logički uslov, a drugi ne sme da prođe određenu tačku ako taj uslov nije ispunjen

=== Rešenje ===
<syntaxhighlight lang="ada">
var semA : Semaphore := 0;
semB : Semaphore := 0;
flag : boolean := false;

process A:
begin
loop
...
flag = true;
signal(semB);
wait(semA);
end
end A;

process B:
begin
loop
wait(semB);
signal(semA);
end
end B;
</syntaxhighlight>

== 5. zadatak ==
=== Postavka ===
Ako tokom svog prvog prolaza linker u svojoj tabeli pronađe prethodno definisan simbol koji je definisan u tekućem fajlu (izvozi se), da li će prijaviti grešku? Obrazložiti.

=== Rešenje ===
Da, jer se već nalazi u tabeli simbola i dolazi do konflikta imena.

== 6. zadatak ==
=== Postavka ===
Šta je interna fragmentacija kod alokacije memorije? Da li je ona moguća kod kontinualne alokacije memorije?

=== Rešenje ===
Interna fragmentacija predstavlja neiskorišćen deo memorije unutar alociranih blokova zbog ograničavanja dozvoljene veličine bloka.
Kod kontinualne alokacije postoji problem eksterne ali ne i interne fragmentacije jer proces zauzima tačno onoliko prostora koliko mu je potrebno.

== 7. zadatak ==
=== Postavka ===
U nekom sistemu sa straničnom organizacijom virtuelne memorije virtuelna adresa je 64-bitna. Posmatraju se dva (teorijska) granična slučaja: a) neki proces koristi ceo svoj virtuelni prostor; b) neki proces koristi samo nekoliko susednih stranica svog virtuelnog prostora. Koji pristup organizacije PMT zauzima manje memorije za PMT za svaki od ova dva slučaja: PMT organizovana u jednom nivou (linearno) ili PMT organizovana u više nivoa? Kratko obrazložiti

=== Rešenje ===
Manje prostora bi zauzimala PMT organizovana u jednom nivou jer bi organizovanje u dva nivoa izazvalo alociranje cele tabele prvog i zatim određen broj tabela 2. nivoa.

== 8. zadatak ==
=== Postavka ===
Kojom tehnikom se može blokovski orijentisani ulazni uređaj koristiti kao znakovno orijentisani ulazni tok? Kratko objasniti kako.

=== Rešenje ===
Tehnikom baferisanja: poseban proces koji kontroliše uređaj. Sa uređaja se uzima blok po blok podataka i stavlja u bafer. Korisnik uzima znak po znak kao znakovno orijentisani ulazni tok.

== 9. zadatak ==
=== Postavka ===
Neki proces izvršava redom sledeće sistemske pozive. Pod pretpostavkom da korisnik u čije ime se izvršava ovaj proces ima pravo pristupa do oba fajla i na čitanje i na upis, i da oba poziva za otvaranje fajlova uspevaju, navesti koji od preostalih poziva će biti uspešan, a koji neuspešan (upisati na liniji pored poziva).
<syntaxhighlight lang = "c">
FHANDLE f1 = fopen(“x.doc”,read);
FHANDLE f2 = fopen(“y.doc”,read|write);
fread(f1,buffer1,n1);
fwrite(f1,buffer2,n2);
fread(f2,buffer1,n1);
fwrite(f2,buffer2,n2);
</syntaxhighlight>

=== Rešenje ===
<syntaxhighlight lang = "c">
fread(f1,buffer1,n1); uspešan
fwrite(f1,buffer2,n2); neuspešan
fread(f2,buffer1,n1); uspešan
fwrite(f2,buffer2,n2); uspešan
</syntaxhighlight>

== 10. zadatak ==
=== Postavka ===
Predložiti i ukratko objasniti neki način vođenja evidencije slobodnih blokova na disku koji ne koristi nikakav dodatni prostor za tu evidenciju (osim tih slobodnih blokova).

=== Rešenje ===
Prvi slobodan blok sadrži broj slobodnih blokova i pokazivač na sledeći.

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Октобар 2014

2021-09-22T15:13:54Z

WikiEditor:

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2014/okt/OS1%20Okt%202014.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Šta je bio osnovni motiv za uvođenje multiprogramiranja u računarske sisteme?

=== Rešenje ===
Videti zadatak iz [[ОС1/Септембар 2011#1. zadatak|septembarskog roka 2011]].

== 2. zadatak ==
=== Postavka ===
Korišćenjem standardnih bibliotečnih operacija <code>setjmp</code> i <code>longjmp</code>, implementirati operaciju <code>wait</code> na binarnom semaforu koji je realizovan klasom <code>Event</code> poput one u školskom jezgru.

=== Rešenje ===
<syntaxhighlight lang="c">
Event::wait() {
lock(lck);
if(--val < 0) {
if(setjmp(Thread::running->context) == 0) {
blocked.put(Thread::running);
Thread::running = Scheduler::get();
longjmp(Thread::running->context, 1);
}
}
unlock(lck);
}
</syntaxhighlight>

== 3. zadatak ==
=== Postavka ===
Na jeziku C, korišćenjem sistemskog poziva <code>fork()</code> za Unix, napisati program koji prihvata celobrojni argument ''n'' i koji, kada se nad njim pokrene proces, pokreće jedan proces-dete i završava se, ovaj proces-dete pokreće svoje dete, itd, tako da ukupno bude ''n'' procesa u relaciji roditelj-dete (''n'' „generacija“).

=== Rešenje ===
<syntaxhighlight lang="c">
int main(int argc, char* argv[]) {
if(argc < 2)
return -1;
int N = atoi(argv[1]);
for(int i = 0; i < N; i++) {
if(fork() != 0) return 0;
}
return 0;
}
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
Korišćenjem standardnih brojačkih semafora u školskom jezgru, na jeziku C++ napisati kod za ograničeni bafer (''bounded buffer'').
=== Rešenje ===
Videti zadatak iz [[ОС1/Јул 2011#4. zadatak|julskog roka 2011]].

== 5. zadatak ==
=== Postavka ===
Koja je osnovna razlika između tehnika dinamičkog učitavanja i preklopa (''overlays'')?

=== Rešenje ===
Videti zadatak iz [[ОС1/Јул 2011#5. zadatak|julskog roka 2011]].

== 6. zadatak ==
=== Postavka ===
Ko i kada upisuje vrednosti u registar bazne adrese i registar ograničenja procesora kod kontinualne alokacije memorije? Ukratko objasniti svrhu ovih registara.

=== Rešenje ===
Kada se kreira novi proces, stavlja se u ulazni red. OS alocira memorijske zahteve u ulaznom redu i trenutno stanje memorije i bira proces za učitavanje. OS učitava izabran proces i upisuje vrednost u base i limit registar. Bazni je koristan kod realokacije procesa a limit služi za zaštitu zauzete memorije jednog procesa od drugog.

== 7. zadatak ==
=== Postavka ===
Primenom tehnike ''copy-on-write'' kod virtuelne memorije, hardver je generisao izuzetak tipa „nedozvoljen upis u adresiranu stranicu“. Precizno objasniti šta dalje radi operativni sistem.

=== Rešenje ===
Kada proces prvi put upisuje u neku deljenu stranicu hardver generiše izuzetak tipa nedozvoljen upis u adresiranu stranicu. Operativni sistem zaključuje da je upis logički dozvoljen ali je stranica deljena, stranica se tada kopira, prestaje da bude deljena.

== 8. zadatak ==
=== Postavka ===
Navesti tipične operacije apstrakcije blokovski orijentisanog izlaznog uređaja sa '''sekvencijalnim''' pristupom.
=== Rešenje ===
{{delimično rešeno}}

== 9. zadatak ==
=== Postavka ===
Neki proces izvršava sistemski poziv za upis u fajl koji je prethodno uspešno otvorio i sistem mu to ne dozvoljava, sa porukom da tom procesu nije dozvoljena ta operacija, iako je korisniku u čije ime se taj proces izvršava dozvoljena operacija upisa u taj fajl. Objasnite kako i zašto se ovo dogodilo.

=== Rešenje ===
Fajl je otvoren u režimu čitanja.

== 10. zadatak ==
=== Postavka ===
Koliko pristupa blokovima na disku treba izvršiti za pristup n-tom logičkom bloku sadržaja fajla ako je alokacija fajla
# FAT, pri čemu je cela FAT u memoriji
# kontinualna?

=== Rešenje ===
# 1
# 1

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Јун 2014

2021-09-22T15:07:53Z

WikiEditor: /* isto */

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2014/jun/OS1%20jun%202014.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Ukratko objasniti značenje pojmova multiprogramiranje i multiprocesiranje.

=== Rešenje ===
Videti zadatak iz [[ОС1/Јануар 2014#1. zadatak|januarskog roka 2014]].

== 2. zadatak ==
=== Postavka ===
Korišćenjem standardnih bibliotečnih funkcija <code>setjmp()</code> i <code>longjmp()</code> implementirati funkciju <code>void yield(jmp_buf old, jmp_buf new)</code> koja vrši promenu konteksta procesora.

=== Rešenje ===
<syntaxhighlight lang="c">
void yield(jmp_buf old, jmp_buf new) {
if(setjmp(old) == 0)
longjmp(new, 1);
}
</syntaxhighlight>

== 3. zadatak ==
=== Postavka ===
Korišćenjem niti u školskom jezgru (klasa <code>Thread</code>) napisati kod koji konkurentno i rekurzivno obilazi binarno stablo tako što tekuća nit nastavlja da obilazi levo podstablo, a kreira novu nit koja će obići desno podstablo. Struktura <code>Node {Node *left, *right}</code> predstavlja čvor stabla

=== Rešenje ===
<syntaxhighlight lang="c">
class myThread : public Thread {
public:
myThread(Node* root) {
this->root = root;
start();
}
protected:
void run() {
visit(root);
}
private:
Node* root;
};

void visit(Node* root) {
if(root->right)
new myThread(root->right);
if(root->left)
visit(root->left);
}
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
Korišćenjem standardnih brojačkih semafora napisati kod za kontrolu kritične sekcije koju uporedo sme da izvršava najviše ''N'' procesa.

=== Rešenje ===
Videti zadatak iz [[ОС1/Јул 2013#4. zadatak|julskog roka 2013]].

== 5. zadatak ==
=== Postavka ===
Šta je osnovni razlog toga (osnovni problem koji se rešava time) što linker svoj posao obavlja u dva prolaza? Precizno i kratko objasniti.

=== Rešenje ===
Osnovni problem je kako povezati prevedene objektne fajlove u jedinstveni izvršivi fajl i rešiti obraćanje promenljivoj ili funkciji u drugom fajlu.
Linker ne zna apsolutnu poziciju simbola unutar fajla dok ne spoji sve fajlove pa tek onda može da razrešava.

== 6. zadatak ==
=== Postavka ===
Objasniti kako se kod kontinualne alokacije memorije obezbeđuje zaštita memorijskog prostora drugih procesa od ilegalnog adresiranja jednog procesa.

=== Rešenje ===
Zaštita memorijskog prostora drugih procesa od ilegalnog adresiranja jednog procesa kod kontinualne alokacije se obezbeđuje limit registrom. U ovaj registar procesora OS upisuje vrednost prilikom promene konteksta.

== 7. zadatak ==
=== Postavka ===
U nekom sistemu sa straničnom organizacijom virtuelne memorije virtuelna i fizička adresa su 32-bitne, adresibilna jedinica je bajt, a stranica je veličine 64 KB. PMT je organizovana u dva nivoa i jedan ulaz u PMT oba nivoa zauzima po jednu 32-bitnu reč. PMT oba nivoa su iste veličine. Koliko ukupno zauzimaju PMT za proces koji je alocirao samo svoju prvu i poslednju stranicu?

=== Rešenje ===
<math> 2^8 \cdot 4B + 2 \cdot 2^8 \cdot 4B = 3KB</math>

== 8. zadatak ==
=== Postavka ===
Ukratko objasniti tehniku dvostrukog baferisanja.

=== Rešenje ===
Koristi se kod sprege uređaja ili tokova kontrole koji su jako različiti po brzini transfera ili jedinici prenosa. Uvode se 2 bafera.

U prvoj fazi bafer A je ulazni bafer, bafer za proizvođača, a bafer B je izlazni bafer, bafer za potrošača. Kada oba učesnika završe fazu punjenja tj. pražnjenja svog bafera, baferi A i B menjaju uloge.

== 9. zadatak ==
=== Postavka ===
Neki fajl sistem koristi dve vrste ključeva za fajlove, deljene i ekskluzivne, i fajlove zaključava prilikom otvaranja fajla, u zavisnosti od najavljenog načina korišćenja fajla. Procesi A, B, C i D izvršavaju sistemske pozive otvaranja i zatvaranja istog fajla u sledećem redosledu (neki proces izvršava poziv zatvaranja fajla samo ako ga je uspešno otvorio):
#A: open(READ)
#B: open(WRITE)
#C: open(READ)
#A: close
#C: close
#D: open(WRITE)

=== Rešenje ===
Operacija 2. će se izvršiti neuspešno, a ostale uspešno.

== 10. zadatak ==
=== Postavka ===
Koliko pristupa blokovima na disku treba izvršiti za pristup ''n''-tom logičkom bloku sadržaja fajla ako je alokacija fajla
# indeksna, pri čemu je indeks fajla uvek u dva nivoa, a na blok sa indeksom prvog nivoa ukazuje polje u FCB,
# ulančana lista, pri čemu je glava liste u FCB? FCB fajla je u memoriji.

=== Rešenje ===
# 3
# n

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Јануар 2015

2021-09-22T14:58:08Z

WikiEditor: /* isto */

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2015/januar/OS1%20Jan%202015.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Ukratko objasniti osnovni motiv nastanka koncepta raspodele vremena (''time sharing'').

=== Rešenje ===
Svaki korisnik treba da ima utisak da računar radi samo za njega sa dovoljno dobrim i ujednačenim vremenima odziva dok taj isti računar zapravo opslužuje više korisnika istovremeno.

== 2. zadatak ==
=== Postavka ===
Objasniti semantiku mašinske instrukcije ''test & set'' i način njene upotrebe za međusobno isključenje kritičnih sekcija kod miltiprocesorskih sistema.

=== Rešenje ===
Instrukcija ''test & set'' atomično čita i vraća vrednost sadržaja zadate promenljive i u nju upisuje 1. Ova atomičnost se obezbeđuje hardverski zaključavanjem magistrale. Svakoj kritičnoj sekciji, tj. deljenoj strukturi podataka kojoj pristupa kod kritičnih sekcija se pridruži jedna globalna deljena promenljiva L u deljenoj operativnoj memoriji multiprocesora.

<syntaxhighlight lang = "ada">
lock(L):
while test_and_set(L) do null;

unlock(L):
L := 0;
</syntaxhighlight>

== 3. zadatak ==
=== Postavka ===
Na jeziku C, korišćenjem sistemskih poziva <code>fork()</code> i <code>execlp()</code> za Unix, napisati program koji pokreće drugi program iz fajla čiji je naziv zadat kao parametar komandne linije prvog programa.
=== Rešenje ===
<syntaxhighlight lang = "c">
int main (int argc, const char *argv[]) {
if (argc < 2) return -1;
pid_t pid = fork();
if (pid == 0) {
int s = execlp(argv[1], NULL);
if (s < 0) return -2;
}
return 0;
}
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
Napisati kod jednog od dva procesa sa međusobnim isključenjem kritične sekcije korišćenjem Petersonovog rešenja.

=== Rešenje ===
<syntaxhighlight lang = "ada">
shared var turn : integer := 1, flag1, flag2 : boolean := false;

process P1
begin
loop
flag1 := true; turn := 2;
while flag2 and turn = 2 do null;
<critical>
flag1 := false;
<non-critical>
end
end P1;

process P2
begin
loop
flag2 := true; turn := 1;
while flag1 and turn = 1 do null;
<critical>
flag2 := false;
<non-critical>
end
end P2;
</syntaxhighlight>

== 5. zadatak ==
=== Postavka ===
Zašto preklopi (''overlays'') ne mogu da se koriste ako program ima više niti koje obezbeđuje operativni sistem? Precizno objasniti.

=== Rešenje ===
Videti zadatak iz [[ОС1/Септембар 2011#5. zadatak|septembarskog roka 2011]].

== 6. zadatak ==
=== Postavka ===
Potrebno je u nekoj strukturi podataka voditi evidenciju o slobodnim fragmentima memorije kod kontinualne alokacije sa ''best fit'' algoritmom. Koja struktura podataka je efikasnija za implementaciju operacije dealokacije segmenta memorije koju je zauzimao ugašeni proces: a) dvostruko ulančana lista slobodnih fragmenata uređenih po veličini ili b) dvostruko ulančana lista slobodnih fragmenata uređenih po poziciji u memoriji? Kratko obrazložiti.

=== Rešenje ===
Dvostruko ulančana lista slobodnih fragmenata uređenih po poziciji u memoriji, jer je potrebno ulančati sa slobodnim fragmentom iznad i ispod tog segmenta memorije koji dealociramo uz eventualno spajanje.

== 7. zadatak ==
=== Postavka ===
U nekom sistemu sa straničnom organizacijom virtuelne memorije virtuelna i fizička adresa su 32-bitne, adresibilna jedinica je bajt, a stranica je veličine 64 KB. PMT je organizovana u dva nivoa i jedan ulaz u PMT oba nivoa zauzima po jednu 32-bitnu reč. PMT oba nivoa su iste veličine. Koliko ukupno zauzimaju PMT za proces koji je alocirao samo svoju prvu i poslednju stranicu?

=== Rešenje ===
<code>VA(32) = 8 (page1)|8 (page2)| 16 (offset)</code>

<math>2^8 \cdot 4B + 2 \cdot 2^8 \cdot 4B = 3 \cdot 2^{10}B = 3KB</math>

== 8. zadatak ==
=== Postavka ===
Kojom tehnikom se nedeljivi uređaj može učiniti virtuelno deljivim?

=== Rešenje ===
spooling

== 9. zadatak ==
=== Postavka ===
U fajl podsistemu nekog operativnog sistema nema koncepta kurzora (pokazivača) trenutne lokacije za čitanje i upis sadržaja u fajl. Čime se može nadomestiti ovaj nedostatak u sistemskim pozivima za čitanje i upis u fajl? Precizno objasniti i ilustrovati potpisom funkcija za ove pozive.

=== Rešenje ===
Potrebno je dodati i poziciju odakle se želi čitati/upisivati.
<syntaxhighlight lang = "c">
void write(FHANDLE fh, int position, char* buffer, int size);
void read(FHANDLE fh, int position, char* buffer, int size);
</syntaxhighlight>

== 10. zadatak ==
=== Postavka ===
Neki fajl sistem koristi indeksirani pristup alokaciji fajlova sa indeksima u dva nivoa, blokom veličine 512B i 32-bitnim adresama fizičkih blokova. Kolika je maksimalna veličina sadržaja fajla u ovom sistemu?

=== Rešenje ===
<math>\frac{512B}{4B} = 2^7B</math> ulaza u indeksu

maksimalna veličina fajla: <math>2^7 \cdot 2^7 \cdot 2^9 = 2^{23}B = 8MB</math>

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Јул 2014

2021-09-22T14:39:01Z

WikiEditor: /* dodata resenja koja su falila - potrebno proveriti */

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2014/jul/OS1%20Jul%202014.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Šta je bio osnovni motiv za uvođenje raspodele vremena (engl. ''time-sharing'') kod interaktivnih sistema? Objasniti.

=== Rešenje ===
Videti zadatak iz [[ОС1/Фебруар 2013#1. zadatak|februarskog roka 2013]].

== 2. zadatak ==
=== Postavka ===
Na asembleru nekog zamišljenog RISC procesora sa LOAD/STORE arhitekturom napisati prevod sledeće rekurzivne funkcije:
<syntaxhighlight lang="c">
int fib (int n) {
if (n<=1) return 1;
else return fib(n-1)+fib(n-2);
}
</syntaxhighlight>

=== Rešenje ===
<syntaxhighlight lang="asm">
fib: LD R1, #n[SP]
LD R0, #1
CMP R1, R0
JG else
RTS
else: SUB R1, R0
PUSH R1
CALL fib
POP R2
SUB R1, R0
PUSH R1
CALL fib
POP R0
ADD R0, R1
RTS
</syntaxhighlight>

== 3. zadatak ==
=== Postavka ===
Ukoliko su svi sistemski pozivi izvršeni uspešno, koliko procesa se ukupno kreira kada se nad sledećim programom kreira jedan proces (računajući i taj jedan)?
<syntaxhighlight lang = "c">
void main () {
for (int i=0; i<7; i++)
if (fork()==0)
return;
}
</syntaxhighlight>

=== Rešenje===
Odgovor: 8
* P1 pravi dete P2 i inkrementira svoje <code>i</code>.
* P2 je dete, te <code>fork()</code> vraća 0 u kontekstu deteta i završava se program.
* P1 pravi dete P3 i inkrementira svoje <code>i</code>.
* P1 pravi dete P4 i inkrementira svoje <code>i</code>.
* P1 pravi dete P5 i inkrementira svoje <code>i</code>.
* P1 pravi dete P6 i inkrementira svoje <code>i</code>.
* P1 pravi dete P7 i inkrementira svoje <code>i</code>.
* P1 pravi dete P8 i inkrementira svoje <code>i</code>.
* P3, P4, P5, P6, P7, P8 se isto završavaju kao proces P2.
* P1 završava svoj <code>for</code> ciklus jer je <code>i</code> postalo 7.

== 4. zadatak ==
=== Postavka ===
Korišćenjem standardnih brojačkih semafora napisati kod tri uporedna procesa koji sarađuju na sledeći način. Proces ''A'' upisuje jednu vrednost u deljenu promenljivu ''x'', a nezavisni proces ''B'' uporedo upisuje jednu vrednost u deljenu promenljivu ''y''. Proces ''C'' potom čita ''x'' i ''y'' da bi izračunao njihov zbir. Tek kada je ''C'' pročitao ''x'', proces ''A'' upisuje novu vrednost u ''x''; tek kada je ''C'' pročitao vrednost ''y'', proces ''B'' upisuje novu vrednost u ''y'', i tako ciklično.

=== Rešenje ===
<syntaxhighlight lang="ada">
var: sax : Semaphore := 1, scx : Semaphore := 0, sby : Semaphore := 1, sbc : Semaphore := 0;
x, y, z : Integer;

process A:
begin
loop
wait(sax);
x := ...
signal(scx);
end;
end A;

process B:
begin
loop
wait(sby);
y := ...
signal(scy);
end;
end B;

process C:
begin
loop
wait(scx);
z := x;
signal(sax);
wait(scy);
z := z + y;
signal(sby);
end;
end A;
</syntaxhighlight>

== 5. zadatak ==
=== Postavka ===
Neki program koristi dve velike strukture podataka naizmenično: najpre za neku složenu obradu koristi samo prvu strukturu, pa onda za neku drugu obradu koristi samo drugu strukturu, pa onda ponovo prvu, pa drugu itd. Ako se ove dve strukture učitavaju dinamički i preklapaju se (kod korišćenja preklopa, ''overlays''), u kom slučaju će izvršavanje tog programa trajati duže, a u kom će koristiti više memorije: kada se koristi samo dinamičko učitavanje, ili kada se koriste preklopi? Kratko obrazložiti.

=== Rešenje ===
Kod preklopa će izvršavanje trajati duže zbog toliko učitavanja, a dinamičko učitavanje će koristiti više memorije.

== 6. zadatak ==
=== Postavka ===
Neki sistem primenjuje kontinualnu alokaciju memorije. Kakva je hardverska podrška potrebna za ovaj pristup da bi se obezbedila:
#relokatibilnost procesa
#zaštita memorijskog prostora jednog procesa od drugih procesa?

=== Rešenje ===
#relokatibilnost procesa - mora da obezbedi da je base registar dostupan i za čitanje i za upis, kako bi OS tu prilikom promene konteksta upisao baznu adresu tekućeg procesa, a u slučaju realokacije procesa OS menja vrednost bazne adrese za taj proces u svojoj evidenciji koju ima za svaki proces.
#zaštita memorijskog prostora - limit registar.

== 7. zadatak ==
=== Postavka ===
Učestanost pogotka u TLB je 90%, a PMT je organizovana u tri nivoa. TLB je 10 puta brža nego operativna memorija. Za koliko procenata je efektivan pristup memoriji sporiji od pristupa fizičkoj memoriji?

=== Rešenje ===
<math> t_{TLB} = 0.1 t_{RAM} </math>

<math> 0.9 \cdot (t_{TLB} + t_{RAM}) + 0.1 \cdot (t_{TLB} + 4 \cdot t_{RAM}) = 1.4 t_{RAM} </math>

Odnos: <math> (1.4 - 1) / 1 = 40\% </math>

== 8. zadatak ==
=== Postavka ===
Navesti osnovne operacije klase znakovno-orijentisanih ulazno/izlaznih uređaja (tokova).

=== Rešenje===
#<code>int getc(FILE * f)</code> Učitava i vraća 1 znak iz ulaznog toka.
#<code>int putc(int c, FILE * f)</code> Šalje 1 znak na zadati izlazni tok..

== 9. zadatak ==
=== Postavka ===
Neki fajl sistem pruža sledeće operacije u svom API za tekstualne fajlove:
#<code>int size(FHANDLE)</code> Vraća trenutnu veličinu sadržaja fajla u znakovima.
#<code>void append(FHANDLE,int)</code> Proširuje sadržaj fajla za dati broj znakova na kraju.
#<code>void seek(FHANDLE,int)</code> Postavlja kurzor datog fajla na datu poziciju (redni broj znaka počev od 0).
#<code>void write(FHANDLE,char*,int size)</code> Na poziciju kurzora datog fajla upisuje dati niz znakova zadate dužine, i pomera kurzor iza upisanog niza znakova. Operacije seek i write rade samo u opsegu trenutne veličine sadržaja fajla (ne pomeraju kurzor i ne upisuju iza kraja sadržaja fajla).

Napisati operaciju <code>write(FHANDLE,int position,char*,int size);</code>

koja na zadatu poziciju upisuje zadati niz znakova date veličine, pri čemu se fajl implicitno najpre proširuje na potrebnu veličinu ukoliko bi zadata pozicija ili zadati upis prekoračio trenutnu veličinu sadržaja fajla. Zanemariti sve moguće greške u ulazu/izlazu.

=== Rešenje===
<syntaxhighlight lang="c">
write(FHANDLE f, int position, char* b, int size) {
int curSize = size(f);
if (position + size > curSize)
append(f, position + size - curSize);
seek(f, position);
write(f, b, size);
}
</syntaxhighlight>

== 10. zadatak ==
=== Postavka ===
Objasniti kako se u fajl sistemu tipa FAT vodi evidencija o slobnom prostoru.

=== Rešenje ===
Slobodni blokovi se ulančavaju u listu pokazivača koji se nalaze u svakom bloku. Alokacija jednog bloka je jednostavna. Uzima se prvi blok iz liste. FAT varijanta je inherentna - ulazi za slobodne blokove u FAT su posebno označeni.

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Јул 2015

2021-09-22T14:10:34Z

WikiEditor: /* 5. zadatak predlog resenja */

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2015/jul/OS1%20Jul%202015.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Šta je multiprocesorski, a šta distribuirani računarski sistem?

=== Rešenje ===
Videti zadatak iz [[ОС1/Јун 2011#1. zadatak|junskog roka 2011]].

== 2. zadatak ==
=== Postavka ===
Na asembleru nekog zamišljenog dvoadresnog RISC procesora sa ''load/store'' arhitekturom napisati prevod sledeće rekurzivne C funkcije:
<syntaxhighlight lang="c">
int f (int n) {
if (n<=1) return 1;
else return f(n-1)+f(n-2);
}
</syntaxhighlight>

=== Rešenje ===
Videti zadatak iz [[ОС1/Јул 2014#2. zadatak|julskog roka 2014]].

== 3. zadatak ==
=== Postavka ===
Korišćenjem školskog jezgra napisati kod koji omogućava da se kreira nit sa celobrojnim parametrom ''n''. Ako je ''n'' manje ili jednako 0, ova nit samo ispisuje pozdravnu poruku i završava se. U suprotnom, ova nit će (rekurzivno) kreirati istu takvu nit, ali sa parametrom ''n-1''.

=== Rešenje ===
<syntaxhighlight lang="c">
class myThread : public Thread {
public:
myThread(int val) {
n = val;
start();
}
protected:
void run() {
if(n <= 0) printf("Hello");
else new myThread(n - 1);
}
private:
int n;
};
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
Navesti koja su to dva osnovna modela (paradigme) međuprocesne komunikacije.

=== Rešenje ===
Deljena promenljiva/objekat/podatak i razmena poruka.

== 5. zadatak ==
=== Postavka ===
Navesti bar jednu razliku u načinu funkcionisanja linkera kada kao svoj rezultat pravi .exe i kada pravi .lib.

=== Rešenje ===
Kada pravi .exe fajl linker mora da završi posao bez nerazrešenih simbola, a .lib može da ima simbole koje uvozi.

== 6. zadatak ==
=== Postavka ===
Koja dva parametra procesa čine sastavni deo njegovog memorijskog konteksta, a koristi ih hardver pri preslikavanju adresa kod kontinualne alokacije memorije? Ukratko objasniti njihovo značenje.

=== Rešenje ===
Registri base i limit su sastavni deo konteksta procesa. OS ih učitava pri promeni konteksta. Relokatibilnost se obezbeđuje dinamičkim preslikavanjem sa base registrom. Limit registar obezbeđuje zaštitu OS-a od korisničkih procesa i procesa između sebe.

== 7. zadatak ==
=== Postavka ===
Virtuelna memorija organizovana je stranično, sa straničenjem u tri nivoa. Vreme pristupa operativnoj memoriji je 50 ns, a TLB-u 10 ns. Procenat pogotka u TLB je 90%. Koliko je efektivno vreme pristupa memoriji?

=== Rešenje ===
<math> 0.9 \cdot (10 + 50) + 0.1 \cdot (10 + 4 \cdot 50) = 75ns </math>

== 8. zadatak ==
=== Postavka ===
Navesti bar tri vrste usluga vezanih za realno vreme koje uobičajeno nude operativni sistemi.

=== Rešenje ===
#čitanje tekućeg datuma i vremena
#vreme proteklo između 2 događaja
#pokreni datu operaciju u zadato vreme

== 9. zadatak ==
=== Postavka ===
Izvod iz jednog uputstva za Unix fajl sistem i dodelu prava pristupa fajlu iz komandne linije:

''To change the mode of a file, use the chmod command. The general form is chmod X@Y file1 file2 ... where: X is any combination of the letters 'u' (for owner), 'g' (for group), 'o' (for others), 'a' (for all; that is, for 'ugo'); @ is either '+' to add permissions, '-' to remove permissions, or '=' to assign permissions absolutely; and Y is any combination of 'r', 'w', 'x'. ''

Na primer, komanda <code>chmod u=rx file</code> daje vlasniku prava <code>rx</code>, ali ne i pravo <code>w</code>.

Napisati komande koje za dati fajl postavljaju prava na sledeći način:

=== Rešenje ===
#grupi i ostalima dodaju prava na rw, ali ne i na x: <code> chmod go+rw file</code>
#svima oduzimaju pravo na upis: <code> chmod a-w file</code>

== 10. zadatak ==
=== Postavka ===
Neki fajl sistem podržava kombinovano indeksiran pristup alokaciji fajlova, pri čemu FCB sadrži 512 ulaza sa direktnim indeksom (sadrže brojeve blokova za podatke). Ako sadržaj fajla preraste veličinu koju podržava ovaj indeks nultog nivoa, za blokove preko te veličine postoji indeks prvog nivoa sa 512 ulaza u FCB; svaki od tih ulaza sadrži pokazivač na indeks drugog nivoa u kome je po 512 ulaza sa pokazivačima na blokove sa sadržajem. Koliki je maksimalni kapacitet fajla u blokovima? (Odgovor dati kao izraz.)

=== Rešenje ===
<math> (512 + 512 \cdot 512) \cdot blockSize </math>

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Јун 2016

2021-09-22T13:58:48Z

WikiEditor: /* Rešenje valjda? */

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2016/jun/Jun%202016.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Šta se smatralo najvećim nedostatkom prvobitnih paketnih (''batch'') sistema i kako je taj nedostatak rešen?

=== Rešenje ===
Prvobitni batch sistemi su efikasno delili resurse ali nisu interaktivni. Osnovni nedostatak bio je slabo iskorišćenje glavnog resursa računara - procesora. Nedostatak je rešen uvođenjem time sharing-a

== 2. zadatak ==
=== Postavka ===
Korišćenjem funkcije <code>yield(jmp_buf old, jmp_buf new)</code> koja čuva kontekst jedne niti i predaje procesor drugoj niti, realizovati operaciju <code>wait</code> na brojačkom semaforu u školskom jezgru

=== Rešenje ===
Videti zadatak iz [[ОС1/Октобар 2013#2. zadatak|oktobarskog roka 2013]].

== 3. zadatak ==
=== Postavka ===
Za sledeće slučajeve navesti u koje stanje prelazi tekući (''running'') proces i naznačiti da li se to dešava kao posledica sistemskog poziva od strane tog tekućeg procesa ili spoljašnjeg prekida.

=== Rešenje ===


== 4. zadatak ==
=== Postavka ===
Napisati kod koji realizuje Petersonov algoritam međusobnog isključenja dva uporedna procesa pomoću uposlenog čekanja.

=== Rešenje ===
<syntaxhighlight lang="ada">
shared var turn : integer := 1, flag1, flag2 : boolean := false;

process P1
begin
loop
flag1 := true; turn := 2;
while flag2 and turn = 2 do null;
<critical section>
flag1 := false;
<non-critical section>
end
end P1;

process P2
begin
loop
flag2 := true; turn := 1;
while flag1 and turn = 1 do null;
<critical section>
flag2 := false;
<non-critical section>
end
end P2;
</syntaxhighlight>

== 5. zadatak ==
=== Postavka ===
Precizno objasniti zašto klasičan linker svoj posao obavlja u dva prolaza (a ne može samo u jednom). Obrazloženje ilustrovati primerom.

=== Rešenje ===
U prvom prolazu linker pravi globalnu mapu .obj fajlova i globalno definisanih izvezenih simbola i njihovih adresa relativno u odnosu na početak .obj fajla. U drugom prolazu razrešava nerazrešena adresna polja koristeći definisane simbole u tabeli simbola.

== 6. zadatak ==
=== Postavka ===
Virtuelni adresni prostor sistema je 8GB, adresibilna jedinica je 16-bitna reč, a virtuelni adresni prostor je organizovan stranično sa stranicom veličine 32KB. Fizički adresni prostor je veličine 2GB. Tabele preslikavanja stranica su organizovane u dva nivoa, s tim da tabela prvog nivoa ima 2K ulaza. Svaki ulaz u PMT oba nivoa zauzima samo onoliko koliko je potrebno da se smesti broj okvira (PMT drugog nivoa je poravnata na okvir). Koliko memorije zauzimaju ukupno PMT procesa koji je alocirao svojih prvih 128 stranica?

=== Rešenje ===
VAS: 2^33B -> VA: 32b, page size 32KB = 2^15B -> page 14b, AU = 2B

PAS: 2GB = 2^31B -> PA: 30b

PMT1: 2K = 2^11 -> 11b

VA: page1(11) : page2(7) : offset(14)

128 stranica -> PMT1 i 1 PMT2 = 2^11 * 2^2 + 2^7 * 2^2 = 8.5KB

== 7. zadatak ==
=== Postavka ===
Neki sistem sa straničnom organizacijom memorije koristi tehniku ''copy on write''. Jedan proces je tek kreirao drugi proces pozivom <code>fork()</code>. Ako novokreirani proces odmah po pokretanju izvrši operaciju upisa u memoriju, koji izuzetak će generisati procesor, ''page fault'' ili neki drugi i koji? Precizno objasniti zašto i kako.

=== Rešenje ===
Procesor će generisati izuzetak ''write prohibited'', jer je u desktriptoru ove stranice označeno da ona nije dozvoljena za upis zbog tek kreiranog procesa deteta.

== 8. zadatak ==
=== Postavka ===
Na asembleru nekog zamišljenog RISC procesora sa LOAD/STORE arhitekturom napisati program koji prenosi blok podataka zadate dužine sa zadate adrese na izlazni uređaj korišćenjem programiranog ulaza/izlaza sa prozivanjem (polling).

=== Rešenje ===
<syntaxhighlight lang="ada">
LD R1, blockAddr
LD R2, cnt
ST [ctrl], #0..1
wait: LD R0, [status]
AND R0, #1..0
JZ wait
LD R0, [R1]
ST [data], R0
INC R1
DEC R2
JNZ wait
ST [ctrl], R0
</syntaxhighlight>

== 9. zadatak ==
=== Postavka ===
Ako fajl sistem koristi dve vrste ključeva, deljeni (''shared'') i ekskluzivni (''exclusive''), sa implicitnim zaključavanjem prilikom otvaranja fajla, koji ključ će biti zahtevan od strane procesa koji otvara fajl sa najavom samo operacije čitanja?

=== Rešenje ===
Deljeni (shared) ključ.

== 10. zadatak ==
=== Postavka ===
Neki sistem evidentira slobodne blokove fajl sistema tako što u jedan slobodan blok smešta spisak (indeks) do ''n'' narednih slobodnih blokova (najmanje 0, najviše ''n''), kao i broj sledećeg takvog indeksnog bloka. Koliki je broj blokova kojima sistem treba da pristupi (na čitanje ili upis) u najgorem slučaju prilikom alokacije jednog slobodnog bloka za sadržaj fajla? Broj prvog takvog bloka u lancu je globalni podatak koji se nalazi u memoriji i njegova eventualna izmena se ne broji.

=== Rešenje ===
{{delimično rešeno}}

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Јун 2016

2021-09-22T13:57:17Z

WikiEditor: /* 7. zadatak predlog resenja */

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2016/jun/Jun%202016.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Šta se smatralo najvećim nedostatkom prvobitnih paketnih (''batch'') sistema i kako je taj nedostatak rešen?

=== Rešenje ===
Prvobitni batch sistemi su efikasno delili resurse ali nisu interaktivni. Osnovni nedostatak bio je slabo iskorišćenje glavnog resursa računara - procesora. Nedostatak je rešen uvođenjem time sharing-a

== 2. zadatak ==
=== Postavka ===
Korišćenjem funkcije <code>yield(jmp_buf old, jmp_buf new)</code> koja čuva kontekst jedne niti i predaje procesor drugoj niti, realizovati operaciju <code>wait</code> na brojačkom semaforu u školskom jezgru

=== Rešenje ===
Videti zadatak iz [[ОС1/Октобар 2013#2. zadatak|oktobarskog roka 2013]].

== 3. zadatak ==
=== Postavka ===
Za sledeće slučajeve navesti u koje stanje prelazi tekući (''running'') proces i naznačiti da li se to dešava kao posledica sistemskog poziva od strane tog tekućeg procesa ili spoljašnjeg prekida.

=== Rešenje ===


== 4. zadatak ==
=== Postavka ===
Napisati kod koji realizuje Petersonov algoritam međusobnog isključenja dva uporedna procesa pomoću uposlenog čekanja.

=== Rešenje ===
<syntaxhighlight lang="ada">
shared var turn : integer := 1, flag1, flag2 : boolean := false;

process P1
begin
loop
flag1 := true; turn := 2;
while flag2 and turn = 2 do null;
<critical section>
flag1 := false;
<non-critical section>
end
end P1;

process P2
begin
loop
flag2 := true; turn := 1;
while flag1 and turn = 1 do null;
<critical section>
flag2 := false;
<non-critical section>
end
end P2;
</syntaxhighlight>

== 5. zadatak ==
=== Postavka ===
Precizno objasniti zašto klasičan linker svoj posao obavlja u dva prolaza (a ne može samo u jednom). Obrazloženje ilustrovati primerom.

=== Rešenje ===
U prvom prolazu linker pravi globalnu mapu .obj fajlova i globalno definisanih izvezenih simbola i njihovih adresa relativno u odnosu na početak .obj fajla. U drugom prolazu razrešava nerazrešena adresna polja koristeći definisane simbole u tabeli simbola.

== 6. zadatak ==
=== Postavka ===
Virtuelni adresni prostor sistema je 8GB, adresibilna jedinica je 16-bitna reč, a virtuelni adresni prostor je organizovan stranično sa stranicom veličine 32KB. Fizički adresni prostor je veličine 2GB. Tabele preslikavanja stranica su organizovane u dva nivoa, s tim da tabela prvog nivoa ima 2K ulaza. Svaki ulaz u PMT oba nivoa zauzima samo onoliko koliko je potrebno da se smesti broj okvira (PMT drugog nivoa je poravnata na okvir). Koliko memorije zauzimaju ukupno PMT procesa koji je alocirao svojih prvih 128 stranica?

=== Rešenje ===
VAS: 2^33B -> VA: 32b, page size 32KB = 2^15B -> page 14b, AU = 2B

PAS: 2GB = 2^31B -> PA: 30b

PMT1: 2K = 2^11 -> 11b

VA: page1(11) : page2(7) : offset(14)

128 stranica -> PMT1 i 1 PMT2 = 2^11 * 2^2 + 2^7 * 2^2 = 8.5KB

== 7. zadatak ==
=== Postavka ===
Neki sistem sa straničnom organizacijom memorije koristi tehniku ''copy on write''. Jedan proces je tek kreirao drugi proces pozivom <code>fork()</code>. Ako novokreirani proces odmah po pokretanju izvrši operaciju upisa u memoriju, koji izuzetak će generisati procesor, ''page fault'' ili neki drugi i koji? Precizno objasniti zašto i kako.

=== Rešenje ===
Procesor će generisati izuzetak ''write prohibited'', jer je u desktriptoru ove stranice označeno da ona nije dozvoljena za upis zbog tek kreiranog procesa deteta.

== 8. zadatak ==
=== Postavka ===
Na asembleru nekog zamišljenog RISC procesora sa LOAD/STORE arhitekturom napisati program koji prenosi blok podataka zadate dužine sa zadate adrese na izlazni uređaj korišćenjem programiranog ulaza/izlaza sa prozivanjem (polling).

=== Rešenje ===
<syntaxhighlight lang="ada">
LD R1, blockAddr
LD R2, cnt
ST [ctrl], #0..1
wait: LD R0, [status]
AND R0, #1..0
JZ wait
LD R0, [R1]
ST [data], R0
INC R1
DEC R2
JNZ wait
ST [ctrl], R0
</syntaxhighlight>

== 9. zadatak ==
=== Postavka ===
Ako fajl sistem koristi dve vrste ključeva, deljeni (''shared'') i ekskluzivni (''exclusive''), sa implicitnim zaključavanjem prilikom otvaranja fajla, koji ključ će biti zahtevan od strane procesa koji otvara fajl sa najavom samo operacije čitanja?

=== Rešenje ===
{{delimično rešeno}}

== 10. zadatak ==
=== Postavka ===
Neki sistem evidentira slobodne blokove fajl sistema tako što u jedan slobodan blok smešta spisak (indeks) do ''n'' narednih slobodnih blokova (najmanje 0, najviše ''n''), kao i broj sledećeg takvog indeksnog bloka. Koliki je broj blokova kojima sistem treba da pristupi (na čitanje ili upis) u najgorem slučaju prilikom alokacije jednog slobodnog bloka za sadržaj fajla? Broj prvog takvog bloka u lancu je globalni podatak koji se nalazi u memoriji i njegova eventualna izmena se ne broji.

=== Rešenje ===
{{delimično rešeno}}

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Јул 2017

2021-09-22T13:50:27Z

WikiEditor: /* 2->1 ?*/

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2017/jul/Jul%202017.pdf Zadaci sa stranice predmeta.]

== 1. zadatak ==
=== Postavka ===
Šta je hard, a šta soft sistem za rad u realnom vremenu (real-time system)?

=== Rešenje ===
Tvrdi sistemi za rad u realnom vremenu su sistemi u kojima odziv mora da stigne u određenom vremenu (''deadline''). Prekoračenje može dovesti do rezličitih katastrofa. Meki sistemi za rad u realnom vremenu su sistemi kojima je rok bitan ali smeju ga prekoračiti dok god performanse ulaze u zadate okvire.

== 2. zadatak ==
=== Postavka ===
Objasniti značenje mašinske instrukcije tipa ''test-and-set'' i njenu upotrebu u jezgru operativnog sistema.

=== Rešenje ===
<code>test_and_set</code> je instrukcija koja omogućava sinhronizaciju na hardverskom nivou. Služi za međusobno isključenje izvršavanja na više procesora. Ona atomično čita i vraća sadržaj zadate memorijske lokacije, i u tu lokaciju upisuje vrednost 1. Može da se koristi u implementaciji <code>lock()</code> funkcije.

== 3. zadatak ==
=== Postavka ===
Korišćenjem školskog jezgra napisati program koji u ''n'' uporednih niti izračunava kvadrat svakog elementa nekog celobrojnog niza (<code>a[i]*=a[i]</code>) veličine ''n*k'', tako što svaka nit obrađuje ''k'' elemanata[sic] (jednu particiju niza).

=== Rešenje ===
<syntaxhighlight lang="c++">
class ArrThread : Thread {
public:
ArrThread(int* a, int s, int f): arr(a), start(s), finish(f) {}
void run() {
for (int i = start; i < finish; i++) {
arr[i] *= arr[i];
}
}
private:
int* arr;
int start;
int finish;
};

int main() {
ArrThread* t[n];
int start = 0;
for (int i = 0; i < n; i++) {
t[i] = new ArrThread(array, start, start + k);
start += k;
}
for (int i = 0; i < n; i++) {
delete t[i];
}
return 0;
}
</syntaxhighlight>

== 4. zadatak ==
Videti zadatak iz [[ОС1/Јул 2019#4. zadatak|julskog roka 2019]].

== 5. zadatak ==
=== Postavka ===
Precizno objasniti zašto klasičan linker svoj posao obavlja u dva prolaza (a ne može samo ujednom). Obrazloženje ilustrovati primerom.

=== Rešenje ===
Linkerov zadatak je da spoji sve fajlove u jedan izvršni, ali da bi to uradio, linker mora naći sve simbole koji se uvoze odnosno izvoze.

U prvom prolazu analizira ulazne fajlove, veličinu njihovog binarnog sadržaja (prevoda), i pravi mapu ''exe'' fajla; osim toga, sakuplja infomacije iz tabela simbola ''obj'' fajlova i izgrađuje svoju tabelu simbola; u tu tabelu simbola unosi izvezene simbole iz ''obj'' fajlova, za koje odmah može da izračuna adresu u odnosu na ceo ''exe'' fajl. U drugom prolazu spaja sve te fajlove u jedan, i ujedno razrešava nerazrešena adresna polja mašinskih instrukcija na osnovu informacija o adresama u koje se preslikavaju simboli iz njegove tabele simbola.

Primer: Recimo da imamo dva objektna fajla, <code>a.obj</code> i <code>b.obj</code>. <code>a.obj</code> izvozi simbol <code>f</code> i uvozi simbol <code>c</code>. Linker će iz prvog objektnog fajla dodati u tabelu simbol <code>f</code>. <code>b.obj</code> uvozi simbol <code>f</code> i izvozi simbol <code>c</code>, pa će linker u svoju tabelu dodati simbol <code>c</code>. U drugom prolazu će linker razrešiti <code>c</code> polje u <code>a.obj</code> i polje <code>f</code> u <code>b.obj</code>.

== 6. zadatak ==
=== Postavka ===
Objasniti uslugu koju program očekuje od operativnog sistema ako koristi preklope (''overlay'').

=== Rešenje ===
Obaveza OS-a je samo da obezbedi uslugu (sistemski poziv) koji alocira deo (virtuelnog) adresnog prostora procesa, kao i uslugu kojom u dati prostor procesa učitava sadržaj iz nekog binarnog fajla i sadržaj iz memorije upisuje u neki fajl (uobičajene sistemske usluge za rad sa fajlovima); OS ne zna za šta se te usluge koriste, tj. ne zna da se one upotrebljavaju baš za dinamičko učitavanje i zamenu delova procesa.

== 7. zadatak ==
=== Postavka ===
Virtuelni adresni prostor je veličine 1GB, organizovan je segmentno, sa maksimalnom veličinom segmenta od 4KB, adresibilna jedinica je bajt. Svi segmenti nekog procesa su stvarne veličine od po 2KB i u fizičku memoriju smešteni su odmah jedan iza drugog, pri čemu segment broj 0 počinje od fizičke adrese F000h. Prikazati logičku strukturu virtuelne adrese i izračunati u koju fizičku adresu se preslikava virtuelna adresa 2543h.

=== Rešenje ===
VA(30) : seg(18) offset(12)

Virtuelna adresa 2543h tj. 0010 | 0101 0100 0011b pripada 2. segmentu koji počinje od fizičke adrese 10000h i završava na 10800h.

Fizička adresa se dobija sabiranjem bazne adrese u fizičkom adresnom prostoru i offsetnog dela virtuelne adrese:
PA = 10000h + 543h = 10543h.

== 8. zadatak ==
Videti zadatak iz [[ОС1/Јун 2021#6. zadatak|junskog roka 2021. godine]].

== 9. zadatak ==
Videti zadatak iz [[ОС1/Јун 2020#7. zadatak|junskog roka 2020. godine]].

== 10. zadatak ==
=== Postavka ===
Neki fajl sistem koristi indeksirani pristup alokaciji fajlova sa indeksima u dva nivoa, blokom veličine 512KB i 64-bitnim adresama fizičkih blokova. Kolika je maksimalna veličina fajla u ovom sistemu?

=== Rešenje ===
Pošto je blok veličine <math>2^{19}B</math> a adresa <math>2^3B</math> to znači da u jedan indeks može da stane <math>2^{16}</math> adresa blokova. Konačan broj bajtova koji je na ovaj način mogu adresirati jeste <math>2^{16} \cdot 2^{16} \cdot 2^{19} = 2^{51}B = 2PB</math>.

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Јун 2018

2021-09-22T13:47:16Z

WikiEditor: /* predlog resenja */

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2018/jun/Jun%202018.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Objasniti razliku između pojmova ''proces'' i ''nit'' (engl. ''thread'').

=== Rešenje ===
Proces je jedno izvršavanje programa sa jednim adresnim prostorom. Nit (''thread'') ili laki proces je tok kontrole koji teče uporedo sa drugim tokovima kontrole, ali koji deli virtuelni adresni prostor sa nekim drugim tokom ili tokovima kontrole.

== 2. zadatak ==
=== Postavka ===
Korišćenjem standardnih bibliotečnih operacija <code>setjmp</code> i <code>longjmp</code>, implementirati operaciju ''wait'' na binarnom semaforu koji je realizovan klasom <code>Event</code> poput one u školskom jezgru.

=== Rešenje ===
<syntaxhighlight lang="cpp">
void Event::wait() {
if (val == 1) {
val = 0;
} else {
if (setjmp(Thread::running->context) == 0) {
blocked.put(running);
Thread::running = Scheduler::get();
longjmp(Thread::running->context, 1);
}
}
}
</syntaxhighlight>

== 3. zadatak ==
=== Postavka ===
Korišćenjem sistemskih poziva <code>fork</code> i <code>exec</code>, napisati funkciju <code>run</code> koja kreira proces nad programom u fajlu sa zadatom putanjom i vraća negativnu vrednost u slučaju greške, a <code>pid</code> kreiranog procesa u slučaju uspeha pri <code>fork</code>. Ukoliko ne uspe <code>exec</code>, kreirani proces-dete treba ugasiti.

=== Rešenje ===
<syntaxhighlight lang="cpp">
int run(char* path) {
pid_t pid = fork();
if (pid < 0) {
return -1;
}
if (pid == 0) {
int t = exec(path);
if (t < 0) {
exit(-2);
}
}
return pid;
}
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
Dva procesa pristupaju kritičnoj sekciji. Dat je presudokod jednog od njih, koji bi trebalo da obezbedi međusobno isključenje uposlenim čekanjem (kod drugog procesa izgleda analogno). Da li ovo rešenje obezbeđuje međusobno isključenje? Da li ima neki problem (ako ima, koji)?
<syntaxhighlight lang="milo">
process P1
begin
loop
flag1 := true;
while flag2 = true do null end;
<critical section>
flag1 := false;
<non-critical section>
end
end P1;
</syntaxhighlight>

=== Rešenje ===
Ovo rešenje ne valja jer se dešava ''livelock'' odnosno oba procesa se međusobno zaključaju i ni jedan ni drugi se neće dalje izvršavati. To se desi kada proces P1 postavi <code>flag1</code> na <code>true</code> a zatim se desi promena konteksta i P2 postavi <code>flag2</code> na <code>true</code>.

== 5. zadatak ==
=== Postavka ===
Za koju od ove dve tehnike, dinamičko učitavanje (''dynamic loading'') ili preklopi (''overlays''), se može očekivati duže izvršavanje istog programa u najgorem slučaju? Precizno obrazložiti.

=== Rešenje ===
Duže vreme izvršavanja u najgorem slučaju se može očekivati kod preklopa jer će program stalno učitavati iz memorije iznova i iznova, dok će dinamičko učitavanje zauzeti više memorije, svaki potreban modul će učitati po jednom.

== 6. zadatak ==
=== Postavka ===
U nekom sistemu primenjuje se ''worst-fit'' algoritam kontinualne alokacije memorije. Inicijalno je prostor veličine 256KB potpuno slobodan za alokaciju korisničkih procesa. Potom su različiti procesi zadavali sledeće zahteve (slovna oznaka označava proces koji je postavio zahtev, brojna oznaka označava veličinu alociranog prostora u KB, a minus označava gašenje procesa i oslobađanje njegove memorije): A64, B16, C128, D32, A-, E8, F32, B-

Odgovoriti na sledeća pitanja koja se odnose na stanje memorije nakon ove sekvence zahteva:
# Koliko je ukupno slobodnih fragmenata?
# Kolika je veličina najmanjeg slobodnog fragmenta?
# Kolika je veličina najvećeg slobodnog fragmenta?

=== Rešenje ===
Jedno slovo označava 8KB prostora.
AAAAAAAA------------------------
AAAAAAAABB----------------------
AAAAAAAABBCCCCCCCCCCCCCCCC------
AAAAAAAABBCCCCCCCCCCCCCCCCDDDD--
--------BBCCCCCCCCCCCCCCCCDDDD--
E-------BBCCCCCCCCCCCCCCCCDDDD--
EFFFF---BBCCCCCCCCCCCCCCCCDDDD--
EFFFF-----CCCCCCCCCCCCCCCCDDDD--
* Slobodnih fragmenata: 2
* Najmanji slobodan fragment: 16KB
* Najveći slobodan fragment: 40KB

== 7. zadatak ==
=== Postavka ===
Prilikom preslikavanja virtuelne adrese, procesor je generisao izuzetak zbog pokušaja upisa na tu adresu koji je u deskriptoru stranice označen kao zabranjen. Operativni sistem ipak neće ugasiti taj proces. Precizno objasniti zašto.

=== Rešenje ===
Neće ugasiti program jer se zapravo radi o tehnici ''copy-on-write'' odnosno kopiranja na upis. U ovoj tehnici, MMU vidi tu memoriju kao zabranjenu za upis. Prilikom generisanja greške, OS proverava da li je zabranjena, i kako vidi da zapravo nije nije, to znači da se radi o tehnici kopiranja na upis pa će operativni sistem kopirati stranicu i reći MMU da je dozvoljena za upis.

== 8. zadatak ==
=== Postavka ===
Navesti tri usluge vezane za realno vreme koje operativni sistem može da nudi i predložiti i kratko objasniti funkcije – sistemske pozive za te usluge.

=== Rešenje ===
# Informacija o tekućem realnom vremenu:
#: <syntaxhighlight lang="c" inline>time_t time (time_t* tloc);</syntaxhighlight>
#: Vraća broj sekundi koje su protekle od 1. 1. 1970. u 0 časova. Postoje i bibliotečke funkcije u <code>time.h</code> koje vraćaju “kalendarsko” vreme, rastavljeno na datum i sat itd, a oslanjaju se na ovaj sistemski poziv: <code>asctime</code>, <code>ctime</code>, <code>gmtime</code>, <code>localtime</code>.
# Suspenzija pozivajućeg procesa (“uspavljivanje”) za zadato vreme
#: <syntaxhighlight lang="c" inline>unsigned int sleep (unsigned int seconds);</syntaxhighlight>
# Čekanje na događaje, uslove ili na sinhronizacione primitive, ali vremenski ograničeno (tzv. ''timeout'' kontrole); ako se proces ne deblokira u zadatom vremenu, biće deblokiran zbog isteka vremenske kontrole; npr. za semafore:
#: <syntaxhighlight lang="c" inline>int sem_timedwait (sem_t *sem, const struct timespec *abs_timeout);</syntaxhighlight>

== 9. zadatak ==
=== Postavka ===
Ako je tekući direktorijum nekog procesa <code>/a/b/c</code>, koja je apsolutna putanja do fajla koji taj proces otvara davanjem putanje <code>d/../../e/f.txt</code>?

=== Rešenje ===
Raščlanimo relativnu putanju na delove:
* <code>d</code>: idemo u direktorijum <code>d</code>, sada je putanja <code>/a/b/c/d</code>
* <code>..</code> idemo jedan direktorijum iznad, sada je putanja <code>/a/b/c</code>
* <code>..</code> idemo jedan direktorijum iznad, sada je putanja <code>/a/b</code>
* <code>e</code> idemo u direktorijum <code>e</code>, sada je putanja <code>/a/b/e</code>
* <code>f.txt</code> posećujemo fajl <code>f.txt</code>, krajnja putanja je <code>/a/b/e/f.txt</code>

== 10. zadatak ==
{{delimično rešeno}}
=== Postavka ===
Fajl sistem primenjuje ulančanu alokaciju, s tim da se i slobodni blokovi ulančavaju u listu. U strukturi FCB polje <code>head</code> sadrži broj prvog bloka sa sadržajem fajla, a polje <code>size</code> veličinu sadržaja. Funkcija jezgra <code>free</code> prima kao argument broj prvog bloka u lancu blokova koje treba proglasiti slobodnim. Napisati funkciju jezgra <code>truncate</code> koja briše sadržaj fajla na čiji <code>FCB</code> ukazuje argument.

=== Rešenje ===
Pretpostavimo da <code>free_head</code> i <code>free_tail</code> predstavljaju pokazivače na početak i kraj ulančane liste slobodnih blokova.
<syntaxhighlight lang="c">
void truncate(FCB *f) {
if (f->head == NULL) return;
int numOfBlocks = size / BLOCK_SIZE, i = 0, cur = f->head, tmp_head = f->head;
while (i < numOfBlocks) {
free(cur);
cur = cur->next;
i++;
}
if (free_head == NULL) free_head = tmp_head;
else free_tail->next = tmp_head;
free_tail = tmp_head;
}
</syntaxhighlight>
[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Јун 2017

2021-09-22T13:30:03Z

WikiEditor: /* 6. zadatak pogresan tekst */

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2017/jun/Jun%202017.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Šta je multiprogramiranje, a šta multiprocesiranje?

=== Rešenje ===
Videti zadatak iz [[ОС1/Јануар 2014#1. zadatak|januarskog roka 2014]].

== 2. zadatak ==
=== Postavka ===
Objasniti kako se obezbeđuje međusobno isključenje pristupa kritičnim sekcijama jezgra operativnog sistema od strane uporednih tokova kontrole (niti) koji se izvršavaju na istom, odnosno na različitim procesorima.

=== Rešenje ===
Videti zadatak iz [[ОС1/Фебруар 2014#2. zadatak|februarskog roka 2014]].

== 3. zadatak ==
=== Postavka ===
Korišćenjem sistemskog poziva <code>create_thread(void(*f)(void*),void* p)</code> koji kreira nit koja izvršava datu funkciju <code>f</code> sa datim argumentom <code>p</code>, na jeziku C napisati program koji u ''n'' uporednih niti izračunava kvadrat svakog elementa nekog celobrojnog niza (<code>a[i]*=a[i]</code>) veličine <code>n*k</code>, tako što svaka nit obrađuje ''k'' elemanata (jednu particiju niza).

=== Rešenje ===
<syntaxhighlight lang="c">
int n = ...;
int k = ...;
int a[n*k];

void square(void* p) {
int part = *(int*)(p);
part *= k;
for(int i = 0; i < k; i++)
a[part + i] *= a[part + i];
}

void main() {
for(int i = 0; i < n; i++)
create_thread(square, &i);
}
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
Korišćenjem standardnih brojačkih semafora u školskom jezgru, na jeziku C++ napisati implementaciju ograničenog bafera (''bounded buffer'').

=== Rešenje ===
Videti zadatak iz [[ОС1/Октобар 2011#4. zadatak|oktobarskog roka 2011]].

== 5. zadatak ==
=== Postavka ===
Ako u svom C programu ni u jednom fajlu ne definišete funkciju <code>main()</code>, ko će prijaviti grešku i kog tipa, prevodilac ili linker? Precizno obrazložiti na osnovu čega se ta greška prijavljuje.

=== Rešenje ===
Linker prijavljuje grešku tipa simbol main nije definisan. Kada se povezuje C/C++ program, lista obj fajlova mora da sadrži i obavezno generiše modul koji poziva funkciju main, pa je zato i referiše kao spoljni simbol kog uvozi, što dovodi do greške ako ga nema.

== 6. zadatak ==
=== Postavka ===
Da li se količina memorije koju program zahteva u najgorem slučaju njegovog izvršavanja smanjuje primenom tehnike dinamičkog učitavanja (u odnosu na količinu koju zahteva kada se ta tehnika ne koristi)? Kratko obrazložiti.

=== Rešenje ===
Ne smanjuje se, jer u najgorem slučaju on zahteva sve svoje potprograme i strukture, a tehnika dinamičkog učitavanja obezbeđuje da delovi ne moraju da se učitavaju samo dok se prvi put ne javi potreba za njima.

== 7. zadatak ==
=== Postavka ===
Virtuelni adresni prostor je veličine 1GB, organizovan je segmentno, sa maksimalnom veličinom segmenta od 4KB, adresibilna jedinica je bajt. Svi segmenti nekog procesa su stvarne veličine od po 2KB i u fizičku memoriju smešteni su odmah jedan iza drugog, pri čemu segment broj 0 počinje od fizičke adrese F000h. Prikazati logičku strukturu virtuelne adrese i izračunati u koju fizičku adresu se preslikava virtuelna adresa 2564h.

=== Rešenje ===
VA: 2^30B, segment 4KB = 2^12B, AU = 1B

limit: 2KB

VA(30) : segment(18) : offset(12)

VA = 2564h -> segment = 2, offset = 564

PA = 11564

== 8. zadatak ==
=== Postavka ===
bjasniti kako se znakovno orijentisani sekvencijalni ulazni uređaj može učiniti (virtuelno) istim takvim, ali sa direktnim pristupom?

=== Rešenje ===
{{delimično rešeno}}

== 9. zadatak ==
=== Postavka ===
Ako je tekući direktorijum nekog procesa <code>/a/b/c</code>, koja je apsolutna staza do fajla koga ovaj proces otvara zadajući sledeću stazu: <code>../../d/e/../f.txt</code>?

=== Rešenje ===
<code>/a/d/f.txt</code>

== 10. zadatak ==
=== Postavka ===
Neki fajl sistem koristi kombinovani indeksirani pristup alokaciji fajlova sa indeksima od jednog do tri nivoa. Objasniti zašto taj fajl sistem pokušava da alocira blokove za sadržaj fajla što bliže jedan drugome na disku, kad god je to moguće?

=== Rešenje ===
Da bi vreme pristupa blokovima bilo što kraće.

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Модификације август 2021

2021-09-21T22:05:31Z

WikiEditor: /* male izmene */

{{tocright}}
Sledeće modifikacije su se pojavile na odbrani projekta u avgustovskom roku 2021.

== 30 poena ==
* U klasi Thread dodati nestatičku metodu <code>int olderSiblingCount()</code> koja vraća broj nezavršene starije braće trenutne niti. Ukoliko nit nije nastala <code>fork()</code>-om, metoda vraća -1.
* Nit ''A'' je stariji brat niti ''B'' ako su i nit ''A'' i nit ''B'' nastale forkovanjem iste niti, ali je ''A'' startovana pre ''B''.

* Napisati test primer na sledeći način:
* Forkom napraviti 5 dece a zatim u svakom detetu generisati slučajan broj <code>num_iter</code> (od 3 do 10) i u petlji koja iterira <code>num_iter</code> puta ispisivati sledeću poruku: "<code>Thread id: x/num_iter olderSiblingCount: res</code>" gde je <code>id</code> ID trenutne niti, <code>x</code> trenutna iteracija petlje, <code>num_iter</code> prethodno slučajno generisan broj, a <code>res</code> povratna vrednost <code>olderSiblingCount()</code> metode za tekuću nit.
* Takođe dodati semafor koji u svakoj iteraciji deteta uspavljuje dete na random vreme od <code>50</code> do <code>250ms</code>.

=== Rešenje ===
<syntaxhighlight lang="cpp">
int userMain(int argc, char** argv) {
for(int i = 0; i < 5; i++) {
int pid = Thread::fork();
if(pid) continue;
Semaphore sleeper(0);
int num_iter = 3 + (rand() % 8);
for(int j = 0; j < num_iter; j++) {
intLock
cout << "Thread " << Thread::getRunningId() << ": " << j << "/" << num_iter << " olderSiblingCount = " << (Thread::getThreadById(Thread::getRunningId()))->olderSiblingCount() << endl;
intUnlock
sleeper.wait(1 + (rand() % 5));
}
Thread::exit();
}
Thread::waitForForkChildren();
}
</syntaxhighlight>

[[Категорија:Лабораторијске вежбе]]
[[Категорија:ОС1]]

ОС1/Модификације предрок 2019

2021-09-11T23:48:52Z

WikiEditor: neki glupi test

{{tocright}}
{{нерешено}}

Следеће модификације су се појавиле на одбрани пројекта у предроку 2019.

== 20 поена ==
* Проширити класу <code>Semaphore</code> статичком методом <code>addOwner()</code> и нестатичком методом <code>removeOwner(ID id)</code> које додају и уклањају власнике семафора, респективно.
* <code>addOwner()</code> додаје текућу нит као власника. <code>removeOwner(ID id)</code> уклања нит са задатим <code>ID</code>- јем уколико је она била власник.
* Уколико методе <code>wait()</code> или <code>signal()</code> позове нит која не припада скупу власника, оне немају ефекта.

== Решење ==

Пример теста.

<syntaxhighlight lang="cpp">

#include "thread.h"
#include "intLock.h"
#include "semaphor.h"

Semaphore sem(1);

class testThread : public Thread {
public:
testThread(int i) : Thread() { this->ind = i; }
~testThread() { waitToComplete(); }

protected:
void run() {
if (ind % 2) sem.addOwner();
while (1) {
if (sem.wait(0) != -1) {
intLock
printf("%d Usao u kriticnu sekciju\n", ind);
intUnlock

sem.signal();

intLock
printf("%d Izasao iz kriticne sekcije\n", ind);
intUnlock

sem.removeOwner(Thread::getRunningId());
}
else break;
}
}

private:
int ind;
};

void tick() {}

const int N = 20;

int userMain(int argc, char* argv[]) {
testThread *thrs[N];

for (int i = 0; i < N; i++) {
thrs[i] = new testThread(i);
thrs[i]->start();
}
for (int j = 0; j < N; j++) {
delete thrs[j];
}
printf("Kraj!\n");
}

</syntaxhighlight>

[[Категорија:Лабораторијске вежбе]]
[[Категорија:ОС1]]

ОС1/Модификације јун 2021

2021-09-11T21:37:00Z

WikiEditor: /* Решење */

{{tocright}}
Следеће модификације су се појавиле на одбрани пројекта у јунском року 2021.

== 20 поена ==
* Следећа ставка иста је као 1. задатак са другог колоквијума у јунском року 2017. године: Школско језгро треба проширити концептом ''баријере'' ("ограда", "рампа", енгл. ''barrier'') чији је интерфејс дат доле. Семантика овог концепта и операција над њим је следећа:
** Баријера може бити у једном од два стања: ''отворена'' или ''затворена''. Баријера се иницијализује задатим стањем (аргумент конструктора). Нит у чијем контексту се креира баријера (тј. извршава конструктор) је њен ''власник''.
** <syntaxhighlight lang="cpp" inline>void Barrier::pass()</syntaxhighlight>: уколико позивајућа нит није власник ове баријере, ова операција нема ефекта - нит наставља своје извршавање; уколико је позивајућа нит власник баријере, а баријера затворена, нит се суспендује (блокира) све док се баријера не отвори; ако је баријера отворена, нит наставља извршавање без блокаде;
** <syntaxhighlight lang="cpp" inline>void Barrier::close()</syntaxhighlight>: затвара баријеру;
** <syntaxhighlight lang="cpp" inline>void Barrier::open()</syntaxhighlight>: отвара баријеру и евентуално деблокира нит која је на баријери блокирана.
* Написати јавни тест са две нити A и B. Нит B прави глобални семафор са вредношћу 0 и глобалну баријеру са вредношћу 1, а нит A упослено чека док се они не направе. Нит A треба циклично да позива <code>Barrier::open()</code>, <code>Barrier::pass()</code> и <code>Semaphore::wait(0)</code>, док нит B треба циклично да позива <code>Barrier::pass()</code>, <code>Barrier::close()</code> и <code>Semaphore::signal()</code>.
<syntaxhighlight lang="cpp">
class Barrier {
public:
Barrier (int open=1);
void open();
void close();
void pass();
};
</syntaxhighlight>

=== Решење ===
Оквирно решење може се наћи као решење поменутог колоквијума.
Тест описан текстом задатка.

<syntaxhighlight lang=cpp>
#include "thread.h"
#include "semaphor.h"
#include "barrier.h"
#include "intLock.h"

Semaphore *s = 0;
Barrier *b = 0;
Semaphore waiter(0);

class MyA : public Thread {
public:
MyA() : Thread() {}
~MyA() { waitToComplete(); }
protected:
void run() {
while (s == 0 || b == 0) {}

while (1) {
b->open();
intLock
cout << "A opened the barrier" << endl;
intUnlock
b->pass();
intLock
cout << "A passed the barrier" << endl;
intUnlock
s->wait(0);
}
}
};

class MyB : public Thread {
public:
MyB() : Thread() {}
~MyB() { waitToComplete(); }
protected:
void run() {
s = new Semaphore(0);
b = new Barrier(1);
while (1) {

b->pass();
intLock
cout << "B passed the barrier" << endl;
intUnlock
b->close();
intLock
cout << "B closed the barrier" << endl;
intUnlock
s->signal();
waiter.wait(30);
}
}
};

void tick() {}

int userMain(int argc, char *argv[]) {
MyA a;
MyB b;
a.start();
b.start();
a.waitToComplete();
b.waitToComplete();
}
</syntaxhighlight>

== 30 поена ==
* Направити да се након позива <code>fork()</code> као следећа нит за извршавање изабере дете (пре изласка из <code>fork()</code> у родитељској нити). Такође, форсирати да се прво бирају нити без деце.
* Написати тест пример који тестира задату функционалност. На пример, може да изгледа попут:
<syntaxhighlight lang="cpp">
int result = Thread::fork();
if (result != -1) {
if (result == 0) {
intLock
cout << "Child!" << endl;
intUnlock
Thread::exit();
} else {
intLock
cout << "Parent!" << endl;
intUnlock
Thread::waitForForkChildren();
}
}
</syntaxhighlight>

=== Решење ===
* Решење за бирање детета јесте да се у <code>PCB</code> дода показивач на дете које је изабрано који се поставља на новонаправљено дете у <code>fork()</code>, проверава да ли је <code>nullptr</code> у тајмеру (у који се ушло позивом функције <code>dispatch()</code> унутар функције <code>fork()</code>), ако није онда се нит која је следећа за извршавање поставља на то дете и показивач се враћа на <code>nullptr</code>.
* Једно решење за форсирање нити које немају децу јесте да се, уколико се не дешава бирање детета, из <code>Scheduler</code> ваде нити док се не пронађе нит без деце (која се одмах постави као нит за извршавање) или док се не избаце све нити, ако су извађене нити са децом оне се убацују у другу листу и на крају се враћају назад у <code>Scheduler</code>. Уколико нит без деце није пронађена, између вађења и враћања нити проверава се да ли је извучена иједна нит без деце и вади се једна нит са децом уколико није.

[[Категорија:Лабораторијске вежбе]]
[[Категорија:ОС1]]

ОС1/Јул 2017

2021-08-31T19:59:27Z

WikiEditor: /* isto */

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2017/jul/Jul%202017.pdf Zadaci sa stranice predmeta.]

== 1. zadatak ==
=== Postavka ===
Šta je hard, a šta soft sistem za rad u realnom vremenu (real-time system)?

=== Rešenje ===
Tvrdi sistemi za rad u realnom vremenu su sistemi u kojima odziv mora da stigne u određenom vremenu (''deadline''). Prekoračenje može dovesti do rezličitih katastrofa. Meki sistemi za rad u realnom vremenu su sistemi kojima je rok bitan ali smeju ga prekoračiti dok god performanse ulaze u zadate okvire.

== 2. zadatak ==
=== Postavka ===
Objasniti značenje mašinske instrukcije tipa ''test-and-set'' i njenu upotrebu u jezgru operativnog sistema.

=== Rešenje ===
<code>test_and_set</code> je instrukcija koja omogućava sinhronizaciju na hardverskom nivou. Služi za međusobno isključenje izvršavanja na više procesora. Ona atomično čita i vraća sadržaj zadate memorijske lokacije, i u tu lokaciju upisuje vrednost 1. Može da se koristi u implementaciji <code>lock()</code> funkcije.

== 3. zadatak ==
=== Postavka ===
Korišćenjem školskog jezgra napisati program koji u ''n'' uporednih niti izračunava kvadrat svakog elementa nekog celobrojnog niza (<code>a[i]*=a[i]</code>) veličine ''n*k'', tako što svaka nit obrađuje ''k'' elemanata[sic] (jednu particiju niza).

=== Rešenje ===
<syntaxhighlight lang="c++">
class ArrThread : Thread {
public:
ArrThread(int* a, int s, int f): arr(a), start(s), finish(f) {}
void run() {
for (int i = start; i < finish; i++) {
arr[i] *= arr[i];
}
}
private:
int* arr;
int start;
int finish;
};

int main() {
ArrThread* t[n];
int start = 0;
for (int i = 0; i < n; i++) {
t[i] = new ArrThread(array, start, start + k);
start += k;
}
for (int i = 0; i < n; i++) {
delete t[i];
}
return 0;
}
</syntaxhighlight>

== 4. zadatak ==
Videti zadatak iz [[ОС1/Јул 2019#4. zadatak|julskog roka 2019]].

== 5. zadatak ==
=== Postavka ===
Precizno objasniti zašto klasičan linker svoj posao obavlja u dva prolaza (a ne može samo ujednom). Obrazloženje ilustrovati primerom.

=== Rešenje ===
Linkerov zadatak je da spoji sve fajlove u jedan izvršni, ali da bi to uradio, linker mora naći sve simbole koji se uvoze odnosno izvoze.

U prvom prolazu analizira ulazne fajlove, veličinu njihovog binarnog sadržaja (prevoda), i pravi mapu ''exe'' fajla; osim toga, sakuplja infomacije iz tabela simbola ''obj'' fajlova i izgrađuje svoju tabelu simbola; u tu tabelu simbola unosi izvezene simbole iz ''obj'' fajlova, za koje odmah može da izračuna adresu u odnosu na ceo ''exe'' fajl. U drugom prolazu spaja sve te fajlove u jedan, i ujedno razrešava nerazrešena adresna polja mašinskih instrukcija na osnovu informacija o adresama u koje se preslikavaju simboli iz njegove tabele simbola.

Primer: Recimo da imamo dva objektna fajla, <code>a.obj</code> i <code>b.obj</code>. <code>a.obj</code> izvozi simbol <code>f</code> i uvozi simbol <code>c</code>. Linker će iz prvog objektnog fajla dodati u tabelu simbol <code>f</code>. <code>b.obj</code> uvozi simbol <code>f</code> i izvozi simbol <code>c</code>, pa će linker u svoju tabelu dodati simbol <code>c</code>. U drugom prolazu će linker razrešiti <code>c</code> polje u <code>a.obj</code> i polje <code>f</code> u <code>b.obj</code>.

== 6. zadatak ==
=== Postavka ===
Objasniti uslugu koju program očekuje od operativnog sistema ako koristi preklope (''overlay'').

=== Rešenje ===
Obaveza OS-a je samo da obezbedi uslugu (sistemski poziv) koji alocira deo (virtuelnog) adresnog prostora procesa, kao i uslugu kojom u dati prostor procesa učitava sadržaj iz nekog binarnog fajla i sadržaj iz memorije upisuje u neki fajl (uobičajene sistemske usluge za rad sa fajlovima); OS ne zna za šta se te usluge koriste, tj. ne zna da se one upotrebljavaju baš za dinamičko učitavanje i zamenu delova procesa.

== 7. zadatak ==
=== Postavka ===
Virtuelni adresni prostor je veličine 1GB, organizovan je segmentno, sa maksimalnom veličinom segmenta od 4KB, adresibilna jedinica je bajt. Svi segmenti nekog procesa su stvarne veličine od po 2KB i u fizičku memoriju smešteni su odmah jedan iza drugog, pri čemu segment broj 0 počinje od fizičke adrese F000h. Prikazati logičku strukturu virtuelne adrese i izračunati u koju fizičku adresu se preslikava virtuelna adresa 2543h.

=== Rešenje ===
VA(30) : seg(18) offset(12)

Virtuelna adresa 2543h tj. 0010 | 0101 0100 0011b pripada 2. segmentu koji počinje od fizičke adrese 10000h i završava na 10800h.

Fizička adresa se dobija sabiranjem bazne adrese u fizičkom adresnom prostoru i offsetnog dela virtuelne adrese:
PA = 10000h + 543h = 10543h.

== 8. zadatak ==
Videti zadatak iz [[ОС1/Јун 2021#6. zadatak|junskog roka 2021. godine]].

== 9. zadatak ==
Videti zadatak iz [[ОС1/Јун 2020#7. zadatak|junskog roka 2020. godine]].

== 10. zadatak ==
=== Postavka ===
Neki fajl sistem koristi indeksirani pristup alokaciji fajlova sa indeksima u dva nivoa, blokom veličine 512KB i 64-bitnim adresama fizičkih blokova. Kolika je maksimalna veličina fajla u ovom sistemu?

=== Rešenje ===
Pošto je blok veličine <math>2^{19}B</math> a adresa <math>2^3B</math> to znači da u jedan indeks može da stane <math>2^{16}</math> adresa blokova. Konačan broj bajtova koji je na ovaj način mogu adresirati jeste <math>2^{16} \cdot 2^{16} \cdot 2^{19} = 2^{51}B = 1PB</math>.

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Јул 2019

2021-08-31T19:16:45Z

WikiEditor: /* nema waitToComplete u skolskom jezgru */

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2019/jul/Jul%202019.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Šta se smatra multiprocesorskim računarskim sistemom? Šta je simetričan multiprocesorski sistem?

=== Rešenje ===
Multiprocesorski sistem je sistem sa više procesora koji imaju zajedničku memoriju. Simetričan multiprocesorski sistem znači da su svi procesori opšte namene, jednaki i imaju isto vreme pristupa operativnoj memoriji. Asimetrični multiprocesorski sistem ima i specijalizovane procesore ili procesore sa različitim vremenom pristupa memoriji.

== 2. zadatak ==
=== Postavka ===
Neki procesor prilikom obrade prekida prebacuje svoje izvršavanje na korišćenje posebnog pokazivača steka koji se koristi u privilegovanom režimu rada, i pritom čuva sve registre na steku na čiji vrh ukazuje ovaj pokazivač. Operativni sistem na ovom procesoru koristi samo jedan sistemski stek za izvršavanje celog kernel koda. Da li se kontekst izvršavanja procesa (kontekst procesora) može čuvati na ovom steku?

=== Rešenje ===
{{delimično rešeno}}

== 3. zadatak ==
=== Postavka ===
Korišćenjem niti u školskom jezgru napisati funkciju <code>sum</code> koja kreira nit koja će sabrati sve elemente zadatog niza zadate dužine i rezultat upisati na traženo mesto; u slučaju greške ove funkcije vraćaju negativnu vrednost.
<syntaxhighlight lang="c">int sum (int array[], size_t size, long* result);</syntaxhighlight>

=== Rešenje ===
<syntaxhighlight lang="cpp">
class SumThread {
public:
SumThread(int* arr, size_t _size, long* res): array(arr), size(_size), result(res) {}
void run() {
long res = 0;
for (size_t i = 0; i < size; i++) {
res += array[i];
}
*result = res;
}
private:
int* array;
size_t size;
long* result;
};

int sum (int array[], size_t size, long* result) {
if (result == nullptr) return -1;
SumThread* st = new SumThread(array, size, result);
st->start();
delete st;
return 0;
}
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
Napisati pseudokod koji obezbeđuje međusobno isključenje pristupa kritičnoj sekciji dva procesa pomoću Petersonovog algoritma.

=== Rešenje ===
<syntaxhighlight lang="ada">
shared var turn : integer := 1, flag1, flag2 : boolean := false;
process P1
begin
loop
flag1 := true;
turn := 2;
while flag2 and turn = 2 do null;
<critical section>
flag1 := false;
<non-critical section>
end
end P1;
process P2
begin
loop
flag2 := true;
turn := 1;
while flag1 and turn = 1 do null;
<critical section>
flag2 := false;
<non-critical section>
end
end P2;
</syntaxhighlight>

== 5. zadatak ==
=== Postavka ===
Zbog čega operativni sistem ne radi zamenu (''swapping'') procesa njegovim izbacivanjem iz memorije prilikom svake promene konteksta, kada procesu koji je izgubio procesor memorija svakako nije potrebna?

=== Rešenje ===
Zato što je pristup hard disku vrlo spor te će takva implementacija znatno uticati na performanse. Ovo se primenjivalo na ''[[wikipedia:Windows 3.1|Windows 3.1]]'', i bilo je vrlo sporo. Danas, ''swapping'' se koristi kada nema dovoljno mesta u operativnoj memoriji.

== 6. zadatak ==
=== Postavka ===
Šta je kompakcija kod kontinualne alokacije memorije?

=== Rešenje ===
Kod kontinualne alokacije može doći do eksterne fragmentacije, odnosno da su slobodni fragmenti toliko mali da ni jedan proces ne može stati na tom delu, ali zbirno ih ima dovoljno za neki procos. Kompakcija rešava taj problem realokacijom svih zauzetih delova i spajanjem svih slobodnih fragmenata u jedan veliki slobodan fragment. Dok se dešava kompakcija, nijedan proces koji se pomera se ne može izvršavati.

== 7. zadatak ==
=== Postavka ===
Virtuelni adresni prostor je velične 8GB, a adresibilna jedinica je 16-bitna reč. Stranica je veličine 4KB, a preslikavanje je u dva nivoa, s tim da PMT prvog nivoa ima dva puta manje ulaza nego PMT drugog nivoa. Prikazati strukturu virtuelne adrese i označiti širinu svakog polja.

=== Rešenje ===
VA(32): Page1(10), Page2(11), Offset(11)

== 8. zadatak ==
=== Postavka ===
Navesti tipične usluge operativnog sistema vezane za pristup blokovski orijentisanom ulaznom uređaju sa direktnim pristupom i predložiti potpise odgovarajućih funkcija za te sistemske pozive.

=== Rešenje ===
Osnovne usluge jesu pisanje i čitanje.
<syntaxhighlight lang="c">
int readBlock(int fd, BlockNo block, void* buffer);
int writeBlock(int fd, BlockNo block, void* buffer);
</syntaxhighlight>

== 9. zadatak ==
=== Postavka ===
Objasniti koncept ACL (''access control list'').

=== Rešenje ===
Da bi se fajlovi zaštitili, jedan način je da se ograniče prava pristupa korisnika. Potrebno je definisati koji korisnik (ili grupa korisnika) može da izvršava koju operaciju. Jedan pristup je svakom fajlu pridružiti listu ovih parova (korisnik i operacija). Takva lista je lista kontrole pristupa (ACL).

== 10. zadatak ==
=== Postavka ===
Fajl sistem primenjuje FAT alokaciju, s tim da se i slobodni blokovi ulančavaju u listu. U strukturi FCB polje <code>head</code> sadrži broj prvog bloka sa sadržajem fajla, a polje <code>size</code> veličinu sadržaja. Globalna promenljiva <code>fat_free_head</code> sadrži broj prvog bloka (glavu liste), a <code>fat_free_tail</code> poslednjeg bloka (rep liste) u lancu slobodnih. FAT je u memoriju učitana kao niz. Napisati funkciju jezgra <code>truncate</code> koja briše sadržaj fajla na čiji FCB ukazuje argument.

=== Rešenje ===
<syntaxhighlight lang="cpp">
const unsigned long FAT_SIZE = ...;
unsigned long FAT[FAT_SIZE];

void truncate(FCB* file) {
unsigned long b = file->head;
for (unsigned long i = 0; i < file->size; ++i) {
unsigned long next = FAT[b];
FAT[b] = 0;
// Ovde se smatra da fat_free_tail pokazuje na blok 0 kada nema slobodnih blokova.
if (fat_free_tail) {
FAT[fat_free_tail] = b;
fat_free_tail = b;
} else {
fat_free_head = b;
fat_free_tail = b;
}
b = next;
}
file->size = 0;
file->head = 0;
}
</syntaxhighlight>

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Јул 2017

2021-08-30T16:21:38Z

WikiEditor: /* Izmena resenja ako moze jos neko da proveri da nisam pogresila izmenom */

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2017/jul/Jul%202017.pdf Zadaci sa stranice predmeta.]

== 1. zadatak ==
=== Postavka ===
Šta je hard, a šta soft sistem za rad u realnom vremenu (real-time system)?

=== Rešenje ===
Tvrdi sistemi za rad u realnom vremenu su sistemi u kojima odziv mora da stigne u određenom vremenu (''deadline''). Prekoračenje može dovesti do rezličitih katastrofa. Meki sistemi za rad u realnom vremenu su sistemi kojima je rok bitan ali smeju ga prekoračiti dok god performanse ulaze u zadate okvire.

== 2. zadatak ==
=== Postavka ===
Objasniti značenje mašinske instrukcije tipa ''test-and-set'' i njenu upotrebu u jezgru operativnog sistema.

=== Rešenje ===
<code>test_and_set</code> je instrukcija koja omogućava sinhronizaciju na hardverskom nivou. Služi za međusobno isključenje izvršavanja na više procesora. Ona atomično čita i vraća sadržaj zadate memorijske lokacije, i u tu lokaciju upisuje vrednost 1. Može da se koristi u implementaciji <code>lock()</code> funkcije.

== 3. zadatak ==
=== Postavka ===
Korišćenjem školskog jezgra napisati program koji u ''n'' uporednih niti izračunava kvadrat svakog elementa nekog celobrojnog niza (<code>a[i]*=a[i]</code>) veličine ''n*k'', tako što svaka nit obrađuje ''k'' elemanata[sic] (jednu particiju niza).

=== Rešenje ===
<syntaxhighlight lang="c++">
class ArrThread : Thread {
public:
ArrThread(int* a, int s, int f): arr(a), start(s), finish(f) {}
void run() {
for (int i = start; i < finish; i++) {
arr[i] *= arr[i];
}
}
private:
int* arr;
int start;
int finish;
};

int main() {
ArrThread* t[n];
int start = 0;
for (int i = 0; i < n; i++) {
t[i] = new ArrThread(array, start, start + k);
start += k;
}
for (int i = 0; i < n; i++) {
t[i]->waitToComplete();
delete t[i];
}
return 0;
}
</syntaxhighlight>

== 4. zadatak ==
Videti zadatak iz [[ОС1/Јул 2019#4. zadatak|julskog roka 2019]].

== 5. zadatak ==
=== Postavka ===
Precizno objasniti zašto klasičan linker svoj posao obavlja u dva prolaza (a ne može samo ujednom). Obrazloženje ilustrovati primerom.

=== Rešenje ===
Linkerov zadatak je da spoji sve fajlove u jedan izvršni, ali da bi to uradio, linker mora naći sve simbole koji se uvoze odnosno izvoze.

U prvom prolazu analizira ulazne fajlove, veličinu njihovog binarnog sadržaja (prevoda), i pravi mapu ''exe'' fajla; osim toga, sakuplja infomacije iz tabela simbola ''obj'' fajlova i izgrađuje svoju tabelu simbola; u tu tabelu simbola unosi izvezene simbole iz ''obj'' fajlova, za koje odmah može da izračuna adresu u odnosu na ceo ''exe'' fajl. U drugom prolazu spaja sve te fajlove u jedan, i ujedno razrešava nerazrešena adresna polja mašinskih instrukcija na osnovu informacija o adresama u koje se preslikavaju simboli iz njegove tabele simbola.

Primer: Recimo da imamo dva objektna fajla, <code>a.obj</code> i <code>b.obj</code>. <code>a.obj</code> izvozi simbol <code>f</code> i uvozi simbol <code>c</code>. Linker će iz prvog objektnog fajla dodati u tabelu simbol <code>f</code>. <code>b.obj</code> uvozi simbol <code>f</code> i izvozi simbol <code>c</code>, pa će linker u svoju tabelu dodati simbol <code>c</code> i razrešiti polje <code>f</code> u <code>b.obj</code> u prvom prolazu. U drugom prolazu će linker razrešiti <code>c</code> polje u <code>a.obj</code>, što nije mogao da odradi bez dva prolaza.

== 6. zadatak ==
=== Postavka ===
Objasniti uslugu koju program očekuje od operativnog sistema ako koristi preklope (''overlay'').

=== Rešenje ===
Obaveza OS-a je samo da obezbedi uslugu (sistemski poziv) koji alocira deo (virtuelnog) adresnog prostora procesa, kao i uslugu kojom u dati prostor procesa učitava sadržaj iz nekog binarnog fajla i sadržaj iz memorije upisuje u neki fajl (uobičajene sistemske usluge za rad sa fajlovima); OS ne zna za šta se te usluge koriste, tj. ne zna da se one upotrebljavaju baš za dinamičko učitavanje i zamenu delova procesa.

== 7. zadatak ==
=== Postavka ===
Virtuelni adresni prostor je veličine 1GB, organizovan je segmentno, sa maksimalnom veličinom segmenta od 4KB, adresibilna jedinica je bajt. Svi segmenti nekog procesa su stvarne veličine od po 2KB i u fizičku memoriju smešteni su odmah jedan iza drugog, pri čemu segment broj 0 počinje od fizičke adrese F000h. Prikazati logičku strukturu virtuelne adrese i izračunati u koju fizičku adresu se preslikava virtuelna adresa 2543h.

=== Rešenje ===
VA(30) : seg(18) offset(12)

Virtuelna adresa 2543h tj. 0010 | 0101 0100 0011b pripada 2. segmentu koji počinje od fizičke adrese 10000h i završava na 10800h.

Fizička adresa se dobija sabiranjem bazne adrese u fizičkom adresnom prostoru i offsetnog dela virtuelne adrese:
PA = 10000h + 543h = 10543h.

== 8. zadatak ==
Videti zadatak iz [[ОС1/Јун 2021#6. zadatak|junskog roka 2021. godine]].

== 9. zadatak ==
Videti zadatak iz [[ОС1/Јун 2020#7. zadatak|junskog roka 2020. godine]].

== 10. zadatak ==
=== Postavka ===
Neki fajl sistem koristi indeksirani pristup alokaciji fajlova sa indeksima u dva nivoa, blokom veličine 512KB i 64-bitnim adresama fizičkih blokova. Kolika je maksimalna veličina fajla u ovom sistemu?

=== Rešenje ===
Pošto je blok veličine <math>2^{19}B</math> a adresa <math>2^3B</math> to znači da u jedan indeks može da stane <math>2^{16}</math> adresa blokova. Konačan broj bajtova koji je na ovaj način mogu adresirati jeste <math>2^{16} \cdot 2^{16} \cdot 2^{19} = 2^{51}B = 1PB</math>.

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Октобар 2020

2021-08-24T20:53:34Z

WikiEditor: /* mislim da je falilo mutex polje */

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2020/oktobar/Okt%202020.pdf Zadaci sa stranice predmeta.]

== 1. zadatak ==
=== Postavka ===
Korišćenjem makroa <code>test_and_set</code> koji u svojoj implementaciji izvršava odgovarajuću instrukciju procesora tipa ''test-and-set'', implementirati međusobno isključenje kritične sekcije za višeprocesorski pristup.

=== Rešenje ===
<syntaxhighlight lang="c">
// Globalna
bool lock;

// Ulazak u kritičnu sekciju
while (test_and_set(&lock));
// Kritična sekcija
lock = false;
// ...
</syntaxhighlight>

== 2. zadatak ==
=== Postavka ===
Korišćenjem standardnih brojačkih semafora implementirati klasu sa dve operacije, ''tick'' i ''tock'', tako da se one mogu izvršavati iz konkurentnih procesa međusobno isključivo i samo u sledećem poretku: ''tick'', ''tick'', ''tock'', ''tick'', ''tick'', ''tock''...

=== Rešenje ===
<syntaxhighlight lang="cpp">
#include <iostream>

class Clock {
public:
Clock() : tickSem(0), tockSem(2), mutex(1),
allowedTock(false) {}
void tick();
void tock();
bool allowedTock;
private:
Semaphore tickSem;
Semaphore tockSem;
Semaphore mutex;
};

void Clock::tick() {
tockSem.wait();
mutex.wait();
std::cout << "tick" << std::endl;
if (allowedTock) {
tickSem.signal();
}
allowedTock = !allowedTock;
mutex.signal();
}

void Clock::tock() {
tickSem.wait();
mutex.wait();
std::cout << "tock" << std::endl;
tockSem.signal();
tockSem.signal();
mutex.signal();
}
</syntaxhighlight>

== 3. zadatak ==
=== Postavka ===
U definiciji semantike jezika C++ piše da pokušaj indirektnog upisa u objekat konstantnog tipa (označen kao <code>const</code>), recimo preko pokazivača na nekonstantu, ima „nedefinisan efekat“, što zapravo znači da se ostavlja mogućnost da različite implementacije prevodioca i različite platforme (hardver i OS) ovakve situacije tretiraju na različite načine. Navesti i precizno objasniti kakve tačno efekte ovakav upis može da ima i na koji način dolazi do tih efekata.

=== Rešenje ===
# Može da se desi da prevodilac više konstanti iste vrednosti alocira na istom mestu (kao što na primer postoji ''string pool'' u Javi) pa se upisom u jednu konstantu menjaju i sve ostale.
# Može da se desi da se te konstante čuvaju na stranici koja nije dozvoljena za upis (stranica sa kodom) pa se prilikom tog upisa generiše greška u pristupu stranici i operativni sistem ugasi proces.

== 4. zadatak ==
=== Postavka ===
U nekom sistemu sa straničnom organizacijom virtuelne memorije virtuelna i fizička adresa su 30-bitne, adresibilna jedinica je bajt, a stranica je veličine 64 KB. PMT je organizovana u dva nivoa i jedan ulaz u PMT oba nivoa zauzima po jednu 32-bitnu reč. PMT oba nivoa su iste veličine. Koliko ukupno zauzimaju PMT za proces koji je alocirao prvih 256 i poslednjih 256 stranica?

=== Rešenje ===
* VA(30): Page1(7) Page2(7) Offset(16)
* PA(30): Frame(14) Offset(16)
Pošto se iz jednog PMT može adresirati ukupno <math>2^7</math> ulaza u PMT, i svaki ulaz zauzima <math>2^2B</math>, to znači da jedan PMT ukupno zauzima <math>2^9B</math>. Za adresiranje 256 stranica potrebno je dva PMT drugog nivoa, tako da se ukupno stvara 5 PMT, i ukupna zauzeta veličina je <math>5 * 2^9 = 2.5KB</math>.

== 5. zadatak ==
=== Postavka ===
Da li je drajver uređaja (''device driver'') softverska ili hardverska komponenta računara? Ako je softverska, da li je komponenta operativnog sistema ili korisničkog programa? Ako je hardverska, da li je komponenta vezana za funkcionisanje operativne memorije ili ulazno/izlaznog uređaja?

=== Rešenje ===
Drajver je softverska komponenta koja može ali ne mora biti deo operativnog sistema (npr. mikrokernelski operativni sistemi) i služi za standardizovanu komunikaciju sa ulaznim i izlaznim uređajima. Drajvere obično proizvode proizvođači uređaja za koji su ti drajveri pravljeni i obično se pokreću u privilegovanom režimu (ali to ne mora biti slučaj).

== 6. zadatak ==
=== Postavka ===
Ukratko objasniti koncept „tvrde veze“ (''hard link'') u fajl sistemu koji podržava strukture direktorijuma tipa usmerenog acikličkog grafa (DAG).

=== Rešenje ===
Tvrda veza je veza na datoteku koja služi tome da održava datoteku u fajl sistemu, jer dok god postoje tvrde veze na neku datoteku ona i dalje postoji, i kad se sve tvrde veze obrišu ona prestaje da postoji.

== 7. zadatak ==
=== Postavka ===
Kako se kod FAT fajl sistema implementira evidencija slobodnih blokova?

=== Rešenje ===
Kod FAT fajl sistema se u FAT tabeli mogu ulančavati slobodni blokovi, ili jednostavno biti označeni posebnim ''null'' vrednostima.

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Јул 2021

2021-08-24T17:38:12Z

WikiEditor: dopune

{{tocright}}
[http://os.etf.rs/OS1/rokovi/2021/jul/Jul%202021.pdf Zadaci na stranici predmeta.] Svi zadaci vrede 3 poena.

== 1. zadatak ==
=== Postavka ===
Šta je ''preotimanje procesora'' (engl. ''preemption'') i koji hardverski mehanizam ga omogućuje? Šta se postiže uvođenjem ove tehnike u računarske sisteme?

=== Rešenje ===
* '''Preotimanje procesora''' je prekidanje izvršavanja jednog procesa na procesoru da bi se izvršio kernel kod ili neki drugi proces.
* '''Mehanizam prekida''' omogućuje preotimanje procesora - procesor dobija signal da prekine trenutni proces i pređe na kod kernela. Preotimanjem se postiže multiprogramiranje sa boljom raspodelom vremena i vremenom odziva.

== 2. zadatak ==
=== Postavka ===
Dat je potpis jednog sistemskog poziva na sistemima nalik sistemu Unix. Kratko, ali prezino objasniti šta radi ovaj sistemski poziv i značenje svakog parametra i rezultata.
<syntaxhighlight lang="c">void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);</syntaxhighlight>

=== Rešenje ===
<code>mmap</code> je sistemski poziv koji mapira fajl ili uređaj u memoriju. Značenja parametara:
* <code>void *addr</code> je (željena) početna adresa mapiranja. Ukoliko je <code>NULL</code>, operativni sistem sam bira početnu adresu.
* <code>size_t length</code> je dužina mapirane memorije
* <code>int prot</code> je fleg koji označava dozvoljene načine pristupa mapiranoj memoriji (da li sme da se čita, upisuje, izvršava) i mora se slagati sa načinom pristupa fajla.
* <code>int flags</code> je fleg koji označava da li je mapirana memorija vidljiva ostalim procesima koji mapiraju isti fajl, da li se promene u memoriji upisuju u fajl itd.
* <code>int fd</code> je ručka fajla
* <code>off_t offset</code> je pomeraj od početka fajla od kojeg se vrši mapiranje
Ukoliko je poziv uspešan, vraća se void pokazivač na memoriju koja je mapirana.

== 3. zadatak ==
=== Postavka ===
Šta se postiže tehnikom “kopiranja pri upisu” kod upravljanja memorijom? Kratko, ali precizno objasniti način rada ove tehnike.

=== Rešenje ===
Tehnikom ''copy-on-write'' postiže se '''ušteda memorije''', tako što se memorija koja se koristi u više procesa ne kopira dok je jedan proces ne promeni. Implementira se tako što se deskriptor logičkog segmenta koji se deli između procesa označi kao dozvoljen za upis, ali u ulazu PMT-a kao zabranjen za upis. U situaciju kada se desi upis, hardver generiše izuzetak koji se obrađuje od strane OS-a. OS zaključuje da se radi o kopiranju pri upisu iz deskriptora logičkog segmenta i vrši kopiranje, usmeravanje PMT-a drugog procesa na kopiju i u deskriptorima stranica obe kopije dozvoljava upis.

== 4. zadatak ==
=== Postavka ===
Ako se nad sledećim programom kreira jedan proces, koliko će ukupno biti elemenata sa vrednošću '''različitom od 0''' u nizovima <code>pid</code> svih kreiranih procesa (uključujući i taj jedan početni) kada svi ti procesi izađu iz petlje, pod pretpostavkom da su svi sistemski pozivi uspeli?
<syntaxhighlight lang="c">
const int N=2; int pid[N];
void main () {
for (int i=0; i<N; i++) pid[i] = fork();
}
</syntaxhighlight>

=== Rešenje ===
<code>fork()</code> u kontekstu roditelja vraća pravi <code>pid</code> deteta, a u kontekstu deteta vraća 0. Odgovor je 4: <code>child1</code> i <code>child3</code> u ''parent'', <code>child2</code> u ''child1'' i <code>child1</code> u ''child3''.
[[Датотека:OS1 jul 2021 4. zadatak objašnjenje.svg|оквир|центар|Objašnjenje]]

== 5. zadatak ==
=== Postavka ===
Dokazati da Petersonov algoritam za međusobno isključenje kritičnih sekcija dva uporedna procesa uposlenim čekanjem zaista obezbeđuje međusobno isključenje, odnosno ne poseduje problem utrkivanja (engl. ''race condition''). (Dati kod samo jednog procesa sa međusobnim isključenjem pomoću ovog algoritma.)

=== Rešenje ===
Petersonov algoritam:
<syntaxhighlight lang="ada">
process P1;
begin
loop
flag1 := true; turn := 2;
while flag2 and turn = 2 do null;
<critical section>
flag1 := false;
<non-critical section>
end
end P1;
</syntaxhighlight>
Pretpostavimo da algoritam ne obezbeđuje međusobno isključenje. Ako algoritam NE obezbeđuje međusobno isključenje, dogodiće se situacija da su oba procesa ušla u kritičnu sekciju. Ako se to desilo, to znači da su oba uslova petlji uposlenog čekanja <code>false</code>. Pošto oba procesa odmah pred ulazak u petlju postavljaju svoj <code>flag</code> na <code>true</code>, jedini način da uslov za petlju bude netačan je da uslov sa <code>turn</code> bude netačan, a pošto su oba uslova netačna, to bi značilo da promenljiva <code>turn</code> nema ni vrednost 1 ni vrednost 2. Pošto promenljivu <code>turn</code> koriste samo ova dva procesa i samo postavljaju vrednost na 1 ili 2, do ovoga nikako ne može doći. Time dobijamo kontradikciju na početnu pretpostavku i dobijamo da algoritam zaista omogućava međusobno isključenje.

== 6. zadatak ==
=== Postavka ===
Šta je ''simbolička veza'' (''symbolic link'', ''soft link'') u fajl sistemu? Kako se ona implementira?

=== Rešenje ===
'''Simbolička veza''' je veza do nekog fajla u fajl sistemu koja se ne ažurira automatski. Implementira se kao '''fajl sa posebnim tretmanom''' od strane operativnog sistema i u sebi sadrži apsolutnu i relativnu putanju do nekog fajla u fajl sistemu. Razlikuje se od tvrde veze tako što ne pokazuje direktno do FCB-a i može da postane prekinuta tj. landarava, ako se ''target'' fajl premesti ili preimenuje.

== 7. zadatak ==
=== Postavka ===
Neki fajl sistem koristi bit vektor za evidenciju slobodnih blokova na disku. Kolika je veličina ovog vektora u bajtovima, za disk veličine 16 TB sa blokom veličine 512B.

=== Rešenje ===
* 16 TB = 24 * 240 B = 244 B.
* 244 B / 512 B = 244 B / 29 = 235 blokova.
* 235 / 8 bita u B = 232 = 22 * 230 = '''4 GB'''.

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Јун 2021

2021-08-24T14:02:04Z

WikiEditor: /* fork -> pid valjda */

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2021/jun/Jun%202021.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Šta je sistemski poziv, a šta sistemski program?

=== Rešenje ===
Sistemski poziv je određena funkcionalnost koju operativni sistem pruža korisničkim programima. Korisnički programi mogu pozvati sistemski poziv, često korišćenjem mehanizma softverskih prekida, kako bi od operativnog sistema zatražili neke osnovne usluge kojima najčešće iz korisničkog režima i nemaju pristup. Primer sistemskog poziva bi bio <code>fork()</code> na ''Unix-like'' sistemima.

Sistemski program je program koji obavlja osnovne operacije sa korisničkim sistemom, na primer brisanje fajlova (<code>rm</code> na ''Unix-like'' sistemima).

== 2. zadatak ==
=== Postavka ===
Šta su nedostaci organizacije memorije sa particijama?

=== Rešenje ===
* Pojavljuje se interna fragmentacija, jer ako procesu ne treba ceo svoj memorijski prostor onda je rezervisani deo prostora koji taj proces ne koristi bespotrebno bačen.
* Balansira se između veličine adresnog prostora jednog procesa i ukupnog broja procesa.
* Stepen multiprogramiranja (broj aktivnih procesa koji su u memoriji i koji se mogu uporedo izvršavati) je ograničen brojem particija.

== 3. zadatak ==
=== Postavka ===
Korisnik nekog računara radi u veb pregledaču (''web browser'') u kom je otvorio veliki broj kartica (''tab'') u kojima pregleda različite sajtove. Primetio je da mu se računar ponaša neobično, da sporo reaguje na akcije (ima veliko vreme odziva), da sporo prikazuje sadržaj stranica itd.
<div class="abc-list">
# ''Precizno'' objasniti zašto se ovo dešava.
# Korisnik je dalje primetio da kada zatvori većinu kartica i ostavi svega dve-tri, računar se ne ponaša ništa bolje. Ali kada ugasi ceo pregledač, računar se ponovo ponaša valjano. ''Precizno'' objasniti uzrok oba ova ponšaanja[sic].
</div>

=== Rešenje ===
<div class="abc-list">
# Veb pregledači obično za svaki tab pokrenu odvojenu nit, tako da se sa više tabova češće dešava promena konteksta. Pored toga, veće je zauzeće memorije, i može da se dešava da se sve stranice u fizičkom adresnom prostoru potroše pa mora da se radi zamena stranica, što zahteva spore operacije upisa i čitanja sa spoljašnje memorije i više promašaja keša, a može doći i do batrganja.
# Moguće je da pretraživač ne oslobodi sve resurse koje je zauzeo, pa se gašenjem tabova ne oslobodi korišćena memorija. Kada se ugasi ceo proces, operativni sistem će osloboditi sve resurse koje je proces koristio pa će moći da nastavi sa normalnijim radom.
</div>

== 4. zadatak ==
=== Postavka ===
Na jeziku C, korišćenjem sistemskih poziva <code>fork()</code> i <code>execlp()</code> za Unix, napisati program koji pokreće drugi program iz fajla čiji je naziv zadat kao parametar komandne linije prvog.

=== Rešenje ===
<syntaxhighlight lang="c">
int main(int argc, char* argv[]) {
if (argc < 2) {
// Korisnička greška.
return -1;
}
pid_t pid = fork();
if (pid < 0) {
// Nije uspeo fork().
return -2;
} else if (pid == 0) {
char* args[] = {argv[0], argv[1]};
execlp(argv[0], args);
// Nije uspeo execlp().
return -3;
}
return 0;
}
</syntaxhighlight>

== 5. zadatak ==
=== Postavka ===
Korišćenjem standardnih brojačkih semafora u školskom jezgru, na jeziku C++ napisati globalne deklaracije i inicijalizacije, kao i kod tela dve uporedne niti A i B koje ciklično rade:
* A: upisuje vrednost u deljene promenljive <code>x</code> i <code>y</code>, a zatim čeka da proces B upiše zbir <code>x</code> i <code>y</code> u promenljivu <code>z</code> čiju vrednost onda ispisuje na standardni izlaz;
* B: čeka da proces A upiše vrednosti u deljene promenljive <code>x</code> i <code>y</code>, zatim ove dve vrednosti sabira i zbir upisuje u deljenu promenljivu <code>z</code>.

=== Rešenje ===
<syntaxhighlight lang="cpp">
#include <iostream>

Semaphore waitA(0);
Semaphore waitB(0);

class A : public Thread {
public:
virtual void run() {
while (true) {
x = 1;
y = 2;
waitA.signal();
waitB.wait();
std::cout << z << std::endl;
}
}
};

class B : public Thread {
public:
virtual void run() {
while (true) {
waitA.wait();
z = x + y;
waitB.signal();
}
}
};

int main(void) {
A a;
B b;
a.start();
b.start();
a.join();
b.join();
return 0;
}
</syntaxhighlight>

== 6. zadatak ==
=== Postavka ===
Kojom tehnikom se nedeljivi uređaj može učiniti virtuelno deljivim? Navesti klasičan primer takvog uređaja za koji se najčešće primenjuje ova tehnika

=== Rešenje ===
Tehnikom ''spooling'' se nedeljevi uređaj može učiniti virtuelno deljivim, i klasičan primer takvog uređaja je štampač.

== 7. zadatak ==
=== Postavka ===
Neki fajl sistem koristi indeksirani pristup alokaciji fajlova sa indeksima u dva nivoa, blokom veličine 256KB i 64-bitnim adresama fizičkih blokova. Kolika je maksimalna veličina fajla u ovom sistemu?

=== Rešenje ===
Maksimalna veličina fajla se dostiže kada svi ulazi u indeks prvog nivoa pokazuju na indekse drugog nivoa, a svi indeksi drugog nivoa pokazuju na zauzete blokove. Indeksi prvog i drugog nivoa su veličine jednog bloka, tako da se broj ulaza u indeksu dobija deljenjem veličine bloka (<math>256KB = 2^{18}B</math>) i veličine ulaza (<math>64b = 8B = 2^3B</math>): <math>\frac{2^{18}B}{2^3B} = 2^{15}</math>. To znači da je moguće adresirati <math>2^{15}</math> indeksa drugog nivoa, i iz svakog indeksa drugog nivoa adresirati <math>2^{15}</math> blokova, a u svakom bloku ima <math>2^{18}B</math>, tako da je krajnja maksimalna veličina jednaka <math>2^{15+15+18} = 2^{48} = 256TB</math>.

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Јун 2021

2021-08-24T13:49:29Z

WikiEditor: /* dopuna */

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2021/jun/Jun%202021.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Šta je sistemski poziv, a šta sistemski program?

=== Rešenje ===
Sistemski poziv je određena funkcionalnost koju operativni sistem pruža korisničkim programima. Korisnički programi mogu pozvati sistemski poziv, često korišćenjem mehanizma softverskih prekida, kako bi od operativnog sistema zatražili neke osnovne usluge kojima najčešće iz korisničkog režima i nemaju pristup. Primer sistemskog poziva bi bio <code>fork()</code> na ''Unix-like'' sistemima.

Sistemski program je program koji obavlja osnovne operacije sa korisničkim sistemom, na primer brisanje fajlova (<code>rm</code> na ''Unix-like'' sistemima).

== 2. zadatak ==
=== Postavka ===
Šta su nedostaci organizacije memorije sa particijama?

=== Rešenje ===
* Pojavljuje se interna fragmentacija, jer ako procesu ne treba ceo svoj memorijski prostor onda je rezervisani deo prostora koji taj proces ne koristi bespotrebno bačen.
* Balansira se između veličine adresnog prostora jednog procesa i ukupnog broja procesa.
* Stepen multiprogramiranja (broj aktivnih procesa koji su u memoriji i koji se mogu uporedo izvršavati) je ograničen brojem particija.

== 3. zadatak ==
=== Postavka ===
Korisnik nekog računara radi u veb pregledaču (''web browser'') u kom je otvorio veliki broj kartica (''tab'') u kojima pregleda različite sajtove. Primetio je da mu se računar ponaša neobično, da sporo reaguje na akcije (ima veliko vreme odziva), da sporo prikazuje sadržaj stranica itd.
<div class="abc-list">
# ''Precizno'' objasniti zašto se ovo dešava.
# Korisnik je dalje primetio da kada zatvori većinu kartica i ostavi svega dve-tri, računar se ne ponaša ništa bolje. Ali kada ugasi ceo pregledač, računar se ponovo ponaša valjano. ''Precizno'' objasniti uzrok oba ova ponšaanja[sic].
</div>

=== Rešenje ===
<div class="abc-list">
# Veb pregledači obično za svaki tab pokrenu odvojenu nit, tako da se sa više tabova češće dešava promena konteksta. Pored toga, veće je zauzeće memorije, i može da se dešava da se sve stranice u fizičkom adresnom prostoru potroše pa mora da se radi zamena stranica, što zahteva spore operacije upisa i čitanja sa spoljašnje memorije i više promašaja keša, a može doći i do batrganja.
# Moguće je da pretraživač ne oslobodi sve resurse koje je zauzeo, pa se gašenjem tabova ne oslobodi korišćena memorija. Kada se ugasi ceo proces, operativni sistem će osloboditi sve resurse koje je proces koristio pa će moći da nastavi sa normalnijim radom.
</div>

== 4. zadatak ==
=== Postavka ===
Na jeziku C, korišćenjem sistemskih poziva <code>fork()</code> i <code>execlp()</code> za Unix, napisati program koji pokreće drugi program iz fajla čiji je naziv zadat kao parametar komandne linije prvog.

=== Rešenje ===
<syntaxhighlight lang="c">
int main(int argc, char* argv[]) {
if (argc < 2) {
// Korisnička greška.
return -1;
}
pid_t pid = fork();
if (fork < 0) {
// Nije uspeo fork().
return -2;
} else if (fork == 0) {
char* args[] = {argv[0], argv[1]};
execlp(argv[0], args);
// Nije uspeo execlp().
return -3;
}
return 0;
}
</syntaxhighlight>

== 5. zadatak ==
=== Postavka ===
Korišćenjem standardnih brojačkih semafora u školskom jezgru, na jeziku C++ napisati globalne deklaracije i inicijalizacije, kao i kod tela dve uporedne niti A i B koje ciklično rade:
* A: upisuje vrednost u deljene promenljive <code>x</code> i <code>y</code>, a zatim čeka da proces B upiše zbir <code>x</code> i <code>y</code> u promenljivu <code>z</code> čiju vrednost onda ispisuje na standardni izlaz;
* B: čeka da proces A upiše vrednosti u deljene promenljive <code>x</code> i <code>y</code>, zatim ove dve vrednosti sabira i zbir upisuje u deljenu promenljivu <code>z</code>.

=== Rešenje ===
<syntaxhighlight lang="cpp">
#include <iostream>

Semaphore waitA(0);
Semaphore waitB(0);

class A : public Thread {
public:
virtual void run() {
while (true) {
x = 1;
y = 2;
waitA.signal();
waitB.wait();
std::cout << z << std::endl;
}
}
};

class B : public Thread {
public:
virtual void run() {
while (true) {
waitA.wait();
z = x + y;
waitB.signal();
}
}
};

int main(void) {
A a;
B b;
a.start();
b.start();
a.join();
b.join();
return 0;
}
</syntaxhighlight>

== 6. zadatak ==
=== Postavka ===
Kojom tehnikom se nedeljivi uređaj može učiniti virtuelno deljivim? Navesti klasičan primer takvog uređaja za koji se najčešće primenjuje ova tehnika

=== Rešenje ===
Tehnikom ''spooling'' se nedeljevi uređaj može učiniti virtuelno deljivim, i klasičan primer takvog uređaja je štampač.

== 7. zadatak ==
=== Postavka ===
Neki fajl sistem koristi indeksirani pristup alokaciji fajlova sa indeksima u dva nivoa, blokom veličine 256KB i 64-bitnim adresama fizičkih blokova. Kolika je maksimalna veličina fajla u ovom sistemu?

=== Rešenje ===
Maksimalna veličina fajla se dostiže kada svi ulazi u indeks prvog nivoa pokazuju na indekse drugog nivoa, a svi indeksi drugog nivoa pokazuju na zauzete blokove. Indeksi prvog i drugog nivoa su veličine jednog bloka, tako da se broj ulaza u indeksu dobija deljenjem veličine bloka (<math>256KB = 2^{18}B</math>) i veličine ulaza (<math>64b = 8B = 2^3B</math>): <math>\frac{2^{18}B}{2^3B} = 2^{15}</math>. To znači da je moguće adresirati <math>2^{15}</math> indeksa drugog nivoa, i iz svakog indeksa drugog nivoa adresirati <math>2^{15}</math> blokova, a u svakom bloku ima <math>2^{18}B</math>, tako da je krajnja maksimalna veličina jednaka <math>2^{15+15+18} = 2^{48} = 256TB</math>.

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Јул 2017

2021-08-19T15:25:35Z

WikiEditor: Rešenje 7. zadatka ako nisam nesto pogrešila

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2017/jul/Jul%202017.pdf Zadaci sa stranice predmeta.]

== 1. zadatak ==
=== Postavka ===
Šta je hard, a šta soft sistem za rad u realnom vremenu (real-time system)?

=== Rešenje ===
Tvrdi sistemi za rad u realnom vremenu su sistemi u kojima odziv mora da stigne u određenom vremenu (''deadline''). Prekoračenje može dovesti do rezličitih katastrofa. Meki sistemi za rad u realnom vremenu su sistemi kojima je rok bitan ali smeju ga prekoračiti dok god performanse ulaze u zadate okvire.

== 2. zadatak ==
=== Postavka ===
Objasniti značenje mašinske instrukcije tipa ''test-and-set'' i njenu upotrebu u jezgru operativnog sistema.

=== Rešenje ===
<code>test_and_set</code> je instrukcija koja omogućava sinhronizaciju na hardverskom nivou. Služi za međusobno isključenje izvršavanja na više procesora. Ona atomično čita i vraća sadržaj zadate memorijske lokacije, i u tu lokaciju upisuje vrednost 1. Može da se koristi u implementaciji <code>lock()</code> funkcije.

== 3. zadatak ==
=== Postavka ===
Korišćenjem školskog jezgra napisati program koji u ''n'' uporednih niti izračunava kvadrat svakog elementa nekog celobrojnog niza (<code>a[i]*=a[i]</code>) veličine ''n*k'', tako što svaka nit obrađuje ''k'' elemanata[sic] (jednu particiju niza).

=== Rešenje ===
<syntaxhighlight lang="c++">
class ArrThread : Thread {
public:
ArrThread(int* a, int s, int f): arr(a), start(s), finish(f) {}
void run() {
for (int i = start; i < finish; i++) {
arr[i] *= arr[i];
}
}
private:
int* arr;
int start;
int finish;
};

int main() {
ArrThread* t[n];
int start = 0;
for (int i = 0; i < n; i++) {
t[i] = new ArrThread(array, start, start + k);
start += k;
}
for (int i = 0; i < n; i++) {
t[i]->waitToComplete();
delete t[i];
}
return 0;
}
</syntaxhighlight>

== 4. zadatak ==
Videti zadatak iz [[ОС1/Јул 2019#4. zadatak|julskog roka 2019]].

== 5. zadatak ==
=== Postavka ===
Precizno objasniti zašto klasičan linker svoj posao obavlja u dva prolaza (a ne može samo ujednom). Obrazloženje ilustrovati primerom.

=== Rešenje ===
Linkerov zadatak je da spoji sve fajlove u jedan izvršni, ali da bi to uradio, linker mora naći sve simbole koji se uvoze odnosno izvoze.

U prvom prolazu analizira ulazne fajlove, veličinu njihovog binarnog sadržaja (prevoda), i pravi mapu ''exe'' fajla; osim toga, sakuplja infomacije iz tabela simbola ''obj'' fajlova i izgrađuje svoju tabelu simbola; u tu tabelu simbola unosi izvezene simbole iz ''obj'' fajlova, za koje odmah može da izračuna adresu u odnosu na ceo ''exe'' fajl. U drugom prolazu spaja sve te fajlove u jedan, i ujedno razrešava nerazrešena adresna polja mašinskih instrukcija na osnovu informacija o adresama u koje se preslikavaju simboli iz njegove tabele simbola.

Primer: Recimo da imamo dva objektna fajla, <code>a.obj</code> i <code>b.obj</code>. <code>a.obj</code> izvozi simbol <code>f</code> i uvozi simbol <code>c</code>. Linker će iz prvog objektnog fajla dodati u tabelu simbol <code>f</code>. <code>b.obj</code> uvozi simbol <code>f</code> i izvozi simbol <code>c</code>, pa će linker u svoju tabelu dodati simbol <code>c</code>. U drugom prolazu će linker razrešiti <code>c</code> polje u <code>a.obj</code> i polje <code>f</code> u <code>b.obj</code>.

== 6. zadatak ==
=== Postavka ===
Objasniti uslugu koju program očekuje od operativnog sistema ako koristi preklope (''overlay'').

=== Rešenje ===
Obaveza OS-a je samo da obezbedi uslugu (sistemski poziv) koji alocira deo (virtuelnog) adresnog prostora procesa, kao i uslugu kojom u dati prostor procesa učitava sadržaj iz nekog binarnog fajla i sadržaj iz memorije upisuje u neki fajl (uobičajene sistemske usluge za rad sa fajlovima); OS ne zna za šta se te usluge koriste, tj. ne zna da se one upotrebljavaju baš za dinamičko učitavanje i zamenu delova procesa.

== 7. zadatak ==
=== Postavka ===
Virtuelni adresni prostor je veličine 1GB, organizovan je segmentno, sa maksimalnom veličinom segmenta od 4KB, adresibilna jedinica je bajt. Svi segmenti nekog procesa su stvarne veličine od po 2KB i u fizičku memoriju smešteni su odmah jedan iza drugog, pri čemu segment broj 0 počinje od fizičke adrese F000h. Prikazati logičku strukturu virtuelne adrese i izračunati u koju fizičku adresu se preslikava virtuelna adresa 2543h.

=== Rešenje ===
VA(30) : seg(18) offset(12)

Virtuelna adresa 2543h tj. 0010 | 0101 0100 0011b pripada 2. segmentu koji počinje od fizičke adrese 10000h i završava na 10800h.

Fizička adresa se dobija sabiranjem bazne adrese u fizičkom adresnom prostoru i offsetnog dela virtuelne adrese:
PA = 10000h + 543h = 10543h.

== 8. zadatak ==
Videti zadatak iz [[ОС1/Јун 2021#6. zadatak|junskog roka 2021. godine]].

== 9. zadatak ==
Videti zadatak iz [[ОС1/Јун 2020#7. zadatak|junskog roka 2020. godine]].

== 10. zadatak ==
=== Postavka ===
Neki fajl sistem koristi indeksirani pristup alokaciji fajlova sa indeksima u dva nivoa, blokom veličine 512KB i 64-bitnim adresama fizičkih blokova. Kolika je maksimalna veličina fajla u ovom sistemu?

=== Rešenje ===
Pošto je blok veličine <math>2^{19}B</math> a adresa <math>2^6B</math> to znači da u jedan indeks može da stane <math>2^{13}</math> adresa blokova. Konačan broj bajtova koji je na ovaj način mogu adresirati jeste <math>2^{13} \cdot 2^{13} \cdot 2^{19} = 2^{45}B = 32TB</math>.

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Јул 2020

2021-08-19T13:27:19Z

WikiEditor: /* 2^2 */

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2020/jul/Jul%202020.pdf Zadaci na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Na asembleru nekog zamišljenog RISC procesora sa ''load/store'' arhitekturom napisati program koji vrši prenos bloka podataka iz memorije na izlazni uređaj tehnikom programiranog izlaza korišćenjem prozivanja (''polling''). Samostalno usvojiti potrebne detaljne pretpostavke.

=== Rešenje ===
Pretpostavke:
* Memorija se prenosi sa adrese 1000h
* Ulazno/izlazni i adresni prostor su razdvojeni
* Kontrolni registar uređaja je na FF00h, registar podataka na FF01h a statusni registar na FF02h
* Adresiranje je bajtovsko
* Blok je veličine 100h bajtova
* Registri su veličine 16 bita i kad se čita ili piše iz memorije ili na uređaj koristi se najnižih 8 bita
* Najniži bit kontrolnog registra je bit ''Start'', najniži bit statusnog registra je bit ''Ready''
* Periferija automatski postaje nespremna za upis sledećeg podatka kada se u nju upiše podatak koji se još nije preneo
<syntaxhighlight lang="asm">
load r0, #1000h ; adresa
load r1, #100h ; brojač
load r2, #0 ; nula
load r3, #1 ; privremeni registar
out FF00h, r3 ; pokrećemo periferiju
loop: in FF02h, r3 ; čitamo statusni registar
and r3, r3, #1 ; proveravamo ready bit
jz loop ; ako je ready = 0 čitamo ponovo
load r3, (r0) ; učitavamo podatak iz memorije
out FF01h, r3 ; šaljemo podatak na periferiju
inc r0 ; inkrementiramo adresu
dec r1 ; dekrementiramo brojač (postavlja se PSW)
jnz loop ; ako brojač != 0 vraćamo se na čekanje
load r3, #0 ; gasimo periferiju
out FF00h, r3
</syntaxhighlight>

== 2. zadatak ==
=== Postavka ===
Korišćenjem školskog jezgra napisati kod klase koja apstrahuje nit koja, ukoliko se kreira sa neparnim celobrojnim parametrom, kreira još jednu takvu istu nit, samo sa za jedan manjim istim celobrojnim parametrom (sve dok ne stigne do 0), a u suprotnom se samo završava.

=== Rešenje ===
<syntaxhighlight lang="cpp">
class ForkThread : public Thread {
public:
ForkThread(unsigned n) : n(n) {}
virtual void run();
private:
unsigned n;
};

void ForkThread::run() {
if (n % 2) {
ForkThread thr(n-1);
thr.start();
thr.join();
}
}
</syntaxhighlight>

== 3. zadatak ==
=== Postavka ===
U nekom sistemu primenjuje se ''best-fit'' algoritam kontinualne alokacije memorije. Inicijalno je prostor veličine 512KB potpuno slobodan za alokaciju korisničkih procesa. Potom su različiti procesi zadavali sledeće zahteve (slovna oznaka označava proces koji je postavio zahtev, brojna oznaka označava veličinu alociranog prostora u KB, a minus označava gašenje procesa i oslobađanje njegove memorije):
: A128, B32, C256, D64, A-, E16, F64, B-
Odgovoriti na sledeća pitanja koja se odnose na stanje memorije nakon ove sekvence zahteva:
# Koliko je ukupno slobodnih fragmenata?
# Kolika je veličina najmanjeg slobodnog fragmenta?
# Kolika je veličina najvećeg slobodnog fragmenta?

=== Rešenje ===
Po koracima, alokacija memorije će izgledati ovako (jedno slovo = 16KB):
AAAAAAAABBCCCCCCCCCCCCCCCCDDDD--
--------BBCCCCCCCCCCCCCCCCDDDD--
--------BBCCCCCCCCCCCCCCCCDDDDE-
FFFF----BBCCCCCCCCCCCCCCCCDDDDE-
FFFF------CCCCCCCCCCCCCCCCDDDDE-
# 2 su slobodna fragmenta.
# Najmanji slobodan fragment je 16KB.
# Najveći slobodan fragment je 96KB.

== 4. zadatak ==
=== Postavka ===
Virtuelna memorija organizovana je stranično, a adresibilna jedinica je bajt. Virtuelna adresa je 32-bitna, stranica je veličine 4KB, PMT je organizovana u dva nivoa, deskriptor stranice je 32-bitni u tabelama oba nivoa, pri čemu je polje za straničenje prvog nivoa veličine 8 bita. Koliki prostor bi ukupno zauzimala PMT nekog procesa kada bi taj proces:
<div class="abc-list">
# koristio ceo svoj virtuelni adresni prostor?
# alocirao samo jedan logički segment veličine samo jedne stranice?
</div>

=== Rešenje ===
Adresa ima strukturu VA(32): Page1(8) Page2(12) Offset(12). PMT prvog nivoa ima <math>2^8</math> ulaza, a PMT drugog nivoa <math>2^{12}</math>, i oba imaju ulaze veličine <math>2^2</math> bajtova.
* <math>2^8 * 2^{12} * 2^2 + 2^8 * 2^2 = 2^{22} + 2^{10} = 4M + 1K</math>
* <math>2^8 * 2^2 + 2^{12} * 2^2 = 2^{10} + 2^{14} = 1K + 16K = 17K</math>

== 5. zadatak ==
=== Postavka ===
Umesto tehnike ''spooling'', pristup uporednih procesa štampaču u nekom sistemu omogućuje se međusobnim isključenjem pomoću operacije rezervacije: svaki proces, pre nego što zatraži bilo koju operaciju sa štampačem, mora da ga rezerviše, a tu rezervaciju otpušta tek kada završi sa celim jednim poslom štampe. Šta je nedostatak ove tehnike?

=== Rešenje ===
Nedostatak ove tehnike je što se procesi dok čekaju na štampač blokiraju, a za to vreme su mogli da rade nešto korisnije.

== 6. zadatak ==
=== Postavka ===
Neki fajl sistem pruža sledeće operacije u svom API za tekstualne fajlove:
* <syntaxhighlight lang="c" inline>FHANDLE open(char* filename)</syntaxhighlight> Otvara fajl sa datim imenom.
* <syntaxhighlight lang="c" inline>void close(FHANDLE)</syntaxhighlight> Zatvara dati fajl.
* <syntaxhighlight lang="c" inline>int size(FHANDLE)</syntaxhighlight> Vraća trenutnu veličinu sadržaja fajla u znakovima.
* <syntaxhighlight lang="c" inline>void append(FHANDLE, int)</syntaxhighlight> Proširuje sadržaj fajla za dati broj znakova na kraju.
* <syntaxhighlight lang="c" inline>void seek(FHANDLE, int)</syntaxhighlight> Postavlja kurzor datog fajla na datu poziciju (redni broj znaka počev od 0).
* <syntaxhighlight lang="c" inline>void write(FHANDLE, char*)</syntaxhighlight> Na poziciju kurzora datog fajla upisuje dati niz znakova, ne uključujući završni znak ‘\0’, i pomera kurzor iza upisanog niza znakova.
Napisati program koji na kraj postojećeg fajla sa imenom <code>proba.txt</code> upisuje sve što je uneseno preko standardnog ulaza, sve dok se na ulazu ne unese znak ’X’. Zanemariti sve potencijalne greške u ulazu/izlazu.

=== Rešenje ===
<syntaxhighlight lang="c">
int main(void) {
FHANDLE file = open("proba.txt");
seek(file, size(file));
char buf[2];
buf[1] = '\0';
while (true) {
buf[0] = getchar();
if (buf[0] == 'X') {
break;
}
append(file, 1);
write(file, buf);
}
close(file);
return 0;
}
</syntaxhighlight>

== 7. zadatak ==
=== Postavka ===
Koliko pristupa blokovima na disku treba izvršiti za pristup ''n''-tom logičkom bloku sadržaja fajla ako je alokacija fajla
<div class="abc-list">
# FAT, pri čemu je FAT uvek inicijalno učitana u memoriju prilikom montiranja fajl sistema,
# indeksna, pri čemu je ceo indeks fajla u jednom bloku, a broj tog bloka zapisan je u FCB koji je učitan prilikom otvaranja fajla?
</div>

=== Rešenje ===
<div class="abc-list">
# 1, jer je FAT već u memoriji pa se samo treba pristupiti bloku koji je tražen.
# 2, jedan da se pročita blok sa indeksom i jedan da se pristupi bloku koji je tražen.
</div>

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Октобар 2020

2021-08-19T12:53:01Z

WikiEditor: /* 32b = 2^3B*/

{{tocright}}
[http://os.etf.bg.ac.rs/OS1/rokovi/2020/oktobar/Okt%202020.pdf Zadaci sa stranice predmeta.]

== 1. zadatak ==
=== Postavka ===
Korišćenjem makroa <code>test_and_set</code> koji u svojoj implementaciji izvršava odgovarajuću instrukciju procesora tipa ''test-and-set'', implementirati međusobno isključenje kritične sekcije za višeprocesorski pristup.

=== Rešenje ===
<syntaxhighlight lang="c">
// Globalna
bool lock;

// Ulazak u kritičnu sekciju
while (test_and_set(&lock));
// Kritična sekcija
lock = false;
// ...
</syntaxhighlight>

== 2. zadatak ==
=== Postavka ===
Korišćenjem standardnih brojačkih semafora implementirati klasu sa dve operacije, ''tick'' i ''tock'', tako da se one mogu izvršavati iz konkurentnih procesa međusobno isključivo i samo u sledećem poretku: ''tick'', ''tick'', ''tock'', ''tick'', ''tick'', ''tock''...

=== Rešenje ===
<syntaxhighlight lang="cpp">
#include <iostream>

class Clock {
public:
Clock() : tickSem(0), tockSem(2), mutex(1),
allowedTock(false) {}
void tick();
void tock();
bool allowedTock;
private:
Semaphore tickSem;
Semaphore tockSem;
};

void Clock::tick() {
tockSem.wait();
mutex.wait();
std::cout << "tick" << std::endl;
if (allowedTock) {
tickSem.signal();
}
allowedTock = !allowedTock;
mutex.signal();
}

void Clock::tock() {
tickSem.wait();
mutex.wait();
std::cout << "tock" << std::endl;
tockSem.signal();
tockSem.signal();
mutex.signal();
}
</syntaxhighlight>

== 3. zadatak ==
=== Postavka ===
U definiciji semantike jezika C++ piše da pokušaj indirektnog upisa u objekat konstantnog tipa (označen kao <code>const</code>), recimo preko pokazivača na nekonstantu, ima „nedefinisan efekat“, što zapravo znači da se ostavlja mogućnost da različite implementacije prevodioca i različite platforme (hardver i OS) ovakve situacije tretiraju na različite načine. Navesti i precizno objasniti kakve tačno efekte ovakav upis može da ima i na koji način dolazi do tih efekata.

=== Rešenje ===
# Može da se desi da prevodilac više konstanti iste vrednosti alocira na istom mestu (kao što na primer postoji ''string pool'' u Javi) pa se upisom u jednu konstantu menjaju i sve ostale.
# Može da se desi da se te konstante čuvaju na stranici koja nije dozvoljena za upis (stranica sa kodom) pa se prilikom tog upisa generiše greška u pristupu stranici i operativni sistem ugasi proces.

== 4. zadatak ==
=== Postavka ===
U nekom sistemu sa straničnom organizacijom virtuelne memorije virtuelna i fizička adresa su 30-bitne, adresibilna jedinica je bajt, a stranica je veličine 64 KB. PMT je organizovana u dva nivoa i jedan ulaz u PMT oba nivoa zauzima po jednu 32-bitnu reč. PMT oba nivoa su iste veličine. Koliko ukupno zauzimaju PMT za proces koji je alocirao prvih 256 i poslednjih 256 stranica?

=== Rešenje ===
* VA(30): Page1(7) Page2(7) Offset(16)
* PA(30): Frame(14) Offset(16)
Pošto se iz jednog PMT može adresirati ukupno <math>2^7</math> ulaza u PMT, i svaki ulaz zauzima <math>2^3B</math>, to znači da jedan PMT ukupno zauzima <math>2^{10}B</math>. Za adresiranje 256 stranica potrebno je dva PMT drugog nivoa, tako da se ukupno stvara 5 PMT, i ukupna zauzeta veličina je <math>5 * 2^{10} = 5KB</math>.

== 5. zadatak ==
=== Postavka ===
Da li je drajver uređaja (''device driver'') softverska ili hardverska komponenta računara? Ako je softverska, da li je komponenta operativnog sistema ili korisničkog programa? Ako je hardverska, da li je komponenta vezana za funkcionisanje operativne memorije ili ulazno/izlaznog uređaja?

=== Rešenje ===
Drajver je softverska komponenta koja može ali ne mora biti deo operativnog sistema (npr. mikrokernelski operativni sistemi) i služi za standardizovanu komunikaciju sa ulaznim i izlaznim uređajima. Drajvere obično proizvode proizvođači uređaja za koji su ti drajveri pravljeni i obično se pokreću u privilegovanom režimu (ali to ne mora biti slučaj).

== 6. zadatak ==
=== Postavka ===
Ukratko objasniti koncept „tvrde veze“ (''hard link'') u fajl sistemu koji podržava strukture direktorijuma tipa usmerenog acikličkog grafa (DAG).

=== Rešenje ===
Tvrda veza je veza na datoteku koja služi tome da održava datoteku u fajl sistemu, jer dok god postoje tvrde veze na neku datoteku ona i dalje postoji, i kad se sve tvrde veze obrišu ona prestaje da postoji.

== 7. zadatak ==
=== Postavka ===
Kako se kod FAT fajl sistema implementira evidencija slobodnih blokova?

=== Rešenje ===
Kod FAT fajl sistema se u FAT tabeli mogu ulančavati slobodni blokovi, ili jednostavno biti označeni posebnim ''null'' vrednostima.

[[Категорија:Рокови]]
[[Категорија:ОС1]]

ОС1/Јул 2021

2021-08-19T12:18:24Z

WikiEditor: /* tajpo */

{{tocright}}
[http://os.etf.rs/OS1/rokovi/2021/jul/Jul%202021.pdf Zadaci na stranici predmeta.] Svi zadaci vrede 3 poena.

== 1. zadatak ==
=== Postavka ===
Šta je ''preotimanje procesora'' (engl. ''preemption'') i koji hardverski mehanizam ga omogućuje? Šta se postiže uvođenjem ove tehnike u računarske sisteme?

=== Rešenje ===
* '''Preotimanje procesora''' je prekidanje izvršavanja jednog procesa na procesu da bi se izvršio kernel kod ili neki drugi proces.
* '''Mehanizam prekida''' omogućuje preotimanje procesora - procesor dobija signal da prekine trenutni proces i pređe na kod kernela. Preotimanjem se postiže multiprocesiranje sa boljom raspodelom vremena i vremenom odziva.

== 2. zadatak ==
=== Postavka ===
Dat je potpis jednog sistemskog poziva na sistemima nalik sistemu Unix. Kratko, ali prezino objasniti šta radi ovaj sistemski poziv i značenje svakog parametra i rezultata.
<syntaxhighlight lang="c">void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);</syntaxhighlight>

=== Rešenje ===
<code>mmap</code> je sistemski poziv koji mapira fajl ili uređaj u memoriju. Značenja parametara:
* <code>void *addr</code> je (željena) početna adresa mapiranja. Ukoliko je <code>NULL</code>, operativni sistem sam bira početnu adresu.
* <code>size_t length</code> je dužina mapirane memorije
* <code>int prot</code> je fleg koji označava dozvoljene načine pristupa mapiranoj memoriji (da li sme da se čita, upisuje, izvršava) i mora se slagati sa načinom pristupa fajla.
* <code>int flags</code> je fleg koji označava da li je mapirana memorija vidljiva ostalim procesima koji mapiraju isti fajl, da li se promene u memoriji upisuju u fajl itd.
* <code>int fd</code> je ručka fajla
* <code>off_t offset</code> je pomeraj od početka fajla od kojeg se vrši mapiranje
Ukoliko je poziv uspešan, vraća se void pokazivač na memoriju koja je mapirana.

== 3. zadatak ==
=== Postavka ===
Šta se postiže tehnikom “kopiranja pri upisu” kod upravljanja memorijom? Kratko, ali precizno objasniti način rada ove tehnike.

=== Rešenje ===
Tehnikom ''copy-on-write'' postiže se '''ušteda memorije''', tako što se memorija koja se koristi u više procesa ne kopira dok je jedan proces ne promeni. Implementira se tako što se u deskriptor logičkog segemtna koja se deli između procesa označi kao dozvoljen za upis, ali u ulazu PMT-a kao zabranjen za upis. U situaciju kada se desi upis, hardver generiše izuzetak koji se obrađuje od strane OS-a. OS zaključuje da se radi o kopiranju pri upisu iz deskriptora logičkog segmenta i vrši kopiranje, usmeravanje PMT-a drugog procesa na kopiju i u deskriptorima stranica obe kopije dozvoljava upis.

== 4. zadatak ==
=== Postavka ===
Ako se nad sledećim programom kreira jedan proces, koliko će ukupno biti elemenata sa vrednošću '''različitom od 0''' u nizovima <code>pid</code> svih kreiranih procesa (uključujući i taj jedan početni) kada svi ti procesi izađu iz petlje, pod pretpostavkom da su svi sistemski pozivi uspeli?
<syntaxhighlight lang="c">
const int N=2; int pid[N];
void main () {
for (int i=0; i<N; i++) pid[i] = fork();
}
</syntaxhighlight>

=== Rešenje ===
<code>fork()</code> u kontekstu roditelja vraća pravi <code>pid</code> deteta, a u kontekstu deteta vraća 0. Odgovor je 4: <code>child1</code> i <code>child3</code> u ''parent'', <code>child2</code> u ''child1'' i <code>child1</code> u ''child3''.
[[Датотека:OS1 jul 2021 4. zadatak objašnjenje.svg|оквир|центар|Objašnjenje]]

== 5. zadatak ==
=== Postavka ===
Dokazati da Petersonov algoritam za međusobno isključenje kritičnih sekcija dva uporedna procesa uposlenim čekanjem zaista obezbeđuje međusobno isključenje, odnosno ne poseduje problem utrkivanja (engl. ''race condition''). (Dati kod samo jednog procesa sa međusobnim isključenjem pomoću ovog algoritma.)

=== Rešenje ===
Petersonov algoritam:
<syntaxhighlight lang="ada">
process P1;
begin
loop
flag1 := true; turn := 2;
while flag2 and turn = 2 do null;
<critical section>
flag1 := false;
<non-critical section>
end
end P1;
</syntaxhighlight>
Pretpostavimo da algoritam ne obezbeđuje međusobno isključenje. Ako algoritam NE obezbeđuje međusobno isključenje, dogodiće se situacija da su oba procesa ušla u kritičnu sekciju. Ako se to desilo, to znači da su oba uslova petlji uposlenog čekanja <code>false</code>. Pošto oba procesa odmah pred ulazak u petlju postavljaju svoj <code>flag</code> na <code>true</code>, jedini način da uslov za petlju bude netačan je da uslov sa <code>turn</code> bude netačan, a pošto su oba uslova netačna, to bi značilo da promenljiva <code>turn</code> nema ni vrednost 1 ni vrednost 2. Pošto promenljivu <code>turn</code> koriste samo ova dva procesa i samo postavljaju vrednost na 1 ili 2, do ovoga nikako ne može doći. Time dobijamo kontradikciju na početnu pretpostavku i dobijamo da algoritam zaista omogućava međusobno isključenje.

== 6. zadatak ==
=== Postavka ===
Šta je ''simbolička veza'' (''symbolic link'', ''soft link'') u fajl sistemu? Kako se ona implementira?

=== Rešenje ===
'''Simbolička veza''' je veza do nekog fajla u fajl sistemu koja se ne ažurira automatski. Implementira se kao '''fajl sa posebnim tretmanom''' od strane operativnog sistema i u sebi sadrži apsolutnu i relativnu putanju do nekog fajla u fajl sistemu. Razlikuje se od tvrde veze tako što ne pokazuje direktno do FCB-a i može da postane prekinuta tj. landarava.

== 7. zadatak ==
=== Postavka ===
Neki fajl sistem koristi bit vektor za evidenciju slobodnih blokova na disku. Kolika je veličina ovog vektora u bajtovima, za disk veličine 16 TB sa blokom veličine 512B.

=== Rešenje ===
* 16 TB = 24 * 240 B = 244 B.
* 244 B / 512 B = 244 B / 29 = 235 blokova.
* 235 / 8 bita u B = 232 = 22 * 230 = '''4 GB'''.

[[Категорија:Рокови]]
[[Категорија:ОС1]]

Вероватноћа и статистика/Јун 2021

2021-06-20T13:12:51Z

WikiEditor: /* sad je oki */

== Испитни део - Статистика ==
=== 1. задатак ===
==== Поставка ====
Нека су Х и Y независне случајне променљиве са <math>Unif(0, 1)</math> расподелом и нека важи за случајне променљиве U и V важи U = 2X + 4Y, V = X - Y. Одредити коефицијент корелације за <math>\rho (U, V)</math>.

==== Решење ====
<math>-0.316</math>

=== 2. задатак ===
==== Поставка ====
Нека случајна променљива Х има расподелу <math>Bin(100, p)</math>) са вероватноћом успеха p, 0 \frac{2}{5}</math>

=== 3. задатак ===
==== Поставка ====
1) Дати дефиницију карактеристичне функције случајне променљиве Х.

2) Дати исказ теореме која описује особину карактеристичне функције збира две случајне променљиве.

3) Нека су Х и Y независне случајне променљиве, где Х има <math>Unif(0, 1)</math> расподелу, а Y је дата законом расподеле
<math>Y : \left(\begin{array}{ll}
1 & 2 \\
0.5 & 0.5 \\
\end{array}\right)</math>. Доказати да случајна променљива Z = X + Y има <math>Unif(1, 3)</math> расподелу.

=== 4. задатак ===
==== Поставка ====
Број студената на предавањима је случајна променљива са <math>Poiss(36)</math> расподелом.
1) Колико треба да има места у учионици да би са вероватноћом бар 99% сви присутни студенти могли да седе?

2) Која апроксимација је коришћена под 1)? Објаснити како се дошло до те апроскимације.
==== Решење ====
Минималан број места је 50. Коришћена је апроксимација Пуасонове расподеле нормалном <math>N(36, 36)</math> расподелом.

=== 5. задатак ===
==== Поставка ====
На основу узорка обима 121 из <math>N(\mu, \sigma^2)</math> расподеле добијено је <math>\hat{\mu} = 1.2</math> и <math>s^2 = 2.25</math>. Тестираати хипотезу <math>H_0: \mu = 1</math> против алтернативне хипотезе <math>H_1: \mu > 1</math> са нивоом значајности 0.05. Објаснити поступак.

==== Решење ====
Хипотеза <math>H_0</math> се не одбацује.
[[Категорија:Вероватноћа_и_статистика]]
[[Категорија:Рокови]]

Вероватноћа и статистика/Јун 2021

2021-06-20T13:08:42Z

WikiEditor: /* sredite samo ovaj deo pliz */

== Испитни део - Статистика ==
=== 1. задатак ===
==== Поставка ====
Нека су Х и Y независне случајне променљиве са <math>Unif(0, 1)</math> расподелом и нека важи за случајне променљиве U и V важи U = 2X + 4Y, V = X - Y. Одредити коефицијент корелације за <math>\rho (U, V)</math>.

==== Решење ====
<math>-0.316</math>

=== 2. задатак ===
==== Поставка ====
Нека случајна променљива Х има расподелу <math>Bin(100, p)</math>) са вероватноћом успеха p, 0 \frac{2}{5}</math>

=== 3. задатак ===
==== Поставка ====
1) Дати дефиницију карактеристичне функције случајне променљиве Х.

2) Дати исказ теореме која описује особину карактеристичне функције збира две случајне променљиве.

3) Нека су Х и Y независне случајне променљиве, где Х има <math>Unif(0, 1)</math> расподелу, а Y је дата са законом расподеле
<math> \left $ \begin{tabular}{ccc} 1 & 2 \\ 0.5 & 0.5 \\ \end{tabular} \right $ </math> (0.5, 2 0.5). Доказати да случајна променљива Z = X + Y има <math>Unif(1, 3)</math> расподелу.

=== 4. задатак ===
==== Поставка ====
Број студената на предавањима је случајна променљива са <math>Poiss(36)</math> расподелом.
1) Колико треба да има места у учионици да би са вероватноћом бар 99% сви присутни студенти могли да седе?

2) Која апроксимација је коришћена под 1)? Објаснити како се дошло до те апроскимације.
==== Решење ====
Минималан број места је 50. Коришћена је апроксимација Пуасонове расподеле нормалном <math>N(36, 36)</math> расподелом.

=== 5. задатак ===
==== Поставка ====
На основу узорка обима 121 из <math>N(\mu, \sigma^2)</math> расподеле добијено је <math>\hat{\mu} = 1.2</math> и <math>s^2 = 2.25</math>. Тестираати хипотезу <math>H_0: \mu = 1</math> против алтернативне хипотезе <math>H_1: \mu > 1</math> са нивоом значајности 0.05. Објаснити поступак.

==== Решење ====
Хипотеза <math>H_0</math> се не одбацује.
[[Категорија:Вероватноћа_и_статистика]]
[[Категорија:Рокови]]

Вероватноћа и статистика/Јун 2021

2021-06-20T12:59:14Z

WikiEditor: /* Испитни део - Статистика */

== Испитни део - Статистика ==
=== 1. задатак ===
==== Поставка ====
Нека су Х и Y независне случајне променљиве са <math>Unif(0, 1)</math> расподелом и нека важи за случајне променљиве U и V важи U = 2X + 4Y, V = X - Y. Одредити коефицијент корелације за <math>\rho (U, V)</math>.

==== Решење ====
<math>-0.316</math>

=== 2. задатак ===
==== Поставка ====
Нека случајна променљива Х има расподелу <math>Bin(100, p)</math>) са вероватноћом успеха p, 0 \frac{2}{5}</math>

=== 3. задатак ===
==== Поставка ====
1) Дати дефиницију карактеристичне функције случајне променљиве Х.

2) Дати исказ теореме која описује особину карактеристичне функције збира две случајне променљиве.

3) Нека су Х и Y независне случајне променљиве, где Х има <math>Unif(0, 1)</math> расподелу, а Y је дата са законом расподеле (1 0.5, 2 0.5). Доказати да случајна променљива Z = X + Y има <math>Unif(1, 3)</math> расподелу.

=== 4. задатак ===
==== Поставка ====
Број студената на предавањима је случајна променљива са <math>Poiss(36)</math> расподелом.
1) Колико треба да има места у учионици да би са вероватноћом бар 99% сви присутни студенти могли да седе?

2) Која апроксимација је коришћена под 1)? Објаснити како се дошло до те апроскимације.
==== Решење ====
Минималан број места је 50. Коришћена је апроксимација Пуасонове расподеле нормалном <math>N(36, 36)</math> расподелом.

=== 5. задатак ===
==== Поставка ====
На основу узорка обима 121 из <math>N(\mu, \sigma^2)</math> расподеле добијено је <math>\hat{\mu} = 1.2</math> и <math>s^2 = 2.25</math>. Тестираати хипотезу <math>H_0: \mu = 1</math> против алтернативне хипотеѕе <math>H_1: \mu > 1</math> са нивоом значајности 0.05. Објаснити поступак.

==== Решење ====
Хипотеза <math>H_0</math> се не одбацује.
[[Категорија:Вероватноћа_и_статистика]]
[[Категорија:Рокови]]

Вероватноћа и статистика/Јун 2021

2021-06-20T12:58:41Z

WikiEditor: /* jos sitnica */

== Испитни део - Статистика ==
=== 1. задатак ===
==== Поставка ====
Нека су Х и Y независне случајне променљиве са <math>Unif(0, 1)</math> расподелом и нека важи за случајне променљиве U и V важи U = 2X + 4Y, V = X - Y. Одредити коефицијент корелације за <math>\rho (U, V)</math>.

==== Решење ====
<math>-0.316</math>

=== 2. задатак ===
==== Поставка ====
Нека случајна променљива Х има расподелу <math>Bin(100, p)</math>) са вероватноћом успеха p, 0 \frac{2}{5}</math>

=== 3. задатак ===
==== Поставка ====
1) Дати дефиницију карактеристичне функције случајне променљиве Х.

2) Дати исказ теореме која описује особину карактеристичне функције збира две случајне променљиве.

3) Нека су Х и Y независне случајне променљиве, где Х има <math>Unif(0, 1)</math> расподелу, а Y је дата са законом расподеле (1 0.5, 2 0.5). Доказати да случајна променљива Z = X + Y има <math>Unif(1, 3)</math> расподелу.

=== 4. задатак ===
==== Поставка ====
Број студената на предавањима је случајна променљива са <math>Poiss(36)</math> расподелом.
1) Колико треба да има места у учионици да би са вероватноћом бар 99% сви присутни студенти могли да седе?

2) Која апроксимација је коришћена под 1)? Објаснити како се дошло до те апроскимације.
==== Решење ====
Минималан број места је 50. Коришћена је апроксимација Пуасонове расподеле нормалном <math>N(36, 36)</math> расподелом.

=== 5. задатак ===
==== Поставка ====
На основу узорка обима 121 из <math>N(\mu^2, \sigma)</math> расподеле добијено је <math>\hat{\mu} = 1.2</math> и <math>s^2 = 2.25</math>. Тестираати хипотезу <math>H_0: \mu = 1</math> против алтернативне хипотеѕе <math>H_1: \mu > 1</math> са нивоом значајности 0.05. Објаснити поступак.

==== Решење ====
Хипотеза <math>H_0</math> се не одбацује.
[[Категорија:Вероватноћа_и_статистика]]
[[Категорија:Рокови]]

Вероватноћа и статистика/Јун 2021

2021-06-20T12:54:02Z

WikiEditor: /* slovo */

== Испитни део - Статистика ==
=== 1. задатак ===
==== Поставка ====
Нека су Х и Y независне случајне променљиве са <math>Unif(0, 1)</math> расподелом и нека важи за случајне променљиве U и V важи U = 2X + 4Y, V = X - Y. Одредити коефицијент корелације за <math>\rho (U, V)</math>.

==== Решење ====
<math>-0.316</math>

=== 2. задатак ===
==== Поставка ====
Нека случајна променљива Х има расподелу <math>Bin(100, p)</math>) са вероватноћом успеха p, 0 \frac{2}{5}</math>

=== 3. задатак ===
==== Поставка ====
1) Дати дефиницију карактеристичне функције случајне променљиве Х.

2) Дати исказ теореме која описује особину карактеристичне функције збира две случајне променљиве.

3) Нека су Х и Y независне случајне променљиве, где Х има <math>Unif(0, 1)</math> расподелу, а Y је дата са законом расподеле (1 0.5, 2 0.5). Доказати да случајна променљива Z = X + Y има <math>Unif(1, 3)</math> расподелу.

=== 4. задатак ===
==== Поставка ====
Број студената на предавањима је случајна променљива са <math>Poiss(36)</math> расподелом.
1) Колико треба да има места у учионици да би са вероватноћом бар 99% сви присутни студенти могли да седе?

2) Која апроксимација је коришћена под 1)? Објаснити како се дошло до те апроскимације.
==== Решење ====
Минималан број места је 50. Коришћена је апроксимација Пуасонове расподеле нормалном <math>N(36, 36)</math> расподелом.

=== 5. задатак ===
==== Поставка ====
На основу узорка обима 121 из <math>N(36, 36)</math> расподеле добијено је <math>\mu = 1.2</math> и <math>s^2 = 2.25</math>. Тестираати хипотезу <math>H_0: \mu = 1</math> против алтернативне хипотеѕе <math>H_1: \mu > 1</math> са нивоом значајности 0.05. Објаснити поступак.
==== Решење ====
Хипотеза <math>H_0</math> се не одбацује.
[[Категорија:Вероватноћа_и_статистика]]
[[Категорија:Рокови]]

Вероватноћа и статистика/Јун 2021

2021-06-20T12:49:49Z

WikiEditor: /* Решење */

== Испитни део - Статистика ==
=== 1. задатак ===
==== Поставка ====
Нека су Х и Y независне случајне променљиве са <math>Unif(0, 1)</math> расподелом и нека важи за случајне променљиве U и V важи U = 2X + 4Y, V = X - Y. Одредити коефицијент корелације за <math>\phi (U, V)</math>.
==== Решење ====
<math>-0.316</math>

=== 2. задатак ===
==== Поставка ====
Нека случајна променљива Х има расподелу <math>Bin(100, p)</math>) са вероватноћом успеха p, 0 \frac{2}{5}</math>

=== 3. задатак ===
==== Поставка ====
1) Дати дефиницију карактеристичне функције случајне променљиве Х.

2) Дати исказ теореме која описује особину карактеристичне функције збира две случајне променљиве.

3) Нека су Х и Y независне случајне променљиве, где Х има <math>Unif(0, 1)</math> расподелу, а Y је дата са законом расподеле (1 0.5, 2 0.5). Доказати да случајна променљива Z = X + Y има <math>Unif(1, 3)</math> расподелу.

=== 4. задатак ===
==== Поставка ====
Број студената на предавањима је случајна променљива са <math>Poiss(36)</math> расподелом.
1) Колико треба да има места у учионици да би са вероватноћом бар 99% сви присутни студенти могли да седе?

2) Која апроксимација је коришћена под 1)? Објаснити како се дошло до те апроскимације.
==== Решење ====
Минималан број места је 50. Коришћена је апроксимација Пуасонове расподеле нормалном <math>N(36, 36)</math> расподелом.

=== 5. задатак ===
==== Поставка ====
На основу узорка обима 121 из <math>N(36, 36)</math> расподеле добијено је <math>\mu = 1.2</math> и <math>s^2 = 2.25</math>. Тестираати хипотезу <math>H_0: \mu = 1</math> против алтернативне хипотеѕе <math>H_1: \mu > 1</math> са нивоом значајности 0.05. Објаснити поступак.
==== Решење ====
Хипотеза <math>H_0</math> се не одбацује.
[[Категорија:Вероватноћа_и_статистика]]
[[Категорија:Рокови]]

Вероватноћа и статистика/Јун 2021

2021-06-20T12:49:25Z

WikiEditor: ViS Ispit iz statistike jun 2021

== Испитни део - Статистика ==
=== 1. задатак ===
==== Поставка ====
Нека су Х и Y независне случајне променљиве са <math>Unif(0, 1)</math> расподелом и нека важи за случајне променљиве U и V важи U = 2X + 4Y, V = X - Y. Одредити коефицијент корелације за <math>\phi (U, V)</math>.
==== Решење ====
<math>-0.316</math>

=== 2. задатак ===
==== Поставка ====
Нека случајна променљива Х има расподелу <math>Bin(100, p)</math>) са вероватноћом успеха p, 0 \frac{2}{5}</math>

=== 3. задатак ===
==== Поставка ====
1) Дати дефиницију карактеристичне функције случајне променљиве Х.

2) Дати исказ теореме која описује особину карактеристичне функције збира две случајне променљиве.

3) Нека су Х и Y независне случајне променљиве, где Х има <math>Unif(0, 1)</math> расподелу, а Y је дата са законом расподеле (1 0.5, 2 0.5). Доказати да случајна променљива Z = X + Y има <math>Unif(1, 3)</math> расподелу.

=== 4. задатак ===
==== Поставка ====
Број студената на предавањима је случајна променљива са <math>Poiss(36)</math> расподелом.
1) Колико треба да има места у учионици да би са вероватноћом бар 99% сви присутни студенти могли да седе?

2) Која апроксимација је коришћена под 1)? Објаснити како се дошло до те апроскимације.
==== Решење ====
Минималан број места је 50. Коришћена је апроксимација Пуасонове расподеле нормалном <math>N(36, 36)</math> расподелом.

=== 5. задатак ===
==== Поставка ====
На основу узорка обима 121 из <math>N(36, 36)</math> расподеле добијено је <math>\mu = 1.2</math> и <math>s^2 = 2.25</math>. Тестираати хипотезу <math>H_0: \mu = 1</math> против алтернативне хипотеѕе <math>H_1: \mu > 1</math> са нивоом значајности 0.05. Објаснити поступак.
==== Решење ====
Џипотеза <math>H_0</math> се не одбацује.
[[Категорија:Вероватноћа_и_статистика]]
[[Категорија:Рокови]]

АСП2/К3 2017

2021-02-16T19:33:20Z

WikiEditor: /* jos jedna izmena */

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S112ASP2_k3_2016.pdf Postavka zadataka sa stranice predmeta.]

== 1. zadatak ==
=== Postavka ===
Kako izgleda niz sa slike nakon prvih pet iteracija ''shakersort'' algoritma?

=== Rešenje ===
{| class="wikitable"
|+ Niz nakon pet iteracija ''shakersort'' algoritma
| 12 || 3 || 34 || 83 || 21 || 95 || 34 || 1 || 18 || 20 || 83 || 17 || 44 || 39
|-
| 3 || 12 || 34 || 21 || 83 || 34 || 1 || 18 || 20 || 83 || 17 || 44 || 39 || 95
|-
| 1 || 3 || 12 || 34 || 21 || 83 || 34 || 17 || 18 || 20 || 83 || 39 || 44 || 95
|-
| 1 || 3 || 12 || 21 || 34 || 34 || 17 || 18 || 20 || 83 || 39 || 44 || 83 || 95
|-
| 1 || 3 || 12 || 17 || 21 || 34 || 34 || 18 || 20 || 39 || 83 || 44 || 83 || 95
|-
| 1 || 3 || 12 || 17 || 21 || 34 || 18 || 20 || 34 || 39 || 44 || 83 || 83 || 95
|}

== 2. zadatak ==
=== Postavka ===
Data je heš tabela sa 10 ulaza. U tabelu se unose ključevi koje se mogu sastojati od velikih i malih slova. Primarna heš funkcija je ''H1(K) = (1 + len(K)) mod 10'', gde ''len(K)'' vraća broj slova u prosleđenom ključu ''K''. Vremenska lokalnost je veoma izražena, jer se nakon umetanja svakog ključa javlja veliki broj pretraživanja na taj ključ pre nego što se umetne sledeći. Kolizije se razrešavaju nestandardnom primenom dvostrukog heširanja kod koga je sekundarna funkcija ''H2(K) = 3 + up_case_cnt(K)'', gde ''up_case_cnt(K)'' vraća ukupan broj velikih slova u ključu ''K''.
<div class="abc-list">
# Predložiti modifikaciju načina za razrešavanje kolizije tako da se minimizuje vreme uspešnog pretraživanja u datim uslovima.
# Primenom predloženog rešenja u donju tabelu umetnuti sledeće ključeve:
#: ČoKoLaDa, PalAčINka, kafA, TORtA, RoLaT, SLadoled, koLAČ
#: Prikazati finalno stanje heš tabele i celokupan postupak primenom tehnike opisane u rešenju pod a).
</div>

=== Rešenje ===
<div class="abc-list">
# Prilikom razrešavanja kolizije, postojeće ključeve možemo pomeriti da budu niže u ispitnom nizu duplim heširanjem a novoumetnuti ključ staviti na njegov početak kako bi se sa što manjim brojem kolizija dolazilo do najskorije umetnutih ključeva.
# Umetanje u tabelu ide ovako:
## ČoKoLaDa se umeće na mesto 9
## PalAčINka se umeće na mesto 0
## kafA se umeće na mesto 5
## TORtA se umeće na mesto 6
## RoLaT se umeće na mesto 6, TORtA se pomera na mesto 3
## SLadoled se umeće na mesto 9, ČoKoLaDa se pomera na mesto 6, RoLaT se pomera na mesto 2
## koLAČ se umeće na mesto 6, ČoKoLaDa se pomera na mesto 3, TORtA se pomera na mesto 0, PalAčINka se pomera na mesto 7
</div>
{| class="wikitable"
|+ Konačni izgled heš tabele nakon umetanja
! 0
| TORtA
|-
! 1
|
|-
! 2
| RoLaT
|-
! 3
| ČoKoLaDa
|-
! 4
|
|-
! 5
| kafA
|-
! 6
| koLAČ
|-
! 7
| PalAčINka
|-
! 8
|
|-
! 9
| SLadoled
|}

== 3. zadatak ==
=== Postavka ===
Napisati iterativnu implementaciju ''quicksort'' algoritma. U telu funkcije QUICKSORT koja će predstavljati ovu implementaciju, nakon izbora pivota, pozivati funkciju PARTITION koja vraća konačnu poziciju pivota u nizu. Algoritam realizovati što efikasnije, a za pivot uzeti element niza koji je srednji po vrednosti u izboru između elemenata sa prve tri pozicije u particiji.

=== Rešenje ===
Pošto se pominje velika efikasnost, bitno je da na stek guramo veće particije a direktno obilazimo manje kako bi dubina steka bila što manja.
<syntaxhighlight lang="milo">
QUICKSORT(arr, n)
STACK_INIT(S_down)
STACK_INIT(S_up)
down = 1
up = n
from_stack = false
while (not STACK_EMPTY(S_down)) or (not from_stack) do
if from_stack then
down = POP(S_down)
up = POP(S_up)
end_if
if up - down = 1 then
if arr[up] < arr[down] then
arr[up] ↔ arr[down]
end_if
from_stack = true
continue
end_if
first = arr[up]
second = arr[up+1]
third = arr[up+2]
if (first ≤ second ≤ third) or (third ≤ second ≤ first) then
pivot = 2
else if (second ≤ first ≤ third) or (third ≤ first ≤ second) then
pivot = 1
else
pivot = 3
end_if
pivot_pos = PARTITION(arr, down, up, pivot)
lower_down = down
lower_up = pivot_pos-1
higher_down = pivot_pos+1
higher_up = up
if (lower_up - lower_down < 1) and (higher_up - higher_down < 1) then
from_stack = true
else if lower_up - lower_down < higher_up - higher_down then
up = lower_up
down = lower_down
from_stack = false
PUSH(S_down, higher_down)
PUSH(S_up, higher_up)
else
up = higher_up
down = higher_down
from_stack = false
PUSH(S_down, lower_down)
PUSH(S_up, lower_up)
end_if
end_while
</syntaxhighlight>
Pošto je rečeno da se izbor pivota radi u QUICKSORT, pretpostavićemo da se taj pivot zatim prosleđuje PARTITION kao parametar.
<syntaxhighlight lang="milo">
PARTITION(arr, down, up, pivot_pos)
i = down
j = up
pivot = arr[pivot_pos]
while i < j do
while (arr[i] ≤ pivot) and (i < j) do
i = i + 1
end_while
while arr[j] > pivot do
j = j - 1
end_while
if i < j then
arr[i] ↔ arr[j]
end_while
end_while
arr[pivot_pos] ↔ arr[j]
return j
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
Napisati u pseudokodu funkciju za dekrementiranje ključa koji se nalazi u binarnom nerastućem (max) hipu. Smatrati da je hip smešten u nizu čiji indeksi počinju od 0. Funkcija kao svoj parametar dobija indeks ključa u nizu koga treba dekrementirati.

=== Rešenje ===
<syntaxhighlight lang="milo">
HEAP KEY DEC(i)
arr[i] = arr[i]-1
left = 2 * i + 1
right = 2 * i + 2
while ((left ≤ n) and (arr[left] > arr[i])) or ((right ≤ n) and (arr[right] > arr[i])) do
if right ≤ n then
if arr[right] > arr[left] then
high = right
else
high = left
end_if
else
high = left
end_if
arr[i] ↔ arr[high]
i = high
left = 2 * i + 1
right = 2 * i + 2
end_while
</syntaxhighlight>

== 5. zadatak ==
=== Postavka ===
Podaci se smeštaju u heš tabelu sa 7 ulaza primenom heš funkcije hp(K) = K mod 7. Za razrešavanje kolizija se koristi metoda dvostrukog heširanja sa sekundarnom heš funkcijom hs(K) = 4 + K mod 2. Obrazložiti na koji način u ovom slučaju može doći do sekundarnog grupisanja i navesti sekvencu od tri ključa koja proizvodi ovaj efekat u konkretnom slučaju. Navedene ključeve uneti u tabelu.

=== Rešenje ===
U ovom slučaju može doći do sekundarnog grupisanja kada uneti ključevi daju isti ostatak pri deljenju sa 7 i pri deljenju sa 2. Takvi su recimo ključevi 0, 14 i 28.
{| class="wikitable"
|+ Tabela sa unetim ključevima
! 0
| 0
|-
! 1
|
|-
! 2
|
|-
! 3
|
|-
! 4
| 14
|-
! 5
|
|-
! 6
|
|-
! 7
|
|-
! 8
| 28
|}

== 6. zadatak ==
=== Postavka ===
Fibonačijev hip
<div class="abc-list">
# Koja je razlika između dodavanja u binomni hip i Fibonačijev hip? Objasniti kratko i precizno, u jednoj do dve rečenice.
# U prazan Fibonačijev hip dodaju se elementi 10, 5, 17, 3, 12, 11, 1, potom se briše element sa vrednošću 1, nakon čega se dodaju elementi 7 i 2. Nacrtati izgled hipa nakon prvih sedam umetanja i nakon svake naredne izmene hipa.
</div>

=== Rešenje ===
<div class="abc-list">
# Pri dodavanju u Fibonačijev hip uneti čvor se samo ulančava, a grupisanje slično binomnom hipu se dešava tek kod izbacivanja najmanjeg elementa.
# Ispod su dati izgledi hipa nakon date četiri operacije.
</div>
<gallery>
ASP2 K3 2017 zadatak 6 hip umetanje 1.png | Izgled hipa nakon umetanja 10, 5, 17, 3, 12, 11, 1.
ASP2 K3 2017 zadatak 6 hip brisanje.png | Izgled hipa nakon brisanja 1.
ASP2 K3 2017 zadatak 6 hip umetanje 2.png | Izgled hipa nakon umetanja 7.
ASP2 K3 2017 zadatak 6 hip umetanje 3.png | Izgled hipa nakon umetanja 2.
</gallery>

== 7. zadatak ==
=== Postavka ===
Podaci se smeštaju u heš tabelu sa ''n'' ulaza primenom heš funkcije h(K) = K mod n. Za razrešavanje kolizija se koristi metoda kvadratnog pretraživanja, ali nije dozvoljeno koristiti operaciju množenja (kvadriranja). Predložiti metod brisanja i napisati pseudokodove operacija brisanja i umetanja.

=== Rešenje ===
Možemo primetiti da <math>2^2 - 1^2 = 3, 3^2 - 2^2 = 5, 4^2 - 3^2 = 7, ...</math> što znači da umesto kvadriranja možemo da radimo samo sabiranje sa sledećim neparnim brojem.
<syntaxhighlight lang="milo">
DELETE(H, key)
i = init = H(key)
step = 3
while T[i] ≠ key do
if (step ≠ 3) and (i = init) then
return
end_if
i = i + step
step = step + 2
end_while
T[i] = deleted
</syntaxhighlight>
<syntaxhighlight lang="milo">
INSERT(H, key)
i = init = H(key)
step = 3
while T[i] ≠ empty or T[i] ≠ deleted do
if (step ≠ 3) and (i = init) then
ERROR(Tabela puna)
end_if
i = i + step
step = step + 2
end_while
T[i] = key
</syntaxhighlight>

== 8. zadatak ==
=== Postavka ===
Objasniti kako se može modelirati ponašanje algoritama sortiranja poređenjem. Za dati model izvesti teorijsku granicu složenosti u najgorem slučaju.

=== Rešenje ===
Ponašanje algoritma se može modelirati stablom odlučivanja. Svako odlučivanje se modeluje unutrašnjim čvorom a svaki ishod listom, tako da složenost u najgorem slučaju dobijamo kao visinu tog stabla. Pošto je broj ishoda ovakvog stabla odlučivanja jednak <math>n!</math>, a najveći broj listova u stablu visine <math>h</math> jednak <math>2^h</math>, možemo da izjednačimo <math>n! = 2^h</math>. Kad logaritmujemo obe strane jednačine i primenimo Stirlingovu aproksimaciju (<math>n! > \left(\frac{n}{e}\right)^n</math>) dobijamo <math>h = \log(n!) > n \log\left(\frac{n}{e}\right) > n \log n - n \log e = O(n \log n)</math>.

[[Категорија:АСП2]]
[[Категорија:Рокови]]

АСП2/К3 2017

2021-02-16T19:23:26Z

WikiEditor: /* mala izmena */

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S112ASP2_k3_2016.pdf Postavka zadataka sa stranice predmeta.]

== 1. zadatak ==
=== Postavka ===
Kako izgleda niz sa slike nakon prvih pet iteracija ''shakersort'' algoritma?

=== Rešenje ===
{| class="wikitable"
|+ Niz nakon pet iteracija ''shakersort'' algoritma
| 12 || 3 || 34 || 83 || 21 || 95 || 34 || 1 || 18 || 20 || 83 || 17 || 44 || 39
|-
| 3 || 12 || 34 || 21 || 83 || 34 || 1 || 18 || 20 || 83 || 17 || 44 || 39 || 95
|-
| 1 || 3 || 12 || 34 || 21 || 83 || 34 || 17 || 18 || 20 || 83 || 39 || 44 || 95
|-
| 1 || 3 || 12 || 21 || 34 || 34 || 17 || 18 || 20 || 83 || 39 || 44 || 83 || 95
|-
| 1 || 3 || 12 || 17 || 21 || 34 || 34 || 18 || 20 || 39 || 83 || 44 || 83 || 95
|-
| 1 || 3 || 12 || 17 || 21 || 34 || 18 || 20 || 34 || 39 || 44 || 83 || 83 || 95
|}

== 2. zadatak ==
=== Postavka ===
Data je heš tabela sa 10 ulaza. U tabelu se unose ključevi koje se mogu sastojati od velikih i malih slova. Primarna heš funkcija je ''H1(K) = (1 + len(K)) mod 10'', gde ''len(K)'' vraća broj slova u prosleđenom ključu ''K''. Vremenska lokalnost je veoma izražena, jer se nakon umetanja svakog ključa javlja veliki broj pretraživanja na taj ključ pre nego što se umetne sledeći. Kolizije se razrešavaju nestandardnom primenom dvostrukog heširanja kod koga je sekundarna funkcija ''H2(K) = 3 + up_case_cnt(K)'', gde ''up_case_cnt(K)'' vraća ukupan broj velikih slova u ključu ''K''.
<div class="abc-list">
# Predložiti modifikaciju načina za razrešavanje kolizije tako da se minimizuje vreme uspešnog pretraživanja u datim uslovima.
# Primenom predloženog rešenja u donju tabelu umetnuti sledeće ključeve:
#: ČoKoLaDa, PalAčINka, kafA, TORtA, RoLaT, SLadoled, koLAČ
#: Prikazati finalno stanje heš tabele i celokupan postupak primenom tehnike opisane u rešenju pod a).
</div>

=== Rešenje ===
<div class="abc-list">
# Prilikom razrešavanja kolizije, postojeće ključeve možemo pomeriti da budu niže u ispitnom nizu duplim heširanjem a novoumetnuti ključ staviti na njegov početak kako bi se sa što manjim brojem kolizija dolazilo do najskorije umetnutih ključeva.
# Umetanje u tabelu ide ovako:
## ČoKoLaDa se umeće na mesto 9
## PalAčINka se umeće na mesto 0
## kafA se umeće na mesto 5
## TORtA se umeće na mesto 6
## RoLaT se umeće na mesto 6, TORtA se pomera na mesto 3
## SLadoled se umeće na mesto 9, ČoKoLaDa se pomera na mesto 6, RoLaT se pomera na mesto 2
## koLAČ se umeće na mesto 6, ČoKoLaDa se pomera na mesto 3, TORtA se pomera na mesto 0, PalAčINka se pomera na mesto 7
</div>
{| class="wikitable"
|+ Konačni izgled heš tabele nakon umetanja
! 0
| TORtA
|-
! 1
|
|-
! 2
| RoLaT
|-
! 3
| ČoKoLaDa
|-
! 4
|
|-
! 5
| kafA
|-
! 6
| koLAČ
|-
! 7
| PalAčINka
|-
! 8
|
|-
! 9
| SLadoled
|}

== 3. zadatak ==
=== Postavka ===
Napisati iterativnu implementaciju ''quicksort'' algoritma. U telu funkcije QUICKSORT koja će predstavljati ovu implementaciju, nakon izbora pivota, pozivati funkciju PARTITION koja vraća konačnu poziciju pivota u nizu. Algoritam realizovati što efikasnije, a za pivot uzeti element niza koji je srednji po vrednosti u izboru između elemenata sa prve tri pozicije u particiji.

=== Rešenje ===
Pošto se pominje velika efikasnost, bitno je da na stek guramo veće particije a direktno obilazimo manje kako bi dubina steka bila što manja.
<syntaxhighlight lang="milo">
QUICKSORT(arr, n)
STACK_INIT(S_down)
STACK_INIT(S_up)
down = 1
up = n
from_stack = false
while (not STACK_EMPTY(S_down)) or (not from_stack) do
if from_stack then
down = POP(S_down)
up = POP(S_up)
end_if
if up - down = 1 then
if arr[up] < arr[down] then
arr[up] ↔ arr[down]
end_if
from_stack = true
continue
end_if
first = arr[up]
second = arr[up+1]
third = arr[up+2]
if (first ≤ second ≤ third) or (third ≤ second ≤ first) then
pivot = 2
else if (second ≤ first ≤ third) or (third ≤ first ≤ second) then
pivot = 1
else
pivot = 3
end_if
pivot_pos = PARTITION(arr, down, up, pivot)
lower_down = down
lower_up = pivot_pos-1
higher_down = pivot_pos+1
higher_up = up
if (lower_up - lower_down < 1) and (higher_up - higher_down < 1) then
from_stack = true
else if lower_up - lower_down < higher_up - higher_down then
up = lower_up
down = lower_down
from_stack = false
PUSH(S_down, higher_down)
PUSH(S_up, higher_up)
else
up = higher_up
down = higher_down
from_stack = false
PUSH(S_down, lower_down)
PUSH(S_up, lower_up)
end_if
end_while
</syntaxhighlight>
Pošto je rečeno da se izbor pivota radi u QUICKSORT, pretpostavićemo da se taj pivot zatim prosleđuje PARTITION kao parametar.
<syntaxhighlight lang="milo">
PARTITION(arr, down, up, pivot_pos)
i = down
j = up
pivot = arr[pivot_pos]
while i < j do
while (arr[i] ≤ pivot) and (i < j) do
i = i + 1
end_while
while arr[j] > pivot do
j = j - 1
end_while
if i < j then
arr[i] ↔ arr[j]
end_while
end_while
arr[pivot_pos] ↔ arr[j]
return j
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
Napisati u pseudokodu funkciju za dekrementiranje ključa koji se nalazi u binarnom nerastućem (max) hipu. Smatrati da je hip smešten u nizu čiji indeksi počinju od 0. Funkcija kao svoj parametar dobija indeks ključa u nizu koga treba dekrementirati.

=== Rešenje ===
<syntaxhighlight lang="milo">
HEAP KEY DEC(i)
arr[i] = arr[i]-1
left = 2 * i + 1
right = 2 * i + 2
while ((left ≤ n) and (arr[left] > arr[i])) or ((right ≤ n) and (arr[right] > arr[i])) do
if right ≤ n then
if arr[right] > arr[left] then
high = right
else
high = left
end_if
else
high = left
end_if
arr[i] ↔ arr[high]
i = high
left = 2 * i + 1
right = 2 * i + 2
end_while
</syntaxhighlight>

== 5. zadatak ==
=== Postavka ===
Podaci se smeštaju u heš tabelu sa 7 ulaza primenom heš funkcije hp(K) = K mod 7. Za razrešavanje kolizija se koristi metoda dvostrukog heširanja sa sekundarnom heš funkcijom hs(K) = 4 + K mod 2. Obrazložiti na koji način u ovom slučaju može doći do sekundarnog grupisanja i navesti sekvencu od tri ključa koja proizvodi ovaj efekat u konkretnom slučaju. Navedene ključeve uneti u tabelu.

=== Rešenje ===
U ovom slučaju može doći do sekundarnog grupisanja kada uneti ključevi daju isti ostatak pri deljenju sa 7 i pri deljenju sa 2. Takvi su recimo ključevi 0, 14 i 28.
{| class="wikitable"
|+ Tabela sa unetim ključevima
! 0
| 0
|-
! 1
|
|-
! 2
|
|-
! 3
|
|-
! 4
| 14
|-
! 5
|
|-
! 6
|
|-
! 7
|
|-
! 8
| 28
|}

== 6. zadatak ==
=== Postavka ===
Fibonačijev hip
<div class="abc-list">
# Koja je razlika između dodavanja u binomni hip i Fibonačijev hip? Objasniti kratko i precizno, u jednoj do dve rečenice.
# U prazan Fibonačijev hip dodaju se elementi 10, 5, 17, 3, 12, 11, 1, potom se briše element sa vrednošću 1, nakon čega se dodaju elementi 7 i 2. Nacrtati izgled hipa nakon prvih sedam umetanja i nakon svake naredne izmene hipa.
</div>

=== Rešenje ===
<div class="abc-list">
# Pri dodavanju u Fibonačijev hip uneti čvor se samo ulančava, a grupisanje slično binomnom hipu se dešava tek kod izbacivanja najmanjeg elementa.
# Ispod su dati izgledi hipa nakon date četiri operacije.
</div>
<gallery>
ASP2 K3 2017 zadatak 6 hip umetanje 1.png | Izgled hipa nakon umetanja 10, 5, 17, 3, 12, 11, 1.
ASP2 K3 2017 zadatak 6 hip brisanje.png | Izgled hipa nakon brisanja 1.
ASP2 K3 2017 zadatak 6 hip umetanje 2.png | Izgled hipa nakon umetanja 7.
ASP2 K3 2017 zadatak 6 hip umetanje 3.png | Izgled hipa nakon umetanja 2.
</gallery>

== 7. zadatak ==
=== Postavka ===
Podaci se smeštaju u heš tabelu sa ''n'' ulaza primenom heš funkcije h(K) = K mod n. Za razrešavanje kolizija se koristi metoda kvadratnog pretraživanja, ali nije dozvoljeno koristiti operaciju množenja (kvadriranja). Predložiti metod brisanja i napisati pseudokodove operacija brisanja i umetanja.

=== Rešenje ===
Možemo primetiti da <math>2^2 - 1^2 = 3, 3^2 - 2^2 = 5, 4^2 - 3^2 = 7, ...</math> što znači da umesto kvadriranja možemo da radimo samo sabiranje sa sledećim neparnim brojem.
<syntaxhighlight lang="milo">
DELETE(H, key)
i = init = H(key)
step = 3
while T[i] ≠ key do
if (step ≠ 3) and (i = init) then
return
end_if
i = i + step
step = step + 2
end_while
T[i] = empty
</syntaxhighlight>
<syntaxhighlight lang="milo">
INSERT(H, key)
i = init = H(key)
step = 3
while T[i] ≠ empty do
if (step ≠ 3) and (i = init) then
ERROR(Tabela puna)
end_if
i = i + step
step = step + 2
end_while
T[i] = key
</syntaxhighlight>

== 8. zadatak ==
=== Postavka ===
Objasniti kako se može modelirati ponašanje algoritama sortiranja poređenjem. Za dati model izvesti teorijsku granicu složenosti u najgorem slučaju.

=== Rešenje ===
Ponašanje algoritma se može modelirati stablom odlučivanja. Svako odlučivanje se modeluje unutrašnjim čvorom a svaki ishod listom, tako da složenost u najgorem slučaju dobijamo kao visinu tog stabla. Pošto je broj ishoda ovakvog stabla odlučivanja jednak <math>n!</math>, a najveći broj listova u stablu visine <math>h</math> jednak <math>2^h</math>, možemo da izjednačimo <math>n! = 2^h</math>. Kad logaritmujemo obe strane jednačine i primenimo Stirlingovu aproksimaciju (<math>n! > \left(\frac{n}{e}\right)^n</math>) dobijamo <math>h = \log(n!) > n \log\left(\frac{n}{e}\right) > n \log n - n \log e = O(n \log n)</math>.

[[Категорија:АСП2]]
[[Категорија:Рокови]]

Базе података 1

2021-02-09T20:39:44Z

WikiEditor:

{{tocright}}
'''Базе података 1''' је обавезан предмет у трећем семестру.

== Странице ==
* [https://rti.etf.bg.ac.rs/rti/bp1/ Страница предмета]

== Корисне везе ==
{{Материјали
| vuk = 1haJaA9fzRFoEn2cmcUc-l-NKenLG_8n5
| beastweb = baze-podataka-1 Старије
}}

== Лаб вежбе ==
Током семестра организују се две лабораторијске вежбе. На првој лабораторијској вежби се ради повезивање на SQLite базу кроз програмски језик C++ и извршавање једноставних упита над њом, док се на другој лабораторијској вежби раде напреднији упити у [[#Cactus|''Cactus''-u]].
{{#dpl:
| titleregexp = Базе_података_1/Лаб
| format = ,\n* [[%PAGE%|²{#invoke:String¦sub¦%PAGE%¦17¦-1}²]],,
| noresultsheader = Тренутно нема лабораториских вежби.
}}

== Испитни рокови ==
Претходни испитни рокови се могу наћи на страници предмета. Нажалост, нису нарочито погодни за вежбу јер сви имају решења већ означена. Испод можете наћи испитне рокове са странице предмета без означених решења:
{{#dpl:
| namespace = File
| titleregexp = ^BP1 .*\.pdf$
| noresultsheader = Тренутно нема нерешених рокова.
| format = ,\n* [[Медиј:%TITLE%|²{#invoke:String¦sub¦%TITLE%¦4¦-5}²]],,
}}

== Cactus ==
''Cactus'' је софтвер који се на лабораторијској вежби и испиту користи као алат за проверавање тачности упита. У тим приликама студентима биће дат cSQL фајл који у себи садржи тест примере који студенту помажу да провери да ли откуцани упит ради оно што се од њега очекује. Пролазак јавног тест примера, додуше, не значи да је цео упит тачан, јер се тестира и на тајним тест примерима.

''Cactus'' је писан користећи Java 10, и генерално не ради са осталим Java верзијама. Готове архиве са спакованим ''Cactus''-ом заједно са Java 10 су доступне за [https://studentetfbgacrs-my.sharepoint.com/:u:/g/personal/sa190595d_student_etf_bg_ac_rs/EYS6i0XcbWZAv_7fhlqIQA0BCqTM1m_Il409uFGTv1Zi4g Windows] и за [https://studentetfbgacrs-my.sharepoint.com/:u:/g/personal/sa190595d_student_etf_bg_ac_rs/EdzDtvWgB2xEn11Ydap3KWwBTk31IBX_MqFHCIT5QCOxmQ Linux,] (након преузимања отпакујте архиву и покрените <code>pokreni.bat</code> или <code>pokreni.sh</code>) али можете и такође само [https://www.oracle.com/java/technologies/java-archive-javase10-downloads.html преузети JRE 10] (одељак "Java SE Runtime Environment 10.0.2") за ваш оперативни систем и преко њега покренути ''Cactus'' са [https://rti.etf.bg.ac.rs/rti/bp1/materijali/Cactus.jar странице предмета.]

== Начин оцењивања ==
* '''K1''', '''K2''' — Бодови са првог и другог колоквијума максимално 20 за први колоквијум и максимално 10 за други. Могу се поправити у следећем колоквијумском или испитном року.
* '''I''' — Бодови са испита, максимално 50.
* '''L1''', '''L2''' — Бодови са лабораторијских вежби, прва носи 5 а друга 15 бодова.
* '''P''' — Коначан број бодова: <math>P = K_1 + K_2 + I + L_1 + L_2</math>.
* '''Услов за полагање:''' <math>I \geq 25</math>.
{| class="wikitable"
! Бодови
| <math>P \leq 50</math> || <math>50 || <math>60 || <math>70 || <math>80 || <math>90 < P</math>
|-
! Оцена
| 5 || 6 || 7 || 8 || 9 || 10
|}

[[Категорија:Трећи семестар]]
[[Категорија:Обавезни предмети]]
[[Категорија:Базе података 1]]

ОО1/К1 2020

2020-11-17T16:45:43Z

WikiEditor: /* Dodaci za G1 */

{{tocright}}
* Za pitanja sa više odgovora, tačni odgovori su podebljani i uokvireni.
* Za pitanja za koje se odgovori unose, tačni odgovori su podvučeni i sakriveni: ovako.
* Pritisnite na sledeće dugme kako biste ih sakrili ili otkrili: 

== G1 ==
=== 1. zadatak ===
Koji je tip promenljive <code>p</code> u sledećem programu:
<syntaxhighlight lang="cpp">
int main(void) {
int i = 1;
const int k = i;
auto p = new int + k;
return 0;
}
</syntaxhighlight>
# <code>int</code>
# <code>const int</code>
# <code>int*</code>
# <code>const int*</code>
# Program se ne prevodi.

=== 2. zadatak ===
Šta ispisuje sledeći program na jeziku C++?
<syntaxhighlight lang="cpp">
#include <iostream>

int &f(int &x){
return ++x;
}

int main(void) {
std::cout << f(2);
}
</syntaxhighlight>
<div class="abc-list">
# 6
# 0
# Program se ne prevodi.
# 5
</div>

=== 3. zadatak ===
Ime simbol predstavlja niz referenci na nepromenljiv pokazivač na int. Kako se deklariše u kodu?
<div class="abc-list">
# ...
# ...
# <code>int * const &simbol[]</code>
# Deklaracija za simbol se ne prevodi.
</div>

=== ?. zadatak ===
Zaokružiti tačna tvrđenja u vezi sa preklapanjem imena funkcija na jeziku C++:
<div class="abc-list">
# Kada dve funkcije imaju isti naziv, statički tokom prevođenja programa se određuje koja funkcija će biti pozvana.
# Kada dve funkcije imaju isti naziv, dinamički tokom izvršenja programa se određuje koja funkcija će biti pozvana.
# Kada dve funkcije imaju isti naziv, statički tokom izvršenja programa se određuje koja funkcija će biti pozvana.
# Kada dve funkcije imaju isti naziv, dinamički tokom prevođenja programa se određuje koja funkcija će biti pozvana.
</div>

=== ?. zadatak ===
Koje od navedenih parova potpisa funkcija mogu postojati u istom programu, a da prevodilac ne prijavljuje grešku?
<div class="abc-list">
# <code> int & f(int i, int j);</code> i <code> int && f(int i, int j); </code>
# <code> int const f(int i, int j);</code> i <code> int f(int i, int j); </code>
# <code> float volatile f(int i, int j);</code> i <code> int volatile f(int i, int j); </code>
</div>

=== 7. zadatak ===
Šta ispisuje sledeći program na programskom jeziku C++:
<syntaxhighlight lang="cpp">
#include <iostream>
using namespace std;

class K {
static int staticId;
int id = staticId++;
public:
K() = default;
K(const K&) {}
int m(K arg) {
return arg.id;
}
};

int K::staticId = 1;
int main()
{
K a;
K b;
K c(a);
cout << a.m(c);
}
</syntaxhighlight>
<div class="abc-list">
# 1
# 2
# 5
# 3
# 4
# Više od 5.
</div>

== G2 ==
=== 1. zadatak ===
Zaokružiti tačne tvrdnje u vezi sa referencama na jeziku C++:
<div class="abc-list">
# Moguće je definisati referencu na pokazivač.
# Moguće je definisati niz referenci.
# Moguće je definisati referencu na referencu.
# Moguće je definisati pokazivač na referencu.
</div>

=== 2. zadatak ===
Šta ispisuje sledeći program na jeziku C++?
<syntaxhighlight lang="cpp">
#include <iostream>

int &f(int &x){
return x++;
}

int main(void) {
int x = 5;
std::cout << f(x);
}
</syntaxhighlight>
<div class="abc-list">
# 6
# 0
# Program se ne prevodi.
# 5
</div>

=== 4. zadatak ===
Povezati tvrdnje u vezi sa modifikatorima metoda:
{| class="wikitable"
|+ Modifikatori
|-
| <code>volatile </code> b.

<code>const </code> e.

<code>& </code> g.

<code> && </code> f.
|| <div class="abc-list">
# Metoda se može zvati samo ako je tekući objekat pokazivač.
# Oznaka kompajleru da ne vrši optimizacije.
# Oznaka kompajleru da vrši optimizacije.
# Metoda je mutator.
# Metoda je inspektor.
# Metoda se može zvati samo ako je tekući objekat dvrednost.
# Metoda se može zvati samo ako je tekući objekat lvrednost.
# Metoda se može zvati samo ako je tekući objekat konstantan.
</div>
|}

=== 5. zadatak ===
Zaokružiti tačne tvrdnje u vezi sa pomerajućim konstruktorom na jeziku C++:
<div class="abc-list">
# Definisanjem podrazumevanog konstruktora briše se ugrađeni premeštajući konstruktor.
# Definisanjem kopirajućeg konstruktora briše se ugrađeni premeštajući konstruktor.
# Pomerajući konstruktor mora da ima samo jedan parametar.
</div>

=== 6. zadatak ===
Zaokružiti tačne tvrdnje u vezi sa funkcijama na jeziku C++:
<div class="abc-list">
# Mogu se definisati više funkcija istog imena ako imaju različiti broj parametara bez podrazumevanih vrednosti. 
# Mogu se definisati više funkcija istog imena ako su im različite povratne vrednosti.
# Ne mogu se definisati više funkcija istog imena, jer kompajler ne bi mogao da ih raspozna.
# Mogu se definisati više funkcija istog imena ako imaju različite tipove parametara. 
</div>

=== 7. zadatak ===
Šta ispisuje sledeći program na programskom jeziku C++:
<syntaxhighlight lang="cpp">
#include <iostream>
using namespace std;

class L {
L(const &L l) = delete;
};

class K {
static int staticId;
int id = staticId++;
L l;
public:
K() = default;
K(const K&) {}
int m(K arg) {
return arg.id;
}
};

int K::staticId = 1;
int main()
{
K a;
K b;
K c(a);
cout << a.m(c);
}
</syntaxhighlight>
<div class="abc-list">
# 1
# 2
# Program se ne prevodi
# 3
# 4
</div>

=== 8. zadatak ===
Šta ispisuje sledeći program na programskom jeziku C++?
<syntaxhighlight lang="cpp">
#include <iostream>
using namespace std;

class Klasa {
static Klasa *napravi()
{
cout << 1;
return new Klasa{0};
}
Klasa *clan = napravi();
public:
Klasa() { cout << 2; }
Klasa(int a) : clan(nullptr) { cout << 3; }
};

int main() {
Klasa k;
}
</syntaxhighlight>
Odgovor: 132

=== 9. zadatak ===
Dopuniti XXX sa linijom tako da je program ispravan:
<syntaxhighlight lang="cpp">
#include <iostream>

class A {
A(const A& a) = delete;
public:
int n = 1;
A() = default;
A(A&& a) { };
};

void f(A a) {
std::cout << a.n;
}

int main(void)
{
XXX
return 0;
}
</syntaxhighlight>
<div class="abc-list">
# <code> f(); </code>
# <code> A a; f(a); </code>
# <code>f(A()); </code> 
# <code>f(A); </code>
</div>

=== 10. zadatak ===
Zaokružiti tačne tvrdnje u vezi sa statičkim poljima u klasama na jeziku C++:
<div class="abc-list">
# U definiciji klase se mogu definisati promenljiva statička polja.
# Doseg imena statičkog polja je klasa.
# Statičkom polju s iz klase K se pristupa koristeći izraz K.s.
</div>

[[Категорија:Рокови]]
[[Категорија:ОО1]]

НАД

2020-11-15T15:15:19Z

WikiEditor:

{{tocright}}
'''Нумеричка анализа и дискретна математика''' је изборни предмет у трећем семестру.

== Странице ==
* [http://numdis.etf.rs/nadSI.html Страница предмета за нумеричку анализу]
* [http://discretmat.etf.bg.ac.rs Страница предмета за дискретну математику]

== Корисне везе ==
{{Материјали
| vuk = 1-sLpI_AC78xSPWCEG8bYRpnDTkhi5uF8
| box = 8374949993
| scientificmind = IR2NUMDIS
| beastweb = numericka-analiza-i-diskretna-matematika
}}


== Испитни рокови ==
=== Колоквијум 1 ===
{{#dpl:
| titleregexp = НАД/К1
| noresultsheader = Тренутно нема решених рокова.
| format = ,* [[%PAGE%|²{#invoke:String¦sub¦%PAGE%¦5¦-1}²]]\n,,
}}
=== Колоквијум 2 ===
{{#dpl:
| titleregexp = НАД/К2
| noresultsheader = Тренутно нема решених рокова.
| format = ,* [[%PAGE%|²{#invoke:String¦sub¦%PAGE%¦5¦-1}²]]\n,,
}}
=== Колоквијум 3 ===
{{#dpl:
| titleregexp = НАД/К3
| noresultsheader = Тренутно нема решених рокова.
| format = ,* [[%PAGE%|²{#invoke:String¦sub¦%PAGE%¦5¦-1}²]]\n,,
}}
=== Интегрални испит ===
{{#dpl:
| titleregexp = НАД/Испит
| noresultsheader = Тренутно нема решених рокова.
| format = ,* [[%PAGE%|²{#invoke:String¦sub¦%PAGE%¦5¦-1}²]]\n,,
}}

== Начин оцењивања ==

*[http://numdis.etf.rs/PDF/13S082NAD_2020-2021-2.pdf Начин полагања испита у 2020/2021. години]
[[Категорија:Трећи семестар]]
[[Категорија:Изборни предмети]]
[[Категорија:НАД]]