पुनः पोस्ट करने का कारण:
मूल रूप से मुझे केवल एक ही उत्तर मिला, वह केवलबताया कि शीर्षक अतिरंजित था। इसलिए फिर से कोशिश करना, हो सकता है कि अधिक लोग इस बार इस प्रश्न को देखेंगे क्योंकि मुझे नहीं पता कि वास्तव में और कहां देखना है ... मैं दोहराव से बचने के लिए मूल प्रश्न को हटाना सुनिश्चित करूंगा, और इसके बजाय इस नए को रखूंगा। मैं मंच स्पैम करने की कोशिश नहीं कर रहा हूँ।
संपादन पर ऊपर दिए गए पाठ को हटाने के लिए स्वतंत्र महसूस करें, मैं सिर्फ यह बताना चाहता था कि मैं "पुनः पोस्टिंग" क्यों कर रहा हूँ - लेकिन यह वास्तव में प्रश्न का हिस्सा नहीं है।
तो, मूल प्रश्न था:
मेरे कार्यक्रम में मेरे कुछ कार्य हैं जो डीबग मोड में, विजुअल स्टूडियो कम्युनिटी, 2015 में बेहद धीमी गति से चलते हैं। वे 3 डी मॉडल के वर्जन को "इंडेक्स" करने के लिए कार्य करते हैं।
आम तौर पर, मैं थोड़ा धीमा होने के लिए डिबग मोड के लिए तैयार हूं, शायद 2 -3 गुना धीमा। लेकिन।
में रिहाई मोड, कार्यक्रम के बारे में मॉडल को शुरू और अनुक्रमित करता है 2 - 3 सेकंड। उत्तम।
में डिबग मोड, हालांकि, यह खत्म हो गया है 7 मिनट मेरे कार्यक्रम के लिए वास्तव में प्रतिक्रिया देने के लिए, प्रतिपादन शुरू करने और इनपुट लेने के लिए। यह सात मिनट के लिए एक मॉडल को अनुक्रमणित करता है। इस दौरान कार्यक्रम पूरी तरह से फ्रीज हो गया है।
एक ही मॉडल 3 से कम में "रिलीज़" मोड में लोड और अनुक्रमित करता है सेकंड। यह कैसे संभव है कि यह डिबग में अविश्वसनीय रूप से लंबा हो?
दोनों डिबग और रिलीज़ मोड बॉक्स मोड से बाहर मानक हैं। मैं उनमें से किसी भी सेटिंग में बदलाव को याद नहीं करता।
यहाँ कोड है जो डिबग मोड में कार्यक्रम को धीमा कर रहा है:
// Main Indexer Function
void indexVBO_TBN(
std::vector<glm::vec3> &in_vertices,
std::vector<glm::vec2> &in_uvs,
std::vector<glm::vec3> &in_normals,
std::vector<glm::vec3> &in_tangents,
std::vector<glm::vec3> &in_bitangents,
std::vector<unsigned short> & out_indices,
std::vector<glm::vec3> &out_vertices,
std::vector<glm::vec2> &out_uvs,
std::vector<glm::vec3> &out_normals,
std::vector<glm::vec3> &out_tangents,
std::vector<glm::vec3> &out_bitangents){
int count = 0;
// For each input vertex
for (unsigned int i = 0; i < in_vertices.size(); i++) {
// Try to find a similar vertex in out_vertices, out_uvs, out_normals, out_tangents & out_bitangents
unsigned int index;
bool found = getSimilarVertexIndex(in_vertices[i], in_uvs[i], in_normals[i], out_vertices, out_uvs, out_normals, index);
if (found) {
// A similar vertex is already in the VBO, use it instead !
out_indices.push_back(unsigned short(index));
// Average the tangents and the bitangents
out_tangents[index] += in_tangents[i];
out_bitangents[index] += in_bitangents[i];
} else {
// If not, it needs to be added in the output data.
out_vertices.push_back(in_vertices[i]);
out_uvs.push_back(in_uvs[i]);
out_normals.push_back(in_normals[i]);
out_tangents.push_back(in_tangents[i]);
out_bitangents.push_back(in_bitangents[i]);
out_indices.push_back((unsigned short)out_vertices.size() - 1);
}
count++;
}
}
और फिर 2 छोटे "सहायक" कार्यों का उपयोग करता है (isNear() तथा getSimilarVertexIndex()):
// Returns true if v1 can be considered equal to v2
bool is_near(float v1, float v2){
return fabs( v1-v2 ) < 0.01f;
}
bool getSimilarVertexIndex( glm::vec3 &in_vertex, glm::vec2 &in_uv, glm::vec3 &in_normal,
std::vector<glm::vec3> &out_vertices, std::vector<glm::vec2> &out_uvs, std::vector<glm::vec3> &out_normals,
unsigned int &result){
// Lame linear search
for (unsigned int i = 0; i < out_vertices.size(); i++) {
if (is_near(in_vertex.x, out_vertices[i].x) &&
is_near(in_vertex.y, out_vertices[i].y) &&
is_near(in_vertex.z, out_vertices[i].z) &&
is_near(in_uv.x, out_uvs[i].x) &&
is_near(in_uv.y, out_uvs[i].y) &&
is_near(in_normal.x, out_normals[i].x) &&
is_near(in_normal.y, out_normals[i].y) &&
is_near(in_normal.z, out_normals[i].z)
) {
result = i;
return true;
}
}
return false;
}
उपरोक्त कार्यों का सारा श्रेय निम्न को जाता है: http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-9-vbo-indexing/
क्या यह हो सकता है:
- विजुअल स्टूडियो कम्युनिटी 2015 का अंक?
- VSC15 डिबग मोड मुद्दा?
- धीमा कोड? (लेकिन यह केवल डिबग में धीमा है ?!)
उत्तर:
जवाब के लिए 3 № 1ऐसी कई चीजें हैं, जिन्हें अनुकूलित किया जा सकता है:
- सूचकांकों के साथ एक वेक्टर को पुनरावृत्त करना
[]पुनरावृत्तियों की तुलना में धीमी है; डिबग में, यह निश्चित रूप से दूर अनुकूलित नहीं है, लेकिन रिलीज में यह हो सकता है - इसके अलावा, के माध्यम से एक सदिश तक पहुँचने
[]डिबग मोड में होने पर रनटाइम चेक और डीबगिंग सुविधाओं के कारण धीमा है; जब आप इसे लागू करने के लिए जाते हैं तो यह काफी आसानी से देखा जा सकता हैoperator[] push_backतथाsizeरिलीज मोड का उपयोग करते समय गिरने की तुलना में कुछ अतिरिक्त जांचें भी हो सकती हैं
तो, मेरा मुख्य अनुमान यह होगा कि आप उपयोग करते हैं [] बहुत अधिक। जब आप वास्तविक पुनरावृत्तियों का उपयोग करके पुनरावृति को बदलते हैं तो यह रिलीज़ में और भी तेज़ हो सकता है। इसलिए, इसके बजाय:
for (unsigned int i = 0; i < in_vertices.size(); i++) {
उपयोग:
for(auto& vertex : in_vertices)
यह अप्रत्यक्ष रूप से पुनरावृत्तियों का उपयोग करता है। आप स्पष्ट रूप से लिख सकते हैं:
for(auto vertexIt = in_vertices.begin(); vertexIt != in_vertices.end(); ++vertexIt)
{
auto& vertex = *vertexIt;
जाहिर है, यह लंबा कोड है जो कम पठनीय लगता है और इसका कोई व्यावहारिक लाभ नहीं है, जब तक कि आपको कुछ अन्य कार्यों के लिए पुनरावृत्ति की आवश्यकता न हो।