Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:118320
MIME-Version: 1.0
References: <CANMwmbPkDLX4zXDNKh+zchgMxyGUdzSXkKO6eDgE0FPDR1Ezdg@mail.gmail.com>
 <CAMrTa2FpTxD9k+B0WUtR=8qYxjVJjUgVwGHf76dH2FkwjPUdWw@mail.gmail.com> <CANMwmbO-JOq9f6KZrtMSKLCJo1af+MhLyXMwdmF1ad20iSJChQ@mail.gmail.com>
In-Reply-To: <CANMwmbO-JOq9f6KZrtMSKLCJo1af+MhLyXMwdmF1ad20iSJChQ@mail.gmail.com>
Date: Sat, 30 Jul 2022 13:57:48 +0400
Message-ID: <CAO8qBaULEwgrTkuZyxT1D08Oc6mBhFWk0zhi63CJXDy354ROig@mail.gmail.com>
To: juan carlos morales <dev.juan.morales@gmail.com>
Cc: internals@lists.php.net
Content-Type: multipart/alternative; boundary="000000000000411abb05e502cde3"
Subject: Re: [PHP-DEV] RFC Idea - is_json - looking for feedback
From: oleksii.bulba@gmail.com (Oleksii Bulba)

--000000000000411abb05e502cde3
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

> $memoryAfter =3D memory_get_usage(true) / 1024 / 1024;

I see that you used `memory_get_usage` that shows memory usage at the time
of the function call.
As far as I understand, your function does not return any value,
so I suspect that it is obvious that the memory usage after the function
call is the same as before.
But what is the actual memory usage during the function call?
Can you run the same benchmark but with `memory_get_peak_usage` function to
see how your function uses memory?

# $memoryAfter =3D  memory_get_peak_usage(true) / 1024 / 1024;

Also, I'm concerned if it would be better to name the function
`is_json_valid`?

On Sat, Jul 30, 2022 at 10:37 AM juan carlos morales <
dev.juan.morales@gmail.com> wrote:

> Just want to clarify that when I mentioned the use of memory, I wrote dow=
n
> the function "memory_get_usage()", which basically gives us the memory
> handle by php that is related to the memory_limit INI setting.
>
> Now I will provide a benchmark I have done really quick:
>
> # Code used (I have the implementation of is_json() done already)
>
> <?php
> // make sure you set your memory limit to -1 before running this code
> // Here we create a very very very big json string, really big
> $limit =3D 1000000;
> $jsonString =3D '{ "test": { "foo": "bar" },';
>
> for ($i=3D0; $i < $limit; $i++) {
>   $jsonString .=3D " \"test$i\": { \"foo\": { \"test\" : { \"foo\" :  {
> \"test\" : { \"foo\" : \"bar\" }}}}},";
> }
>
> $jsonString .=3D ' "testXXXX": { "foo": "replaceme" } }';
> //{ "test" : { "foo" : "bar" }}}
>
> $memoryBefore =3D memory_get_usage(true) / 1024 / 1024;
> echo "Megas used before call: " . $memoryBefore . PHP_EOL;
>
> $start =3D microtime(true);
>
> json_decode($jsonString, null, $limit, 0);
> //<------------------ un/comment to show/hide results for json_decode()
> //is_json($jsonString);
>  //<------------------ un/comment to show/hide results for is_json()
>
> $memoryAfter =3D memory_get_usage(true) / 1024 / 1024;
> echo "Megas used after call: " . $memoryAfter . PHP_EOL;
>
> echo "Difference: " . ($memoryAfter - $memoryBefore) . PHP_EOL;
>
> echo "Time: " . (microtime(true) - $start) . " seconds" . PHP_EOL;
> return;
>
> # Results
> ## json_decode()
> Megas used before call: 79.23828125
> Megas used after call: 3269.23828125
> Difference: 3190
> Time: 12.091101884842 seconds
>
> ## is_json()
> Megas used before call: 79.23828125
> Megas used after call: 79.23828125
> Difference: 0
> Time: 5.4537169933319 seconds
>
>
> And yes, I am open to share the implementation, but after I write the RFC=
.
>
> Thanks for taking your time to give me a feedback.
>
> El s=C3=A1b, 30 jul 2022 a las 3:50, Jordan LeDoux (<jordan.ledoux@gmail.=
com>)
> escribi=C3=B3:
>
> >
> >
> > On Fri, Jul 29, 2022 at 7:27 AM juan carlos morales <
> > dev.juan.morales@gmail.com> wrote:
> >
> >> # Why this function ?
> >>
> >> At the moment the only way to determine if a JSON-string is valid we
> have
> >> to execute the json_decode() function.
> >>
> >> The drawback about this, is that json_decode() generates an in memory =
an
> >> object/array (depending on parameters) while parsing the string; this
> >> leads
> >> to a memory usage that is not needed (because we use memory for creati=
ng
> >> the object/array) and also can cause an error for reaching the
> >> memory-limit
> >> of the php process.
> >>
> >> Sometimes we just need to know is the string is a valid json or not, a=
nd
> >> nothing else.
> >>
> >
> > You say that you have a first-pass at the implementation done. I'd be
> > curious to see it. My initial thought was that in order to validate the
> > string, you likely need to allocate extra memory as part of the
> validation
> > that depends on the string size. You'd definitely save the overhead of =
a
> > ZVAL, but for such an object that overhead is likely negligible.
> >
> > So I guess my question would be: in the actual implementation that land=
s,
> > how much memory would this actually save compared to json_decode()? Thi=
s
> > seems like it would make the RFC tricky, as the purported benefit of th=
e
> > RFC depends very tightly on the implementation that lands.
> >
> > Jordan
> >
>

--000000000000411abb05e502cde3--