tracer | Communication Interface for Tracer MT-5

Here are some leading questions that can help you reach the answer. Answers to the questions after a break:

1. Where does the jmp rel -1 instruction jump to?
2. What does the target instruction do? What happens after it?
3. How did this instruction end up in the program section of the memory?

1. jmp rel -1 is encoded in the memory at addresses 5-6. When it is executed, we have pc = 5, thus after the jump we will execute the instruction at pc = 4, which is 0x48307fff7fff8000.
2. This bytecode encodes the instruction [ap] = [ap - 1] + [ap - 1]; ap++ (to check, you can manually decode the flags and offsets, or simply write a cairo program with this instruction and see what it compiles to). After it is executed, pc is increased by 1, so we again execute jmp rel -1, and so on in an infinite loop. It should be clear why this fills the memory with powers of 2 (the first 2, at address 10, was written by the [fp + 1] = 2; ap++ instruction).
3. The instruction [fp] = 5201798304953761792; ap++ has an immediate argument (the right hand side, 5201798304953761792). Instructions with immediate arguments are encoded as two field elements in the memory, the first encoding the general instruction (e.g. [fp] = imm; ap++), and the second being the immediate value itself. This immediate value is thus written in address 4, and indeed 5201798304953761792 is the same as 0x48307fff7fff8000. Similarly, the 2 at address 2 is the immediate argument of the instruction [fp + 1] = 2, and the -1 at address 6 is the immediate of jmp rel -1.

To summarize, this strange behavior is due to the relative jump moving to an address of an immediate value and parsing it as a standalone instruction. Normally this wouldn't occur, since pc is incremented by 2 after executing an instruction with an immediate value, and by 1 when executing an instruction without one, so it always continues to the next compiled instruction. The unlabeled jump was necessary here to reach this unexpected program counter.

Opening a type exposes all accessible static members of the type, so I think this does what you want:

You can use time.sleep(1.0) rather than counting the zzz.

Service name must be set via resource as per the specification. I am not sure which version of js libs you are using. This should get you the service name.

It sounds like you're thinking of static arguments as "values that don't vary between computations". In JAX's JIT, static arguments can better be thought of as "hashable compile-time constants". In your case, you don't have hashable compile-time constants; you have arrays, so you can just JIT-compile with no static args:

Probably this answer will be useful for you. This nvidia_smi python module have some useful tools like checking the gpu total memory. Here I reproduce the code of the answer I mentioned earlier.

After some debugging, I figured out the answer.

Seems like with this simple example, the BatchSpanProcessor is not a good idea because there is only one span that is getting traced.

SimpleSpanProcessor directly forwards the spans to Cloud Trace no matter what whereas BatchSpanProcessor waits until there is enough data before pushing to Cloud Trace. Hence why I was not seeing anything in Cloud Trace because BatchSpanProcessor hadn't registered enough spans for it to actually upload it to Google Cloud.

Span Processors Documentation

Change the following lines

Ok, I figured out how to make it work. I added this middleware and it will sync the request context with the headers traceID, spanID and traceFlags. After this we are good to create tracer and spans as we want.

It's the approximate amount of time the goroutine was blocked. It is only displayed if the amount of time the goroutine was blocked is at least 1 minute.

You can look at the code that produces this output in the go runtime source, runtime/traceback.go (linked is the go1.16.6 version of the code).