Werkzeug: 0.15.x . पर भगोड़ा स्मृति उपयोग

@ edk0

ऐसा लगता है कि आप कह रहे हैं कि नियमों को सही ढंग से GC'd नहीं किया जा रहा है?

मैं स्पष्ट नहीं हूं कि यह किन वास्तविक परिस्थितियों में होगा। आम तौर पर आप नियमों के एक सेट को परिभाषित करते हैं और फिर उनका उपयोग करते हैं, वे मनमाने ढंग से बनाए और हटाए नहीं जाते हैं।

यहां हमारे उपयोग में कॉन्फ़िगरेशन फ़ाइल में परिभाषित रीडायरेक्ट का एक सेट शामिल है, यह कॉन्फ़िगरेशन फ़ाइल समय-समय पर बदलती रहती है क्योंकि हम वैनिटी रूट जोड़ते या हटाते हैं

हर बार जब हम वैनिटी रूट जोड़ना चाहते हैं तो एप्लिकेशन को तैनात करने के बजाय, हम बस कॉन्फ़िगरेशन फ़ाइल को अपडेट करते हैं और एप्लिकेशन रूट मैपिंग का पुनर्निर्माण करता है (जिसका उपयोग flask ऐप द्वारा रीडायरेक्ट की सेवा के लिए किया जाता है)

हम्म, यह आमतौर पर निराश होता है क्योंकि मानचित्र में परिवर्तन मल्टीप्रोसेस श्रमिकों में सिंक्रनाइज़ नहीं होते हैं। मैं शायद इसे 404 के लिए एक त्रुटि हैंडलर के रूप में कार्यान्वित कर दूंगा, यह जांचने के लिए कि इसके बजाय रीडायरेक्ट वापस किया जाना चाहिए या नहीं। यह नहीं कह रहा कि इसे ठीक नहीं किया जाना चाहिए, बस यह एक ऐसा उपयोग मामला नहीं है जिसके बारे में मैंने सुना होगा।

प्रत्येक व्यक्तिगत कार्यकर्ता समय-समय पर कॉन्फ़िगरेशन फ़ाइल की जांच करता है और इसे पुनः लोड करता है - जहां तक ​​​​मैं कह सकता हूं, इसे सीधे फ्लास्क ऐप में इंजेक्ट नहीं किया जा रहा है

किसी भी तरह से, इन वस्तुओं को शायद रिसाव नहीं करना चाहिए: हंसना: - मैं देख रहा हूं कि इसका क्या कारण हो सकता है - मुझे संदेह है कि संकलित किए जा रहे कार्यों में समस्या है या उनमें से हैशिंग है ( Map लगता है किसी तरह से शामिल होना)

ध्यान दें, यह रिसाव <string:b> हिस्से के बिना नहीं होता है

यहां फ़ंक्शन ऑब्जेक्ट्स का डिस्सेप्लर है जो इसे बनाता है:

>>> x = Rule('/a/<string:b>')
>>> from werkzeug.routing import Map
>>> y = Map([x])
>>> x._build
<function <builder:'/a/<string:b>'> at 0x7f16d62d1730>
>>> import dis
>>> dis.dis(x._build)
  1           0 LOAD_CONST               0 ('')
              2 LOAD_CONST               1 ('/a/')
              4 LOAD_CONST               2 (<bound method BaseConverter.to_url of <werkzeug.routing.UnicodeConverter object at 0x7f16d2c9a0f0>>)
              6 LOAD_FAST                0 (b)
              8 CALL_FUNCTION            1
             10 BUILD_STRING             2
             12 BUILD_TUPLE              2
             14 RETURN_VALUE
>>> dis.dis(x._build_unknown)
  1           0 LOAD_CONST               0 ('')
              2 LOAD_CONST               1 ('/a/')
              4 LOAD_CONST               2 (<bound method BaseConverter.to_url of <werkzeug.routing.UnicodeConverter object at 0x7f16d2c9a0f0>>)
              6 LOAD_FAST                0 (b)
              8 CALL_FUNCTION            1
             10 LOAD_FAST                1 (.keyword_arguments)
             12 JUMP_IF_TRUE_OR_POP     20
             14 LOAD_CONST               0 ('')
             16 DUP_TOP
             18 JUMP_FORWARD            10 (to 30)
        >>   20 LOAD_CONST               3 (functools.partial(<function url_encode at 0x7f16d2d5d510>, charset='utf-8', sort=False, key=None))
             22 ROT_TWO
             24 CALL_FUNCTION            1
             26 LOAD_CONST               4 ('?')
             28 ROT_TWO
        >>   30 BUILD_STRING             4
             32 BUILD_TUPLE              2
             34 RETURN_VALUE

स्क्रिप्ट को थोड़ा एडजस्ट करना:

import collections
import gc
import pprint
from werkzeug.routing import Map, Rule


def main():
    for _ in range(10000):
        Map([Rule('/a/<string:b>')])
    for _ in range(5):
        gc.collect()
    counts = collections.Counter(type(o) for o in gc.get_objects())
    pprint.pprint(counts.most_common(15))


if __name__ == '__main__':
    exit(main())

ऐसा लगता है कि यह लीक हो रहा है (कम से कम, शायद इसके ऊपर के अन्य सामान्य प्रकारों में भी अधिक) Map , Rule , साथ ही एक functools.partial और एक UnicodeConverter प्रति कॉल:

$ ./venv/bin/python t.py
[(<class 'dict'>, 62085),
 (<class 'list'>, 50514),
 (<class 'function'>, 24085),
 (<class 'tuple'>, 21811),
 (<class 'method'>, 20032),
 (<class 'set'>, 10518),
 (<class 'functools.partial'>, 10002),
 (<class 'werkzeug.routing.UnicodeConverter'>, 10000),
 (<class 'werkzeug.routing.Map'>, 10000),
 (<class 'werkzeug.routing.Rule'>, 10000),
 (<class 'weakref'>, 1306),
 (<class 'wrapper_descriptor'>, 1131),
 (<class 'method_descriptor'>, 879),
 (<class 'builtin_function_or_method'>, 839),
 (<class 'getset_descriptor'>, 740)]

जीसी में इसे जीवित रखने वाली चीजों के कुछ ग्राफ यहां दिए गए हैं:

def graph(obj, ids, *, seen=None, indent='', limit=10):
    if seen is None:
        seen = set()

    for referrer in gc.get_referrers(obj):
        # the main frame which has a hard reference to ths object
        if (
                type(referrer).__name__ == 'frame' and
                referrer.f_globals['__name__'] == '__main__'
        ):
            continue
        # objects only present due to traversal of gc referrers
        elif id(referrer) not in ids:
            continue
        elif id(referrer) in seen:
            print(f'{indent}(already seen) {id(referrer)}')
            continue

        seen.add(id(referrer))

        if indent == '':
            print('=' * 79)
        print(f'{indent}type: {type(referrer).__name__} ({id(referrer)})')
        fmted = repr(referrer)  #pprint.pformat(referrer)
        print(indent + fmted.replace('\n', f'\n{indent}'))

        if limit:
            graph(
                referrer, ids,
                seen=seen, indent='==' + indent, limit=limit - 1,
            )

...

    ids = {id(o) for o in gc.get_objects()}
    obj = next(iter(o for o in gc.get_objects() if isinstance(o, Map)))
    graph(obj, ids)

===============================================================================
type: dict (140272699432680)
{'map': Map([<Rule '/a/<b>' -> None>]), 'regex': '[^/]{1,}'}
==type: UnicodeConverter (140272699175656)
==<werkzeug.routing.UnicodeConverter object at 0x7f93c867f2e8>
====type: method (140272750734216)
====<bound method BaseConverter.to_url of <werkzeug.routing.UnicodeConverter object at 0x7f93c867f2e8>>
======type: tuple (140272726348928)
======('', '/a/', <bound method BaseConverter.to_url of <werkzeug.routing.UnicodeConverter object at 0x7f93c867f2e8>>)
====type: method (140272749846664)
====<bound method BaseConverter.to_url of <werkzeug.routing.UnicodeConverter object at 0x7f93c867f2e8>>
======type: tuple (140272726372424)
======('', '/a/', <bound method BaseConverter.to_url of <werkzeug.routing.UnicodeConverter object at 0x7f93c867f2e8>>, functools.partial(<function url_encode at 0x7f93c877eae8>, charset='utf-8', sort=False, key=None), '?')
====type: dict (140272723298056)
===={'b': <werkzeug.routing.UnicodeConverter object at 0x7f93c867f2e8>}
======type: dict (140272749460432)
======{'rule': '/a/<string:b>', 'is_leaf': True, 'map': Map([<Rule '/a/<b>' -> None>]), 'strict_slashes': True, 'subdomain': '', 'host': None, 'defaults': None, 'build_only': False, 'alias': False, 'methods': None, 'endpoint': None, 'redirect_to': None, 'arguments': {'b'}, '_trace': [(False, '|'), (False, '/a/'), (True, 'b')], '_converters': {'b': <werkzeug.routing.UnicodeConverter object at 0x7f93c867f2e8>}, '_regex': re.compile('^\\|\\/a\\/(?P<b>[^/]{1,})$'), '_argument_weights': [100], '_static_weights': [(0, -1)], '_build': <function <builder:'/a/<string:b>'> at 0x7f93c9d880d0>, '_build_unknown': <function <builder:'/a/<string:b>'> at 0x7f93c9d88158>}
========type: Rule (140272749480984)
========<Rule '/a/<b>' -> None>
==========type: list (140272699123848)
==========[<Rule '/a/<b>' -> None>]
============type: dict (140272726280736)
============{'_rules': [<Rule '/a/<b>' -> None>], '_rules_by_endpoint': {None: [<Rule '/a/<b>' -> None>]}, '_remap': False, '_remap_lock': <unlocked _thread.lock object at 0x7f93cb6d9da0>, 'default_subdomain': '', 'charset': 'utf-8', 'encoding_errors': 'replace', 'strict_slashes': True, 'redirect_defaults': True, 'host_matching': False, 'converters': {'default': <class 'werkzeug.routing.UnicodeConverter'>, 'string': <class 'werkzeug.routing.UnicodeConverter'>, 'any': <class 'werkzeug.routing.AnyConverter'>, 'path': <class 'werkzeug.routing.PathConverter'>, 'int': <class 'werkzeug.routing.IntegerConverter'>, 'float': <class 'werkzeug.routing.FloatConverter'>, 'uuid': <class 'werkzeug.routing.UUIDConverter'>}, 'sort_parameters': False, 'sort_key': None}
==============type: Map (140272749480872)
==============Map([<Rule '/a/<b>' -> None>])
================(already seen) 140272699432680
================(already seen) 140272749460432
==========type: list (140272700110792)
==========[<Rule '/a/<b>' -> None>]
============type: dict (140272726280808)
============{None: [<Rule '/a/<b>' -> None>]}
==============(already seen) 140272726280736
(already seen) 140272749460432

यह चक्र को तोड़ने और स्मृति रिसाव को खत्म करने के लिए पर्याप्त है:

diff --git a/src/werkzeug/routing.py b/src/werkzeug/routing.py
index c7cff94d..8176ddfe 100644
--- a/src/werkzeug/routing.py
+++ b/src/werkzeug/routing.py
@@ -1254,13 +1254,13 @@ class BaseConverter(object):
     weight = 100

     def __init__(self, map):
-        self.map = map
+        self.charset = map.charset

     def to_python(self, value):
         return value

     def to_url(self, value):
-        return _fast_url_quote(text_type(value).encode(self.map.charset))
+        return _fast_url_quote(text_type(value).encode(self.charset))


 class UnicodeConverter(BaseConverter):

हालांकि मेरा मानना ​​​​है कि चक्र का वास्तविक कारण यह है कि LOAD_CONST का उपयोग कोड ऑब्जेक्ट्स में ऑब्जेक्ट्स के खिलाफ किया जा रहा है जो स्वयं स्थिरांक नहीं हैं, मेरा मानना ​​​​है कि यह जीसी को भ्रमित करता है (यह मानते हुए कि संदर्भित कोड ऑब्जेक्ट्स लाइव हैं, जब वे वास्तव में नहीं हैं)

#1524 . के माध्यम से