def GetProdU():
pdq.Init("")
pdq.streams = pdq.CreateClosed("Production", pdq.TERM, 20.0, 20.0)
pdq.nodes = pdq.CreateNode("CPU", pdq.CEN, pdq.FCFS)
pdq.nodes = pdq.CreateNode("DK1", pdq.CEN, pdq.FCFS)
pdq.nodes = pdq.CreateNode("DK2", pdq.CEN, pdq.FCFS)
pdq.SetDemand("CPU", "Production", 0.30)
pdq.SetDemand("DK1", "Production", 0.08)
pdq.SetDemand("DK2", "Production", 0.10)
pdq.Solve(pdq.APPROX)
return (pdq.GetUtilization("CPU", "Production", pdq.TERM))
def multiserver(m, stime):
work = "reqs"
node = "bus"
x = 0.0
for i in range(1, CPUS + 1):
if (i <= m):
pdq.Init("multibus")
streams = pdq.CreateClosed(work, pdq.TERM, i, 0.0)
nodes = pdq.CreateNode(node, pdq.CEN, pdq.ISRV)
pdq.SetDemand(node, work, stime)
pdq.Solve(pdq.EXACT)
x = pdq.GetThruput(pdq.TERM, work)
sm_x[i] = x
else:
sm_x[i] = x
def mem_model(n, m):
x = 0.0
for i in range(1, n + 2):
if (i <= m):
pdq.Init("")
pdq.nodes = pdq.CreateNode("CPU", pdq.CEN, pdq.FCFS)
pdq.nodes = pdq.CreateNode("DK1", pdq.CEN, pdq.FCFS)
pdq.nodes = pdq.CreateNode("DK2", pdq.CEN, pdq.FCFS)
pdq.streams = pdq.CreateClosed("work", pdq.TERM, i, 0.0)
pdq.SetDemand("CPU", "work", 3.0)
pdq.SetDemand("DK1", "work", 4.0)
pdq.SetDemand("DK2", "work", 2.0)
pdq.Solve(pdq.EXACT)
x = pdq.GetThruput(pdq.TERM, "work")
sm_x.append(x)
else:
sm_x.append(x) # last computed value
#
#---------------------------------------------------------------------
import pdq
#---------------------------------------------------------------------
# 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 -----------
###############################################################################
#
# $Id: open1.py,v 1.3 2009/03/26 02:55:32 pfeller Exp $
#
#---------------------------------------------------------------------
import pdq
arrivalRate = 0.75
serviceTime = 1.0
#---- Initialize the system ------------------------------------------
pdq.Init("Open Center in PyDQ")
pdq.SetComment("This is just a simple M/M/1 queue.");
pdq.nodes = pdq.CreateNode("server", pdq.CEN, pdq.FCFS)
pdq.streams = pdq.CreateOpen("work", arrivalRate)
pdq.SetWUnit("Customers")
pdq.SetTUnit("Seconds")
pdq.SetDemand("server", "work", serviceTime)
pdq.Solve(pdq.CANON)
#
# Based on time_share.c
#
# Illustrates PDQ solver for closed uni-server queue. Compare with repair.c
#
##### Model specific variables #######################################
#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 ################################################
break
#---------------------------------------------------------------------
think = 10.0
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)
#
# open1msq.py
#
# Created by NJG on Fri, Apr 13, 2007 (test MSQ vs. M/M/1 in PyDQ)
#
# $Id: open1msq.py,v 1.2 2009/03/26 02:55:32 pfeller Exp $
#
#---------------------------------------------------------------------
import pdq
arrivalRate = 0.75
serviceTime = 1.0
pdq.Init("Open1 MSQ Test")
pdq.SetComment("Cf. M/M/1/FCFS against MSQ with m=1 in PyDQ.")
pdq.streams = pdq.CreateOpen("work", arrivalRate)
pdq.SetWUnit("Customers")
pdq.SetTUnit("Seconds")
pdq.nodes = pdq.CreateNode("MM1", pdq.CEN, pdq.FCFS)
pdq.nodes = pdq.CreateNode("MMm", 1, pdq.MSQ)
pdq.SetDemand("MM1", "work", serviceTime)
pdq.SetDemand("MMm", "work", serviceTime)
pdq.Solve(pdq.CANON)
#---------------------------------------------------------------------
# Prevent this program from loading pdq.py in this directory
import sys
del sys.path[0]
import pdq
#---- Define globals -------------------------------------------------
arrivRate = 0.75
service_time = 1.0
#---- 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 ---
# 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()
demand[(CD_Msg, FDarray[i].id)] = (1.0 * 0.5 / 128.9) / FS_DISKS
demand[(RQ_Msg, FDarray[i].id)] = (1.5 * 0.5 / 128.9) / FS_DISKS
demand[(SU_Msg, FDarray[i].id)] = (0.5 * 0.5 / 128.9) / FS_DISKS
# Mainframe DASD I/Os = (#accesses / (max IOs/Sec)) / #disks
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)
# 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()
# 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()
#
# $Id: mc-test.py,v 4.3 2009/03/26 02:55:32 pfeller Exp $
#
#---------------------------------------------------------------------
import pdq
#---------------------------------------------------------------------
# Based on multiclass-test.c
#
# 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 ------------------------------------------
dbstr3 = "Visits: %5.4f %5.4f %5.4f" % (self.visitRatio[0], \
self.visitRatio[1], self.visitRatio[2])
ShowState("%s\n%s\n%s\n%s" % (dbstr0, dbst1, dbstr2, dbstr3))
def ShowState(*L):
""" L is a list of strings. Displayed by sys.stderr as concatenated
elements of L and then stops execution
"""
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()
#---- Initialize the model -----------------------------------------------------
tech = pdq.APPROX
if (tech == pdq.EXACT):
technique = "EXACT"
else:
technique = "APPROX"
print "**** %s Solution ****:\n" % technique
print " N R (w1) R (w2)"
for pop in range(1, 10):
pdq.Init("Test_Exact_calc")
#---- Define the workload and circuit type ----------------------------------
pdq.streams = pdq.CreateClosed("w1", pdq.TERM, 1.0 * pop, think)
pdq.streams = pdq.CreateClosed("w2", pdq.TERM, 1.0 * pop, think)
#---- Define the queueing center --------------------------------------------
pdq.nodes = pdq.CreateNode("node", pdq.CEN, pdq.FCFS)
#---- service demand --------------------------------------------------------
pdq.SetDemand("node", "w1", 1.0)
pdq.SetDemand("node", "w2", 0.5)
#!/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()
Zinvl = ZX
Zwthr = ZX
Xcpu = 0.0
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)
#
# 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()
import pdq
# Based on closed.c
#
# Illustrate use of PDQ solver for a closed circuit queue.
#---- 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 ------------------------------------------
Created by NJG on Fri, Apr 13, 2007
PDQ model using 2 MSQ nodes in tandem.
"""
import pdq
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)
pdq.Solve(pdq.APPROX)
return (pdq.GetUtilization("CPU", "Production", pdq.TERM))
#---------------------------------------------------------------------
if (PRIORITY):
Ucpu_prod = GetProdU()
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)
#
# $Id$
#
#---------------------------------------------------------------------
import pdq
#---------------------------------------------------------------------
# Based on simple_series_circuit.c
#
# An open queueing circuit with 3 centers.
arrivals_per_second = 0.10
pdq.Init("Simple Series Circuit")
pdq.streams = pdq.CreateOpen("Work", arrivals_per_second)
pdq.nodes = pdq.CreateNode("Center1", pdq.CEN, pdq.FCFS)
pdq.nodes = pdq.CreateNode("Center2", pdq.CEN, pdq.FCFS)
pdq.nodes = pdq.CreateNode("Center3", pdq.CEN, pdq.FCFS)
pdq.SetDemand("Center1", "Work", 1.0)
pdq.SetDemand("Center2", "Work", 2.0)
pdq.SetDemand("Center3", "Work", 3.0)
pdq.Solve(pdq.CANON)
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()
v = array([L[0]/L[0], L[1]/L[0], L[2]/L[0], L[3]/L[0]])
print "Visit ratios: ", v[0], v[1], v[2], v[3]
# 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();
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()
