gm | Go语言：实现国密SM2/SM3/SM4算法；实现SM2 X509v3证书签发和解析

As there are inconsistent spaces between the digits and letter, we may use a regex lookaround

You can use

Even though nobody posted an answer, from the comment section I could conclude that:

• Nobody found any undefined behavior in the bug repro code.
• At least some of you were able to reproduce the undesired behavior.

So I filed a bug report against Visual Studio 2019.

The Microsoft team confirmed the problem.

However, unfortunately it seems like Visual Studio 2019 will not receive a bug fix because Visual Studio 2022 seemingly does not have the bug. Apparently, the most recent version not having that particular bug is good enough for Microsoft's quality standards.

I find this disappointing because I think that the correctness of a compiler is essential and Visual Studio 2022 has just been released with new features and therefore probably contains new bugs. So there is no real "stable version" (one is cutting edge, the other one doesn't get bug fixes). But I guess we have to live with that or choose a different, more stable compiler.

You need to keep the state of the position and restore it on each input. There is no other way. You can look at how content editable is handled in my project jQuery Terminal (the links point to specific lines in source code and use commit hash, current master when I've written this, so they will always point to those lines).

• insert method that is used when user type something (or on copy-paste).
• fix_textarea - the function didn't changed after I've added content editable. The function makes sure that textarea or contenteditable (that are hidden) have the same state as the visible cursor.
• clip object (that is textarea or content editable - another not refactored name that in beginning was only for clipboard).

For position I use jQuery Caret that is the core of moving the cursor. You can easily modify this code and make it work as you want. jQuery plugin can be easily refactored into a function move_cursor.

This should give you an idea how to implement this on your own in your project.

It looks like you import highlight.js in your application.js then attempt to import it again from the pinned location which is not the pattern recommended in importmaps documentation.

Try either importing the entirety of highlight.js or just import the specific languages you want.

Try updating the imports on your application.js file and removing the language specific

Once your raw_data dictionary has been created, I don't see where it is ever modified (after all, that is the point of using deepcopy on it). So while deep-copying a mutable object is not thread safe, this particular object is not undergoing mutation at any time. So I don't see why there would be an issue. But, you could always do the deepcopy under control of a lock if you were not confident.

If you are doing this with multithreading, then using a threading.Lock is probably not going to cost you in performance since the deepcopy operation is all CPU and you cannot achieve any deepcopy parallelism anyway because your thread is already locking on the Global Interpreter Lock (GIL) for that function (it is primarily Python bytecode). This additional locking just prevents giving up your time slice while in the middle of a deepcopy operation to another thread that might begin a deepcopy operation (but again, I still don't think that is an issue). But if you are using multithreading, then what performance increase will you be getting from doing concurrent I/O operations? Depending on whether you have a hard disk drive or solid state drive and what the characteristics of that drive is, concurrency might even hurt your I/O performance. You may get some performance improvement from the Pandas operations if they release the GIL.

Multiprocessing, which does provide true parallelism of CPU-intensive functions, has its own overhead in the creation of the processes and in passing data from one address space to another (i.e. one process to another). This additional overhead that you do not have in serial processing has to be compensated for by the savings achieved by parallelizing your calculations. It's not clear from what you have shown, if that is indeed representative of your actual situation, that you would gain anything from that parallelism. But, then, of course, you would not have to worry about the thread safety of deepcopy since once each process has a copy of raw_data that process would be running a single thread with its own copy of memory totally isolated from one another.

Summary

1. In general, deepcopy is not thread safe for mutable objects but since your object does not appear to be "mutating", it shouldn't be an issue. But if running under multithreading, you could do the deepcopy operation as an atomic operation under control of a multithreading.Lock without any significant loss in performance.

2. If you are using multiprocessing, and assuming raw_data was not being implemented in shared memory, then each process would be working on its own copy of raw_data to begin with. So even if another process were "mutating" raw_data, as long as any one process was running a single thread, there is no need to worry about the thread safety of deepcopy.

3. It's not clear whether multithreading or multiprocessing will achieve any performance improvements based on the code I have seen.

Benchmark

This benchmarks serial, multithreading and multiprocessing. Perhaps with only 2 keys in each dictionary this is not a realistic example but it gives a general idea:

-Wlarger-than="max-bytes" might be what you're looking for. It warns you whenever an object is defined whose size exceeds "max-bytes".

There's compiler warning C4067. It looks like you need to set the flag /Za for it to apply to #endif directives.

In the Visual Studio properties page, this flag is controlled by the setting "Disable Language Extensions" in the Language subsection of the C/C++ section.

You can use