Rosetta | Java library that leverages Jackson | Object-Relational Mapping library

Since the benchmark is running linear algebra routines, what is likely being tested here are the BLAS implementations. A default Anaconda distribution for osx-64 platform is going to come with Intel's MKL implementation; the osx-arm64 platform only has the generic Netlib BLAS and the OpenBLAS implementation options.

For me (MacOS w/ Intel i9), I get the following benchmark results:

So, I suspect the old MBP had MKL installed, and the M1 system is installing either Netlib or OpenBLAS. Maybe try figuring out whether Netlib or OpenBLAS are faster on M1, and keep the faster one.

Here are specifically the different environments I tested:

Using this line should fix it:

the package you are using is not compatible with the new mac hardware by the looks of it. You will need to run this using Rosetta 2, which is an apple system component.

1. Ensure your VSCode uses the arm64 version. (it can use a different go version from the system)

2. Run Go: install/update tools. It will rebuild all tools with the arm64 go version.

I just reproduced that behavior on my Linux machine.

The problem seems to be a timing problem between your program and the "Window manager".

The "Window manager" is the program which is responsible for drawing the title bar and maybe borders at the windows. The "Window manager" works like this:

Whenever a window is mapped on the root window, the "Window manager" is notified by X11. The "Window manager" creates an "outer window" that contains the title bar and the border. Then it reparents the window so the window becomes a child window of the "outer window".

Example:

If the "Window manager" handles some window after being mapped, it becomes a child window of the "outer window"; for this reason, any window that is not a child window of an "outer window" is obviously not handled by the "Window manager" if it is mapped.

... at least in the "normal case".

For this reason, the "Window manager" does not care about windows that are un-mapped on the root window (but only about windows that are un-mapped from an "outer window").

Normally, the "Window manager" behaves like this:

I can confirm that the gcr.io/google.com/cloudsdktool/cloud-sdk:slim image used in your Dockerfile is an x86_64 image, which is incompatible with an ARM64-based M1 Mac. Since CloudSDK does not currently have any ARM64-based images, creating your own base image with CloudSDK will be necessary. The steps to do that are:

1. Update the line in your Dockerfile pointing to gcr.io/google.com/cloudsdktool/cloud-sdk:slim to a new base image (debian:buster-slim for example)
2. Install the CloudSDK tooling onto the image. It should look something like this in your Dockerfile:

I ran into this as well after an upgrade to an Apple with an M1. There are several steps toward diagnosing the root cause of the issue. The first is to check the version of Go you've got installed.

So far, the best solution I've found is to start the terminal with Rosetta 2, then run a function I have saved in .zshrc to initialize the correct conda installation so that I can use the correct architecture for my needs depending on the situation.

My current solution is the following function named x86:

At bottom, it just means that the compiler's backend was configured to emit ARM64 instructions for the program instead of (or in-addition to) x86-64 instructions.

This means that certain x86-64 specific functionality instruction can no longer be used, unless equivalent ARM instructions are used instead.

This usually isn't much of a problem though, because most macOS software is typically written at a higher level of abstraction, using system-provided frameworks.

For example, using CoreImage to manipulate images abstracts you from the details of the CPU and GPU. In such cases, Apple does the heavy lifting of porting over their frameworks. All you have to do as an application developer is to check a box that says "target ARM64".