Question

前几天我给你提了一个问题，我得到了一些非常有用的答案。我将向那些没有阅读过的人做一个总结，我将解释我的新疑点，以及我现在遇到问题的地方。

解释

我一直致力于一个程序，模拟一个小型数据库，首先从txt文件中读取信息并将它们存储在计算机内存中然后，我可以使用普通表和/或转置表进行查询。问题是性能还不够好。它的工作速度比我预期的要慢。我已经改进了它，但我认为我应该进一步改进它。我有特定点，我的程序没有很好的表现。

当前问题

我现在遇到的第一个问题（我的程序速度较慢）就是我花了更多的时间，比如10万列的表格和100行（0.325分钟，我已经通过你的帮助改善了这一点）超过100,000行＆amp; 100列（1.61198分钟，与之前相同）。但另一方面，对于某些数据的访问时间在第二种情况下更好（在一个确定的例子中，47秒与第一种情况下的6079秒）任何想法为什么??

解释

现在让我提醒您我的代码是如何工作的（使用我的代码的附加摘要）

首先，我有一个.txt文件模拟数据库表，其中随机字符串用“|”分隔。这里有一个表的例子（有7行和5列）。我也有转置表

的 NormalTable.txt 的

42sKuG^uM|24465\lHXP|2996fQo\kN|293cvByiV|14772cjZ`SN|
28704HxDYjzC|6869xXj\nIe|27530EymcTU|9041ByZM]I|24371fZKbNk|
24085cLKeIW|16945TuuU\Nc|16542M[Uz\|13978qMdbyF|6271ait^h|
13291_rBZS|4032aFqa|13967r^\\`T|27754k]dOTdh|24947]v_uzg|
1656nn_FQf|4042OAegZq|24022nIGz|4735Syi]\|18128klBfynQ|
6618t\SjC|20601S\EEp|11009FqZN|20486rYVPR|7449SqGC|
14799yNvcl|23623MTetGw|6192n]YU\Qe|20329QzNZO_|23845byiP|

TransposedTable.txt （这是上一篇文章中的新内容）

42sKuG^uM|28704HxDYjzC|24085cLKeIW|13291_rBZS|1656nn_FQf|6618t\SjC|14799yNvcl|
24465\lHXP|6869xXj\nIe|16945TuuU\Nc|4032aFqa|4042OAegZq|20601S\EEp|23623MTetGw|
2996fQo\kN|27530EymcTU|16542M[Uz\|13967r^\\`T|24022nIGz|11009FqZN|6192n]YU\Qe|
293cvByiV|9041ByZM]I|13978qMdbyF|27754k]dOTdh|4735Syi]\|20486rYVPR|20329QzNZO_|
14772cjZ`SN|24371fZKbNk|6271ait^h|24947]v_uzg|18128klBfynQ|7449SqGC|23845byiP|

解释

.txt文件中的此信息由我的程序读取并存储在计算机内存中。然后，在进行查询时，我将访问存储在计算机内存中的这些信息。将数据加载到计算机内存中可能是一个缓慢的过程，但稍后访问数据会更快，这对我来说真的很重要。

在这里，您可以获得从文件中读取此信息并存储在计算机中的部分代码。

从Table.txt文件中读取数据并将其存储在计算机内存中的代码

int h;
do
{
    cout<< "Do you want to query the normal table or the transposed table? (1- Normal table/ 2- Transposed table):" ;
    cin>>h; 
}while(h!=1 && h!=2);

string ruta_base("C:\\Users\\Raul Velez\\Desktop\\Tables\\");
if(h==1)
{
    ruta_base +="NormalTable.txt"; // Folder where my "Table.txt" is found
}

if(h==2)
{
    ruta_base +="TransposedTable.txt";
}

string temp; // Variable where every row from the Table.txt file will be firstly stored
vector<string> buffer; // Variable where every different row will be stored after separating the different elements by tokens.
vector<ElementSet> RowsCols; // Variable with a class that I have created, that simulated a vector and every vector element is a row of my table

ifstream ifs(ruta_base.c_str());
while(getline( ifs, temp )) // We will read and store line per line until the end of the ".txt" file. 
{
    size_t tokenPosition = temp.find("|"); // When we find the simbol "|" we will identify different element. So we separate the string temp into tokens that will be stored in vector<string> buffer
    // --- NEW PART ------------------------------------
    const char* p = temp.c_str();
    char* p1 = strdup(p);

    char* pch = strtok(p1, "|");
    while(pch)
    {
            buffer.push_back(string(pch));
            pch = strtok(NULL,"|");
    }
    free(p1);

    ElementSet sss(0,buffer);
    buffer.clear();
    RowsCols.push_back(sss); // We store all the elements of every row (stores as vector<string> buffer) in a different position in "RowsCols" 
    // --- NEW PART END ------------------------------------
}

Table TablesStorage(RowsCols); // After every loop we will store the information about every .txt file in the vector<Table> TablesDescriptor
vector<Table> TablesDescriptor;
TablesDescriptor.push_back(TablesStorage); // In the vector<Table> TablesDescriptor will be stores all the different tables with all its information

DataBase database(1, TablesDescriptor);

上一篇文章中已经提供的信息

此后，访问信息部分。我们假设我想进行查询，并要求输入。假设我的查询是行“n”，还有连续的元组“numTuples”和列“y”。（我们必须说列的数量由十进制数“y”定义，它将被转换为二进制并向我们显示要查询的列，例如，如果我要求列54（二进制的00110110）我将要求第2,3,5和6列。然后我访问计算机内存以获取所需信息并将其存储在vectorVector向量中。在这里，我将向您展示此代码的一部分。

问题在循环 if（h == 2）中，访问转置表中的数据，性能更差¿为什么？

在我输入时访问所需信息的代码

int n, numTuples; 
unsigned long long int y;

cout<< "Write the ID of the row you want to get more information: " ;
cin>>n; // We get the row to be represented -> "n"

cout<< "Write the number of followed tuples to be queried: " ;
cin>>numTuples; // We get the number of followed tuples to be queried-> "numTuples"

cout<<"Write the ID of the 'columns' you want to get more information: ";
cin>>y; // We get the "columns" to be represented ' "y"

unsigned int r; // Auxiliar variable for the columns path
int t=0; // Auxiliar variable for the tuples path
int idTable;

vector<int> columnsToBeQueried; // Here we will store the columns to be queried get from the bitset<500> binarynumber, after comparing with a mask
vector<string> shownVector; // Vector to store the final information from the query
bitset<5000> mask;
mask=0x1;

clock_t t1, t2;
t1=clock(); // Start of the query time

bitset<5000> binaryNumber = Utilities().getDecToBin(y); // We get the columns -> change number from decimal to binary. Max number of columns: 5000

// We see which columns will be queried
for(r=0;r<binaryNumber.size();r++) //
{               
    if(binaryNumber.test(r) & mask.test(r))  // if both of them are bit "1"
    {
        columnsToBeQueried.push_back(r);
    }
    mask=mask<<1;   
}

do
{
    for(int z=0;z<columnsToBeQueried.size();z++)
    {
        ElementSet selectedElementSet;
        int i;
        i=columnsToBeQueried.at(z);
        Table& selectedTable = database.getPointer().at(0); // It simmulates a vector with pointers to different tables that compose the database, but our example database only have one table, so don't worry ElementSet selectedElementSet;
        if(h == 1)
        {

            selectedElementSet=selectedTable.getRowsCols().at(n);
            shownVector.push_back(selectedElementSet.getElements().at(i)); // We save in the vector shownVector the element "i" of the row "n"
        }

        if(h == 2)  
        {
            selectedElementSet=selectedTable.getRowsCols().at(i);
            shownVector.push_back(selectedElementSet.getElements().at(n)); // We save in the vector shownVector the element "n" of the row "i"
        }
        n=n+1;
        t++;            
    }
}while(t<numTuples);

t2=clock(); // End of the query time
showVector().finalVector(shownVector);
float diff ((float)t2-(float)t1);
float microseconds = diff / CLOCKS_PER_SEC*1000000;
cout<<"Time: "<<microseconds<<endl;

课程定义

这里我附上了一些类定义，以便您可以编译代码，并更好地了解它的工作原理：

class ElementSet
{
private:
    int id;
    vector<string> elements; 

public:
    ElementSet(); 
    ElementSet(int, vector<string>&); 

    const int& getId();
    void setId(int);

    const vector<string>& getElements();
    void setElements(vector<string>);

};

class Table
{
private:
    vector<ElementSet> RowsCols; 

public:
    Table(); 
    Table(vector<ElementSet>&); 

    const vector<ElementSet>& getRowsCols();
    void setRowsCols(vector<ElementSet>);
};


class DataBase
{
     private:
        int id;
        vector<Table> pointer; 

     public:
        DataBase(); 
        DataBase(int, vector<Table>&); 

    const int& getId();
    void setId(int);

    const vector<Table>& getPointer();
    void setPointer(vector<Table>);

    };

class Utilities
{
        public:
        Utilities();
        static bitset<500> getDecToBin(unsigned long long int);
};

我的问题摘要

为什么数据的加载因表格式而异？
为什么对信息的访问也取决于表（并且性能与表数据加载相反？

非常感谢你的帮助！：）

Answer 1

我看到的一件事可以解释你的问题是你做了很多分配，其中很多似乎是暂时的。例如，在您加载时：

每行分配一个临时字符串
每列分配一个临时字符串
将行复制到临时ElementSet
将其复制到RowSet
将RowSet复制到表
将表复制到TableDescriptor
将TableDescriptor复制到数据库

据我所知，这些副本中的每一个都是该对象的完整新副本。如果您只有几条100或1000条记录可能没问题，但在您的情况下，您有1000万条记录，因此副本将非常耗时。

由于每行和每列的加载循环中完成的分配数量，您的加载时间可能会有所不同。内存碎片也可能在某些时候有所贡献（当处理大量小分配时，默认内存处理程序有时需要很长时间来分配新内存）。即使您删除了所有不必要的分配，我仍然希望100列案例比100,000案例略慢，因为您的加载和解析是按行进行的。

您在selectedElementSet中创建行的完整副本时，您的信息访问时间可能会有所不同。如果你有100列，这将是快速的，但当你有100,000列时，它会很慢。

有关改进代码的一些具体建议：

减少您的分配和副本数量。理想的情况是在读取文件时进行一次分配，然后在存储时为每条记录进行另一次分配。
如果您要将数据存储在Database中，请将其从头开始存放。不要将数据的半打完整副本从临时对象转到数据库。
尽可能使用对数据的引用而不是实际副本。
进行性能分析时，请确保在运行程序的新实例时获得时间。如果您在同一个实例中测试这两种情况，并且执行测试的顺序很重要，则内存使用和碎片可能会产生重大影响。

修改：代码建议希望在搜索循环中提高你的速度，尝试类似：

for(int z=0;z<columnsToBeQueried.size();z++)
    {
        int i;
        i=columnsToBeQueried.at(z);
        Table& selectedTable = database.getPointer().at(0);

        if(h == 1)
        {
            ElementSet& selectedElementSet = selectedTable.getRowsCols().at(n);
            shownVector.push_back(selectedElementSet.getElements().at(i));
        }
        else if(h == 2)  
        {
            ElementSet& selectedElementSet = selectedTable.getRowsCols().at(i);
            shownVector.push_back(selectedElementSet.getElements().at(n));
        }

        n=n+1;
        t++;            
    }

我刚刚更改了selectedElementSet以使用一个引用，该引用应该完全消除正在发生的行副本，理论上它应该对性能产生明显的影响。为了获得更高的性能提升，您可以将shownVector更改为引用/指针以避免另一个副本。

编辑：回复评论

你问你在哪里制作副本。原始代码中的以下行：

ElementSet selectedElementSet;
selectedElementSet = selectedTable.getRowsCols().at(n);

在vector<string> elements中创建ElementSet成员的副本。在100,000列的情况下，这将是一个包含100,000个字符串的向量，因此副本的时间相对较长。由于您实际上不需要创建新的副本，因此将selectedElementSet更改为引用，就像我上面的示例代码一样，将删除此副本。

优化模拟数据库的代码（2）

1 个答案: