试图并行化我的代码,但是当我 运行 它时,它永远不会给出正确的输出
trying to parallelize my code however when I run it, it never gives the correct output
我有一个程序可以初始化一个大小为 1,000,000 的向量,然后找到其中的所有素数。质数存储在一个新向量中,然后我遍历该向量并尝试在其中找到所有快乐的数字。我正在尝试使用任务并行性在 2 个线程之间拆分工作,但是我从来没有 return 任何输出。这是一个快乐数字的定义一个快乐数字是由以下过程定义的数字:从任何正整数开始,用其数字的平方和替换该数字,并重复该过程直到该数字等于 1 (它会停留的地方),或者它在一个不包括 1 的循环中无限循环。这个过程以 1 结尾的数字是快乐的数字,而那些不以 1 结尾的数字是不快乐的数字(或悲伤的数字)。
#include <omp.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include<bits/stdc++.h>
#include<vector>
#include<numeric>
using namespace std;
void funcA();
void funcB();
int squaresum(int n){
int sum=0;
while(n){
int d=n%10;
sum+=d*d;
n=n/10;
}
return sum;
}
bool ishappy(int n){
set<int> s;
s.insert(n);
while(1){
if(n==1) return true;
n=squaresum(n);
if(s.find(n)!=s.end()) return false;
s.insert(n);
}
return false;
}
bool isprime(int n)
{
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
int getHappyCount(int start, int size, int& happy)
{
int holder = size;
vector<int> num(size);
for(int i=start;i<start+size;i++) num[i]=i+1;
vector<int> prime;
for(int i=0;i<holder;i++)
{
if(isprime(num[i])) prime.push_back(num[i]);
}
int count=0;
for(int i=0;i<prime.size();i++)
{
if(ishappy(prime[i])) count++;
}
#pragma omp atomic
happy += count;
}
int main()
{
int happy = 0;
#pragma omp parallel num_threads(2)
{
#pragma omp sections
{
#pragma omp section
{
(void) getHappyCount(0, 500000, happy);
printf("there are %d happy prime numbers \n", happy);
}
#pragma omp section
{
(void) getHappyCount(500000, 500000, happy);
printf("there are %d happy prime numbers \n", happy);
}
}
}
printf("there are %d happy prime numbers \n", happy);
return 0;
}
vector<int> num(size);
for (int i = start; i < start + size; i++)
num[i] = i + 1;
这显然是错误的,除非 start
为零。在所有其他情况下,num[i]
会导致对 num
向量的越界访问。您可以切换到,例如:
for (int i = 0; i < size; i++)
num[i] = start + i + 1;
此外,getHappyCount
正文中缺少 return
语句意味着未定义的行为。在明确抑制警告之前,您应该学会理解警告。只需将 return 类型更改为 void
或 return 即可。
我有一个程序可以初始化一个大小为 1,000,000 的向量,然后找到其中的所有素数。质数存储在一个新向量中,然后我遍历该向量并尝试在其中找到所有快乐的数字。我正在尝试使用任务并行性在 2 个线程之间拆分工作,但是我从来没有 return 任何输出。这是一个快乐数字的定义一个快乐数字是由以下过程定义的数字:从任何正整数开始,用其数字的平方和替换该数字,并重复该过程直到该数字等于 1 (它会停留的地方),或者它在一个不包括 1 的循环中无限循环。这个过程以 1 结尾的数字是快乐的数字,而那些不以 1 结尾的数字是不快乐的数字(或悲伤的数字)。
#include <omp.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include<bits/stdc++.h>
#include<vector>
#include<numeric>
using namespace std;
void funcA();
void funcB();
int squaresum(int n){
int sum=0;
while(n){
int d=n%10;
sum+=d*d;
n=n/10;
}
return sum;
}
bool ishappy(int n){
set<int> s;
s.insert(n);
while(1){
if(n==1) return true;
n=squaresum(n);
if(s.find(n)!=s.end()) return false;
s.insert(n);
}
return false;
}
bool isprime(int n)
{
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
int getHappyCount(int start, int size, int& happy)
{
int holder = size;
vector<int> num(size);
for(int i=start;i<start+size;i++) num[i]=i+1;
vector<int> prime;
for(int i=0;i<holder;i++)
{
if(isprime(num[i])) prime.push_back(num[i]);
}
int count=0;
for(int i=0;i<prime.size();i++)
{
if(ishappy(prime[i])) count++;
}
#pragma omp atomic
happy += count;
}
int main()
{
int happy = 0;
#pragma omp parallel num_threads(2)
{
#pragma omp sections
{
#pragma omp section
{
(void) getHappyCount(0, 500000, happy);
printf("there are %d happy prime numbers \n", happy);
}
#pragma omp section
{
(void) getHappyCount(500000, 500000, happy);
printf("there are %d happy prime numbers \n", happy);
}
}
}
printf("there are %d happy prime numbers \n", happy);
return 0;
}
vector<int> num(size);
for (int i = start; i < start + size; i++)
num[i] = i + 1;
这显然是错误的,除非 start
为零。在所有其他情况下,num[i]
会导致对 num
向量的越界访问。您可以切换到,例如:
for (int i = 0; i < size; i++)
num[i] = start + i + 1;
此外,getHappyCount
正文中缺少 return
语句意味着未定义的行为。在明确抑制警告之前,您应该学会理解警告。只需将 return 类型更改为 void
或 return 即可。