Hacker News Reader

Comment by coldtea | Hacker News Reader

  p = p + v * dt;
  v = v + a * dt;

How is this "single assignment"? Aren't v and p assigned values already before those lines? Or do they have some default initial value for their type that doesn't count as an assignment?

View on HN

As an aside,

  v = v + a * dt;
  p = p + v * dt;

is typically more accurate. The first form is Forward Euler integration [1], while my suggestion is Semi-implicit Euler [2].

[1]: https://en.wikipedia.org/wiki/Euler_method [2]: https://en.wikipedia.org/wiki/Semi-implicit_Euler_method

It's not C, but a new language with similar syntax. Based on reading the docs at [1], the assignment is sugar for generating a new binding for the result of that expression that shadows the previous one.

[1]: http://www.sac-home.org/doku.php?id=about:core

I don't understand.

What does the "single assignment" bit get you that a compiler with an SSA pass doesn't?

I assume the removal of pointer aliasing?

Probably that the original binding of p is immutable, as it would be in a functional language: you can create a new binding, but you can't actually change the value of the existing binding.

Unless there's something I don't understand, that's what the single static assignment pass does in a compiler.

New bindings live at different addresses (if you pass a pointer to one binding, and then make a new binding with a new value, the existing pointer will point to the old value and not the new binding's value) and bindings made in a loop iteration won't live to the next iteration.

This sounds like an implementation detail. What does the language spec say about the outcome.

Different bindings are like entirely different variables that just coincidentally share the same name.

The (C) language spec says that:

  x = 5;
  int* p = &x;
  x = 6; // new binding of x
  printf("%i\n",*p);

prints "6". If new bindings lived at different addresses, it would print "5".

When the SSA pass happens in the compiler it's already too late to have guaranteed certain behaviours from the source stage...

E.g. you can turn a C program into SSA, but if you have aliasing issues, it's not gonna fix them...

An SSA pass is an implementation detail that can't change language semantics, so, as I understand, it either doesn't transform or applies only to pointers when values have externally (to the block in which they are defined) visible mutation based on the language semantics; having single assignment semantics and thereby lacking mutability is a significant property for, particularly, parallel code with shared references. If no one can mutate a reference, you don't need Rust- or Pony-like tracking of who can see or mutate it, it's safe for everyone to see it.

Maybe it’s short for:

    p[t+dt] = p[t]+v[t]*dt
    v[t+dt] = v[t]+a[t]*dt

?

Reply on news.ycombinator.com