Git Product home page Git Product logo

Comments (2)

michaelwoerister avatar michaelwoerister commented on August 20, 2024

My suggested answers to these questions are:

Does the incremental cache loading time contribute to a queries self-time?

Yes. Self-time is what one sorts for when trying to find out what is expensive. It would be unhelpful if something got sorted to the back even though 50% of total compile time is spent loading things for it from the cache.

In the incremental cache loading case, is the loading event nested inside a regular query-provider event?

Let's go with no. That causes fewer events to be generated. Also, in order to make things really uniform, in-memory cache hit events would have to wrapped with a query-provider event too, which would be lots of overhead for not much gain.

Should we distinguish between actual cache loading, metadata loading, and provider re-executions caused by missing cache entries? If so, how?

Down the line, yes. It's a useful distinction to make. These should all be separate query kinds (incr. cache loading already is). However, I think this is something to be implemented after we have query keys, so we don't make too many changes at once.

Do query-blocked time contribute to self-time? How about total-time?

Blocking should add to self-time for the same reason as incr. cache loading should add to self-time (see above). I don't remember what I meant by "How about total-time?", I think the question is not relevant anymore since we switched to @andjo403's approach of computing total time as thread_max_time - thread_min_time.

Is a query-blocked event always followed by a cache-hit event (the latter of which would then be responsible for incrementing the invocation count) What if cache-hit events are filtered out? Is it OK to have wrong invocation counts?

I haven't thought about this one yet.

from measureme.

michaelwoerister avatar michaelwoerister commented on August 20, 2024

Is a query-blocked event always followed by a cache-hit event (the latter of which would then be responsible for incrementing the invocation count) What if cache-hit events are filtered out? Is it OK to have wrong invocation counts?

It turns out the natural way of implementing this is that a cache-hit event is indeed generated after each query-blocked event. So this does not behave differently than the regular case.

from measureme.

Related Issues (20)

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.