總覽
Skyframe StateMachine
是位於堆疊上的解構函式物件。當必要值無法立即取得,但會以非同步方式計算時,此方法可支援彈性且不重複的評估1。StateMachine
在等待期間無法綁定執行緒資源,而是必須暫停及恢復。因此,解構會公開明確的重新進入點,以便略過先前的運算。
StateMachine
可用於表示序列、分支、結構化邏輯並行作業,並專門針對 Skyframe 互動進行調整。StateMachine
可組合成較大的 StateMachine
,並共用子 StateMachine
。並行是一種結構性且純粹的邏輯。每個並行子工作都會在單一共用父項 SkyFunction 執行緒中執行。
簡介
本節會簡要說明並介紹 java.com.google.devtools.build.skyframe.state
套件中的 StateMachine
。
Skyframe 重新啟動功能簡介
Skyframe 是執行依附元件圖表平行評估的架構。圖表中的每個節點都對應至 SkyFunction 的評估結果,其中 SkyKey 會指定參數,而 SkyValue 會指定結果。運算模型允許 SkyFunction 查詢 SkyValues 的 SkyValues,以便觸發其他 SkyFunction 的遞迴且平行評估。當要求的 SkyValue 尚未就緒,因為某些運算子圖未完成,而非阻斷 (這會綁定執行緒),要求的 SkyFunction 會觀察 null
getValue
回應,並應傳回 null
而非 SkyValue,表示因缺少輸入內容而未完成。當先前要求的所有 SkyValues 都已可用時,Skyframe 會重新啟動 SkyFunction。
在 SkyKeyComputeState
推出之前,處理重新啟動作業的傳統方式是完全重新執行運算。雖然這具有二次複雜性,但由於每次重新執行時,以這種方式寫入的函式最終會完成,但傳回的查詢較少null
。有了 SkyKeyComputeState
,您就可以將手動指定的檢查點資料與 SkyFunction 建立關聯,大幅減少重新運算的次數。
StateMachine
是 SkyKeyComputeState
內的物件,可透過公開暫停和繼續執行掛鉤,在 SkyFunction 重新啟動時消除幾乎所有重新計算作業 (假設 SkyKeyComputeState
不會從快取中移除)。
SkyKeyComputeState
中的具狀態運算
從物件導向的設計的角度來看,考慮將運算物件儲存在 SkyKeyComputeState
中,而不是只儲存純資料值,在 Java 中,攜帶物件的行為最低描述是「功能介面」,而這已足夠。StateMachine
有以下有趣的遞迴定義2。
@FunctionalInterface
public interface StateMachine {
StateMachine step(Tasks tasks) throws InterruptedException;
}
Tasks
介面類似 SkyFunction.Environment
,但專為非同步作業而設計,並新增對邏輯上並行的子工作支援3。
step
的傳回值是另一個 StateMachine
,可讓您以歸納法指定一連串步驟。StateMachine
完成後,step
會傳回 DONE
。例如:
class HelloWorld implements StateMachine {
@Override
public StateMachine step(Tasks tasks) {
System.out.println("hello");
return this::step2; // The next step is HelloWorld.step2.
}
private StateMachine step2(Tasks tasks) {
System.out.println("world");
// DONE is special value defined in the `StateMachine` interface signaling
// that the computation is done.
return DONE;
}
}
說明具有下列輸出內容的 StateMachine
。
hello
world
請注意,由於 step2
符合 StateMachine
的函式介面定義,因此方法參照 this::step2
也是 StateMachine
。方法參照是指定 StateMachine
中下一個狀態最常見的方式。
直覺來說,將運算作業分解為 StateMachine
個步驟 (而非單一函式),可提供暫停和恢復運算作業所需的鉤子。StateMachine.step
傳回時,會有明確的暫停點。由傳回的 StateMachine
值指定的續行點是明確的「resume」點。因此可以避免重新計算,因為系統可以直接從上次中斷的地方開始計算。
回呼、繼續運作和非同步運算
從技術層面來說,StateMachine
是接續,用於決定要執行的後續運算。StateMachine
可以透過從 step
函式傳回,將控制權轉移回 Driver
例項,進而自願暫停,而非阻斷。接著,Driver
可以切換至準備就緒的 StateMachine
,或放棄控制項返回 SkyFrame。
傳統上,回呼和續接會混淆為一個概念。不過,StateMachine
會保留兩者之間的差異。
- 回呼 - 說明儲存非同步運算結果的儲存位置。
- 接續 - 指定下一個執行狀態。
呼叫非同步作業時必須使用回呼,這表示在呼叫方法時不會立即執行實際作業,例如 SkyValue 查詢。回呼應盡可能簡單。
接續動作是 StateMachine
的 StateMachine
傳回值,並且封裝所有非同步運算解析後的複雜執行作業。這種結構化方法有助於將回呼的複雜度控制在可管理的範圍內。
工作
Tasks
介面會為 StateMachine
提供 API,以便透過 SkyKey 查詢 SkyValue,並排定並行子工作。
interface Tasks {
void enqueue(StateMachine subtask);
void lookUp(SkyKey key, Consumer<SkyValue> sink);
<E extends Exception>
void lookUp(SkyKey key, Class<E> exceptionClass, ValueOrExceptionSink<E> sink);
// lookUp overloads for 2 and 3 exception types exist, but are elided here.
}
SkyValue 查詢
StateMachine
會使用 Tasks.lookUp
超載來查詢 SkyValues。它們與 SkyFunction.Environment.getValue
和 SkyFunction.Environment.getValueOrThrow
相似,且具有類似的例外狀況處理語意。實作不會立即執行查詢,而是在執行前盡可能批次執行4查詢作業。此值可能無法立即取得 (例如需要重新啟動 SkyFrame),因此呼叫端可使用回呼指定要如何處理產生的值。
StateMachine
處理器 (Driver
和連結至 SkyFrame) 可確保在下一個狀態開始前提供值。以下提供範例。
class DoesLookup implements StateMachine, Consumer<SkyValue> {
private Value value;
@Override
public StateMachine step(Tasks tasks) {
tasks.lookUp(new Key(), (Consumer<SkyValue>) this);
return this::processValue;
}
// The `lookUp` call in `step` causes this to be called before `processValue`.
@Override // Implementation of Consumer<SkyValue>.
public void accept(SkyValue value) {
this.value = (Value)value;
}
private StateMachine processValue(Tasks tasks) {
System.out.println(value); // Prints the string representation of `value`.
return DONE;
}
}
在上述範例中,第一個步驟會查詢 new Key()
,並將 this
做為取用端傳遞。這是因為 DoesLookup
實作了 Consumer<SkyValue>
。
根據合約,在下一個狀態 DoesLookup.processValue
開始之前,所有 DoesLookup.step
的查詢都會完成。因此,可從 processValue
存取 value
。
子工作
Tasks.enqueue
會要求在邏輯上並行執行子工作。子工作也是 StateMachine
,可以執行一般 StateMachine
的任何操作,包括遞迴建立更多子工作或查詢 SkyValues。與 lookUp
類似,狀態機器驅動程式會確保所有子工作都已完成,再繼續進行下一個步驟。以下提供範例。
class Subtasks implements StateMachine {
private int i = 0;
@Override
public StateMachine step(Tasks tasks) {
tasks.enqueue(new Subtask1());
tasks.enqueue(new Subtask2());
// The next step is Subtasks.processResults. It won't be called until both
// Subtask1 and Subtask 2 are complete.
return this::processResults;
}
private StateMachine processResults(Tasks tasks) {
System.out.println(i); // Prints "3".
return DONE; // Subtasks is done.
}
private class Subtask1 implements StateMachine {
@Override
public StateMachine step(Tasks tasks) {
i += 1;
return DONE; // Subtask1 is done.
}
}
private class Subtask2 implements StateMachine {
@Override
public StateMachine step(Tasks tasks) {
i += 2;
return DONE; // Subtask2 is done.
}
}
}
雖然 Subtask1
和 Subtask2
在邏輯上是並行,但所有內容都會在單一執行緒中執行,因此 i
的「並行」更新作業不需要任何同步處理。
結構化並行
由於每個 lookUp
和 enqueue
都必須在進到下一個狀態前解析,因此並行作業自然會限制在樹狀結構中。您可以建立階層式5 並行作業,如以下範例所示。
從 UML 中很難判斷並行結構是否形成樹狀結構。我們提供其他檢視畫面,可更清楚顯示樹狀結構。
結構化並行就是容易理解的。
組合和控制流程模式
本節將提供範例,說明如何組合多個 StateMachine
,以及解決特定控制流程問題的解決方案。
順序狀態
這是最常見且最直接的控制流程模式。SkyKeyComputeState
內部的有狀態運算中顯示了這項功能的範例。
分支版本
您可以使用一般 Java 控制流程傳回不同的值,藉此在 StateMachine
中分支狀態,如以下範例所示。
class Branch implements StateMachine {
@Override
public StateMachine step(Tasks tasks) {
// Returns different state machines, depending on condition.
if (shouldUseA()) {
return this::performA;
}
return this::performB;
}
…
}
某些分支會為了提早完成而傳回 DONE
,這很常見。
進階順序組合
由於 StateMachine
控制結構屬於無記憶體的結構,因此將 StateMachine
定義做為子工作有時可能會不太容易。讓 M1 和 M2 分別代表共用 StateMachine
S 的 StateMachine
例項,其中 M1 和 M2 分別是序列 <A, S, B> 和 <X, S, Y>。問題在於 S 不知道是否要繼續執行 B 或 Y,且 StateMachine
並未保留呼叫堆疊。本節將介紹達成此目標的幾種方法。
StateMachine
做為終端序列元素
這無法解決提出的問題。只有在共用 StateMachine
是序列終端時,才會示範順序組合。
// S is the shared state machine.
class S implements StateMachine { … }
class M1 implements StateMachine {
@Override
public StateMachine step(Tasks tasks) {
performA();
return new S();
}
}
class M2 implements StateMachine {
@Override
public StateMachine step(Tasks tasks) {
performX();
return new S();
}
}
即使 S 本身是複雜的狀態機器,這項做法也能正常運作。
依序組合作業的子工作
由於排入佇列的子工作保證會在下一個狀態前完成,因此有時可能會稍微濫用6子工作機制。
class M1 implements StateMachine {
@Override
public StateMachine step(Tasks tasks) {
performA();
// S starts after `step` returns and by contract must complete before `doB`
// begins. It is effectively sequential, inducing the sequence < A, S, B >.
tasks.enqueue(new S());
return this::doB;
}
private StateMachine doB(Tasks tasks) {
performB();
return DONE;
}
}
class M2 implements StateMachine {
@Override
public StateMachine step(Tasks tasks) {
performX();
// Similarly, this induces the sequence < X, S, Y>.
tasks.enqueue(new S());
return this::doY;
}
private StateMachine doY(Tasks tasks) {
performY();
return DONE;
}
}
runAfter
注入
有時,濫用 Tasks.enqueue
是不可能的,因為在 S 執行前,必須先完成其他並行子工作或 Tasks.lookUp
呼叫。在這種情況下,您可以將 runAfter
參數插入 S,以便通知 S 接下來要執行的動作。
class S implements StateMachine {
// Specifies what to run after S completes.
private final StateMachine runAfter;
@Override
public StateMachine step(Tasks tasks) {
… // Performs some computations.
return this::processResults;
}
@Nullable
private StateMachine processResults(Tasks tasks) {
… // Does some additional processing.
// Executes the state machine defined by `runAfter` after S completes.
return runAfter;
}
}
class M1 implements StateMachine {
@Override
public StateMachine step(Tasks tasks) {
performA();
// Passes `this::doB` as the `runAfter` parameter of S, resulting in the
// sequence < A, S, B >.
return new S(/* runAfter= */ this::doB);
}
private StateMachine doB(Tasks tasks) {
performB();
return DONE;
}
}
class M2 implements StateMachine {
@Override
public StateMachine step(Tasks tasks) {
performX();
// Passes `this::doY` as the `runAfter` parameter of S, resulting in the
// sequence < X, S, Y >.
return new S(/* runAfter= */ this::doY);
}
private StateMachine doY(Tasks tasks) {
performY();
return DONE;
}
}
此方法比濫用子工作更簡潔。不過,如果過度使用這個方法 (例如,使用 runAfter
巢狀多個 StateMachine
),就會導致回呼地獄。建議您改用一般序列狀態來分割序列 runAfter
。
return new S(/* runAfter= */ new T(/* runAfter= */ this::nextStep))
可以換成下列指令。
private StateMachine step1(Tasks tasks) {
doStep1();
return new S(/* runAfter= */ this::intermediateStep);
}
private StateMachine intermediateStep(Tasks tasks) {
return new T(/* runAfter= */ this::nextStep);
}
禁止的替代方案:runAfterUnlessError
在先前的草稿中,我們考慮了 runAfterUnlessError
,這個函式會在發生錯誤時提早中止。這是因為錯誤通常會檢查兩次:一次由具有 runAfter
參照的 StateMachine
檢查,另一次由 runAfter
機器本身檢查。
經過一番思考後,我們認為代碼的一致性比重複執行錯誤檢查更重要。如果 runAfter
機制無法以與 tasks.enqueue
機制一致的方式運作,就會造成混淆,因為 tasks.enqueue
機制一律需要進行錯誤檢查。
直接委派
每次有正式狀態轉換時,主要 Driver
迴圈都會推進。根據合約規定,進階狀態表示所有先前排入佇列的 SkyValue 查詢和子工作,會在下一個狀態執行前完成。有時委派物件 StateMachine
的邏輯會導致階段提前,造成不必要或反效果的結果。舉例來說,如果委派代表的第一個 step
執行能與委派狀態查詢平行處理的 SkyKey 查詢,則推進階段會讓這些查詢依序執行。而系統更應該執行直接委派,如以下範例所示。
class Parent implements StateMachine {
@Override
public StateMachine step(Tasks tasks ) {
tasks.lookUp(new Key1(), this);
// Directly delegates to `Delegate`.
//
// The (valid) alternative:
// return new Delegate(this::afterDelegation);
// would cause `Delegate.step` to execute after `step` completes which would
// cause lookups of `Key1` and `Key2` to be sequential instead of parallel.
return new Delegate(this::afterDelegation).step(tasks);
}
private StateMachine afterDelegation(Tasks tasks) {
…
}
}
class Delegate implements StateMachine {
private final StateMachine runAfter;
Delegate(StateMachine runAfter) {
this.runAfter = runAfter;
}
@Override
public StateMachine step(Tasks tasks) {
tasks.lookUp(new Key2(), this);
return …;
}
// Rest of implementation.
…
private StateMachine complete(Tasks tasks) {
…
return runAfter;
}
}
資料流程
先前的討論重點是控制流程管理。本節說明資料值的傳播方式。
實作 Tasks.lookUp
回呼
範例說明如何在 SkyValue 查詢中實作 Tasks.lookUp
回呼。本節將說明原因,並建議處理多個 SkyValue 的方法。
Tasks.lookUp
回呼
Tasks.lookUp
方法會將回呼 sink
做為參數。
void lookUp(SkyKey key, Consumer<SkyValue> sink);
慣用的方法是使用 Java lambda 來實作:
tasks.lookUp(key, value -> myValue = (MyValueClass)value);
其中 myValue
是執行查詢的 StateMachine
例項成員變數。不過,與在 StateMachine
實作中實作 Consumer<SkyValue>
介面相比,lambda 需要額外的記憶體配置。在有多個查詢會造成歧義的情況下,lambda 仍有其用處。
Tasks.lookUp
也有錯誤處理超載,類似於 SkyFunction.Environment.getValueOrThrow
。
<E extends Exception> void lookUp(
SkyKey key, Class<E> exceptionClass, ValueOrExceptionSink<E> sink);
interface ValueOrExceptionSink<E extends Exception> {
void acceptValueOrException(@Nullable SkyValue value, @Nullable E exception);
}
實作範例如下所示。
class PerformLookupWithError extends StateMachine, ValueOrExceptionSink<MyException> {
private MyValue value;
private MyException error;
@Override
public StateMachine step(Tasks tasks) {
tasks.lookUp(new MyKey(), MyException.class, ValueOrExceptionSink<MyException>) this);
return this::processResult;
}
@Override
public acceptValueOrException(@Nullable SkyValue value, @Nullable MyException exception) {
if (value != null) {
this.value = (MyValue)value;
return;
}
if (exception != null) {
this.error = exception;
return;
}
throw new IllegalArgumentException("Both parameters were unexpectedly null.");
}
private StateMachine processResult(Tasks tasks) {
if (exception != null) {
// Handles the error.
…
return DONE;
}
// Processes `value`, which is non-null.
…
}
}
與不含錯誤處理的查詢一樣,讓 StateMachine
類別直接實作回呼,即可為 lambda 省下記憶體配置。
「錯誤處理」可提供更多細節,但基本上,錯誤與一般值之間沒有太多差異。
使用多個 SkyValue
通常需要多次查詢 SkyValue。很多時間都可行的方法,就是切換 SkyValue 的類型。以下是從原型正式版程式碼簡化而成的範例。
@Nullable
private StateMachine fetchConfigurationAndPackage(Tasks tasks) {
var configurationKey = configuredTarget.getConfigurationKey();
if (configurationKey != null) {
tasks.lookUp(configurationKey, (Consumer<SkyValue>) this);
}
var packageId = configuredTarget.getLabel().getPackageIdentifier();
tasks.lookUp(PackageValue.key(packageId), (Consumer<SkyValue>) this);
return this::constructResult;
}
@Override // Implementation of `Consumer<SkyValue>`.
public void accept(SkyValue value) {
if (value instanceof BuildConfigurationValue) {
this.configurationValue = (BuildConfigurationValue) value;
return;
}
if (value instanceof PackageValue) {
this.pkg = ((PackageValue) value).getPackage();
return;
}
throw new IllegalArgumentException("unexpected value: " + value);
}
由於值類型不同,因此可以明確共用 Consumer<SkyValue>
回呼實作項目。若非如此,則可改用以 lambda 為基礎的實作項目,或實作適當回呼的完整內部類別例項。
在 StateMachine
之間傳播值
到目前為止,本文件只說明如何安排子工作中的工作,但子工作也需要將值回報給呼叫端。由於子工作在邏輯上屬於非同步性質,因此子工作結果會透過回呼將結果傳遞給呼叫端。為執行這項作業,子工作會定義透過其建構函式插入的接收器介面。
class BarProducer implements StateMachine {
// Callers of BarProducer implement the following interface to accept its
// results. Exactly one of the two methods will be called by the time
// BarProducer completes.
interface ResultSink {
void acceptBarValue(Bar value);
void acceptBarError(BarException exception);
}
private final ResultSink sink;
BarProducer(ResultSink sink) {
this.sink = sink;
}
… // StateMachine steps that end with this::complete.
private StateMachine complete(Tasks tasks) {
if (hasError()) {
sink.acceptBarError(getError());
return DONE;
}
sink.acceptBarValue(getValue());
return DONE;
}
}
呼叫端 StateMachine
看起來會如下所示。
class Caller implements StateMachine, BarProducer.ResultSink {
interface ResultSink {
void acceptCallerValue(Bar value);
void acceptCallerError(BarException error);
}
private final ResultSink sink;
private Bar value;
Caller(ResultSink sink) {
this.sink = sink;
}
@Override
@Nullable
public StateMachine step(Tasks tasks) {
tasks.enqueue(new BarProducer((BarProducer.ResultSink) this));
return this::processResult;
}
@Override
public void acceptBarValue(Bar value) {
this.value = value;
}
@Override
public void acceptBarError(BarException error) {
sink.acceptCallerError(error);
}
private StateMachine processResult(Tasks tasks) {
// Since all enqueued subtasks resolve before `processResult` starts, one of
// the `BarResultSink` callbacks must have been called by this point.
if (value == null) {
return DONE; // There was a previously reported error.
}
var finalResult = computeResult(value);
sink.acceptCallerValue(finalResult);
return DONE;
}
}
上述範例說明瞭幾件事。Caller
必須傳回其結果,並定義自己的 Caller.ResultSink
。Caller
會實作 BarProducer.ResultSink
回呼。恢復後,processResult
會檢查 value
是否為空值,以判斷是否發生錯誤。這是接受子工作或 SkyValue 查詢的輸出內容後的常見行為模式。
請注意,acceptBarError
的實作會根據 錯誤浮現的規定,急切地將結果轉送至 Caller.ResultSink
。
如要瞭解頂層 StateMachine
的替代方案,請參閱「Driver
和 SkyFunctions 連線」一文。
處理錯誤
Tasks.lookUp
回呼和在 StateMachines
之間傳播值中,已經有幾個錯誤處理範例。系統不會擲回 InterruptedException
以外的例外狀況,而會改為透過回呼作為值傳遞。這類回呼通常具有或非語意,會傳遞一個值或錯誤。
下一節將說明與 Skyframe 錯誤處理相關的微妙但重要的互動。
錯誤冒泡 (--nokeep_going)
在錯誤啟動期間,即使並非所有要求的 SkyValue 可用,SkyFunction 仍可能重新啟動。在這種情況下,由於 Tasks
API 合約,系統永遠不會達到後續狀態。但 StateMachine
仍應傳播例外狀況。
無論是否已達到下一個狀態,傳播作業都必須執行,因此錯誤處理回呼必須執行這項工作。對於內部 StateMachine
,這項操作是透過叫用父項回呼來完成。
在與 SkyFunction 介面的頂層 StateMachine
中,您可以呼叫 ValueOrExceptionProducer
的 setException
方法來執行此操作。ValueOrExceptionProducer.tryProduceValue
隨後會擲回例外狀況,即使有缺少的 SkyValues 也一樣。
如果直接使用 Driver
,請務必檢查 SkyFunction 是否傳播錯誤,即使機器尚未完成處理也一樣。
事件處理
對於需要發出事件的 SkyFunction,系統會將 StoredEventHandler
插入 SkyKeyComputeState,並進一步插入需要這些事件的 StateMachine
。過去,如果沒有重播,Skyframe 會捨棄特定事件,因此需要使用 StoredEventHandler
,但這個問題已在後續修正。StoredEventHandler
插入作業會保留,因為這可簡化從錯誤處理回呼發出的事件實作。
Driver
和 SkyFunctions 的橋接
Driver
負責管理 StateMachine
的執行作業,從指定的根 StateMachine
開始。由於 StateMachine
可遞迴地將子工作 StateMachine
排入佇列,因此單一 Driver
可管理多個子工作。這些子工作會建立樹狀結構,這是結構化並行的結果。Driver
會將 SkyValue 查詢資料批次化,並在各個子工作中執行,以提高效率。
有許多類別是圍繞 Driver
建構,並使用下列 API。
public final class Driver {
public Driver(StateMachine root);
public boolean drive(SkyFunction.Environment env) throws InterruptedException;
}
Driver
會採用單一根目錄 StateMachine
做為參數。呼叫
Driver.drive
會在不重新啟動 SkyFrame 的情況下盡可能執行 StateMachine
。在 StateMachine
完成時傳回 true,否則傳回 false,表示並非所有值皆可用。
Driver
會維護 StateMachine
的並行狀態,非常適合在 SkyKeyComputeState
中嵌入。
直接為 Driver
執行個體化
StateMachine
實作通常會透過回呼傳達結果。您可以直接例項化 Driver
,如以下範例所示。
Driver
會嵌入 SkyKeyComputeState
實作項目,並在稍後定義對應的 ResultSink
實作項目。在頂層,State
物件是運算結果的適當接收器,因為它保證會比 Driver
長壽。
class State implements SkyKeyComputeState, ResultProducer.ResultSink {
// The `Driver` instance, containing the full tree of all `StateMachine`
// states. Responsible for calling `StateMachine.step` implementations when
// asynchronous values are available and performing batched SkyFrame lookups.
//
// Non-null while `result` is being computed.
private Driver resultProducer;
// Variable for storing the result of the `StateMachine`
//
// Will be non-null after the computation completes.
//
private ResultType result;
// Implements `ResultProducer.ResultSink`.
//
// `ResultProducer` propagates its final value through a callback that is
// implemented here.
@Override
public void acceptResult(ResultType result) {
this.result = result;
}
}
以下程式碼會勾勒 ResultProducer
。
class ResultProducer implements StateMachine {
interface ResultSink {
void acceptResult(ResultType value);
}
private final Parameters parameters;
private final ResultSink sink;
… // Other internal state.
ResultProducer(Parameters parameters, ResultSink sink) {
this.parameters = parameters;
this.sink = sink;
}
@Override
public StateMachine step(Tasks tasks) {
… // Implementation.
return this::complete;
}
private StateMachine complete(Tasks tasks) {
sink.acceptResult(getResult());
return DONE;
}
}
然後延遲計算結果的程式碼可能如下所示。
@Nullable
private Result computeResult(State state, Skyfunction.Environment env)
throws InterruptedException {
if (state.result != null) {
return state.result;
}
if (state.resultProducer == null) {
state.resultProducer = new Driver(new ResultProducer(
new Parameters(), (ResultProducer.ResultSink)state));
}
if (state.resultProducer.drive(env)) {
// Clears the `Driver` instance as it is no longer needed.
state.resultProducer = null;
}
return state.result;
}
正在嵌入「Driver
」
如果 StateMachine
產生值且未引發例外狀況,則嵌入 Driver
是另一種可行的實作方式,如以下範例所示。
class ResultProducer implements StateMachine {
private final Parameters parameters;
private final Driver driver;
private ResultType result;
ResultProducer(Parameters parameters) {
this.parameters = parameters;
this.driver = new Driver(this);
}
@Nullable // Null when a Skyframe restart is needed.
public ResultType tryProduceValue( SkyFunction.Environment env)
throws InterruptedException {
if (!driver.drive(env)) {
return null;
}
return result;
}
@Override
public StateMachine step(Tasks tasks) {
… // Implementation.
}
SkyFunction 的程式碼可能如下所示 (其中 State
是 SkyKeyComputeState
的函式特定類型)。
@Nullable // Null when a Skyframe restart is needed.
Result computeResult(SkyFunction.Environment env, State state)
throws InterruptedException {
if (state.result != null) {
return state.result;
}
if (state.resultProducer == null) {
state.resultProducer = new ResultProducer(new Parameters());
}
var result = state.resultProducer.tryProduceValue(env);
if (result == null) {
return null;
}
state.resultProducer = null;
return state.result = result;
}
將 Driver
嵌入 StateMachine
實作項目,更適合 Skyframe 的同步程式碼樣式。
可能產生例外狀況的 StateMachine
否則,SkyKeyComputeState
可嵌入的 ValueOrExceptionProducer
和 ValueOrException2Producer
類別會提供同步 API,以符合同步 SkyFunction 程式碼。
ValueOrExceptionProducer
抽象類別包含下列方法。
public abstract class ValueOrExceptionProducer<V, E extends Exception>
implements StateMachine {
@Nullable
public final V tryProduceValue(Environment env)
throws InterruptedException, E {
… // Implementation.
}
protected final void setValue(V value) { … // Implementation. }
protected final void setException(E exception) { … // Implementation. }
}
它包含一個嵌入的 Driver
例項,並與「嵌入驅動程式」中的 ResultProducer
類別相似,並以類似方式與 SkyFunction 建立介面。而是會在發生任一情形時呼叫 setValue
或 setException
,而不是定義 ResultSink
。如果同時發生這兩種情況,系統會優先採用例外狀況。tryProduceValue
方法會將非同步回呼程式碼連結至同步程式碼,並在設定回呼程式碼時擲回例外狀況。
如先前所述,在錯誤冒泡期間,即使機器尚未完成,但由於並非所有輸入都可用,因此可能會發生錯誤。為因應此情況,tryProduceValue
會擲回任何已設定的例外狀況,即使在機器完成運作之前也是如此。
結尾:最終移除回呼
StateMachine
是效率高,但要執行非同步運算的樣板密集方式。在 Bazel 程式碼的特定部分,會廣泛使用繼續運作 (尤其是以 Runnable
的形式傳遞至 ListenableFuture
),但在分析 SkyFunctions 中並不常見。分析作業大多受限於 CPU,且沒有有效的異步 API 可用於磁碟 I/O。最後,建議您把回呼最佳化,因為回呼會經過學習,導致可讀性不佳。
Java 虛擬執行緒是最具潛力的替代方案之一。不必撰寫回呼,而是以同步的封鎖呼叫取代所有內容。這可能是因為連結虛擬執行緒資源與平台執行緒不同,應該沒什麼成本。不過,即使使用虛擬執行緒,以執行緒建立和同步處理原始碼取代簡單的同步作業,成本也太高。我們從 StateMachine
遷移至 Java 虛擬執行緒,但速度卻慢了好幾個數量級,導致端對端分析延遲時間增加了近 3 倍。由於虛擬執行緒仍是預覽功能,因此這項遷移作業可能會在日後效能改善時執行。
另一種可考慮的方法是等待 Loom 協同程式 (如果有提供的話)。這項做法的優點是,您可以透過合作多工處理來減少同步作業的額外負擔。
如果其他方法都失敗,低階位元碼重寫也可以是可行的替代方法。如果充分最佳化,也許就能利用手動編寫的回呼程式碼達到最佳效能。
附錄
回歸地獄
回呼堆積是使用回呼的非同步程式碼中嚴重的問題。原因在於後續步驟的接續程序是在上一個步驟中嵌入。如果有多個步驟,這個巢狀結構可能非常深層。如果與控制流程耦合,程式碼就會變得難以管理。
class CallbackHell implements StateMachine {
@Override
public StateMachine step(Tasks task) {
doA();
return (t, l) -> {
doB();
return (t1, l2) -> {
doC();
return DONE;
};
};
}
}
巢狀實作的優點之一,就是可以保留外部步驟的堆疊框架。在 Java 中,擷取的 lambda 變數必須有效地設為最終變數,因此使用這類變數可能會很麻煩。如要避免深層巢狀結構,請將方法參照做為連續動作傳回,而非 lambda,如下所示。
class CallbackHellAvoided implements StateMachine {
@Override
public StateMachine step(Tasks task) {
doA();
return this::step2;
}
private StateMachine step2(Tasks tasks) {
doB();
return this::step3;
}
private StateMachine step3(Tasks tasks) {
doC();
return DONE;
}
}
如果 runAfter
插入模式使用過於密集,也可能會發生回呼地獄,但只要將插入作業與順序步驟交錯使用,即可避免這種情況。
範例:鏈結 SkyValue 查詢
應用程式邏輯需要有 SkyValue 查詢的相依鏈結,例如,如果第二個 SkyKey 依附第一個 SkyValue,則屬於這種情況。無論如何,這將導致複雜且深層的回呼結構。
private ValueType1 value1;
private ValueType2 value2;
private StateMachine step1(...) {
tasks.lookUp(key1, (Consumer<SkyValue>) this); // key1 has type KeyType1.
return this::step2;
}
@Override
public void accept(SkyValue value) {
this.value1 = (ValueType1) value;
}
private StateMachine step2(...) {
KeyType2 key2 = computeKey(value1);
tasks.lookup(key2, this::acceptValueType2);
return this::step3;
}
private void acceptValueType2(SkyValue value) {
this.value2 = (ValueType2) value;
}
不過,由於接續會指定為方法參照,因此程式碼會在狀態轉換期間看起來是程序化的:step2
會接在 step1
之後。請注意,此處使用 lambda 指派 value2
。這樣一來,程式碼的順序就會與由上而下的運算順序相符。
其他提示
可讀性:執行順序
為提升可讀性,請盡量讓 StateMachine.step
實作項目保持在執行順序中,並在程式碼中傳遞回呼時立即實作回呼。但在控制流程分支時,這不一定可行。在這種情況下,提供其他意見可能會有所幫助。
在「範例:鏈結 SkyValue 查詢」中,我們會建立中間方法參照,以便達成這項目標。這麼做會犧牲一點效能,換取可讀性,在本例中可能值得這麼做。
世代假說
中期存活的 Java 物件會破壞 Java 垃圾收集器的世代假設,後者旨在處理存活時間極短或永久存活的物件。根據定義,SkyKeyComputeState
中的物件違反了這個假設。這類物件包含所有仍在執行的 StateMachine
所建構的樹狀結構,其根目錄為 Driver
,在暫停時具有中間生命週期,等待非同步運算完成。
在 JDK19 中,這個問題似乎沒有那麼嚴重,但使用 StateMachine
時,有時 GC 時間會增加,即使實際產生的垃圾減少幅度相當大也一樣。由於 StateMachine
具有中間壽命,因此可能會升級至舊版,導致舊版更快填滿,因此需要進行更耗費資源的主要或完整 GC 才能清理。
一開始的預防措施是盡量減少使用 StateMachine
變數,但有時並不可行,例如在多個狀態中需要一個值時。在可行情況下,本機堆疊 step
變數是新生代變數,且可有效 GC。
針對 StateMachine
變數,將工作細分為子工作,並遵循在 StateMachine
之間傳播值的建議模式,也相當實用。請注意,按照這個模式操作時,只有子項 StateMachine
能參照父項 StateMachine
,反之亦然。也就是說,當子項使用結果回呼完成並更新父項時,子項就會自然脫離範圍,並符合 GC 的資格。
最後,在某些情況下,需要在較早的狀態中使用 StateMachine
變數,但在較晚的狀態中則不需要。一旦知道不再需要大型物件,將其參照設為空值可能會很有幫助。
命名狀態
命名方法時,通常可以為該方法內發生的行為命名。由於 StateMachine
沒有堆疊,因此不太清楚如何在其中執行這項操作。舉例來說,假設方法 foo
會呼叫子方法 bar
。在 StateMachine
中,這可轉譯為狀態序列 foo
,後面接著 bar
。foo
不再包含 bar
行為。因此,狀態的方法名稱通常範圍較小,可反映本機行為。
並行樹狀圖
以下是結構化並行性中圖表的其他檢視畫面,可更清楚呈現樹狀結構。方塊會形成一棵小樹。
-
在沒有可用的值時,SkyFrame 的慣例做法是從從頭開始重新啟動。 ↩
-
請注意,
step
可擲回InterruptedException
,但範例略過這項操作。Bazel 程式碼中有一些低層方法會擲回此例外狀況,並向上傳播至執行StateMachine
的Driver
(稍後會加以說明)。在不需要時,不宣告擲回錯誤也沒關係。↩ -
並行子工作的動機來自
ConfiguredTargetFunction
,後者會針對每個依附元件執行獨立的工作。每個依附元件都有自己的獨立StateMachine
,而不是操控會一次處理所有依附元件的複雜資料結構,造成效率不彰的情形。↩ -
單一步驟中的多個
tasks.lookUp
呼叫會一起批次處理。在並行子工作中發生的查詢,可以建立額外的批次。 ↩ -
這麼做就像產生執行緒,然後將其加入以實現順序組合。 ↩