10.6.4. Evaluation of opamp’s performance

We are going to set up the evaluation of a Miller opamp. For now we are not going to use any of the pyopus.design module’s facilities. The script from file 01-evaluator.py in folder demo/design/miller/

# Advanced performance evaluator demo

# Import definitions
from definitions import *
# Import PerformanceEvaluator class
from pyopus.evaluator.performance import PerformanceEvaluator
# Import MPI support
# If MPI is imported an application not using MPI will behave correctly
# (i.e. only slot 0 will run the program) even when started with mpirun/mpiexec
from pyopus.parallel.mpi import MPI
# Import cooperative multitasking OS which will also take care of job distribution
from pyopus.parallel.cooperative import cOS
# Plotting support
from pyopus.plotter import interface as pyopl
# pprint for pretty printing data structures
from pprint import pprint
# pickle for loading results
import pickle
# NumPy
import numpy as np

if __name__=='__main__':
	# Prepare statistical parameters dictionary with nominal values
	nominalStat={ name: desc['dist'].mean() for name, desc in statParams.items() }
	# Prepare operating parameters dictionary with nominal values
	nominalOp={ name: desc['init'] for name, desc in opParams.items() }
	# Prepare initial design parameters dictionary
	initialDesign={ name: desc['init'] for name, desc in designParams.items() }
	# Prepare one corner
	#  defined for all simulator setups
	#  module 'tm' definines the typical MOS models
	#  operating parameters are set to nominal values
		'nom': {
			'params': nominalOp, 
			'modules': ['tm']
	# Prepare parallel evaluation environment, cOS will use MPI as its backend
	# Remote tasks will be started in their own local folders. Before a task 
	# is started all files in the current folder of the machine that spawns a 
	# the remote task will be copied to that task's local folder (this is 
	# specified by the mirrorMap argument to MPI constructor). 
	# In definitions.py measures have no corners listed, 
	# Therefore they will be evaluated across all specified corners. 
	# The storeResults argument makes the evaluator store the waveforms
	# in temporary result files in the system TMP folder (because resultsFolder
	# is set to None) with prefix 'restemp_'
		heads, analyses, measures, corners, variables=variables, 
		storeResults=True, resultsFolder=None, resultsPrefix="restemp.", 
	# Evaluate, pass initial design parameters and nominal statistical parameters
	# to the netlist. 
	results, anCount = pe([initialDesign, nominalStat])
	# Print formatted results (values of performance measures)
	print(pe.formatResults(nMeasureName=10, nCornerName=15))
	# Print the list of temporary pickled result files across hosts where 
	# evaluations took place. This is a dictionary with (host, (corner, analysis))
	# for key. None for host means the results are stored on the local machine
	# (i.e. the one that invoked the evaluator). 
	print("\nResult files across hosts")
	# Extract and print the set of hosts where evaluations took place
	for h, k in pe.resFiles.keys():
	print("\nSet of hosts where results are stored (None is localhost):", s)
	# To access all result files we must first move them to the host where 
	# pe() was called. The files will be moved to the current directory 
	# (destination='.'). The collected files will have prefix 'res_'. Files 
	# will be moved (i.e. deleted from remote machines). 
	files=pe.collectResultFiles(destination=".", prefix="res.", move=True)
	# Print names of pickled result files after they were moved here. 
	# This is a dictionary with (corner, analysis) for key. 
	print("\nCollected result files")
	# Result file with key ('nom', 'blank') in the above mentioned dictionary 
	# holds the environment where dependent measurements without were 
	# evaluated for the 'nom' corner. Load one and print the environment. 
	with open(files[('nom', 'blank')], 'rb') as f:
	print("\n'blank' analysis measure evaluation environment")
	# Load the ac analysis results and plot gain in dB vs frequency
	with open(files[('nom', 'ac')], 'rb') as f:
	# Extract frequency scale and gain. 
	gain=20*np.log10(np.abs(acRes.v('out')/acRes.v('inp', 'inn')))
	# Plot gain. 
	f1=pyopl.figure(windowTitle="AC analysis", figpx=(600,400), dpi=100)	
	if pyopl.alive(f1):
		ax1.semilogx(freq, gain, '-', label='gain [dB]', color=(1,0,0))
		ax1.set_xlabel('f [Hz]')
		ax1.set_ylabel('gain [dB]')
		ax1.set_title('Gain vs frequency')
	# Wait for the user to close the plot environment control window. 

	# Delete collected result files
	# Cleanup temporary files generated by the evaluator
	# Finalize cOS parallel environment

The script first prepares dictionaries with nominal statistical parameter values (0), nominal operating parameter values and initial design parameter values. The nominal corner named nom is defined. This corner adds the ‘tm’ module to the input netlist for the simulator and specifies the nominal values of operating parameters.

Next, the cooperative multitasking OS is initialized. It uses MPI as the backend and starts every task in its own local folder which contains the copies of all files from the current folder (mirrorMap argument to MPI).

Finally, a pyopus.evaluator.performance.PerformanceEvaluator object is created from heads, analyses, measures, and variables defined in definitions.py and the corners variable constructed in this script. The evaluator will store the waveforms produced by the simulator in the local temporary folder of the machine where the results were computed by a simulator. The performance evaluator is then called (pe()) and the values of the initial design parameters and nominal statistical parameters are passed. These parameters are added to the input netlist for the simulator.

When the evaluation is finished the performance measures are printed

     area |             nom:    1.179e-09
     cmrr |             nom:    5.796e+01
     gain |             nom:    6.624e+01
 gain_com |             nom:    8.277e+00
 gain_vdd |             nom:   -2.624e+01
 gain_vss |             nom:    3.777e+00
  in1kmn2 |             nom:    1.581e-16
in1kmn2id |             nom:    1.581e-16
in1kmn2rd |             nom:    0.000e+00
 inoise1k |             nom:    3.344e-14
     isup |             nom:    3.010e-04
 onoise1k |             nom:    3.337e-14
   out_op |             nom:    6.979e-03
 overshdn |             nom:    7.176e-02
 overshup |             nom:    8.924e-02
       pm |             nom:    7.004e+01
 psrr_vdd |             nom:    9.247e+01
 psrr_vss |             nom:    6.246e+01
   slewdn |             nom:    1.082e+07
   slewup |             nom:    1.006e+07
    swing |             nom:    1.474e+00
   tsetdn |             nom:    1.925e-07
   tsetup |             nom:    2.094e-07
     ugbw |             nom:    6.641e+06
  vds_drv |             nom: [0.58454814 0.8205568  0.433882   0.11164392 0.82752772 0.55567868 0.32221448 0.80099198]
  vgs_drv |             nom: [0.2121875  0.20869958 0.02675759 0.02674103 0.02677772 0.39175785 0.39175785 0.10682108]

Next, the list of stored waveform files and hosts where they are stored is printed

Result files across hosts
{(None, ('nom', 'ac')): '/tmp/restemp.calypso_7967_2.nom.ac.s8xost1h',
 (None, ('nom', 'accom')): '/tmp/restemp.calypso_7967_6.nom.accom.fe5in9c1',
 (None, ('nom', 'acvdd')): '/tmp/restemp.calypso_7967_5.nom.acvdd.j5xqaicj',
 (None, ('nom', 'acvss')): '/tmp/restemp.calypso_7967_3.nom.acvss.qny1pj8d',
 (None, ('nom', 'blank')): '/tmp/restemp.calypso_7967_1.nom.blank.1dgn84hu',
 (None, ('nom', 'dc')): '/tmp/restemp.calypso_7967_2.nom.dc.9oion0n5',
 (None, ('nom', 'noise')): '/tmp/restemp.calypso_7967_2.nom.noise.otzdr6la',
 (None, ('nom', 'op')): '/tmp/restemp.calypso_7967_2.nom.op.ynjjg7io',
 (None, ('nom', 'tran')): '/tmp/restemp.calypso_7967_2.nom.tran.0w17d3qc',
 (None, ('nom', 'translew')): '/tmp/restemp.calypso_7967_4.nom.translew.u5d0kmli'}

A call to pyopus.evaluator.performance.PerformanceEvaluator.collectResultFiles() is made. This moves the result files from temporary storage on respective hosts to the current folder of the host that invoked the evaluator. The list of collected files is printed

Collected result files
{('nom', 'ac'): 'res.nom.ac.pck',
 ('nom', 'accom'): 'res.nom.accom.pck',
 ('nom', 'acvdd'): 'res.nom.acvdd.pck',
 ('nom', 'acvss'): 'res.nom.acvss.pck',
 ('nom', 'blank'): 'res.nom.blank.pck',
 ('nom', 'dc'): 'res.nom.dc.pck',
 ('nom', 'noise'): 'res.nom.noise.pck',
 ('nom', 'op'): 'res.nom.op.pck',
 ('nom', 'tran'): 'res.nom.tran.pck',
 ('nom', 'translew'): 'res.nom.translew.pck'}

The file holding the environment in which the performance measures without an analysis were evaluated is loaded and the environment is printed

'blank' analysis measure evaluation environment
{'isNmos': [1, 1, 1, 1, 1, 0, 0, 0],
 'm': <module 'pyopus.evaluator.measure' from '/home/arpadb/pytest/pyopus/evaluator/measure.py'>,
 'mosList': ['xmn1', 'xmn2', 'xmn3', 'xmn4', 'xmn5', 'xmp1', 'xmp2', 'xmp3'],
 'np': <module 'numpy' from '/usr/local/lib/python3.5/dist-packages/numpy/__init__.py'>,
 'param': {'c_out': 8.21e-12,
           'cload': 1e-12,
           'diff_l': 1.08e-06,
           'diff_w': 7.73e-06,
           'gu0nmm': 0.0,
           'gu0pmm': 0.0,
           'gvtnmm': 0.0,
           'gvtpmm': 0.0,
           'ibias': 0.0001,
           'lev1': -0.5,
           'lev2': 0.5,
           'load_l': 2.57e-06,
           'load_w': 3.49e-05,
           'mirr_l': 5.63e-07,
           'mirr_ld': 5.63e-07,
           'mirr_w': 7.46e-05,
           'mirr_wd': 7.46e-05,
           'mirr_wo': 7.46e-05,
           'mn1u0': 0.0,
           'mn1vt': 0.0,
           'mn2u0': 0.0,
           'mn2vt': 0.0,
           'mn3u0': 0.0,
           'mn3vt': 0.0,
           'mn4u0': 0.0,
           'mn4vt': 0.0,
           'mn5u0': 0.0,
           'mn5vt': 0.0,
           'mp1u0': 0.0,
           'mp1vt': 0.0,
           'mp2u0': 0.0,
           'mp2vt': 0.0,
           'mp3u0': 0.0,
           'mp3vt': 0.0,
           'out_l': 3.75e-07,
           'out_w': 4.8e-05,
           'pw': 1e-05,
           'r_out': 19.7,
           'rfb': 1000000.0,
           'rin': 1000000.0,
           'rload': 100000000.0,
           'temperature': 25,
           'tf': 1e-09,
           'tr': 1e-09,
           'tstart': 1e-05,
           'vdd': 1.8},
 'result': {'gain': {'nom': 66.24103484725208},
            'gain_com': {'nom': 8.276939732033867},
            'gain_vdd': {'nom': -26.235135394608754},
            'gain_vss': {'nom': 3.776680236411179},
            'in1kmn2': {'nom': 1.5814509234426575e-16},
            'in1kmn2id': {'nom': 1.5814509234426575e-16},
            'in1kmn2rd': {'nom': 0.0},
            'inoise1k': {'nom': 3.343611882428561e-14},
            'isup': {'nom': 0.0003009768725819436},
            'onoise1k': {'nom': 3.3371018439855986e-14},
            'out_op': {'nom': 0.00697923487611618},
            'overshdn': {'nom': 0.07176477049919334},
            'overshup': {'nom': 0.08923807202380866},
            'pm': {'nom': 70.04010745060916},
            'slewdn': {'nom': 10818342.824614132},
            'slewup': {'nom': 10059147.304855734},
            'swing': {'nom': 1.474471744100907},
            'tsetdn': {'nom': 1.9248788635101697e-07},
            'tsetup': {'nom': 2.0939194104629665e-07},
            'ugbw': {'nom': 6641299.6248098845},
            'vds_drv': {'nom': array([0.58454814, 0.8205568 , 0.433882  , 0.11164392, 0.826805  , 0.55567868, 0.32221448, 0.80172834])},
            'vgs_drv': {'nom': array([0.2121875 , 0.20869958, 0.02675759, 0.02674103, 0.02677769, 0.39175785, 0.39175785, 0.10679811])}}}

Gain of the initial Miller amplifier in nominal corner.

Next, the file holding the waveforms produced by the ac analysis is loaded. The frequency scale and the gain in dB are extracted and plotted.

The script cleans up all temporary files. Only the collected result files (.pck) remain on disk.

If we start the script on multiple local CPUs with

mpirun -n 5 python3 01-evaluator.py

we can see that the evaluation runs faster because analyses are distributed across multiple CPUs. The part of the output that lists the remotely stored result files changes to

Result files across hosts
{(MPIHostID('calypso'), ('nom', 'ac')): '/tmp/restemp.calypso_7a50_1.nom.ac.r0hhsg4f',
 (MPIHostID('calypso'), ('nom', 'accom')): '/tmp/restemp.calypso_7a4e_1.nom.accom.advjsa_v',
 (MPIHostID('calypso'), ('nom', 'acvdd')): '/tmp/restemp.calypso_7a4e_1.nom.acvdd.9nz70aco',
 (MPIHostID('calypso'), ('nom', 'acvss')): '/tmp/restemp.calypso_7a4f_1.nom.acvss.5k4b2czs',
 (None, ('nom', 'blank')): '/tmp/restemp.calypso_7a4d_1.nom.blank.ny6qsqz3',
 (MPIHostID('calypso'), ('nom', 'dc')): '/tmp/restemp.calypso_7a50_1.nom.dc.5pe13zzs',
 (MPIHostID('calypso'), ('nom', 'noise')): '/tmp/restemp.calypso_7a50_1.nom.noise.d283cnzi',
 (MPIHostID('calypso'), ('nom', 'op')): '/tmp/restemp.calypso_7a50_1.nom.op.4lwpkitq',
 (MPIHostID('calypso'), ('nom', 'tran')): '/tmp/restemp.calypso_7a50_1.nom.tran.9jl8tkra',
 (MPIHostID('calypso'), ('nom', 'translew')): '/tmp/restemp.calypso_7a51_1.nom.translew.x0o3fm8o'}

We can see that only the (‘nom’, None) corner-analysis pair is stored locally because the corresponding performance measures were evaluated on the local machine (the one that invoked the evaluator).