def __init__(self):
threading.Thread.__init__(self)
self.myOverlay = None
sys.setcheckinterval(25)
self.chanlist = ChannelList()
self.paused = False
self.fullUpdating = True
def inject_jump(self, where, dest):
"""
Monkeypatch bytecode at ``where`` to force it to jump to ``dest``.
Returns function which puts things back how they were.
"""
# We're about to do dangerous things to a functions code content.
# We can't make a lock to prevent the interpreter from using those
# bytes, so the best we can do is to set the check interval to be high
# and just pray that this keeps other threads at bay.
old_check_interval = sys.getcheckinterval()
sys.setcheckinterval(2**20)
pb = ctypes.pointer(self.ob_sval)
orig_bytes = [pb[where+i][0] for i in xrange(where)]
v = struct.pack("<BH", opcode.opmap["JUMP_ABSOLUTE"], dest)
# Overwrite code to cause it to jump to the target
for i in xrange(3):
pb[where+i][0] = ord(v[i])
def tidy_up():
"""
Put the bytecode back how it was. Good as new.
"""
sys.setcheckinterval(old_check_interval)
for i in xrange(3):
pb[where+i][0] = orig_bytes[i]
return tidy_up
def test_setcheckinterval(self):
import sys
raises(TypeError, sys.setcheckinterval)
orig = sys.getcheckinterval()
for n in 0, 100, 120, orig: # orig last to restore starting state
sys.setcheckinterval(n)
assert sys.getcheckinterval() == n
def evaluate(self,pop,force = 0):
#import tree
#print '1',tree.ref()
#only send the individuals out that need evaluation
if force:
_eval_list = pop.data
else:
_eval_list = filter(lambda x: not x.evaluated,pop)
#print '2',tree.ref()
eval_list = pop.clone()
#print '3',tree.ref()
eval_list.data = _eval_list
if len(eval_list):
Nserv = len(pop.server_list)
groups = divide_list(eval_list,Nserv)
#print '4',tree.ref()
sys.setcheckinterval(10)
finished = sync.event()
bar = sync.barrier(Nserv)
#print "EVAL LENGTH!!!", plen(pop.evaluator)
gr = groups[0]
print "GROUP LENGTH!!!", plen(groups[0]), len(gr),
#print "IND!!!", plen(gr[0]),plen(gr[0].root)
#print '4.5',tree.ref()
for i in range(len(groups)):
inputs = {'sub_pop':groups[i], 'evaluator':pop.evaluator, 'force':force}
returns = ('sub_pop',)
code = 'evaluator.evaluate(sub_pop,force)'
data_pack = (inputs,returns,code)
server = pop.server_list[i]
thread.start_new_thread(remote_thread_eval,(bar,finished,server,data_pack))
#print '7',tree.ref()
finished.wait()
sys.setcheckinterval(10)
def tidy_up():
"""
Put the bytecode back how it was. Good as new.
"""
sys.setcheckinterval(old_check_interval)
for i in xrange(3):
pb[where+i][0] = orig_bytes[i]
def test_string_slicing(self):
def f(ct, passCt,chars):
x = "asdfasdf" * (ct / 8)
res = 0
for _ in xrange(passCt):
for ix in xrange(len(x)):
res = res + len(x[ix:ix+chars])
return res
self.evaluateWithExecutor(f, 1000000, 1, 2)
self.evaluateWithExecutor(f, 10000, 1, 2)
def runTest(func, name):
PerformanceTestReporter.PerfTest(name)(func)()
runTest(lambda: self.evaluateWithExecutor(f, 1000000, 10, 2), "pyfora.string_slicing_10mm.2_char_large_string.pyfora")
runTest(lambda: self.evaluateWithExecutor(f, 1000000, 10, 200), "pyfora.string_slicing_10mm.200_char_large_string.pyfora")
runTest(lambda: self.evaluateWithExecutor(f, 10000, 1000, 2), "pyfora.string_slicing_10mm.2_char_small_string.pyfora")
runTest(lambda: self.evaluateWithExecutor(f, 10000, 1000, 200), "pyfora.string_slicing_10mm.200_char_small_string.pyfora")
sys.setcheckinterval(100000)
runTest(lambda: f(1000000, 10, 2), "pyfora.string_slicing_10mm.2_char_large_string.native")
runTest(lambda: f(1000000, 10, 200), "pyfora.string_slicing_10mm.200_char_large_string.native")
runTest(lambda: f(10000, 1000, 2), "pyfora.string_slicing_10mm.2_char_small_string.native")
runTest(lambda: f(10000, 1000, 200), "pyfora.string_slicing_10mm.200_char_small_string.native")
sys.setcheckinterval(100)
def preprocessPercentileRatios(self):
print "preprocessPercentileRatios start"
distributionsFile = self.getDatasetSlidingSizesFile()
if os.path.isfile(distributionsFile):
#Teh distributions file is processed
print "The distribution file exists"
return
self.initializePropertiesComputeStructures(False)
print "computing the ratios"
try:
zpa = zipfile.ZipFile(distributionsFile,"w",zipfile.ZIP_DEFLATED)
zpa.writestr("dummy.txt","dummy file")
zpa.close()
self.ziplock = threading.Lock()
# Create a pool with three worker threads
pool = ThreadPool.ThreadPool(5)
sys.setcheckinterval(1000)
for windowSize in self.slidingWindowSizes:
if self.useWindowThreading:
pool.queueTask(self.preprocessWindowSize, windowSize, None)
else:
self.preprocessWindowSize(windowSize)
# When all tasks are finished, allow the threads to terminate
if self.useWindowThreading:
print "Joining the threads"
pool.joinAll()
except:
os.unlink(distributionsFile)
raise
print "preprocessPercentileRatios end"
def main():
"""Main entry point for the application"""
# Prepare for mantid import
prepare_mantid_env()
# todo: parse command arguments
# general initialization
app = initialize()
# the default sys check interval leads to long lags
# when request scripts to be aborted
sys.setcheckinterval(SYSCHECK_INTERVAL)
main_window = None
try:
main_window = start_workbench(app)
except BaseException:
# We count this as a crash
import traceback
# This is type of thing we want to capture and have reports
# about. Prints to stderr as we can't really count on anything
# else
traceback.print_exc(file=ORIGINAL_STDERR)
if main_window is None:
# An exception occurred don't exit here
return
ORIGINAL_SYS_EXIT()
def xdump(path, show_scheme=True, show_data=True):
# print "query_res " + str(xquery_res)
xobj, scheme, ret_type = list_path(path)
if xobj is None:
return None
if ret_type == "DIR":
ret_fields = [['dir']]
for (son_dir_name, son_dir) in xobj.items():
ret_fields.append([add_cross_if_dir(son_dir_name, son_dir)])
return ret_fields
ret_fields = list()
if show_scheme:
ret_fields.append(list(scheme.keys()))
if ret_type == "LOGS":
ret_fields.extend(xobj)
return ret_fields
def_interval = sys.getcheckinterval()
# TODO: maybe copy before and no need to lock?
sys.setcheckinterval(1000000000)
try:
ret_fields.extend(decompose_fields(xobj,
show_scheme=False,
show_data=show_data))
except Exception as e:
raise e
finally:
sys.setcheckinterval(def_interval)
return ret_fields
def test_string_slicing_into_vector(self):
def testFunction(ct, passCt,chars):
x = "asdfasdf" * (ct / 8)
res = 0
for _ in xrange(passCt):
v = [x[ix*chars:ix*chars+chars] for ix in xrange(len(x) / chars)]
for e in v:
res = res + len(e)
return res
f = testFunction
self.evaluateWithExecutor(f, 1000000, 1, 2)
self.evaluateWithExecutor(f, 10000, 1, 2)
def runTest(func, name):
PerformanceTestReporter.PerfTest(name)(func)()
runTest(lambda: self.evaluateWithExecutor(f, 1000000, 10, 2), "pyfora.string_slicing_into_vector_10mm.2_char_large_string.pyfora")
runTest(lambda: self.evaluateWithExecutor(f, 1000000, 1000, 200), "pyfora.string_slicing_into_vector_10mm.200_char_large_string.pyfora")
runTest(lambda: self.evaluateWithExecutor(f, 10000, 1000, 2), "pyfora.string_slicing_into_vector_10mm.2_char_small_string.pyfora")
runTest(lambda: self.evaluateWithExecutor(f, 10000, 100000, 200), "pyfora.string_slicing_into_vector_10mm.200_char_small_string.pyfora")
sys.setcheckinterval(100000)
runTest(lambda: f(1000000, 10, 2), "pyfora.string_slicing_into_vector_10mm.2_char_large_string.native")
runTest(lambda: f(1000000, 1000, 200), "pyfora.string_slicing_into_vector_10mm.200_char_large_string.native")
runTest(lambda: f(10000, 1000, 2), "pyfora.string_slicing_into_vector_10mm.2_char_small_string.native")
runTest(lambda: f(10000, 100000, 200), "pyfora.string_slicing_into_vector_10mm.200_char_small_string.native")
sys.setcheckinterval(100)
def setup(options):
sys.setcheckinterval(options.check_interval)
zope.app.appsetup.product.setProductConfigurations(
options.product_config)
options.eventlog()
options.accesslog()
for logger in options.loggers:
logger()
features = ('zserver',)
# Provide the devmode, if activated
if options.devmode:
features += ('devmode',)
logging.warning("Developer mode is enabled: this is a security risk "
"and should NOT be enabled on production servers. Developer mode "
"can be turned off in etc/zope.conf")
zope.app.appsetup.config(options.site_definition, features=features)
db = zope.app.appsetup.appsetup.multi_database(options.databases)[0][0]
notify(zope.processlifetime.DatabaseOpened(db))
task_dispatcher = ThreadedTaskDispatcher()
task_dispatcher.setThreadCount(options.threads)
for server in options.servers:
server.create(task_dispatcher, db)
notify(zope.processlifetime.ProcessStarting())
return db
def __init__(self):
threading.Thread.__init__(self)
self.myOverlay = None
self.shouldExit = False
sys.setcheckinterval(25)
self.chanlist = ChannelList()
self.chanlist.sleepTime = 0.1
def short_checkinterval(request):
"""
Sets a small interval using sys.setcheckinterval to cause many context
switches.
"""
old_interval = sys.getcheckinterval()
sys.setcheckinterval(0)
request.addfinalizer(lambda: sys.setcheckinterval(old_interval))
def test_setcheckinterval(self):
if test.test_support.due_to_ironpython_bug("http://tkbgitvstfat01:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=148342"):
return
self.assertRaises(TypeError, sys.setcheckinterval)
orig = sys.getcheckinterval()
for n in 0, 100, 120, orig: # orig last to restore starting state
sys.setcheckinterval(n)
self.assertEquals(sys.getcheckinterval(), n)
def test_setcheckinterval(self):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
self.assertRaises(TypeError, sys.setcheckinterval)
orig = sys.getcheckinterval()
for n in 0, 100, 120, orig: # orig last to restore starting state
sys.setcheckinterval(n)
self.assertEqual(sys.getcheckinterval(), n)
def doStatProf(*args):
import bench.statprof
sys.setcheckinterval(0)
bench.statprof.start()
runLimited(*args)
bench.statprof.stop()
bench.statprof.display()
def _collect(self):
gc.collect()
check_interval = sys.getcheckinterval()
sys.setcheckinterval(sys.maxint)
try:
return {id(object) for object in gc.get_objects() if not isinstance(object, EXCLUDE_TYPES)}
finally:
sys.setcheckinterval(check_interval)
def run(self):
pthread_setname_np(self.ident, "Manhole ----")
client = self.client
client.settimeout(None)
pid, uid, gid = get_peercred(client)
euid = os.geteuid()
client_name = "PID:%s UID:%s GID:%s" % (pid, uid, gid)
if uid not in (0, euid):
raise SuspiciousClient(
"Can't accept client with %s. "
"It doesn't match the current EUID:%s or ROOT." % (
client_name, euid
))
cry("Accepted connection %s from %s" % (client, client_name))
pthread_setname_np(self.ident, "Manhole %s" % pid)
client.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 0)
client.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 0)
backup = []
try:
client_fd = client.fileno()
for mode, names in (
('w', (
'stderr',
'stdout',
'__stderr__',
'__stdout__'
)),
('r', (
'stdin',
'__stdin__'
))
):
for name in names:
backup.append((name, getattr(sys, name)))
setattr(sys, name, os.fdopen(client_fd, mode, 0))
run_repl()
cry("DONE.")
finally:
cry("Cleaning up.")
old_interval = sys.getcheckinterval()
sys.setcheckinterval(2147483647)
junk = [] # keep the old file objects alive for a bit
for name, fh in backup:
junk.append(getattr(sys, name))
setattr(sys, name, fh)
del backup
for fh in junk:
try:
fh.close()
except IOError:
pass
del fh
del junk
self.client = None
sys.setcheckinterval(old_interval)
def thread_func(lock, acquire_array, lock_array, index):
gevent.sleep(random.uniform(0, 0.1))
# We use the fact that the GIL prevents CPython from context switching between the acquire_array.append()
# and the lock.acquire() when we set the check interval to a great value
sys.setcheckinterval(10000000)
acquire_array.append(index)
with lock:
sys.setcheckinterval(1)
lock_array.append(index)
def test_trashcan_threads(self):
# Issue #13992: trashcan mechanism should be thread-safe
NESTING = 60
N_THREADS = 2
def sleeper_gen():
"""A generator that releases the GIL when closed or dealloc'ed."""
try:
yield
finally:
time.sleep(0.000001)
class C(list):
# Appending to a list is atomic, which avoids the use of a lock.
inits = []
dels = []
def __init__(self, alist):
self[:] = alist
C.inits.append(None)
def __del__(self):
# This __del__ is called by subtype_dealloc().
C.dels.append(None)
# `g` will release the GIL when garbage-collected. This
# helps assert subtype_dealloc's behaviour when threads
# switch in the middle of it.
g = sleeper_gen()
next(g)
# Now that __del__ is finished, subtype_dealloc will proceed
# to call list_dealloc, which also uses the trashcan mechanism.
def make_nested():
"""Create a sufficiently nested container object so that the
trashcan mechanism is invoked when deallocating it."""
x = C([])
for i in range(NESTING):
x = [C([x])]
del x
def run_thread():
"""Exercise make_nested() in a loop."""
while not exit:
make_nested()
old_checkinterval = sys.getcheckinterval()
sys.setcheckinterval(3)
try:
exit = []
threads = []
for i in range(N_THREADS):
t = threading.Thread(target=run_thread)
threads.append(t)
with start_threads(threads, lambda: exit.append(1)):
time.sleep(1.0)
finally:
sys.setcheckinterval(old_checkinterval)
gc.collect()
self.assertEqual(len(C.inits), len(C.dels))
def setUp(self):
# Set a very small check interval, this will make it more likely
# that the interpreter crashes when threading is done incorrectly.
if sys.version_info[:2] >= (3, 2):
self._int = sys.getswitchinterval()
sys.setswitchinterval(0.0000001)
else:
self._int = sys.getcheckinterval()
sys.setcheckinterval(1)
def main():
"""Main entry point for the application"""
# setup command line arguments
parser = argparse.ArgumentParser(description='Mantid Workbench')
parser.add_argument('script', nargs='?')
parser.add_argument('-x', '--execute', action='store_true',
help='execute the script file given as argument')
parser.add_argument('-q', '--quit', action='store_true',
help='execute the script file with \'-x\' given as argument and then exit')
# TODO -a or --about: show about dialog and exit
# TODO -d or --default-settings: start MantidPlot with the default settings
# DONE -h or --help: show command line options <- free with command line parser
# TODO -v or --version: print MantidPlot version and release date
# TODO -r or --revision: print MantidPlot version and release date
# TODO -s or --silent: start mantidplot without any setup dialogs
# DONE -x or --execute: execute the script file given as argument
# DONE -xq or --executeandquit: execute the script file given as argument and then exit MantidPlot
# this is not a valid short command line option
try:
# set up bash completion as a soft dependency
import argcomplete
argcomplete.autocomplete(parser)
except ImportError:
pass # silently skip this
# parse the command line options
options = parser.parse_args()
# TODO handle options that don't require starting the workbench e.g. --help --version
# fix/validate arguments
if options.script is not None:
# convert into absolute path
options.script = os.path.abspath(os.path.expanduser(options.script))
if not os.path.exists(options.script):
# TODO should be logged
print('script "{}" does not exist'.format(options.script))
options.script = None
app = initialize()
# the default sys check interval leads to long lags
# when request scripts to be aborted
sys.setcheckinterval(SYSCHECK_INTERVAL)
exit_value = 0
try:
exit_value = start_workbench(app, options)
except BaseException:
# We count this as a crash
import traceback
# This is type of thing we want to capture and have reports
# about. Prints to stderr as we can't really count on anything
# else
traceback.print_exc(file=ORIGINAL_STDERR)
exit_value = -1
finally:
ORIGINAL_SYS_EXIT(exit_value)
def __init__(self, worker, workerArgs = None, syncs = []):
self.numWorkers = int(raw_input("Number of workers or cores: "))
sys.setcheckinterval(CHECK_INTERVAL)
self.worker = worker
self.workerArgs = workerArgs
self.sleep = SLEEP*60
self.syncEverySeconds = SYNC*60*60
self.syncs = syncs
self.syncRequest = False
def main():
'''
'''
sys.setcheckinterval(1000000)
try:
os.nice(-20)
except OSError:
print 'Note, running as root sets this script to a higher priority'
show_progress = True
print 'Reading file...'
fsBB, music = wav.read('classical1.wav')
music = music[0:2*fsBB] #Truncate to 2 seconds
musicL = music.T[0] #Separate out the left/right channels
musicR = music.T[1]
musicRL = musicL + musicR #merge the two channels
int16_max = float(2**15 - 1)
musicRL = musicRL/int16_max #normalize to 1
fsIF = 800000.
fc = 100000
BPL = True #Bandpass limiter, see demodulator
predeemph = True #Preemphasis and deemphasis filtering
fm_mod, kf = modulate_fm(musicRL, fsBB, fsIF, debug = False,
preemph = predeemph, fc = fc, progress = show_progress)
T = len(fm_mod)/fsIF
t = np.linspace(0, T, T*fsIF)
plt.plot(t[0:10000], fm_mod[0:10000])
plt.show()
return
# fm_mod = AWGN_channel(fm_mod, 10, debug = False, progress = show_progress)
# fm_mod = distortion_channel(fm_mod, taps = 10, progress = show_progress)
# fm_mod = multipath_channel(fm_mod, [1e-7],
# [1], fsIF, debug = False)
# fm_mod = nonlinearphase_channel(fm_mod, taps = 12, debug = True)
fm_mod = AWGN_channel(fm_mod, 0, debug = False, progress = show_progress)
#The analog_to_digital function is only really useful for generating an
#output file, since the following arithmetic is still done with float64.
#To model the effects of quantization just add gaussian noise...
#fm_mod = analog_to_digital(fm_mod, bits = 4, rnge = [-1,1], file_out = None,
# progress = show_progress)
BB_IQ = iqdemodulate_fm(fm_mod, fsIF, debug = False, deemph = predeemph, fc = fc,
BPL = BPL, progress = show_progress)
BB_ZX = zxdemodulate_fm(fm_mod, fsIF, debug = False, deemph = predeemph, fc = fc,
BPL = BPL, progress = show_progress)
play(BB_IQ, fsIF, fsBB, norm = 'inf', debug = False,
msg = 'Playing IQ, inf norm')
play(BB_ZX, fsIF, fsBB, norm = 'inf', debug = False,
msg = 'Playing ZX, inf norm')
return
def __init__(self, path=None):
"""Sets up and starts the `AppServer`.
`path` is the working directory for the AppServer
(directory in which AppServer is contained, by default)
This method loads plugins, creates the Application object,
and starts the request handling loop.
"""
self._running = 0
self._startTime = time()
global globalAppServer
if globalAppServer:
raise ProcessRunning("More than one AppServer" " or __init__() invoked more than once.")
globalAppServer = self
# Set up the import manager:
self._imp = ImportManager()
ConfigurableForServerSidePath.__init__(self)
if path is None:
path = os.path.dirname(__file__) # os.getcwd()
self._serverSidePath = os.path.abspath(path)
self._webKitPath = os.path.abspath(os.path.dirname(__file__))
self._webwarePath = os.path.dirname(self._webKitPath)
self.recordPID()
self._verbose = self.setting("Verbose")
if self._verbose:
self._silentURIs = self.setting("SilentURIs")
if self._silentURIs:
import re
self._silentURIs = re.compile(self._silentURIs)
else:
self._silentURIs = None
self._plugIns = []
self._requestID = 0
self.checkForInstall()
self.config() # cache the config
self.printStartUpMessage()
if self.setting("CheckInterval") is not None:
sys.setcheckinterval(self.setting("CheckInterval"))
self._app = self.createApplication()
self.loadPlugIns()
# @@ 2003-03 ib: shouldn't this just be in a subclass's __init__?
if self.isPersistent():
self._closeEvent = Event()
self._closeThread = Thread(target=self.closeThread, name="CloseThread")
# self._closeThread.setDaemon(1)
self._closeThread.start()
self._running = 1
def config(configfile, opts=None, dump=False):
""" initialize the application """
# pylint: disable = R0912, W0621
from wtf import config as _config
if configfile is None:
config = _config.Config(
_os.path.normpath(_os.path.abspath(_os.getcwd()))
)
else:
config = _config.load(configfile)
if dump:
_config.dump(config)
_sys.exit(0)
if 'wtf' in config and 'pythonpath' in config.wtf:
_sys.path = list(config.wtf.pythonpath) + _sys.path
if opts is not None and opts.checkinterval:
checkinterval = opts.checkinterval
elif 'wtf' in config:
checkinterval = config.wtf('checkinterval', 0)
else:
checkinterval = 0
if checkinterval:
_sys.setcheckinterval(checkinterval)
if opts is not None and opts.max_descriptors:
from wtf import cmdline as _cmdline
max_descriptors = opts.max_descriptors
exc = _cmdline.CommandlineError
elif 'wtf' in config:
max_descriptors = max(-1, int(config.wtf('max_descriptors', 0)))
exc = _config.ConfigurationError
else:
max_descriptors = 0
if max_descriptors:
try:
import resource as _resource
except ImportError:
raise exc(
"Cannot set max descriptors: resource module not available"
)
else:
try:
name = _resource.RLIMIT_NOFILE
except AttributeError:
try:
name = _resource.RLIMIT_OFILE
except AttributeError:
raise exc(
"Cannot set max descriptors: no rlimit constant found"
)
_resource.setrlimit(name, (max_descriptors, max_descriptors))
return config
def __unicode__(self):
"""Return a serialized version of this tree/branch."""
ci = getcheckinterval()
setcheckinterval(0)
value = ''.join(self.render('utf8')).decode('utf8')
setcheckinterval(ci)
return value
def pbar(title="Progress dialog example",
text="An informative message",
max=100,
style=wx.PD_CAN_ABORT|wx.PD_AUTO_HIDE|wx.PD_SMOOTH|wx.PD_ELAPSED_TIME|wx.PD_ESTIMATED_TIME|wx.PD_REMAINING_TIME,
*arg,**kwd):
sys.setcheckinterval(0)
gettext.install("wxpbr")
app = pbr(title,text,max,style,*arg,**kwd)
app.start()
return app
def tidy_up():
"""
Put the bytecode back to how it was. Good as new.
"""
if sys.version_info[0] < 3:
sys.setcheckinterval(old_check_interval)
else:
sys.setswitchinterval(old_check_interval)
for i in range(3):
pb[where + i][0] = orig_bytes[i]
def init ( self ):
# reduce check frequency to speed up things
sys.setcheckinterval(1000)
# check for the manager's SQLite database
if not os.path.exists(self.settings.dbPath):
print "Management database not found. Creating it..."
# connect to SQLite database and enable dictionary access of rows
self.dbCon = sqlite3.connect(self.settings.dbPath)
self.dbCon.row_factory = sqlite3.Row
# check if the dicom series database table exists
qResult = None
with self.dbCon:
dbCur = self.dbCon.cursor()
dbCur.execute( "SELECT name FROM sqlite_master WHERE type='table' AND name='%s'" % self.settings.dbTblSeries )
qResult = dbCur.fetchone()
if qResult is None:
# series table doesn't exist - create table in database
print "Database table '%s' not found. Creating it..." % self.settings.dbTblSeries
dcmHeaderNames = [ DicomDictionary[dcmHeaderKey][4] for dcmHeaderKey in self.settings.tagsToRecord ]
qCreate = "CREATE TABLE " + self.settings.dbTblSeries + " ( id INTEGER PRIMARY KEY, NumberOfDicoms INTEGER DEFAULT 0 NOT NULL, " + ' TEXT, '.join(dcmHeaderNames) + " TEXT )"
with self.dbCon:
dbCur = self.dbCon.cursor()
dbCur.execute(qCreate)
# check if the series' notes database table exists
qResult = None
with self.dbCon:
dbCur = self.dbCon.cursor()
dbCur.execute( "SELECT name FROM sqlite_master WHERE type='table' AND name='%s'" % self.settings.dbTblSeriesNotes )
qResult = dbCur.fetchone()
if qResult is None:
# projects table doesn't exist - create table in database
print "Database table '%s' not found. Creating it..." % self.settings.dbTblSeriesNotes
qCreate = ("CREATE TABLE %s ( id INTEGER PRIMARY KEY, SeriesInstanceUID INTEGER, Note TEXT ); "
"CREATE INDEX SeriesInstanceUidIdx ON %s (SeriesInstanceUID); "
) % ( self.settings.dbTblSeriesNotes, self.settings.dbTblSeriesNotes )
with self.dbCon:
dbCur = self.dbCon.cursor()
dbCur.executescript(qCreate)
# check root directory's existence
if not os.path.exists(self.settings.rootDir):
print "Root directory not found. You must create this!"
return
# check for dicom directory
if not os.path.exists(self.settings.dicomDir):
print "DICOM storage directory not found. Creating it..."
os.makedirs(self.settings.dicomDir)
if len(args) == 1:
func = conv3x3
else:
func = eval('conv3x3' + args[1])
n = 1000
for i in range(10):
func(Image(n, n), Image(3, 3))
if len(args) > 1:
return 'conv3x3%s(%s(%dx%d))' % (args[1], Image.__name__, n, n)
else:
return Image.__name__
if __name__ == '__main__':
import time, sys
sys.setcheckinterval(2**30)
try:
import pypyjit
pypyjit.set_param(trace_limit=200000)
except ImportError:
pass
Image = eval(sys.argv[1])
n = 1000
# Warmup
conv3x3(Image(n, n), Image(3, 3))
conv3x3iter(Image(n, n), Image(3, 3))
conv3x3range(Image(n, n), Image(3, 3))
a = time.time()
for i in range(10):
def sys_func():
lists = sys.argv # 传递给Python脚本的命令行参数列表 => python p.py -> ['p.py'] / python
strs = sys.getdefaultencoding() # 默认字符集名称
num = sys.getfilesystemencoding() # 系统文件名字符集名称
dicts = sys.getrefcount(object) # 返回object的引用计数（比实际多1个）
lists = sys.path # 模块搜索路径
sys.path.append("./test") # 动态添加模块搜索路径
strs = sys.platform # 平台标识符（系统身份进行详细的检查，推荐使用） Linux: 'linux' / Windows:'win32' / Cygwin:'cygwin' / Mac OS X:'darwin'
strs = sys.version # python解释器版本
lists = sys.thread_info # 线程信息
num = sys.api_version # 解释器C API版本
types, value, back = sys.exc_info() # 捕获异常 详见 异常 文章
sys.excepthook(types, value, back) # 打印异常
types = sys.last_type
value = sys.last_value
back = sys.last_trackback
# sys.exit([arg]) // 引发SystemExit异常退出Python(可以try)，范围[0,127], None==0, "string"==1
sys.exit(0)
num = sys.getrecursionlimit() # 最大递归数（堆栈最大深度）
sys.setrecursionlimit(5000) # 修改最大递归数
fnum = sys.getswitchinterval() # 获取线程切换间隔
sys.setswitchinterval(0.005) # 设置线程切换间隔，单位秒
num = sys.getcheckinterval() # 解释器的检查间隔
sys.setcheckinterval(100) # 设置解释器检查间隔，执行（默认）100个虚拟指令执行一次检查, 值为<=0时,检查每个虚拟指令
# sys.stdin // 标准输入流
strs = sys.stdin.readline()[:-1]
# sys.stdout // 标准出入输出
sys.stdout.write(">>")
sys.stdout.flush()
# sys.stderr // 标注错误流
sys.stderr.write(">>")
# ---
lists = sys.builtin_module_names # 所有模块 (注:非导入模块)
path = sys.base_exec_prefix # Python安装路径
path = sys.base_prefix # 同base_exec_prefix
path = sys.exec_prefix # 同base_exec_prefix
path = sys.prefix # 同base_exec_prefix
path = sys.executable # Python解释器的绝对路径
strs = sys.byteorder # 本机字节顺序指示器, big-endian(最高有效字节在第一位)值为'big', little-endian(最低有效字节在第一位)值为'little'
strs = sys.copyright # python版权
num = sys.hexversion # 16进制版本号
lists = sys.implementation # 当前运行的解释器的信息
num = sys.getallocatedblocks() # 解释器当前分配的内存块的数量
boolean = sys.dont_write_bytecode # 是否不会尝试导入源模块是写入.pyc文件 (False会写入.pyc文件)
# sys.getsizeof(object[, default]) // 返回对象的大小bit, 只计算自身内存消耗,不计算引用对象的内存消耗, 调用对象的__sizeof__(), default没有获取到默认返回值
num = sys.getsizeof(object)
boolean = sys.is_finalizing() # 解释器是否正在被关机
num = sys.maxsize # 最大整数值(2 ** 31 -1), 与系统有关
num = sys.maxunicode # 最大Unicode值的整数 (1114111)
strs = sys.ps1 # 解释器主提示符
strs = sys.ps2 # 解释器次提示符
sys.call_tracing(func, ("arg",)) # 调用函数
sys._clear_type_cache() # 清除内部类型缓存
sys._debugmallocstats() # 打印CPython内存分配器状态的低级信息
sys.setprofile(profilefunc) # 设置profile函数, 默认None
sys.getprofile() # 获取profile函数
sys.settrace(tracefunc) # 设置跟踪函数, def tracefunc(frame、event 和arg):
sys.gettrace() # 获取跟踪函数, 默认None
sys.set_coroutine_wrapper(wrapper) # 设置包装 def wrapper(coro):
sys.get_coroutine_wrapper() # 包装, 默认None
def tearDown(self):
sys.setcheckinterval(self._original_check_interval)
from OFS.Application import install_product
from OFS.Folder import Folder # NOQA
from Testing.ZopeTestCase import layer
# ZODB sandbox factory
from ZODB.DemoStorage import DemoStorage # NOQA
# Allow test authors to install Zope products into the test environment. Note
# that installProduct() must be called at module level -- never from tests.
from OFS.Application import get_folder_permissions # NOQA; NOQA
# Allow code to tell it is run by the test framework
os.environ['ZOPETESTCASE'] = '1'
# Increase performance on MP hardware
if PY2:
sys.setcheckinterval(2500)
# Always shut up
_quiet = True
def _print(msg):
'''Writes 'msg' to stderr and flushes the stream.'''
sys.stderr.write(msg)
sys.stderr.flush()
def _write(msg):
'''Writes 'msg' to stderr if not _quiet.'''
if not _quiet:
_print(msg)
def fastresponses(wakeup):
sys.setcheckinterval(64)
time.sleep(12.01)
if self.lastwakeup == wakeup:
sys.setcheckinterval(4096)
self.synsockets.clear()
import tkinter import model.core as core import gui.frame as frame import sys sys.setcheckinterval(0) core = core.Core() frame = frame.Frame(core)
# happened, then the path munging code is skipped.
swhome = r'INSERT_SOFTWARE_HOME'
import sys
import os
if swhome != 'INSERT_SOFTWARE_HOME' and EMMIX_DEBUG:
import sys
sys.path.insert(0, '%s/lib/python' % swhome)
sys.path.insert(1, '%s/bin/lib' % swhome)
sys.path.insert(2, '%s/bin/lib/plat-win' % swhome)
sys.path.insert(3, '%s/bin/lib/win32' % swhome)
sys.path.insert(4, '%s/bin/lib/win32/lib' % swhome)
sys.path.insert(5, '%s' % swhome)
import os, sys, getopt, string
sys.setcheckinterval(120)
program = sys.argv[0]
here = os.path.join(os.getcwd(), os.path.split(program)[0])
Zpid = ''
########################################################################
# Configuration section
## General configuration options
##
# If you want run as a daemon, then uncomment the line below:
if sys.platform == 'win32': Zpid = ''
else: Zpid = 'zProcessManager.pid'
def main(self):
rounds = self.values['-n']
reportfile = self.values['-f']
show_bench = self.values['-s']
regression_only = self.values['-r']
compare_to = self.values['-c']
hidenoise = self.values['-d']
warp = int(self.values['-w'])
withgc = self.values['--with-gc']
limitnames = self.values['-t']
if limitnames:
if _debug:
print '* limiting test names to one with substring "%s"' % \
limitnames
limitnames = re.compile(limitnames, re.I)
else:
limitnames = None
verbose = self.verbose
withsyscheck = self.values['--with-syscheck']
calibration_runs = self.values['-C']
timer = self.values['--timer']
print '-' * LINE
print 'PYBENCH %s' % __version__
print '-' * LINE
print '* using %s %s' % (getattr(
platform, 'python_implementation',
lambda: 'Python')(), string.join(string.split(sys.version), ' '))
# Switch off garbage collection
if not withgc:
try:
import gc
except ImportError:
print '* Python version doesn\'t support garbage collection'
else:
try:
gc.disable()
except NotImplementedError:
print '* Python version doesn\'t support gc.disable'
else:
print '* disabled garbage collection'
# "Disable" sys check interval
if not withsyscheck:
# Too bad the check interval uses an int instead of a long...
value = 2147483647
try:
sys.setcheckinterval(value)
except (AttributeError, NotImplementedError):
print '* Python version doesn\'t support sys.setcheckinterval'
else:
print '* system check interval set to maximum: %s' % value
if timer == TIMER_SYSTIMES_PROCESSTIME:
import systimes
print '* using timer: systimes.processtime (%s)' % \
systimes.SYSTIMES_IMPLEMENTATION
else:
print '* using timer: %s' % timer
print
if compare_to:
try:
f = open(compare_to, 'rb')
bench = pickle.load(f)
bench.name = compare_to
f.close()
compare_to = bench
except IOError, reason:
print '* Error opening/reading file %s: %s' % (
repr(compare_to), reason)
compare_to = None
def setupInterpreter(self):
""" make changes to the python interpreter environment """
sys.setcheckinterval(self.cfg.python_check_interval)
__version__ = '6.2.0' __author__ = 'Wim Lavrijsen ([email protected])' ### system and interpreter setup ------------------------------------------------ import os, sys, types import collections ## there's no version_info in 1.5.2 if sys.version[0:3] < '2.2': raise ImportError( 'Python Version 2.2 or above is required.' ) ## 2.2 has 10 instructions as default, > 2.3 has 100 ... make same if sys.version[0:3] == '2.2': sys.setcheckinterval( 100 ) ## readline support, if available try: import rlcompleter, readline class RootNameCompleter( rlcompleter.Completer ): def file_matches( self, text ): matches = [] path, name = os.path.split( text ) try: for fn in os.listdir( path or os.curdir ): if fn[:len(name)] == name: full = os.path.join( path, fn ) matches.append( full )
lc.printResults()
def testConflictSymmetricNoSync(self):
lc = LoopConflict(ops=[vmHostOpToggle] * 2,
args=self.args,
limit=self.loopLimit,
sync=False)
lc.run()
lc.printResults()
def testConflictAsymmetric(self):
lc = LoopConflict(ops=[vmHostOpOn, vmDelDisk],
args=self.args,
limit=self.loopLimit,
sync=False)
lc.run()
lc.printResults()
if __name__ == "__main__":
# set the check interval to a low number to increase concurrency for I/O bound ops
sys.setcheckinterval(1)
hostOpToggleSuite = unittest.TestSuite()
hostOpToggleSuite.addTest(HostOpToggleTestCase("testIndependent"))
# hostOpToggleSuite.addTest(HostOpToggleTestCase("testConflictSymmetric"))
# hostOpToggleSuite.addTest(HostOpToggleTestCase("testConflictSymmetricNoSync"))
# hostOpToggleSuite.addTest(HostOpToggleTestCase("testConflictAsymmetric"))
""" or, simply say - """
# hostOpToggleSuite = unittest.MakeSuite(HostOpToggleTestCase)
unittest.TextTestRunner(verbosity=2).run(hostOpToggleSuite)
def main():
metadata = {'pybench_version': __version__}
runner = perf.Runner(metadata=metadata, add_cmdline_args=add_cmdline_args)
cmd = runner.argparser
cmd.add_argument("-b",
"--benchmarks",
metavar="REGEX",
help='run only tests with names matching REGEX')
cmd.add_argument('--with-gc',
action="store_true",
help='enable garbage collection')
cmd.add_argument('--with-syscheck',
action="store_true",
help='use default sys check interval')
cmd.add_argument('--copyright', action="store_true", help='show copyright')
cmd.add_argument('--list',
action="store_true",
help='display the list of benchmarks and exit')
args = runner.parse_args()
bench = Benchmark(runner, args.output, verbose=runner.args.verbose)
bench.rounds = runner.args.warmups + runner.args.samples
if args.copyright:
print(__copyright__.strip())
print()
sys.exit()
if args.list:
bench.list_benchmarks(args)
sys.exit()
# Switch off garbage collection
if not args.with_gc:
try:
import gc
except ImportError:
print('* Python version doesn\'t support garbage collection',
file=sys.stderr)
else:
try:
gc.disable()
except NotImplementedError:
print('* Python version doesn\'t support gc.disable',
file=sys.stderr)
else:
if args.verbose:
print('* disabled garbage collection', file=sys.stderr)
# "Disable" sys check interval
if not args.with_syscheck:
# Too bad the check interval uses an int instead of a long...
value = 2147483647
try:
sys.setcheckinterval(value)
except (AttributeError, NotImplementedError):
print('* Python version doesn\'t support sys.setcheckinterval',
file=sys.stderr)
else:
if args.verbose:
print('* system check interval set to maximum: %s' % value,
file=sys.stderr)
bench.load_tests(runner.args, Setup)
try:
bench.run()
except KeyboardInterrupt:
print()
print('*** KeyboardInterrupt -- Aborting')
print()
return
def setUp(self):
self._original_check_interval = sys.getcheckinterval()
sys.setcheckinterval(1)
def test_setcheckinterval(self):
self.assertRaises(TypeError, sys.setcheckinterval)
orig = sys.getcheckinterval()
for n in 0, 100, 120, orig: # orig last to restore starting state
sys.setcheckinterval(n)
self.assertEquals(sys.getcheckinterval(), n)
def setupInterpreter(self):
# make changes to the python interpreter environment
if PY2:
# Check interval is gone in supported Python 3 versions.
sys.setcheckinterval(self.cfg.python_check_interval)
def main():
"""Main entry point for the application"""
# setup command line arguments
parser = argparse.ArgumentParser(description='Mantid Workbench')
parser.add_argument('script', nargs='?')
parser.add_argument('-x',
'--execute',
action='store_true',
help='execute the script file given as argument')
parser.add_argument(
'-q',
'--quit',
action='store_true',
help=
'execute the script file with \'-x\' given as argument and then exit')
# TODO -a or --about: show about dialog and exit
# TODO -d or --default-settings: start MantidPlot with the default settings
# DONE -h or --help: show command line options <- free with command line parser
# TODO -v or --version: print MantidPlot version and release date
# TODO -r or --revision: print MantidPlot version and release date
# TODO -s or --silent: start mantidplot without any setup dialogs
# DONE -x or --execute: execute the script file given as argument
# DONE -xq or --executeandquit: execute the script file given as argument and then exit MantidPlot
# this is not a valid short command line option
try:
# set up bash completion as a soft dependency
import argcomplete
argcomplete.autocomplete(parser)
except ImportError:
pass # silently skip this
# parse the command line options
options = parser.parse_args()
# TODO handle options that don't require starting the workbench e.g. --help --version
# fix/validate arguments
if options.script is not None:
# convert into absolute path
options.script = os.path.abspath(os.path.expanduser(options.script))
if not os.path.exists(options.script):
# TODO should be logged
print('script "{}" does not exist'.format(options.script))
options.script = None
app = initialize()
# the default sys check interval leads to long lags
# when request scripts to be aborted
sys.setcheckinterval(SYSCHECK_INTERVAL)
exit_value = 0
try:
exit_value = start_workbench(app, options)
except BaseException:
# We count this as a crash
import traceback
# This is type of thing we want to capture and have reports
# about. Prints to stderr as we can't really count on anything
# else
traceback.print_exc(file=ORIGINAL_STDERR)
exit_value = -1
finally:
ORIGINAL_SYS_EXIT(exit_value)
runner = perf.Runner(add_cmdline_args=add_cmdline_args)
runner.metadata[
'description'] = "Test the performance of Python's threads."
benchmarks = {
"iterative_count": test_iterative_count,
"threaded_count": test_threaded_count
}
parser = runner.argparser
parser.add_argument("--num_threads",
action="store",
type=int,
default=2,
dest="num_threads",
help="Number of threads to test.")
parser.add_argument("--check_interval",
action="store",
type=int,
default=sys.getcheckinterval(),
dest="check_interval",
help="Value to pass to sys.setcheckinterval().")
runner.argparser.add_argument("benchmark", choices=sorted(benchmarks))
options = runner.parse_args()
name = 'threading_%s' % options.benchmark
bench_func = benchmarks[options.benchmark]
sys.setcheckinterval(options.check_interval)
runner.bench_sample_func(name, bench_func, options.num_threads)
def main():
usage = "usage: %prog [-h|--help] [options]"
parser = OptionParser(usage=usage)
parser.add_option("-t",
"--throughput",
action="store_true",
dest="throughput",
default=False,
help="run throughput tests")
parser.add_option("-l",
"--latency",
action="store_true",
dest="latency",
default=False,
help="run latency tests")
parser.add_option("-b",
"--bandwidth",
action="store_true",
dest="bandwidth",
default=False,
help="run I/O bandwidth tests")
parser.add_option("-i",
"--interval",
action="store",
type="int",
dest="check_interval",
default=None,
help="sys.setcheckinterval() value")
parser.add_option("-I",
"--switch-interval",
action="store",
type="float",
dest="switch_interval",
default=None,
help="sys.setswitchinterval() value")
parser.add_option("-n",
"--num-threads",
action="store",
type="int",
dest="nthreads",
default=4,
help="max number of threads in tests")
# Hidden option to run the pinging and bandwidth clients
parser.add_option("",
"--latclient",
action="store",
dest="latclient",
default=None,
help=SUPPRESS_HELP)
parser.add_option("",
"--bwclient",
action="store",
dest="bwclient",
default=None,
help=SUPPRESS_HELP)
options, args = parser.parse_args()
if args:
parser.error("unexpected arguments")
if options.latclient:
kwargs = eval(options.latclient)
latency_client(**kwargs)
return
if options.bwclient:
kwargs = eval(options.bwclient)
bandwidth_client(**kwargs)
return
if not options.throughput and not options.latency and not options.bandwidth:
options.throughput = options.latency = options.bandwidth = True
if options.check_interval:
sys.setcheckinterval(options.check_interval)
if options.switch_interval:
sys.setswitchinterval(options.switch_interval)
print("== %s %s (%s) ==" % (
platform.python_implementation(),
platform.python_version(),
platform.python_build()[0],
))
# Processor identification often has repeated spaces
cpu = ' '.join(platform.processor().split())
print("== %s %s on '%s' ==" % (
platform.machine(),
platform.system(),
cpu,
))
print()
if options.throughput:
print("--- Throughput ---")
print()
run_throughput_tests(options.nthreads)
if options.latency:
print("--- Latency ---")
print()
run_latency_tests(options.nthreads)
if options.bandwidth:
print("--- I/O bandwidth ---")
print()
run_bandwidth_tests(options.nthreads)
def multi_processor(reader,
workflow_class,
graph_builder_constructor,
graph_builder_params,
ranker_constructor,
ranker_params,
eval_parameters,
ranking_cutoff,
mesh_tree_filename,
distance_matrix_filename,
distance_function,
umls_converter_data_filename,
umls_concept_data_filename,
extra_data_name,
extra_data_contents,
output_file,
num_processes=None,
queue_size=None,
output_callback=output,
output_headers_callback=output_headers,
output_item_callback=output_one_item,
performance_tuning=True):
"""
Perform the evaluation.
Multiprocessing notes: It's the responsibility of the caller to make sure that
extra_data_contents, if any, are multiprocessing-safe. For example, by using
a SyncManager and Namespace and passing the proxy. See umls/concept for an example.
"""
if num_processes is None:
num_processes = cpu_count()
if performance_tuning:
# Since reading the file involves an awful lot of object creation
# and destruction we'll tweak the gc adjustments to sweep less frequently
# IOW - we have a LOT of short-lived objects. No sense garbage-collecting
# the latter generations very often.
# (this is about 10x, 5x, and 5x the usual)
original_threshold = gc.get_threshold()
gc.set_threshold(10 * original_threshold[0], 5 * original_threshold[1],
5 * original_threshold[1])
original_check_interval = sys.getcheckinterval()
# Similarly, we'll try to minimize overhead from thread switches
# 5x usual value
sys.setcheckinterval(5 * original_check_interval)
logging.debug("Initializing Concept storage from %s",
umls_concept_data_filename)
if umls_concept_data_filename is None:
Concept.init_storage()
else:
Concept.init_storage(StringDBDict(umls_concept_data_filename))
Pmid.init_storage()
proctitle.setproctitle("MEDRank-main")
processes = []
logging.info("Creating %d worker processes.", num_processes)
#task_queue=[JoinableQueue(queue_size) for x in xrange(num_processes)]
task_queues = [Queue(queue_size) for x in xrange(num_processes)]
this_output_queue = Queue(2 * queue_size)
# Create an output processor
output_processor = Process(target=output_callback,
args=(output_file, this_output_queue,
output_headers_callback,
output_item_callback))
output_processor.start()
for i in xrange(num_processes):
this_process = Process(
target=processor,
args=(workflow_class, graph_builder_constructor,
graph_builder_params, ranker_constructor, ranker_params,
eval_parameters, ranking_cutoff, mesh_tree_filename,
distance_matrix_filename, distance_function,
umls_converter_data_filename, extra_data_name,
extra_data_contents, task_queues[i], this_output_queue,
"MEDRank-Worker-%d" % i),
name="MEDRank-Worker-%d" % i)
logging.log(ULTRADEBUG, "Created process: %r", this_process)
this_process.start()
processes.append((this_process, this_output_queue, task_queues[i]))
all_results = {}
count = 0
# Use a single dispatch queue for automagical load balancing
# CHANGED - Now uses multiple queues to avoid starving due to waiting on semlocks
for each_article in reader:
count += 1
#queues_and_sizes=[(task_queues[x].qsize(), x)
# for x in xrange(num_processes)]
#queues_and_sizes.sort()
#target_process=queues_and_sizes[0][1]
# logging.info("Dispatching article %d: %r", count, each_article)
target_process = (count - 1) % num_processes
#Lowest-loaded process first.
logging.info("Dispatching article %d: %s to %s", count,
each_article.set_id, processes[target_process][0].name)
task_queues[target_process].put(each_article)
#task_queue[target_process].put(each_article)
#task_queue.put(each_article)
#logging.info("The task queue is approximately %d items long.",
# task_queue.qsize())
logging.log(ULTRADEBUG, "Waiting for processing to end.")
all_results = {}
alive_processes = [x for x in processes if x[0].is_alive()]
remaining_processes = len(alive_processes)
logging.info("There are %d processes (out of %d) still alive.",
remaining_processes, num_processes)
for i in xrange(remaining_processes):
alive_processes[i][2].put('STOP')
alive_processes[i][2].close()
logging.debug("Sent STOP requests. Notifying queue that no further "
"requests will come.")
logging.info("All information sent to the processors.")
# Back to normal
if performance_tuning:
gc.set_threshold(original_threshold[0], original_threshold[1],
original_threshold[2])
sys.setcheckinterval(original_check_interval)
# Note end of output
while len(processes) > 0:
a_process = processes.pop()
# We join the process to wait for the end of the reading
a_process[0].join()
# logging.log(ULTRADEBUG, "Fetching results from finished process.")
# all_results.update(a_process[1].get()) # Add results to result pool
# logging.log(ULTRADEBUG, "Received results.")
logging.info("Finishing writing out results.")
this_output_queue.put("STOP")
output_processor.join()
logging.info("Results written. Finishing multiprocessing.")
return
def main():
sys.setcheckinterval(10000) # this is not threaded application
parseCmd.init()
# setup.py is FLASH_HOME/bin/setup.py
# FLASH_HOME is the parent of directory having setup.py
flashHome = os.path.dirname(os.path.dirname(os.path.abspath(sys.argv[0])))
# Initialize other related directory names
GVars.init(flashHome)
# parse the command line arguments. The effect of calling
# this method is to set a lot of values in 'GVars'
parseCmd.parse()
############## Clean up simulation name ############################
os.chdir(GVars.simulationsDir)
if not os.path.isdir(GVars.simulationName): # Needs to be cleaned up?
# Find directories matching simulatation name (case insensitive)
simnames = dirGlob(GVars.simulationName + "*")
if len(simnames) == 1: # only one possible name
GVars.simulationName = simnames[0]
else:
if not simnames: # no match
raise SetupError("Unit %s not found" % GVars.simulationName)
else:
GVars.out.put(
"Potential completions : %s" % ', '.join(simnames),
globals.ERROR)
raise SetupError("Unit %s is ambiguous" % GVars.simulationName)
############ Proceed with other stuff ###################
os.chdir(GVars.flashHomeDir)
machDir = determineMachine()
unitList = UnitList(
) # A class which encapsulates operations of unit collections
objdir = os.path.join(GVars.flashHomeDir, GVars.objectDir)
if not os.path.isdir(objdir): os.mkdir(objdir)
if GVars.unitsFile: # copy over the user specified units file
sname = os.path.join(GVars.flashHomeDir, GVars.unitsFile)
tname = os.path.join(objdir, globals.UnitsFilename)
shutil.copy(sname, tname)
############## SWITCHING TO SOURCE DIR ############################
os.chdir(GVars.sourceDir)
if GVars.auto:
# generate and write an automatic "Units" file
unitList.generateUnitsfile()
# read units file, satisfy requirement and all the good stuf
unitList.populate()
# adjust values of command line options based on units used
# this is the only place the setup script uses its knowledge
# about Flash Units and what they do
unitList.adjustOpts()
parseCmd.final() # finalise the options
# create the object which does stuff relating to linking files
linkList = LinkFileList(objdir)
# Combine info from all Config files
configInfo = unitList.getConfigInfo()
# get Runtime Paramas info
rpInfo = unitList.getRPInfo(configInfo['max_plot_vars'])
# get info regarding all variables
varInfo = unitList.getVarInfo()
# Add library options to configInfo
for key in GVars.withLibraries.keys():
if not configInfo['LIBRARY'].has_key(key):
configInfo['LIBRARY'][key] = []
configInfo['LIBRARY'][key].append(GVars.withLibraries[key])
######### Now handle libraries depending on other libraries ##########
configInfo['libConfigInfo'] = LibUnion(configInfo['LIBRARY'])
# ConfigInfo['libConfigInfo'] is a dictionary mapping libraries to their config information
# also CLASS.libOrder is a list of pairs (libname, args)
# This order is important due to linker invocation order
configInfo['libConfigInfo'].writeLibraries(
) # write out lib data to setup_libraries
# only now is noClobber flag stable
linkList.cleanObjectDir()
############################### CHANGE TO OBJECT DIR ###################
os.chdir(GVars.flashHomeDir)
os.chdir(GVars.objectDir)
# remove the SuccessFile
try:
os.unlink(globals.SuccessFilename)
except OSError:
pass
rpInfo.writeCode(configInfo) # write Fortran code for RP support
# find files which should not be linked
linkList.getDontLinkList(unitList.getList(), configInfo['LINKIF'])
# getLinkOrder does the fancy sorting of unitnames
for unitname in unitList.getLinkOrder():
linkList.linkFiles(os.path.join(GVars.sourceDir, unitname))
linkList.linkFiles(os.path.join(GVars.flashHomeDir, 'sites'))
# Link in the right version of the make file
# attempt to find Makefile in FLASH root directory, otherwise link make file from sites
tmp_makefilePathRoot = os.path.join(flashHome,
"Makefile.h" + GVars.makefileext)
tmp_makefilePathSites = os.path.join(machDir,
"Makefile.h" + GVars.makefileext)
if os.path.isfile(tmp_makefilePathRoot):
linkList.addLink(tmp_makefilePathRoot, "Makefile.h")
print "Using Makefile.h: " + tmp_makefilePathRoot
else:
linkList.addLink(tmp_makefilePathSites, "Makefile.h")
print "Using Makefile.h: " + tmp_makefilePathSites
# functions in the simulations dir override earlier instances
linkList.linkFiles(GVars.simulationsDir)
# functions from LINKIF statements override everything else,
# assuming their conditions apply.
linkList.doLINKIFOverrides(unitList.getList(), configInfo['LINKIF'])
# now is when we do the real link/copying
linkList.reallyLink()
############## flash.par and Makefiles **************
# Copy in flash.par
if os.path.isfile(
os.path.join(GVars.simulationsDir, GVars.simulationName,
'flash.par')):
shutil.copy(
os.path.join(GVars.simulationsDir, GVars.simulationName,
'flash.par'), '.')
test_src = os.path.join(GVars.flashHomeDir, 'tools', 'scripts', 'testing',
'precision_test', 'precision_test.F90')
if os.path.isfile(test_src):
shutil.copy(test_src, '.')
GVars.out.put('creating Makefiles for all units', globals.INFO)
unitList.createMakefiles()
#FIXME merge with createMakefiles
GVars.out.put('generating buildstamp generator', globals.INFO)
generateBuildstampGenerator()
GVars.out.put('copying release accessor function Makefile', globals.INFO)
shutil.copy(os.path.join(GVars.flashHomeDir, 'bin/make_release'), '.')
GVars.out.put('copying buildstats accessor function Makefile',
globals.INFO)
shutil.copy(os.path.join(GVars.flashHomeDir, 'bin/make_bstats'), '.')
GVars.out.put('copying flashUnits accessor function Makefile',
globals.INFO)
unitList.generateSetupFlashUnits()
#shutil.copy(os.path.join(GVars.flashHomeDir, 'bin/make_flashUnits'), '.')
shutil.copy(os.path.join(GVars.flashHomeDir, 'bin/resetup'), '.')
GVars.out.put('copying Dependency generator', globals.INFO)
flist = [
"setup_depends.py", "setup_addcdepends.py", "setup_reorder.py",
"reorder.tpl"
]
for f in flist:
shutil.copy(os.path.join(GVars.flashHomeDir, 'bin/' + f), '.')
GVars.out.put('generating Makefile', globals.IMPINFO)
generateMakefile(configInfo, machDir)
# generateDbaseDefines(configInfo, opts)
generateFlashDefines(configInfo) # writes the Flash.h file
writeSimulationFiles(configInfo)
# Copy/link datafiles to object directory
if GVars.portable:
func = lambda real, link: shutil.copy2(real, link)
else:
cwd = os.getcwd()
func = lambda real, link: os.symlink(getRelPath(real, cwd), link)
datafiles = []
for wildcard in configInfo['DATAFILES']:
for file in glob.glob(os.path.join(GVars.sourceDir, wildcard)):
datafiles.append(file[len(GVars.sourceDir):].strip("/"))
bname = os.path.basename(file)
try:
func(file, bname)
except:
os.remove(bname)
func(file, bname)
simDir = os.path.join(GVars.simulationsDir, GVars.simulationName)
for wildcard in GVars.datafiles:
for file in glob.glob(os.path.join(simDir, wildcard)):
datafiles.append(file[len(GVars.sourceDir):].strip("/"))
bname = os.path.basename(file)
try:
func(file, bname)
except:
os.remove(bname)
func(file, bname)
if datafiles:
GVars.out.put('Copying data files: %d copied' % len(datafiles),
globals.IMPINFO)
# write "setup_datafiles" into object directory, even if empty
open(
os.path.join(GVars.flashHomeDir, GVars.objectDir,
globals.SetupDatafilesFilename),
'w').write("\n".join(datafiles))
if (GVars.setupVars.get("ParameshLibraryMode") or
((not GVars.setupVars.get("Grid") or
(GVars.setupVars.get("Grid").upper() == "PM4DEV")) and
(configInfo['PPDEFINES'].has_key('USE_AMR_RUNTIME_PARAMETERS_FILE') or
('-DUSE_AMR_RUNTIME_PARAMETERS_FILE' in GVars.definesNames)))):
generatePm3RPDefines(configInfo)
if GVars.parfile:
shutil.copy2(os.path.join(simDir, GVars.parfile), "flash.par")
GVars.out.put("Copied %s as flash.par" % GVars.parfile,
globals.IMPINFO)
parseCmd.writeCmdLine()
unitList.writeSetupUnitsFile()
varInfo.writeVarInfo()
# rp Stuff
rpInfo.writeRPInfo()
rpInfo.writeDefaultPar()
# if no flash.par copy default.par over
if not os.path.isfile('flash.par'):
shutil.copy(globals.RPDefaultParFilename, 'flash.par')
# create the successfile
ofd = open(globals.SuccessFilename, "w")
ofd.write("SUCCESS\n")
ofd.close()
os.chdir(GVars.flashHomeDir)
GVars.out.put('SUCCESS', globals.ALWAYS)
def done(self):
sys.setcheckinterval(4096)
import utils
import global_config
def _run_time_waster():
print('')
print('****** Starting time-waster ******')
while True:
try:
for i in range(0, 30000):
s = "a;djfalfjasdl;fajdl;fjasdf alkdfja ;ldfjal;sdfj jad;lfjasd;lfjaksdflkjd"
s = "qoroqerueouewqroiq nqeoiruq proqieu ruqoweruq eporuuqeropque r uuqoperuqowie"
s = "a;djfalfjasdl;fajdl;fjasdf alkdfja ;ldfjal;sdfj jad;lfjasd;lfjaksdflkjd"
s = "qoroqerueouewqroiq nqeoiruq proqieu ruqoweruq eporuuqeropque r uuqoperuqowie"
s = "a;djfalfjasdl;fajdl;fjasdf alkdfja ;ldfjal;sdfj jad;lfjasd;lfjaksdflkjd"
s = "qoroqerueouewqroiq nqeoiruq proqieu ruqoweruq eporuuqeropque r uuqoperuqowie"
except KeyboardInterrupt:
print('Got SIGINT (shutting down)')
break
except:
print('Got an unexpected exception')
sys.exit(1)
print('****** Exiting time-waster ******')
if __name__ == '__main__':
sys.setcheckinterval(global_config.check_interval)
_run_time_waster()
if len(failure) >= 2:
return None
print >> sys.stderr, 'Connecting to the meta-server %s:%d...' % METASERVER
try:
s = socket(AF_INET, SOCK_STREAM)
s.connect(METASERVER)
except error, e:
print >> sys.stderr, '*** cannot contact meta-server:', str(e)
failure.append(e)
return None
else:
print >> sys.stderr, 'connected.'
return s
sys.setcheckinterval(4096)
def float2str(f):
# don't trust locale issues and write a string with a '.'
s = str(long(f * 1000000.0))
return s[:-6] + '.' + s[-6:]
def str2float(s):
try:
return float(s)
except:
# locale issues may prevent float() from decoding the string
s = s.strip()
try:
def main(self):
rounds = self.values['-n']
reportfile = self.values['-f']
show_bench = self.values['-s']
compare_to = self.values['-c']
hidenoise = self.values['-d']
warp = int(self.values['-w'])
withgc = self.values['--with-gc']
limitnames = self.values['-t']
if limitnames:
if _debug:
print('* limiting test names to one with substring "%s"' % \
limitnames)
limitnames = re.compile(limitnames, re.I)
else:
limitnames = None
verbose = self.verbose
withsyscheck = self.values['--with-syscheck']
calibration_runs = self.values['-C']
timer = self.values['--timer']
print('-' * LINE)
print('PYBENCH %s' % __version__)
print('-' * LINE)
print('* using %s %s' % (
getattr(platform, 'python_implementation', lambda:'Python')(),
' '.join(sys.version.split())))
# Switch off garbage collection
if not withgc:
try:
import gc
except ImportError:
print('* Python version doesn\'t support garbage collection')
else:
try:
gc.disable()
except NotImplementedError:
print('* Python version doesn\'t support gc.disable')
else:
print('* disabled garbage collection')
# "Disable" sys check interval
if not withsyscheck:
# Too bad the check interval uses an int instead of a long...
value = 2147483647
try:
sys.setcheckinterval(value)
except (AttributeError, NotImplementedError):
print('* Python version doesn\'t support sys.setcheckinterval')
else:
print('* system check interval set to maximum: %s' % value)
if timer == TIMER_SYSTIMES_PROCESSTIME:
import systimes
print('* using timer: systimes.processtime (%s)' % \
systimes.SYSTIMES_IMPLEMENTATION)
else:
# Check that the clock function does exist
try:
get_timer(timer)
except TypeError:
print("* Error: Unknown timer: %s" % timer)
return
print('* using timer: %s' % timer)
if hasattr(time, 'get_clock_info'):
info = time.get_clock_info(timer[5:])
print('* timer: resolution=%s, implementation=%s'
% (info.resolution, info.implementation))
print()
if compare_to:
try:
f = open(compare_to,'rb')
bench = pickle.load(f)
bench.name = compare_to
f.close()
compare_to = bench
except IOError as reason:
print('* Error opening/reading file %s: %s' % (
repr(compare_to),
reason))
compare_to = None
if show_bench:
try:
f = open(show_bench,'rb')
bench = pickle.load(f)
bench.name = show_bench
f.close()
bench.print_header()
if compare_to:
bench.print_comparison(compare_to,
hidenoise=hidenoise,
limitnames=limitnames)
else:
bench.print_benchmark(hidenoise=hidenoise,
limitnames=limitnames)
except IOError as reason:
print('* Error opening/reading file %s: %s' % (
repr(show_bench),
reason))
print()
return
if reportfile:
print('Creating benchmark: %s (rounds=%i, warp=%i)' % \
(reportfile, rounds, warp))
print()
# Create benchmark object
bench = Benchmark(reportfile,
verbose=verbose,
timer=timer,
warp=warp,
calibration_runs=calibration_runs)
bench.rounds = rounds
bench.load_tests(Setup, limitnames=limitnames)
try:
bench.calibrate()
bench.run()
except KeyboardInterrupt:
print()
print('*** KeyboardInterrupt -- Aborting')
print()
return
bench.print_header()
if compare_to:
bench.print_comparison(compare_to,
hidenoise=hidenoise,
limitnames=limitnames)
else:
bench.print_benchmark(hidenoise=hidenoise,
limitnames=limitnames)
# Ring bell
sys.stderr.write('\007')
if reportfile:
try:
f = open(reportfile,'wb')
bench.name = reportfile
pickle.dump(bench,f)
f.close()
except IOError as reason:
print('* Error opening/writing reportfile')
except IOError as reason:
print('* Error opening/writing reportfile %s: %s' % (
reportfile,
reason))
print()
def tearDown(self):
if sys.version_info[:2] >= (3, 2):
sys.setswitchinterval(self._int)
else:
sys.setcheckinterval(self._int)
def setup_server(self):
"""Configure CherryPy server from application configuration.
Traverses the server configuration portion and applies parameters
known to be for CherryPy to the CherryPy server configuration.
These are: engine, hooks, log, request, respose, server, tools,
wsgi, checker.
Also applies pseudo-parameters ``thread_stack_size`` (default: 128kB)
and ``sys_check_interval`` (default: 10000). The former sets the
default stack size to desired value, to avoid excessively large
thread stacks -- typical operating system default is 8 MB, which
adds up rather a lot for lots of server threads. The latter sets
python's ``sys.setcheckinterval``; the default is to increase this
to avoid unnecessarily frequent checks for python's GIL, global
interpreter lock. In general we want each thread to complete as
quickly as possible without making unnecessary checks."""
cpconfig = cherrypy.config
# Determine server local base.
port = getattr(self.srvconfig, 'port', 8080)
local_base = getattr(self.srvconfig, 'local_base',
socket.gethostname())
if local_base.find(':') == -1:
local_base = '%s:%d' % (local_base, port)
# Set default server configuration.
cherrypy.log = Logger()
cpconfig.update({'server.max_request_body_size': 0})
cpconfig.update({'server.environment': 'production'})
cpconfig.update({'server.socket_host': '0.0.0.0'})
cpconfig.update({'server.socket_port': port})
cpconfig.update({'server.socket_queue_size': 100})
cpconfig.update({'server.thread_pool': 100})
cpconfig.update({'tools.proxy.on': True})
cpconfig.update({'tools.proxy.base': local_base})
cpconfig.update({'tools.time.on': True})
cpconfig.update({'engine.autoreload.on': False})
cpconfig.update({'request.show_tracebacks': False})
cpconfig.update(
{'request.methods_with_bodies': ("POST", "PUT", "DELETE")})
thread.stack_size(
getattr(self.srvconfig, 'thread_stack_size', 128 * 1024))
sys.setcheckinterval(
getattr(self.srvconfig, 'sys_check_interval', 10000))
self.silent = getattr(self.srvconfig, 'silent', False)
# Apply any override options from app config file.
for section in ('engine', 'hooks', 'log', 'request', 'response',
'server', 'tools', 'wsgi', 'checker'):
if not hasattr(self.srvconfig, section):
continue
for opt, value in getattr(self.srvconfig,
section).dictionary_().iteritems():
if isinstance(value, ConfigSection):
for xopt, xvalue in value.dictionary_().iteritems():
cpconfig.update(
{"%s.%s.%s" % (section, opt, xopt): xvalue})
elif isinstance(value, str) or isinstance(value, int):
cpconfig.update({"%s.%s" % (section, opt): value})
else:
raise RuntimeError(
"%s.%s should be string or int, got %s" %
(section, opt, type(value)))
# Apply security customisation.
if hasattr(self.srvconfig, 'authz_defaults'):
defsec = self.srvconfig.authz_defaults
cpconfig.update({'tools.cms_auth.on': True})
cpconfig.update({'tools.cms_auth.role': defsec['role']})
cpconfig.update({'tools.cms_auth.group': defsec['group']})
cpconfig.update({'tools.cms_auth.site': defsec['site']})
if hasattr(self.srvconfig, 'authz_policy'):
cpconfig.update(
{'tools.cms_auth.policy': self.srvconfig.authz_policy})
cherrypy.log("INFO: final CherryPy configuration: %s" %
pformat(cpconfig))
def main():
'''
'''
sys.setcheckinterval(1000000)
try:
os.nice(-20)
except OSError:
print 'Note, running as root sets this script to a higher priority'
show_progress = True
print 'Reading file...'
fsBB, music = wav.read('classical1.wav')
music = music[0:2 * fsBB] #Truncate to 2 seconds
musicL = music.T[0] #Separate out the left/right channels
musicR = music.T[1]
musicRL = musicL + musicR #merge the two channels
int16_max = float(2**15 - 1)
musicRL = musicRL / int16_max #normalize to 1
fsIF = 800000.
fc = 100000
BPL = True #Bandpass limiter, see demodulator
predeemph = True #Preemphasis and deemphasis filtering
fm_mod, kf = modulate_fm(musicRL,
fsBB,
fsIF,
debug=False,
preemph=predeemph,
fc=fc,
progress=show_progress)
T = len(fm_mod) / fsIF
t = np.linspace(0, T, T * fsIF)
plt.plot(t[0:10000], fm_mod[0:10000])
plt.show()
return
# fm_mod = AWGN_channel(fm_mod, 10, debug = False, progress = show_progress)
# fm_mod = distortion_channel(fm_mod, taps = 10, progress = show_progress)
# fm_mod = multipath_channel(fm_mod, [1e-7],
# [1], fsIF, debug = False)
# fm_mod = nonlinearphase_channel(fm_mod, taps = 12, debug = True)
fm_mod = AWGN_channel(fm_mod, 0, debug=False, progress=show_progress)
#The analog_to_digital function is only really useful for generating an
#output file, since the following arithmetic is still done with float64.
#To model the effects of quantization just add gaussian noise...
#fm_mod = analog_to_digital(fm_mod, bits = 4, rnge = [-1,1], file_out = None,
# progress = show_progress)
BB_IQ = iqdemodulate_fm(fm_mod,
fsIF,
debug=False,
deemph=predeemph,
fc=fc,
BPL=BPL,
progress=show_progress)
BB_ZX = zxdemodulate_fm(fm_mod,
fsIF,
debug=False,
deemph=predeemph,
fc=fc,
BPL=BPL,
progress=show_progress)
play(BB_IQ,
fsIF,
fsBB,
norm='inf',
debug=False,
msg='Playing IQ, inf norm')
play(BB_ZX,
fsIF,
fsBB,
norm='inf',
debug=False,
msg='Playing ZX, inf norm')
return
if sys.platform == 'win32':
# include modules directory (if it isn't already and it exists)
loc2 = os.environ['PYMOL_PATH'] + '/modules'
if os.path.exists(loc2):
if loc2 not in sys.path:
sys.path.insert(0, loc2)
# include installed numpy
loc1 = os.environ['PYMOL_PATH'] + '/modules/numeric'
if os.path.exists(loc1):
sys.path.insert(0, loc1)
if '' not in sys.path: # make sure cwd is in path like normal Python
sys.path.insert(0, '')
sys.setcheckinterval(1) # maximize responsiveness
# auto-detect bundled FREEMOL (if present)
if not os.environ.has_key("FREEMOL"):
test_path = os.path.join(os.environ['PYMOL_PATH'], "freemol")
if os.path.isdir(test_path):
os.environ['FREEMOL'] = test_path
# include FREEMOL's libpy in sys.path (if present)
if os.environ.has_key("FREEMOL"):
freemol_libpy = os.path.join(os.environ['FREEMOL'], "libpy")
if os.path.isdir(freemol_libpy):
if freemol_libpy not in sys.path:
sys.path.append(freemol_libpy)
def main(builtinParameters={}):
# Bump the GIL check interval, its more important to get any one thread to a
# blocking operation (hopefully exec) than to try and unblock other threads.
#
# FIXME: This is a hack.
import sys
sys.setcheckinterval(1000)
global options
from optparse import OptionParser, OptionGroup
parser = OptionParser("usage: %prog [options] {file-or-path}")
parser.add_option("-j",
"--threads",
dest="numThreads",
metavar="N",
help="Number of testing threads",
type=int,
action="store",
default=None)
parser.add_option("",
"--config-prefix",
dest="configPrefix",
metavar="NAME",
help="Prefix for 'lit' config files",
action="store",
default=None)
parser.add_option("",
"--param",
dest="userParameters",
metavar="NAME=VAL",
help="Add 'NAME' = 'VAL' to the user defined parameters",
type=str,
action="append",
default=[])
group = OptionGroup(parser, "Output Format")
# FIXME: I find these names very confusing, although I like the
# functionality.
group.add_option("-q",
"--quiet",
dest="quiet",
help="Suppress no error output",
action="store_true",
default=False)
group.add_option("-s",
"--succinct",
dest="succinct",
help="Reduce amount of output",
action="store_true",
default=False)
group.add_option("-v",
"--verbose",
dest="showOutput",
help="Show all test output",
action="store_true",
default=False)
group.add_option("",
"--no-progress-bar",
dest="useProgressBar",
help="Do not use curses based progress bar",
action="store_false",
default=True)
parser.add_option_group(group)
group = OptionGroup(parser, "Test Execution")
group.add_option("",
"--path",
dest="path",
help="Additional paths to add to testing environment",
action="append",
type=str,
default=[])
group.add_option("",
"--vg",
dest="useValgrind",
help="Run tests under valgrind",
action="store_true",
default=False)
group.add_option("",
"--vg-leak",
dest="valgrindLeakCheck",
help="Check for memory leaks under valgrind",
action="store_true",
default=False)
group.add_option("",
"--vg-arg",
dest="valgrindArgs",
metavar="ARG",
help="Specify an extra argument for valgrind",
type=str,
action="append",
default=[])
group.add_option("",
"--time-tests",
dest="timeTests",
help="Track elapsed wall time for each test",
action="store_true",
default=False)
group.add_option("",
"--no-execute",
dest="noExecute",
help="Don't execute any tests (assume PASS)",
action="store_true",
default=False)
parser.add_option_group(group)
group = OptionGroup(parser, "Test Selection")
group.add_option("",
"--max-tests",
dest="maxTests",
metavar="N",
help="Maximum number of tests to run",
action="store",
type=int,
default=None)
group.add_option("",
"--max-time",
dest="maxTime",
metavar="N",
help="Maximum time to spend testing (in seconds)",
action="store",
type=float,
default=None)
group.add_option("",
"--shuffle",
dest="shuffle",
help="Run tests in random order",
action="store_true",
default=False)
group.add_option("",
"--filter",
dest="filter",
metavar="REGEX",
help=("Only run tests with paths matching the given "
"regular expression"),
action="store",
default=None)
parser.add_option_group(group)
group = OptionGroup(parser, "Debug and Experimental Options")
group.add_option("",
"--debug",
dest="debug",
help="Enable debugging (for 'lit' development)",
action="store_true",
default=False)
group.add_option("",
"--show-suites",
dest="showSuites",
help="Show discovered test suites",
action="store_true",
default=False)
group.add_option("",
"--repeat",
dest="repeatTests",
metavar="N",
help="Repeat tests N times (for timing)",
action="store",
default=None,
type=int)
parser.add_option_group(group)
(opts, args) = parser.parse_args()
if not args:
parser.error('No inputs specified')
if opts.numThreads is None:
# Python <2.5 has a race condition causing lit to always fail with numThreads>1
# http://bugs.python.org/issue1731717
# I haven't seen this bug occur with 2.5.2 and later, so only enable multiple
# threads by default there.
if sys.hexversion >= 0x2050200:
opts.numThreads = Util.detectCPUs()
else:
opts.numThreads = 1
inputs = args
# Create the user defined parameters.
userParams = dict(builtinParameters)
for entry in opts.userParameters:
if '=' not in entry:
name, val = entry, ''
else:
name, val = entry.split('=', 1)
userParams[name] = val
# Create the global config object.
litConfig = LitConfig.LitConfig(progname=os.path.basename(sys.argv[0]),
path=opts.path,
quiet=opts.quiet,
useValgrind=opts.useValgrind,
valgrindLeakCheck=opts.valgrindLeakCheck,
valgrindArgs=opts.valgrindArgs,
noExecute=opts.noExecute,
ignoreStdErr=False,
debug=opts.debug,
isWindows=(platform.system() == 'Windows'),
params=userParams,
config_prefix=opts.configPrefix)
tests = lit.discovery.find_tests_for_inputs(litConfig, inputs)
if opts.showSuites:
suitesAndTests = {}
for t in tests:
if t.suite not in suitesAndTests:
suitesAndTests[t.suite] = []
suitesAndTests[t.suite].append(t)
print '-- Test Suites --'
suitesAndTests = suitesAndTests.items()
suitesAndTests.sort(key=lambda (ts, _): ts.name)
for ts, ts_tests in suitesAndTests:
print ' %s - %d tests' % (ts.name, len(ts_tests))
print ' Source Root: %s' % ts.source_root
print ' Exec Root : %s' % ts.exec_root
# Select and order the tests.
numTotalTests = len(tests)
# First, select based on the filter expression if given.
if opts.filter:
try:
rex = re.compile(opts.filter)
except:
parser.error("invalid regular expression for --filter: %r" %
(opts.filter))
tests = [t for t in tests if rex.search(t.getFullName())]
# Then select the order.
if opts.shuffle:
random.shuffle(tests)
else:
tests.sort(key=lambda t: t.getFullName())
# Finally limit the number of tests, if desired.
if opts.maxTests is not None:
tests = tests[:opts.maxTests]
# Don't create more threads than tests.
opts.numThreads = min(len(tests), opts.numThreads)
extra = ''
if len(tests) != numTotalTests:
extra = ' of %d' % numTotalTests
header = '-- Testing: %d%s tests, %d threads --' % (len(tests), extra,
opts.numThreads)
if opts.repeatTests:
tests = [
t.copyWithIndex(i) for t in tests for i in range(opts.repeatTests)
]
progressBar = None
if not opts.quiet:
if opts.succinct and opts.useProgressBar:
try:
tc = ProgressBar.TerminalController()
progressBar = ProgressBar.ProgressBar(tc, header)
except ValueError:
print header
progressBar = ProgressBar.SimpleProgressBar('Testing: ')
else:
print header
startTime = time.time()
display = TestingProgressDisplay(opts, len(tests), progressBar)
provider = TestProvider(tests, opts.maxTime)
try:
import win32api
except ImportError:
pass
else:
def console_ctrl_handler(type):
provider.cancel()
return True
win32api.SetConsoleCtrlHandler(console_ctrl_handler, True)
runTests(opts.numThreads, litConfig, provider, display)
display.finish()
if not opts.quiet:
print 'Testing Time: %.2fs' % (time.time() - startTime)
# Update results for any tests which weren't run.
for t in tests:
if t.result is None:
t.setResult(Test.UNRESOLVED, '', 0.0)
# List test results organized by kind.
hasFailures = False
byCode = {}
for t in tests:
if t.result not in byCode:
byCode[t.result] = []
byCode[t.result].append(t)
if t.result.isFailure:
hasFailures = True
# FIXME: Show unresolved and (optionally) unsupported tests.
for title, code in (('Unexpected Passing Tests', Test.XPASS),
('Failing Tests', Test.FAIL)):
elts = byCode.get(code)
if not elts:
continue
print '*' * 20
print '%s (%d):' % (title, len(elts))
for t in elts:
print ' %s' % t.getFullName()
print
if opts.timeTests:
# Collate, in case we repeated tests.
times = {}
for t in tests:
key = t.getFullName()
times[key] = times.get(key, 0.) + t.elapsed
byTime = list(times.items())
byTime.sort(key=lambda (name, elapsed): elapsed)
if byTime:
Util.printHistogram(byTime, title='Tests')
for name, code in (
('Expected Passes ', Test.PASS),
('Expected Failures ', Test.XFAIL),
('Unsupported Tests ', Test.UNSUPPORTED),
('Unresolved Tests ', Test.UNRESOLVED),
('Unexpected Passes ', Test.XPASS),
('Unexpected Failures', Test.FAIL),
):
if opts.quiet and not code.isFailure:
continue
N = len(byCode.get(code, []))
if N:
print ' %s: %d' % (name, N)
# If we encountered any additional errors, exit abnormally.
if litConfig.numErrors:
print >> sys.stderr, '\n%d error(s), exiting.' % litConfig.numErrors
sys.exit(2)
# Warn about warnings.
if litConfig.numWarnings:
print >> sys.stderr, '\n%d warning(s) in tests.' % litConfig.numWarnings
if hasFailures:
sys.exit(1)
sys.exit(0)
def ProxyDaemon(log_file='/var/log/ssl_proxy_access.log',
HandlerClass=ProxyRequestHandler,
ServerClass=ProxyServer,
protocol="HTTP/1.0",
thread=True,
interactive=False,
port=1443,
spoof_ssl_config={'DEFAULT': True},
display_filter=None,
cert=None,
dump_payload=False,
http_redirect_table={},
ssl_redirect_table={},
log=logging):
sys.setcheckinterval(10)
server_address = ('0.0.0.0', port)
HandlerClass.protocol_version = protocol
HandlerClass.cert = cert
HandlerClass.spoof_ssl_config = spoof_ssl_config
HandlerClass.log = log
# Example for http_redirect_table:
# http_redirect_table == {'https://host.example.com:443/(foo/.*)':
# 'http://otherhost.example.com:7433/\1'}
# This will match URLs like https://host.example.com:443/foo/bar
# And rewrite them as http://otherhost.example.com:7433/foo/bar
# Before making connections.
HandlerClass.http_redirect_table = http_redirect_table
# Example for ssl_redirect_table:
# ssl_redirect_table == {('orig.example.com', 443):
# ('new_dest.example.com', 443)}
HandlerClass.ssl_redirect_table = ssl_redirect_table
HandlerClass.dump_payload = dump_payload
if interactive:
HandlerClass.interactive = True
HandlerClass.display_filter = display_filter
log_fh = None
else:
try:
log_fh = open(log_file, 'a')
except:
log.fatal('Could not open access log: %s' % log_file)
sys.exit(os.EX_CANTCREAT)
HandlerClass.log_file = log_fh
HandlerClass.interactive = False
if thread:
reusable_socketserver = SocketServer.ThreadingTCPServer
else:
reusable_socketserver = SocketServer.TCPServer
reusable_socketserver.allow_reuse_address = True
reusable_socketserver.daemon_threads = True
try:
httpd = reusable_socketserver(server_address, HandlerClass)
except socket.error:
log.exception('Could not bind to %s:%s' % server_address)
sys.exit(os.EX_OSERR)
sa = httpd.socket.getsockname()
log.info('Listening on %s port %s ...' % (sa[0], sa[1]))
# Need to get the logfile closed before the shutdown happens.
try:
httpd.serve_forever()
except KeyboardInterrupt:
log.info('Shutting down from keyboard...')
if log_fh:
log_fh.close()
except:
if log_fh:
log_fh.close()
log.exception('Exception after serve_forever')
raise
