ext/bcmath: Optimize `bcdiv` processing #14660

SakiTakamachi · 2024-06-25T04:01:57Z

Changed to use BC_VECTOR to calculate faster.
Since there is a considerable speed difference, the benchmark was roughly measured.
The division code was changed in the third commit.

benchmark code:

<?php

// 1
$num1 = '1.23';
$num2 = '2';

$start = microtime(true);
for ($i = 0; $i < 500000; $i++) {
    bcdiv($num1, $num2, 0);
}
echo microtime(true) - $start . PHP_EOL;

// 2
$num1 = '4.123456';
$num2 = '0.001';

$start = microtime(true);
for ($i = 0; $i < 1000000; $i++) {
    bcdiv($num1, $num2, 0);
}
echo microtime(true) - $start . PHP_EOL;

// 3
$num1 = '1.23';
$num2 = '2.12';

$start = microtime(true);
for ($i = 0; $i < 1000000; $i++) {
    bcdiv($num1, $num2, 4);
}
echo microtime(true) - $start . PHP_EOL;

// 4
$num1 = '5.2345678';
$num2 = '2.1234567';

$start = microtime(true);
for ($i = 0; $i < 1000000; $i++) {
    bcdiv($num1, $num2, 0);
}
echo microtime(true) - $start . PHP_EOL;

// 5
$num1 = '5.23456789';
$num2 = '2.12345678';

$start = microtime(true);
for ($i = 0; $i < 1000000; $i++) {
    bcdiv($num1, $num2, 0);
}
echo microtime(true) - $start . PHP_EOL;

// 6
$num1 = '1.234567812345678';
$num2 = '2.123456712345678';

$start = microtime(true);
for ($i = 0; $i < 1000000; $i++) {
    bcdiv($num1, $num2, 50);
}
echo microtime(true) - $start . PHP_EOL;

// 7
$num1 = '1.234567812345678';
$num2 = '2.1';

$start = microtime(true);
for ($i = 0; $i < 1000000; $i++) {
    bcdiv($num1, $num2, 50);
}
echo microtime(true) - $start . PHP_EOL;

// 8
$num1 = str_repeat('1234567890', 300);
$num2 = str_repeat('9876543210', 300);

$start = microtime(true);
for ($i = 0; $i < 5000; $i++) {
    bcdiv($num1, $num2, 50);
}
echo microtime(true) - $start . PHP_EOL;

before:

0.13476610183716 // 1
0.28906989097595 // 2
0.29561901092529 // 3
0.26175594329834 // 4
0.25259518623352 // 5
2.5445368289948 // 6
1.1578629016876 // 7
1.598653793335 // 8

after:

0.080783128738403 // 1
0.15704202651978 // 2
0.15926694869995 // 3
0.16794800758362 // 4
0.17711997032166 // 5
0.32082390785217 // 6
0.28861498832703 // 7
0.048795223236084 // 8

ext/bcmath/libbcmath/src/div.c

SakiTakamachi · 2024-06-25T15:56:13Z

There was a mistake in some of the assumptions, which made the code unnecessarily complicated, so I will correct it.

SakiTakamachi · 2024-06-25T15:57:21Z

done

jorgsowa · 2024-06-26T13:24:08Z

ext/bcmath/libbcmath/src/convert.c

+BC_VECTOR bc_parse_chunk_chars(const char *str)
+{
+	BC_VECTOR tmp;
+	memcpy(&tmp, str, sizeof(tmp));
+#if !BC_LITTLE_ENDIAN
+	tmp = BC_BSWAP(tmp);
+#endif


If I see correctly this part is the same for both sizes, so it can be excluded from the condition.

This is originally Niels' code, and is written this way for readability.

I would like to leave his code untouched.

I doubt it's more readable when we repeat the second level if condition in both functions, but it's a subjective opinion. For sure cognitive complexity is lower without nesting if conditions. It's not a big deal though.

SakiTakamachi · 2024-06-27T09:06:52Z

It could probably be made a bit less complicated.

I'll fix it and rebase it.

SakiTakamachi · 2024-06-28T07:58:38Z

done

SakiTakamachi · 2024-06-30T13:17:17Z

ext/bcmath/libbcmath/src/div.c

+	BC_VECTOR div_carry = 0;
+
+	/*
+	 * If calculate the temporary quotient using only one array of n1 and n2, the error will be greater


Does this rule have a name? If so, please let me know, as I can simply provide the URL.

SakiTakamachi · 2024-07-04T00:19:50Z

@Girgias @nielsdos

This is all the changes in this PR, so I would appreciate it if you could check it out when you have time :)

nielsdos · 2024-07-04T11:06:00Z

First two commits are definitely fine to already land on master. I'll try to have a look at the actual algorithmic changes today.

nielsdos

The bc_do_div and bc_fast_div logic seem fine.
I couldn't quite follow bc_standard_div and am waiting for clarifications on that. I'll continue when my current remarks/questions have been answered.
I also think this should've been done in multiple steps, e.g. you already did a few optimizations in the base algorithm which complicates things.
What are the similarities and differences / advantages and disadvantages of your algorithm vs the previously implemented algorithm?

ext/bcmath/libbcmath/src/div.c

nielsdos · 2024-07-04T20:21:59Z

ext/bcmath/libbcmath/src/div.c

+
+	/*
+	 * If calculate the temporary quotient using only one array of n1 and n2, the error will be greater
+	 * than 1 and the number of additions and backs will increase significantly.


I don't know what you mean with backs

I tried changing the wording of the comment. Is this correct in English?

nielsdos · 2024-07-04T20:22:43Z

ext/bcmath/libbcmath/src/div.c

+	 * If calculate the temporary quotient using only one array of n1 and n2, the error will be greater
+	 * than 1 and the number of additions and backs will increase significantly.
+	 * Therefore, when calculating the quotient, adjust the number of digits for n2 so that it becomes
+	 * BC_VECTOR_SIZE + 1 digit, and adjust the number of digits for n1 by the same amount.


Do you mean that you add padding?

It may be slightly different from padding. I've edited the comment to be a little more detailed.

nielsdos · 2024-07-04T20:30:02Z

ext/bcmath/libbcmath/src/div.c

+	 * than 1 and the number of additions and backs will increase significantly.
+	 * Therefore, when calculating the quotient, adjust the number of digits for n2 so that it becomes
+	 * BC_VECTOR_SIZE + 1 digit, and adjust the number of digits for n1 by the same amount.
+	 * By doing so, the error in the quotient will be within 1, so if need to add back, only need to add it once.


It's unclear what you mean with "add back"

The expression has been corrected.

ext/bcmath/libbcmath/src/div.c

nielsdos · 2024-07-04T20:31:28Z

ext/bcmath/libbcmath/src/div.c

+	 *
+	 * Details:
+	 * Suppose that when calculating the temporary quotient, only the high-order elements of the BC_VECTOR array are used.
+	 * At this time, n1 and n2 can be considered to be decomposed as follows. (Here, B = 10^b)


Where does b come from, or is this just "any natural number" ?
EDIT: okay I see, it's any natural number afaict, please clarify this by adding e.g. (any b ∈ ℕ) in the comment

Thanks, added it.

nielsdos · 2024-07-04T20:33:41Z

ext/bcmath/libbcmath/src/div.c

+	BC_VECTOR *n2_vector = n1_vector + n1_arr_size;
+	BC_VECTOR *quot_vector = n2_vector + n2_arr_size;
+
+	/* Fill with zeros and convert as many vector elements as need */


Suggested change

/* Fill with zeros and convert as many vector elements as need */

/* Fill with zeros and convert as many vector elements as needed */

nielsdos · 2024-07-04T20:42:37Z

ext/bcmath/libbcmath/src/div.c

+	 * n2 = n2_high * B^k + n2_low
+	 *
+	 * The error E can be expressed by the following formula.
+	 * E = n1_high * B^k / n2_high * B^k - (n1_high * B^k + n1_low) / (n2_high * B^k + n2_low)


I suppose you mean (n1_high * B^k) / (n2_high * B^k)

What is the definition or the error in this case? I know things like relative error and absolute error in numeric approximations but I'm not sure what you really mean here or where this is going.

Parentheses were missing in many places. The result of the expression is correct. Fixed.

nielsdos · 2024-07-04T21:04:30Z

ext/bcmath/libbcmath/src/div.c

+	 * E = n1_high / n2_high - (n1_high * B^k + n1_low) / (n2_high * B^k + n2_low)
+	 * E = (n1_high * (n2_high * B^k + n2_low) - (n1_high * B^k + n1_low) * n2_high) / n2_high * (n2_high * B^k + n2_low)


From line 97 to line 98 there is a mistake I think. Isn't the last part supposed to be / (n2_high * B^k + n2_low) instead of * (n2_high * B^k + n2_low) ?

Consequently the steps that follow on this could be wrong too.

SakiTakamachi · 2024-07-05T04:58:14Z

@nielsdos

I couldn't quite follow bc_standard_div and am waiting for clarifications on that. I'll continue when my current remarks/questions have been answered.

I replied and edited the comment.

I also think this should've been done in multiple steps, e.g. you already did a few optimizations in the base algorithm which complicates things.

I should have broken it down a little more, sorry.

What are the similarities and differences / advantages and disadvantages of your algorithm vs the previously implemented algorithm?

Is this about bc_standard_div (or bc_fast_div)?
It is similar to the previous implementation in that it is a using restoring division algorithm. The difference is that the previous implementation calculated one digit at a time, whereas the new implementation calculates BC_VECTOR_SIZE digits at a time.

Due to the change in radix of calculation, the method used to calculate the "temporary quotient" is significantly different from the previous implementation.

nielsdos · 2024-07-05T23:43:41Z

Thanks for the changes, I'll have a look again this weekend.

What are the similarities and differences / advantages and disadvantages of your algorithm vs the previously implemented algorithm?

Is this about bc_standard_div (or bc_fast_div)? It is similar to the previous implementation in that it is a using restoring division algorithm. The difference is that the previous implementation calculated one digit at a time, whereas the new implementation calculates BC_VECTOR_SIZE digits at a time.

Due to the change in radix of calculation, the method used to calculate the "temporary quotient" is significantly different from the previous implementation.

I see. The reason I asked the question was because I didn't fully grasp that you were using the restoring division technique, as I didn't manage to get that far because of the issues with the expressions in the comments. Thanks for clarifying.

nielsdos

I was able to understand most of the derivations but still have some questions about it.

ext/bcmath/libbcmath/src/div.c

nielsdos · 2024-07-07T15:01:11Z

ext/bcmath/libbcmath/src/div.c

+	 * Since B = 10^b, the formula becomes:
+	 * MAX_E = (n2_high * B * (B^k - 1)) / (n2_high * (n2_high * B^k + B^k - 1))
+	 * MAX_E = (10^x * 10^b * ((10^b)^k - 1)) / (10^x * (10^x * (10^b)^k + (10^b)^k - 1))
+	 * MAX_E = (10^(x + b) * (10^(k * b) - 1)) / (10^(2x + k * b) + 10^(x + k * b) + 10^x)


Sign error?

Suggested change

* MAX_E = (10^(x + b) * (10^(k * b) - 1)) / (10^(2x + k * b) + 10^(x + k * b) + 10^x)

* MAX_E = (10^(x + b) * (10^(k * b) - 1)) / (10^(2x + k * b) + 10^(x + k * b) - 10^x)

I also don't immediately see how you go from this line (145) to line 146

Sorry, I made a pretty elementary mistake. Fixed the approximation procedure.

fa0b577

nielsdos · 2024-07-07T15:13:14Z

ext/bcmath/libbcmath/src/div.c

+	 *
+	 * Approximate again and remove +1 in the denominator
+	 * MAX_E < 10^(x + k + 2b) / (10^x * (10^(x + k * b) + 1))
+	 * MAX_E < 10^(x + k + 2b) / (10^x * 10^(x + k * b))


How do you go from this line to line 157?

nielsdos · 2024-07-07T15:24:25Z

ext/bcmath/libbcmath/src/div.c

+				n1_calc_bottom[j] -= sub_low;
+			} else {
+				n1_calc_bottom[j] += BC_VECTOR_BOUNDARY_NUM - sub_low;
+				borrow++;


Why is the borrow never reset? I think I'm missing something here.

The value is always overwritten with borrow = sub / BC_VECTOR_BOUNDARY_NUM in L209, so it's okay.

nielsdos · 2024-07-07T15:25:19Z

ext/bcmath/libbcmath/src/div.c

+	char *qptr = (*quot)->n_value;
+	char *qend = qptr + quot_len - 1;
+
+	i = 0;


Useless line? The for loop initializes this to zero in the next line

You are right, thx. I fixed it
611fbb7

SakiTakamachi · 2024-07-07T23:59:56Z

@nielsdos
Fixed comments and removed unnecessary lines. I apologize for making so many beginner's mistakes.

SakiTakamachi · 2024-07-16T00:35:38Z

Since the property hook was merged, I merged master just to be sure.

nielsdos

I think this is right, or at least I don't see anything wrong and some stress testing doesn't reveal issues.
It would still be good if someone else had a look as well.

Co-authored-by: Gina Peter Banyard <[email protected]>

Girgias

Still working through it

Girgias · 2024-07-18T19:50:59Z

ext/bcmath/libbcmath/src/div.c

+/*
+ * Used when the divisor is split into 2 or more chunks.
+ */


Nit:

Suggested change

/*

* Used when the divisor is split into 2 or more chunks.

*/

/* Used when the divisor is split into 2 or more chunks. */

Fixed
859a9db

ext/bcmath/libbcmath/src/div.c

Girgias · 2024-07-18T20:02:32Z

ext/bcmath/libbcmath/src/div.c

+	 * If calculate the temporary quotient using only one array of numerator and divisor, the error E can be larger than 1.
+	 * In other words, in the restoring division, the count of additions for restore increases significantly.


I am not exactly sure what you mean by

using only one array for numerator and divisor

The other thing, which I would like to know, is how much of an impact in performance do the repeated restores actual cause.

Because if it is negligible, I would just not bother, it would also make the initial implementation easier to review.

I am not exactly sure what you mean by

This means that an error will occur if calculations are made using only the high parts.

The other thing, which I would like to know, is how much of an impact in performance do the repeated restores actual cause.

Because if it is negligible, I would just not bother, it would also make the initial implementation easier to review.

I'll try measuring it.

Suggested change

* If calculate the temporary quotient using only one array of numerator and divisor, the error E can be larger than 1.

* In other words, in the restoring division, the count of additions for restore increases significantly.

* Because we use the restoring division we need to perform E restorations, which can be significant if E is large.

Feels like it conveys the same meaning, just way more succinctly

@Girgias
Measurements were made under conditions that would most likely make a difference.

code:

$num1 = '90000000000000000000000000000000000000000000000000000000000000'; $num2 = '109999999999999999999999999999999999999999'; $start = microtime(true); for ($i = 0; $i < 500; $i++) { bcdiv($num1, $num2, 0); } echo microtime(true) - $start . PHP_EOL;

Multiple restores: 13.932011127472s
This PR: 0.00018405914306641s

Fixed the comment
72f7f3a

@Girgias Measurements were made under conditions that would most likely make a difference.

code:

$num1 = '90000000000000000000000000000000000000000000000000000000000000'; $num2 = '109999999999999999999999999999999999999999'; $start = microtime(true); for ($i = 0; $i < 500; $i++) { bcdiv($num1, $num2, 0); } echo microtime(true) - $start . PHP_EOL;

Multiple restores: 13.932011127472s This PR: 0.00018405914306641s

Do you have the implementation without a restore in a branch somewhere just so that I can have a look?

@Girgias
Made a PR in my repository :)
SakiTakamachi#10

ext/bcmath/libbcmath/src/div.c

Co-authored-by: Gina Peter Banyard <[email protected]>

Girgias

More comments, I think I'm happy with the algorithm somewhat

ext/bcmath/libbcmath/src/div.c

Girgias · 2024-07-19T12:28:17Z

ext/bcmath/libbcmath/src/div.c

+		/* For sub, add the remainder to the high-order digit */
+		numerator_vectors[numerator_top_index - i] += div_carry * BC_VECTOR_BOUNDARY_NUM;


The "for sub" here is throwing me off, what are you trying to say precisely?

numerator_high_part is only used to calculate the quotient, and numerator_vectors does not contain div_carry here yet.

After this, add div_carry to numerator_vectors for numerator_vectors - (divisor_vectors * quot_guess).

Girgias · 2024-07-19T12:40:27Z

ext/bcmath/libbcmath/src/div.c

+static void bc_do_div(const char *n1, size_t n1_readable_len, size_t n1_bottom_extension, const char *n2, size_t n2_len, bc_num *quot, size_t quot_len)
+{


Would be good to rename n1 and n2 here as well.

Renamed
ffb6e8e

ext/bcmath/libbcmath/src/div.c

Girgias · 2024-07-19T12:43:56Z

ext/bcmath/libbcmath/src/div.c

+	/* remove n2 trailing zeros */
+	while (*n2end == 0 && n2_scale > 0) {
+		n2end--;
+		n2_scale--;
+	}
+	while (*n2end == 0) {
+		n2end--;
+		n2_int_right_zeros++;
 	}


I think having this as a private function that is also use by _bc_rm_leading_zeros() would make this less strange, especially as it used a couple of times.

Please have this in a separate commit

The loop continuation conditions for _bc_rm_leading_zeros() are as follows.

*num->n_value == 0 && num->n_len > 1

Meanwhile, the conditions for the loop that removes leading_zeros in here:

*n1ptr == 0 && n1_len > 0

Combining it with _bc_rm_leading_zeros() may be a bit more complicated, as the conditions are slightly different.

nielsdos · 2024-07-19T15:38:52Z

I think the changes made an improvement in the understandability. Looks good.

Co-authored-by: Gina Peter Banyard <[email protected]>

Girgias

More comments, but also I really would like to see what the difference in performance is between doing all the work for having a single restoration, or just having multiple restorations.

ext/bcmath/libbcmath/src/div.c

Girgias · 2024-07-21T14:38:08Z

ext/bcmath/libbcmath/src/div.c

+	 * If calculate the temporary quotient using only one array of numerator and divisor, the error E can be larger than 1.
+	 * In other words, in the restoring division, the count of additions for restore increases significantly.


Suggested change

* If calculate the temporary quotient using only one array of numerator and divisor, the error E can be larger than 1.

* In other words, in the restoring division, the count of additions for restore increases significantly.

* Because we use the restoring division we need to perform E restorations, which can be significant if E is large.

Feels like it conveys the same meaning, just way more succinctly

ext/bcmath/libbcmath/src/div.c

Girgias · 2024-07-21T14:43:00Z

ext/bcmath/libbcmath/src/div.c

+	 * numerator_arr = [0, 5678, 1234]
+	 * divisor_arr = [6789, 2345, 1]


Why is the split for the divisor favouring the low digits whereas the numerator favours the high digits?

the numerator favours the high digits

No, this isn't actually the case. Written in an easy-to-understand manner, it looks like this:

numerator_arr = [0000, 5678, 1234]

Co-authored-by: Gina Peter Banyard <[email protected]>

SakiTakamachi · 2024-07-22T02:13:34Z

@Girgias
Fixed comments and took measurements for comparison (#14660 (comment)).

SakiTakamachi · 2024-08-15T08:43:31Z

@Girgias

Do you have any other concerns about this?

SakiTakamachi requested review from Girgias and nielsdos as code owners June 25, 2024 04:01

github-actions bot added the Extension: bcmath label Jun 25, 2024

SakiTakamachi commented Jun 25, 2024

View reviewed changes

ext/bcmath/libbcmath/src/div.c Outdated Show resolved Hide resolved

SakiTakamachi force-pushed the refactor_bcdiv branch from 3e0c1df to f77cdf8 Compare June 25, 2024 15:57

SakiTakamachi force-pushed the refactor_bcdiv branch from 5762267 to 4647323 Compare June 26, 2024 09:38

jorgsowa reviewed Jun 26, 2024

View reviewed changes

SakiTakamachi force-pushed the refactor_bcdiv branch 7 times, most recently from 67b9e10 to e442f59 Compare June 28, 2024 07:53

SakiTakamachi force-pushed the refactor_bcdiv branch 2 times, most recently from 7549b7b to 6714a3b Compare June 28, 2024 11:51

SakiTakamachi commented Jun 30, 2024

View reviewed changes

nielsdos reviewed Jul 4, 2024

View reviewed changes

nielsdos reviewed Jul 7, 2024

View reviewed changes

nielsdos approved these changes Jul 16, 2024

View reviewed changes

SakiTakamachi and others added 4 commits July 18, 2024 12:12

Fixed a comment

9196685

Co-authored-by: Gina Peter Banyard <[email protected]>

Fixed var names

5b70842

Fixed confusing comments

28bf55d

Fixed a comment

eeb72ca

Co-authored-by: Gina Peter Banyard <[email protected]>

Girgias reviewed Jul 18, 2024

View reviewed changes

SakiTakamachi and others added 6 commits July 19, 2024 08:56

Fixed a comment

401ad24

Co-authored-by: Gina Peter Banyard <[email protected]>

Fixed vector to vectors

e0b83ad

Removed unnecessary comments

06b6f56

Calculate numerator_high_part first

dfb1e4f

Fixed a comment

859a9db

Fixed a comment

f24a72b

Girgias reviewed Jul 19, 2024

View reviewed changes

SakiTakamachi and others added 5 commits July 20, 2024 18:15

Added a comment that using restoring division

3cca73d

Fixed a comment

bd9b1bb

Co-authored-by: Gina Peter Banyard <[email protected]>

Added a blank line

f07abf4

Co-authored-by: Gina Peter Banyard <[email protected]>

Fixed a comment

8ca6f1e

Co-authored-by: Gina Peter Banyard <[email protected]>

Fixed var names

ffb6e8e

Girgias reviewed Jul 21, 2024

View reviewed changes

SakiTakamachi and others added 4 commits July 22, 2024 11:06

Fixed a comment

72f7f3a

Co-authored-by: Gina Peter Banyard <[email protected]>

Fixed a comment

b88956d

Co-authored-by: Gina Peter Banyard <[email protected]>

Fixed a comment

3f3679a

Co-authored-by: Gina Peter Banyard <[email protected]>

Fixed a comment

71a3ba3

Co-authored-by: Gina Peter Banyard <[email protected]>

SakiTakamachi added 2 commits July 22, 2024 11:19

Renamed var names

68bcff9

Added a early return case

d80c452

Girgias approved these changes Aug 17, 2024

View reviewed changes

SakiTakamachi merged commit 8c704ab into php:master Aug 18, 2024
11 checks passed

SakiTakamachi deleted the refactor_bcdiv branch August 18, 2024 09:00

	/* Fill with zeros and convert as many vector elements as need */
	/* Fill with zeros and convert as many vector elements as needed */

		* E = n1_high / n2_high - (n1_high * B^k + n1_low) / (n2_high * B^k + n2_low)
		* E = (n1_high * (n2_high * B^k + n2_low) - (n1_high * B^k + n1_low) * n2_high) / n2_high * (n2_high * B^k + n2_low)

	* MAX_E = (10^(x + b) * (10^(k * b) - 1)) / (10^(2x + k * b) + 10^(x + k * b) + 10^x)
	* MAX_E = (10^(x + b) * (10^(k * b) - 1)) / (10^(2x + k * b) + 10^(x + k * b) - 10^x)

		* If calculate the temporary quotient using only one array of numerator and divisor, the error E can be larger than 1.
		* In other words, in the restoring division, the count of additions for restore increases significantly.

	* If calculate the temporary quotient using only one array of numerator and divisor, the error E can be larger than 1.
	* In other words, in the restoring division, the count of additions for restore increases significantly.
	* Because we use the restoring division we need to perform E restorations, which can be significant if E is large.

		/* For sub, add the remainder to the high-order digit */
		numerator_vectors[numerator_top_index - i] += div_carry * BC_VECTOR_BOUNDARY_NUM;

		static void bc_do_div(const char n1, size_t n1_readable_len, size_t n1_bottom_extension, const char n2, size_t n2_len, bc_num *quot, size_t quot_len)
		{

		* numerator_arr = [0, 5678, 1234]
		* divisor_arr = [6789, 2345, 1]

ext/bcmath: Optimize bcdiv processing #14660

ext/bcmath: Optimize bcdiv processing #14660

Uh oh!

Conversation

SakiTakamachi commented Jun 25, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Uh oh!

SakiTakamachi commented Jun 25, 2024

Uh oh!

SakiTakamachi commented Jun 25, 2024

Uh oh!

jorgsowa Jun 26, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

SakiTakamachi commented Jun 27, 2024

Uh oh!

SakiTakamachi commented Jun 28, 2024

Uh oh!

Choose a reason for hiding this comment

Uh oh!

SakiTakamachi commented Jul 4, 2024

Uh oh!

nielsdos commented Jul 4, 2024

Uh oh!

nielsdos left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

SakiTakamachi commented Jul 5, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

nielsdos commented Jul 5, 2024

Uh oh!

nielsdos left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

ext/bcmath: Optimize `bcdiv` processing #14660

ext/bcmath: Optimize `bcdiv` processing #14660

SakiTakamachi commented Jun 25, 2024 •

edited

Loading

jorgsowa Jun 26, 2024 •

edited

Loading

SakiTakamachi commented Jul 5, 2024 •

edited

Loading

SakiTakamachi commented Jul 16, 2024 •

edited

Loading