cf | Cloudflare CLI - A cloudflare command line interface | REST library

Looking at the result of Cachegrind, it doesn't look like the memory is your bottleneck. The NN has to be stored in memory anyway, but if it's too large that your program's having a lot of L1 cache misses, then it's worth thinking to try to minimize L1 misses, but 1.7% of L1 (data) miss rate is not a problem.

So you're trying to make this run fast anyway. Looking at your code, what's happening at the most inner loop is very simple (load-> multiply -> add -> store), and it doesn't have any side effect other than the final store. This kind of code is easily parallelizable, for example, by multithreading or vectorizing. I think you'll know how to make this run in multiple threads seeing that you can write code with some complexity, and you asked in comments how to manually vectorize the code.

I will explain that part, but one thing to bear in mind is that once you choose to manually vectorize the code, it will often be tied to certain CPU architectures. Let's not consider non-AMD64 compatible CPUs like ARM. Still, you have the option of MMX, SSE, AVX, and AVX512 to choose as an extension for vectorized computation, and each extension has multiple versions. If you want maximum portability, SSE2 is a reasonable choice. SSE2 appeared with Pentium 4, and it supports 128-bit vectors. For this post I'll use AVX2, which supports 128-bit and 256-bit vectors. It runs fine on your CPU, and has reasonable portability these days, supported from Haswell (2013) and Excavator (2015).

The pattern you're using in the inner loop is called FMA (fused multiply and add). AVX2 has an instruction for this. Have a look at this function and the compiled output.

Python's decimal module follows the IBM General Decimal Arithmetic Specification, which says that 0 to the power of 0 raises an Invalid Operation condition and produces NaN. By default, Python raises a decimal.InvalidOperation exception for Invalid Operation conditions, but you can change the context settings to get the NaN if you want:

You're using a pre-warmed image

You don't need reflection. One way is to use an interface:

I rewrote your code with some better ways to create table. My idea was to pick out the buttons that fell onto a range of type and then loop through those buttons and change its color to those type.

How about this?

ColdFusion 2018 Update 12 and ColdFusion 2021 Update 2 broke some query of query functionality. This is a known issue and has been reported to Adobe. They have (unofficially) released a patch for this issue. Unfortunately, because of the urgency with the log4J exploit, they did NOT include the patch with ColdFusion 2018 Update 13 nor ColdFusion 2021 Update 3.

Several tickets have been submitted for this. Here are a few:

CF-4212425
CF-4212580
CF-4212600

Note that this ticket includes the patches for both ColdFusion 2018 and ColdFusion 2021.

CF-4212383

I will include links to the patches here for others to find. Be sure to use the correct one for your version. You will likely need to be registered and logged into the bug Tracker to access these.

hf201800-4212383.jar

hf202100-4212383.jar

Instructions from Adobe on that ticket:

Please find the patch for CF2018 and CF2021 attached.

Steps to apply the patch-

• Download the file, rename it to hf201800-4212383.jar for CF2018 or hf202100-4212383.jar for CF2021.
• Place the file indside \cfusion\lib\updates
• Restart CF server.

Comment by Aayushi R.

Obviously you should apply these to non-production servers first and test.

The Response that you're printing is basically just the initial HTTP info (e.g. status and headers). You'll need to wait for the payload as well using methods depending on what you're expecting:

• bytes/bytes_stream/chunk to get the raw data
• text/text_with_charset to get the data as a string
• json to deserialize the data into a structured type (see the docs for serde_json for more info)

In this case it looks like you're getting a JSON payload so using .json() into a deserializable type sounds like the right way to go, but if your only goal is to print it then .text() is probably the simpler approach.

May be not quite what you want (if you insist on using built in Powershell commands), but if you care about speed, use streams and asynchronous Read/Write. Powershell is a great tool because it can use any .NET classes seamlessly.

The script below can easily be extended to write to more than 2 destinations and can potentially handle arbitrary streams. You might want to add some error handling via try/catch there too. You may also try to play with buffered streams with various buffer size to optimize the code.

Some references:

• FileStream.ReadAsync
• FileStream.WriteAsync
• CancellationToken
• Task.GetAwaiter

-- 2021-12-09 update: Code is modified a little to reflect suggestions from comments.