learning-process / ppc-2024-threads Goto Github PK

View Code? Open in Web Editor NEW

2.0 2.0 132.0 9.76 MB

License: BSD 3-Clause "New" or "Revised" License

CMake 0.32% C++ 99.52% Python 0.09% Batchfile 0.02% Shell 0.06%

ppc-2024-threads's People

Contributors

Stargazers

Watchers

Forkers

mahbhlddnhakkh manymoera atikin-nt aleksandreremin arkostaa avezorgen kirill23323 evldn nikitakorablev namxobick sturmannn mineshadow7 awenger444 lxvdnl leakmachine catk1ller007 amazingkivas oleg-w570 romanmitin kryacki ssuren4ik petrbonyuk alexandervladislavovich nastosimys stepa123de soileks aartyomm smirnovlm spells39 firststep0 ualex322 shlera04 gr0mila savotina pozvas at0mn1yivan oleg212 neotouch1 dochkavurdalaka egorkosarevv frenetz morgachevstepan nol0n damlrca mada40 jankoz mishaizlesa archimikael ismukhin zhatkinvyacheslav yourd8ne dnoniel-ermolaev kriseevm aaldebarann nik-se0 mortus19 agentv0 v-intim overinvest alexey131313 isk7 instmois un1i sokolovadaria tmworking krllvv dmitry-vnn kasimtcevroman katrin000 crazy767 igorkonovalovaleks bliiinch slx52 ionovva nastyamortina hugelka andrewstiks dipirs lesnikowka marissa696 adandroll threetoads jkurdina safarov-nm 2nyt veto1234-ii karrin0chka smdar1a alexfrom38 muuja maximkaloginov relby luchshiy-shmel alesyacurtis 4isper geronlmo firstbourne vyunolbek faert tatiana567

ppc-2024-threads's Issues

add information about github issues if exist bug

Possible infinite loop in the test in the master branch

ppc-2024-threads/tasks/omp/dostavalov_s_sop_gradient/src/ops_omp.cpp

Lines 93 to 142 in 91f2cca

    
             while (true) { 
        
               std::vector<double> A_Dir(size, 0.0); 
        
           #pragma omp parallel for shared(matrix_ptr, direction, A_Dir) 
        
               for (long i = 0; i < size; ++i) { 
        
                 for (long j = 0; j < size; ++j) { 
        
                   A_Dir[i] += matrix_ptr[i * size + j] * direction[j]; 
        
                 } 
        
               } 
        
               double residual_dot_residual = 0.0; 
        
               double A_Dir_dot_direction = 0.0; 
        
           #pragma omp parallel for reduction(+ : residual_dot_residual, A_Dir_dot_direction) 
        
               for (long i = 0; i < size; ++i) { 
        
                 residual_dot_residual += residual[i] * residual[i]; 
        
                 A_Dir_dot_direction += A_Dir[i] * direction[i]; 
        
               } 
        
               double alpha = residual_dot_residual / A_Dir_dot_direction; 
        
           #pragma omp parallel for 
        
               for (long i = 0; i < static_cast<long>(result.size()); ++i) { 
        
                 result[i] += alpha * direction[i]; 
        
               } 
        
           #pragma omp parallel for 
        
               for (long i = 0; i < static_cast<long>(residual.size()); ++i) { 
        
                 residual[i] = prev_residual[i] - alpha * A_Dir[i]; 
        
               } 
        
               double new_residual = 0.0; 
        
           #pragma omp parallel for reduction(+ : new_residual) 
        
               for (long i = 0; i < static_cast<long>(residual.size()); ++i) { 
        
                 new_residual += residual[i] * residual[i]; 
        
               } 
        
               if (sqrt(new_residual) < TOLERANCE) { 
        
                 break; 
        
               } 
        
               double beta = new_residual / residual_dot_residual; 
        
           #pragma omp parallel for 
        
               for (long i = 0; i < size; ++i) { 
        
                 direction[i] = residual[i] + beta * direction[i]; 
        
               } 
        
               prev_residual = residual; 
        
             }

The code can be executed indefinitely or for a very long time due to the fact that the matrix consists of random numbers and as a result of errors in rounding floating-point numbers.

Code added in #284.

Cppcheck >= 2.11 crashes build on missingInclude parameter.

Head of the Issue

Build crashes using Cppcheck newest versions.

Expected behavior

No crash on Building tasks and modules.

Description

On Unix-based systems if building using newer packages of Cppcheck (>= 2.11) project crashes because it searches for include files and fails for some reason.
This might be happening because since Cppcheck version 2.11 :

"missingInclude" and "missingIncludeSystem" are reported with "-j" is > 1 and processes are used in the backend (default in non-Windows binaries).

And

"missingInclude" and "missingIncludeSystem" will now cause the "--error-exitcode" to be applied.

Suggested fixes

In cmake configure.cmake file for UNIX Cppcheck MACRO set parameter

--disable=missingInclude

To disable missingInclude checks parameter.

HW/SW Specifications tested on:

System: x86_64 Arch Linux on 6.8.5-arch1-1 (64-bit)
Project version: Any latest main branch.
Cppcheck version: 2.12.0
GCC version: gcc (GCC) 13.2.1 20230801
Clang Version: clang version 17.0.6

learning-process / ppc-2024-threads Goto Github PK

ppc-2024-threads's People

Contributors

Stargazers

Watchers

Forkers

ppc-2024-threads's Issues

add information about github issues if exist bug

Possible infinite loop in the test in the master branch

Cppcheck >= 2.11 crashes build on missingInclude parameter.

Head of the Issue

Expected behavior

Description

Suggested fixes

write about data in perf tests in readme

add information about namespace

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent

	while (true) {
	std::vector<double> A_Dir(size, 0.0);

	#pragma omp parallel for shared(matrix_ptr, direction, A_Dir)
	for (long i = 0; i < size; ++i) {
	for (long j = 0; j < size; ++j) {
	A_Dir[i] += matrix_ptr[i * size + j] * direction[j];
	}
	}

	double residual_dot_residual = 0.0;
	double A_Dir_dot_direction = 0.0;

	#pragma omp parallel for reduction(+ : residual_dot_residual, A_Dir_dot_direction)
	for (long i = 0; i < size; ++i) {
	residual_dot_residual += residual[i] * residual[i];
	A_Dir_dot_direction += A_Dir[i] * direction[i];
	}

	double alpha = residual_dot_residual / A_Dir_dot_direction;

	#pragma omp parallel for
	for (long i = 0; i < static_cast<long>(result.size()); ++i) {
	result[i] += alpha * direction[i];
	}

	#pragma omp parallel for
	for (long i = 0; i < static_cast<long>(residual.size()); ++i) {
	residual[i] = prev_residual[i] - alpha * A_Dir[i];
	}

	double new_residual = 0.0;
	#pragma omp parallel for reduction(+ : new_residual)
	for (long i = 0; i < static_cast<long>(residual.size()); ++i) {
	new_residual += residual[i] * residual[i];
	}

	if (sqrt(new_residual) < TOLERANCE) {
	break;
	}

	double beta = new_residual / residual_dot_residual;

	#pragma omp parallel for
	for (long i = 0; i < size; ++i) {
	direction[i] = residual[i] + beta * direction[i];
	}

	prev_residual = residual;
	}