def updateCache(self):
        # Import Psyco if available and not disabled
        import platform
        if platform.machine() in ['i386', 'i486', 'i586', 'i686']:
            if not self.configuration.disable_psyco:
                try:
                    import psyco
                except ImportError:
                    bb.msg.note(1, bb.msg.domain.Collection, "Psyco JIT Compiler (http://psyco.sf.net) not available. Install it to increase performance.")
                else:
                    psyco.bind( self.parse_bbfiles )
            else:
                bb.msg.note(1, bb.msg.domain.Collection, "You have disabled Psyco. This decreases performance.")

        self.status = bb.cache.CacheData()

        ignore = bb.data.getVar("ASSUME_PROVIDED", self.configuration.data, 1) or ""
        self.status.ignored_dependencies = Set( ignore.split() )

        self.handleCollections( bb.data.getVar("BBFILE_COLLECTIONS", self.configuration.data, 1) )

        bb.msg.debug(1, bb.msg.domain.Collection, "collecting .bb files")
        (filelist, masked) = self.collect_bbfiles()
        bb.data.renameVar("__depends", "__base_depends", self.configuration.data)
        self.parse_bbfiles(filelist, masked, self.myProgressCallback)
        bb.msg.debug(1, bb.msg.domain.Collection, "parsing complete")

        self.buildDepgraph()

    def fbenchmark(f, var=[Symbol("x")]):
        """
        Do some benchmarks with f using clambdify, lambdify and psyco.
        """
        global cf, pf, psyf
        start = time()
        cf = clambdify(var, f)
        print "compile time (including sympy overhead): %f s" % (time() - start)
        pf = lambdify(var, f, "math")
        psyf = None
        try:
            import psyco

            psyf = lambdify(var, f, "math")
            psyco.bind(psyf)
        except ImportError:
            pass
        code = """for x in (i/1000. for i in range(1000)):
        f(%s)""" % (
            "x," * len(var)
        ).rstrip(
            ","
        )
        t1 = Timer(code, "from __main__ import cf as f")
        t2 = Timer(code, "from __main__ import pf as f")
        if psyf:
            t3 = Timer(code, "from __main__ import psyf as f")
        else:
            t3 = None
        print "for x = (0, 1, 2, ..., 999)/1000"
        print "20 times in 3 runs"
        print "compiled:      %.4f %.4f %.4f" % tuple(t1.repeat(3, 20))
        print "Python lambda: %.4f %.4f %.4f" % tuple(t2.repeat(3, 20))
        if t3:
            print "Psyco lambda:  %.4f %.4f %.4f" % tuple(t3.repeat(3, 20))

def main(n=1000, n_iter=100):
    print "Doing %d iterations on a %dx%d grid" % (n_iter, n, n)
    methods = ["numeric", "blitz", "inline", "fastinline"]
    # 'pyrex',
    #'fortran77', 'fortran90-arrays', 'fortran95-forall']
    for i in methods:
        print i,
        sys.stdout.flush()
        print "took", time_test(n, n, stepper=i, n_iter=n_iter), "seconds"

    print "slow (1 iteration)",
    sys.stdout.flush()
    s = time_test(n, n, stepper="slow", n_iter=1)
    print "took", s, "seconds"
    print "%d iterations should take about %f seconds" % (n_iter, s * n_iter)

    try:
        import psyco
    except ImportError:
        print "You don't have Psyco installed!"
    else:
        psyco.bind(LaplaceSolver)
        psyco.bind(Grid)
        print "slow with Psyco (1 iteration)",
        sys.stdout.flush()
        s = time_test(n, n, stepper="slow", n_iter=1)
        print "took", s, "seconds"
        print "%d iterations should take about %f seconds" % (n_iter, s * n_iter)

 def fbenchmark(f, var=[Symbol('x')]):
     """
     Do some benchmarks with f using clambdify, lambdify and psyco.
     """
     global cf, pf, psyf
     start = time()
     cf = clambdify(var, f)
     print 'compile time (including sympy overhead): %f s' % (time() - start)
     pf = lambdify(var, f, 'math')
     psyf = None
     try:
         import psyco
         psyf = lambdify(var, f, 'math')
         psyco.bind(psyf)
     except ImportError:
         pass
     code = '''for x in (i/1000. for i in xrange(1000)):
     f(%s)''' % ('x,'*len(var)).rstrip(',')
     t1 = Timer(code, 'from __main__ import cf as f')
     t2 = Timer(code, 'from __main__ import pf as f')
     if psyf:
         t3 = Timer(code, 'from __main__ import psyf as f')
     else:
         t3 = None
     print 'for x = (0, 1, 2, ..., 999)/1000'
     print '20 times in 3 runs'
     print 'compiled:      %.4f %.4f %.4f' % tuple(t1.repeat(3, 20))
     print 'Python lambda: %.4f %.4f %.4f' % tuple(t2.repeat(3, 20))
     if t3:
         print 'Psyco lambda:  %.4f %.4f %.4f' % tuple(t3.repeat(3, 20))

def main(n=500, n_iter=100):
    print "Doing %d iterations on a %dx%d grid"%(n_iter, n, n)
    for i in ['numeric', 'blitz', 'inline', 'fastinline', 'fortran',
              'pyrex']:
        print i,
        sys.stdout.flush()
        print "took", time_test(n, n, stepper=i, n_iter=n_iter), "seconds"

    print "slow (1 iteration)",
    sys.stdout.flush()
    s = time_test(n, n, stepper='slow', n_iter=1)
    print "took", s, "seconds"
    print "%d iterations should take about %f seconds"%(n_iter, s*n_iter)

    try:
        import psyco
    except ImportError:
        print "You don't have Psyco installed!"
    else:
        psyco.bind(LaplaceSolver)
        psyco.bind(Grid)
        print "slow with Psyco (1 iteration)",
        sys.stdout.flush()
        s = time_test(n, n, stepper='slow', n_iter=1)
        print "took", s, "seconds"
        print "%d iterations should take about %f seconds"%\
              (n_iter, s*n_iter)

 def __init__(self, infile, debug=0, firstblock=None, lastblock=None) :
     """Initialize the generic parser."""
     self.infile = infile
     self.debug = debug
     if firstblock is None :
         self.infile.seek(0)
         firstblock = self.infile.read(FIRSTBLOCKSIZE)
         try :
             self.infile.seek(-LASTBLOCKSIZE, 2)
             lastblock = self.infile.read(LASTBLOCKSIZE)
         except IOError :    
             lastblock = ""
         self.infile.seek(0)
     self.firstblock = firstblock
     self.lastblock = lastblock
     if not self.isValid() :
         raise PDLParserError, "Invalid file format !"
     try :
         import psyco 
     except ImportError :    
         pass # Psyco is not installed
     else :    
         # Psyco is installed, tell it to compile
         # the CPU intensive methods : PCL and PCLXL
         # parsing will greatly benefit from this, 
         # for PostScript and PDF the difference is
         # barely noticeable since they are already
         # almost optimal, and much more speedy anyway.
         psyco.bind(self.getJobSize)

def psyco_speedup ():
	try:
		import psyco
		psyco.bind(chessboard)
		psyco.bind(evaluation)
	except:
		pass
	return 0

def test_circular_obj():
    def f1():
        x = Rect(5, 6)
        x.foo = x
        return x
    psyco.bind(f1)
    x = f1()
    assert x.foo is x

	def optimize(self, functions):
		try:
			from psyco import bind
			for function in functions:
				bind(function)
		except ImportError:
			pass
		return False

def enable_psyco(template_class):
  try:
    import psyco
  except ImportError:
    pass
  else:
    psyco.bind(SpitfireTemplate)
    psyco.bind(template_class)

    def __init__(self, *args):
        self.objimap = None
        apply(mailserver.MailServer.__init__, (self,) + args)

        try:
            # Psyco increase speed about a 40% here...
            psyco.bind(self.get_message)
        except NameError:
            pass

 def setup_psyco():
     """ Оптимизировать узкие места в MrdDataSource с помощью psyco """
     try:
         import psyco
         psyco.bind(MrdDataSource._calculate_endings)
         psyco.bind(MrdDataSource._load_lemmas)
         psyco.bind(MrdDataSource._cleanup_endings)
         psyco.bind(MrdDataSource._section_lines)
         psyco.bind(DictDataSource.calculate_rule_freq)
     except ImportError:
         pass

    def __init__(self, *args):
        self.objpop = None
        self.deleted_msgs = []
        apply(mailserver.MailServer.__init__, (self,) + args)

        try:
            # Psyco increase speed about a 40% here...
            import psyco
            psyco.bind(self.get_message)
        except ImportError:
            pass

    def __init__(
        self,
        redis_host='localhost',
        redis_port=6379,
        redis_db=0,
        ):

        self._REDIS_DELIM = '$'
        self._redis = redis.Redis(host=redis_host, port=redis_port, db=redis_db)

        try:
            import psyco
            psyco.bind(self.resolveUserInfoForKeys)
            print 'Using psyco to compile resolveUserInfoForKeys method'
        except ImportError, e:
            pass  # psyco not installed

def test_constant_obj():
    def f1():
        return rect1.w * rect1.h
    def f2(a):
        rect1.w = a
    psyco.bind(f1)
    psyco.bind(f2)
    rect1.w = 6
    rect1.h = 7
    res = f1()
    assert res == 42
    f2(4)
    res = f1()
    assert res == 28
    f2(0.5)
    res = f1()
    assert res == 3.5

def _psyco_speedup():
	try:
		import psyco
		psyco.bind(rc4crypt)
		psyco.bind(netstream)
		psyco.bind(nethost)
		psyco.bind(CCLIB)
	except:
		return False
	return True

def accelerate_functions():
    try:
        import psyco
    except ImportError:
        print "Psyco not found.  Some features may run slowly."
        return

    print "Psyco found, accelerating functions."

    import bmh_search
    import behavior

    psyco.bind(bmh_search.BMHSearchForward)
    psyco.bind(bmh_search.BMHSearchBackward)
    import commands.save_and_load
    psyco.bind(commands.save_and_load.compressList)
    psyco.bind(behavior.BehaviorArray)
    psyco.bind(behavior.BehaviorArray._getBlankCommands)

    def __init__(self, primary, matrix, secondary=[]):
        if primary == []:
            raise RunTimeError("No primary columns!")
        if matrix == []:
            raise RunTimeError("No membership matrix")
        self.columns = primary + secondary
        for row in matrix:
            for col in row[:-1]:
                if not col in self.columns:
                    raise ColumnError(col)
        self.nodes = {}
        self.headers = {}
        self.rows = {}
        self.updates = 0
        self.solutions = []

        self.setHeaders(primary, secondary)
        self.readRows(matrix)
        psyco.bind(self.backTrack)

def UsePsyco():
    'Tries to use psyco if it is installed'
    try:
        import psyco
        import elementtree.XMLTreeBuilder as XMLTreeBuilder
        import GCCXMLParser

        psyco.bind(XMLTreeBuilder.fixtext)
        psyco.bind(XMLTreeBuilder.fixname)
        psyco.bind(XMLTreeBuilder.TreeBuilder)
        psyco.bind(GCCXMLParser.GCCXMLParser) 
    except ImportError: pass         

    def __init__(self, primary, matrix, secondary = []):
        if primary == []:
            raise RunTimeError("No primary columns!")
        if matrix == []:
            raise RunTimeError("No membership matrix")
        self.columns = primary + secondary
        for row in matrix:
            for col in row[:-1]:
                if not col in self.columns:
                    raise ColumnError(col)

        headers = {}                # temporary dict used to construct self.matrix
        self.matrix = []             # "jagged array" of nodes: a list of lists of ones in the matrix 
        self.rows = {}               # symbolic names for the rows, indexed by row number
        self.root = Column()
        self.readColumns(primary, secondary, headers)   # modifies headers
        self.readRows(headers, matrix)                         # initializes self.matrix and self.rows
        self.solutions = []
        self.updates = 0
        psyco.bind(self.backTrack)