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 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
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
#
# 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()
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
pdq.SetDemand(name, "query", Sifp / Nifp)
for k in range(Namp):
name = "AMP%d" % k
pdq.SetDemand(name, "query", Samp / Namp)
for k in range(Ndsu):
name = "DSU%d" % k
pdq.SetDemand(name, "query", Sdsu / Ndsu)
# 300 nodes takes about a minute to solve on a PowerMac
print("Solving ... ")
pdq.Solve(pdq.EXACT)
# 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()
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)
streams = pdq.CreateClosed(wname, pdq.TERM, Nrwht, Zrwht)
cname = "%s%d" % (L2C, i)
pdq.SetDemand(cname, wname, 1.0)
pdq.SetDemand(BUS, wname, 0.0) # no bus activity
print "i %2d cname %10s nodes %2d streams %d" % (i, cname, nodes,
streams)
(no, Wrdop) = intwt(Nrdop)
print "no %d Nrdop %d, Wrdop %d" % (no, Nrdop, Wrdop)
for i in range(no):
wname = "%s%d" % (RDOP, i)
streams = pdq.CreateClosed(wname, pdq.TERM, Nrdop, Zrdop)
cname = "%s%d" % (L2C, i)
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()
#---------------------------------------------------------------------
comment = pdq.GetComment()
print 'pdq.GetComment -> \"%s\"' % comment
# $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)
print "Using: %s" % pdq.version
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()
# 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()
#---- 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)
pdq.SetDemand("node3", "batch", 0.06)
#---- Solve it -------------------------------------------------------
pdq.Solve(pdq.EXACT)
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)
#---- Solve the model -------------------------------------------------------
pdq.Solve(tech)
print "%3.0f %8.4f %8.4f" % (pop,
pdq.GetResponse(pdq.TERM, "w1"),
pdq.GetResponse(pdq.TERM, "w2"));
#!/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()
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()
#---------------------------------------------------------------------
txCD = "CatDsply"
txRQ = "RemQuote"
txSU = "StatusUp"
#----- Define an OPEN circuit aggregate workload -------------------------------
no_streams = pdq.CreateOpen(txCD, USERS * 4.0 / 60.0)
no_streams = pdq.CreateOpen(txRQ, USERS * 8.0 / 60.0)
no_streams = pdq.CreateOpen(txSU, USERS * 1.0 / 60.0)
#-------------------------------------------------------------------------------
# Define the service demands on each physical resource ...
# CD request + reply chain from workflow diagram
#-------------------------------------------------------------------------------
pdq.SetDemand("PC", txCD, demand[(CD_Req, PC)] + (5 * demand[(CD_Rpy, PC)]))
pdq.SetDemand("FS", txCD, demand[(Req_CD, FS)] + (5 * demand[(CD_Msg, FS)]))
for i in range(FS_DISKS):
pdq.SetDemand(
FDarray[i].label, txCD, demand[(Req_CD, FDarray[i].id)] +
(5 * demand[(CD_Msg, FDarray[i].id)]))
pdq.SetDemand("GW", txCD, demand[(GT_Snd, GW)] + (5 * demand[(GT_Rcv, GW)]))
pdq.SetDemand("MF", txCD, demand[(MF_CD, MF)])
for i in range(MF_DISKS):
pdq.SetDemand(MDarray[i].label, txCD, demand[(MF_CD, MDarray[i].id)])
#-------------------------------------------------------------------------------
# NOTE: Synchronous process execution caimports data for the CD
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()
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()
#---------------------------------------------------------------------
# $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()
#---------------------------------------------------------------------
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)
pdq.SetDemand("DK1", "Production", 0.08)
pdq.SetDemand("DK1", "Developmnt", 0.05)
pdq.SetDemand("DK2", "Production", 0.10)
pdq.SetDemand("DK2", "Developmnt", 0.06)
#---- Import APPROX rather than EXACT to match the numbers in the book -
pdq.Solve(pdq.APPROX)
""" 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]])
# Queue lengths
print "U0: %6.2f\tQ0: %6.2f" % (r[0]*100, r[0] / (1 - r[0]))
print "U1: %6.2f\tQ1: %6.2f" % (r[1]*100, r[1] / (1 - r[1]))
print "U2: %6.2f\tQ2: %6.2f" % (r[2]*100, r[2] / (1 - r[2]))
print "U3: %6.2f\tQ3: %6.2f" % (r[3]*100, r[3] / (1 - r[3]))
#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()
#---------------------------------------------------------------------
