Beberaa Tutorial dari packet Traceer
1. NTP Server dan Syslog Server
2. Access List Basic, tahap 1 dan tahap 2
access list tahap 1
access list tahap 2
IP Versi 6
di catatan ini mengenai IP versi 6
1. Konfigurasi Packet tracert host, switch, router menggunakan ipversi 6 , dengan ip publik versi 6 (GUA) dan ip lokal versi 6, LLA
Algortima Priority Scheduling
algortima priory scheduling
dengan bahasa phyton .
Kode masih di pelajari:
=======================
# Python3 implementation for Priority Scheduling with
# Different Arrival Time priority scheduling
"""1. sort the processes according to arrival time
2. if arrival time is same the acc to priority
3. apply fcfs """
totalprocess = 5
proc = []
for i in range(5):
l = []
for j in range(4):
l.append(0)
proc.append(l)
# Using FCFS Algorithm to find Waiting time
def get_wt_time( wt):
# declaring service array that stores
# cumulative burst time
service = [0] * 5
# Initilising initial elements
# of the arrays
service[0] = 0
wt[0] = 0
for i in range(1, totalprocess):
service[i] = proc[i - 1][1] + service[i - 1]
wt[i] = service[i] - proc[i][0] + 1
# If waiting time is negative,
# change it o zero
if(wt[i] < 0) :
wt[i] = 0
def get_tat_time(tat, wt):
# Filling turnaroundtime array
for i in range(totalprocess):
tat[i] = proc[i][1] + wt[i]
def findgc():
# Declare waiting time and
# turnaround time array
wt = [0] * 5
tat = [0] * 5
wavg = 0
tavg = 0
# Function call to find waiting time array
get_wt_time(wt)
# Function call to find turnaround time
get_tat_time(tat, wt)
stime = [0] * 5
ctime = [0] * 5
stime[0] = 1
ctime[0] = stime[0] + tat[0]
# calculating starting and ending time
for i in range(1, totalprocess):
stime[i] = ctime[i - 1]
ctime[i] = stime[i] + tat[i] - wt[i]
print("Process_no\tStart_time\tComplete_time",
"\tTurn_Around_Time\tWaiting_Time")
# display the process details
for i in range(totalprocess):
wavg += wt[i]
tavg += tat[i]
print(proc[i][3], "\t\t", stime[i],
"\t\t", end = " ")
print(ctime[i], "\t\t", tat[i], "\t\t\t", wt[i])
# display the average waiting time
# and average turn around time
print("Average waiting time is : ", end = " ")
print(wavg / totalprocess)
print("average turnaround time : " , end = " ")
print(tavg / totalprocess)
# Driver code
if __name__ =="__main__":
arrivaltime = [1, 2, 3, 4, 5]
bursttime = [3, 5, 1, 7, 4]
priority = [3, 4, 1, 7, 8]
for i in range(totalprocess):
proc[i][0] = arrivaltime[i]
proc[i][1] = bursttime[i]
proc[i][2] = priority[i]
proc[i][3] = i + 1
# Using inbuilt sort function
proc = sorted (proc, key = lambda x:x[2])
proc = sorted (proc)
# Calling function findgc for
# finding Gantt Chart
findgc()
# This code is contributed by
# Shubham Singh(SHUBHAMSINGH10)
===============================================
video menyusul ..
Algoritma Shortest Remaining Time First (SRTF)
kode ini masih belum sempurna...masih ada beda sedikit dengan manual,
tapi untuk memahami tidak masalah
[==============================================================
# Python3 program to implement Shortest Remaining Time First
# Shortest Remaining Time First (SRTF)
# Function to find the waiting time
# for all processes
def findWaitingTime(processes, n, wt):
rt = [0] * n
# Copy the burst time into rt[]
for i in range(n):
rt[i] = processes[i][1]
complete = 0
t = 0
minm = 999999999
short = 0
check = False
# Process until all processes gets
# completed
while (complete != n):
# Find process with minimum remaining
# time among the processes that
# arrives till the current time`
for j in range(n):
if ((processes[j][2] <= t) and
(rt[j] < minm) and rt[j] > 0):
minm = rt[j]
short = j
check = True
if (check == False):
t += 1
continue
# Reduce remaining time by one
rt[short] -= 1
# Update minimum
minm = rt[short]
if (minm == 0):
minm = 999999999
# If a process gets completely
# executed
if (rt[short] == 0):
# Increment complete
complete += 1
check = False
# Find finish time of current
# process
fint = t + 1
# Calculate waiting time
wt[short] = (fint - proc[short][1] -
proc[short][2])
if (wt[short] < 0):
wt[short] = 0
# Increment time
t += 1
# Function to calculate turn around time
def findTurnAroundTime(processes, n, wt, tat):
# Calculating turnaround time
for i in range(n):
tat[i] = processes[i][1] + wt[i]
# Function to calculate average waiting
# and turn-around times.
def findavgTime(processes, n):
wt = [0] * n
tat = [0] * n
# Function to find waiting time
# of all processes
findWaitingTime(processes, n, wt)
# Function to find turn around time
# for all processes
findTurnAroundTime(processes, n, wt, tat)
# Display processes along with all details
print("Processes Burst Time Waiting",
"Time Turn-Around Time")
total_wt = 0
total_tat = 0
for i in range(n):
total_wt = total_wt + wt[i]
total_tat = total_tat + tat[i]
print(" ", processes[i][0], "\t\t",
processes[i][1], "\t\t",
wt[i], "\t\t", tat[i])
print("\nAverage waiting time = %.5f "%(total_wt /n) )
print("Average turn around time = ", total_tat / n)
# Driver code
if __name__ =="__main__":
# Process id's
print ("algoritma Shortest Remaining Time First ")
print(" ")
proc = [[1, 6, 1], [2, 8, 1],
[3, 7, 2], [4, 4, 3]]
n = 4
findavgTime(proc, n)
# This code is contributed
# Shubham Singh(SHUBHAMSINGH10)
# modified by andrew @2020
================================================
Algortima Shortest Seek Time First
Algoritma Shortest Seek Time First (SSTF)
untuk penjadwlan Disk
dalam bahasa phyton, :
idenya adalah mencari posisi yang terdekat dari head. (titik awal ) ke proses proses selanjutnya.
Keuntungan dan kerugian dalam algoritma ini adalah
Advantages of Shortest Seek Time First (SSTF) –
- Better performance than FCFS scheduling algorithm.
- It provides better throughput.
- This algorithm is used in Batch Processing system where throughput is more important.
- It has less average response and waiting time.
Disadvantages of Shortest Seek Time First (SSTF) –
- Starvation is possible for some requests as it favours easy to reach request and ignores the far away processes.
- Their is lack of predictability because of high variance of response time.
- Switching direction slows things down.
Program dalam phyton
=============================================================
# Python3 program for implementation of
# SSTF disk scheduling
# Calculates difference of each
# track number with the head position
def calculateDifference(queue, head, diff):
for i in range(len(diff)):
diff[i][0] = abs(queue[i] - head)
# find unaccessed track which is
# at minimum distance from head
def findMin(diff):
index = -1
minimum = 999999999
for i in range(len(diff)):
if (not diff[i][1] and
minimum > diff[i][0]):
minimum = diff[i][0]
index = i
return index
def shortestSeekTimeFirst(request, head):
if (len(request) == 0):
return
l = len(request)
diff = [0] * l
# initialize array
for i in range(l):
diff[i] = [0, 0]
# count total number of seek operation
seek_count = 0
# stores sequence in which disk
# access is done
seek_sequence = [0] * (l + 1)
for i in range(l):
seek_sequence[i] = head
calculateDifference(request, head, diff)
index = findMin(diff)
diff[index][1] = True
# increase the total count
seek_count += diff[index][0]
# accessed track is now new head
head = request[index]
# for last accessed track
seek_sequence[len(seek_sequence) - 1] = head
print("Total number of seek operations =",
seek_count)
print("Seek Sequence is/ /Urutan Proses nya : ")
# print the sequence
for i in range(l + 1):
print(seek_sequence[i])
# Driver code
if __name__ =="__main__":
# request array
proc = [176, 79, 34, 60,
92, 11, 41, 114]
print("Data awal adalah ", proc)
print("Titik Awal di posisi 50 ")
print(" ")
shortestSeekTimeFirst(proc, 50)
# This code is contributed by
# Shubham Singh(SHUBHAMSINGH10)
# Modified by andrew @2020
============================================================
video youtube menyusul
Contoh Program Penjadwalan FIFO
Video
Contoh Penjadwalan FIFO (First In First Out)
Menggunakan Phyton
kode Program :
=====================================================================
# FIFO
# Python3 program for implementation
# of FCFS scheduling
# Function to find the waiting
# time for all processes
def findWaitingTime(processes, n,
bt, wt):
# waiting time for
# first process is 0
wt[0] = 0
# calculating waiting time
for i in range(1, n ):
wt[i] = bt[i - 1] + wt[i - 1]
# Function to calculate turn
# around time
def findTurnAroundTime(processes, n,
bt, wt, tat):
# calculating turnaround
# time by adding bt[i] + wt[i]
for i in range(n):
tat[i] = bt[i] + wt[i]
# Function to calculate
# average time
def findavgTime( processes, n, bt):
wt = [0] * n
tat = [0] * n
total_wt = 0
total_tat = 0
print ("Contoh First Come First Serve ")
print ("Waiting Time = Turn Around Time - Burst Time ")
# Function to find waiting
# time of all processes
findWaitingTime(processes, n, bt, wt)
# Function to find turn around
# time for all processes
findTurnAroundTime(processes, n,
bt, wt, tat)
# Display processes along
# with all details
print( "Processes Burst time " +
" Waiting time " +
" Turn around time")
# Calculate total waiting time
# and total turn around time
for i in range(n):
total_wt = total_wt + wt[i]
total_tat = total_tat + tat[i]
print(" " + str(i + 1) + "\t\t" +
str(bt[i]) + "\t " +
str(wt[i]) + "\t\t " +
str(tat[i]))
print( "Average waiting time = "+
str(total_wt / n))
print("Average turn around time = "+
str(total_tat / n))
# Driver code
if __name__ =="__main__":
# process id's
processes = [ 1, 2, 3]
n = len(processes)
# Burst time of all processes
burst_time = [10, 5, 8]
findavgTime(processes, n, burst_time)
# This code is contributed
# by ChitraNayal
#modified by andrew @2020
==================================================================
Video youtube menyusul
Sistem Operasi - Pemrograman Round Robin
Contoh Pemrograman Round Robin Dengan Phyton
Kode Phyton nya
====================================================
# Python3 program for implementation of
# RR scheduling
# Function to find the waiting time
# for all processes
def findWaitingTime(processes, n, bt,
wt, quantum):
rem_bt = [0] * n
# Copy the burst time into rt[]
for i in range(n):
rem_bt[i] = bt[i]
t = 0 # Current time
# Keep traversing processes in round
# robin manner until all of them are
# not done.
while(1):
done = True
# Traverse all processes one by
# one repeatedly
for i in range(n):
# If burst time of a process is greater
# than 0 then only need to process further
if (rem_bt[i] > 0) :
done = False # There is a pending process
if (rem_bt[i] > quantum) :
# Increase the value of t i.e. shows
# how much time a process has been processed
t += quantum
# Decrease the burst_time of current
# process by quantum
rem_bt[i] -= quantum
# If burst time is smaller than or equal
# to quantum. Last cycle for this process
else:
# Increase the value of t i.e. shows
# how much time a process has been processed
t = t + rem_bt[i]
# Waiting time is current time minus
# time used by this process
wt[i] = t - bt[i]
# As the process gets fully executed
# make its remaining burst time = 0
rem_bt[i] = 0
# If all processes are done
if (done == True):
break
# Function to calculate turn around time
def findTurnAroundTime(processes, n, bt, wt, tat):
# Calculating turnaround time
for i in range(n):
tat[i] = bt[i] + wt[i]
# Function to calculate average waiting
# and turn-around times.
def findavgTime(processes, n, bt, quantum):
wt = [0] * n
tat = [0] * n
# Function to find waiting time
# of all processes
findWaitingTime(processes, n, bt,
wt, quantum)
# Function to find turn around time
# for all processes
findTurnAroundTime(processes, n, bt,
wt, tat)
# Display processes along with all details
print("Processes Burst Time Waiting",
"Time Turn-Around Time")
total_wt = 0
total_tat = 0
for i in range(n):
total_wt = total_wt + wt[i]
total_tat = total_tat + tat[i]
print(" ", i + 1, "\t\t", bt[i],
"\t\t", wt[i], "\t\t", tat[i])
print ("quantum time = ", quantum)
print("\nAverage waiting time = %.5f "%(total_wt /n) )
print("Average turn around time = %.5f "% (total_tat / n))
# Driver code
if __name__ =="__main__":
# Process id's
proc = [1, 2, 3]
n = 3
# Burst time of all processes
burst_time = [8,4,6]
# Time quantum
quantum = 2;
findavgTime(proc, n, burst_time, quantum)
# This code is contributed by
# Shubham Singh(SHUBHAMSINGH10)
#modified by andrew fiade @2020
============================================================
Anda dapat menggunakan google colabs , dapat copy paste langsung .
Video Penjelasan
Subscribe to:
Posts (Atom)
-
Contoh Pemrograman Round Robin Dengan Phyton Kode Phyton nya ==================================================== # Python3 program for i...
-
Video Contoh Penjadwalan FIFO (First In First Out) Menggunakan Phyton kode Program : ===================================================...
-
CountIF = countif ( 'sep2022'!$F$7:$F$99 ; B3 ) hasil di sheet berbeda, B3 nilai string untuk perbandingan $ nilai tetap COUNT Rumu...
