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;
}
}
