CSC 343 Operating Systems, Fall 2015

Transcription

1 CSC 343 Operating Systems, Fall 2015 Dr. Dale E. Parson, Assignment 4, analyzing swapping algorithm variations. This assignment is due via gmake turnitin from the swapping2015 directory by 11:59 PM on Friday December 4. There is no spreadsheet or PLOTS.txt file to turn in this time. I will not accept solutions after the end of December 5. The coding is this assignment consists of building variations of a swapping algorithm from memorylimited handout code in program rr_ff_noswap.stm that causes some of the 24 single-threaded processes to block until they can obtain memory, but that do not engage in swapping. You will add swapping. The usual 10% per day late penalties apply, and I will not accept solutions after the end of December 5. cd $HOME # or start out in your login directory cd. /OpSys cp ~parson/opsys/swapping2015.problem.zip swapping2015.problem.zip unzip swapping2015.problem.zip cd./swapping Running gmake testrr testrr_ff_noswap on harry should work fine with the handout code. Handout program rr_ff_noswap.stm is a modified version of handout round-robin CPU scheduler rr.stm that runs 24 single-threaded processes for which there is insufficient physical memory to house all 24 in memory concurrently. Here are the pertinent data structures from the processor state machine. init -> makingprocesses init()[]/@ # CPU scheduling queue: processor.readyq = Queue(ispriority=False); # Two gig of available memory, initially all free, starts at phyaddr 0. processor.physicalmemory = ; # Each entry is this table is a (LIMIT, BASE) pair, with values giving # (SIZE, START_ADDRESS) of a region in physical memory. As memory gets # allocated and freed by processes, this initial region gets chopped # up into multiple smaller regions and the merged where possible # when freeing. See macros and lambda functions in the thread state # machine for the code the manages the processor.freeregions and # pcb.relocationregister. processor.freeregions = [(processor.physicalmemory, 0)]; # The waitmemq is the Queue where process threads wait until they get memory. processor.waitmemq = Queue(ispriority=False); The graph for the thread state machine from appears on the next page. It is the same as for Round Robin that we have gone over before with one important exception. Note the new checkifmemory and waitformemory states. When a process cannot run 1 due to insufficient memory to satisfy its memory requirement, the process enters waitformemory until another process completes execution and enters the terminated 1 Since these processes are single- threaded, this handout uses the terms process and thread somewhat interchangeably. All threads within a process share its memory space, so all threads would block waiting for memory in which to run in a multithreaded process. page 1

2 state. On the transition into terminated the latter process returns its memory to the physical memory pool and then sends a memoryready event by calling signalevent for the thread at the front of the processor.waitmemq seen above. The working of this program is very much like the use of the processor.readyq for holding threads that are waiting for a context on which to run. In this case processor.waitmemq holds threads 0 that are waiting for their respective process to obtain memory. When a terminating thread signals a thread waiting in processor.waitmemq (i.e., in the waitformemory state) about the availability of memory, the signaled thread goes back to state checkifmemory to test whether it can obtain its memory. A terminating thread may release less memory than is required by the signaled thread, or the memory may be too fragmented for use. If so, the signaled thread returns to the processor.waitmemq in the waitformemory state. Otherwise, it proceeds to the scheduling state for normal Round Robin execution. This is the first assignment running on the new version 11 of the STM compiler and simulator. This compiler/simulator version requires initialization of all STM local variables in the variable declaration section or in the transition(s) from the init state, and it requires initialization of all fields in the thread, pcb and processor objects in transition(s) from the appropriate init state (processor init for processor object fields, thread 0 init for pcb object fields, and thread init for thread object fields). I added this run time check because Python does not check for assignment into misspelled variables. This check costs about 3% in simulation time increase. The thread STM in this assignment uses several new variables including swapdevice, findcost, putcost, and several Python functions and STM macros for memory management that we will go over in class. Handout STM rr_ff_noswap.stm uses round robin CPU scheduling and first fit physical memory allocation. page 2

3 Here is the initialization transition code for the single thread of each process with the new parts in bold. init -> checkifmemory pid, tid = getid(); iobound = True if ((pid % 2) == 1) else False ; # ^^^ The odd pids are IO bound. The others (50%) are CPU bound. swapdevice = len(processor.fastio)-1 ; # The range of process sizes drives contention for memory. # Each process averages (1/16 + 1/2) / 2 = of physical memory, # so we'd expect 3 to 4 processes to fit into memory at one time, # and never fewer than 2 will fit at one time. See processestogo # in the processor STM above. pcb.logicalmemorysize = sample(int(processor.physicalmemory/16), int(processor.physicalmemory/2), 'uniform'); # pcb.relocationregister will get a piece of processor.freeregions. pcb.relocationregister = None ; cpuburst = sample(1, 250, 'exponential', 25) if iobound else sample(100, 1100, 'revexponential', 1000); tickstorun = min(cpuburst, quantum); tickstodefer = cpuburst - tickstorun; # Set variables freeslot and findcost: getfirstfit ; cpu(findcost)@ An inspection of rr_ff_noswap.log after a successful gmake testrr_ff_noswap 2 shows the following. An assignment 3 handout shows how to keep the log file from being removed. $ grep DEBUG rr_ff_noswap.log cut -d' ' -f2-3 less ( , 0) [( L, )] None [( L, )] ( , ) [( L, )] None [( L, )] ( , ) [( L, )] None [( L, )] ( , ) [( L, )] None [( L, )] ( , ) [( L, )] None [( L, )] None [( L, )] ( , ) [( L, )] None [( , ), ( L, )] None [( , ), ( L, )] ( , ) [( , ), ( L, )] 2 You must comment out this line that follows your test of interest in the makefile in order to keep the log file: /bin/rm - f /tmp/$(student)_stm_*.log $(STUDENT)_STM_*.log rr_ff_noswap*.log. Comment it out by preceding it with a # character. Note this is the line for gmake testrr_ff_noswap. If you do so, make sure to run gmake clean at the end of a work session in which you want to clean up the log file. page 3

4 ( , ) [( , ), ( L, )] ( , 0) [( L, )] ( , 0) [( L, )] ( , 0) [( L, )] ( , 0) [( L, )] In each of those lines, the value to the left of the first shows the pcb.relocationregister values for the process that is obtaining or freeing memory, showing the value None when the pcb.relocationregister is not set to point to physical memory. A valid entry has two values, the size of a memory region (the limit), and the start of that region (the base). The list of such pairs to the right of the is the full set of disjoint free memory regions in processor.freeregions as introduced on page 1. ROUND ROBIN, BEST FIT, WITH NO SWAPPING (Edit file rr_bf_noswap.stm) 25% of project 2. Next, cp rr_ff_noswap.stm rr_bf_noswap.stm and modify rr_bf_noswap.stm as follows. The only changes in this section are to change the file name, add the student name, and change the first fit comment to best fit at the top of the file, then replace every call to the getfirstfit macro with a call to getbestfit, and replace every call to the putfirstfit macro with a call to putbestfit. Do not change the definitions of these macros; change only their calls. We will go over them in class. After making the above changes, gmake testrr_bf_noswap should work without errors. I have found that the metrics for the first fit and best fit variations of this assignment are identical in most test runs. There are a few algorithm variations that show minor differences, but for this simulation s conditions, there is not much measurable difference between the two. BEST FIT WITH CPU BURST-DRIVEN SWAPPING (Edit file rr_bf_swaponcpu.stm) 25% page 4

5 All of the remaining variations of this assignment generate the above graph. Here are the salient points. For this stage, cp rr_bf_noswap.stm rr_bf_swaponcpu.stm and edit the following changes into the latter file. In rr_bf_swaponcpu.stm the thread STM adds some local variables: swapdevice = -2, iodevice = -2, findcost = -1, putcost = -1, cpuburstsum = 0, lifetimestart = 0, cpuburstswap = 500, lifetimeswap = 10000, swappedout Update local variable cpuburstsum (e.g., accumulating via +=) the value in cpuburst every time the latter variable updates by calling sample(). Variable cpuburstsum sums the burst times. This variable comes into play when the STM is leaving the waiting state. Notice that there are two transitions out of waiting, one going to scheduling as before, and the other going to checkifmemory. The original transition to scheduling now has a guard that allows crossing only when the len(processor.waitmemq) == 0, meaning that no process is stalled waiting for memory, or when cpuburstsum < cpuburstswap, meaning that this thread is not ready to give up its memory just yet. The only new action in this transition is the update to cpuburstsum after computing cpuburst via sample(). The transition from waiting to checkifmemory executes if the opposite condition is true, i.e., there are threads in processor.waitmemq and cpuburstsum >= cpuburstswap. Here is this transition; rather than accumulate into cpuburstsum, this transition re-initializes it because it also releases the process memory by calling putbestfit. waiting -> checkifmemory io()[@len(processor.waitmemq) > 0 and cpuburstsum >= cpuburstswap@]/@ cpuburst = sample(1, 250, 'exponential', 25) if iobound else sample(100, 1100, 'revexponential', 1000); cpuburstsum = cpuburst ; tickstorun = min(cpuburst, quantum); tickstodefer = cpuburst - tickstorun; # Release held memory and signal the next waiting thread if any. putbestfit ; signalevent(processor.waitmemq.deq(), 'memoryready'); swappedout = True ; io(swapdevice)@ The call to putbestfit releases this process memory, setting pcb.relocationregister to None. This process signals the first waiting process thread, sets the swappedout flag to True, and performs swapping-out I/O. Setting swappedout flag to True configures this process to take an additional swap-in I/O delay after it re-obtains memory. The two new transitions out of checkifmemory on the completion of the swap-out io() event are identical to their cpu()-event counterparts. However, both the cpu() and io() transitions with guards on pcb.relocationregister!= None must set swappedout = False, because a process with a valid pcb.relocationregister is not swapped out. The above transition from waiting nulls pcb.relocationregister as part of releasing memory, so it will retain swappedout as True. page 5

6 The transition out of waitformemory now looks like this: waitformemory -> checkifmemory # Set variables freeslot and findcost: getbestfit ; io(swapdevice) if (swappedout and pcb.relocationregister) else cpu(findcost)@ If it is swapping in, it starts a time-consuming io(swapdevice) (swap-back-in). If it is just attaching to physical memory for the first time, it takes the less expensive cpu(findcost) charge. The destination checkifmemory state will set swappedout back to False if and only if the pcb.relocationregister has been mapped to memory. It is possible that the above call to getbestfit will fail due to lack of requested memory, leaving pcb.relocationregister with a value of None. The checkifmemory state correctly handles that condition. 3. Running gmake testrr_bf_swaponcpu should pass after you make the above changes. EDIT file rr_bf_swaponstime.stm 25% of assignment grade 4. Run cp rr_bf_swaponcpu.stm rr_bf_swaponstime.stm, make the following changes to the latter file (including comments at the top), and gmake testrr_bf_swaponstime when you are ready to test. There are very few changes in this stage. They are based on the idea that a process relinquishes its memory to processes-in-need-of-memory when it exceeds some threshold of simulated wall clock time or real time given by the simulator s time() function, rather than by a threshold on cpu burst time. First, initialize lifetimestart = time(); when coming out of the thread init state. Next, on the two transitions coming out of the waiting state, replace the tests comparing cpuburstsum to cpuburstswap with tests comparing (time() - lifetimestart) to lifetimeswap. This is a test on elapsed time. See lifetimeswap = on page 4 above. The transition from waiting -> checkifmemory must reinitialize lifetimestart = time();. EDIT file rr_bf_swaponsize.stm 25% of assignment grade 5. Run cp rr_bf_swaponstime.stm rr_bf_swaponsize.stm, make the following changes to the latter file (including comments at the top), and gmake testrr_bf_swaponsize when you are ready to test. There are very few changes in this stage. They are based on the idea that a process relinquishes its memory to processes-in-need-of-memory based on the memory size of the relinquishing process. Bigger processes relinquish more frequently. This program initializes a variable memoryaccum to 0. On the two transitions coming out of the waiting state, replace the tests comparing (time() - lifetimestart) to lifetimeswap with tests comparing (pcb.logicalmemorysize + memoryaccum) to processor.physicalmemory. In the waiting -> scheduling transition update memoryaccum += pcb.logicalmemorysize ;, and in the waiting -> checkifmemory transition reinitialize memoryaccum = 0 ;. The point of this version of the program is to relinquish memory to a waiting process when a process has used an aggregate of processor.physicalmemory or more bytes in multiple trips around the main state machine loop. page 6

7 When everything is ready, gmake turnitin by the due date. Note that the late acceptance period is only one day, so I can post my solution in a timely manner. On the next page are several graphs of interest. We will discuss these in class. There is no graph for students to extract this time. page 7