Question

我在文本文件values.txt中逐行生成了16 0和16 1的所有32位排列。例如 -

00000000000000001111111111111111
00000000000000010111111111111111
00000000000000011011111111111111
00000000000000011101111111111111

依旧......

让我们考虑一下文本文件的每一行都是一个布尔函数。我需要在域中检查此功能的可逆性。

为此，我从文本文件中拾取第一行并将其存储到维度为32x1，矩阵a [] []的列矩阵中。

在嵌套的for循环中我基本上以3x3矩阵的形式生成域值，我需要检查函数的可逆性。我创建了一个维度3x3的矩阵g [] []，它将存储所有no的二进制表示。从1到2 ^ 9。例如- 对于0矩阵g看起来像 -

0 0 0
0 0 0
0 0 0

为1，矩阵g为 -

0 0 0 
0 0 0
0 0 1

对于2个矩阵g将是

0 0 0
0 0 0
0 1 0

依此类推2 ^ 9。

对于上面从0到2 ^ 9生成的每个矩阵，我正在根据我的函数计算维度3x3的新矩阵u [] []。这是通过读取矩阵的每个元素的5个相邻值来完成的。

例如 - 考虑g矩阵

0 0 0
0 1 1
1 0 0

我拾取第一个元素，即g [0] [0]，使用五个相邻值（顶值，左值，元素本身，右值，低于值）计算一个新值，即g [2 ] [0]，G [0] [2]，G [0] [0]，G [0] [1]，G [1] [0]。这5个没有。合并代表二进制否。我计算它的十进制等值，十进制值对应于行号。矩阵a [] []，我必须更新u [0] [0]的值。我将对g的每个元素重复上述过程，最终将得到一个3x3的u矩阵。

这个完整的过程是针对一个矩阵，它的矩阵对应于0。像这样对于从0到2 ^ 9的每个g [] []矩阵，我将创建2 ^ 9个矩阵。

在任何时间点，如果对于两个矩阵g [] []，矩阵u [] []恰好相同我中止函数，读取第二行文本文件并再次开始上述过程，即I对导致重复矩阵的函数不感兴趣。如果所有2 ^ 9矩阵碰巧都不同，我将相应函数的值（文本文件中的行）写入另一个文本文件。

因此，总而言之，我需要为整体计算创建总计60亿* 2 ^ 9的矩阵。

问题是，对于文本文件中的特定函数，2 ^ 9矩阵是单独计算的。如果我能以某种方式将它们并行化，我会大大减少计算时间......

#include <algorithm>
#include <fstream>
#include <iostream>
#include <string>
#include <math.h>
using namespace std;
#include <boost/multiprecision/cpp_int.hpp>
using namespace boost::multiprecision;
#include <boost/lexical_cast.hpp>
#include <cctype>
#include <boost/assign/list_of.hpp>
#include <set>
#include <stdint.h>
#include <omp.h>
#define convertToString(x) #x
using namespace boost::assign;

int main()
{
    ifstream infile;
    infile.open("values.txt");
    ofstream outfile;
    outfile.open("haha.txt");
    short a[32][1];
    while(!infile.eof())
    {
        string STRING;
        getline(infile,STRING);
        set<string> SET;
        int count=0;


        for(int i=0;i<32;i++)
        {
                a[i][0]=STRING.at(i)-'0';
        }


        int g[9];
        int u[9];
        char buffer[10];
        buffer[9] = 0;
        uint16_t f = 0;

        int max = (int)pow(2,3);


        for(int r=0;r<max && count!=1;r++)
        {
           for(int s=0;s<max && count!=1;s++)
           {
              for(int t=0;t<max && count!=1;t++)
              {
                for(int i = 0; i < 9; ++i)
                {
                   g[i] = (f & (1 << (8 - i))) != 0;
                }
                ++f;

                u[0]=a[(g[6]*2*2*2*2)+(g[2]*2*2*2)+(g[0]*2*2)+(g[1]*2)+(g[3]*1)][0];
                u[1]=a[(g[7]*2*2*2*2)+(g[0]*2*2*2)+(g[1]*2*2)+(g[2]*2)+(g[4]*1)][0];
                u[2]=a[(g[8]*2*2*2*2)+(g[1]*2*2*2)+(g[2]*2*2)+(g[0]*2)+(g[5]*1)][0];
                u[3]=a[(g[0]*2*2*2*2)+(g[5]*2*2*2)+(g[3]*2*2)+(g[4]*2)+(g[6]*1)][0];
                u[4]=a[(g[1]*2*2*2*2)+(g[3]*2*2*2)+(g[4]*2*2)+(g[5]*2)+(g[7]*1)][0];
                u[5]=a[(g[2]*2*2*2*2)+(g[4]*2*2*2)+(g[5]*2*2)+(g[3]*2)+(g[8]*1)][0];
                u[6]=a[(g[3]*2*2*2*2)+(g[8]*2*2*2)+(g[6]*2*2)+(g[7]*2)+(g[0]*1)][0];
                u[7]=a[(g[4]*2*2*2*2)+(g[6]*2*2*2)+(g[7]*2*2)+(g[8]*2)+(g[1]*1)][0];
                u[8]=a[(g[5]*2*2*2*2)+(g[7]*2*2*2)+(g[8]*2*2)+(g[6]*2)+(g[2]*1)][0];


                for(int i = 0; i < 9; ++i)
                {
                   buffer[i] = '0' + u[i];
                }
                if(!SET.insert(::std::string(buffer)).second)
                {
                   count = 1;
                }
             }
          }
        }

        if(count==0)
        {
            outfile<<STRING<<"\n";
            cout<<STRING<<"\n";
        }


    }
        infile.close();
        outfile.close();
        return 0;
    }

Answer 1

当第二维只有1时，不需要使用二维数组。只需定义一个[32]并在访问数组的任何地方省略第二个索引运算符（[0]）（可能只会提高可读性，我希望编译器无论如何都可以优化它 - 但是你可以安全地使用它。）

你的转换函数是无效的，每次在字符串前面都会先创建一个新的字符串对象。在这样的缓冲区中执行一次：

char buffer[10];
buffer[9] = 0;
for(int i = 0; i < 9; ++i)
{
    buffer[i] = '0' + ((dec & (1 << (8 - i))) != 0);
}
return ::std::string(buffer);

是否有任何理由只能输出9位而不是全部16位？

循环中你的u数组相同......

高一级：

string binary=in.convert(f++);

for(int i=0;i<9;i++)
    g[i]=binary.at(i)-'0';

您首先转换了一个字符串，然后将其转换回数字？为什么不将数组传递给你的转换函数并直接赋值（0和1，而不是'0'和'1'）？

您只在一个地方使用转换功能 - 也许您想让它内联。至少，使它成为静态，因为它不依赖于任何类成员（如果没有其他成员函数，则更具有名称空间而不是类）。

编辑：我允许简单地内联整个内容（遗漏了pragma）：

int g[9];
int u[9];
char buffer[10];
buffer[9] = 0;
uint16_t f = 0;

int max = (int)pow(2,3);
for(int r=0;r<max;r++
{
    for(int s=0;s<max;s++)
    {
        for(int t=0;t<max;t++)
        {
            for(int i = 0; i < 9; ++i)
            {
                g[i] = (f & (1 << (8 - i))) != 0;
            }
            ++f;
            /* calculate the u array here */
            for(int i = 0; i < 9; ++i)
            {
                buffer[i] = '0' + (u[i] != 0);
            }
            if(!SET.insert(::std::string(buffer)).second)
            {
                count = 1;
            }
        }
    }
}

预先计算了功率，不确定编译器是否会优化它...

如果你的u和g数组使用大小与CPU寄存器大小相匹配的整数类型，你可能会获得额外的性能提升......

您没有检查数组a可以获得哪些值。可能，任何人都可能。如果您保证这些值始终只为0或1，您甚至可以将代码缩短到最低程度：

buffer[i] = '0' + u[i];

提早离开你的圈子：

#pragma omp parallel
{
    for(int r=0;r<(int)pow(2,3);r++)
    {
        for(int s=0;s<(int)pow(2,3);s++)
        {
            #pragma omp parallel for shared(SET,count,f)
            for(int t=0;t<(int)pow(2,3);t++)
            {
                /* ... */
                    count = 1;
                    goto EndOfLoop;
                /* ... */
            }
        }
    }
    :EndOfLoop;
}

"It is illegal to branch (goto) into or out of a parallel region"，但不在其中，正如我读到的那样......变体将是

for(int r=0; count == 0 && r<(int)pow(2,3);r++)

对于所有三个循环，但这些额外的if成本绩效...

需要帮助使用openmp并行化C ++代码

1 个答案: