TEST_F(ExpressionTree, SoleDataOwner) { auto setup = GetSetup(); ExpressionNodeFactory e(setup->GetAllocator(), setup->GetCode()); Storage<int> empty; ASSERT_TRUE(empty.IsSoleDataOwner()); auto s = e.Direct<int>(); ASSERT_TRUE(s.IsSoleDataOwner()); auto s2 = s; ASSERT_FALSE(s.IsSoleDataOwner()); ASSERT_FALSE(s2.IsSoleDataOwner()); s2.Reset(); ASSERT_TRUE(s.IsSoleDataOwner()); ASSERT_TRUE(s2.IsSoleDataOwner()); // Different indirects that refer to stack are sole owners of their storage. auto stack1 = e.Temporary<int>(); ASSERT_TRUE(stack1.IsSoleDataOwner()); auto stack2 = e.Temporary<int>(); ASSERT_TRUE(stack2.IsSoleDataOwner()); }
TEST_F(ExpressionTree, TakeSoleOwnershipOfDirect) { auto setup = GetSetup(); ExpressionNodeFactory e(setup->GetAllocator(), setup->GetCode()); auto s = e.Direct<int>(eax); ASSERT_TRUE(s.IsSoleDataOwner()); ASSERT_EQ(s.GetStorageClass(), StorageClass::Direct); ASSERT_EQ(s.GetDirectRegister(), eax); auto s2 = s; ASSERT_FALSE(s.IsSoleDataOwner()); ASSERT_FALSE(s2.IsSoleDataOwner()); ASSERT_EQ(s2.GetStorageClass(), StorageClass::Direct); ASSERT_EQ(s2.GetDirectRegister(), eax); s.TakeSoleOwnershipOfDirect(); ASSERT_TRUE(s.IsSoleDataOwner()); ASSERT_EQ(s.GetStorageClass(), StorageClass::Direct); ASSERT_EQ(s.GetDirectRegister(), eax); ASSERT_TRUE(s2.IsSoleDataOwner()); ASSERT_EQ(s2.GetStorageClass(), StorageClass::Direct); // ASSERT_NE(s2.GetDirectRegister(), eax); Doesn't compile! ASSERT_FALSE((s2.GetDirectRegister() == eax)); }
TEST_FIXTURE_END_TEST_CASES_BEGIN // Verify that the sole owner of an indirect storage will reuse the // base register for the direct register after dereferencing. TEST_F(ExpressionTree, BaseRegisterReuse) { auto setup = GetSetup(); ExpressionNodeFactory e(setup->GetAllocator(), setup->GetCode()); // Create indirect storage to reference an integer. struct Test { int m_dummy; }; Test testStruct; auto & structNode = e.Immediate(&testStruct); auto & indirectNode = e.Deref(e.FieldPointer(structNode, &Test::m_dummy)); indirectNode.IncrementParentCount(); structNode.CodeGenCache(e); indirectNode.CodeGenCache(e); auto storage = indirectNode.CodeGen(e); auto baseRegister = storage.GetBaseRegister(); ASSERT_TRUE(storage.ConvertToDirect(false).IsSameHardwareRegister(baseRegister)); }
TEST_F(ExpressionTree, RegisterPinning) { auto setup = GetSetup(); TestRegisterPinning<int>(*setup); TestRegisterPinning<float>(*setup); }
TEST_F(Conditional, If) { auto setup = GetSetup(); Function<uint64_t, bool, uint64_t, uint64_t> e(setup->GetAllocator(), setup->GetCode()); auto & test = e.If(e.GetP1(), e.GetP2(), e.GetP3()); auto function = e.Compile(test); bool p1 = true; uint64_t p2 = 0xFFFFFFFFFFFFFFFF; uint64_t p3 = 0; auto expected = p1 ? p2 : p3; auto observed = function(p1, p2, p3); ASSERT_EQ(expected, observed); p1 = false; expected = p1 ? p2 : p3; observed = function(p1, p2, p3); ASSERT_EQ(expected, observed); }
void cKeys::PutSetup(const char *Remote, const char *Setup) { if (!GetSetup(Remote)) Add(new cKey(Remote, Setup, k_Setup)); else esyslog("ERROR: called PutSetup() for %s, but setup has already been defined!", Remote); }
TEST_F(ExpressionTree, RegisterSpillingInteger) { auto setup = GetSetup(); ExpressionNodeFactory e(setup->GetAllocator(), setup->GetCode()); std::vector<Storage<int>> storages; const unsigned totalRegisterCount = RegisterBase::c_maxIntegerRegisterID + 1; // Try to obtain totalRegisterCount direct registers. for (unsigned i = 0; i < totalRegisterCount; ++i) { storages.push_back(e.Direct<int>()); ASSERT_EQ(storages.back().GetStorageClass(), StorageClass::Direct); } // There won't be enough registers for all storages to stay // direct since reserved base pointers can't be obtained. Thus, // some of the storages should have their registers spilled. // Three reserved registers are RBP, RSP and RIP. Note: this // assumes that RBP is a base register - if RSP is used instead // of RBP, the test will need to be adjusted. // Alternatively, ExpressionTree::IsAnyBaseRegister could be // made accessible and used to count the reserved registers. const unsigned reservedRegisterCount = 3; unsigned directCount = 0; unsigned indirectCount = 0; unsigned indexOfFirstDirect = 0; for (unsigned i = 0; i < storages.size(); ++i) { if (storages[i].GetStorageClass() == StorageClass::Direct) { directCount++; if (directCount == 1) { indexOfFirstDirect = i; } } else { indirectCount++; } } // Most storages should be direct, some corresponding to the // reserved registers should not. ASSERT_EQ(totalRegisterCount - reservedRegisterCount, directCount); ASSERT_EQ(reservedRegisterCount, indirectCount); // A new direct storage should cause the oldest reserved register // to be spilled (note: this assumes current allocation strategy). ASSERT_EQ(storages[indexOfFirstDirect].GetStorageClass(), StorageClass::Direct); Storage<int> spillTrigger = e.Direct<int>(); ASSERT_EQ(spillTrigger.GetStorageClass(), StorageClass::Direct); ASSERT_EQ(storages[indexOfFirstDirect].GetStorageClass(), StorageClass::Indirect); }
TEST_F(ExpressionTree, NoBaseRegisterReuseBasePointer) { auto setup = GetSetup(); ExpressionNodeFactory e(setup->GetAllocator(), setup->GetCode()); auto storage = e.Temporary<int>(); auto baseRegister = storage.GetBaseRegister(); ASSERT_FALSE(storage.ConvertToDirect(false).IsSameHardwareRegister(baseRegister)); }
TEST_F(ExpressionTree, NoBaseRegisterReuseRIPRelative) { auto setup = GetSetup(); ExpressionNodeFactory e(setup->GetAllocator(), setup->GetCode()); auto storage = e.RIPRelative<int>(16); ASSERT_TRUE(storage.GetBaseRegister().IsRIP()); ASSERT_FALSE(storage.ConvertToDirect(false).IsRIP()); }
void CVICOSFirstStep::CalcStraightMatrix() { CVICOSContext* pSetup = GetSetup(); CProblem* pProb = pSetup->GetProblem(); long iDim = pSetup->GetDim(); time tStart = pSetup->GetStart(), tFinish = pSetup->GetFinish(), tStep = pSetup->GetNStep(); long iStepCount = long((tFinish - tStart) / tStep) + 1; m_X.Create(iStepCount + 1); for (long i = 0; i <= iStepCount; i++) { matrixpoint& Xt = m_X[i]; Xt.Create(iDim, iDim); } // идем по столбцам $iCol$, фундаментальной матрицы for (long iCol = 0; iCol < iDim; iCol++) { timepoint X0; X0.Create(iDim); for (long i = 0; i < iDim; i++) { X0[i] = (i == iCol) ? 1 : 0; } long i = 0; for (time tCur = tStart; tCur <= tFinish; tCur += tStep) { X0 = m_pMethod->CalculateStep(tCur, X0, tStep, pProb); matrixpoint& mpCurrent = m_X[i++]; for (long iRow = 0; iRow < iDim; iRow++) { mpCurrent(iRow, iCol) = X0[iRow]; } } } for (long i = 0; i <= iStepCount; i++) { std::cout << "t=" << (tStart + tStep * i) << std::endl; std::cout << "matrix=" << std::endl << m_X[i] << std::endl << std::endl; } }
TEST_F(ExpressionTree, MultipleReferencesToRIP) { auto setup = GetSetup(); ExpressionNodeFactory e(setup->GetAllocator(), setup->GetCode()); auto temp1 = e.RIPRelative<int>(0); auto temp2 = e.RIPRelative<int>(16); ASSERT_TRUE(temp1.GetBaseRegister().IsRIP()); ASSERT_EQ(temp1.GetBaseRegister(), temp2.GetBaseRegister()); }
TEST_F(ExpressionTree, MultipleReferencesToBasePointer) { auto setup = GetSetup(); ExpressionNodeFactory e(setup->GetAllocator(), setup->GetCode()); auto temp1 = e.Temporary<int>(); auto temp2 = e.Temporary<int>(); ASSERT_EQ(temp1.GetBaseRegister(), temp2.GetBaseRegister()); ASSERT_NE(temp1.GetOffset(), temp2.GetOffset()); }
eng1_qm::eng1_qm(setup * p1, i32u p2) : engine(p1, p2) { // create the local-to-global lookup table... // create the local-to-global lookup table... // create the local-to-global lookup table... l2g_qm = new i32u[GetSetup()->GetQMAtomCount()]; atom ** atmtab = GetSetup()->GetQMAtoms(); atom ** glob_atmtab = GetSetup()->GetAtoms(); for (i32s n1 = 0;n1 < GetSetup()->GetQMAtomCount();n1++) { i32s index = 0; while (index < GetSetup()->GetAtomCount()) { if (atmtab[n1] == glob_atmtab[index]) break; else index++; } if (index >= GetSetup()->GetAtomCount()) { cout << "BUG: eng1_qm ctor failed to create the l2g lookup table." << endl; exit(EXIT_FAILURE); } l2g_qm[n1] = index; } // transition_state_search will set this if needed... // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ tss_ref_str = NULL; tss_force_const = 0.0; tss_delta_ene = 0.0; }
fGL eng1_qm::GetVDWSurf(fGL * pp, fGL * dd) { fGL vdwsv = 0.0; if (dd != NULL) dd[0] = dd[1] = dd[2] = 0.0; atom ** atmtab = GetSetup()->GetQMAtoms(); for (i32s n1 = 0;n1 < GetSetup()->GetQMAtomCount();n1++) { fGL tmp1[3]; fGL r2 = 0.0; const f64 * cdata = & crd[l2g_qm[n1] * 3]; for (i32s n2 = 0;n2 < 3;n2++) { tmp1[n2] = pp[n2] - cdata[n2]; r2 += tmp1[n2] * tmp1[n2]; } if (r2 == 0.0) return +1.0e+35; // numeric_limits<fGL>::max()?!?!?! fGL r1 = sqrt(r2); fGL tmp2 = r1 / (atmtab[n1]->vdwr + 0.0); // solvent radius??? 0.15 fGL qqq = tmp2 * tmp2 * tmp2 * tmp2; fGL tmp3 = 1.0 / (qqq * qqq * qqq); vdwsv += tmp3; if (dd != NULL) // sign ??? constant ??? { for (i32s n2 = 0;n2 < 3;n2++) { fGL tmp4 = tmp1[n2] / r1; fGL tmp5 = tmp4 * tmp3 / tmp2; dd[n2] += tmp5; } } } return vdwsv; }
TEST_F(FloatingPoint, AddDouble) { auto setup = GetSetup(); { Function<double, double, double> expression(setup->GetAllocator(), setup->GetCode()); auto & a = expression.Add(expression.GetP2(), expression.GetP1()); auto function = expression.Compile(a); double p1 = 12340000.0; double p2 = 5678.0; auto expected = p1 + p2; auto observed = function(p1, p2); ASSERT_EQ(observed, expected); } }
TEST_F(FloatingPoint, AddImmediateDouble) { auto setup = GetSetup(); { Function<double, double> expression(setup->GetAllocator(), setup->GetCode()); double immediate = 123.456; auto & a = expression.Immediate(immediate); auto & b = expression.Add(expression.GetP1(), a); auto function = expression.Compile(b); double p1 = 12340000.0; auto expected = p1 + immediate; auto observed = function(p1); ASSERT_EQ(observed, expected); } }
TEST_F(ExpressionTree, RegisterSpillingFloat) { auto setup = GetSetup(); ExpressionNodeFactory e(setup->GetAllocator(), setup->GetCode()); std::vector<Storage<float>> storages; const unsigned totalRegisterCount = RegisterBase::c_maxFloatRegisterID + 1; // Try to obtain totalRegisterCount direct registers. for (unsigned i = 0; i < totalRegisterCount; ++i) { storages.push_back(e.Direct<float>()); ASSERT_EQ(storages.back().GetStorageClass(), StorageClass::Direct); } // There are no reserved registers for floats, so no register // should have been bumped. for (auto const & s : storages) { ASSERT_EQ(s.GetStorageClass(), StorageClass::Direct); } // A new direct storage should cause the oldest reserved register // to be spilled (note: this assumes current allocation strategy). Storage<float> spillTrigger = e.Direct<float>(); ASSERT_EQ(spillTrigger.GetStorageClass(), StorageClass::Direct); ASSERT_EQ(storages[0].GetStorageClass(), StorageClass::Indirect); Storage<float> spillTrigger2 = e.Direct<float>(); ASSERT_EQ(spillTrigger2.GetStorageClass(), StorageClass::Direct); ASSERT_EQ(storages[1].GetStorageClass(), StorageClass::Indirect); // Make sure that a released register will be used for a new // direct rather than spilling storages[2] for it. ASSERT_EQ(storages[2].GetStorageClass(), StorageClass::Direct); spillTrigger2.Reset(); spillTrigger2 = e.Direct<float>(); ASSERT_EQ(storages[2].GetStorageClass(), StorageClass::Direct); }
TEST_F(FloatingPoint, AddTwoImmediateDouble) { auto setup = GetSetup(); { Function<double> expression(setup->GetAllocator(), setup->GetCode()); double immediate1 = 123.0; double immediate2 = 0.456; auto & a = expression.Immediate(immediate1); auto & b = expression.Immediate(immediate2); auto & c = expression.Add(a, b); auto function = expression.Compile(c); auto expected = immediate1 + immediate2; auto observed = function(); ASSERT_EQ(observed, expected); } }
TEST_F(ExpressionTree, NoBaseRegisterReuseFloat) { auto setup = GetSetup(); ExpressionNodeFactory e(setup->GetAllocator(), setup->GetCode()); // Create indirect storage to reference a float. struct Test { float m_dummy; }; Test testStruct; auto & structNode = e.Immediate(&testStruct); auto & indirectNode = e.Deref(e.FieldPointer(structNode, &Test::m_dummy)); indirectNode.IncrementParentCount(); structNode.CodeGenCache(e); indirectNode.CodeGenCache(e); auto storage = indirectNode.CodeGen(e); auto baseRegister = storage.GetBaseRegister(); ASSERT_FALSE(storage.ConvertToDirect(false).IsSameHardwareRegister(baseRegister)); }
void FBlurShader::Blur(FGLRenderer *renderer, float blurAmount, int sampleCount, GLuint inputTexture, GLuint outputFrameBuffer, int width, int height, bool vertical) { BlurSetup *setup = GetSetup(blurAmount, sampleCount); if (vertical) setup->VerticalShader->Bind(); else setup->HorizontalShader->Bind(); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, inputTexture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glBindFramebuffer(GL_FRAMEBUFFER, outputFrameBuffer); glViewport(0, 0, width, height); glDisable(GL_BLEND); renderer->RenderScreenQuad(); }
bool CGame::LoadSetup() { // 加载全局配置 string strTemp; ifstream streamLog; streamLog.open("LogSetup.ini"); if( streamLog.is_open() ) { streamLog >> strTemp >> GetSetup()->lUseLogServer >> strTemp >> GetSetup()->strLogIP >> strTemp >> GetSetup()->dwLogPort >> strTemp >> GetSetup()->strErrFile >> strTemp >> GetSetup()->strLogFile >> strTemp >> GetSetup()->strTxtLogFile >> strTemp >> GetSetup()->dwClientNo; streamLog.close(); }
void CVICOSFirstStep::CalcInversedMatrix() { CVICOSContext* pSetup = GetSetup(); //CProblem* pProb = pSetup->GetProblem(); long iDim = pSetup->GetDim(); time tStart = pSetup->GetStart(), tFinish = pSetup->GetFinish(), tStep = pSetup->GetNStep(); long iStepCount = long((tFinish - tStart) / tStep) + 1; m_Xi.Create(m_X.GetCount()); for (long i = 0; i <= iStepCount; i++) { matrixpoint &dest = m_Xi[i], &src = m_X[i]; dest.Create(iDim, iDim); if (iDim == 1) { dest(0, 0) = 1 / src(0, 0); } else { MatrixInversion(src.GetData(), iDim, dest.GetData()); } std::cout << "t=" << (tStart + tStep * i) << std::endl; std::cout << "imatrix=" << std::endl << m_Xi[i] << std::endl << std::endl; } }