topo | process topologies of goroutines | Code Inspection library

Put it shortly, the benchmark is flawed.

perform multiple experiments to determine the minimum access time of each thread

The term "minimum access time" is unclear here. I assume you mean "latency". The thing is your benchmark does not measure the latency. volatile tell to the compiler to read store data from the memory hierarchy. The processor is free to store the value in its cache and x86-64 processors actually do that (like almost all modern processors).

How do OMP_PLACES and OMP_PROC_BIND work?

You can find the documentation of both here and there. Put it shortly, I strongly advise you to set OMP_PROC_BIND=TRUE and OMP_PLACES="{0},{1},{2},..." based on the values retrieved from hw-loc. More specifically, you can get this from hwloc-calc which is a really great tool (consider using --li --po, and PU, not CORE because this is what OpenMP runtimes expect). For example you can query the PU identifiers of a given NUMA node. Note that some machines have very weird non-linear OS PU numbering and OpenMP runtimes sometimes fail to map the threads correctly. IOMP (OpenMP runtime of ICC) should use hw-loc internally but I found some bugs in the past related to that. To check the mapping is correct, I advise you to use hwloc-ps. Note that OMP_PLACES=cores does not guarantee that threads are not migrating from one core to another (even one on a different NUMA node) except if OMP_PROC_BIND=TRUE is set (or a similar setting). Note that you can also use numactl so to control the NUMA policies of your process. For example, you can tell to the OS not to use a given NUMA node or to interleave the allocations. The first touch policy is not the only one and may not be the default one on all platforms (on some Linux platforms, the OS can move the pages between the NUMA nodes so to improve locality).

Why is the above happening?

The code takes 4.38 ms to read 50 MiB in memory in each threads. This means 1200 MiB read from the node 0 assuming the first touch policy is applied. Thus the throughout should be about 267 GiB/s. While this seems fine at first glance, this is a pretty big throughput for such a processor especially assuming only 1 NUMA node is used. This is certainly because part of the fetches are done from the L3 cache and not the RAM. Indeed, the cache can partially hold a part of the array and certainly does resulting in faster fetches thanks to the cache associativity and good cache policy. This is especially true as the cache lines are not invalidated since the array is only read. I advise you to use a significantly bigger array to prevent this complex effect happening.

You certainly expect one NUMA node to have a smaller throughput due to remote NUMA memory access. This is not always true in practice. In fact, this is often wrong on modern 2-socket systems since the socket interconnect is often not a limiting factor (this is the main source of throughput slowdown on NUMA systems).

NUMA effect arise on modern platform because of unbalanced NUMA memory node saturation and non-uniform latency. The former is not a problem in your application since all the PUs use the same NUMA memory node. The later is not a problem either because of the linear memory access pattern, CPU caches and hardware prefetchers : the latency should be completely hidden.

Even more puzzling are the following environments and their outputs

Using 26 threads on a 24 core machine means that 4 threads have to be executed on two cores. The thing is hyper-threading should not help much in such a case. As a result, multiple threads sharing the same core will be slowed down. Because IOMP certainly pin thread to cores and the unbalanced workload, 4 threads will be about twice slower.

Having 48 threads cause all the threads to be slower because of a twice bigger workload.

This is how far I got. The zoom out from FullScreenView to GalleryView works. the only thing that doesn't, is a clean zoom in into the TabView. I suppose this is because of the wrapping by TabView.

Summary of comments:...

You should be able to find issues/problems with corrupt/incorrect PNG files using:

I guess you have used the same approach to configure languages Kontent gatsby source plugin as it is in starters.

According to the error, I would guess your environment variables are not propagated to Cloudflare. So process.env.KONTENT_LANGUAGE_CODENAMES is undefined -> which causess the error cannot read properties of undefined (reading 'split') on gatsby-config.js:30:67.

The node-sass package suggests that the Node 16 is supported in node-sass version 6+. So, install the latest version of node-sass (npm i node-sass@latest) or update the package.json dependency to "node-sass": "^7.0.1" and then try a full install again (npm install).

Edit

I had to perform a couple of extra steps to get this to work.

1. Add "node-sass": "^7.0.1" as the dependency in package.json
2. Install react-scripts version 4.0.3: npm install react-scripts@4.0.3
3. Rebuild node-sass with npm rebuild node-sass
4. Start the application with npm start

You could even investigate updating react-scripts to the latest version 5.

Of course, I did it quickly, so you have to adapt to your own code. I removed L.GeoJSON.AJAX but nothing prevents you from continuing to use it, I advise you not to ;)

On line 14, this is not valid, given the input data: lons.append(cp_dicts['geometries']['coordinates'][0]

You need to update the loop along these lines:

In this case you need to use an extent that includes all your geometries to initialize the view parameters, or after calculating zoom to that extent. For that you need to calculate the extent.

The particularity here is that your geometries are points, so you will not be able to use extent methods, because points have no extent.

But, not worries, to calculate the result extent (ie. the "full extent" of your geometries), is not difficult.

Here is a small function I put for you that can achieve that,

Sorry for not directly responding to your described error, but I would not use esri-loader with newer versions of ArcGIS for JavaScript API. Why not npm as ES modules which do not require a separate script loader?

Build with ES Module

This way you can do simple imports like this:

import WebMap from "@arcgis/core/WebMap";

Here are the initial setup instructions:

Install instructions

Finally, here is a sample react app from Esri using exactly that:

Esri React App example