Início / user-21874203

SinixND's questions

Martin Hope
SinixND
Asked: 2024-11-23 01:11:18 +0800 CST
  • 10

nas palestras de Mike Actons aqui e aqui (os links têm carimbos de data/hora), bem como nesta postagem do blog, eles preparam/pré-condicionam/pré-buscam/consultam dados não contíguos necessários primeiro para depois iterá-los/fazer cálculos de uma forma amigável ao cache.

Aqui está o código da postagem do blog:

// objects_store.h

struct ObjectsStore
{
    vector<Vector3D> m_Positions;
    vector<Quaternion> m_Orientations;
};

// Runtime solution:

struct TranslationData
{
    Vector3D m_ObjPosition;
    const Quaternion m_ObjOrientation;
    const Vector3D m_ObjTranslation;
};

void PrepareTranslations(const ObjectsStore& inStore,
                         const vector<Vector3D>& inTranslations,
                         vector<TranslationData>& outObjectsToTranslate)
{
    assert(inStore.m_Positions.size() == inStore.m_Orientations.size());
    assert(inStore.m_Positions.size() == inTranslations.size());
    for (size_t i = 0; i < inTranslations.size(); ++i)
    {
        outObjectsToTranslate.push_back
        ({ 
             inStore.m_Positions[i];
             inStore.m_Orientations[i];
             inTranslations[i];
        });
    }
}

void TranslateObject(vector<TranslationData>& ioObjectsToTranslate)
{
    for (TranslationData& data: ioObjectsToTranslate)
        data.m_ObjPosition += data.m_ObjOrientation * data.m_ObjTranslation;
}

void ApplyTranslation(const vector<TranslationData>& inTranslationData
                      ObjectsStore& outStore)
{
    assert(inStore.m_Positions.size() == inTranslationData.size());
    for (size_t i = 0; i < inTranslationData.size(); ++i)
        outStore.m_Positions[i] = inTranslationData[i].m_ObjPosition;
}

void UpdateGame(ObjectsStore& ioStore, vector<Vector3D>& inTranslations)
{
   vector<TranslationData> translation_data;
   PrepareTranslations(ioStore, inTranslations, translation_data);
   TranslateObject(translation_data);
   ApplyTranslation(translation_data, ioStore);
}

Minha pergunta é: para preparar os dados dessa maneira, é preciso acessá-los de qualquer maneira (e também copiá-los), então me pergunto se, mesmo que os dados sejam mais amigáveis ​​ao cache depois , não seria mais eficiente modificá-los diretamente e poupar a etapa de preparação?

Até onde eu entendo, obviamente os cálculos são muito eficientes nos dados preparados, mas com o custo adicional de prepará-los em primeiro lugar.

Alguém pode me dizer o que estou esquecendo aqui? Alguém assume o custo extra para obter outros benefícios (como código mais claro etc.) ou é realmente mais eficiente do que a modificação direta?

desde já, obrigado

c++