コード例 #1
0
    def __init__(self, space=16384, os=4096):
        '''
        Constructor
        '''
        self.space = space  # total space of memory
        self.os = os  # space of OS in memory

        self.elapsedTime = 0
        self.jobProcessed = 0

        # create OS partition and free partition called "main"
        # double link partition in memory
        self.osPartition = MyPartition("OS partition", 4096, "Undefined", "OS",
                                       [0, self.os])
        self.mainPartition = MyPartition("blank partition", 12288, 0,
                                         "Available", [self.os, self.space])
        self.osPartition.nextPartition = self.mainPartition
        self.mainPartition.prevPartition = self.osPartition

        # get data from text file and put them in entry queue
        dataQueue = ReadData()
        dataQueue.readDataFile(dataQueue.filename)
        self.entryQueue = MyQueue()
        self.entryQueue = dataQueue.entryQueue

        # variables used to compute statistics of best-fit, first-fit, and next-fit
        self.entryQueueLength = {}
        self.memoryRatio = {}
        self.fragmentation = {}

        # variable used to store memory output
        self.output = ''
コード例 #2
0
def reverseK(queue, k):
    if k > queue.size() or k < 0 or queue.is_empty():
        return None

    stack = MyStack()
    new_q = MyQueue()

    for i in range(k):
        v = queue.dequeue()
        stack.push(v)

    while not stack.is_empty():
        v = stack.pop()
        new_q.enqueue(v)

    while not queue.is_empty():
        v = queue.dequeue()
        new_q.enqueue(v)

    return new_q
コード例 #3
0
class MyMemory():
    '''
    class used to simulate memory management for best-fit, first-fit, and next-fit
    '''
    def __init__(self, space=16384, os=4096):
        '''
        Constructor
        '''
        self.space = space  # total space of memory
        self.os = os  # space of OS in memory

        self.elapsedTime = 0
        self.jobProcessed = 0

        # create OS partition and free partition called "main"
        # double link partition in memory
        self.osPartition = MyPartition("OS partition", 4096, "Undefined", "OS",
                                       [0, self.os])
        self.mainPartition = MyPartition("blank partition", 12288, 0,
                                         "Available", [self.os, self.space])
        self.osPartition.nextPartition = self.mainPartition
        self.mainPartition.prevPartition = self.osPartition

        # get data from text file and put them in entry queue
        dataQueue = ReadData()
        dataQueue.readDataFile(dataQueue.filename)
        self.entryQueue = MyQueue()
        self.entryQueue = dataQueue.entryQueue

        # variables used to compute statistics of best-fit, first-fit, and next-fit
        self.entryQueueLength = {}
        self.memoryRatio = {}
        self.fragmentation = {}

        # variable used to store memory output
        self.output = ''

    '''
    insert job using first-fit algorithm
    '''

    def insertProcessFirstFit(self, number, size, duration):
        memoryPartition = self.osPartition

        while (True):
            # partition is OS: just skip to the next partition
            if (memoryPartition.status == "OS"):
                memoryPartition = memoryPartition.nextPartition
                continue

            # partition is not blank partition skip
            if (memoryPartition.status != "Available"):
                if (self.checkAvailableSpace(memoryPartition)):
                    memoryPartition = memoryPartition.nextPartition
                    continue
                # reach end of memory
                else:
                    self.updateMemory()
                    # calculation of fragmentation over time
                    fragmentation = self.findFragmentation()
                    if (fragmentation != None):
                        self.fragmentation[self.elapsedTime] = fragmentation
                    while (not (self.checkProcessIfDone())):
                        self.updateMemory()
                    done = self.insertProcessFirstFit(number, size, duration)
                    if (done):  # insertion is done
                        return True

            # if partition is blank check size: if enough put new process in
            if (memoryPartition.status == "Available"):
                if (memoryPartition.size > int(size[0:-1])):
                    memoryPartition.name = "Process " + number
                    memoryPartition.duration = duration
                    memoryPartition.status = "Processing"
                    memoryPartition.space = [
                        memoryPartition.space[0],
                        memoryPartition.space[0] + int(size[0:-1])
                    ]
                    if (self.checkAvailableSpace(memoryPartition)):
                        nextPartition = memoryPartition.nextPartition
                        newNextPartition = MyPartition(
                            "blank partition",
                            memoryPartition.size - int(size[0:-1]), 0,
                            "Available", [
                                memoryPartition.space[0] + int(size[0:-1]),
                                memoryPartition.space[0] + memoryPartition.size
                            ])
                        memoryPartition.size = int(size[0:-1])
                        memoryPartition.nextPartition = newNextPartition
                        newNextPartition.prevPartition = memoryPartition
                        newNextPartition.nextPartition = nextPartition
                        nextPartition.prevPartition = newNextPartition
                        if (not (self.entryQueue.isEmpty())):
                            self.output += "=> Time spent in entry queue for job " + str(
                                self.entryQueue.frontElt().itemNumber
                            ) + ": " + str(
                                self.entryQueue.frontElt().timeInQueue) + "\n"
                            print "=> Time spent in entry queue for job ", self.entryQueue.frontElt(
                            ).itemNumber, ": ", self.entryQueue.frontElt(
                            ).timeInQueue
                        self.entryQueue.dequeue()
                        self.entryQueueLength[
                            self.elapsedTime] = self.entryQueue.length
                        return True

                    # reach end of memory
                    else:
                        newNextPartition = MyPartition(
                            "blank partition",
                            memoryPartition.size - int(size[0:-1]), 0,
                            "Available", [
                                memoryPartition.space[0] + int(size[0:-1]),
                                memoryPartition.space[0] + memoryPartition.size
                            ])
                        memoryPartition.size = int(size[0:-1])
                        memoryPartition.nextPartition = newNextPartition
                        newNextPartition.prevPartition = memoryPartition
                        if (not (self.entryQueue.isEmpty())):
                            self.output += "=> Time spent in entry queue for job " + str(
                                self.entryQueue.frontElt().itemNumber
                            ) + ": " + str(
                                self.entryQueue.frontElt().timeInQueue) + "\n"
                            print "=> Time spent in entry queue for job ", self.entryQueue.frontElt(
                            ).itemNumber, ": ", self.entryQueue.frontElt(
                            ).timeInQueue
                        self.entryQueue.dequeue()
                        self.entryQueueLength[
                            self.elapsedTime] = self.entryQueue.length
                        return True

                if (memoryPartition.size == size[0:-1]):
                    memoryPartition.name = "Process " + number
                    memoryPartition.duration = duration
                    memoryPartition.status = "Processing"
                    if (not (self.entryQueue.isEmpty())):
                        self.output += "=> Time spent in entry queue for job " + str(
                            self.entryQueue.frontElt(
                            ).itemNumber) + ": " + str(
                                self.entryQueue.frontElt().timeInQueue) + "\n"
                        print "=> Time spent in entry queue for job ", self.entryQueue.frontElt(
                        ).itemNumber, ": ", self.entryQueue.frontElt(
                        ).timeInQueue
                    self.entryQueue.dequeue()
                    self.entryQueueLength[
                        self.elapsedTime] = self.entryQueue.length
                    return True

                if (memoryPartition.size < size[0:-1]):
                    if (self.checkAvailableSpace(memoryPartition)):
                        memoryPartition = memoryPartition.nextPartition
                        continue
                    # reach end of memory
                    else:
                        self.updateMemory()
                        # calculation of fragmentation over time
                        fragmentation = self.findFragmentation()
                        if (fragmentation != None):
                            self.fragmentation[
                                self.elapsedTime] = fragmentation
                        while (not (self.checkProcessIfDone())):
                            self.updateMemory()
                        done = self.insertProcessFirstFit(
                            number, size, duration)
                        if (done):  # insertion is done
                            return True

            # check space to make sure partition does not go out of memory bounds
            # if we reach end of memory, and memory is full: Update memory => need boolean variable for

    '''
    insert job using best-fit algorithm
    '''

    def insertProcessBestFit(self, number, size, duration):
        # check if there is partition in memory
        partition = self.traverseMemory(int(size[0:-1]))
        # case : partition exists
        if (partition != None):
            if (partition.size == int(size[0:-1])):
                partition.name = "Process " + number
                partition.duration = duration
                partition.status = "Processing"
                if (not (self.entryQueue.isEmpty())):
                    self.output += "=> Time spent in entry queue for job " + str(
                        self.entryQueue.frontElt().itemNumber) + ": " + str(
                            self.entryQueue.frontElt().timeInQueue) + "\n"
                    print "=> Time spent in entry queue for job ", self.entryQueue.frontElt(
                    ).itemNumber, ": ", self.entryQueue.frontElt().timeInQueue
                self.entryQueue.dequeue()
                self.entryQueueLength[
                    self.elapsedTime] = self.entryQueue.length
                return True
            if (partition.size > int(size[0:-1])):
                partition.name = "Process " + number
                partition.duration = duration
                partition.status = "Processing"
                partition.space = [
                    partition.space[0], partition.space[0] + int(size[0:-1])
                ]
                if (self.checkAvailableSpace(partition)):
                    nextPartition = partition.nextPartition
                    newNextPartition = MyPartition(
                        "blank partition", partition.size - int(size[0:-1]), 0,
                        "Available", [
                            partition.space[0] + int(size[0:-1]),
                            partition.space[0] + partition.size
                        ])
                    partition.size = int(size[0:-1])
                    partition.nextPartition = newNextPartition
                    newNextPartition.prevPartition = partition
                    newNextPartition.nextPartition = nextPartition
                    nextPartition.prevPartition = newNextPartition
                    if (not (self.entryQueue.isEmpty())):
                        self.output += "=> Time spent in entry queue for job " + str(
                            self.entryQueue.frontElt(
                            ).itemNumber) + ": " + str(
                                self.entryQueue.frontElt().timeInQueue) + "\n"
                        print "=> Time spent in entry queue for job ", self.entryQueue.frontElt(
                        ).itemNumber, ": ", self.entryQueue.frontElt(
                        ).timeInQueue
                    self.entryQueue.dequeue()
                    self.entryQueueLength[
                        self.elapsedTime] = self.entryQueue.length
                    return True
                else:
                    newNextPartition = MyPartition(
                        "blank partition", partition.size - int(size[0:-1]), 0,
                        "Available", [
                            partition.space[0] + int(size[0:-1]),
                            partition.space[0] + partition.size
                        ])
                    partition.size = int(size[0:-1])
                    partition.nextPartition = newNextPartition
                    newNextPartition.prevPartition = partition
                    if (not (self.entryQueue.isEmpty())):
                        self.output += "=> Time spent in entry queue for job " + str(
                            self.entryQueue.frontElt(
                            ).itemNumber) + ": " + str(
                                self.entryQueue.frontElt().timeInQueue) + "\n"
                        print "=> Time spent in entry queue for job ", self.entryQueue.frontElt(
                        ).itemNumber, ": ", self.entryQueue.frontElt(
                        ).timeInQueue
                    self.entryQueue.dequeue()
                    self.entryQueueLength[
                        self.elapsedTime] = self.entryQueue.length
                    return True
        # case : partition does not exist
        else:
            self.updateMemory()
            # calculation of fragmentation over time
            fragmentation = self.findFragmentation()
            if (fragmentation != None):
                self.fragmentation[self.elapsedTime] = fragmentation
            while (not (self.checkProcessIfDone())):
                self.updateMemory()
            done = self.insertProcessBestFit(number, size, duration)
            if (done):  # insertion is done
                return True

    '''
    traverse memory and look for smallest partition to put job
    '''

    def traverseMemory(self, size):
        partition = self.mainPartition
        bestPartition = MyPartition("temp", 0)
        closest = 0
        findOnePartition = False  # boolean variable to check for success or failure

        # go through main partition
        while (partition):
            if (partition.status == "Available" and partition.size >= size):
                if (findOnePartition):
                    if (closest > partition.size - size):
                        bestPartition = partition
                        closest = partition.size - size
                else:
                    bestPartition = partition
                    closest = partition.size - size
                    findOnePartition = True
            partition = partition.nextPartition
        if (not (findOnePartition)):
            return None
        return bestPartition

    '''
    insert job using next-fit algorithm
    '''

    def insertProcessNextFit(self, number, size, duration):
        # look through main memory if it contains job already
        partition = self.lookForLastJob()
        # case : if it contains job, starts from last job in memory
        if (partition != None):
            if (self.checkAvailableSpace(partition)):
                partition = partition.nextPartition
            else:
                partition = self.mainPartition
            while (partition):
                if (partition.status == "Available"):
                    if (partition.size > int(size[0:-1])):
                        partition.name = "Process " + number
                        partition.duration = duration
                        partition.status = "Processing"
                        partition.space = [
                            partition.space[0],
                            partition.space[0] + int(size[0:-1])
                        ]
                        if (self.checkAvailableSpace(partition)):
                            nextPartition = partition.nextPartition
                            newNextPartition = MyPartition(
                                "blank partition",
                                partition.size - int(size[0:-1]), 0,
                                "Available", [
                                    partition.space[0] + int(size[0:-1]),
                                    partition.space[0] + partition.size
                                ])
                            partition.size = int(size[0:-1])
                            partition.nextPartition = newNextPartition
                            newNextPartition.prevPartition = partition
                            newNextPartition.nextPartition = nextPartition
                            nextPartition.prevPartition = newNextPartition
                            if (not (self.entryQueue.isEmpty())):
                                self.output += "=> Time spent in entry queue for job " + str(
                                    self.entryQueue.frontElt().itemNumber
                                ) + ": " + str(self.entryQueue.frontElt().
                                               timeInQueue) + "\n"
                                print "=> Time spent in entry queue for job ", self.entryQueue.frontElt(
                                ).itemNumber, ": ", self.entryQueue.frontElt(
                                ).timeInQueue
                            self.entryQueue.dequeue()
                            self.entryQueueLength[
                                self.elapsedTime] = self.entryQueue.length
                            return True

                        # reach end of memory
                        else:
                            newNextPartition = MyPartition(
                                "blank partition",
                                partition.size - int(size[0:-1]), 0,
                                "Available", [
                                    partition.space[0] + int(size[0:-1]),
                                    partition.space[0] + partition.size
                                ])
                            partition.size = int(size[0:-1])
                            partition.nextPartition = newNextPartition
                            newNextPartition.prevPartition = partition
                            if (not (self.entryQueue.isEmpty())):
                                self.output += "=> Time spent in entry queue for job " + str(
                                    self.entryQueue.frontElt().itemNumber
                                ) + ": " + str(self.entryQueue.frontElt().
                                               timeInQueue) + "\n"
                                print "=> Time spent in entry queue for job ", self.entryQueue.frontElt(
                                ).itemNumber, ": ", self.entryQueue.frontElt(
                                ).timeInQueue
                            self.entryQueue.dequeue()
                            self.entryQueueLength[
                                self.elapsedTime] = self.entryQueue.length
                            return True

                    if (partition.size == size[0:-1]):
                        partition.name = "Process " + number
                        partition.duration = duration
                        partition.status = "Processing"
                        if (not (self.entryQueue.isEmpty())):
                            self.output += "=> Time spent in entry queue for job " + str(
                                self.entryQueue.frontElt().itemNumber
                            ) + ": " + str(
                                self.entryQueue.frontElt().timeInQueue) + "\n"
                            print "=> Time spent in entry queue for job ", self.entryQueue.frontElt(
                            ).itemNumber, ": ", self.entryQueue.frontElt(
                            ).timeInQueue
                        self.entryQueue.dequeue()
                        self.entryQueueLength[
                            self.elapsedTime] = self.entryQueue.length
                        return True

                    if (partition.size < size[0:-1]):
                        if (self.checkAvailableSpace(partition)):
                            partition = partition.nextPartition
                            continue
                        # reach end of memory
                        else:
                            self.updateMemory()
                            # calculation of fragmentation over time
                            fragmentation = self.findFragmentation()
                            if (fragmentation != None):
                                self.fragmentation[
                                    self.elapsedTime] = fragmentation
                            while (not (self.checkProcessIfDone())):
                                self.updateMemory()
                            done = self.insertProcessNextFit(
                                number, size, duration)
                            if (done):  # insertion is done
                                return True
        # case : if it does not contain job in memory
        elif (not (self.hasJobProcessing())):
            partition = self.mainPartition
            if (partition.size == int(size[0:-1])):
                partition.name = "Process " + number
                partition.duration = duration
                partition.status = "Processing"
                if (not (self.entryQueue.isEmpty())):
                    self.output += "=> Time spent in entry queue for job " + str(
                        self.entryQueue.frontElt().itemNumber) + ": " + str(
                            self.entryQueue.frontElt().timeInQueue) + "\n"
                    print "=> Time spent in entry queue for job ", self.entryQueue.frontElt(
                    ).itemNumber, ": ", self.entryQueue.frontElt().timeInQueue
                self.entryQueue.dequeue()
                self.entryQueueLength[
                    self.elapsedTime] = self.entryQueue.length
                return True
            if (partition.size > int(size[0:-1])):
                partition.name = "Process " + number
                partition.duration = duration
                partition.status = "Processing"
                partition.space = [
                    partition.space[0], partition.space[0] + int(size[0:-1])
                ]
                newNextPartition = MyPartition(
                    "blank partition", partition.size - int(size[0:-1]), 0,
                    "Available", [
                        partition.space[0] + int(size[0:-1]),
                        partition.space[0] + partition.size
                    ])
                partition.size = int(size[0:-1])
                partition.nextPartition = newNextPartition
                newNextPartition.prevPartition = partition
                if (not (self.entryQueue.isEmpty())):
                    self.output += "=> Time spent in entry queue for job " + str(
                        self.entryQueue.frontElt().itemNumber) + ": " + str(
                            self.entryQueue.frontElt().timeInQueue) + "\n"
                    print "=> Time spent in entry queue for job ", self.entryQueue.frontElt(
                    ).itemNumber, ": ", self.entryQueue.frontElt().timeInQueue
                self.entryQueue.dequeue()
                self.entryQueueLength[
                    self.elapsedTime] = self.entryQueue.length
                return True

    '''
    look if there is some job in memory
    '''

    def lookForLastJob(self):
        partition = self.mainPartition
        foundJob = False

        # go through main partition
        while (partition):
            if (partition.status == "Processing"):
                lastJobInMemory = partition
                foundJob = True
            partition = partition.nextPartition
        if (foundJob):
            return lastJobInMemory
        return None

    '''
    check if there is partition after a specified partition 
    specified partition passed as argument
    '''

    def checkAvailableSpace(self, partition):
        temp = MyPartition("temp", 0)
        temp = partition
        if (temp.nextPartition == None):
            return False
        return True

    '''
    increment and decrement time 
    
    '''

    def updateMemory(self):
        # go through each job in memory and decrement duration
        temp = self.mainPartition
        while (temp):
            if (temp.status == "Processing"):
                temp.duration = int(temp.duration) - 1
            temp = temp.nextPartition

        # go through each job in entry queue and increment waiting time
        temp = MyElt()
        temp = self.entryQueue.frontElt()
        while (temp):
            temp.timeInQueue = int(temp.timeInQueue) + 1
            temp = temp.nextItem

        # increment elapsed time
        self.elapsedTime = int(self.elapsedTime) + 1

    '''
    Compute memory in use over time
    when memory cannot load the next job
    '''

    def findMemoryInUse(self):
        # go through each job in memory and decrement duration
        temp = self.mainPartition
        memoryInUse = 0
        while (temp):
            if (temp.status == "Processing"):
                memoryInUse += temp.size
            temp = temp.nextPartition
        return memoryInUse

    '''
    Find fragmentation in memory over time
    return number of fragmentation with average size
    '''

    def findFragmentation(self):
        # go through each job in memory and decrement duration
        temp = self.mainPartition
        numFrag = 0
        size = 0
        while (temp):
            if (temp.status == "Available"):
                numFrag += 1
                size += temp.size
            temp = temp.nextPartition
        if (numFrag > 0):
            averageSize = float(size) / numFrag
            return [numFrag, averageSize]
        return None

    '''
    remove job in memory when it is done
    check if the next or previous partition are blank and converge them if it is true
    '''

    def removeProcess(self, partition):
        temp = MyPartition("temp", 0)
        temp = partition
        temp.name = "blank partition"
        temp.duration = 0
        temp.status = "Available"
        if (temp.prevPartition != None):
            prevPart = MyPartition("temp", 0)
            prevPart = temp.prevPartition
            if (prevPart.status == "Available"):
                temp = self.combineBlankPartition(prevPart, temp)
        if (partition.nextPartition != None):
            nextPart = MyPartition("temp", 0)
            nextPart = temp.nextPartition
            if (nextPart.status == "Available"):
                temp = self.combineBlankPartition(temp, nextPart)
        # if there is no jobs processing in memory and partitions were not merged correctly
        if (not (self.hasJobProcessing())):
            self.mainPartition = MyPartition("blank partition", 12288, 0,
                                             "Available",
                                             [self.os, self.space])
            self.osPartition.nextPartition = self.mainPartition
            self.mainPartition.prevPartition = self.osPartition
        self.checkProcessIfDone()

    '''
    converge blank partition
    '''

    def combineBlankPartition(self, partition1, partition2):
        temp = MyPartition("temp", 0)
        temp = partition1
        partition1 = temp
        temp = partition2
        partition2 = temp
        if (partition1.status == "Available"
                and partition2.status == "Available"):
            if (partition1.space[1] == partition2.space[0]):
                partition1.nextPartition = partition2.nextPartition
                partition1.size += partition2.size
                partition1.space[1] = partition2.space[1]
                return partition1

    '''
    check if some jobs are done in memory or not
    if so, remove them and return True
    false otherwise
    '''

    def checkProcessIfDone(self):
        memoryPartition = self.mainPartition
        while (memoryPartition):
            if (memoryPartition.status == "Processing"):
                if (memoryPartition.duration == 0):
                    # computation of memory ratio goes HERE
                    memoryInUse = self.findMemoryInUse()
                    self.memoryRatio[self.elapsedTime] = memoryInUse

                    # calculation of fragmentation over time
                    fragmentation = self.findFragmentation()
                    if (fragmentation != None):
                        self.fragmentation[self.elapsedTime] = fragmentation

                    # increment job processed
                    self.jobProcessed = int(self.jobProcessed) + 1

                    self.removeProcess(memoryPartition)
                    return True
            memoryPartition = memoryPartition.nextPartition
        return False

    '''
    print content of memory 
    '''

    def printMemoryPartition(self):
        temp = self.osPartition
        # print ">> Name: \t\t\t Size: \t\t\t Status:"
        while (temp):
            print ">> ", temp.name, "\t\t\t", temp.size, "K\t\t\t", temp.status, "\t\t\t", temp.duration
            temp = temp.nextPartition
        print
        print "Job processed: ", self.jobProcessed
        print "Elapsed time: ", self.elapsedTime, "fortnights"
        return "Job processed: " + str(
            self.jobProcessed) + "\nElapsed time: " + str(
                self.elapsedTime) + "fortnights"

    '''
    check if memory still has some job processing
    return true, if it does
    false otherwise
    '''

    def hasJobProcessing(self):
        temp = self.mainPartition
        while (temp):
            if (temp.status == "Processing"):
                return True
            temp = temp.nextPartition
        return False

    '''
    Write data into a text file
    '''

    def writeDataFile(self, filename, content):
        try:
            f = open(filename, "w")
            f.write(content)
            f.close()
        except IOError:
            pass

    '''
    simulate memory management
    '''

    def simulation(self, process, algorithm):
        self.output += algorithm + ' Algorithm \n\n'
        while (process):
            if (algorithm == "First-Fit"):
                self.insertProcessFirstFit(process.itemNumber, process.size,
                                           process.duration)
            elif (algorithm == "Best-Fit"):
                self.insertProcessBestFit(process.itemNumber, process.size,
                                          process.duration)
            elif (algorithm == "Next-Fit"):
                self.insertProcessNextFit(process.itemNumber, process.size,
                                          process.duration)
            process = self.entryQueue.frontElt()
            # for debugging purpose
            # print
            # self.printMemoryPartition()
            # print

        while (self.hasJobProcessing()):
            self.checkProcessIfDone()
            if (self.hasJobProcessing()):
                self.updateMemory()
            # for debugging purpose
            # print
            # self.printMemoryPartition()
            # print

        # if there is no jobs processing in memory
        if (not (self.hasJobProcessing())):
            self.mainPartition = MyPartition("blank partition", 12288, 0,
                                             "Available",
                                             [self.os, self.space])
            self.osPartition.nextPartition = self.mainPartition
            self.mainPartition.prevPartition = self.osPartition

        # self.printMemoryPartition()

        throughput = float(self.jobProcessed) / self.elapsedTime

        print
        self.output += "\n" + self.printMemoryPartition() + "\n"
        self.output += str('\n=> Throughput: %4.2f \n\n' % throughput)
        # print '=> Throughput: %4.2f \n' % throughput

        for key, value in self.entryQueueLength.iteritems():
            # print '=> at t = ',key, ' fortnights: ', value, ' job in Entry Queue'
            self.output += '=> at t = ' + str(key) + ' fortnights: ' + str(
                value) + ' job in Entry Queue\n'

        print
        self.output += '\n'

        for key, value in self.memoryRatio.iteritems():
            # print '=> at t = ',key, ' fortnights:  %4.2f percent of memory in use. (main partition: OS excluded)' % ((float(value) /( self.space - self.os )) * 100)
            self.output += str(
                '=> at t = ' + str(key) +
                ' fortnights:  %4.2f percent of memory in use. (main partition: OS excluded)\n'
                % ((float(value) / (self.space - self.os)) * 100))

        print
        self.output += '\n'

        for key, value in self.fragmentation.iteritems():
            # print '=> at t = ',key, ' fortnights: \n\t- ', value[0], ' number of unused memory\n\t- ', value[1], 'k average size \n'
            self.output += '=> at t = ' + str(
                key) + ' fortnights: \n\t- ' + str(
                    value[0]) + ' number of unused memory\n\t- ' + str(
                        value[1]) + 'k average size \n'
コード例 #4
0
class ReadData():
    '''
    class used to read text file containing data
    '''

    def __init__(self, filename = "test_jobs.txt"):
        '''
        Constructor
        '''
        self.filename = filename
        self.entryQueue = MyQueue()
        
    '''
    Check if file exists or not
    '''
    def fileExists(self, filename):
        try:
            f = open(filename)
            f.close()
            return True
        except IOError:
            return False
    
    '''
    Read data from text file and store it in an instance of my Custom Queue
    Return Custom Queue object
    '''    
    def readDataFile(self, filename):
        if (self.fileExists(filename)):
            try:
                f = open(filename, "r")
                line = f.readline()
                
                while line != '':
                    line = line.strip()
                    
                    # for debugging purpose
                    # print line 
                    
                    # case : if blank line
                    if (len(line) == 0):
                        line = f.readline()
                        continue
                    # case : if comment line
                    if (line[0] == '#'):
                        line = f.readline()
                        continue
                    # case : if data line
                    jobProcess = line.split() 
                    if (len(jobProcess) > 3):
                        self.entryQueue.enqueue(jobProcess[0], jobProcess[1], jobProcess[2])
                   
                    # for debugging purpose
                    # print jobProcess
                    
                    line = f.readline()
                    
                f.close()
            except IOError:
                return "Cannot open File..."
        return "File is not found..."
コード例 #5
0
 def __init__(self, filename = "test_jobs.txt"):
     '''
     Constructor
     '''
     self.filename = filename
     self.entryQueue = MyQueue()
コード例 #6
0
class ReadData():
    '''
    class used to read text file containing data
    '''
    def __init__(self, filename="test_jobs.txt"):
        '''
        Constructor
        '''
        self.filename = filename
        self.entryQueue = MyQueue()

    '''
    Check if file exists or not
    '''

    def fileExists(self, filename):
        try:
            f = open(filename)
            f.close()
            return True
        except IOError:
            return False

    '''
    Read data from text file and store it in an instance of my Custom Queue
    Return Custom Queue object
    '''

    def readDataFile(self, filename):
        if (self.fileExists(filename)):
            try:
                f = open(filename, "r")
                line = f.readline()

                while line != '':
                    line = line.strip()

                    # for debugging purpose
                    # print line

                    # case : if blank line
                    if (len(line) == 0):
                        line = f.readline()
                        continue
                    # case : if comment line
                    if (line[0] == '#'):
                        line = f.readline()
                        continue
                    # case : if data line
                    jobProcess = line.split()
                    if (len(jobProcess) > 3):
                        self.entryQueue.enqueue(jobProcess[0], jobProcess[1],
                                                jobProcess[2])

                    # for debugging purpose
                    # print jobProcess

                    line = f.readline()

                f.close()
            except IOError:
                return "Cannot open File..."
        return "File is not found..."
コード例 #7
0
 def __init__(self, filename="test_jobs.txt"):
     '''
     Constructor
     '''
     self.filename = filename
     self.entryQueue = MyQueue()