dpzmick's comments

> If so, what's y̶o̶u̶r̶ a use-case?

CERN uses PTP on steroids for physics experiments: https://white-rabbit.web.cern.ch/

I believe there's a hint towards the end of the article:

> Note: Perlmutter’s “AI performance” is based on Nvidia’s half-precision numerical format (FP16 Tensor Core) with Nvidia’s sparsity feature enabled.

FP16 is a 16 bit floating point format. FLOPS for top 500 are measured with LINPACK HPL, which says it is over 64 bit floating point values (I think):

> HPL is a software package that solves a (random) dense linear system in double precision (64 bits) arithmetic on distributed-memory computers. It can thus be regarded as a portable as well as freely available implementation of the High Performance Computing Linpack Benchmark.

(from https://www.netlib.org/benchmark/hpl/)

This isn't totally disingenuous though. These FP16 operations are very useful for some kinds of calculations.

similar boxes are on amazon, with worse(ish) specs under the brand "Protectli "

this is a reasonable test: https://www.cs.virginia.edu/stream/ref.html

but it's pretty straightforward to just copy giant buffers in order/out of order and squint really hard at the results

I too was confused by this. Bad naming!

I'm another user of the predecessor to Conducto. We're using it to orchestrate very large regression test (usually ~40-50k independent processes run as part of the regression testing).

I also use conducto's predecessor to manage "data science" workflows (simlar to https://www.conducto.com/docs/advanced/data-science) on a large computer. It is miles ahead of the alternatives we've tried (and built).

The biggest win we've gotten with conducto comes from the composability. We can ship part of our application as a function which returns conducto nodes. Someone else can call this function an stick it into their own tree (code, not configuration!)

Our integration test suite builds a conducto tree ships containing test code from 4ish different libraries (developed by 2 different teams), each of which includes it's own tree-building functions. Likewise, we ship many of our applications for the large computer as functions which return conducto nodes. Users just call our functions and embed our portion of the workload into their own trees.

Give it a shot!

I've been going with this style for things like reading files (with retries) or any sort of loop that feels awkward.

  while (1) {
    int ret = ...;
    if (ret == ...) break;
    if (ret == some_other_condition) break;
    // additional termination conditions....
    // do exactly one thing
  }

in C, it items[0] could segfault, the fault could be caught by a signal handler which does some unbounded amount of work, then populates the appropriate memory location and returns...

More realistically, the page of memory that items[0] is sitting on could be swapped to disk, requiring the OS to do some big operation.

trying to write a piece of code with the big-O you are looking for generally has a huge number of caveats. I'm undecided on whether this is a feature (abstraction) or a flaw (easily misleading)

Another option for interesting generative art would be generative music.

There's tons of opensource audio/music generation software (ChucK, supercollider/overtone, csound, vcvrack), and there's a fun (expensive) world of modular synthesizers lurking around the corner (euclidean rhythm generation is a common technique, many people use logic gates with random of sequenced high/low signals to create interesting patterns, random voltage generation is used for pitches, etc).

If you go super far down the rabbit hole, I've seen examples of people doing generative visual art with a modular synthesizer, modulating video loop parameters, or running oscilloscopes. Anything is possible!

Very little is done with these values in the fast path. The application in question is basically a smart proxy that performs a very minimal amount of formatting. Most of the code in the fast path is pretty linear so I was curious if there were any good way to keep this particular case conditional free.

But, you are right that it probably doesn't matter. The minimal benchmarking I did convinced us that there wouldn't be much of a cost. The code that actually ended up being committed to our project has the branch.

Try compiling with c++11 turned on.

In this case, yes, optimizations don't appear to be giving me much of a win. Although, I'm very glad I checked! There are certainly some very realistic scenarios in which it would be valuable to save this branch.

In this case I don't think that being clever can actually help us much. I have some microbenchmarks towards the end of the post that are not very indicative of any performance gained by writing this "clever" code.

In the real world version of this problem the padding bytes contain some real values and the structs are both written straight to a network line (protocol is defined externally)

Thanks! I started with a fork of this Jekyll site: https://github.com/johnotander/pixyll so I can't take much credit for the design

I'll give that benchmark trick a try. Thanks for the feedback.

For some additional context, these structs are packed wire-line protocol structs. In reality the padding bytes are full of other fun details.