def load_environment(global_conf, app_conf): """Configure the Pylons environment via the ``pylons.config`` object """ # Pylons paths root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) paths = dict(root=root, controllers=os.path.join(root, 'controllers'), static_files=os.path.join(root, 'public'), templates=[os.path.join(root, 'templates')]) # Initialize config with the basic options config.init_app(global_conf, app_conf, package='hewwolord', paths=paths) config['routes.map'] = make_map() config['pylons.app_globals'] = app_globals.Globals() config['pylons.h'] = hewwolord.lib.helpers # Create the Genshi TemplateLoader config['pylons.app_globals'].genshi_loader = TemplateLoader( paths['templates'], auto_reload=True) # Setup the SQLAlchemy database engine if 'sqlalchemy.module' in config: config['sqlalchemy.module'] = __import__(config['sqlalchemy.module']) engine = engine_from_config(config, 'sqlalchemy.') try: import coev flagdict = { 'coev.debug.lib.coev': coev.CDF_COEV, 'coev.debug.lib.coev.dump': coev.CDF_COEV_DUMP, 'coev.debug.lib.colock': coev.CDF_COLOCK, 'coev.debug.lib.colock.dump': coev.CDF_COLOCK_DUMP, 'coev.debug.lib.nbuf': coev.CDF_NBUF, 'coev.debug.lib.nbuf.dump': coev.CDF_NBUF_DUMP, 'coev.debug.lib.runq.dump': coev.CDF_RUNQ_DUMP, 'coev.debug.lib.stack': coev.CDF_STACK, 'coev.debug.lib.stack.dump': coev.CDF_STACK_DUMP } lib_debug_flags = 0 for f in flagdict: if asbool(config.get(f, False)): lib_debug_flags |= flagdict[f] coev.setdebug( asbool(config.get('coev.debug.module', False)), lib_debug_flags ) import thread thread.stack_size(int(config.get('coev.stack.size', 2 * 1024 * 1024))) except ImportError: pass mcservers = aslist(config['memcache.servers']) mcdebug = asbool(config['memcache.debug']) init_model(engine, mcservers, mcdebug)
def setup_app(command, conf, vars): """Place any commands to setup quanthistling here""" thread.stack_size(512 * 1024) # Don't reload the app if it was loaded under the testing environment if not pylons.test.pylonsapp: load_environment(conf.global_conf, conf.local_conf) # Create the tables if they don't already exist metadata.create_all(bind=Session.bind)
def test_stack_size(): import sys if is_cli or (sys.version_info[0] == 2 and sys.version_info[1] > 4) or sys.version_info[0] > 2: import thread size = thread.stack_size() Assert(size==0 or size>=32768) bad_size_list = [ 1, -1, -32768, -32769, -32767, -40000, 32767, 32766] for bad_size in bad_size_list: AssertError(ValueError, thread.stack_size, bad_size) good_size_list = [4096*10, 4096*100, 4096*1000, 4096*10000] for good_size in good_size_list: #CodePlex Work Item 7827 if (is_cli or is_silverlight) and good_size<=50000: print "Ignoring", good_size, "for CLI"; continue temp = thread.stack_size(good_size) Assert(temp>=32768 or temp==0) def temp(): pass thread.start_new_thread(temp, ()) temp = thread.stack_size(1024*1024) Assert(temp>=32768 or temp==0)
def test_stack_size(self): import thread thread.stack_size(0) res = thread.stack_size(0) assert res == 0 res = thread.stack_size(1024*1024) assert res == 0 res = thread.stack_size(2*1024*1024) assert res == 1024*1024 res = thread.stack_size(0) assert res == 2*1024*1024
def hashtag_stream(hashtags, auth): print "listening for %s" % ",".join(hashtags) twitter_stream = TwitterStream(auth=auth) try: iterator = twitter_stream.statuses.filter(track=",".join(hashtags)) except: time.sleep(3) iterator = twitter_stream.statuses.filter(track=",".join(hashtags)) while True: print "*"*40 print "stack size: %d" % thread.stack_size() print "started thread worker for %s" % ",".join(hashtags) for tweet in iterator: try: hashtag = "#" try: for htag in hashtags: if htag in str(tweet["text"]): hashtag = str(htag) err_count = bayespell.errors(tweet["text"]) if hashtag.strip() != "#": print hashtag, err_count hashtag_object = Hashtag.objects.get(tag=hashtag) hashtag_object.typos = hashtag_object.typos + err_count hashtag_object.save() except: pass continue except: time.sleep(3) twitter_stream = TwitterStream(auth=auth) try: iterator = twitter_stream.statuses.filter(track=",".join(hashtags)) except: time.sleep(3) iterator = twitter_stream.statuses.filter(track=",".join(hashtags)) continue
filename = 'SCC.txt' vert_number = 875714 max_scc_count = 5 def all(): count = 0 list_ = [] with open(filename, 'r') as f: for line in f: node_list = line.split() edge = Edge(int(node_list[0]),int(node_list[1])) list_.append(edge) count += 1 if count % 50000 == 0: logw("edges loaded from file:", count) compute_scc(list_) logw(list(reversed(max_scc))) # need to overcome recursion depth limits in python # other way - rewrite recursion to loop using own stack sys.setrecursionlimit(100000) thread.stack_size(2**27) #just big size thread = threading.Thread( target = all ) start_time = time.clock() thread.start() thread.join() print time.clock() - start_time
import sys import thread sys.setrecursionlimit(10300) thread.stack_size(1024 * 80) n = input() l = [] for i in range(n): l += [list(map(int, raw_input().split()))] check = [] def isOK(x, y): global n if x < 0 or x >= n: return False if y < 0 or y >= n: return False return True def dfs(x, y): global check, l, level if check[y][x] > 0: return check[y][x] = 1 delta = [(1, 0), (0, 1), (0, -1), (-1, 0)] for a, b in delta: if isOK(a + x, b + y) and l[b + y][a + x] > level: dfs(a + x, b + y) return
import thread thread.stack_size(512 * 1024)
dest="total", type="int", default=None, help="total number of sessions to generate") parser.add_option("-d", "--duration", dest="duration", type="int", default=1, help="total number of seconds to generate load") parser.add_option("-n", "--seed", dest="seed", type="int", default=100, help="random number generator seed") (options, args) = parser.parse_args() # seed random number generator random.seed(options.seed) thread.stack_size(50000) # launch generator wg = WorkloadGenerator(options.host, options.port, options.load) if options.total: wg.startTotal(options.total) else: wg.startDuration(options.duration)
#with open('SCCTest.txt', 'r') as f: #with open('SCCTest2.txt', 'r') as f: lines = f.readlines() x = 0 for line in lines: if 0 == (x % 10000): print 'Read %d' % x edge = line.split() edge[0] = int(edge[0]) - 1 edge[1] = int(edge[1]) - 1 edges[edge[0]].append(edge[1]) revEdges[edge[1]].append(edge[0]) x += 1 print 'Loaded' sys.setrecursionlimit(100000) thread.stack_size(2**27) t1 = threading.Thread(target = scc) begin = time.clock() t1.start() # start the scc thread t1.join() # and wait for it to finish print time.clock() - begin #scc() #print 'Done' l = [] for scc in sccs: l.append(len(scc)) l.sort() l.reverse() s = '' for i in xrange(5): if i >= len(l): s += '0,' else: s += str(l[i]) + ','
import re import thread import traceback thread.stack_size(1024 * 512) # reduce vm size class Input(dict): def __init__(self, conn, raw, prefix, command, params, nick, user, host, paraml, msg): server = conn.server_host chan = paraml[0].lower() if chan == conn.nick.lower(): # is a PM chan = nick def say(msg): conn.msg(chan, msg) def reply(msg): if chan == nick: # PMs don't need prefixes self.say(msg) else: self.say(nick + ': ' + msg) def pm(msg, nick=nick): conn.msg(nick, msg) def set_nick(nick):
if __name__ == "__main__": gc.set_debug(gc.DEBUG_LEAK) parser = optparse.OptionParser(usage="%prog -h [host] -p [port] -l [load (sessions/s)] -d [duration (seconds)] -t [total (sessions)] -n [seed]", version="%prog 1.0") parser.add_option("-s", "--server", dest="host", type="str", default="localhost", help= "server to connect to") parser.add_option("-p", "--port", dest="port", type="int", default=80, help= "port number to connect to") parser.add_option("-l", "--load", dest="load", type="int", default=1, help= "number of sessions to create per second") parser.add_option("-t", "--total", dest="total", type="int", default=None, help= "total number of sessions to generate") parser.add_option("-d", "--duration", dest="duration", type="int", default=1, help= "total number of seconds to generate load") parser.add_option("-n", "--seed", dest="seed", type="int", default=100, help= "random number generator seed") (options, args) = parser.parse_args() # seed random number generator random.seed(options.seed) thread.stack_size(50000) # launch generator wg = WorkloadGenerator(options.host, options.port, options.load) if options.total: wg.startTotal(options.total) else: wg.startDuration(options.duration)
def thread_stack_size(size=None): if size is not None: raise thread.ThreadError() # doesn't really apply, but whatever return thread.stack_size()
import thread import traceback thread.stack_size(1024 * 512) # reduce vm size class Input(dict): def __init__(self, conn, raw, prefix, command, params, nick, user, host, paraml, msg): chan = paraml[0].lower() if chan == conn.nick.lower(): # is a PM chan = nick def say(msg): conn.msg(chan, msg) def reply(msg): if chan == nick: # PMs don't need prefixes conn.msg(chan, msg) else: conn.msg(chan, nick + ': ' + msg) def pm(msg): conn.msg(nick, msg) def set_nick(nick): conn.set_nick(nick) def me(msg): conn.msg(chan, "\x01%s %s\x01" % ("ACTION", msg))
print 'finding top five largest SCCs...' dfs_loop_1st(g) dfs_loop_2nd(g) # filler is just to make the sort function works # because g.vertices[0] is not used filler = Vertex() g.vertices[0] = filler top_scc_s = sorted(g.vertices, key=lambda vertex: vertex.minions, reverse=True) for i in range(5): v = top_scc_s[i] print 'label:{0} t:{1} minions:{2}'.format(v.label, v.fscore, v.minions) # with the recursive way, two parameters need to be adjusted: # (because the DFS recursive method can go really deep here) # the default python recursive limit is 1000, which is not enough for the hw problem set # the default thread stack size is 1mb? which is also not enough for the hw problem set # (got the following code from the course's forum) import sys, thread, threading, time sys.setrecursionlimit(100000) thread.stack_size(2**27) t1 = threading.Thread(target=kosaraju, args=()) begin = time.clock() t1.start() # start the scc thread t1.join() # and wait for it to finish print time.clock() - begin
import sys import random import time from Tkinter import * import ImageTk from threading import Thread import thread thread.stack_size(2**17) # allow some more threads RADIUS=2 WIDTH, HEIGHT = 400, 400 FPS=40 COLOR_GREEN = "#00FF00" COLOR_GRAY = "#DDDDDD" COLOR_YELLOW = "#FAFAC8" class Timer(Thread): "executes a task repeatedly " def __init__(self, update=None, wait_time=1.0): Thread.__init__(self) self.wait_time = wait_time # in secs as float self.update = update self.running = True def run(self): while self.running: time.sleep(self.wait_time) if self.running: self.update()
global edgeOut explored[startVertex] = True leader[startVertex] = s leaders[s].append(startVertex) for edgeOut in edgesOut[startVertex]: if not explored[edgeOut]: DFS(edgeOut) import sys, thread, threading, time from math import * sys.setrecursionlimit(100000) # don't know what I actually needed here thread.stack_size( 2**27 ) # largest power of 2 that didn't give me an error, don't know what I needed begin = time.clock() print "opening file..." filehandle = open("2sat6.txt") lines = filehandle.readlines() maxN = int(lines[0]) lines = lines[1:] filehandle.close() edges = [0] * (2 * len(lines)) for i in range(len(lines)): line = lines[i] # if(i%1000==0): # print ".",
def run(self): # If we can, replace lgTaskProcessor with lgTaskSlave in our title try: import setproctitle title = setproctitle.getproctitle() if 'lgTaskProcessor' in title: title = title.replace('lgTaskProcessor', 'lgTaskSlave') else: title += ' --slave' setproctitle.setproctitle(title) except ImportError: pass # We're in our own process now, so disconnect the processor's # pymongo connection to make sure we don't hold those sockets open self._processor.taskConnection.close() # Also, ensure that the global talk variables weren't copied over. # This only affects testing situations - that is, the normal processor # process won't use talk. import lgTask.talk lgTask.talk.talkConnection.resetFork() canQsize = True try: self._queue.qsize() except NotImplementedError: # Oh Mac OS X, how silly you are sometimes canQsize = False self._fixSigTerm() # rconsole? if self._processor._useRConsole: import lgTask.lib.rfooUtil as rfooUtil rfooUtil.spawnServer() # Any tasks that we start only really need a teeny bit of stack thread.stack_size(1024 * 1024) try: while True: try: # See if we should be marked as accepting new tasks from # the Processor if self._isAccepting.value: self._checkAccepting() # Check tasks are running self._checkRunning() # Get new task taskData = self._queue.get( timeout = self._processor.KILL_INTERVAL ) taskThread = InterruptableThread( target = self._runTaskThreadMain , args = (taskData,) ) # Remember the ID so that we can check for "kill" states taskThread.taskId = taskData['_id'] taskThread.start() self._running.append(taskThread) # Update running count newCount = len(self._running) if canQsize: newCount += self._queue.qsize() self._runningCount.value = newCount except Empty: pass except Exception: self._processor.log("Slave error {0}: {1}".format( self.pid, traceback.format_exc() )) # After each iteration, see if we're alive if not self._shouldContinue(): break except: self._processor.log("Slave error {0}: {1}".format( self.pid, traceback.format_exc() )) finally: pass
import gc import sys from threading import Timer import thread thread.stack_size(1024 * 1024) # 1Mb, default is 8Mb # Setup hourly garbage collection (and stats printing) def _gc_collect(): # shows all the memleak info and stores # uncollectable objects to gc.garbage # sys.stderr.write("\n-- DUMP BEGIN --\n") # gc.set_debug(gc.DEBUG_LEAK) gc.collect() # sys.stderr.write("Uncollectable unreachable objects (sorry):\n") # for obj in gc.garbage: # try: # sys.stderr.write("%s\n" % (obj,)) # except: # pass # sys.stderr.write("Quantity: %s\n" % (len(gc.garbage),)) # sys.stderr.write("\n-- DUMP END --\n") # gc.set_debug(False) # now empty the list # del gc.garbage[:] # gc.collect() _setup_timer()
parser.add_argument('--socket', nargs='?', metavar='PATH', help='path of the local socket') parser.add_argument('--logfile', nargs='?', metavar='PATH', help='path of the log file') args = parser.parse_args() # stderr doesn't work with FastCGI; the following is a hack to get a # log file with diagnostics anyway if args.logfile: sys.stderr = sys.stdout = file(args.logfile, 'a') prev_sys_path = list(sys.path) new_sys_path = [] for item in list(sys.path): if item not in prev_sys_path: new_sys_path.append(item) sys.path.remove(item) sys.path[:0] = new_sys_path sys.path.append(os.path.dirname(sys.argv[0])) thread.stack_size(524288) wsgi_app = loadapp('config:' + os.path.abspath(args.config_file)) logging.config.fileConfig(args.config_file) if __name__ == '__main__': WSGIServer(wsgi_app, bindAddress=args.socket, umask=0, minSpare=1, maxSpare=5, maxThreads=50).run()
sccCountList.sort(reverse=True) print sccCountList[:5] if __name__ == "__main__": sys.setrecursionlimit(200000) nodelist = [] F = [Node()] count = 0 leader = None for i in xrange(875715): nodelist.append(Node()) read = open("SCC.txt", 'rb') line = read.readline() while line: nodes = line.split() if len(nodes) == 0: line = read.readline() continue firstIdx = int(nodes[0]) secondIdx = int(nodes[1]) if firstIdx != secondIdx: nodelist[firstIdx].To.append(secondIdx) nodelist[secondIdx].From.append(firstIdx) line = read.readline() read.close() thread.stack_size(1048576 * 128) thread.start_new_thread(ThreadGraph, (nodelist, ))
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})
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})
done.release() print ('\n*** Barrier Test ***') if done.acquire(0): raise ValueError("'done' should have remained acquired") bar = barrier(numtasks) running = numtasks for i in range(numtasks): thread.start_new_thread(task2, (i,)) done.acquire() print ('all tasks done') if hasattr(thread, 'stack_size'): # not all platforms support changing thread stack size print ('\n*** Changing thread stack size ***') if thread.stack_size() != 0: raise ValueError("initial stack_size not 0") thread.stack_size(0) if thread.stack_size() != 0: raise ValueError("stack_size not reset to default") from os import name as os_name if os_name in ("nt", "os2", "posix"): tss_supported = 1 try: thread.stack_size(4096) except ValueError: print ('caught expected ValueError setting stack_size(4096)') except thread.error:
import thread import traceback thread.stack_size(1024 * 512) # Reduce VM size class Input(dict): def __init__(self, conn, raw, prefix, command, params, nick, user, host, paraml, msg): chan = paraml[0].lower() if chan == conn.nick.lower(): # Is a PM chan = nick def say(msg): conn.msg(chan, msg) def reply(msg): if chan == nick: # PMs don't need prefixes conn.msg(chan, msg) else: conn.msg(chan, nick + ': ' + msg) def pm(msg): conn.msg(nick, msg) def set_nick(nick): conn.set_nick(nick) def me(msg):
import thread thread.stack_size(128*1024) import socket import re import WMCore.HTTPFrontEnd.RequestManager.ReqMgrConfiguration as ReqMgrConfig __all__ = [] from WMCore.WMInit import getWMBASE import os.path INSTALL = getWMBASE() HOST = socket.getfqdn().lower() COUCH = "https://%s/couchdb" % HOST ADD_MONITOR_FLAG = False if re.match(r"^vocms0(?:13[689]|140|16[135]|30[67]|318)\.cern\.ch$", HOST): COUCH = "https://cmsweb.cern.ch/couchdb" elif re.match(r"^vocms0(?:13[12])\.cern\.ch$", HOST): COUCH = "https://cmsweb-testbed.cern.ch/couchdb" elif re.match(r"^vocms0127\.cern\.ch$", HOST): COUCH = "https://cmsweb-dev.cern.ch/couchdb" config = ReqMgrConfig.reqMgrConfig(installation=INSTALL, couchurl = COUCH, addMonitor = ADD_MONITOR_FLAG) TEMPLATES = os.path.normpath(os.path.join(INSTALL, '../../../data/templates/WMCore/WebTools')) JAVASCRIPT_PATH = os.path.normpath(os.path.join(INSTALL, '../../../data/javascript')) HTML_PATH = os.path.normpath(os.path.join(INSTALL, '../../../data/html')) config.webapp_("reqmgr") config.reqmgr.html = os.path.join(HTML_PATH, 'RequestManager')
done.release() print '\n*** Barrier Test ***' if done.acquire(0): raise ValueError, "'done' should have remained acquired" bar = barrier(numtasks) running = numtasks for i in range(numtasks): thread.start_new_thread(task2, (i, )) done.acquire() print 'all tasks done' # not all platforms support changing thread stack size print '\n*** Changing thread stack size ***' if thread.stack_size() != 0: raise ValueError, "initial stack_size not 0" thread.stack_size(0) if thread.stack_size() != 0: raise ValueError, "stack_size not reset to default" from os import name as os_name if os_name in ("nt", "os2", "posix"): tss_supported = 1 try: thread.stack_size(4096) except ValueError: print 'caught expected ValueError setting stack_size(4096)' except thread.error:
explored[startVertex]=True leader[startVertex]=s leaders[s].append(startVertex) for edgeOut in edgesOut[startVertex]: if not explored[edgeOut]: DFS(edgeOut) import sys, thread, threading, time from math import* sys.setrecursionlimit(100000) # don't know what I actually needed here thread.stack_size(2**27) # largest power of 2 that didn't give me an error, don't know what I needed begin = time.clock() print "opening file..." filehandle=open("2sat6.txt") lines=filehandle.readlines() maxN=int(lines[0]) lines=lines[1:] filehandle.close() edges=[0]*(2*len(lines)) for i in range(len(lines)): line=lines[i] # if(i%1000==0): # print ".",
def test_stack_size(self): # Various stack size tests. self.assertEquals(thread.stack_size(), 0, "intial stack size is not 0") thread.stack_size(0) self.assertEquals(thread.stack_size(), 0, "stack_size not reset to default") if os.name not in ("nt", "os2", "posix"): return tss_supported = True try: thread.stack_size(4096) except ValueError: verbose_print("caught expected ValueError setting " "stack_size(4096)") except thread.error: tss_supported = False verbose_print("platform does not support changing thread stack " "size") if tss_supported: fail_msg = "stack_size(%d) failed - should succeed" for tss in (262144, 0x100000, 0): thread.stack_size(tss) self.assertEquals(thread.stack_size(), tss, fail_msg % tss) verbose_print("successfully set stack_size(%d)" % tss) for tss in (262144, 0x100000): verbose_print("trying stack_size = (%d)" % tss) self.next_ident = 0 self.created = 0 for i in range(NUMTASKS): self.newtask() verbose_print("waiting for all tasks to complete") self.done_mutex.acquire() verbose_print("all tasks done") thread.stack_size(0)
#from devices.device_base import DeviceBase from devices.xbee.xbee_devices.xbee_base import XBeeBase from devices.xbee.xbee_devices.xbee_serial import XBeeSerial from settings.settings_base import SettingsBase, Setting from channels.channel_source_device_property import * from common.types.boolean import Boolean, STYLE_ONOFF from devices.xbee.xbee_config_blocks.xbee_config_block_ddo \ import XBeeConfigBlockDDO from devices.xbee.xbee_device_manager.xbee_device_manager_event_specs \ import * from devices.xbee.common.addressing import * from devices.xbee.common.prodid import RCS_THERMOSTAT import time import thread thread.stack_size(2048*1024) # classes class XBeeSerialTerminal(XBeeSerial): """\ This class extends one of our base classes and is intended as an example of a concrete, example implementation, but it is not itself meant to be included as part of our developer API. Please consult the base class documentation for the API and the source code for this file for an example implementation. """ ADDRESS_TABLE = [ [0xe8, 0xc105, 0x11] ]
help='shuffle mode (true or false)', required=True) subparser.add_argument('-f1', '--file1', help='output file name 1', required=True) subparser.add_argument('-r1', '--ratio1', help='output file ratio(%) 1') subparser.add_argument('-f2', '--file2', help='output file name 2') subparser.add_argument('-r2', '--ratio2', help='output file ratio(%) 2') subparser.set_defaults( func=create_image_classification_dataset_command) except: pass args = parser.parse_args() args.func(args) if __name__ == '__main__': import thread import threading thread.stack_size(128 * 1024 * 1024) sys.setrecursionlimit(0x3fffffff) main_thread = threading.Thread(target=main) main_thread.start() main_thread.join()
from src import systasks from src import widgets from src.config import config if config['local-access-only']: bindto = '127.0.0.1' else: bindto = '0.0.0.0' cherrypy.process.servers.check_port(bindto, config['http-port'], timeout=1.0) cherrypy.process.servers.check_port(bindto, config['https-port'], timeout=1.0) MyExternalIPAdress = util.updateIP() thread.stack_size(256000) if config['change-process-title']: try: import setproctitle setproctitle.setproctitle("kaithem") except: pass if config['enable-websockets']: from ws4py.server.cherrypyserver import WebSocketPlugin, WebSocketTool from ws4py.websocket import EchoWebSocket WebSocketPlugin(cherrypy.engine).subscribe() cherrypy.tools.websocket = WebSocketTool()