Uke 15 - PowerShell, Java-tråder og synkronisering, deadlock, internminne og konkurransefinale!

Oppgaver til mandag 7. - fredag 11. apr

  1. (Oblig) 
     $sum = 0; Get-ChildItem | ForEach-Object {if($_.Extension -eq ".ps1") {$sum += $_.Length}};$sum
    alternativt 
    $sum = 0; Get-ChildItem | Where-Object Extension -eq ".ps1" | ForEach-Object{ $sum += $_.Length}; $sum
    eller 
    $sum = 0; Get-ChildItem -Filter *.ps1 | ForEach-Object { $sum += $_.Length }; $sum
  2. (Oblig) 
     ls -r | Where-Object{$_.Extension -eq ".ps1"}
    alternativt 
    ls -r *.ps1

  3. ls -r C:\  2> $null | Sort-Object -des Length |  Select-Object -first 10
  4. ls -r C: 2> $null | sort length -des | select -first 25 | Format-Table directory,name,length
  5. (Oblig) 
     get-date "17 may 1814"

  6.  ps | Where-Object {$_.StartTime -gt (get-date).AddMinutes(-50)} | ft id,ProcessName,StartTime
  7. (Oblig) Bruker man synchronized(lock) rundt kodeblokkene der saldo blir oppdatert, vil en tråd som går inn i denne blokken ta en lock som det bare finnes en av. Ingen andre tråder vil da kunne ta denne locken og må vente hvis de nå prøver å gå inn i disse kodeblokkene. Dermed kan bare en tråd av gangen kunne gjøre oppdateringer inne i kodeblokken og sluttresultatet blir riktig. Men programmet bruker mer tid, fordi det koster litt overhead å sørge for dette, trådene må vente på hverandre. 
               for(i = 1;i < MAX;i++)
		    {
			synchronized(lock){saldo++;} // Synkronisert kode-blokk
		    }
    Synkroniseringen fungerer både om trådene kjører på hver sin CPU (låsing av minne-bussen) og om de kjører på samme CPU, som taskset fører til.

  8.  
    // Kompileres med  javac SynchThreadS.java
    // Run: java SynchThreadS

    import java.lang.Thread;

    class SaldoThreadS extends Thread
    {
        static int MAX = 10000000;
        static int count = 0;
        public static int saldo;
        int id,mil;
        
        SaldoThreadS(int millisek)
        {
           count++;
           id = count;
           mil = millisek;
        }
        
        public void run()
        {
           try { sleep (mil); } catch (Exception e) { }       
           System.out.println("Thread nr. "+ id +", priority " + getPriority() + " starts");
           updateSaldo();
        }

       private synchronized void upSaldo()
         {
            saldo++;
         }
       private synchronized void downSaldo()
         {
            saldo--;
         }
       

       private void updateSaldo()
        {
         int i;
         if(id == 1) 
            {
            for(i = 1;i < MAX;i++) 
               {
               upSaldo();
               }
            }
         else      
            {
            for(i = 1;i < MAX;i++)
               {
               downSaldo();
               }
            }
         System.out.println("Thread nr. " + id + " finished. Saldo: " + saldo);
        }
    }

    class SynchThreadInt extends Thread
    {
       public static void main (String args[])
       {
        int i;
        System.out.println("Starts two threads!");

        SaldoThreadS s1 = new SaldoThreadS(1000);
        s1.start();

        SaldoThreadS s2 = new SaldoThreadS(1000);
        s2.start();
          
        try{s1.join();} catch (InterruptedException e){}
        try{s2.join();} catch (InterruptedException e){}

        System.out.println("Final total saldo: " +SaldoThreadS.saldo);
       }
    }

    Metodene må deklareres som static, ellers vil det eksistere en metode for hver tråd. Dermed får hver tråd sin egen monitor-lås og synkroniseringen har ingen effekt. Når metoden deklarers som static, vil det kun eksistere en eneste monitor og alle tråder synkroniseres mot denne.
  9. Mutex oppnås, OK. Men prosessene kan kun gå inn i kritisk avsnitt annenhver gang -> ubrukelig
  10. Algoritmene sørger for at mutual exclusion blir oppfylt, det er ikke mulig for noen av prosessene å komme samtidig inn i kritisk avsnitt. Men en context switch etter 
     flag[t] = true;
    for en prosess blir fatalt hvis den andre prosessen da prøver å gå inn i kritisk avsnitt og også utfører 
     flag[t] = true;
    for begge flaggene blir true og begge prosessene blir stående og spinne i while-løkken til evig tid......
  11. Så lenge de to prosessene ikke samtidig prøver å gå inn i kritisk avsnitt, er det ikke noe problem. Da vil en prosess gå rett inn, eventuelt vente til flag[other] blir false når den andre allerede er inne. Hvis de går inn samtidig er den siste som setter turn = other som må vente. Derfor er det også mest rettferdig at turn settes til other og ikke til t, seg selv. Legg merke til at turn kun har betydning når begge prosessene setter flag[t] = true. Etter at en av dem har entret kritisk avsnitt er turn fastlåst og igjen er det flag[] som bestemmer.
  12. It certainly works with preemptive scheduling. In fact, it was designed for that case. When scheduling is nonpreemptive, it might fail. Consider the case in which turn is initially 0 but process 1 runs first. It will just loop forever and never release the CPU.
  13. (Oblig) Når koden ser slik ut vil de to trådene bli stående å vente på hverandre og deadlock oppstår. Java gjør ingenting med dette, programmet bare henger.
  14. (Oblig) En fysisk adresse er en absolutt adresse til det fysiske internminnet. En virtuell adresse er en adresse i det virtuelle adresserommet. Denne kan mappes til en fysisk adresse, vanligvis gjøres det av MMU.
  15. Average access time = 0.95 × 2 nsec (byte is cache) + 0.05 × 0.99 × 10 nsec (byte is RAM, but not in cache) + 0.05 × 0.01 × 10,000,000 nsec (byte is on disk, but not in cache or RAM) = 5002.395 nsec = 5.002395 µsec
  16. (Oblig) (a) 8692 (b) 18010 (c) 30128
  17. (Oblig) Ja, det vil først bli sjekket om denne byte'n ligger i cache og den blir hentet derfra om den gjør det. Hvis ikke er det en cahce-miss og den må hentes fra RAM.
  18. (Oblig) Tallene ligger allerede i registerne, så det er ikke behov for å hente noe fra RAM/cache for å utføre denne instruksjonen.
  19. (Oblig) Adresserommet er da på 2^10 = 1024 adresser.
  20. (Oblig) Det er plass til 8 sider i adresserommet, 1024/128 = 8.
  21. (Oblig)