bubbles | A React SSR SPA framework built on top of Parcel | Server Side Rendering library

I figured it had to do with the "List" data structure in C#, but after looking into the documentation, it appears all operations I am using in the bubbleSort function are O(1)

O(1) isn't necessarily fast, it's just constant. Changing the C# code to use an array roughly doubles its speed. Not certain exactly why that is (List uses arrays under the hood) but IIRC arrays are sometimes able to elide bounds checks.

Also, your C# swap is doing a bit more work than your JS swap; you can replace this:

Possible solution

Upgrade google analytics to firebase analaytics. Hope it'll solve your problems.Also upgrade all the library what're you using.

For me below solutions solve the problem.

Add PendingIntent.FLAG_IMMUTABLE to your pending intents.

Here is an example -

PendingIntent pendingIntent = PendingIntent.getActivity(this, alarmID, notificationIntent, PendingIntent.FLAG_IMMUTABLE);

For further information follow this link - https://developer.android.com/reference/android/app/PendingIntent#FLAG_IMMUTABLE

I suggest using flex magic with a new row-div wrapping every bubble.

That's not how it works with class. The construction parts of it would be close to correct with the old function-based setup, but class works slightly differently in this regard.

When you do new C, the object isn't created until the A constructor is called. Here's what happens:

1. new calls C's [[Construct]] internal method with new.target set to C.
   1. Any code in C prior to super() runs. this is inaccessible at this point.
   2. C's code calls B's [[Construct]] (via super()) with new.target still set to C.
      1. Any code in B prior to super() runs. this is still in accessible.
      2. B calls A's [[Construct]] (via super()) with new.target still set to C.
         1. Since A is the base constructor, A's [[Construct]] creates the object, setting its prototype from the prototype property of new.target (which is C).
         2. Any code in the A constructor runs, and has access to this.
      3. Any code in B after super() runs (and has access to this).
   3. Any code in C after super() runs (and has access to this).
2. The object created by A is the result of the new expression.

(I'm skipping over some minor details above for clarity.)

This is how the class construct ensures that the new object is initialized in order from the base constructor (A) to the first derived constructor (B) and the finally the new target (C). That way, A has access to the new object first, followed by B, followed by C.

More in in the specification link above.

It looks like GCC's naïveté about store-forwarding stalls is hurting its auto-vectorization strategy here. See also Store forwarding by example for some practical benchmarks on Intel with hardware performance counters, and What are the costs of failed store-to-load forwarding on x86? Also Agner Fog's x86 optimization guides.

(gcc -O3 enables -ftree-vectorize and a few other options not included by -O2, e.g. if-conversion to branchless cmov, which is another way -O3 can hurt with data patterns GCC didn't expect. By comparison, Clang enables auto-vectorization even at -O2, although some of its optimizations are still only on at -O3.)

It's doing 64-bit loads (and branching to store or not) on pairs of ints. This means, if we swapped the last iteration, this load comes half from that store, half from fresh memory, so we get a store-forwarding stall after every swap. But bubble sort often has long chains of swapping every iteration as an element bubbles far, so this is really bad.

(Bubble sort is bad in general, especially if implemented naively without keeping the previous iteration's second element around in a register. It can be interesting to analyze the asm details of exactly why it sucks, so it is fair enough for wanting to try.)

Anyway, this is pretty clearly an anti-optimization you should report on GCC Bugzilla with the "missed-optimization" keyword. Scalar loads are cheap, and store-forwarding stalls are costly. (Can modern x86 implementations store-forward from more than one prior store? no, nor can microarchitectures other than in-order Atom efficiently load when it partially overlaps with one previous store, and partially from data that has to come from the L1d cache.)

Even better would be to keep buf[x+1] in a register and use it as buf[x] in the next iteration, avoiding a store and load. (Like good hand-written asm bubble sort examples, a few of which exist on Stack Overflow.)

If it wasn't for the store-forwarding stalls (which AFAIK GCC doesn't know about in its cost model), this strategy might be about break-even. SSE 4.1 for a branchless pmind / pmaxd comparator might be interesting, but that would mean always storing and the C source doesn't do that.

If this strategy of double-width load had any merit, it would be better implemented with pure integer on a 64-bit machine like x86-64, where you can operate on just the low 32 bits with garbage (or valuable data) in the upper half. E.g.,

In my case, firebase UI (com.firebaseui:firebase-ui-auth:8.0.0) was using com.google.android.gms:play-services-auth:19.0.0 which I found with the command './gradlew -q app:dependencyInsight --dependency play-services-auth --configuration debugCompileClasspath'

This version of the play services auth was causing the issue for me.

I added a separate

implementation 'com.google.android.gms:play-services-auth:20.0.1'

to my gradle and this issue disappeared.

Width if the input can be adjusted by changing the display property of .emotionTagsDiv to flex

This problem is happening because the "change event" of the input is quiet special. It is managed by "ChangeEventPlugin".

One of the restrictions of this plugin is that the "change" event only will be dispatched if the input value actually changes.

To solve the problem, you have to add this in your code:

In this case, the pending intent for the geofence needs to use FLAG_MUTABLE while the notification pending intent needs to use FLAG_IMMUTABLE. Unfortunately, they have not updated the documentation or the codelabs example for targeting Android 12 yet. Here's how I modified the codelabs geofence example to work.

First, update gradle to target SDK31.

In HuntMainActivity, change the geofencePendingIntent to: