[Python]磁盘调度算法FCFS,SSTF,SCAN,CSCAN

1、先来先服务（FCFS）

FCFS算法根据进程请求访问磁盘的先后顺序进行调度，这是一种最简单的调度算法。

此算法的优点是公平、简单，每个进程的请求都能依此得到处理，但缺点是磁头移动的距离和平均移动距离会很大。

2、最短寻道时间优先（SSTF）

 SSTF算法选择调度处理的磁道是与当前磁头所在磁道距离最近的磁道，以使每次的寻找时间最短。

当然，总是选择最小寻找时间并不能保证平均寻找时间最小，但是能提供比FCFS算法更好的性能。

3、扫描算法（SCAN）

SCAN算法在磁头当前移动方向上选择与当前磁头所在磁道距离最近的请求作为下一次服务的对象。

4、循环扫描算法（CSCAN）

在扫描算法的基础上规定磁头单向移动来提供服务，回返时直接快速移动至起始端而不服务任何请求。

data:

100
55 58 39 18 90 160 150 38 184

FCFS：

def loaddata(fileName):
    f = open(fileName)
    start = f.readline()
    data = f.readline()
    return start, data


def loadNext(now, next):
    length = abs(int(now) - int(next))
    print(next, length)
    return length



l = 0
start, data = loaddata('data')
for d in data.split():
    l += loadNext(start, d)
    start = d
n = len(data.split())
print("FIFO:平均寻道长度：%.1f" %(l/n))

SSTF:

def loaddata(fileName):
    f = open(fileName)
    start = f.readline()
    data = f.readline()
    return start, data

def findNextIndex(start,datas):
    length = []
    for data in datas:
        l = abs(int(start) - int(data))
        length.append(l)
    minIndex = length.index(min(length))
    return minIndex

def loadNext(now, next):
    length = abs(int(now) - int(next))
    print(next, length)
    return length

l = 0
start,data = loaddata('data')
data2 = data.split().copy()
n = len(data2)
for d in data.split():
    nextIndex = findNextIndex(start,data2)
    l += loadNext(start,data2[nextIndex])
    start = data2[nextIndex]
    data2.remove(data2[nextIndex])

print("FIFO:平均寻道长度：%.1f" %(l/n))

SCAN:

def loaddata(fileName):
    f = open(fileName)
    start = f.readline()
    data = f.readline()
    return start, data


def loadNext(now, next):
    length = abs(int(now) - int(next))
    print(next, length)
    return length

def findNext(now,data):
    biggerList = []
    smallerList = []
    for d in data:
        if int(d) > int(now):
            biggerList.append(d)
    if (len(biggerList)==0):
        if len(data)!=0:
            for d2 in data:
                if int(d2)<int(now):
                    smallerList.append(d2)
            return max(smallerList)
        else:
            return None
    return min(biggerList)



l = 0
start,data = loaddata('data')
data2 = data.split().copy()
n = len(data2)
for d in data :
    next = findNext(start,data2)
    if next == None:
        break
    l += loadNext(start,next)
    start = next
    data2.remove(next)
print("FIFO:平均寻道长度：%.1f" %(l/n))

CSCAN:

def loaddata(fileName):
    f = open(fileName)
    start = f.readline()
    data = f.readline()
    return start, data


def loadNext(now, next):
    length = abs(int(now) - int(next))
    print(next, length)
    return length

def findNext(now,data):
    biggerList = []
    smallerList = []
    for d in data:
        if int(d) > int(now):
            biggerList.append(d)
    if (len(biggerList)==0):
        if len(data) != 0:
            now = 0
            return(findNext(now,data))
        else:
            return None
    return min(biggerList)



l = 0
start,data = loaddata('data')
data2 = data.split().copy()
n = len(data2)
for d in data :
    next = findNext(start,data2)
    if next == None:
        break
    l += loadNext(start,next)
    start = next
    data2.remove(next)
print("FIFO:平均寻道长度：%.1f" %(l/n))