Performance Problems

[wizzat]

Hey,

So I've been using jsonschema for basic json validation of events before processing. However, one thing that I've noticed is that urlparse and urljoin are consistently among the hot spots in my code base. After tracing it down I've found that a lot of it comes from RefResolver.resolving and RefResolver.resolving.

It seems like a couple of optimizations could be really handy:

@contextlib.contextmanager
def resolving(self, ref):

    if ref == '#':
        yield self.store[self.base_uri]
    else:
        ...

I'm not entirely sure how to go about handling in_scope, but in my application it seems like resolution scope always becomes the raw scope.

@contextlib.contextmanager
def in_scope(self, scope):
    old_scope = self.resolution_scope
    self.resolution_scope = scope
    try:
        yield
    finally:
        self.resolution_scope = old_scope

The next spot that seems to take up a bunch of time is in iter_errors. There aren't any validation errors, but this seems like it's just a matter of applying the schema to the object and detecting any errors. However, in several places it seems like it's wrapped in a list, which means you lose the ability to grab the first error and bail out.

[ankostis]

Hi,

I have also observed the same behavior with my schema, too many calls to the urllib.
But i found an additional cause of the delay, the repetitious stacking of function-frames for every visited schema node, regardless of whether it defined an id property or not.

To have a common reference i created benchmarks that Julian has requested, and used the META_SCHEMAs along with a moderately large sample schema i'm using for my project.
I then added two optimizations, their combination, a new test-case measuring the validator's performance, along with the engraving of the timings of the various cases above on the docstrings of the test-case methods (read also pull-request #182).
Both optimizations (hopefully) preserve the semantics of the scopes (to avoid problems like #159).

The new TC about ensuring the well-state of scopes-stacks in my Pull-Request passes for all python-version EXCEPT from the 'pypi' environment. It seems that the finally after the yield does not run.

If that is the case, then, this new test-case (slightly-modified) should also fail with the old unoptimized code in master.
Has anybody any idea why this happens?

[ankostis]

Forgot the most important: For complicated schemas the combined optimizations improve the performance almost by a factor x2.

[Bachmann1234]

Is there any update on this? Currently jsonschema is a major performance bottleneck for a project I am working on.

What's the status of those PRS? Anything I can do to help? I hope to look into the library in detail myself next week.