EE 599-002: Examle Questions

Here are some questions on material that will be on the final exam. They are more like homework problems in character than exam problems. Actual exam questions may vary in length in difficulty.

  1. A switch has three connections established, C1, C2, and C3. The release time and execution time of the first six packets to arrive are shown below:
    Connection (release, execution) (release, exec)
    C1(0, 2) (3, 1)
    C2(1, 3) (5, 3)
    C3(1, 2) (6, 1)
    1. Assuming the switch is using Weighted Fair Queueuing and C1, C2, and C3 have been assigned û1 = 0.25, û2 = 0.3, û3 = 0.1, show how the above packets are scheduled.
    2. Assuming the switch is using Weighted Round Robin with RL = 9 and C1, C2, and C3 have been assigned weights wt1 = 2, wt2 = 3, wt3 = 3, show how the above packets are scheduled.
  2. Tasks three devices would like to send messages to each other using a shared medium network. The period, message size, and deadline for the three message streads are T1: (250 μs, 4 Bytes, 250 μs), T2: (500 μs, 8 Bytes, 500 μs), and T3: (1000 μs, 32 Bytes, 1000 μs).
    1. Ignoring framing overhead, can these tasks be scheduled using RM on a 500 Kbit/s CAN network?

      sketch of solution:

      1. execution time is in bytes, but period is in μs, so convert (e.g., e1 = (4 bytes * 8 bits/byte) / 500 Kbits/s = 64 μs)
      2. Use time-demand analysis to determine schedulability of tasks using computed execution times. Don't forget to include bi(np), which is equal to the max length of all lower priority packets.
    2. Ingorning framing overhead, can these tasks be scheduled using RM on a 4 Mbit/s token ring network with a max round-trip-time of 1 μs and maxiumum packet size of 4096 bytes?

      sketch of answer: convert execution times from bytes to seconds as with CAN, and apply time demand analysis, but bi(np) = 2 emax and bi = 2 CS + bi(np)

Here are some questions related to power-aware scheduling:

  1. A battery powered system has three tasks T1: (1 ms, 4 ms), T2: (2 ms, 6 ms), and T3 (3 ms, 12 ms) and consumes 10 mW when any task is running and 0 mW when it is idle. (Remember E = Σ Pi×ti)
    1. How much energy does the system consume in one hyperperiod if the system runs at full speed using EDF scheduling?
    2. What is the minumum constant frequency at which the system can run such that all tasks are still schedulable? How much energy does the system consume running at that frequency assuming that power when tasks are running = f3P where P is the power at full speed?
    3. The pair (fi, Pi) indicate a mode in which the system runs with relative frequency fi and relative power Pi. Assuming this particular system has modes (1, 1), (0.75, 0.5), and (0.5, 0.2), how much energy is consumed in one hyperperiod running the above tasks with ccEDF assuming all tasks run their full worst-case execution time (WCET)? How much energy does it use if all tasks take only 1/2 their WCET?

Here are some questinos releated to non-volatile storage and filesystems.

  1. What type of non-storage would you use for each of the following applications and why?
    Application Storate Type Why?
    Mars Rover Science
    Data Storage
    PDA Address and Data
    Storage
    Surveillance System
    Digital Video
    Ethernet Switch Settings
    Electronic Voting Booth
    Vote Storage
  2. What would be the primary technical difficulties implementing a typical Unix filesystem on FLASH media?
  3. Why is journalling used in filesystems? Is it more likely to be important for embedded systems than for desktop workstations and server? Why or why not?
  4. What are the advantages and disadvantages of using a FAT filesystem for embedded systems?
  5. One common problem with filesystems is that over time they can become fragmented. As files are created and destroyed free blocks tend to get spread around the disk so that blocks in new files tend not to be contiguous on the disk. How well do you think each of the filesystems we discussed (ext3, FAT, JFFS2) will perform with a fragmented disk? Consider the three cases of reading sequentially from a file, seeking to a position in the file and reading a small amount of data, and writing to the end of a file.