mkbosmans

If you capture the heat from the burning, e.g. to generate electricity, then that can save burning oil/gas/coal instead.

Furthermore, the landfill will usually also generate gasses like methane, which need to be burned off too.

Nobody says they have no limitations. The question is are those limitation fundamental, i.e. can we expect improvement, say within a year.

No need for radical changes.

  def visit_bf(g):
    n, children = g
    yield n
    if children:
        iterators = [iter(visit_df(c)) for c in children]
        while iterators:
            try:
                yield next(iterators[0])
            except StopIteration:
                iterators.pop(0)
            iterators = iterators[1:] + iterators[:1]

The difference between DFS and BFS is literally just the last line that rotates the list of child trees.

Python is a pretty mainstream language and even though the DFS case can be simplified by using `yield from` and BFS cannot, I consider that just to be syntactic sugar on top of this base implementation.

Well, the article says that the effect of the impact was much larger than the scientists expected. That doesn't really give a lot of confidence in how good we are at predicting these things.

That's not just a good prediction—it is literally already happening right now!

Nothing on that list has been named that way by Euler himself of course.

I saw that you used `float z;` to later use `z` instead of the constant `0.`. You can also apply that to get a zero vector: `vec3 y;` and use `y` in place of `p-p`.

It seems that leaving the obsession behind some more can save another byte.

Another two bytes found (I think)

  (d==0.?K*.01*h:c-c)

could become

  (d>0.?.0:.01)*K*h

Especially in HPC there are lots of workloads that do not benefit from SMT. Such workloads are almost always bottlenecked on either memory bandwidth or vector execution ports. These are exactly the resources that are shared between the sibling threads.

So now you have a choice of either disabling SMT in the bios, or make sure the application correctly interprets the CPU topology and only spawns one thread per physical core. The former is often the easier option, both from software development and system administration perspective.

Sort of niche indeed.

In addition to needing SMT to get full performance, there were a lot of other small details you needed to get right on Xeon Phi to get close to the advertised performance. Think of AVX512 and the HBM.

For practical applications, it never really delivered.

I'm not sure what the OS on the X32 (or the Midas M32 sister model for that matter) is from factory. The higher end Midas Pro consoles do definitely run on Linux though.

It is the performance win for similar looking results that I find improbable. For a box blur to look like gaussian blur, you would need multiple passes. Even though each pass is now O(1) instead of O(n) (with n the blur radius), due to caching effects I think a gaussian kernel would still be faster, especially for the small blur radius as described in the article.