mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-19 07:51:57 +09:00
[Perf] (TLS): pGLContext and gPipeInputs become pointer slots
This commit is contained in:
@@ -147,17 +147,17 @@ TEST(ContextEpochTest, SameXfbNameInTwoServedContextsDoesNotAliasThePausedSpan)
|
||||
TEST(ContextEpochTest, ServerLivenessDoesNotFollowTheClientContextOrAVerbStamp) {
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
DriverScope scope;
|
||||
auto context = Move(MG_State::pGLContext);
|
||||
auto context = MG_State::pGLContext.Take();
|
||||
const Bool previous = MG_Pipe::MGPipeServerContextIsLive();
|
||||
MG_Pipe::MGPipeServerSetContextLive(false);
|
||||
MG_State::pGLContext = MakeUnique<MG_State::GLState::GLContext>();
|
||||
EXPECT_FALSE(MG_Pipe::gPipeInputs.IsLive());
|
||||
EXPECT_FALSE(MG_Pipe::gPipeInputs->IsLive());
|
||||
MG_Pipe::MGPipeServerSetContextLive(true);
|
||||
MG_State::pGLContext.reset();
|
||||
EXPECT_TRUE(MG_Pipe::gPipeInputs.IsLive());
|
||||
EXPECT_TRUE(MG_Pipe::gPipeInputs->IsLive());
|
||||
MG_Pipe::MGPipeServerSetContextLive(false);
|
||||
MG_Pipe::MGPipeServerStampVerbBoundary(MG_Pipe::MGPipeVerb::DrawArrays);
|
||||
EXPECT_FALSE(MG_Pipe::gPipeInputs.IsLive()) << "a stale command resurrected a destroyed server context";
|
||||
EXPECT_FALSE(MG_Pipe::gPipeInputs->IsLive()) << "a stale command resurrected a destroyed server context";
|
||||
MG_Pipe::MGPipeServerClearVerbBoundary();
|
||||
MG_State::pGLContext = Move(context);
|
||||
MG_Pipe::MGPipeServerSetContextLive(previous);
|
||||
|
||||
@@ -87,7 +87,7 @@ namespace {
|
||||
m_blockKb = MG_Config::RecordArm.PersistentBlockKb;
|
||||
m_adoptTier = MG_Config::Ipc.AdoptTier;
|
||||
m_pipeStats = MG_Config::Features.PipeStats;
|
||||
m_context = Move(MG_State::pGLContext);
|
||||
m_context = MG_State::pGLContext.Take();
|
||||
MG_State::pGLContext = MakeUnique<MG_State::GLState::GLContext>();
|
||||
MG_Config::Transport = MG_Config::TransportMode::InProcess;
|
||||
MG_Config::RecordArm.PersistentBlockKb = 64;
|
||||
|
||||
@@ -87,7 +87,7 @@ namespace {
|
||||
class FieldOwnershipTest : public ::testing::Test {
|
||||
protected:
|
||||
void SetUp() override {
|
||||
m_previous = Move(MG_State::pGLContext);
|
||||
m_previous = MG_State::pGLContext.Take();
|
||||
MG_State::pGLContext = MakeUnique<GLContext>();
|
||||
#if MOBILEGL_BUILD_DISAGGREGATED
|
||||
MG_Config::Ipc.StrictErrors = false;
|
||||
@@ -486,14 +486,14 @@ TEST_F(FieldOwnershipTest, TheResidualFillsSuppliedMemoReKeysOnEveryInputThatMov
|
||||
|
||||
TEST_F(FieldOwnershipTest, AServerStampMakesRecordSuppliedFieldsFreshAndWithdrawsTheRest) {
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::Clear);
|
||||
EXPECT_TRUE(gPipeInputs.ServerStampedVerb());
|
||||
EXPECT_EQ(gPipeInputs.CurrentVerb(), MGPipeVerb::Clear);
|
||||
EXPECT_TRUE(gPipeInputs->ServerStampedVerb());
|
||||
EXPECT_EQ(gPipeInputs->CurrentVerb(), MGPipeVerb::Clear);
|
||||
const MGPipeFieldMask& mask = kMGPipeClassFieldMask[static_cast<SizeT>(
|
||||
kMGPipeVerbClass[static_cast<SizeT>(MGPipeVerb::Clear)])];
|
||||
SizeT stamped = 0;
|
||||
for (SizeT i = 0; i < kMGPipeInputFieldCount; ++i) {
|
||||
const auto field = static_cast<MGPipeInputField>(i);
|
||||
const Bool fresh = MGPipeInputFieldIsFresh(gPipeInputs.FilledState(), field);
|
||||
const Bool fresh = MGPipeInputFieldIsFresh(gPipeInputs->FilledState(), field);
|
||||
// The stamp respects the verb's own may-read table for the client fill's reason: a
|
||||
// field outside the class was never copied for this verb, so answering it would hand
|
||||
// the server the previous verb's value.
|
||||
@@ -512,7 +512,7 @@ TEST_F(FieldOwnershipTest, AServerStampMakesRecordSuppliedFieldsFreshAndWithdraw
|
||||
// `answerable` out of kMGPipeFieldOwnership, so it can only catch a stamp that disagrees
|
||||
// with the table - never a table that is wrong. These four say what the stamp must do for
|
||||
// four fields whose class is an argument of this package rather than a lookup.
|
||||
const MGPipeFilledState& filled = gPipeInputs.FilledState();
|
||||
const MGPipeFilledState& filled = gPipeInputs->FilledState();
|
||||
EXPECT_TRUE(MGPipeInputFieldIsFresh(filled, MGPipeInputField::GetClearColor)); // supplied
|
||||
EXPECT_TRUE(MGPipeInputFieldIsFresh(filled, MGPipeInputField::GetRenderStateParameters));
|
||||
EXPECT_FALSE(MGPipeInputFieldIsFresh(filled, MGPipeInputField::GetFramebufferBindingSlot)); // pulled
|
||||
@@ -525,14 +525,14 @@ TEST_F(FieldOwnershipTest, AServerStampMakesRecordSuppliedFieldsFreshAndWithdraw
|
||||
// changing. Before this, the seven most dangerous fields were exempt by construction.
|
||||
TEST_F(FieldOwnershipTest, TheStickyExemptionIsCancelledByTheServerStamp) {
|
||||
MGPipeValidateForVerb(MGPipeVerb::Clear); // the CLIENT fills and stamps all 63, sticky included
|
||||
EXPECT_TRUE(MGPipeInputFieldIsFresh(gPipeInputs.FilledState(), MGPipeInputField::RecordError));
|
||||
EXPECT_TRUE(MGPipeInputFieldIsFresh(gPipeInputs->FilledState(), MGPipeInputField::RecordError));
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::Clear);
|
||||
for (SizeT i = 0; i < kMGPipeFieldOwnershipForwardCount; ++i) {
|
||||
const MGPipeInputField field = kMGPipeFieldOwnershipForwardField[i];
|
||||
// P5f fe retired the scalar forwards to server-owned answers. Their freshness
|
||||
// comes from that ownership; the remaining client forwards lose the exemption.
|
||||
const Bool serverOwned = MGPipeFieldOwnershipOf(field) == MGPipeFieldOwnership::kApplierDerived;
|
||||
EXPECT_EQ(MGPipeInputFieldIsFresh(gPipeInputs.FilledState(), field), serverOwned)
|
||||
EXPECT_EQ(MGPipeInputFieldIsFresh(gPipeInputs->FilledState(), field), serverOwned)
|
||||
<< kMGPipeInputFieldNames[Index(field)] << " has the wrong server-stamp freshness";
|
||||
}
|
||||
}
|
||||
@@ -543,21 +543,21 @@ TEST_F(FieldOwnershipTest, ARecordSuppliedFieldIsReadableAfterAServerStamp) {
|
||||
ASSERT_EQ(MGPipeFieldOwnershipOf(MGPipeInputField::GetClearColor),
|
||||
MGPipeFieldOwnership::kRecordSupplied);
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::Clear);
|
||||
(void)gPipeInputs.GetClearColor();
|
||||
(void)gPipeInputs.GetRenderStateParameters();
|
||||
(void)gPipeInputs->GetClearColor();
|
||||
(void)gPipeInputs->GetRenderStateParameters();
|
||||
EXPECT_EQ(MGPipeResidualPullCount(), Uint64{0});
|
||||
// The pixel store is in kReadback's class, not kClear's, so its readable half is exercised
|
||||
// under the verb that actually reads it. And P5c rv's record-supplied rows join it there:
|
||||
// GetActiveTextureUnit is exactly the read that used to count into `rsp`.
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::ReadPixels);
|
||||
(void)gPipeInputs.GetPixelStoreParameters(false); // the half that has a carrier
|
||||
(void)gPipeInputs.GetActiveTextureUnit(); // P5c rv: set_context_values carries it
|
||||
(void)gPipeInputs.GetMaxTouchedTextureUnit();
|
||||
(void)gPipeInputs->GetPixelStoreParameters(false); // the half that has a carrier
|
||||
(void)gPipeInputs->GetActiveTextureUnit(); // P5c rv: set_context_values carries it
|
||||
(void)gPipeInputs->GetMaxTouchedTextureUnit();
|
||||
EXPECT_EQ(MGPipeResidualPullCount(), Uint64{0});
|
||||
// And a shutter answers the applier's own Serial under a server stamp (APPLIER-DERIVED),
|
||||
// not the client's residual-fill copy: still zero pulls, and the answer MOVES when the
|
||||
// applier's texture state does.
|
||||
(void)gPipeInputs.GetTextureBindGeneration();
|
||||
(void)gPipeInputs->GetTextureBindGeneration();
|
||||
EXPECT_EQ(MGPipeResidualPullCount(), Uint64{0});
|
||||
}
|
||||
|
||||
@@ -578,16 +578,16 @@ TEST_F(FieldOwnershipTest, SetContextValuesLandsInPipeInputsAndTheShuttersAnswer
|
||||
MGPipeApplySetContextValues(values);
|
||||
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::ReadPixels);
|
||||
EXPECT_EQ(gPipeInputs.GetActiveTextureUnit(), 5);
|
||||
EXPECT_EQ(gPipeInputs.GetMaxTouchedTextureUnit(), 23);
|
||||
EXPECT_EQ(gPipeInputs->GetActiveTextureUnit(), 5);
|
||||
EXPECT_EQ(gPipeInputs->GetMaxTouchedTextureUnit(), 23);
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::DrawArrays);
|
||||
EXPECT_EQ(gPipeInputs.GetTouchedBufferBindingPointCount(BufferTarget::Uniform), SizeT{7});
|
||||
EXPECT_EQ(gPipeInputs.GetTouchedBufferBindingPointCount(BufferTarget::Vertex), SizeT{0});
|
||||
EXPECT_TRUE(gPipeInputs.IsTransformFeedbackActive());
|
||||
EXPECT_FALSE(gPipeInputs.IsTransformFeedbackPaused());
|
||||
EXPECT_EQ(gPipeInputs.GetTransformFeedbackGeneration(), 0x1112131415161718ull);
|
||||
EXPECT_EQ(gPipeInputs.GetBoundTransformFeedbackLifetimeId(), 0x2122232425262728ull);
|
||||
EXPECT_EQ(gPipeInputs.GetTransformFeedbackCapturedVertices(), 0x3132333435363738ull);
|
||||
EXPECT_EQ(gPipeInputs->GetTouchedBufferBindingPointCount(BufferTarget::Uniform), SizeT{7});
|
||||
EXPECT_EQ(gPipeInputs->GetTouchedBufferBindingPointCount(BufferTarget::Vertex), SizeT{0});
|
||||
EXPECT_TRUE(gPipeInputs->IsTransformFeedbackActive());
|
||||
EXPECT_FALSE(gPipeInputs->IsTransformFeedbackPaused());
|
||||
EXPECT_EQ(gPipeInputs->GetTransformFeedbackGeneration(), 0x1112131415161718ull);
|
||||
EXPECT_EQ(gPipeInputs->GetBoundTransformFeedbackLifetimeId(), 0x2122232425262728ull);
|
||||
EXPECT_EQ(gPipeInputs->GetTransformFeedbackCapturedVertices(), 0x3132333435363738ull);
|
||||
// Eight record-supplied reads and not one residual pull.
|
||||
EXPECT_EQ(MGPipeResidualPullCount(), Uint64{0});
|
||||
|
||||
@@ -595,12 +595,12 @@ TEST_F(FieldOwnershipTest, SetContextValuesLandsInPipeInputsAndTheShuttersAnswer
|
||||
// SHUTTERS - the value matters only in that it MOVES when the server's texture state does
|
||||
// and never walks backwards - so the pin is the identity with the applier's counters, not
|
||||
// any particular number.
|
||||
EXPECT_EQ(gPipeInputs.GetTextureBindGeneration(), MGPipeApplierTextureShutterSerial());
|
||||
EXPECT_EQ(gPipeInputs.GetSamplingResolutionGeneration(), MGPipeApplierTextureShutterSerial());
|
||||
EXPECT_EQ(gPipeInputs.GetTextureContextId(), MGPipeApplierContextSerial());
|
||||
EXPECT_EQ(gPipeInputs->GetTextureBindGeneration(), MGPipeApplierTextureShutterSerial());
|
||||
EXPECT_EQ(gPipeInputs->GetSamplingResolutionGeneration(), MGPipeApplierTextureShutterSerial());
|
||||
EXPECT_EQ(gPipeInputs->GetTextureContextId(), MGPipeApplierContextSerial());
|
||||
const Uint64 before = MGPipeApplierTextureShutterSerial();
|
||||
MGPipeApplierNoteTextureStateMoved();
|
||||
EXPECT_EQ(gPipeInputs.GetTextureBindGeneration(), before + 1)
|
||||
EXPECT_EQ(gPipeInputs->GetTextureBindGeneration(), before + 1)
|
||||
<< "a texture-state apply moved the serial but the shutter did not answer with it";
|
||||
EXPECT_EQ(MGPipeResidualPullCount(), Uint64{0});
|
||||
}
|
||||
@@ -612,7 +612,7 @@ TEST_F(FieldOwnershipTest, ABarrierPulledReadAfterAServerStampIsCountedNotFatal)
|
||||
const ChildResult r = RunInChild([] {
|
||||
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::DrawArrays);
|
||||
(void)gPipeInputs.GetBoundVertexArray();
|
||||
(void)gPipeInputs->GetBoundVertexArray();
|
||||
});
|
||||
ASSERT_TRUE(DiedOfAbort(r)) << DescribeStatus(r) << "\n" << r.Log;
|
||||
EXPECT_NE(r.Log.find("Fatal{UnmigratedPipeInput, \"GetBoundVertexArray@DrawArrays\"}"), std::string::npos) << r.Log;
|
||||
@@ -629,7 +629,7 @@ TEST_F(FieldOwnershipTest, AStickyForwardIsCountedAsAResidualPull) {
|
||||
const ChildResult r = RunInChild([] {
|
||||
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::Clear);
|
||||
(void)gPipeInputs.ValidateProgramName(1u);
|
||||
(void)gPipeInputs->ValidateProgramName(1u);
|
||||
});
|
||||
ASSERT_TRUE(DiedOfAbort(r)) << DescribeStatus(r) << "\n" << r.Log;
|
||||
EXPECT_NE(r.Log.find("Fatal{UnmigratedPipeInput, \"ValidateProgramName@Clear\"}"), std::string::npos) << r.Log;
|
||||
@@ -644,11 +644,11 @@ TEST_F(FieldOwnershipTest, AStickyForwardIsCountedAsAResidualPull) {
|
||||
// for - and what keeps build-split's monolith lanes behaving as a verify build's do.
|
||||
TEST_F(FieldOwnershipTest, NothingIsCountedOutsideAServerStampedVerb) {
|
||||
MGPipeValidateForVerb(MGPipeVerb::ReadPixels);
|
||||
(void)gPipeInputs.ValidateProgramName(1u);
|
||||
gPipeInputs.InvalidateCompileEnv();
|
||||
(void)gPipeInputs.GetActiveTextureUnit();
|
||||
(void)gPipeInputs->ValidateProgramName(1u);
|
||||
gPipeInputs->InvalidateCompileEnv();
|
||||
(void)gPipeInputs->GetActiveTextureUnit();
|
||||
EXPECT_EQ(MGPipeResidualPullCount(), Uint64{0});
|
||||
EXPECT_FALSE(gPipeInputs.ServerStampedVerb());
|
||||
EXPECT_FALSE(gPipeInputs->ServerStampedVerb());
|
||||
}
|
||||
|
||||
// THE APPLIER'S OWN CLEAR, reached directly rather than through the client's fill. In a spawned
|
||||
@@ -658,13 +658,13 @@ TEST_F(FieldOwnershipTest, NothingIsCountedOutsideAServerStampedVerb) {
|
||||
// InvalidateCompileEnv is reached from backend initialisation under - is gone for good.
|
||||
TEST_F(FieldOwnershipTest, TheAppliersOwnClearDisarmsTheStampWithoutTheClientsFill) {
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::ReadPixels);
|
||||
ASSERT_TRUE(gPipeInputs.ServerStampedVerb());
|
||||
(void)gPipeInputs.GetActiveTextureUnit();
|
||||
ASSERT_TRUE(gPipeInputs->ServerStampedVerb());
|
||||
(void)gPipeInputs->GetActiveTextureUnit();
|
||||
ASSERT_EQ(MGPipeResidualPullCount(), Uint64{0});
|
||||
MGPipeServerClearVerbBoundary();
|
||||
EXPECT_FALSE(gPipeInputs.ServerStampedVerb());
|
||||
(void)gPipeInputs.ValidateProgramName(1u);
|
||||
gPipeInputs.InvalidateCompileEnv();
|
||||
EXPECT_FALSE(gPipeInputs->ServerStampedVerb());
|
||||
(void)gPipeInputs->ValidateProgramName(1u);
|
||||
gPipeInputs->InvalidateCompileEnv();
|
||||
EXPECT_EQ(MGPipeResidualPullCount(), Uint64{0});
|
||||
}
|
||||
|
||||
@@ -677,7 +677,7 @@ TEST_F(FieldOwnershipTest, ABarrierPulledFieldOutsideTheVerbsClassIsStillFatal)
|
||||
#if MGTEST_HAVE_FORK
|
||||
const ChildResult r = RunInChild([] {
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::Clear);
|
||||
(void)gPipeInputs.GetProgramForDraw(); // retired accessor, outside kClear too
|
||||
(void)gPipeInputs->GetProgramForDraw(); // retired accessor, outside kClear too
|
||||
});
|
||||
ASSERT_TRUE(DiedOfAbort(r)) << DescribeStatus(r) << "\n" << r.Log;
|
||||
EXPECT_NE(r.Log.find("Fatal{UnmigratedPipeInput, \"GetProgramForDraw@Clear\"}"), std::string::npos)
|
||||
@@ -693,7 +693,7 @@ TEST_F(FieldOwnershipTest, ResidualPullsReachThePublishedPerFrameCounter) {
|
||||
PS::SetEnabledForTesting(true);
|
||||
PS::ResetForTesting();
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::DrawArrays);
|
||||
(void)gPipeInputs.GetCurrentVertexAttribute(0);
|
||||
(void)gPipeInputs->GetCurrentVertexAttribute(0);
|
||||
EXPECT_EQ(PS::FrameCalls(PS::CallClass::ResidualPulls), Uint64{0});
|
||||
EXPECT_NE(PS::FormatWindowLine().find(" rsp=0"), std::string::npos) << PS::FormatWindowLine();
|
||||
// Prove the reporting channel did not merely become a constant zero after retirement.
|
||||
@@ -742,9 +742,9 @@ TEST_F(FieldOwnershipTest, SplitBindingPointCapacityNeverConsultsTheFrontend) {
|
||||
RoleSplitArm guard;
|
||||
guard.Arm(true);
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::DrawArrays);
|
||||
EXPECT_EQ(gPipeInputs.GetBufferBindingPointCount(BufferTarget::Uniform), 84u);
|
||||
EXPECT_EQ(gPipeInputs.GetBufferBindingPointCount(BufferTarget::TransformFeedback), 84u);
|
||||
EXPECT_EQ(gPipeInputs.GetBufferBindingPointCount(BufferTarget::PixelPack), 0u);
|
||||
EXPECT_EQ(gPipeInputs->GetBufferBindingPointCount(BufferTarget::Uniform), 84u);
|
||||
EXPECT_EQ(gPipeInputs->GetBufferBindingPointCount(BufferTarget::TransformFeedback), 84u);
|
||||
EXPECT_EQ(gPipeInputs->GetBufferBindingPointCount(BufferTarget::PixelPack), 0u);
|
||||
EXPECT_EQ(MGPipeFieldOwnershipOf(MGPipeInputField::GetBufferBindingPointCount),
|
||||
MGPipeFieldOwnership::kApplierDerived);
|
||||
MGPipeServerClearVerbBoundary();
|
||||
@@ -756,16 +756,16 @@ TEST_F(FieldOwnershipTest, SplitOpenSpansAreOwnedByTheApplierAndSurviveOtherBind
|
||||
auto& state = MGPipeApplier();
|
||||
state.StreamOutputSpans.clear();
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::DrawArrays);
|
||||
EXPECT_FALSE(gPipeInputs.HasOpenTransformFeedbackSpan(0));
|
||||
EXPECT_FALSE(gPipeInputs.HasOpenTransformFeedbackSpan(11));
|
||||
EXPECT_FALSE(gPipeInputs->HasOpenTransformFeedbackSpan(0));
|
||||
EXPECT_FALSE(gPipeInputs->HasOpenTransformFeedbackSpan(11));
|
||||
state.StreamOutputSpans[11] = {};
|
||||
state.StreamOutputSpans[12] = {};
|
||||
state.BoundStreamOutputLifetimeId = 12;
|
||||
EXPECT_TRUE(gPipeInputs.HasOpenTransformFeedbackSpan(11));
|
||||
EXPECT_TRUE(gPipeInputs.HasOpenTransformFeedbackSpan(12));
|
||||
EXPECT_TRUE(gPipeInputs->HasOpenTransformFeedbackSpan(11));
|
||||
EXPECT_TRUE(gPipeInputs->HasOpenTransformFeedbackSpan(12));
|
||||
state.StreamOutputSpans.erase(12);
|
||||
EXPECT_TRUE(gPipeInputs.HasOpenTransformFeedbackSpan(11));
|
||||
EXPECT_FALSE(gPipeInputs.HasOpenTransformFeedbackSpan(12));
|
||||
EXPECT_TRUE(gPipeInputs->HasOpenTransformFeedbackSpan(11));
|
||||
EXPECT_FALSE(gPipeInputs->HasOpenTransformFeedbackSpan(12));
|
||||
EXPECT_EQ(MGPipeFieldOwnershipOf(MGPipeInputField::HasOpenTransformFeedbackSpan),
|
||||
MGPipeFieldOwnership::kApplierDerived);
|
||||
state.StreamOutputSpans.clear();
|
||||
@@ -793,7 +793,7 @@ TEST_F(FieldOwnershipTest, SplitCaptureSnapshotSurvivesMakeCurrentUntilObjectRel
|
||||
returning.IsTransformFeedbackActive = 1;
|
||||
MGPipeApplySetContextValues(returning);
|
||||
EXPECT_EQ(state.BoundStreamOutputLifetimeId, begin.LifetimeId);
|
||||
EXPECT_TRUE(gPipeInputs.HasOpenTransformFeedbackSpan(begin.LifetimeId));
|
||||
EXPECT_TRUE(gPipeInputs->HasOpenTransformFeedbackSpan(begin.LifetimeId));
|
||||
const auto found = state.StreamOutputSpans.find(begin.LifetimeId);
|
||||
EXPECT_NE(found, state.StreamOutputSpans.end());
|
||||
if (found != state.StreamOutputSpans.end()) {
|
||||
@@ -803,13 +803,13 @@ TEST_F(FieldOwnershipTest, SplitCaptureSnapshotSurvivesMakeCurrentUntilObjectRel
|
||||
EXPECT_EQ(found->second.Targets[3].Size, 64u);
|
||||
}
|
||||
MGPipeApplierReleaseObjectRecords();
|
||||
EXPECT_FALSE(gPipeInputs.HasOpenTransformFeedbackSpan(begin.LifetimeId));
|
||||
EXPECT_FALSE(gPipeInputs->HasOpenTransformFeedbackSpan(begin.LifetimeId));
|
||||
EXPECT_EQ(state.BoundStreamOutputLifetimeId, 0u);
|
||||
}
|
||||
|
||||
TEST_F(FieldOwnershipTest, RoleSplitOffFoldsTheFillSideOntoTheSharedBlock) {
|
||||
EXPECT_FALSE(MGPipeRoleSplitRehearsalActive());
|
||||
EXPECT_EQ(&MGPipeClientInputs(), &gPipeInputs);
|
||||
EXPECT_EQ(&MGPipeClientInputs(), &*gPipeInputs);
|
||||
}
|
||||
|
||||
// The knob alone is not the arm: under monolith transport the two roles are one thread and
|
||||
@@ -820,7 +820,7 @@ TEST_F(FieldOwnershipTest, RoleSplitUnderMonolithTransportIsStillOneBlock) {
|
||||
MG_Config::Ipc.RoleSplitState = true;
|
||||
MG_Config::Transport = MG_Config::TransportMode::Monolith;
|
||||
EXPECT_FALSE(MGPipeRoleSplitRehearsalActive());
|
||||
EXPECT_EQ(&MGPipeClientInputs(), &gPipeInputs);
|
||||
EXPECT_EQ(&MGPipeClientInputs(), &*gPipeInputs);
|
||||
}
|
||||
|
||||
// D1c/D10 (CONTRACT-P6 3.2, 3.4). THE PREDICATE THAT IS TRUE WITHOUT THE KNOB, and the reason
|
||||
@@ -850,38 +850,38 @@ TEST_F(FieldOwnershipTest, MonolithKeepsOneBlockAndTheWiderPredicateSaysSo) {
|
||||
MG_Config::Ipc.RoleSplitState = false;
|
||||
MG_Config::Transport = MG_Config::TransportMode::Monolith;
|
||||
EXPECT_FALSE(MGPipeBlocksAreDistinct());
|
||||
EXPECT_EQ(&MGPipeClientInputs(), &gPipeInputs);
|
||||
EXPECT_EQ(&MGPipeClientInputs(), &*gPipeInputs);
|
||||
}
|
||||
|
||||
TEST_F(FieldOwnershipTest, RoleSplitGivesTheFillSideADistinctBlockTheStampNeverTouches) {
|
||||
RoleSplitArm guard;
|
||||
guard.Arm(true);
|
||||
ASSERT_TRUE(MGPipeRoleSplitRehearsalActive());
|
||||
ASSERT_NE(&MGPipeClientInputs(), &gPipeInputs);
|
||||
ASSERT_NE(&MGPipeClientInputs(), &*gPipeInputs);
|
||||
|
||||
const Uint64 serverSerialBefore = gPipeInputs.FilledState().CurrentVerbSerial;
|
||||
const Uint64 serverSerialBefore = gPipeInputs->FilledState().CurrentVerbSerial;
|
||||
const Uint64 clientSerialBefore = MGPipeClientInputs().FilledState().CurrentVerbSerial;
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::DrawArrays);
|
||||
EXPECT_EQ(gPipeInputs.FilledState().CurrentVerbSerial, serverSerialBefore + 1);
|
||||
EXPECT_EQ(gPipeInputs->FilledState().CurrentVerbSerial, serverSerialBefore + 1);
|
||||
EXPECT_EQ(MGPipeClientInputs().FilledState().CurrentVerbSerial, clientSerialBefore)
|
||||
<< "the server's verb stamp reached into the client block";
|
||||
EXPECT_TRUE(gPipeInputs.ServerStampedVerb());
|
||||
EXPECT_TRUE(gPipeInputs->ServerStampedVerb());
|
||||
EXPECT_FALSE(MGPipeClientInputs().ServerStampedVerb());
|
||||
|
||||
// The fill side's clear is the client block's own: it must not disarm the server's stamp,
|
||||
// which is CONTRACT-P5E §3.2's "the server's stamp is server-private" as a fact rather
|
||||
// than as a comment.
|
||||
MGPipeClientClearVerbBoundary();
|
||||
EXPECT_TRUE(gPipeInputs.ServerStampedVerb())
|
||||
EXPECT_TRUE(gPipeInputs->ServerStampedVerb())
|
||||
<< "the client-role clear withdrew the SERVER's stamp";
|
||||
MGPipeServerClearVerbBoundary();
|
||||
EXPECT_FALSE(gPipeInputs.ServerStampedVerb());
|
||||
EXPECT_FALSE(gPipeInputs->ServerStampedVerb());
|
||||
|
||||
// And the server block's identity is server-owned under the rehearsal (§3.2's other half):
|
||||
// the stamp set it, and it is non-null - a null identity reads as a hit against
|
||||
// DirectGLES' zero-initialised fb-slot memo cache, which is the unnamed crash this line
|
||||
// exists to preclude.
|
||||
EXPECT_NE(gPipeInputs.ContextIdentity(), nullptr);
|
||||
EXPECT_NE(gPipeInputs->ContextIdentity(), nullptr);
|
||||
}
|
||||
|
||||
// The fill side's writers land in the client block alone. MGPipeLeaveVerb rather than
|
||||
@@ -891,12 +891,12 @@ TEST_F(FieldOwnershipTest, RoleSplitGivesTheFillSideADistinctBlockTheStampNeverT
|
||||
TEST_F(FieldOwnershipTest, TheClientVerbLeaveWritesTheClientBlockAlone) {
|
||||
RoleSplitArm guard;
|
||||
guard.Arm(true);
|
||||
ASSERT_NE(&MGPipeClientInputs(), &gPipeInputs);
|
||||
const Uint64 serverSerialBefore = gPipeInputs.FilledState().CurrentVerbSerial;
|
||||
ASSERT_NE(&MGPipeClientInputs(), &*gPipeInputs);
|
||||
const Uint64 serverSerialBefore = gPipeInputs->FilledState().CurrentVerbSerial;
|
||||
const Uint64 clientSerialBefore = MGPipeClientInputs().FilledState().CurrentVerbSerial;
|
||||
MGPipeLeaveVerb();
|
||||
EXPECT_EQ(MGPipeClientInputs().FilledState().CurrentVerbSerial, clientSerialBefore + 1);
|
||||
EXPECT_EQ(gPipeInputs.FilledState().CurrentVerbSerial, serverSerialBefore)
|
||||
EXPECT_EQ(gPipeInputs->FilledState().CurrentVerbSerial, serverSerialBefore)
|
||||
<< "a fill-side write reached the server block";
|
||||
EXPECT_EQ(MGPipeClientInputs().CurrentVerb(), MGPipeVerb::kVerbCount);
|
||||
}
|
||||
@@ -909,9 +909,9 @@ TEST_F(FieldOwnershipTest, AClientFreshStampCannotReviveARetiredServerGetter) {
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::DrawArrays);
|
||||
// Simulate a regressed writer stamping the old mirror as fresh. FATAL is a
|
||||
// representation verdict, not a freshness verdict, and must still reject it.
|
||||
auto& filled = const_cast<MGPipeFilledState&>(gPipeInputs.FilledState());
|
||||
auto& filled = const_cast<MGPipeFilledState&>(gPipeInputs->FilledState());
|
||||
filled.FilledGen[Index(MGPipeInputField::GetBoundVertexArray)] = filled.CurrentVerbSerial;
|
||||
(void)gPipeInputs.GetBoundVertexArray();
|
||||
(void)gPipeInputs->GetBoundVertexArray();
|
||||
});
|
||||
ASSERT_TRUE(DiedOfAbort(r)) << DescribeStatus(r) << "\n" << r.Log;
|
||||
EXPECT_NE(r.Log.find("Fatal{UnmigratedPipeInput, \"GetBoundVertexArray@DrawArrays\"}"),
|
||||
@@ -923,7 +923,7 @@ TEST_F(FieldOwnershipTest, StrictErrorsTurnsABarrierPulledReadIntoANamedAbort) {
|
||||
const ChildResult r = RunInChild([] {
|
||||
MG_Config::Ipc.StrictErrors = true;
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::DrawArrays);
|
||||
(void)gPipeInputs.GetBoundVertexArray();
|
||||
(void)gPipeInputs->GetBoundVertexArray();
|
||||
});
|
||||
ASSERT_TRUE(DiedOfAbort(r)) << DescribeStatus(r) << "\n" << r.Log;
|
||||
EXPECT_NE(r.Log.find("Fatal{UnmigratedPipeInput, \"GetBoundVertexArray@DrawArrays\"}"), std::string::npos) << r.Log;
|
||||
@@ -936,7 +936,7 @@ TEST_F(FieldOwnershipTest, TheSameReadWithoutStrictErrorsSurvivesAndIsCounted) {
|
||||
const ChildResult r = RunInChild([] {
|
||||
MG_Config::Ipc.StrictErrors = false;
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::DrawArrays);
|
||||
(void)gPipeInputs.GetBoundVertexArray();
|
||||
(void)gPipeInputs->GetBoundVertexArray();
|
||||
});
|
||||
ASSERT_TRUE(DiedOfAbort(r)) << DescribeStatus(r) << "\n" << r.Log;
|
||||
EXPECT_NE(r.Log.find("Fatal{UnmigratedPipeInput, \"GetBoundVertexArray@DrawArrays\"}"), std::string::npos) << r.Log;
|
||||
@@ -950,7 +950,7 @@ TEST_F(FieldOwnershipTest, AnEscalatedRecordsPullIsAdmittedAndSaysWhy) {
|
||||
MG_Config::Ipc.StrictErrors = true;
|
||||
MGPipeApplierSetCurrentRecordBarrieredByEscalation(true);
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::DrawArrays);
|
||||
(void)gPipeInputs.GetBoundVertexArray();
|
||||
(void)gPipeInputs->GetBoundVertexArray();
|
||||
});
|
||||
ASSERT_TRUE(DiedOfAbort(r)) << DescribeStatus(r) << "\n" << r.Log;
|
||||
EXPECT_NE(r.Log.find("Fatal{UnmigratedPipeInput, \"GetBoundVertexArray@DrawArrays\"}"), std::string::npos) << r.Log;
|
||||
@@ -963,7 +963,7 @@ TEST_F(FieldOwnershipTest, StrictErrorsReachTheStickyForwardsAndNameThemByField)
|
||||
const ChildResult r = RunInChild([] {
|
||||
MG_Config::Ipc.StrictErrors = true;
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::DrawArrays);
|
||||
(void)gPipeInputs.ValidateProgramName(1u);
|
||||
(void)gPipeInputs->ValidateProgramName(1u);
|
||||
});
|
||||
ASSERT_TRUE(DiedOfAbort(r)) << DescribeStatus(r) << "\n" << r.Log;
|
||||
EXPECT_NE(r.Log.find("Fatal{UnmigratedPipeInput, \"ValidateProgramName@DrawArrays\"}"), std::string::npos) << r.Log;
|
||||
@@ -976,7 +976,7 @@ TEST_F(FieldOwnershipTest, AnAdmittedBarrierPullIsLoudOnceAndNotFatal) {
|
||||
const ChildResult r = RunInChild([] {
|
||||
MG_Config::Ipc.StrictErrors = true;
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::ReadPixels);
|
||||
(void)gPipeInputs.ValidateProgramName(1u);
|
||||
(void)gPipeInputs->ValidateProgramName(1u);
|
||||
});
|
||||
ASSERT_TRUE(DiedOfAbort(r)) << DescribeStatus(r) << "\n" << r.Log;
|
||||
EXPECT_NE(r.Log.find("Fatal{UnmigratedPipeInput, \"ValidateProgramName@ReadPixels\"}"), std::string::npos) << r.Log;
|
||||
@@ -987,7 +987,7 @@ TEST_F(FieldOwnershipTest, AnAdmittedBarrierPullIsLoudOnceAndNotFatal) {
|
||||
TEST_F(FieldOwnershipTest, AFatalClassReadAbortsEvenWithoutStrictErrors) {
|
||||
const ChildResult r = RunInChild([] {
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::DrawArrays);
|
||||
(void)gPipeInputs.GetTransformFeedbackPausedPrimitiveCounter();
|
||||
(void)gPipeInputs->GetTransformFeedbackPausedPrimitiveCounter();
|
||||
});
|
||||
ASSERT_TRUE(DiedOfAbort(r)) << DescribeStatus(r) << "\n" << r.Log;
|
||||
EXPECT_NE(r.Log.find("Fatal{UnmigratedPipeInput, "
|
||||
@@ -1002,7 +1002,7 @@ TEST_F(FieldOwnershipTest, TheComputeProgramIsServedUnderADispatchStampFromP5bOn
|
||||
const ChildResult r = RunInChild([] {
|
||||
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::DispatchCompute);
|
||||
(void)gPipeInputs.GetProgramForDispatch();
|
||||
(void)gPipeInputs->GetProgramForDispatch();
|
||||
});
|
||||
ASSERT_TRUE(DiedOfAbort(r)) << DescribeStatus(r) << "\n" << r.Log;
|
||||
EXPECT_NE(r.Log.find("Fatal{UnmigratedPipeInput, \"GetProgramForDispatch@DispatchCompute\"}"), std::string::npos) << r.Log;
|
||||
@@ -1016,7 +1016,7 @@ TEST_F(FieldOwnershipTest, TheComputeProgramIsServedUnderADispatchStampFromP5bOn
|
||||
TEST_F(FieldOwnershipTest, TheUnpackHalfOfThePixelStoreAbortsWhileThePackHalfDoesNot) {
|
||||
const ChildResult fatal = RunInChild([] {
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::ReadPixels);
|
||||
(void)gPipeInputs.GetPixelStoreParameters(true);
|
||||
(void)gPipeInputs->GetPixelStoreParameters(true);
|
||||
});
|
||||
ASSERT_TRUE(DiedOfAbort(fatal)) << DescribeStatus(fatal) << "\n" << fatal.Log;
|
||||
EXPECT_NE(fatal.Log.find("Fatal{UnmigratedPipeInput, \"GetPixelStoreParameters@ReadPixels\"}"),
|
||||
@@ -1032,7 +1032,7 @@ TEST_F(FieldOwnershipTest, TheUnpackHalfOfThePixelStoreAbortsWhileThePackHalfDoe
|
||||
|
||||
const ChildResult ok = RunInChild([] {
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::ReadPixels);
|
||||
(void)gPipeInputs.GetPixelStoreParameters(false);
|
||||
(void)gPipeInputs->GetPixelStoreParameters(false);
|
||||
if (MGPipeResidualPullCount() != 0) ::_exit(7);
|
||||
});
|
||||
ASSERT_TRUE(ExitedWith(ok, 0)) << DescribeStatus(ok) << "\n" << ok.Log;
|
||||
@@ -1067,7 +1067,7 @@ TEST_F(FieldOwnershipTest, DualBlockMakesABarrierPulledReadANamedAbortWithoutStr
|
||||
MG_Config::Ipc.RoleSplitState = true;
|
||||
MG_Config::Ipc.StrictErrors = false;
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::DrawArrays);
|
||||
(void)gPipeInputs.GetBoundVertexArray();
|
||||
(void)gPipeInputs->GetBoundVertexArray();
|
||||
});
|
||||
ASSERT_TRUE(DiedOfAbort(r)) << DescribeStatus(r) << "\n" << r.Log;
|
||||
EXPECT_NE(r.Log.find("Fatal{UnmigratedPipeInput, \"GetBoundVertexArray@DrawArrays\"}"), std::string::npos) << r.Log;
|
||||
@@ -1081,7 +1081,7 @@ TEST_F(FieldOwnershipTest, DualBlockDoesNotArmUnderMonolithTransport) {
|
||||
MG_Config::Ipc.RoleSplitState = true;
|
||||
// A real monolith fill, not a manufactured server stamp on a monolith process.
|
||||
MGPipeValidateForVerb(MGPipeVerb::DrawArrays);
|
||||
(void)gPipeInputs.GetBoundVertexArray();
|
||||
(void)gPipeInputs->GetBoundVertexArray();
|
||||
if (MGPipeRoleSplitRehearsalActive() || MGPipeResidualPullCount() != 0) ::_exit(7);
|
||||
});
|
||||
ASSERT_TRUE(ExitedWith(r, 0)) << DescribeStatus(r) << "\n" << r.Log;
|
||||
|
||||
@@ -246,7 +246,7 @@ namespace {
|
||||
kMGPipeSubsystemFramebuffer |
|
||||
kMGPipeSubsystemTextureResources |
|
||||
kMGPipeSubsystemSamplers;
|
||||
m_previousContext = Move(MG_State::pGLContext);
|
||||
m_previousContext = MG_State::pGLContext.Take();
|
||||
MG_State::pGLContext = MakeUnique<GLContext>();
|
||||
MGPipeFramebufferEmitterInstance().ResetForTest();
|
||||
MGPipeTextureEmitterInstance().ResetForTest();
|
||||
|
||||
@@ -73,7 +73,7 @@ namespace {
|
||||
class PipeInputsTest : public ::testing::Test {
|
||||
protected:
|
||||
void SetUp() override {
|
||||
m_previous = Move(MG_State::pGLContext);
|
||||
m_previous = MG_State::pGLContext.Take();
|
||||
MG_State::pGLContext = MakeUnique<GLContext>();
|
||||
MGPipeSetPoisonOmission(nullptr, nullptr);
|
||||
}
|
||||
@@ -85,7 +85,7 @@ namespace {
|
||||
};
|
||||
|
||||
#if MOBILEGL_PIPE_POISON
|
||||
Bool Fresh(MGPipeInputField field) { return MGPipeInputFieldIsFresh(gPipeInputs.FilledState(), field); }
|
||||
Bool Fresh(MGPipeInputField field) { return MGPipeInputFieldIsFresh(gPipeInputs->FilledState(), field); }
|
||||
#endif
|
||||
|
||||
[[maybe_unused]] constexpr const char* kOmittedFatal ="Fatal{UnmigratedPipeInput, \"GetActiveTextureUnit@GenerateMipmap\"}";
|
||||
@@ -147,7 +147,7 @@ TEST_F(PipeInputsTest, OmittingOneFieldForOneVerbLeavesExactlyThatFieldStale) {
|
||||
EXPECT_TRUE(Fresh(MGPipeInputField::GetTextureUnitObject));
|
||||
EXPECT_FALSE(Fresh(MGPipeInputField::GetActiveTextureUnit));
|
||||
// The value was still copied: only the stamp is withheld.
|
||||
EXPECT_EQ(gPipeInputs.CurrentVerb(), MGPipeVerb::GenerateMipmap);
|
||||
EXPECT_EQ(gPipeInputs->CurrentVerb(), MGPipeVerb::GenerateMipmap);
|
||||
// Exactly that field: a field is fresh iff its bit is in kTextureOp's mask and it is not
|
||||
// the omitted one.
|
||||
{
|
||||
@@ -174,7 +174,7 @@ TEST_F(PipeInputsTest, OmittingOneFieldForOneVerbLeavesExactlyThatFieldStale) {
|
||||
}
|
||||
|
||||
// Negative control B, layer 2 (G5): the read itself. The child fills GenerateMipmap with the
|
||||
// omission and reads gPipeInputs.GetActiveTextureUnit(); the parent expects SIGABRT and the
|
||||
// omission and reads gPipeInputs->GetActiveTextureUnit(); the parent expects SIGABRT and the
|
||||
// exact Fatal line, and that nothing else was fatal.
|
||||
TEST_F(PipeInputsTest, ReadingAnOmittedFieldAbortsNamingTheVerb) {
|
||||
#if !MOBILEGL_PIPE_POISON
|
||||
@@ -186,10 +186,10 @@ TEST_F(PipeInputsTest, ReadingAnOmittedFieldAbortsNamingTheVerb) {
|
||||
const ChildResult r = RunInChild([] {
|
||||
MGPipeSetPoisonOmission("GenerateMipmap", "GetActiveTextureUnit");
|
||||
MGPipeValidateForVerb(MGPipeVerb::DrawArrays);
|
||||
(void)gPipeInputs.GetRenderStateParameters(); // a filled field of the preceding draw: must not abort
|
||||
(void)gPipeInputs->GetRenderStateParameters(); // a filled field of the preceding draw: must not abort
|
||||
MGPipeValidateForVerb(MGPipeVerb::GenerateMipmap);
|
||||
(void)gPipeInputs.GetTextureUnitObject(0); // the sibling field: filled, must not abort
|
||||
(void)gPipeInputs.GetActiveTextureUnit(); // the omitted field: Fatal
|
||||
(void)gPipeInputs->GetTextureUnitObject(0); // the sibling field: filled, must not abort
|
||||
(void)gPipeInputs->GetActiveTextureUnit(); // the omitted field: Fatal
|
||||
::_exit(3); // reached only if the poison failed
|
||||
});
|
||||
ASSERT_TRUE(DiedOfAbort(r)) << DescribeStatus(r) << "\n" << r.Log;
|
||||
@@ -207,10 +207,10 @@ TEST_F(PipeInputsTest, ReadingAFilledFieldCompletes) {
|
||||
ASSERT_FALSE(g_logPath.empty()) << "main() did not set MOBILEGL_LOG_FILE_PATH";
|
||||
const ChildResult r = RunInChild([] {
|
||||
MGPipeValidateForVerb(MGPipeVerb::DrawArrays);
|
||||
(void)gPipeInputs.GetRenderStateParameters();
|
||||
(void)gPipeInputs->GetRenderStateParameters();
|
||||
MGPipeValidateForVerb(MGPipeVerb::GenerateMipmap);
|
||||
(void)gPipeInputs.GetTextureUnitObject(0);
|
||||
(void)gPipeInputs.GetActiveTextureUnit();
|
||||
(void)gPipeInputs->GetTextureUnitObject(0);
|
||||
(void)gPipeInputs->GetActiveTextureUnit();
|
||||
});
|
||||
ASSERT_TRUE(ExitedWith(r, 0)) << DescribeStatus(r) << "\n" << r.Log;
|
||||
EXPECT_EQ(r.Log.find("Fatal{"), std::string::npos) << r.Log;
|
||||
@@ -229,7 +229,7 @@ TEST_F(PipeInputsTest, ReadingBeforeAnyFillAbortsNamingNoVerb) {
|
||||
GTEST_SKIP() << "no fork() on this platform";
|
||||
#else
|
||||
ASSERT_FALSE(g_logPath.empty()) << "main() did not set MOBILEGL_LOG_FILE_PATH";
|
||||
if (gPipeInputs.FilledState().CurrentVerbSerial != 0) {
|
||||
if (gPipeInputs->FilledState().CurrentVerbSerial != 0) {
|
||||
GTEST_SKIP() << "another case already filled in this process; gtest_discover_tests runs each case alone";
|
||||
}
|
||||
MG_State::pGLContext->SetLineWidth(7.0f); // a live value the default storage (0) does not hold
|
||||
@@ -237,7 +237,7 @@ TEST_F(PipeInputsTest, ReadingBeforeAnyFillAbortsNamingNoVerb) {
|
||||
#if MOBILEGL_PIPE_VERIFY
|
||||
MG_Config::Features.PipeVerify = true;
|
||||
#endif
|
||||
(void)gPipeInputs.GetLineWidth(); // Fatal{UnmigratedPipeInput, "GetLineWidth@<none>"}
|
||||
(void)gPipeInputs->GetLineWidth(); // Fatal{UnmigratedPipeInput, "GetLineWidth@<none>"}
|
||||
::_exit(3); // reached only if the pre-fill window read as fresh
|
||||
});
|
||||
ASSERT_TRUE(DiedOfAbort(r)) << DescribeStatus(r) << "\n" << r.Log;
|
||||
@@ -261,8 +261,8 @@ TEST_F(PipeInputsTest, PoisonOmitKnobArmsTheOmission) {
|
||||
const ChildResult r = RunInChild([] {
|
||||
MG_Config::Features.PipePoisonOmit = kOmissionKnob;
|
||||
MGPipeValidateForVerb(MGPipeVerb::GenerateMipmap);
|
||||
(void)gPipeInputs.GetTextureUnitObject(0); // the sibling field: filled, must not abort
|
||||
(void)gPipeInputs.GetActiveTextureUnit(); // the omitted field: Fatal
|
||||
(void)gPipeInputs->GetTextureUnitObject(0); // the sibling field: filled, must not abort
|
||||
(void)gPipeInputs->GetActiveTextureUnit(); // the omitted field: Fatal
|
||||
::_exit(3);
|
||||
});
|
||||
ASSERT_TRUE(DiedOfAbort(r)) << DescribeStatus(r) << "\n" << r.Log;
|
||||
@@ -301,9 +301,9 @@ TEST_F(PipeInputsTest, CorruptedSnapshotFieldIsNamedWithItsSerial) {
|
||||
#if !MOBILEGL_PIPE_VERIFY
|
||||
GTEST_SKIP() << "verify not compiled in (MOBILEGL_PIPE_VERIFY=OFF)";
|
||||
#else
|
||||
const Uint64 serialBefore = gPipeInputs.FilledState().CurrentVerbSerial;
|
||||
const Uint64 serialBefore = gPipeInputs->FilledState().CurrentVerbSerial;
|
||||
MGPipeValidateForVerb(MGPipeVerb::DrawArrays);
|
||||
const Uint64 serial = gPipeInputs.FilledState().CurrentVerbSerial;
|
||||
const Uint64 serial = gPipeInputs->FilledState().CurrentVerbSerial;
|
||||
EXPECT_EQ(serial, serialBefore + 1);
|
||||
const MGPipeFieldMask& mask = kMGPipeClassFieldMask[static_cast<SizeT>(MGPipeVerbClass::kDraw)];
|
||||
|
||||
@@ -318,7 +318,7 @@ TEST_F(PipeInputsTest, CorruptedSnapshotFieldIsNamedWithItsSerial) {
|
||||
EXPECT_EQ(field, MGPipeInputField::GetRenderStateParameters);
|
||||
EXPECT_STREQ(kMGPipeInputFieldNames[static_cast<SizeT>(field)], "GetRenderStateParameters");
|
||||
// The serial the report would print is the fill's, and it stamped that field.
|
||||
EXPECT_EQ(gPipeInputs.FilledState().FilledGen[static_cast<SizeT>(field)], serial);
|
||||
EXPECT_EQ(gPipeInputs->FilledState().FilledGen[static_cast<SizeT>(field)], serial);
|
||||
|
||||
// A forwarded field has nothing to corrupt, and the corruption of a field outside the
|
||||
// mask is not seen by a compare over that mask.
|
||||
@@ -341,15 +341,15 @@ TEST_F(PipeInputsTest, MutatedFieldIsNamedAtRead) {
|
||||
#else
|
||||
ASSERT_FALSE(g_logPath.empty()) << "main() did not set MOBILEGL_LOG_FILE_PATH";
|
||||
MGPipeValidateForVerb(MGPipeVerb::Clear); // the parent armed nothing: Features.PipeVerify is false here
|
||||
const Uint64 serial = gPipeInputs.FilledState().CurrentVerbSerial + 1; // the child's DrawArrays fill
|
||||
const Uint64 serial = gPipeInputs->FilledState().CurrentVerbSerial + 1; // the child's DrawArrays fill
|
||||
const ChildResult r = RunInChild([] {
|
||||
MG_Config::Features.PipeVerify = true;
|
||||
MGPipeValidateForVerb(MGPipeVerb::DrawArrays);
|
||||
const Float boundary = gPipeInputs.GetLineWidth(); // boundary == live: completes
|
||||
(void)gPipeInputs.GetRenderStateParameters();
|
||||
const Float boundary = gPipeInputs->GetLineWidth(); // boundary == live: completes
|
||||
(void)gPipeInputs->GetRenderStateParameters();
|
||||
MG_State::pGLContext->SetLineWidth(boundary + 1.0f);
|
||||
if (MG_State::pGLContext->GetLineWidth() == boundary) ::_exit(7); // the mutation did not take
|
||||
(void)gPipeInputs.GetLineWidth(); // the stored value is stale against the live one: Fatal
|
||||
(void)gPipeInputs->GetLineWidth(); // the stored value is stale against the live one: Fatal
|
||||
::_exit(3);
|
||||
});
|
||||
ASSERT_TRUE(DiedOfAbort(r)) << DescribeStatus(r) << "\n" << r.Log;
|
||||
@@ -375,7 +375,7 @@ TEST_F(PipeInputsTest, VerifyCorruptKnobNamesTheFieldAtEntry) {
|
||||
#else
|
||||
ASSERT_FALSE(g_logPath.empty()) << "main() did not set MOBILEGL_LOG_FILE_PATH";
|
||||
MGPipeValidateForVerb(MGPipeVerb::Clear);
|
||||
const Uint64 serial = gPipeInputs.FilledState().CurrentVerbSerial + 1;
|
||||
const Uint64 serial = gPipeInputs->FilledState().CurrentVerbSerial + 1;
|
||||
const ChildResult r = RunInChild([] {
|
||||
MG_Config::Features.PipeVerify = true;
|
||||
MG_Config::Features.PipeVerifyCorrupt = "GetRenderStateParameters";
|
||||
@@ -428,7 +428,7 @@ TEST_F(PipeInputsTest, VerifyFatalOffLogsTheDivergenceAndContinues) {
|
||||
#else
|
||||
ASSERT_FALSE(g_logPath.empty()) << "main() did not set MOBILEGL_LOG_FILE_PATH";
|
||||
MGPipeValidateForVerb(MGPipeVerb::Clear);
|
||||
const Uint64 serial = gPipeInputs.FilledState().CurrentVerbSerial + 1;
|
||||
const Uint64 serial = gPipeInputs->FilledState().CurrentVerbSerial + 1;
|
||||
const ChildResult r = RunInChild([] {
|
||||
MG_Config::Features.PipeVerify = true;
|
||||
MG_Config::Features.PipeVerifyFatal = false;
|
||||
@@ -467,8 +467,8 @@ TEST_F(PipeInputsTest, EveryVerbFillsItsClassAndNothingElse) {
|
||||
<< kMGPipeInputFieldNames[f] << " after " << kMGPipeVerbNames[v];
|
||||
}
|
||||
}
|
||||
EXPECT_EQ(gPipeInputs.ContextIdentity(), static_cast<const void*>(MG_State::pGLContext.get()));
|
||||
EXPECT_TRUE(gPipeInputs.IsLive());
|
||||
EXPECT_EQ(gPipeInputs->ContextIdentity(), static_cast<const void*>(MG_State::pGLContext.get()));
|
||||
EXPECT_TRUE(gPipeInputs->IsLive());
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -481,9 +481,9 @@ TEST_F(PipeInputsTest, EveryVerbFillsItsClassAndNothingElse) {
|
||||
TEST_F(PipeInputsTest, AFrontendMutationInsideAVerbRefreshesThePushedField) {
|
||||
auto& ctx = *MG_State::pGLContext;
|
||||
MGPipeValidateForVerb(MGPipeVerb::DrawArrays);
|
||||
ASSERT_EQ(gPipeInputs.GetSamplingResolutionGeneration(), ctx.GetSamplingResolutionGeneration());
|
||||
ASSERT_EQ(gPipeInputs.GetTextureBindGeneration(), ctx.GetTextureBindGeneration());
|
||||
ASSERT_EQ(gPipeInputs.GetMaxTouchedTextureUnit(), ctx.GetMaxTouchedTextureUnit());
|
||||
ASSERT_EQ(gPipeInputs->GetSamplingResolutionGeneration(), ctx.GetSamplingResolutionGeneration());
|
||||
ASSERT_EQ(gPipeInputs->GetTextureBindGeneration(), ctx.GetTextureBindGeneration());
|
||||
ASSERT_EQ(gPipeInputs->GetMaxTouchedTextureUnit(), ctx.GetMaxTouchedTextureUnit());
|
||||
|
||||
// What UniformManager's fallback path does mid-draw: change a sampler object's filter,
|
||||
// which bumps the context-wide sampling-resolution generation (SamplerObject.cpp).
|
||||
@@ -492,7 +492,7 @@ TEST_F(PipeInputsTest, AFrontendMutationInsideAVerbRefreshesThePushedField) {
|
||||
sampler->SetMinFilter(sampler->GetMinFilter() == SamplerFilterMode::Nearest ? SamplerFilterMode::Linear
|
||||
: SamplerFilterMode::Nearest);
|
||||
ASSERT_NE(ctx.GetSamplingResolutionGeneration(), samplingBefore) << "the mutation did not move the counter";
|
||||
EXPECT_EQ(gPipeInputs.GetSamplingResolutionGeneration(), ctx.GetSamplingResolutionGeneration());
|
||||
EXPECT_EQ(gPipeInputs->GetSamplingResolutionGeneration(), ctx.GetSamplingResolutionGeneration());
|
||||
|
||||
// And a bind reached from inside a verb moves both the bind generation and the
|
||||
// high-water mark of touched units (TextureState::NoteUnitTouched).
|
||||
@@ -501,8 +501,8 @@ TEST_F(PipeInputsTest, AFrontendMutationInsideAVerbRefreshesThePushedField) {
|
||||
ctx.NoteTextureUnitTouched(unit);
|
||||
ASSERT_NE(ctx.GetTextureBindGeneration(), bindBefore) << "the bind did not move the counter";
|
||||
ASSERT_EQ(ctx.GetMaxTouchedTextureUnit(), unit);
|
||||
EXPECT_EQ(gPipeInputs.GetTextureBindGeneration(), ctx.GetTextureBindGeneration());
|
||||
EXPECT_EQ(gPipeInputs.GetMaxTouchedTextureUnit(), ctx.GetMaxTouchedTextureUnit());
|
||||
EXPECT_EQ(gPipeInputs->GetTextureBindGeneration(), ctx.GetTextureBindGeneration());
|
||||
EXPECT_EQ(gPipeInputs->GetMaxTouchedTextureUnit(), ctx.GetMaxTouchedTextureUnit());
|
||||
}
|
||||
|
||||
// The notice refreshes the VALUE and never the stamp: a field this verb withheld the stamp
|
||||
@@ -547,7 +547,7 @@ TEST_F(PipeInputsTest, AFrontendMutationInsideAVerbDoesNotDivergeAtRead) {
|
||||
const ChildResult r = RunInChild([] {
|
||||
MG_Config::Features.PipeVerify = true;
|
||||
MGPipeValidateForVerb(MGPipeVerb::DrawArrays);
|
||||
(void)gPipeInputs.GetSamplingResolutionGeneration(); // boundary == live: completes
|
||||
(void)gPipeInputs->GetSamplingResolutionGeneration(); // boundary == live: completes
|
||||
auto& ctx = *MG_State::pGLContext;
|
||||
const Uint64 before = ctx.GetSamplingResolutionGeneration();
|
||||
auto sampler = MakeShared<MG_State::GLState::SamplerObject>(0u);
|
||||
@@ -556,10 +556,10 @@ TEST_F(PipeInputsTest, AFrontendMutationInsideAVerbDoesNotDivergeAtRead) {
|
||||
if (ctx.GetSamplingResolutionGeneration() == before) {
|
||||
::_exit(7); // the mutation did not take: the case would pass for the wrong reason
|
||||
}
|
||||
(void)gPipeInputs.GetSamplingResolutionGeneration(); // Fatal{PipeVerifyDiffer} without the notice
|
||||
(void)gPipeInputs->GetSamplingResolutionGeneration(); // Fatal{PipeVerifyDiffer} without the notice
|
||||
ctx.NoteTextureUnitTouched(ctx.GetMaxTouchedTextureUnit() + 1);
|
||||
(void)gPipeInputs.GetTextureBindGeneration();
|
||||
(void)gPipeInputs.GetMaxTouchedTextureUnit();
|
||||
(void)gPipeInputs->GetTextureBindGeneration();
|
||||
(void)gPipeInputs->GetMaxTouchedTextureUnit();
|
||||
});
|
||||
ASSERT_TRUE(ExitedWith(r, 0)) << DescribeStatus(r) << "\n" << r.Log;
|
||||
EXPECT_NE(r.Log.find("MGPipe: verify armed"), std::string::npos) << r.Log;
|
||||
|
||||
@@ -375,7 +375,7 @@ namespace {
|
||||
m_savedResourceOps = MGPipeGetResourceOps();
|
||||
static const MGPipeResourceOps kEmpty{};
|
||||
MGPipeSetResourceOps(&kEmpty);
|
||||
m_savedContext = Move(MG_State::pGLContext);
|
||||
m_savedContext = MG_State::pGLContext.Take();
|
||||
MG_State::pGLContext = MakeUnique<MG_State::GLState::GLContext>();
|
||||
|
||||
m_savedTable = MG_Backend::gBackendFunctionsTable;
|
||||
|
||||
@@ -146,60 +146,60 @@ namespace {
|
||||
// ---------------------------------------------------------------------------------
|
||||
void ExpectDerivedDrawFieldsMatch(GLContext& ctx, const char* tag) {
|
||||
SCOPED_TRACE(tag);
|
||||
EXPECT_EQ(gPipeInputs.GetBlendColor(), ctx.GetBlendColor());
|
||||
EXPECT_EQ(gPipeInputs->GetBlendColor(), ctx.GetBlendColor());
|
||||
for (Uint i = 0; i < kMGMaxDrawBuffers; ++i) {
|
||||
BlendEquation gotColor{}, gotAlpha{}, wantColor{}, wantAlpha{};
|
||||
gPipeInputs.GetBlendEquationIndexed(i, gotColor, gotAlpha);
|
||||
gPipeInputs->GetBlendEquationIndexed(i, gotColor, gotAlpha);
|
||||
ctx.GetBlendEquationIndexed(i, wantColor, wantAlpha);
|
||||
EXPECT_EQ(gotColor, wantColor) << "blend equation " << i;
|
||||
EXPECT_EQ(gotAlpha, wantAlpha) << "blend equation " << i;
|
||||
|
||||
BlendFactor gotSrcRGB{}, gotDstRGB{}, gotSrcA{}, gotDstA{};
|
||||
BlendFactor wantSrcRGB{}, wantDstRGB{}, wantSrcA{}, wantDstA{};
|
||||
gPipeInputs.GetBlendFuncIndexed(i, gotSrcRGB, gotDstRGB, gotSrcA, gotDstA);
|
||||
gPipeInputs->GetBlendFuncIndexed(i, gotSrcRGB, gotDstRGB, gotSrcA, gotDstA);
|
||||
ctx.GetBlendFuncIndexed(i, wantSrcRGB, wantDstRGB, wantSrcA, wantDstA);
|
||||
EXPECT_EQ(gotSrcRGB, wantSrcRGB) << "blend func " << i;
|
||||
EXPECT_EQ(gotDstRGB, wantDstRGB) << "blend func " << i;
|
||||
EXPECT_EQ(gotSrcA, wantSrcA) << "blend func " << i;
|
||||
EXPECT_EQ(gotDstA, wantDstA) << "blend func " << i;
|
||||
|
||||
EXPECT_EQ(gPipeInputs.GetColorMaskIndexed(i), ctx.GetColorMaskIndexed(i)) << "colour mask " << i;
|
||||
EXPECT_EQ(gPipeInputs.IsCapabilityEnabledIndexed(CapabilityInput::Blend, i),
|
||||
EXPECT_EQ(gPipeInputs->GetColorMaskIndexed(i), ctx.GetColorMaskIndexed(i)) << "colour mask " << i;
|
||||
EXPECT_EQ(gPipeInputs->IsCapabilityEnabledIndexed(CapabilityInput::Blend, i),
|
||||
ctx.IsCapabilityEnabledIndexed(CapabilityInput::Blend, i))
|
||||
<< "indexed blend enable " << i;
|
||||
}
|
||||
EXPECT_EQ(gPipeInputs.GetCullFaceMode(), ctx.GetCullFaceMode());
|
||||
EXPECT_EQ(gPipeInputs.GetDepthFunc(), ctx.GetDepthFunc());
|
||||
EXPECT_EQ(gPipeInputs.GetDepthMask(), ctx.GetDepthMask());
|
||||
EXPECT_EQ(gPipeInputs->GetCullFaceMode(), ctx.GetCullFaceMode());
|
||||
EXPECT_EQ(gPipeInputs->GetDepthFunc(), ctx.GetDepthFunc());
|
||||
EXPECT_EQ(gPipeInputs->GetDepthMask(), ctx.GetDepthMask());
|
||||
for (Uint i = 0; i < RenderStateParameters::MAX_VIEWPORTS; ++i) {
|
||||
EXPECT_EQ(gPipeInputs.GetDepthRangeIndexed(i), ctx.GetDepthRangeIndexed(i)) << "depth range " << i;
|
||||
EXPECT_EQ(gPipeInputs.GetViewportIndexed(i), ctx.GetViewportIndexed(i)) << "viewport " << i;
|
||||
EXPECT_EQ(gPipeInputs.IsCapabilityEnabledIndexed(CapabilityInput::ScissorTest, i),
|
||||
EXPECT_EQ(gPipeInputs->GetDepthRangeIndexed(i), ctx.GetDepthRangeIndexed(i)) << "depth range " << i;
|
||||
EXPECT_EQ(gPipeInputs->GetViewportIndexed(i), ctx.GetViewportIndexed(i)) << "viewport " << i;
|
||||
EXPECT_EQ(gPipeInputs->IsCapabilityEnabledIndexed(CapabilityInput::ScissorTest, i),
|
||||
ctx.IsCapabilityEnabledIndexed(CapabilityInput::ScissorTest, i))
|
||||
<< "indexed scissor enable " << i;
|
||||
}
|
||||
EXPECT_EQ(gPipeInputs.GetLineWidth(), ctx.GetLineWidth());
|
||||
EXPECT_EQ(gPipeInputs.GetLogicOp(), ctx.GetLogicOp());
|
||||
EXPECT_EQ(gPipeInputs.GetMinSampleShadingValue(), ctx.GetMinSampleShadingValue());
|
||||
EXPECT_EQ(gPipeInputs.GetPatchDefaultInnerLevel(), ctx.GetPatchDefaultInnerLevel());
|
||||
EXPECT_EQ(gPipeInputs.GetPatchDefaultOuterLevel(), ctx.GetPatchDefaultOuterLevel());
|
||||
EXPECT_EQ(gPipeInputs.GetPatchVertices(), ctx.GetPatchVertices());
|
||||
EXPECT_EQ(gPipeInputs.GetPolygonModeFront(), ctx.GetPolygonModeFront());
|
||||
EXPECT_EQ(gPipeInputs.GetPolygonOffsetFactor(), ctx.GetPolygonOffsetFactor());
|
||||
EXPECT_EQ(gPipeInputs.GetPolygonOffsetUnits(), ctx.GetPolygonOffsetUnits());
|
||||
EXPECT_EQ(gPipeInputs.GetPrimitiveRestartIndex(), ctx.GetPrimitiveRestartIndex());
|
||||
EXPECT_EQ(gPipeInputs.GetProvokingVertexMode(), ctx.GetProvokingVertexMode());
|
||||
EXPECT_EQ(gPipeInputs.GetScissorBox(), ctx.GetScissorBox());
|
||||
EXPECT_EQ(gPipeInputs.GetViewport(), ctx.GetViewport());
|
||||
EXPECT_EQ(gPipeInputs->GetLineWidth(), ctx.GetLineWidth());
|
||||
EXPECT_EQ(gPipeInputs->GetLogicOp(), ctx.GetLogicOp());
|
||||
EXPECT_EQ(gPipeInputs->GetMinSampleShadingValue(), ctx.GetMinSampleShadingValue());
|
||||
EXPECT_EQ(gPipeInputs->GetPatchDefaultInnerLevel(), ctx.GetPatchDefaultInnerLevel());
|
||||
EXPECT_EQ(gPipeInputs->GetPatchDefaultOuterLevel(), ctx.GetPatchDefaultOuterLevel());
|
||||
EXPECT_EQ(gPipeInputs->GetPatchVertices(), ctx.GetPatchVertices());
|
||||
EXPECT_EQ(gPipeInputs->GetPolygonModeFront(), ctx.GetPolygonModeFront());
|
||||
EXPECT_EQ(gPipeInputs->GetPolygonOffsetFactor(), ctx.GetPolygonOffsetFactor());
|
||||
EXPECT_EQ(gPipeInputs->GetPolygonOffsetUnits(), ctx.GetPolygonOffsetUnits());
|
||||
EXPECT_EQ(gPipeInputs->GetPrimitiveRestartIndex(), ctx.GetPrimitiveRestartIndex());
|
||||
EXPECT_EQ(gPipeInputs->GetProvokingVertexMode(), ctx.GetProvokingVertexMode());
|
||||
EXPECT_EQ(gPipeInputs->GetScissorBox(), ctx.GetScissorBox());
|
||||
EXPECT_EQ(gPipeInputs->GetViewport(), ctx.GetViewport());
|
||||
for (const StencilFace face : {StencilFace::Front, StencilFace::Back}) {
|
||||
const StencilFaceState& got = gPipeInputs.GetStencilState(face);
|
||||
const StencilFaceState& got = gPipeInputs->GetStencilState(face);
|
||||
const StencilFaceState& want = ctx.GetStencilState(face);
|
||||
EXPECT_EQ(std::memcmp(&got, &want, sizeof(StencilFaceState)), 0)
|
||||
<< "stencil face " << static_cast<int>(face);
|
||||
}
|
||||
for (SizeT i = 0; i < static_cast<SizeT>(CapabilityInput::CapabilityInputCount); ++i) {
|
||||
const CapabilityInput cap = static_cast<CapabilityInput>(i);
|
||||
EXPECT_EQ(gPipeInputs.IsCapabilityEnabled(cap), ctx.IsCapabilityEnabled(cap)) << "capability " << i;
|
||||
EXPECT_EQ(gPipeInputs->IsCapabilityEnabled(cap), ctx.IsCapabilityEnabled(cap)) << "capability " << i;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -214,7 +214,7 @@ namespace {
|
||||
// the only thing in the suite that covers them.
|
||||
void ExpectAssembledBlockIsTheLiveBlock(GLContext& ctx, const char* tag) {
|
||||
SCOPED_TRACE(tag);
|
||||
EXPECT_EQ(std::memcmp(&gPipeInputs.GetRenderStateParameters(), &ctx.GetRenderStateParameters(),
|
||||
EXPECT_EQ(std::memcmp(&gPipeInputs->GetRenderStateParameters(), &ctx.GetRenderStateParameters(),
|
||||
sizeof(RenderStateParameters)),
|
||||
0)
|
||||
<< "the assembled working block is not byte-identical to the live one - a chunk of "
|
||||
@@ -554,7 +554,7 @@ namespace {
|
||||
// restored on the way out so the case stays independent (SanityTest's idiom).
|
||||
struct ContextGuard {
|
||||
SharedPtr<GLContext> Previous;
|
||||
ContextGuard() : Previous(Move(MG_State::pGLContext)) {
|
||||
ContextGuard() : Previous(MG_State::pGLContext.Take()) {
|
||||
MG_State::pGLContext = MakeUnique<GLContext>();
|
||||
MGPipeApplierReset();
|
||||
}
|
||||
@@ -653,7 +653,7 @@ namespace {
|
||||
// The vacuity guard: the block still holds what the fill copied out of the DEFAULT
|
||||
// context, so it must currently DISAGREE with the live one. If this ever passes, the
|
||||
// comparisons below would be checking the filler against itself.
|
||||
ASSERT_NE(gPipeInputs.GetLineWidth(), ctx.GetLineWidth());
|
||||
ASSERT_NE(gPipeInputs->GetLineWidth(), ctx.GetLineWidth());
|
||||
|
||||
applyWholeBlock();
|
||||
|
||||
@@ -667,7 +667,7 @@ namespace {
|
||||
// would hand the backends a 63-wide rectangle where 64 was asked for. The literal
|
||||
// is std::lround's answer - round half AWAY FROM ZERO, so 1.5 -> 2 and 2.5 -> 3,
|
||||
// not the banker's rounding a nearbyint() transcription would give.
|
||||
EXPECT_EQ(gPipeInputs.GetViewport(), IntVec4(2, 3, 64, 32));
|
||||
EXPECT_EQ(gPipeInputs->GetViewport(), IntVec4(2, 3, 64, 32));
|
||||
} // phase 1, kDraw
|
||||
|
||||
// Phase 2, kClear: the three clear values. The verb's own fill runs FIRST and copies
|
||||
@@ -678,13 +678,13 @@ namespace {
|
||||
ctx.SetClearColor(FloatVec4(0.9f, 0.8f, 0.7f, 0.6f));
|
||||
ctx.SetClearDepth(0.125f);
|
||||
ctx.SetClearStencil(21);
|
||||
ASSERT_NE(gPipeInputs.GetClearDepth(), ctx.GetClearDepth());
|
||||
ASSERT_NE(gPipeInputs->GetClearDepth(), ctx.GetClearDepth());
|
||||
|
||||
applyWholeBlock();
|
||||
|
||||
EXPECT_EQ(gPipeInputs.GetClearColor(), ctx.GetClearColor());
|
||||
EXPECT_EQ(gPipeInputs.GetClearDepth(), ctx.GetClearDepth());
|
||||
EXPECT_EQ(gPipeInputs.GetClearStencil(), ctx.GetClearStencil());
|
||||
EXPECT_EQ(gPipeInputs->GetClearColor(), ctx.GetClearColor());
|
||||
EXPECT_EQ(gPipeInputs->GetClearDepth(), ctx.GetClearDepth());
|
||||
EXPECT_EQ(gPipeInputs->GetClearStencil(), ctx.GetClearStencil());
|
||||
}
|
||||
|
||||
// Phase 3, kReadback: GetClampReadColor, the one derived field no draw and no clear
|
||||
@@ -692,12 +692,12 @@ namespace {
|
||||
{
|
||||
MG_Test::ScopedPipeVerb verb(MGPipeVerb::ReadPixels);
|
||||
ctx.SetClampReadColor(GL_FALSE);
|
||||
ASSERT_NE(gPipeInputs.GetClampReadColor(), ctx.GetClampReadColor());
|
||||
ASSERT_NE(gPipeInputs->GetClampReadColor(), ctx.GetClampReadColor());
|
||||
|
||||
applyWholeBlock();
|
||||
|
||||
EXPECT_EQ(gPipeInputs.GetClampReadColor(), ctx.GetClampReadColor());
|
||||
EXPECT_EQ(gPipeInputs.GetClampReadColor(), static_cast<GLenum>(GL_FALSE));
|
||||
EXPECT_EQ(gPipeInputs->GetClampReadColor(), ctx.GetClampReadColor());
|
||||
EXPECT_EQ(gPipeInputs->GetClampReadColor(), static_cast<GLenum>(GL_FALSE));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -764,7 +764,7 @@ namespace {
|
||||
TEST(RenderStateSpans, IncrementalChunksKeepEveryDerivedFieldInStep) {
|
||||
struct ContextGuard {
|
||||
SharedPtr<GLContext> Previous;
|
||||
ContextGuard() : Previous(Move(MG_State::pGLContext)) {
|
||||
ContextGuard() : Previous(MG_State::pGLContext.Take()) {
|
||||
MG_State::pGLContext = MakeUnique<GLContext>();
|
||||
MGPipeApplierReset();
|
||||
}
|
||||
@@ -926,7 +926,7 @@ namespace {
|
||||
// idiom, and the same guard cases 3 and 5 declare inline).
|
||||
struct ApplierContextGuard {
|
||||
SharedPtr<GLContext> Previous;
|
||||
ApplierContextGuard() : Previous(Move(MG_State::pGLContext)) {
|
||||
ApplierContextGuard() : Previous(MG_State::pGLContext.Take()) {
|
||||
MG_State::pGLContext = MakeUnique<GLContext>();
|
||||
MGPipeApplierReset();
|
||||
}
|
||||
@@ -1122,7 +1122,7 @@ namespace {
|
||||
pack.Pack.SkipRows = 5;
|
||||
pack.Pack.SwapBytes = true;
|
||||
MGPipeApplySetPixelPackState(pack);
|
||||
const PixelStoreParameters got = gPipeInputs.GetPixelStoreParameters(false);
|
||||
const PixelStoreParameters got = gPipeInputs->GetPixelStoreParameters(false);
|
||||
EXPECT_EQ(got.Alignment, 8);
|
||||
EXPECT_EQ(got.RowLength, 37);
|
||||
EXPECT_EQ(got.SkipRows, 5);
|
||||
@@ -1155,13 +1155,13 @@ namespace {
|
||||
std::memcpy(tail[1].IntView, secondInt, sizeof(secondInt));
|
||||
MGPipeApplySetVertexAttribDefaults(hdr, tail);
|
||||
|
||||
EXPECT_EQ(gPipeInputs.GetCurrentVertexAttribute(2).floatValue[0], 1.5f);
|
||||
EXPECT_EQ(gPipeInputs.GetCurrentVertexAttribute(2).floatValue[3], 4.5f);
|
||||
EXPECT_EQ(gPipeInputs.GetCurrentVertexAttribute(9).floatValue[2], 0.5f);
|
||||
EXPECT_EQ(gPipeInputs->GetCurrentVertexAttribute(2).floatValue[0], 1.5f);
|
||||
EXPECT_EQ(gPipeInputs->GetCurrentVertexAttribute(2).floatValue[3], 4.5f);
|
||||
EXPECT_EQ(gPipeInputs->GetCurrentVertexAttribute(9).floatValue[2], 0.5f);
|
||||
// ... and the CONVERTED views are the record's, not a memcpy of the float bits:
|
||||
// 1.5f's bits are 0x3FC00000, and the frontend's int view of it is 1.
|
||||
EXPECT_EQ(gPipeInputs.GetCurrentVertexAttribute(2).intValue[0], 1);
|
||||
EXPECT_EQ(gPipeInputs.GetCurrentVertexAttribute(9).intValue[0], -1);
|
||||
EXPECT_EQ(gPipeInputs->GetCurrentVertexAttribute(2).intValue[0], 1);
|
||||
EXPECT_EQ(gPipeInputs->GetCurrentVertexAttribute(9).intValue[0], -1);
|
||||
}
|
||||
|
||||
// delete_render_state: the record stops being live and a bound handle stops being
|
||||
|
||||
@@ -1807,7 +1807,7 @@ namespace {
|
||||
m_previousPush = MG_Config::Features.PipePush;
|
||||
MG_Config::Features.PipePush |= kMGPipeSubsystemResources;
|
||||
MGPipeSetResourceOps(&m_ops);
|
||||
m_previousContext = Move(MG_State::pGLContext);
|
||||
m_previousContext = MG_State::pGLContext.Take();
|
||||
MG_State::pGLContext = MakeUnique<GLContext>();
|
||||
}
|
||||
~PushArm() {
|
||||
|
||||
@@ -231,7 +231,7 @@ namespace {
|
||||
MG_Config::Features.PipePush |= kMGPipeSubsystemResources |
|
||||
kMGPipeSubsystemTextureResources |
|
||||
kMGPipeSubsystemSamplers;
|
||||
m_previousContext = Move(MG_State::pGLContext);
|
||||
m_previousContext = MG_State::pGLContext.Take();
|
||||
MG_State::pGLContext = MakeUnique<GLContext>();
|
||||
MGPipeTextureEmitterInstance().ResetForTest();
|
||||
// AND THE APPLIER IS A PROCESS SINGLETON, so its object records outlive a case. With
|
||||
|
||||
@@ -58,7 +58,7 @@ namespace {
|
||||
class TrackerAggregates : public ::testing::Test {
|
||||
protected:
|
||||
void SetUp() override {
|
||||
m_previous = Move(MG_State::pGLContext);
|
||||
m_previous = MG_State::pGLContext.Take();
|
||||
MG_State::pGLContext = MakeUnique<GLContext>();
|
||||
}
|
||||
void TearDown() override { MG_State::pGLContext = Move(m_previous); }
|
||||
@@ -174,7 +174,7 @@ namespace {
|
||||
}
|
||||
|
||||
TEST_F(TrackerAggregates, ANoteWithoutALiveContextIsANoOp) {
|
||||
SharedPtr<GLContext> held = Move(MG_State::pGLContext);
|
||||
SharedPtr<GLContext> held = MG_State::pGLContext.Take();
|
||||
MGP_NOTE_AGGREGATE(BufferChange); // must not dereference a null context
|
||||
MG_State::pGLContext = Move(held);
|
||||
SUCCEED();
|
||||
@@ -246,7 +246,7 @@ namespace {
|
||||
class TrackerWalk : public ::testing::Test {
|
||||
protected:
|
||||
void SetUp() override {
|
||||
m_previous = Move(MG_State::pGLContext);
|
||||
m_previous = MG_State::pGLContext.Take();
|
||||
MG_State::pGLContext = MakeUnique<GLContext>();
|
||||
m_savedPush = MG_Config::Features.PipePush;
|
||||
ResetTheServerSideSingletons();
|
||||
@@ -904,7 +904,7 @@ namespace {
|
||||
class TrackerAttribPayload : public ::testing::Test {
|
||||
protected:
|
||||
void SetUp() override {
|
||||
m_previous = Move(MG_State::pGLContext);
|
||||
m_previous = MG_State::pGLContext.Take();
|
||||
MG_State::pGLContext = MakeUnique<GLContext>();
|
||||
}
|
||||
void TearDown() override { MG_State::pGLContext = Move(m_previous); }
|
||||
@@ -993,7 +993,7 @@ namespace {
|
||||
class TrackerShippedEmitter : public ::testing::Test {
|
||||
protected:
|
||||
void SetUp() override {
|
||||
m_previous = Move(MG_State::pGLContext);
|
||||
m_previous = MG_State::pGLContext.Take();
|
||||
MG_State::pGLContext = MakeUnique<GLContext>();
|
||||
m_savedPush = MG_Config::Features.PipePush;
|
||||
MG_Config::Features.PipePush = kMGPipeSubsystemsMigratedAtP2;
|
||||
@@ -1166,7 +1166,7 @@ namespace {
|
||||
// that the capability itself reaches the applier's assembled block on the next draw.
|
||||
TEST_F(TrackerShippedEmitter, AClipDistanceEnableReArmsTheResidualBlock) {
|
||||
Draw();
|
||||
ASSERT_FALSE(MobileGL::MG_Pipe::gPipeInputs.IsCapabilityEnabled(CapabilityInput::ClipDistance0))
|
||||
ASSERT_FALSE(MobileGL::MG_Pipe::gPipeInputs->IsCapabilityEnabled(CapabilityInput::ClipDistance0))
|
||||
<< "the premise is gone: a fresh context already has clip distance 0 enabled";
|
||||
|
||||
Ctx().SetCapability(CapabilityInput::ClipDistance0, true);
|
||||
@@ -1177,7 +1177,7 @@ namespace {
|
||||
<< "the premise is gone: a clip-distance enable now moves the pipeline version";
|
||||
EXPECT_EQ(static_cast<Uint16>(Ctx().GetPipelineStateVersion()), pipelineBefore);
|
||||
|
||||
EXPECT_TRUE(MobileGL::MG_Pipe::gPipeInputs.IsCapabilityEnabled(CapabilityInput::ClipDistance0))
|
||||
EXPECT_TRUE(MobileGL::MG_Pipe::gPipeInputs->IsCapabilityEnabled(CapabilityInput::ClipDistance0))
|
||||
<< "a capability change that moves only m_version never reached the applier's block";
|
||||
}
|
||||
|
||||
@@ -1295,7 +1295,7 @@ namespace {
|
||||
// stand into the next verb. A draw with no context is a no-op; its argument must not
|
||||
// outlive it.
|
||||
MGPipeSetPendingBaseInstance(11);
|
||||
SharedPtr<GLContext> parked = Move(MG_State::pGLContext);
|
||||
SharedPtr<GLContext> parked = MG_State::pGLContext.Take();
|
||||
Draw();
|
||||
EXPECT_EQ(MGPipePendingBaseInstance(), 0u)
|
||||
<< "the no-live-context exit left the draw's base instance standing for the next verb";
|
||||
|
||||
@@ -132,7 +132,7 @@ namespace {
|
||||
// case out of the gate's reach.
|
||||
struct EmitterScope {
|
||||
EmitterScope() {
|
||||
m_previousContext = Move(MG_State::pGLContext);
|
||||
m_previousContext = MG_State::pGLContext.Take();
|
||||
MG_State::pGLContext = MakeUnique<GLContext>();
|
||||
MGPipeVertexInputEmitterInstance().Reset();
|
||||
MGPipeVertexInputEmitterInstance().ResetCounters();
|
||||
|
||||
@@ -894,7 +894,7 @@ TEST(DirectVulkanSanity, AdvertisesSubgroupOnlyWhenVulkanReportsUsableSupport) {
|
||||
TEST(DirectVulkanSanity, CapabilityRefreshInvalidatesTheCachedCompileEnvironment) {
|
||||
using namespace MobileGL;
|
||||
|
||||
auto previousContext = Move(MG_State::pGLContext);
|
||||
auto previousContext = MG_State::pGLContext.Take();
|
||||
auto previousBackend = Move(MG_Backend::pActiveBackendObject);
|
||||
MG_State::pGLContext = MakeUnique<MG_State::GLState::GLContext>();
|
||||
|
||||
@@ -1006,7 +1006,7 @@ TEST(GetterSanity, ClampsMaxVertexAttribsToCurrentValueStorageCapacity) {
|
||||
TEST(GetterSanity, ReportsFragmentInterpolationLimitsForFloatAndIntegerQueries) {
|
||||
using namespace MobileGL;
|
||||
|
||||
auto previousContext = Move(MG_State::pGLContext);
|
||||
auto previousContext = MG_State::pGLContext.Take();
|
||||
auto previousBackend = Move(MG_Backend::pActiveBackendObject);
|
||||
MG_State::pGLContext = MakeUnique<MG_State::GLState::GLContext>();
|
||||
|
||||
@@ -1056,7 +1056,7 @@ TEST(GetterSanity, ReportsFragmentInterpolationLimitsForFloatAndIntegerQueries)
|
||||
TEST(GetterSanity, StorageAndUniformBufferOffsetAlignmentsAreSeparateLimits) {
|
||||
using namespace MobileGL;
|
||||
|
||||
auto previousContext = Move(MG_State::pGLContext);
|
||||
auto previousContext = MG_State::pGLContext.Take();
|
||||
auto previousBackend = Move(MG_Backend::pActiveBackendObject);
|
||||
MG_State::pGLContext = MakeUnique<MG_State::GLState::GLContext>();
|
||||
|
||||
@@ -1145,7 +1145,7 @@ TEST(GetterSanity, AtomicCounterQueriesMatchShaderCompilerLimits) {
|
||||
using namespace MobileGL;
|
||||
namespace Transpiler = MG_Util::ShaderTranspiler;
|
||||
|
||||
auto previousContext = Move(MG_State::pGLContext);
|
||||
auto previousContext = MG_State::pGLContext.Take();
|
||||
auto previousBackend = Move(MG_Backend::pActiveBackendObject);
|
||||
MG_State::pGLContext = MakeUnique<MG_State::GLState::GLContext>();
|
||||
MG_Backend::pActiveBackendObject = MakeUnique<DynamicParameterBackend>(MG_Backend::DynamicBackendParameters{});
|
||||
@@ -1224,7 +1224,7 @@ void main() {
|
||||
TEST(GetterSanity, ComputeWorkGroupQueriesMatchShaderCompilerLimits) {
|
||||
using namespace MobileGL;
|
||||
|
||||
auto previousContext = Move(MG_State::pGLContext);
|
||||
auto previousContext = MG_State::pGLContext.Take();
|
||||
auto previousBackend = Move(MG_Backend::pActiveBackendObject);
|
||||
MG_State::pGLContext = MakeUnique<MG_State::GLState::GLContext>();
|
||||
MG_Backend::pActiveBackendObject = MakeUnique<DynamicParameterBackend>(MG_Backend::DynamicBackendParameters{});
|
||||
@@ -1305,7 +1305,7 @@ void main() {
|
||||
TEST(GetterSanity, EveryLimitWithABuiltinAgreesWithItsQuery) {
|
||||
using namespace MobileGL;
|
||||
|
||||
auto previousContext = Move(MG_State::pGLContext);
|
||||
auto previousContext = MG_State::pGLContext.Take();
|
||||
auto previousBackend = Move(MG_Backend::pActiveBackendObject);
|
||||
MG_State::pGLContext = MakeUnique<MG_State::GLState::GLContext>();
|
||||
MG_Backend::pActiveBackendObject =
|
||||
@@ -1404,7 +1404,7 @@ TEST(GetterSanity, EveryLimitWithABuiltinAgreesWithItsQuery) {
|
||||
TEST(GetterSanity, MaxElementIndexIsTheFull32BitIndexCeiling) {
|
||||
using namespace MobileGL;
|
||||
|
||||
auto previousContext = Move(MG_State::pGLContext);
|
||||
auto previousContext = MG_State::pGLContext.Take();
|
||||
auto previousBackend = Move(MG_Backend::pActiveBackendObject);
|
||||
MG_State::pGLContext = MakeUnique<MG_State::GLState::GLContext>();
|
||||
MG_Backend::pActiveBackendObject = MakeUnique<DynamicParameterBackend>(MG_Backend::DynamicBackendParameters{});
|
||||
@@ -1431,7 +1431,7 @@ TEST(GetterSanity, MaxElementIndexIsTheFull32BitIndexCeiling) {
|
||||
TEST(GetterSanity, PerCategoryMultisampleCeilingsAreProbedRatherThanFlooredAtFour) {
|
||||
using namespace MobileGL;
|
||||
|
||||
auto previousContext = Move(MG_State::pGLContext);
|
||||
auto previousContext = MG_State::pGLContext.Take();
|
||||
auto previousBackend = Move(MG_Backend::pActiveBackendObject);
|
||||
MG_State::pGLContext = MakeUnique<MG_State::GLState::GLContext>();
|
||||
|
||||
@@ -1473,7 +1473,7 @@ TEST(GetterSanity, PerCategoryMultisampleCeilingsAreProbedRatherThanFlooredAtFou
|
||||
TEST(ShaderCompilerSanity, ArbCullDistanceIsUsableBelow450) {
|
||||
using namespace MobileGL;
|
||||
|
||||
auto previousContext = Move(MG_State::pGLContext);
|
||||
auto previousContext = MG_State::pGLContext.Take();
|
||||
auto previousBackend = Move(MG_Backend::pActiveBackendObject);
|
||||
MG_State::pGLContext = MakeUnique<MG_State::GLState::GLContext>();
|
||||
MG_Backend::pActiveBackendObject = MakeUnique<DynamicParameterBackend>(MG_Backend::DynamicBackendParameters{});
|
||||
@@ -4579,7 +4579,7 @@ TEST(DirectGLESVertexInputDraw, TheAttributeWalkTakesItsBuffersFromTheRecordNotT
|
||||
// this case exists to catch - gPipeInputs->GetBoundVertexArray()->GetAllAttributes() - has
|
||||
// anything to read at all; a free-standing object would make the revert crash instead of
|
||||
// disagree, which is a red for the wrong reason.
|
||||
SharedPtr<GLContext> previousContext = Move(MG_State::pGLContext);
|
||||
SharedPtr<GLContext> previousContext = MG_State::pGLContext.Take();
|
||||
MG_State::pGLContext = MakeUnique<GLContext>();
|
||||
MG_State::pGLContext->CreateVertexArrayObject(1);
|
||||
MG_State::pGLContext->BindVertexArray(1);
|
||||
@@ -4650,7 +4650,7 @@ TEST(DirectGLESVertexInputDraw, TheIndexArmTakesItsBufferAndItsSerialFromTheReco
|
||||
|
||||
// The frontend's element slot has moved to another buffer with nothing emitted, in a real
|
||||
// context for the reason the case above gives.
|
||||
SharedPtr<GLContext> previousContext = Move(MG_State::pGLContext);
|
||||
SharedPtr<GLContext> previousContext = MG_State::pGLContext.Take();
|
||||
MG_State::pGLContext = MakeUnique<GLContext>();
|
||||
MG_State::pGLContext->CreateVertexArrayObject(1);
|
||||
MG_State::pGLContext->BindVertexArray(1);
|
||||
|
||||
@@ -222,7 +222,7 @@ TEST_F(ContextStateOwnershipTest, DestroyingOneContextLeavesTheOtherAlone) {
|
||||
|
||||
TEST_F(ContextStateOwnershipTest, ReleasingAnEglContextRestoresTheThreadsPreviousGLState) {
|
||||
const auto contextA = NewContext(EGL_NO_CONTEXT);
|
||||
const auto before = MG_State::pGLContext;
|
||||
const auto before = MG_State::pGLContext.Shared();
|
||||
ASSERT_NE(before, nullptr);
|
||||
|
||||
MakeCurrent(contextA);
|
||||
@@ -234,7 +234,7 @@ TEST_F(ContextStateOwnershipTest, ReleasingAnEglContextRestoresTheThreadsPreviou
|
||||
}
|
||||
|
||||
TEST_F(ContextStateOwnershipTest, AThreadWithoutACurrentContextUsesTheProcessDefaultContext) {
|
||||
const auto processDefault = MG_State::pGLContext;
|
||||
const auto processDefault = MG_State::pGLContext.Shared();
|
||||
ASSERT_NE(processDefault, nullptr);
|
||||
EXPECT_EQ(processDefault, MG_State::ProcessDefaultGLContext());
|
||||
|
||||
|
||||
@@ -1469,19 +1469,19 @@ TEST_F(PipeWireCodecTest, SetContextValuesRoundTripsIntoPipeInputs) {
|
||||
// kReadback's class carries the two texture-unit counters, kDraw's the rest
|
||||
// (FillPoints.def) - the stamp is what publishes a RECORD-SUPPLIED field for the read.
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::ReadPixels);
|
||||
EXPECT_EQ(gPipeInputs.GetActiveTextureUnit(), 9);
|
||||
EXPECT_EQ(gPipeInputs.GetMaxTouchedTextureUnit(), 41);
|
||||
EXPECT_EQ(gPipeInputs->GetActiveTextureUnit(), 9);
|
||||
EXPECT_EQ(gPipeInputs->GetMaxTouchedTextureUnit(), 41);
|
||||
MGPipeServerStampVerbBoundary(MGPipeVerb::DrawArrays);
|
||||
for (Uint32 t = 0; t < 15; ++t) {
|
||||
EXPECT_EQ(gPipeInputs.GetTouchedBufferBindingPointCount(static_cast<BufferTarget>(t)),
|
||||
EXPECT_EQ(gPipeInputs->GetTouchedBufferBindingPointCount(static_cast<BufferTarget>(t)),
|
||||
SizeT{100 + t})
|
||||
<< "target " << t;
|
||||
}
|
||||
EXPECT_TRUE(gPipeInputs.IsTransformFeedbackActive());
|
||||
EXPECT_TRUE(gPipeInputs.IsTransformFeedbackPaused());
|
||||
EXPECT_EQ(gPipeInputs.GetTransformFeedbackGeneration(), 0xA1A2A3A4A5A6A7A8ull);
|
||||
EXPECT_EQ(gPipeInputs.GetBoundTransformFeedbackLifetimeId(), 0xB1B2B3B4B5B6B7B8ull);
|
||||
EXPECT_EQ(gPipeInputs.GetTransformFeedbackCapturedVertices(), 0xC1C2C3C4C5C6C7C8ull);
|
||||
EXPECT_TRUE(gPipeInputs->IsTransformFeedbackActive());
|
||||
EXPECT_TRUE(gPipeInputs->IsTransformFeedbackPaused());
|
||||
EXPECT_EQ(gPipeInputs->GetTransformFeedbackGeneration(), 0xA1A2A3A4A5A6A7A8ull);
|
||||
EXPECT_EQ(gPipeInputs->GetBoundTransformFeedbackLifetimeId(), 0xB1B2B3B4B5B6B7B8ull);
|
||||
EXPECT_EQ(gPipeInputs->GetTransformFeedbackCapturedVertices(), 0xC1C2C3C4C5C6C7C8ull);
|
||||
MGPipeServerClearVerbBoundary();
|
||||
}
|
||||
|
||||
|
||||
@@ -816,21 +816,21 @@ TEST(ServerLoopTest, AClearRecordCrossesAndIsStampedAsAVerbBoundary) {
|
||||
ASSERT_TRUE(fixture.StartLoop());
|
||||
|
||||
// The pre-state is the honest one: nothing has stamped yet in this process.
|
||||
ASSERT_NE(MG_Pipe::gPipeInputs.CurrentVerb(), MG_Pipe::MGPipeVerb::Clear);
|
||||
ASSERT_NE(MG_Pipe::gPipeInputs->CurrentVerb(), MG_Pipe::MGPipeVerb::Clear);
|
||||
|
||||
const MG_Pipe::MGPClear clear = WholeFramebufferClear();
|
||||
ASSERT_TRUE(fixture.EmitAndWait(MG_Pipe::MGPWireOp::Clear, &clear, sizeof(clear)));
|
||||
|
||||
Server::ServerLoop& loop = Server::ServerLoopInstance();
|
||||
EXPECT_EQ(loop.DrainedRecords(), 1u);
|
||||
EXPECT_EQ(MG_Pipe::gPipeInputs.CurrentVerb(), MG_Pipe::MGPipeVerb::Clear)
|
||||
EXPECT_EQ(MG_Pipe::gPipeInputs->CurrentVerb(), MG_Pipe::MGPipeVerb::Clear)
|
||||
<< "PipeApplier::StampVerbBoundary did not run, so every server-side PipeInputs read "
|
||||
"would abort on the first field inside SyncRenderState";
|
||||
|
||||
// MANDATORY on leaving the applier (p1's M-5): without it a SPAWNED server latches the flag
|
||||
// for its whole life, every later read is judged against the last verb's mask, and the
|
||||
// sticky forwards start aborting under strict on the very case their exemption exists for.
|
||||
EXPECT_FALSE(MG_Pipe::gPipeInputs.ServerStampedVerb())
|
||||
EXPECT_FALSE(MG_Pipe::gPipeInputs->ServerStampedVerb())
|
||||
<< "MGPipeServerClearVerbBoundary was not called when the apply thread left the applier";
|
||||
|
||||
// No backend object in this process, so the five class-B verbs DECLINE. Asserted rather
|
||||
@@ -1629,7 +1629,7 @@ namespace {
|
||||
// Empty on success, else the step that failed - the harness's SkipReason shape.
|
||||
std::string BringUp() {
|
||||
PinHeadlessEglEnvironment();
|
||||
savedContext = Move(MG_State::pGLContext);
|
||||
savedContext = MG_State::pGLContext.Take();
|
||||
MG_State::pGLContext = MakeUnique<MG_State::GLState::GLContext>();
|
||||
Server::ServerLoop& loop = Server::ServerLoopInstance();
|
||||
// InitSplitRoles step 1: the server's private backend, no GL and no EGL yet; its
|
||||
@@ -1944,13 +1944,13 @@ TEST(ServerLoopEglTest, ServerLivenessFollowsControlFramesAcrossReleaseAndRecrea
|
||||
MGL_EGL_BRING_UP_OR_BAIL(fixture);
|
||||
const auto live = [] {
|
||||
Bool answer = false;
|
||||
EXPECT_EQ(OnApply([&] { answer = MG_Pipe::gPipeInputs.IsLive(); }), MOBILEGL_OK);
|
||||
EXPECT_EQ(OnApply([&] { answer = MG_Pipe::gPipeInputs->IsLive(); }), MOBILEGL_OK);
|
||||
return answer;
|
||||
};
|
||||
EXPECT_FALSE(live()) << "surface creation alone is not a served current context";
|
||||
ASSERT_TRUE(fixture.MakeCurrent());
|
||||
EXPECT_TRUE(live());
|
||||
auto client = Move(MG_State::pGLContext);
|
||||
auto client = MG_State::pGLContext.Take();
|
||||
EXPECT_TRUE(live()) << "server liveness must not consult the client GLContext";
|
||||
MG_State::pGLContext = Move(client);
|
||||
ASSERT_TRUE(fixture.ReleaseCurrent());
|
||||
@@ -2571,7 +2571,7 @@ TEST(ServerLoopTest, AnInstancedBaseVertexDrawRecordReachesTheSinkWithItsFieldsI
|
||||
EXPECT_EQ(seen.FirstRange.IndexBias, 5);
|
||||
EXPECT_FALSE(seen.HadUserIndices);
|
||||
EXPECT_FALSE(seen.HadIndirect);
|
||||
EXPECT_FALSE(MG_Pipe::gPipeInputs.ServerStampedVerb());
|
||||
EXPECT_FALSE(MG_Pipe::gPipeInputs->ServerStampedVerb());
|
||||
|
||||
fixture.Stop();
|
||||
}
|
||||
@@ -2714,7 +2714,7 @@ TEST(P5fReverseChannel, GlErrorsUseTheOwnedCallbackWithoutAResidualPull) {
|
||||
g_fvErrorCalls = 0;
|
||||
MG_Pipe::MGPipeResetResidualPullCountForTesting();
|
||||
MG_Pipe::MGPipeServerStampVerbBoundary(MG_Pipe::MGPipeVerb::Clear);
|
||||
MG_Pipe::gPipeInputs.RecordError(ErrorCode::InvalidOperation,
|
||||
MG_Pipe::gPipeInputs->RecordError(ErrorCode::InvalidOperation,
|
||||
MakeUnique<GenericErrorInfo>("fv", "draw", "driver message"));
|
||||
EXPECT_EQ(g_fvErrorCalls, 1u);
|
||||
EXPECT_EQ(g_fvErrorCode, static_cast<Uint32>(ErrorCode::InvalidOperation));
|
||||
@@ -2780,7 +2780,7 @@ TEST(P5fReverseChannel, RecordErrorWithoutCallbackIsNamedFatal) {
|
||||
MG_Config::Ipc.StrictErrors = true;
|
||||
MG_Config::Ipc.RoleSplitState = true;
|
||||
MG_Pipe::gMGPipeCallbacks.OnGlError = nullptr;
|
||||
MG_Pipe::gPipeInputs.RecordError(ErrorCode::InvalidOperation, nullptr);
|
||||
MG_Pipe::gPipeInputs->RecordError(ErrorCode::InvalidOperation, nullptr);
|
||||
std::_Exit(9);
|
||||
}, ::testing::KilledBySignal(SIGABRT), "");
|
||||
EXPECT_NE(ReadLog().find("OnGlError.callback-missing"), std::string::npos);
|
||||
@@ -2815,7 +2815,7 @@ TEST(P5fReverseChannel, GlErrorMessagesShareFifoWithOtherReverseEvents) {
|
||||
ASSERT_EQ(Server::ServerLoopInstance().RunProbeOnApplyThreadForTesting(
|
||||
+[](void*) -> MobileGLResult {
|
||||
MG_Pipe::MGPipeServerStampVerbBoundary(MG_Pipe::MGPipeVerb::Clear);
|
||||
MG_Pipe::gPipeInputs.RecordError(ErrorCode::InvalidOperation,
|
||||
MG_Pipe::gPipeInputs->RecordError(ErrorCode::InvalidOperation,
|
||||
MakeUnique<GenericErrorInfo>("fv", "driver error"));
|
||||
const MG_Pipe::MGPRange whole{0, MG_Pipe::kMGPipeWholeBuffer};
|
||||
MG_Pipe::gMGPipeCallbacks.OnGpuWritten({17, 3}, 1, &whole);
|
||||
@@ -3165,7 +3165,7 @@ namespace {
|
||||
const MG_Pipe::MGPDrawRange range{0, 3, 0};
|
||||
if (!fixture.EmitAndWaitWithTail(MG_Pipe::MGPWireOp::DrawVbo, &info, sizeof(info), &range, sizeof(range)))
|
||||
::_exit(65);
|
||||
if (MG_Pipe::gPipeInputs.CurrentVerb() == MG_Pipe::MGPipeVerb::Clear) ::_exit(66);
|
||||
if (MG_Pipe::gPipeInputs->CurrentVerb() == MG_Pipe::MGPipeVerb::Clear) ::_exit(66);
|
||||
// A Clear encoded legally and then SHORTENED in the ring before it is published - the
|
||||
// raw-record peer driver's move, in process: its header says 8 bytes, a header and no
|
||||
// MGPClear at all.
|
||||
@@ -3185,7 +3185,7 @@ namespace {
|
||||
Server::ServerLoop& loop = Server::ServerLoopInstance();
|
||||
(void)PollUntil([&] { return !loop.Running(); }, 3000);
|
||||
int failed = 0;
|
||||
if (MG_Pipe::gPipeInputs.CurrentVerb() == MG_Pipe::MGPipeVerb::Clear) failed |= kShortStamped;
|
||||
if (MG_Pipe::gPipeInputs->CurrentVerb() == MG_Pipe::MGPipeVerb::Clear) failed |= kShortStamped;
|
||||
if (!Remote::SessionLatched() || std::strstr(Remote::SessionLatchedLine(), "\"record.Minimum\"") == nullptr)
|
||||
failed |= kShortWrongFault;
|
||||
if (loop.DrainedRecords() != 2) failed |= kShortDrained;
|
||||
|
||||
Reference in New Issue
Block a user