[Optimization] Peephole Optimizations

Reference:
https://blog.regehr.org/archives/2485

Local Peephole Optimization and Compositional Refinement

Let f be a function targeted for peephole optimization. 

We can structurally decompose f into a target redex o (the optimizable instruction sequence) and a continuation context r (the residual program), such that:

f = r ∘ o

By definition, a correct optimization yields a refined sequence o′ that refines the original sequence o, denoted as:

o ⊑ o′

To lift this local optimization to the function level, we rely on the compositionality of the refinement relation. For any valid refinement definition, the context r must act as a monotonic operator:

If x ⊑ y, then r(x) ⊑ r(y)

Applying compositionality to our decomposition:

r(o) ⊑ r(o′)

Because f = r(o), it transitively follows that:

f ⊑ r(o′)

This proves that the locally optimized function refines the original function. By inductively applying this compositionality principle, we can scale this local refinement guarantee across the entire program.

[RACI]

The 4 RACI Roles

• Responsible (The "Doer"): The person (or team) who actually performs the work to complete the task. They are hands-on and do the heavy lifting.
  Rule of thumb: There should be at least one 'R', but multiple contributors can share this responsibility.
• Accountable (The "Owner"): The individual ultimately answerable for the correct and thorough completion of the deliverable. They delegate the work and sign off on the final result.
  Rule of thumb: There must be exactly one Accountable person per task to guarantee decision-making authority.
• Consulted (The "Expert"): People who provide subject-matter expertise or input before a decision or action is finalized.
  Rule of thumb: Communication is two-way.
• Informed (The "Loop"): People who need to be kept up-to-date on project progress, usually stakeholders or leadership.
  Rule of thumb: Communication is one-way—they are simply updated, not required to make decisions.

[Algorithm] Hash

xxHash

FarmHash

[C++] pointer arithmetic

Refernece:
[C++] Object Lifetimes reading minute

class Vec {
  public:
    double* data() { return &x; }

  private:
    double x,y,z;
};

Eigen::Map<...>(absl::Span<Vec>);

*(Vect::data() + 1) // Does not give us y

Take away: 

* Even though x, y, and z are allocated sequentially in memory without padding,

physical layout does not supersede semantic rules.

* The layout guarantees mean you can safely memcpy the data, or cast a Vec* to a double* to access the first element (x). It does not grant permission to use pointer arithmetic on double* to slide across the members.

* The pointer arithmetic is only guaranteed within the type of array.

* Pointer to variable only is considered as pointer to array of size 1.

* Thus any pointer arithmetic on single variable is considered out-of-bound; compiler is free to assume anything.

(reference: https://timsong-cpp.github.io/cppwp/n4140/expr.add#5)

Explain:

Only char*, unsigned char*, and std::byte* are explicitly granted an exception in the standard to 

examine the raw object representation. double* enjoys no such privilege.

(reference: https://timsong-cpp.github.io/cppwp/n4861/basic.lval#11.3)

Fix:

class Vec {
 public:
  double* data() { return data_; } // Legal: returns pointer to element 0 of a 3-element array
 private:
  double data_[3]; // x=data_[0], y=data_[1], z=data_[2]
};

心胸格局 器大識深

職場上遇到值得學習的大老

實在是可遇不可求。

與智者同行，與強者為伍。

格局大的人在種樹，

格局小的人在砍樹。

格局大的人懂得長期投資，

願意合作共贏，把餅做大；

所以有些人身邊的貴人越來越多，

有些人身邊的人卻越來越少。

不是能力的差距，

而是格局的差距。

[Clang] lifetime_capture_by attribute

Reference:
[RFC] Introduce [[clang::lifetime_capture_by(X)]]

[C++] unaligned pointer convert to more strict alignment is an UB

Never create an unaligned pointer of the struct type.

Its UB to convert from one pointer with less alignment guarantees to another with more, if the underlying pointer is not aligned. 

Everything that happens after that is UB, including arithmetic. 

Reference:
https://eel.is/c++draft/expr.static.cast#12