[CS@TUK] Questions and Answers - Recent questions and answers in # Mandatory Modules Bachelor

Answered: Guten Abend Unklarheit beim ausfüllung von gelbe markierte Werte

Tue, 09 Jul 2024 13:35:49 +0000

Die Sequenz von Lade-/Speicherbefehlen arbeitet also mit den folgenden Blöcken:

Mem.Adr.	BlockAdr.	Tag/CacheAdr
L(0)	L(0)	0*4+0
L(15)	L(7)	1*4+3
S(16)	S(8)	2*4+0
L(1)	L(0)	0*4+0
L(14)	L(7)	1*4+3
S(17)	S(8)	2*4+0
L(2)	L(1)	0*4+1
L(13)	L(6)	1*4+2
S(18)	S(9)	2*4+1
L(3)	L(1)	0*4+1
L(12)	L(6)	1*4+2
S(19)	S(9)	2*4+1
L(4)	L(2)	0*4+2
L(11)	L(5)	1*4+1
S(20)	S(10)	2*4+2

Damit wissen wir, welcher Block mit welchen beiden Wortadressen in den Cache geladen werden soll und wir wissen, in welcher Cache-Adresse dieser Block gefunden werden kann oder geladen werden muss. Dazu schauen wir an der Cache-Adresse nach, ob sich dort ein Block mit dem erwünschten Tag befindet. Wenn ja, haben wir den Block im Cache gefunden und haben einen Cache-Treffen. Wenn nein, dann muss der Block in den Cache geladen werden. Dazu muss evtl. erst ein vorhandener Block in den Speicher zurückgeschrieben werden. Um dies zu entscheiden, müssen wir uns merken, welche Blöcke verändert worden sind.

Answered: Guten morgen , im Bezug auf die Berechnung der Speedup

Sat, 23 Mar 2024 09:45:36 +0000

Eigentlich gibt es für den SpeedUp nur eine Formel, nämlich den Quotienten von alter Laufzeit durch neue Laufzeit, der angibt, um welchen Faktor die Programmausführung schneller geworden ist.

Vermutlich meinen Sie aber die Formeln für den SpeedUp von Pipelines, die Schritt für Schritt unterschiedliche Aspekte berücksichtigt haben. Da reicht aber die letzte der Formeln, da die anderen Spezialfälle sind, bei denen manche Parameter 0 sind. Aber selbst diese Formel lohnt sich selten und man schaut besser die aktuelle Situation der Aufgabenstellung an.

Answered: Nops after Jump Instruction

Sat, 23 Mar 2024 09:40:58 +0000

Well, it depends. If you look at the pipeline implementation, jump instructions are certainly fetched, and decoded as all other instructions. What needs to be done for a jump instruction is to add the direct operand that comes with the jump instruction to the program counter. So, all that we need is an adder.

Now, you can implement the jump instruction in such a way that the required addition is done in the execution stage, and that the assignment to the program counter is done in the write back stage. If it would be done like this, we need nops after jump instructions in the same way as for branch instructions. The implementation of Abacus on slide 53 does this.

If we use forwarding, we want to use values as soon as they are available. For jump instruction, we still would have to wait for the addition in the execution phase. However, adders are not expensive, and therefore most processors spend another adder in the ID stage to perform the addition required for jump instructions. Slide 85 shows that implementation of the jump instructions which then requires no stalling anymore (provided register bypassing is used as well).

TLTR: It depends on the pipeline implementation, and with forwarding you may assume no further Nops, without you better ask how the jump instructions are implemented.

Answered: Warum wird die sync Anweisung bei der Ausführungszeit eines Programms nicht beachtet ?

Thu, 21 Mar 2024 16:59:41 +0000

Die Anweisung "sync" sorgt dafür, dass alle Cache-Inhalte in den Hauptspeicher zurückgeschrieben werden und dass (falls vorhanden) Store-Buffer von Multicore-Versionen geleert werden. Damit kann man sicher sein, dass danach die Inhalte der lokalen Speicher (Caches und Store-Buffer) für andere Cores sichtbar sind und damit eine Prozesssynchronization stattfinden kann. Man kann dann auch sicher Inhalte vom Hauptspeicher auf die Festplatte übertragen und berücksichtigt dabei auch die Cache-Inhalte.

Das sind aber alles Probleme, die uns in RoSy eher nicht beschäftigen. Die Anweisung "sync" wird hier meist am Ende der Programme angefügt, um (1) quasi "aufzuräumen" und (2) ein Sprungziel für Sprünge zum Programmende zu haben.

Der zweite Fall ist in RoSy der entscheidende und dafür könnte man ebenso gut "nop" nehmen. Daher spielt "sync" keine große Rolle und kann in RoSy quasi auch als "nop" gelesen werden. Für die Lösung solcher Aufgaben würde die Behandlung von "sync" großzügig ausgelegt werden.

Answered: Compiler Frontend

Wed, 20 Mar 2024 19:55:48 +0000

Your grammar describes the language waba + wabab where w is any word consisting of letters a and b. So, the occurrence of aba is not at an arbitrary place within the word.

Why not the following?

S -> aS | bS | A
A -> abaB
B -> aB | bB |

Answered: wie kommen wir zu einer lösung dieser aufgabe

Tue, 12 Mar 2024 14:52:51 +0000

Es gibt sicherlich sehr viele Programme, die man hier verwenden kann. Im Prinzip kann man hier jeden Sortieralgorithmus verwenden und selbst diese kann man unterschiedlich in Assembler programmieren. Es gibt also keine eindeutige Lösung. Sie können auch ein Sortierverfahren in MiniC programmieren und kompilieren, wenn Sie sich damit schwer tun.

Answered: Guten Abend bitte ich habe eine Frage über unsere übungsblatt 1 aufgabe 3 beim Rosy .

Mon, 11 Mar 2024 17:55:09 +0000

Welche Frage haben Sie denn? Sie haben nur die Aufgabe aus dem Übungsblatt kopiert?

Answered: morgen Bitte noch eine frage uber shannon oder haufmann

Sun, 18 Feb 2024 10:05:10 +0000

Die Musterlösungen, die bisher in der Klausuren angegeben waren, haben diese Regel leider nicht immer befolgt. Ich habe dies für die Klausuren ab 2020 angepasst, so dass es nun stimmen sollte.

Die Regel, dass die Gruppe von Zeichen mit der höheren Wahrscheinlichkeit die 0 zugewiesen werden sollte, sollte grundsätzlich befolgt werden, um Mehrdeutigkeit zu vermeiden. Wenn Sie das nicht machen, bekommen Sie einen genauso guten Code, und für die Codierung auch ihre Punkte. Allerdings können Sie dann bei der Dekodierung eines Wortes auf Probleme stoßen, da dort diese Regel vorausgesetzt wird.

Eine kleine weitere Schwierigkeit ergibt sich, wenn sich eine Gruppe von Zeichen in zwei Teilmengen mit derselben Wahrscheinlichkeit aufspaltet.

Answered: Guten Abend meine frage richtet sich an einer möglicherfehler bei Sequenzielle schaltung

Sat, 17 Feb 2024 18:07:30 +0000

Vielen Dank für den Hinweis, das war tatsächlich ein Fehler. Wahrscheinlich wurde dort zuerst ein D-FlipFlop oder etwas anderes ausprobiert. Der Fehler ist nun korrigiert.

Hinweis: Es handelt sich um die DiRa Klausur vom 28. August 2023.

Answered: guten morgen ich habe eine frage uber die addition von floatingpoint

Sun, 04 Feb 2024 15:33:38 +0000

Wie lautet denn die Frage?

Answered: sind diese beiden Shannon-Normalformen identisch?

Fri, 12 Jan 2024 17:20:07 +0000

Die SNF der Formel a&c&!b&!d|b&c&!d|b&!c&!d|d|!a&!b&!c&!d mit der angegebenen Variablenordnung ist

    (d?true:(c?(b?true:(a?true:false)):(b?true:(a?false:true))))

Das ist exakt die erste der beiden Formeln, die zweite hat einige Syntaxfehler und macht so wie sie dasteht keinen Sinn. Ich habe versucht, die Klammern richtig zu setzen, aber die Zahl der Teilterme erlaubt dies nicht.

Die Formel ist nicht zur obigen Formel äquivalent, da SNFs kanonische Normalformen sind und die beiden Formeln syntaktisch nicht identisch sind.

Answered: Logik DiRa SS23

Thu, 11 Jan 2024 14:19:10 +0000

Um die Landkarte mit drei Farben R,G,B einzufärben, verwenden wir Variablen R_i,G_i und B_i für i=0,1,2,3. Aufgrund der Nachbarschaften der Länder muss dabei Folgendes gelten, damit benachbarte Länder unterschiedliche Farben erhalten:

    (R0->!R1) & (G0->!G1) & (B0->!B1) &
    (R0->!R2) & (G0->!G2) & (B0->!B2) &
    (R1->!R2) & (G1->!G2) & (B1->!B2) &
    (R1->!R3) & (G1->!G3) & (B1->!B3) &
    (R2->!R3) & (G2->!G3) & (B2->!B3)

Ferner muss jedes Land eine Farbe bekommen:

    (R0 | G0 | B0) 
    (R1 | G1 | B1) &
    (R2 | G2 | B2) &
    (R3 | G3 | B3)

und jedes Land soll nicht mehr als eine Farbe bekommen:

    (R0 -> !G0 & !B0) & (G0 -> !R0 & !B0) & (B0 -> !R0 & !G0) &
    (R1 -> !G1 & !B1) & (G1 -> !R1 & !B1) & (B1 -> !R1 & !G1) &
    (R2 -> !G2 & !B2) & (G2 -> !R2 & !B2) & (B2 -> !R2 & !G2) &
    (R3 -> !G3 & !B3) & (G3 -> !R3 & !B3) & (B3 -> !R3 & !G3)

Wenn man alle diese Formeln zu einer Konjunktion zusammenfasst, dann entsprechen alle erfüllenden Belegungen den Färbungen der Landkarte. Zum Beispiel kann man einen BDD für diese Formeln bestimmen und daraus alle Färbungen ablesen. Man kann dafür auch andere Formulierungen finden, die zu den obigen Formeln äquivalent sind.

Da die obigen Formeln viele Wiederholungen für alle Länder enthalten, wurde in der Aufgabe nur nach den Einschränkungen für ein Land gefragt, um die Schreibarbeit für alle Länder zu sparen.

Answered: creation of the Shannon-Fano coding in the old exam 2020

Tue, 09 Jan 2024 09:26:23 +0000

Yes, that is true. The solution had been generated with the former version of the teaching tool which did not follow the remark given in the problem description. Since the remark in the problem description makes sense to define a canonical solution, I have updated the teaching tool accordingly and have also fixed the solution in the exam paper.

Thanks for pointing this out!

Answered: Convert to CNF

Wed, 08 Jun 2022 07:51:41 +0000

First of all, <-> is associative, so that it does not matter for its semantics how we parse a sequence of this operator. According to the lecture, we defined this operator however as being left associative, so that we get the following expression with full use of brackets:

((((a&d)<->b)<->c)|((a<->a)&!b))<->!(c<->(a->a))

A CNF obtained by the BDD of this formula is for instance the following one:

(!a|!b|!d) & (b|!c)

Before starting any computation, we first simplify the formula by replacing a<->a with true and propagating the boolean constants so that we get

((((a&d)<->b)<->c)|!b)<->!c

Next, we make a Shannon decomposition: Starting with variable b (it has two occurrences and thus more than variable a), we get the following cofactors:

b=0: !c
b=1: (a&d<->c)<->!c

Thus, our formula is equivalent to (b -> (a&d<->c)<->!c) & (!b -> !c) which yields

(!b | ((a&d<->c)<->!c)) & (b|!c)

It remains to convert (a&d<->c)<->!c) to a CNF, so we make a Shannon decomposition with c:

c=0: !(a&d)
c=1: !(a&d)

That makes it simple, since the formula (a&d<->c)<->!c) is equivalent to !(a&d). Hence, we get the following formula:

(!b | !(a&d)) & (b|!c)

which has the following CNF:

(!b|!a|!d) & (b|!c)

Answered: 2018 exam, 2 c)

Sun, 28 Mar 2021 17:01:36 +0000

For the 256 bytes, we need 8-bit addresses. The caches have 32 bytes and a block has 2 bytes, so that each cache has 16 blocks.

The direct mapped cache therefore needs 4 bits for set addresses so that a memory address a[7..0] is split into the tag a[7..5], the set address a[4..1] and the block offset a[0]. The set address a[4..1] is therefore computed as setAdr(adr) := (adr % 32) div 2. We therefore have

setAdr(30) = 15
setAdr(31) = 15
setAdr(32) = 0
setAdr(33) = 0

Hence, the set address is 0 and not 16 as you assumed.

For the 4-way set associative cache, we have 4 blocks in a set and therefore each set has 8 bytes, so that the cache has only 4 sets. To that end, we need 2 bits as set addresses, so that a memory address a[7..0] is split into the tag a[7..3], the set address a[2..1] and the block offset a[0]. The set address a[2..1] is therefore computed as setAdr(adr) := (adr % 8) div 2.

Answered: Abacus Cache Organisation: Word or Byte adressable?

Sat, 27 Mar 2021 17:20:23 +0000

Abacus is using 16-bit data words, and is addressing a memory with such words also. Hence, each load/store refers to 2 bytes. Don't have doubts on this, unless it is stated otherwise in an exam problem. Some years ago, the version of Abacus of that time was byte-addressed like MIPS and that leads now to some confusions when looking at older exercises.

To avoid this, I have reworked that exam problem completely so that the same computations that were necessary are now to be done for the current version of Abacus. The program used now in the exam also runs in the simulator so that you can verify the given solution.

I hope this helps!

Answered: 17 WS Aufgabe 4 e

Sat, 27 Mar 2021 08:52:39 +0000

This is one of the strengths of deterministic parsing. There is unique parse tree that is generated by the parse table for a LL or LR grammar regardless whether that word is accepted or not. The exam problem you are considering is asking for that derivation/parse tree, and the final result whether it was accepting or not.

Answered: TAC read and write with arrays

Fri, 26 Mar 2021 17:40:09 +0000

Yes, that was a kind of a discussion for a while. On the one hand, you can argue that arrays are constants since a statement y[x1] = x2 is mapped to a store instruction sti x2,x1,y where y is a constant and thus only x1 and x2 are read and no variable is written.

On the other hand, from the viewpoint of program analysis, you may argue that y[x1] = x2 is updating the array y if you consider y not just as a base address (as done in the C programming language) and instead consider the value of variable y as being the entire array (as done in the F# programming language for instance).

So, dealing with the array is somehow a matter of taste. It does also not matter since we use that information for the dataflow analysis and that in turn is used for register allocation, and we never assign an array variable to a register (since we map array accesses to load/store instructions with the base address of y as a constant).

Answered: rosy Sheet 4 ex. 2

Tue, 23 Mar 2021 19:28:04 +0000

Well, you need to understand what the program does and in case of the program you mention, there is no other way that checking step by step what the content of the memory, the cache, and the registers is. Without the simulator that is quite some work, of course.

We have first executed some code such that reg[i]=i holds. Then, we execute the following:

    sti $1,$0,0     // mem[0] := 1
    sti $2,$0,1     // mem[1] := 2
    ldi $2,$0,1     // reg[2] := mem[1] = 2
    sti $3,$0,2     // mem[2] := 3
    sti $4,$0,3     // mem[3] := 4
    ldi $2,$0,1     // reg[2] := mem[1] = 2
    sti $5,$0,7     // mem[7] := 5
    sti $6,$0,8     // mem[8] := 6
    sti $7,$0,9     // mem[9] := 7
    ldi $2,$0,1     // reg[2] := mem[1] = 2

We have a cache with 8 bytes, 2 bytes, i.e., one memory word, in a block and we use direct mapping. Hence, a memory address m is split into its cache address adr(m) = m mod 4 and its tag tag(m) = m div 4. This gives the following execution with memory transactions:

    sti $1,$0,0     // mem[0] := 1              cache[0] := mem[0]
    sti $2,$0,1     // mem[1] := 2              cache[1] := mem[1]
    ldi $2,$0,1     // reg[2] := mem[1] = 2     
    sti $3,$0,2     // mem[2] := 3              cache[2] := mem[2]
    sti $4,$0,3     // mem[3] := 4              cache[3] := mem[3]
    ldi $2,$0,1     // reg[2] := mem[1] = 2
    sti $5,$0,7     // mem[7] := 5              cache[3] := mem[7]; mem[3] := cache[3]
    sti $6,$0,8     // mem[8] := 6              cache[0] := mem[8]; mem[0] := cache[0]
    sti $7,$0,9     // mem[9] := 7              cache[1] := mem[9]; mem[1] := cache[1]
    ldi $2,$0,1     // reg[2] := mem[1] = 2     cache[1] := mem[1]; mem[9] := cache[1]

Note that the following memory addresses refer to the same cache address:

0,4,8,12
1,5,9,13
2,6,10,14
3,7,11,15

After each step, you need to remember the content of the cache, i.e., which memory block is currently at which address in the cache to find out whether there is a hit or a miss and which memory transaction is required. In particular, the last instruction is a miss since at that point of time, there is mem[9] at cache address 1 and we want to load address 1 which is also mapped to the same cache address. Hence, we first have to write back cache address 1 before loading mem[1] into cache[1].

Answered: generator matrix

Sun, 23 Aug 2020 18:15:03 +0000

So far we never had exam problem about linear codes, but that does not mean that it is unimportant. I would say that a generator matrix should be given, and you should be able to encode and decode words with it. You may even assume a linear code that is separated so that the construction of the control matrix would be simple. it is then not much more than matrix multiplication, right?

Answered: SR flipflop logic minimization

Sun, 23 Aug 2020 18:10:42 +0000

To keep it short: That will be no problem.

Side story: There are many rumors about SR-Flipflops which are not true. Consider a typical implementation by two NOR gates:

        next(p) = !(s | q)
        next(q) = !(r | p)

This leads to the following cases for the four possible inputs if these are kept stable:

s=0 & r=0 : (next(p) = !q) & (next(q) = !p)
s=0 & r=1 : (next(p) = !q) & (next(q) = 0) and thus (p =1) & (q = 0) after two steps
s=1 & r=0 : (next(p) = 0) & (next(q) = !p) and thus (p =0) & (q = 1) after two steps
s=1 & r=1 : (next(p) = 0) & (next(q) = 0)

Hence, you can see that s=1&r=1 do not lead to unstable outputs as often stated, but they violate the invariant that we want that q=!p. That is established by one of the inputs s=0&r=1 or s=1&r=0 and kept invariant by s=0&r=0. However, if we would have once the input s=1&r=1 which makes p=q=0, then the input s=0&r=0 would lead to an unstable state where p and q will oscillate.

You can look at is also from the perspective of the states

p=0 & q=0 : (next(p) = !s) & (next(q) = !r), i.e. all four states are reachable from here
p=0 & q=1 : (next(p) = 0) & (next(q) = !r), i.e. with r=1 we switch to p=q=0 and otherwise remain in p=0 & q=1
p=1 & q=0 : (next(p) = !s) & (next(q) = 0), i.e. with s=1 we switch to p=q=0 and otherwise remain in p=1 & q=0
p=1 & q=1 : (next(p) = 0) & (next(q) = 0), i.e. we switch to p=q=0

As you can see, it is unavoidable to go through state p=q=0.

Having written way too much, let me emphasize here finally, that all of this is not relevant for the exam tomorrow. I don't want to create the impression that this is maybe something you should look at in detail. Please don't waste your time!

Answered: CNF/DNF or CCNF/CDNF

Sun, 23 Aug 2020 17:00:21 +0000

If the exercise asks for CNF / DNF only, then the canonical-CNF / -DNF as well as the minial-CNF / -DNF and anything in between is ok.

CNF / DNF only means that we need a conjunction of disjunctions of literals / a disjunction of conjunction of literals respectively, but size does not matter for that.

Answered: Huffman Coding ws14 ex.1g)

Sun, 23 Aug 2020 15:32:51 +0000

There is more than one correct solution. In the example, we have probabilities (E,0.5);(O,0.125);(S,0.125);(U,0.10);(L,0.05);(N,0.05);(G,0.05) and Huffman encoding is based on a sorting of the letters according to their probabilities. As there are some letters with the same probabilities, you can sort differently and this way you get different codes. Their average number of bits per symbol should however be the same, even though for certain symbols you will have different number of bits. For example, for L,N,G two will have five bits and one of them just four, which one does not matter for the average number of bits per symbol, but of course for the particular encoding it matters.

Answered: B Complement Multiplication

Sun, 23 Aug 2020 13:45:41 +0000

I ran the program IntMultCRACRA with your inputs <7306>12 * <A0A2>12 and got the following partial products that have to be summed up to obtain the shown product:

                B   0   5   1   0   // pp[0][4..0]
            B   B   0   5   1       // pp[1][4..0]
        B   6   1   6   B           // pp[2][4..0]
    0   9   1   A   8               // pp[3][4..0]
    -------------------------------
    0   9   1   A   8   B   1   0   // p[7..0]

Computation of the partial products:

    <7306>12 * A = <B,0,5,1,0>12
    <7306>12 * 0 + <B,0,5,1>12 = <B,B,0,5,1>12
    <7306>12 * A + <B,B,0,5>12 = <B,6,1,6,B>12
    <7306>12 * 2 + <B,6,1,6>12 = <0,9,1,A,8>12

About the red rectangle: You have to apply function alpha when you reach the most significant digits, i.e., in your red rectangle where we have i=1 and j=3=N-1, you have to compute the following

    sm = xin * yin + pin + cin
       = x[1] * alpha(y[3]) + alpha(pp[0][4]) + cp[1][2]
       = 0 * alpha(7) + alpha(B) + 0
       = 0 * alpha(7) + alpha(B)
       = (11<(12/2) ? +x : +11-12)
       = +11-12
       = -1

and with this, you obtain

    cp[1][3] = -1
    pp[1][3] = 11
    pp[1][4] = gamma(-1) = 11

About the green rectangle: Here we have i=3=M-1 and j=3=N-1, and we therefore compute

    sm = xin * yin + pin + cin
       = alpha(x[3]) * alpha(y[3]) + alpha(pp[2][4]) + cp[3][2]
       = alpha(7) * alpha(A) + alpha(B) + 0
       = alpha(7) * alpha(A) + alpha(B) + 0
       = -5 * -2 + -1 + 0
       = 10 + -1 + 0
       = 9

and with this, you obtain

    cp[3][3] = 0
    pp[3][3] = 9
    pp[3][4] = gamma(0) = 0

recall

    alpha(x) = (x<(Base/2) ? +x : +x-Base);
    gamma(y) = (y<0 ? y+Base : y);

Does this help?

Answered: Rounding methods

Sun, 23 Aug 2020 11:57:30 +0000

I don't see a mistake in the slides, let's check some examples:

ceil(1.0-0.5) = ceil(0.5) = 1.0
ceil(1.4-0.5) = ceil(0.9) = 1.0
ceil(1.5-0.5) = ceil(1.0) = 1.0
ceil(1.6-0.5) = ceil(1.1) = 2.0
ceil(2.0-0.5) = ceil(1.5) = 2.0

About cornercases: these are the numbers which are exactly in between two integers like x=1.5 (and not x=2.0). For those numbers n+0.5, we obtain ceil(n+0.5-0.5) = ceil(n) = n which means that we are rounding downwards, right?

Answered: DNF ex.4 ws17

Sun, 23 Aug 2020 10:51:29 +0000

I think both is correct, note the the DNF is not a canonical normal form without further restrictions. You can verify the following equivalences:

((a->b) ∧ (c∨a∨¬b)) <-> (¬a∧¬b ∨ a∧b ∨ ¬a∧c)
((a->b) ∧ (c∨a∨¬b)) <-> (¬a∧¬b ∨ ¬a∧b∧c ∨ a∧b)

It is a matter of logic minimization. The function has even two minimal DNFs which are

!a&!b|a&b|b&c
!a&!b|a&b|!a&c

Answered: Floating point conversion

Sat, 22 Aug 2020 20:27:34 +0000

I think the best way to do this is as follows which is without remembering many complicated formulas:

Normalize the given number in that you haven/double it until the mantissa is between 1 and 2 while maintaining a product with a power of 2. Example: 0.2 = 0.2*2^0 = 0.4*2^{-1} = 0.8*2^{-2} = 1.6*2^{-3}
Convert the mantissa to radix 2: 1.6 = 1 + 1/2 + 1/16 + 1/32 + epsilon, i.e., 1.10011 + eps; if you need four bits, compute five here (which is the additional red one called the rounding bit).
Consider the two representable numbers less and greater than the given number; in the example, these are 1.1001_2 * 2^{-3} and 1.1010_2 * 2^{-3}. Which is the nearest number? This is easily seen as follows: if eps=0, then and the red digit is 1, we are exactly in the middle between two representable numbers, otherwise a red 1 tend to the upper number, and 0 to the lower one. Tie breaking is needed in case of the middle case which is done according to the rounding modes.
Rest depends on the rounding mode and whether you have a special case (denormal number, overflow, etc).

Does this help? Read also the answer to https://q2a.cs.uni-kl.de/1697/conversion-to-resyfloat-if-x-1

Answered: FSM Regulations in the exam

Sat, 22 Aug 2020 19:07:28 +0000

I am not sure what you mean with zero/null states (Müllzustände). Are these unreachable states, or states from where we cannot reach the final states? If you mean that, the answer depends on what the exercise is about. If you have to have a deterministic automaton, you probably need these states to maintain the determinism (or you have to minimize the automaton since these states are useless). Otherwise, it may be okay to drop them.

Answered: BDD: ws17 exercise 5 mistake + apply algorithm

Sat, 22 Aug 2020 18:59:41 +0000

So, I guess the first question is already answered if it was a wrong use of the operator precedences: XOR binds stronger than implication. If you have doubts about something like this, please ask in exams.

For problem 5c, one should compute the conjunction of BDDs for ((a∧¬b)∨c) and a∧b∧¬d ∨ ¬a which should produce the following BDDs:

& =

Note that the ordering is given and therefore c must occur before d on the paths.

Answered: Floating Point Arithmetic

Fri, 21 Aug 2020 13:42:30 +0000

For floating point numbers, you mainly need to be able to convert given numbers from and to floating point format. Performing arithmetic operations on floating point numbers is quite involved, and we usually don't do that in the exam. You should however know how that works in principle, i.e., that we need to adapt the exponents for addition/subtraction, and so on. Performing that in detail is however quite involved since rounding is required at the right steps etc. Bytheway, hardware implementations for the "full" IEEE754 standard are still not everywhere used since it is so complicated.

Answered: Korrekter Rechenweg

Fri, 21 Aug 2020 07:29:24 +0000

Ja, das ist okay.

Answered: What is a BDD(0)?

Thu, 20 Aug 2020 17:20:16 +0000

It refers to the False/True leaves. BDD(0) = False-leaf. BDD(1) = True-leaf.

Answered: Conversion to ReSyFloat if |x|<1

Thu, 20 Aug 2020 17:02:26 +0000

Let's convert 0.2 to a floating point number with 4 bits for the mantissa and three bits for the exponent. First, let's consider what the teaching tool does.

To describe the input, we have to specify the number as a quotient of integers, e.g., 2/10. The tool first translates these two numbers to radix-2 numbers and reads it as <10>_2 / <1010>_2. It realizes that it needs to scale the division by a factor of 2^7, i.e., to compute +<100000000>_2 / <1010>_2 * 2^{-7} to have sufficiently many digits for the mantissa when doing an integer division. The result of this integer division is now

+<1.1001...0/1...>_2 * 2^{-3}

The meaning of this is as follows: the mantissa is normalized (as you can see it starts with a 1 left of the decimal point). The next three digits given in blue color will be our remaining bits for the mantissa. The next bit given in red color is called the rounding bit; it would be the next bit after our mantissa, and finally the 0/1 given in green color will tell us whether there are futher 1 digits after this one (this is known by the integer division +<100000000>_2 / <1010>_2 by checking the remainder). Sometimes people call the green part the sticky bit in that they provide a bit which is 1 if there are further 1 bits and 0 otherwise.

Now, we either have to choose one of the representable numbers +<1.100>_2 * 2^{-3} or +<1.101>_2 * 2^{-3} since our actual number 0.2 = +<1.1001...0/1...>_2 * 2^{-3} cannot be precisely represented. Which one of the two is chosen depends on the rounding mode, and there we have to consider three cases:

In case the rounding bit would be 0, then the number would be closer to +<1.100>_2 * 2{-3}.
However, as the rounding bit is 1, and there are further 1-bits after this (the green ones), our number is closer to +<1.101>_2 * 2{-3}.
There could also be the third case, where the rounding bit is 1, and there are no further green bits on the right. In that case, the number would be right in the middle of the representable numbers +<1.100>_2 * 2{-3} and +<1.101>_2 * 2{-3}.

The table that follows in the output of the teaching tool tells you the numbers chosen for the different rounding modes.

If we would like to use a hidden bit, we should specify one further bit for the teaching tool, and the omit the leading 1 of the mantissa as the hidden bit.

When are denormal numbers used? They are used when the exponent becomes zero. In that case, we cannot reduce the exponent further to scale the mantissa, and we have to live with a mantissa that is not normalized. Recall that normalizing means that the mantissa is between 1 and 2, i.e., in binary 1.xxxxx. If that cannot be achieved with the exponents that we have, you need to represent the number as a denormal number (or it is an overflow).

Looking at the slides 23-26, you need to compute it as follows: First, normalize the number, i.e., represent it as M*2^{E} such that 1≤M<2 holds. In our case, we get

    0.2 = 0.4 * 2^{-1} = 0.8 * 2^{-2} = 1.6 * 2^{-3}

So, we have M = 1.6 and E = -3. With 3 bits for the exponent, we obtain the offet beta .= (2^{3}-1)/2 = 3. Hence, E+beta = -3+3 = 0, and the exponent that we should use is 0, so we will have a denormalize number (indicated by exponent 0).

Now note that 1.6 = 1 + 1/2 + 1/16 + ... which gives us the same information as mentioned above, i.e.

+<1.1001...0/1...>_2 * 2^{-3}

The rest can be explained as before.

Does it help?

Answered: Compose Algorithm ITE

Thu, 20 Aug 2020 09:31:53 +0000

Yes, you can use the ITE algorithm with three BDDs as operands. That is the core problem solved by the ITE algorithm. Once you have figured out the three BDDs which are the operands of the ITE algorithm, then you simple follow the steps of the ITE algorithm:

Maybe I don't understand what your problem there is?

Answered: Operator Base for XOR and AND

Wed, 19 Aug 2020 10:16:58 +0000

¬a = a ⊕ 1

Using other notation, not a = a xor 1

Answered: Question on exam WS17, 3b

Tue, 18 Aug 2020 12:39:58 +0000

Yes, we do not carefully distinguish between overflow and NaN (IEEE 754 does that very carefully). You are right that the problem is rather an overflow, what the teaching tool wants to express is that this number cannot be represented.

Answered: Exist Algorithm

Tue, 18 Aug 2020 10:41:43 +0000

In general, boolean quantification is defined as follows:

∃x. Phi := Phi[x<-0] ⋁ Phi[x<-1]
∀x. Phi := Phi[x<-0] ∧ Phi[x<-1]

In case of existential quantification, it says that Phi holds for some variable assignment where we don't care about the value of x (whether it is either 0 or 1) in the sense that at lease of the values 0,1 for x will extend the variable assignment to satisfy Phi. In case of the universal quantification it says that there must be an assignment for the rest of the variables so that assigning both values x<-0 and value x<-1 (one at a time, of course) will both satisfy the formula.

Answered: DNF determination

Tue, 18 Aug 2020 10:36:14 +0000

There are many ways: Truth tables are certainly one, but that one is always an exponential-size effort. Another approach is to compute a ROBDD, and then to enumerate the paths from the root node to the 1-leaf; each path is a conjunction of possibly negated variables and denotes a variable assignment. Using a disjunction of the paths gives you another DNF. And there is also the way to use Boolean algebra to rewrite a given formula to DNF which is also sometimes a fast solution. Yet another way is to compute the CNF of the negation, and to negate that again to make it a DNF.

In general, there is no best way, it always depends on the given formulas.

Answered: Compose Algorithm

Mon, 17 Aug 2020 16:22:38 +0000

There are again multiple steps happening at once. If we simply follow the algorithm, then the b node is "pulled up" and the Compose-Node goes down one level. Once phi is only True or False case 1 (from your question) applies.

Here we can see this directly, because a does not occur in phi. Therefore case 2 will never apply. We will simply go down recursively until finally case 1 applies. Intuitively: We want to replace a. a does not occur in phi. Therefore we leave phi as it is.

This is a shortcut that is easy to see for humans, and you are allowed to do that in the exam (but better write a comment next to it). The computer can't see that since it only goes through the tree node by node and does not have an "overview".

Answered: Exist Algorithm

Mon, 17 Aug 2020 10:07:39 +0000

You are right. On the left side, two steps are happening at once.

We look at the left and right child of the left exists-node. We see c > b, and therefore we can remove c (c can not occur in the right child, since it's ordered). Now both children of the exists-node are b and we can apply the same case as on the right side.

Answered: Questions about exam exercises

Sun, 16 Aug 2020 18:44:27 +0000

Answers for the DiRa exam in SS20:

If the output character is seen in the state, yes, since then that information is redundant. I guess that is what you have in mind. However, if the states would be called 0,1,2,... then some information would be missing, right?
Linear clause forms are of outmost importance for SAT solving; SAT solving is of outmost importance for verification; verification is of outmost importance for digital circuit design; so yes, it is required!
No, we exclude the case where the basis is an odd number. In general, it is possible to have odd numbers as bases, but then the algorithms sometimes need another special case. We exclude that since the bases used in circuit design are mostly powers of two and thus even numbers.
That is definitely no problem, and we even allow pocket calculators. However, because of that, be prepared that we might ask for a number conversion to base 7 which you don't find on pocket calculators.

Answered: Questions about exam

Sun, 16 Aug 2020 11:21:10 +0000

Here are my answers:

(1+2) You do not need all points to get a 1.0. You can see with the published grade table that at that time 90 points were required for the 1.0, and the exam had 125 points in total. So, you roughly need 75% of the points.

(3) If we find adjacent cubes, i.e., cubes that only differ by exactly one variable, then their disjunction is equivalent to the infimum of these cubes. Both the disjunction and the infimum are commutative and associative operations, so C_(1,2,3,4) and C_(1,3,2,4) are the same and you just need to compute one. That is why for each column in the Quine table, you just need to scan the other cubes below it to compute new cubes for the next column.

(4) Yes, the two columns are exchanged!

(5) You mean the solutions of the exam in SS15. No, we have not made solutions for that, sorry.

Answered: Is a calculator allowed on the exam?

Fri, 14 Aug 2020 12:01:54 +0000

see https://q2a.cs.uni-kl.de/1429/can-we-use-a-calculator-for-the-dira-exam

Answered: Boolean Algebra proof SAT and VALID

Mon, 03 Aug 2020 13:49:31 +0000

What about this solution:

    ((¬a ∨ a) ↔ (b ∨ a)) → (¬((¬a ∨ b) ∧ a) ↔ a ⊕ b)
    = (1 ↔ (b ∨ a)) → (¬((¬a ∨ b) ∧ a) ↔ a ⊕ b)
    = (b ∨ a) → ((¬((¬a ∨ b) ∧ a) ↔ a) ⊕ b)
    = (b ∨ a) → ((¬((¬a ∨ b) ∧ a) ∧ a ∨ ((¬a ∨ b) ∧ a) ∧ ¬a) ⊕ b)
    = (b ∨ a) → ((¬((¬1 ∨ b) ∧ 1) ∧ a ∨ ((¬0 ∨ b) ∧ 0) ∧ ¬a) ⊕ b)
    = (b ∨ a) → ((¬b ∧ a) ⊕ b)
    = (b ∨ a) → ((¬b ∧ a) ∧ ¬b ∨ ¬(¬b ∧ a) ∧ b)
    = (b ∨ a) → ((1 ∧ a) ∧ ¬b ∨ ¬(¬1 ∧ a) ∧ b)
    = (b ∨ a) → (a ∧ ¬b ∨ ¬0 ∧ b)
    = (b ∨ a) → (a ∧ ¬b ∨ b)
    = (b ∨ a) → (a ∨ b)
    = ¬(b ∨ a) ∨ (a ∨ b)
    = ¬(a ∨ b) ∨ (a ∨ b)
    = 1

Answered: wordlength arithmetic encoding

Sun, 26 Jul 2020 11:06:35 +0000

Yes you are right. When we decode 0.66, we first identify that in the start interval [0.0,1.0], it belongs to B's sub-interval [0.6,0.8] (see first line in figure). Then in the interval [0.6,0.8], we identify that encoding 0.66 belongs to A's sub-interval [0.6,0.72] (second line in figure). Then in the interval [0.6,0.72], we narrow down 0.66 to A's sub-interval [0.6,0.672] (third line in figure). Continuing similarly, in the interval [0.6,0.672], encoding 0.66 belongs to C's sub-interval [0.6576,0.672] (fourth line in figure). As you can see, we may continue decoding like this forever since the number 0.66 will always belong to one of the sub-intervals.

It is therefore necessary to inform the decoder when to stop. This can be done in a few ways. One way would be to use a special symbol as end-of-data. For instance, if symbol C is used in the above example to indicate end-of-data, the decoded word would be BAAC. Another way would be to specify total number of symbols in the word. For instance, if total number of symbols is specified as 5 in the above example, then the decoded word would be BAACA. In this case, there would be a fifth line in the above figure indicating that in the interval [0.6576,0.672], the encoding 0.66 belongs to A's sub-interval [0.6576,0.66624].

Answered: DiRa last chapters Processor Architecture + MIPS

Fri, 17 Jul 2020 10:02:12 +0000

They are relevant for the exam, but maybe not the most important topics. They are also an outlook on the RoSy lecture where processor architecture and system software are in the focus. The two lectures are connected by using digital circuit design (which is the major focus of DiRa) for the design of processors.

What is needed for the DiRa exam of this chapter? Well, we do not really discuss the micro architecture of processors, i.e., the circuit design, but just the macro architecture, which means the instruction set. You should therefore be able to read and write such programs. For the execution of these programs, we have the programmer's point of view which means that we assume that in each cycle, one instruction is executed. In reality, this is not the case, but that is the topic of RoSy.

If such an exercise should be part of the exam, we will add a sheet of paper with all of the instructions. So, you don't have to remember them all, but it is recommended to have seen and understood them during the exam preparation. As said, the single-cycle execution of the instructions should then be sufficient.

Answered: DiRa-Hazard

Sat, 04 Jul 2020 08:49:36 +0000

That chapter is not so important. You should know what hazards are and why they could be there, but last time the lecture was given, there wasn't enough time to go into the details. It would be now easy in the digital time to not count the time needed, but I would feel unfair to do this. Thus, let's decide to skip that chapter.

Answered: Exercise 4.1 Rounding Methods(1)

Tue, 26 May 2020 19:36:47 +0000

After scaling up by 2⁵ we are left with the remainder 0.4375. It is less than 0.5 so we round down. If it was more than 0.5 we would round up. "To nearest even" only comes into play if we have exactly 0.5. This is why it's called a tie-breaking rule (0.5 is a tie between up and down).

Answered: Exercise 4.3 Rounding Methods(1)

Tue, 26 May 2020 16:36:16 +0000

The exercise says radix-2 number. Since it says "to 5 digits" and not "to 5 digits after the point" it does not matter whether or not it is a fixpoint number (note that radix numbers we used up until here are also just fixpoint numbers with their point right of the LSB).

connection of entropy, minimum bits and coding length

Fri, 01 May 2020 06:25:25 +0000

Hello :)

I have two questions concerning "Digitaltechnik & Rechnerarchitektur".

1. On Slide 36 we define the maximal entropy. Which information does it exactly give us? Is it always the entropy rounded up so that we get our minimal number of bits to encode the alphabet?

2. Is there a conncection between the entropy and the average coding length of a letter in our alphabet? I understand that there is a conncetion to the weighted code size average but can we conclude something for our alphabet?

I may have a problem understanding the difference between the number of bits and the coding length. I hope someone can help me :)

Thank you,

Paula