# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY # # KIND, either express or implied. # ############################################################################### # # mmm.py # # Created by NJG on Fri, Apr 13, 2007 # import pdq # Parameters taken from mmm_sim.py file arrivalRate = 2.0 serviceTime = 1.0 pdq.Init("M/M/m in PyDQ") pdq.SetComment("Cf. SimPy Results.") pdq.streams = pdq.CreateOpen("work", arrivalRate) pdq.SetWUnit("Customers") pdq.SetTUnit("Seconds") pdq.nodes = pdq.CreateNode("server", 3, pdq.MSQ) pdq.SetDemand("server", "work", serviceTime) pdq.Solve(pdq.CANON) pdq.Report()
#---- Model specific variables --------------------------------------- pop = 3.0 think = 0.1 #---- Initialize the model ------------------------------------------- # Give model a name and initialize internal PDQ variables pdq.Init("Closed Queue") #print "**** %s ****:" % (solve_as == pdq.EXACT ? "EXACT" : "APPROX") #--- Define the workload and circuit type ---------------------------- pdq.streams = pdq.CreateClosed("w1", pdq.TERM, 1.0 * pop, think) #--- Define the queueing center -------------------------------------- pdq.nodes = pdq.CreateNode("node", pdq.CEN, pdq.FCFS) #---- Define service demand ------------------------------------------ pdq.SetDemand("node", "w1", 0.10) pdq.Solve(pdq.APPROX) pdq.Report() #---------------------------------------------------------------------
sys.stderr.write("*** Trace state *** \n%s\n***\n" % "".join(L)) sys.exit(1) # PDQ modeling code starts here ... jNet = JackNet("SimPy Jackson Network", 1) # create an instance pdq.Init(jNet.name) pdq.SetWUnit("Msgs") pdq.SetTUnit("Time") # Create PDQ context and workload for the network streams = pdq.CreateOpen(jNet.work, jNet.arrivRate) # Create PDQ queues for i in range(len(jNet.router)): nodes = pdq.CreateNode(jNet.router[i], pdq.CEN, pdq.FCFS) pdq.SetVisits(jNet.router[i], jNet.work, jNet.visitRatio[i], \ jNet.servTime[i]) # Solve the model and report the peformance measures pdq.Solve(pdq.CANON) pdq.Report() # generic PDQ format # Collect particular PDQ statistics print "---------- Selected PDQ Metrics for SimPy Comparison ---------" for i in range(len(jNet.router)): msgs = pdq.GetQueueLength(jNet.router[i], jNet.work, pdq.TRANS) print "Mean queue%d: %7.4f (%s)" % (i + 1, msgs, "Not in SimPy report") jNet.totalMsgs += msgs print "Mean number: %7.4f" % jNet.totalMsgs
for i in range(MF_DISKS): demand[(MF_CD, MDarray[i].id)] = (2.0 / 60.24) / MF_DISKS demand[(MF_RQ, MDarray[i].id)] = (4.0 / 60.24) / MF_DISKS demand[(MF_SU, MDarray[i].id)] = (1.0 / 60.24) / MF_DISKS # demand.dump() #----- Start building the PDQ model -------------------------------------------- pdq.Init(scenario) # Define physical resources as queues ... no_nodes = pdq.CreateNode("PC", pdq.CEN, pdq.FCFS) no_nodes = pdq.CreateNode("FS", pdq.CEN, pdq.FCFS) for i in range(FS_DISKS): no_nodes = pdq.CreateNode(FDarray[i].label, pdq.CEN, pdq.FCFS) no_nodes = pdq.CreateNode("GW", pdq.CEN, pdq.FCFS) no_nodes = pdq.CreateNode("MF", pdq.CEN, pdq.FCFS) for i in range(MF_DISKS): no_nodes = pdq.CreateNode(MDarray[i].label, pdq.CEN, pdq.FCFS) no_nodes = pdq.CreateNode("TR", pdq.CEN, pdq.FCFS) # NOTE: Althought the Token Ring LAN is a passive computational device, # it is treated as a separate node so as to agree to the results
#!/usr/bin/env python ############################################################################### # Copyright (C) 1994 - 2009, Performance Dynamics Company # # # # This software is licensed as described in the file COPYING, which # # you should have received as part of this distribution. The terms # # are also available at http://www.perfdynamics.com/Tools/copyright.html. # # # # You may opt to use, copy, modify, merge, publish, distribute and/or sell # # copies of the Software, and permit persons to whom the Software is # # furnished to do so, under the terms of the COPYING file. # # # # This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY # # KIND, either express or implied. # ############################################################################### # # M/M/1 in PyDQ import pdq pdq.Init("Python Test Script") pdq.nodes = pdq.CreateNode("Deadhorse", pdq.CEN, pdq.FCFS) pdq.streams = pdq.CreateOpen("Floggit", 0.75) pdq.SetWUnit("Cust") pdq.SetTUnit("Min") pdq.SetDemand("Deadhorse", "Floggit", 1.0) pdq.Solve(pdq.CANON) pdq.Report()
#---- Initialize ----------------------------------------------------- pdq.Init("OpenCenter") pdq.SetComment("A simple M/M/1 queue") #---- Define the workload and circuit type --------------------------- pdq.streams = pdq.CreateOpen("work", arrivRate) pdq.SetWUnit("Customers") pdq.SetTUnit("Seconds") #---- Define the queueing center ------------------------------------- pdq.nodes = pdq.CreateNode("server", pdq.CEN, pdq.FCFS) #---- Define service demand due to workload on the queueing center --- pdq.SetDemand("server", "work", service_time) #---- Solve the model ------------------------------------------------ # Must use the CANONical method for an open circuit pdq.Solve(pdq.CANON) #---- Generate a report ---------------------------------------------- pdq.Report() #---------------------------------------------------------------------
# copies of the Software, and permit persons to whom the Software is # # furnished to do so, under the terms of the COPYING file. # # # # This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY # # KIND, either express or implied. # ############################################################################### # # Created by NJG on Wed, Apr 18, 2007 # # # $Id: orca.py,v 1.2 2009/03/26 02:55:32 pfeller Exp $ import pdq # Measured parameters servers = 4 arivrate = 0.099 # per hr servtime = 10.0 # hrs pdq.Init("ORCA Batch") nstreams = pdq.CreateOpen("Crunch", arivrate) pdq.SetWUnit("Jobs") pdq.SetTUnit("Hours") nnodes = pdq.CreateNode("HPC", int(servers), pdq.MSQ) pdq.SetDemand("HPC", "Crunch", servtime) pdq.Solve(pdq.CANON) pdq.Report()
#pop = 200.0 pop = 100.0 think = 300.0 servt = 0.63 ##### Initialize the model giving it a name ########################## pdq.Init("Time Share Computer") pdq.SetComment("This is just a simple M/M/1 queue.") ##### Define the workload and circuit type ########################### pdq.streams = pdq.CreateClosed("compile", pdq.TERM, pop, think) ##### Define the queueing center ##################################### pdq.nodes = pdq.CreateNode("CPU", pdq.CEN, pdq.FCFS) ##### Define service demand ########################################## pdq.SetDemand("CPU", "compile", servt) ##### Solve the model ################################################ pdq.Solve(pdq.EXACT) pdq.Report() #---------------------------------------------------------------------
importrs = 300 Sifp = 0.10 Samp = 0.60 Sdsu = 1.20 Nifp = 15 Namp = 50 Ndsu = 100 pdq.Init("Teradata DBC-10/12") # Create parallel centers for k in range(Nifp): name = "IFP%d" % k nodes = pdq.CreateNode(name, pdq.CEN, pdq.FCFS) for k in range(Namp): name = "AMP%d" % k nodes = pdq.CreateNode(name, pdq.CEN, pdq.FCFS) for k in range(Ndsu): name = "DSU%d" % k nodes = pdq.CreateNode(name, pdq.CEN, pdq.FCFS) streams = pdq.CreateClosed("query", pdq.TERM, importrs, think) # pdq.SetGraph("query", 100) - unsupported call for k in range(Nifp): name = "IFP%d" % k
from math import * arrivalRate = 40.0/60 # cust per min browseTime = 45.0 # mins buyingTime = 4.0 # mins cashiers = 3 pdq.Init("Big Book Store Model") # Create an open circuit Jackson network streams = pdq.CreateOpen("Customers", arrivalRate) pdq.SetWUnit("Cust") pdq.SetTUnit("Min") # timebase for PDQ report #*** New MSQ flag tells PDQ the following are multiserver nodes *** # M/M/inf queue defined as 100 times the number of Erlangs = lambda * S nodes = pdq.CreateNode("Browsing", int(ceil(arrivalRate * browseTime)) * 100, pdq.MSQ) # M/M/m where m is the number of cashiers nodes = pdq.CreateNode("Checkout", cashiers, pdq.MSQ) # Set service times ... pdq.SetDemand("Browsing", "Customers", browseTime) pdq.SetDemand("Checkout", "Customers", buyingTime) pdq.Solve(pdq.CANON) pdq.Report()
msg = priOn else: msg = noPri #--------------------------------------------------------------------- pdq.Init(msg) #---- Workloads ------------------------------------------------------ pdq.streams = pdq.CreateClosed("Production", pdq.TERM, 20.0, 20.0) pdq.streams = pdq.CreateClosed("Developmnt", pdq.TERM, 15.0, 15.0) #---- Nodes ---------------------------------------------------------- pdq.nodes = pdq.CreateNode("CPU", pdq.CEN, pdq.FCFS) if (PRIORITY): pdq.nodes = pdq.CreateNode("shadCPU", pdq.CEN, pdq.FCFS) pdq.nodes = pdq.CreateNode("DK1", pdq.CEN, pdq.FCFS) pdq.nodes = pdq.CreateNode("DK2", pdq.CEN, pdq.FCFS) #---- Service demands at each node ----------------------------------- pdq.SetDemand("CPU", "Production", 0.30) if (PRIORITY): pdq.SetDemand("shadCPU", "Developmnt", 1.00 / (1 - Ucpu_prod)) else: pdq.SetDemand("CPU", "Developmnt", 1.00)
import pdq L = 50 S = 0.01 pdq.Init("example 7") nodes = pdq.CreateNode("Kanal", pdq.CEN, pdq.FCFS) stream = pdq.CreateOpen("Poruka", L) pdq.SetVisits("Kanal", "Poruka", 1.0 / 0.7, S) # pdq.SetDemand("Kanal", "Poruka", S) pdq.Solve(pdq.CANON) pdq.Report()
############################################################################### # # Created by NJG on Thu, May 31, 2007 # # Blair Zajac, author of Orca states: # "If long term trends indicate increasing figures, more or faster CPUs # will eventually be necessary unless load can be displaced. For ideal # utilization of your CPU, the maximum value here should be equal to the # number of CPUs in the box." # # Zajac's comment implies any waiting line is bad. # PDQ steady-state model for HPC/batch workload with # stretch factor == 1 (no waiting line). # Very low arrival rate over 10 hour period. import pdq processors = 4 arrivalRate = 0.099 # jobs per hour (very low arrivals) crunchTime = 10.0 # hours (very long service time) pdq.Init("ORCA LA Model") s = pdq.CreateOpen("Crunch", arrivalRate) n = pdq.CreateNode("HPCnode", int(processors), pdq.MSQ) pdq.SetDemand("HPCnode", "Crunch", crunchTime) pdq.SetWUnit("Jobs") pdq.SetTUnit("Hour") pdq.Solve(pdq.CANON) pdq.Report()
# Service times in seconds S = array([20, 600, 300, 60]) # Service demands in seconds D = array([v[0] * S[0], v[1] * S[1], v[2] * S[2], v[3] * S[3]]) """ Use the service demands derived from the solved traffic equations to parameterize and solve PyDQ queueing model of the passport office """ # Initialize and solve the model pdq.Init("Passport Office") numStreams = pdq.CreateOpen("Applicant", L[0]) numNodes = pdq.CreateNode("Window0", pdq.CEN, pdq.FCFS) numNodes = pdq.CreateNode("Window1", pdq.CEN, pdq.FCFS) numNodes = pdq.CreateNode("Window2", pdq.CEN, pdq.FCFS) numNodes = pdq.CreateNode("Window3", pdq.CEN, pdq.FCFS) pdq.SetDemand("Window0", "Applicant", D[0]) pdq.SetDemand("Window1", "Applicant", D[1]) pdq.SetDemand("Window2", "Applicant", D[2]) pdq.SetDemand("Window3", "Applicant", D[3]) pdq.Solve(pdq.CANON) pdq.Report() # Utilizations: L_0 * D_k r = array([L[0] * D[0], L[0] * D[1], L[0] * D[2], L[0] * D[3]])
# Test Exact.c lib # # From A.Allen Example 6.3.4, p.413 #--------------------------------------------------------------------- pdq.Init("Multiclass Test") #---- Define the workload and circuit type --------------------------- pdq.streams = pdq.CreateClosed("term1", pdq.TERM, 5.0, 20.0) pdq.streams = pdq.CreateClosed("term2", pdq.TERM, 15.0, 30.0) pdq.streams = pdq.CreateClosed("batch", pdq.BATCH, 5.0, 0.0) #---- Define the queueing center ------------------------------------- pdq.nodes = pdq.CreateNode("node1", pdq.CEN, pdq.FCFS) pdq.nodes = pdq.CreateNode("node2", pdq.CEN, pdq.FCFS) pdq.nodes = pdq.CreateNode("node3", pdq.CEN, pdq.FCFS) #---- Define service demand ------------------------------------------ pdq.SetDemand("node1", "term1", 0.50) pdq.SetDemand("node1", "term2", 0.04) pdq.SetDemand("node1", "batch", 0.06) pdq.SetDemand("node2", "term1", 0.40) pdq.SetDemand("node2", "term2", 0.20) pdq.SetDemand("node2", "batch", 0.30) pdq.SetDemand("node3", "term1", 1.20) pdq.SetDemand("node3", "term2", 0.05)
Pcpu = 0.0 Ubrd = 0.0 Ubwr = 0.0 Ubin = 0.0 Ucht = 0.0 Ucrd = 0.0 Ucwr = 0.0 Ucin = 0.0 #--------------------------------------------------------------------- pdq.Init("ABC Model") #----- Create single bus queueing center ----------------------------- nodes = pdq.CreateNode(BUS, pdq.CEN, pdq.FCFS) #----- Create per CPU cache queueing centers ------------------------- for i in range(MAXCPU): cname = "%s%d" % (L2C, i) nodes = pdq.CreateNode(cname, pdq.CEN, pdq.FCFS) #----- Create CPU nodes, workloads, and demands ---------------------- (no, Wrwht) = intwt(Nrwht) print "no %d %f Nrwht %d, Wrwht %d" % (no, no, Nrwht, Wrwht) for i in range(no): wname = "%s%d" % (RWHT, i)
# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY # # KIND, either express or implied. # ############################################################################### # # Created by NJG on Wed, Apr 18, 2007 # # Queueing model of an email-spam analyzer system comprising a # battery of SMP servers essentially running in batch mode. # Each node was a 4-way SMP server. # The performance metric of interest was the mean queue length. # # This simple M/M/4 model gave results that were in surprisingly # good agreement with monitored queue lengths. # # $Id: spamcan.py,v 1.2 2009/03/26 02:55:32 pfeller Exp $ import pdq # Measured parameters servers = 4 arivrate = 0.66 # per min servtime = 6.0 # seconds pdq.Init("SPAM Analyzer") nstreams = pdq.CreateOpen("Email", arivrate) nnodes = pdq.CreateNode("spamCan", int(servers), pdq.MSQ) pdq.SetDemand("spamCan", "Email", servtime) pdq.Solve(pdq.CANON) pdq.Report()
p12 = 0.30 p13 = 0.70 p23 = 0.20 p32 = 0.10 w3 = (p13 + p23 * p12) / (1 - p23 * p32) w2 = p12 + p32 * w3 #---- Initialize and solve the model --------------------------------- pdq.Init("Passport Office") pdq.streams = pdq.CreateOpen("Applicant", 0.00427) pdq.nodes = pdq.CreateNode("Window1", pdq.CEN, pdq.FCFS) pdq.nodes = pdq.CreateNode("Window2", pdq.CEN, pdq.FCFS) pdq.nodes = pdq.CreateNode("Window3", pdq.CEN, pdq.FCFS) pdq.nodes = pdq.CreateNode("Window4", pdq.CEN, pdq.FCFS) pdq.SetDemand("Window1", "Applicant", 20.0) pdq.SetDemand("Window2", "Applicant", 600.0 * w2) pdq.SetDemand("Window3", "Applicant", 300.0 * w3) pdq.SetDemand("Window4", "Applicant", 60.0) pdq.Solve(pdq.CANON) pdq.Report() #---------------------------------------------------------------------
# KIND, either express or implied. # ############################################################################### # # Created by NJG on Wed, Apr 18, 2007 # # Queueing model of an email-spam analyzer system comprising a # battery of SMP servers essentially running in batch mode. # Each node was a 4-way SMP server. # The performance metric of interest was the mean queue length. # # This simple M/M/4 model gave results that were in surprisingly # good agreement with monitored queue lengths. # # $Id: spamcan1.py,v 1.2 2009/03/31 00:48:34 pfeller Exp $ import pdq # Measured performance parameters cpusPerServer = 4 emailThruput = 2376 # emails per hour scannerTime = 6.0 # seconds per email pdq.Init("Spam Farm Model") # Timebase is SECONDS ... nstreams = pdq.CreateOpen("Email", float(emailThruput) / 3600) nnodes = pdq.CreateNode("spamCan", int(cpusPerServer), pdq.MSQ) pdq.SetDemand("spamCan", "Email", scannerTime) pdq.Solve(pdq.CANON) pdq.Report()
#--------------------------------------------------------------------- # Based on open_feedback rx_prob = 0.30 inter_arriv_rate = 0.5 service_time = 0.75 mean_visits = 1.0 / (1.0 - rx_prob) #----- Initialize the model ------------------------------------------ pdq.Init("Open Feedback") #---- Define the queueing center ------------------------------------- pdq.nodes = pdq.CreateNode("channel", pdq.CEN, pdq.FCFS) #---- Define the workload and circuit type --------------------------- pdq.streams = pdq.CreateOpen("message", inter_arriv_rate) #---- Define service demand due to workload on the queueing center --- pdq.SetVisits("channel", "message", mean_visits, service_time) #---- Must import the CANONical method for an open circuit ----------- pdq.Solve(pdq.CANON) pdq.Report()