def profile_on(*filenames):
    global p_stats, p_start_time, files
    p_stats = []
    p_start_time = time.time()
    files = filenames
    threading.setprofile(profiler)
    sys.setprofile(profiler)

def start(builtins=False, profile_threads=True):
    """
    Start profiler.
    """
    if profile_threads:
        threading.setprofile(_callback)
    _yappi.start(builtins, profile_threads)

 def run(self, profiler):
     profile = functools.partial(self._profile, profiler)
     sys.setprofile(profile)
     threading.setprofile(profile)
     yield
     threading.setprofile(None)
     sys.setprofile(None)

 def start(self):
     if sys.getprofile() is not None:
         raise RuntimeError('Another profiler already registered.')
     self._running = True
     sys.setprofile(self._profile)
     threading.setprofile(self._profile)
     self.timer.start()
     self.stats.record_starting(time.clock())

def stop_profiler():
    # we keep the _state around for the user until the next session

    # Unregister the profiler in this order, otherwise we will have extra
    # measurements in the end
    sys.setprofile(None)
    threading.setprofile(None)
    greenlet.settrace(None)  # pylint: disable=no-member

 def run(self, profiler):
     profile = functools.partial(self._profile, profiler)
     with deferral() as defer:
         sys.setprofile(profile)
         defer(sys.setprofile, None)
         threading.setprofile(profile)
         defer(threading.setprofile, None)
         yield

def activate_hook():
    """ Activates the thread monitor hook. Note that this interferes
    with any kind of profiler and some debugging extensions. """
    global hook_enabled
    
    sys.setprofile(dump_hook)
    threading.setprofile(dump_hook)
    hook_enabled = True

def trace_execution(fn, args, save_to=None):
    import inspect

    if save_to:
        os.environ["INTEL_SEA_SAVE_TO"] = save_to
    itt = ITT("python")

    if itt.lib:
        file_id = itt.get_string_id("__FILE__")
        line_id = itt.get_string_id("__LINE__")
        module_id = itt.get_string_id("__MODULE__")
        trace_execution.frames = {}
        trace_execution.recurrent = False
        high_part = 2 ** 32

        def profiler(frame, event, arg):  # https://pymotw.com/2/sys/tracing.html
            if trace_execution.recurrent:
                return
            trace_execution.recurrent = True
            task_id = id(frame.f_code)
            if "call" in event:
                if task_id in trace_execution.frames:
                    trace_execution.frames[task_id] += 1
                else:
                    trace_execution.frames[task_id] = 1
                task_id += trace_execution.frames[task_id] * high_part
                name = frame.f_code.co_name + ((" (%s)" % arg.__name__) if arg else "")
                if "self" in frame.f_locals:
                    cls = frame.f_locals["self"].__class__.__name__
                    name = cls + "." + name
                # print event, name, task_id, arg
                mdl = inspect.getmodule(frame)
                itt.lib.itt_task_begin_overlapped(itt.domain, task_id, 0, itt.get_string_id(name), 0)
                itt.lib.itt_metadata_add_str(itt.domain, task_id, file_id, frame.f_code.co_filename)
                itt.lib.itt_metadata_add(itt.domain, task_id, line_id, frame.f_code.co_firstlineno)
                if mdl:
                    itt.lib.itt_metadata_add_str(itt.domain, task_id, module_id, mdl.__name__)
            elif "return" in event:
                # print event, frame.f_code.co_name, task_id + trace_execution.frames[task_id] * high_part
                if task_id in trace_execution.frames:
                    itt.lib.itt_task_end_overlapped(
                        itt.domain, 0, task_id + trace_execution.frames[task_id] * high_part
                    )
                    if trace_execution.frames[task_id] > 1:
                        trace_execution.frames[task_id] -= 1
                    else:
                        del trace_execution.frames[task_id]
            trace_execution.recurrent = False

        print trace_execution.frames
        old_profiler = sys.getprofile()
        sys.setprofile(profiler)
        old_threading_profiler = threading.setprofile(profiler)
        fn(*args)
        sys.setprofile(old_profiler)
        threading.setprofile(old_threading_profiler)
    else:
        fn(*args)

 def runcall(self, func, *args, **kw):
     self.set_cmd(repr(func))
     threading.setprofile(self.dispatcher)
     sys.setprofile(self.dispatcher)
     try:
         return func(*args, **kw)
     finally:
         sys.setprofile(None)
         threading.setprofile(None)

 def runctx(self, cmd, globals, locals):
     self.set_cmd(cmd)
     threading.setprofile(self.dispatcher)
     sys.setprofile(self.dispatcher)
     try:
         exec cmd in globals, locals
     finally:
         sys.setprofile(None)
         threading.setprofile(None)
     return self

def start(builtins=False):
    '''
    Args:
    builtins: If set true, then builtin functions are profiled too.
    timing_sample: will cause the profiler to do timing measuresements
                   according to the value. Will increase profiler speed but
                   decrease accuracy.
    '''
    threading.setprofile(__callback)
    _yappi.start(builtins)

    def recover(self):
        """ Unset the current function in the sys.setprofile.

        If available the previous method is recovered in setprofile. A
        RuntimeError is raised if the `previous` attribute does not exist.

        """
        if hasattr(self, 'previous'):
            sys.setprofile(self.previous)
            if has_threading:
                threading.setprofile(self.previous)
            del self.previous
        else:
            raise RuntimeError('A profile function has not been set')

def start_profiler():
    global _state

    _state = GlobalState()

    frame = sys._getframe(0)
    current_greenlet = greenlet.getcurrent()  # pylint: disable=no-member

    thread_state = ensure_thread_state(current_greenlet, frame)
    _state.last = thread_state

    # this needs to be instantiate before the handler is installed
    greenlet.settrace(greenlet_profiler)  # pylint: disable=no-member
    sys.setprofile(thread_profiler)
    threading.setprofile(thread_profiler)

 def run(self):
     if sys.getprofile() is not None:
         # NOTE: There's no threading.getprofile().
         # The profiling function will be stored at threading._profile_hook
         # but it's not documented.
         raise RuntimeError('Another profiler already registered')
     with deferral() as defer:
         sys.setprofile(self._profile)
         defer(sys.setprofile, None)
         threading.setprofile(self._profile)
         defer(threading.setprofile, None)
         self.timer.start(self)
         defer(self.timer.stop)
         yield
         self._times_entered.clear()

        def __init__(self):
            super(Hooks, self).__init__()

            sort = os.getenv('PEAS_PYTHON_PROFILE', default='time')
            self.__stat_sort = sort.split(';')

            self.__stats = None
            self.__stats_lock = threading.Lock()

            self.__thread_refs = []
            self.__thread_local = threading.local()

            threading.setprofile(self.__init_thread)

            self.__profile = cProfile.Profile()
            self.__profile.enable()

    def replace(self, function):
        """ Set a new function in sys.setprofile.

        If the function has been already set and it is not the same as before
        then RuntimeError is raised.

        """
        if hasattr(self, 'previous'):
            if function != sys.getprofile():
                raise RuntimeError(
                    'Cannot replace profile function more than once')
            return
        else:
            self.previous = sys.getprofile()
        if has_threading:
            threading.setprofile(function)
        sys.setprofile(function)

 def start(self):
     """Start profiling.
     
     This hooks into threading and will record all calls made until
     stop() is called.
     """
     self._g_threadmap = {}
     self.p = Profiler()
     permitted = self.__class__.profiler_lock.acquire(
         self.__class__.profiler_block)
     if not permitted:
         raise errors.InternalBzrError(msg="Already profiling something")
     try:
         self.p.enable(subcalls=True)
         threading.setprofile(self._thread_profile)
     except:
         self.__class__.profiler_lock.release()
         raise

    def stop(self):
        """Stop profiling.

        This unhooks from threading and cleans up the profiler, returning
        the gathered Stats object.

        :return: A bzrlib.lsprof.Stats object.
        """
        try:
            self.p.disable()
            for pp in self._g_threadmap.values():
                pp.disable()
            threading.setprofile(None)
            p = self.p
            self.p = None
            threads = {}
            for tid, pp in self._g_threadmap.items():
                threads[tid] = Stats(pp.getstats(), {})
            self._g_threadmap = None
            return Stats(p.getstats(), threads)
        finally:
            self.__class__.profiler_lock.release()

def trace_execution(fn, *args):
    import inspect

    itt = ITT("python")

    if itt.lib:
        trace_execution.depth = 0
        file_id = itt.get_string_id('__FILE__')
        line_id = itt.get_string_id('__LINE__')
        module_id = itt.get_string_id('__MODULE__')

        def profiler(frame, event, arg):
            if 'call' in event:
                trace_execution.depth += 1
                name = frame.f_code.co_name
                if 'self' in frame.f_locals:
                    cls = frame.f_locals['self'].__class__.__name__
                    name = cls + "." + name
                mdl = inspect.getmodule(frame)
                itt.lib.itt_task_begin(itt.domain, trace_execution.depth, 0, itt.get_string_id(name), 0)
                itt.lib.itt_metadata_add_str(itt.domain, trace_execution.depth, file_id, frame.f_code.co_filename)
                itt.lib.itt_metadata_add(itt.domain, trace_execution.depth, line_id, frame.f_code.co_firstlineno)
                if mdl:
                    itt.lib.itt_metadata_add_str(itt.domain, trace_execution.depth, module_id, mdl.__name__)
            if 'return' in event:
                itt.lib.itt_task_end(itt.domain, 0)
                trace_execution.depth -= 1

        old_profiler = sys.getprofile()
        sys.setprofile(profiler)
        old_threading_profiler = threading.setprofile(profiler)
        fn(*args)
        sys.setprofile(old_profiler)
        threading.setprofile(old_threading_profiler)
    else:
        fn(*args)

def profile_on():
    global p_stats, p_start_time
    p_stats = {}
    p_start_time = time.time()
    threading.setprofile(profiler)
    sys.setprofile(profiler)