Why is this JSON Parsing becoming more and more efficient?

Question

I have a function to parse JSON in android. I use org.json for my parsing.

It is something like this:

class ClassName {

public static ArrayList<DataObjectClass> parseResponse(String response){

    JSONObject responseObject = new JSONObject(response);
    if(responseObject.has("someArray")){
        JSONArray someArray = responseObject.getJSONArray("someArray");
        // etc... etc... and i do logic
        }
    }
    return new DataObjectClass(params...)
}

Now I timed my parsing from start to end, and each time I call the function again the parsing time reduces (Unless i quit the app and come again)

I checked the JSONTokener Code and JSONObject code, but I cant find any code for caching. Where is this happening and how can I turn it off (for testing purposes)

score 4 · Accepted Answer · edited Jun 20 '20 at 09:12

It might have something to do with how ART(Andorid RunTime) runs the code.

From docs:

Android runtime (ART) includes a just-in-time (JIT) compiler with code profiling that continually improves the performance of Android applications as they run. The JIT compiler complements ART's current ahead-of-time (AOT) compiler and improves runtime performance, saves storage space, and speeds application and system updates. It also improves upon the AOT compiler by avoiding system slowdown during automatic application updates or recompilation of applications during over-the-air (OTA) updates.

Although JIT and AOT use the same compiler with a similar set of optimizations, the generated code might not be identical. JIT makes use of runtime type information, can do better inlining, and makes on stack replacement (OSR) compilation possible, all of which generates slightly different code.

This means that each time ART runs you code it will analyze how it run and how it can improve that. When you quit your app all that data is lost and it starts again. This is common in all JVM(Java Virtual Machine) applications.

score 3 · Answer 2 · answered Jul 05 '19 at 10:55

Why is this JSON Parsing becoming more and more efficient?

That is the essence of what Just in time compilers do.

They understand (via some sort of profiling, or sometimes: simply counting of method invocations) which parts of your code are performance critical. At some point, they come in, and translate the java bytecode into native machine code for example.

In other words: most likely, when your code does something "just often enough", at some point the JIT will (probably gradually, in multiple steps) recompile it to more and more optimised (machine code) representations.

Why is this JSON Parsing becoming more and more efficient?

2 Answers2