ForkMaster/netgen
1
0
Fork 0
mirror of https://github.com/NGSolve/netgen.git synced 2025-02-06 09:44:17 +05:00
Code Issues Packages Projects Releases Wiki Activity

wip - compile for non-x86 arch

Browse Source
This commit is contained in:
Matthias Hochsteger 2020-11-24 15:24:27 +01:00
parent e7b9baa93b
commit e545cfbbda
9 changed files with 262 additions and 248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
CMakeLists.txt
View File

@ -196,6 +196,7 @@ if(HAVE_DLFCN_H)
endif() endif()
include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR}) include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR})
include_directories(BEFORE /usr/aarch64-linux-gnu/include)
####################################################################### #######################################################################
# platform specific definitions and flags # platform specific definitions and flags
@ -214,6 +215,8 @@ macro(get_dll_from_lib dll_path lib_path)
endmacro() endmacro()
set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD 17)
set(CXX_EXTENSIONS OFF)
set(CMAKE_CXX_EXTENSIONS OFF)
if(WIN32) if(WIN32)
set(CMAKE_MFC_FLAG 0) set(CMAKE_MFC_FLAG 0)
# build convenience (aka object) libraries in windows) # build convenience (aka object) libraries in windows)
@ -230,7 +233,7 @@ endif(APPLE)
if(NOT ZLIB_INCLUDE_DIRS) if(NOT ZLIB_INCLUDE_DIRS)
find_package(ZLIB REQUIRED) find_package(ZLIB REQUIRED)
endif(NOT ZLIB_INCLUDE_DIRS) endif(NOT ZLIB_INCLUDE_DIRS)
include_directories(${ZLIB_INCLUDE_DIRS}) # include_directories(${ZLIB_INCLUDE_DIRS})
####################################################################### #######################################################################
if (USE_GUI) if (USE_GUI)

8
libsrc/core/taskmanager.cpp
View File

@ -201,14 +201,16 @@ namespace ngcore
; ;
} }
static size_t calibrate_init_tsc = __rdtsc(); static size_t calibrate_init_tsc = 0;
// static size_t calibrate_init_tsc = __rdtsc();
typedef std::chrono::system_clock TClock; typedef std::chrono::system_clock TClock;
static TClock::time_point calibrate_init_clock = TClock::now(); static TClock::time_point calibrate_init_clock = TClock::now();
void TaskManager :: StopWorkers() void TaskManager :: StopWorkers()
{ {
done = true; done = true;
double delta_tsc = __rdtsc()-calibrate_init_tsc; double delta_tsc = 0-calibrate_init_tsc;
// double delta_tsc = __rdtsc()-calibrate_init_tsc;
double delta_sec = std::chrono::duration<double>(TClock::now()-calibrate_init_clock).count(); double delta_sec = std::chrono::duration<double>(TClock::now()-calibrate_init_clock).count();
double frequ = (delta_sec != 0) ? delta_tsc/delta_sec : 2.7e9; double frequ = (delta_sec != 0) ? delta_tsc/delta_sec : 2.7e9;
@ -421,7 +423,7 @@ namespace ngcore
if (workers_on_node[j]) if (workers_on_node[j])
{ {
while (complete[j] != jobnr) while (complete[j] != jobnr)
_mm_pause(); ; // _mm_pause();
} }
func = nullptr; func = nullptr;

8
libsrc/core/utils.hpp
View File

@ -8,11 +8,13 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
/*
#ifdef WIN32 #ifdef WIN32
#include <intrin.h> // for __rdtsc() CPU time step counter #include <intrin.h> // for __rdtsc() CPU time step counter
#else #else
#include <x86intrin.h> // for __rdtsc() CPU time step counter #include <x86intrin.h> // for __rdtsc() CPU time step counter
#endif // WIN32 #endif // WIN32
*/
#include "ngcore_api.hpp" // for NGCORE_API #include "ngcore_api.hpp" // for NGCORE_API
@ -52,7 +54,9 @@ namespace ngcore
inline TTimePoint GetTimeCounter() noexcept inline TTimePoint GetTimeCounter() noexcept
{ {
return TTimePoint(__rdtsc()); // return TTimePoint(__rdtsc());
// return TTimePoint(__builtin_readcyclecounter());
return TTimePoint(0);
} }
template <class T> template <class T>
@ -161,7 +165,7 @@ namespace ngcore
while (!m.compare_exchange_weak(should, true)) while (!m.compare_exchange_weak(should, true))
{ {
should = false; should = false;
_mm_pause(); // _mm_pause();
} }
} }
void unlock() void unlock()

324
libsrc/general/gzstream.cpp
View File

@ -1,167 +1,167 @@
// ============================================================================ // // ============================================================================
// gzstream, C++ iostream classes wrapping the zlib compression library. // // gzstream, C++ iostream classes wrapping the zlib compression library.
// Copyright (C) 2001 Deepak Bandyopadhyay, Lutz Kettner // // Copyright (C) 2001 Deepak Bandyopadhyay, Lutz Kettner
// //
// // This library is free software; you can redistribute it and/or
// // modify it under the terms of the GNU Lesser General Public
// // License as published by the Free Software Foundation; either
// // version 2.1 of the License, or (at your option) any later version.
// //
// // This library is distributed in the hope that it will be useful,
// // but WITHOUT ANY WARRANTY; without even the implied warranty of
// // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// // Lesser General Public License for more details.
// //
// // You should have received a copy of the GNU Lesser General Public
// // License along with this library; if not, write to the Free Software
// // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
// // ============================================================================
// //
// // File : gzstream.C
// // Revision : $Revision: 1.7 $
// // Revision_date : $Date: 2003/01/08 14:41:27 $
// // Author(s) : Deepak Bandyopadhyay, Lutz Kettner
// //
// // Standard streambuf implementation following Nicolai Josuttis, "The
// // Standard C++ Library".
// // ============================================================================
// //
// This library is free software; you can redistribute it and/or // #include <mystdlib.h>
// modify it under the terms of the GNU Lesser General Public // #include <myadt.hpp>
// License as published by the Free Software Foundation; either // //#include "gzstream.h"
// version 2.1 of the License, or (at your option) any later version. // //#include <iostream>
// //#include <string.h> // for memcpy
// //
// This library is distributed in the hope that it will be useful, // #ifdef GZSTREAM_NAMESPACE
// but WITHOUT ANY WARRANTY; without even the implied warranty of // namespace GZSTREAM_NAMESPACE {
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // #endif
// Lesser General Public License for more details.
// //
// You should have received a copy of the GNU Lesser General Public // // ----------------------------------------------------------------------------
// License along with this library; if not, write to the Free Software // // Internal classes to implement gzstream. See header file for user classes.
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // // ----------------------------------------------------------------------------
// ============================================================================
// //
// File : gzstream.C // // --------------------------------------
// Revision : $Revision: 1.7 $ // // class gzstreambuf:
// Revision_date : $Date: 2003/01/08 14:41:27 $ // // --------------------------------------
// Author(s) : Deepak Bandyopadhyay, Lutz Kettner
// //
// Standard streambuf implementation following Nicolai Josuttis, "The // gzstreambuf* gzstreambuf::open( const char* name, int open_mode) {
// Standard C++ Library". // if ( is_open())
// ============================================================================ // return (gzstreambuf*)0;
// mode = open_mode;
#include <mystdlib.h> // // no append nor read/write mode
#include <myadt.hpp> // if ((mode & std::ios::ate) || (mode & std::ios::app)
//#include "gzstream.h" // || ((mode & std::ios::in) && (mode & std::ios::out)))
//#include <iostream> // return (gzstreambuf*)0;
//#include <string.h> // for memcpy // char fmode[10];
// char* fmodeptr = fmode;
#ifdef GZSTREAM_NAMESPACE // if ( mode & std::ios::in)
namespace GZSTREAM_NAMESPACE { // *fmodeptr++ = 'r';
#endif // else if ( mode & std::ios::out)
// *fmodeptr++ = 'w';
// ---------------------------------------------------------------------------- // *fmodeptr++ = 'b';
// Internal classes to implement gzstream. See header file for user classes. // *fmodeptr = '\0';
// ---------------------------------------------------------------------------- // file = gzopen( name, fmode);
// if (file == 0)
// -------------------------------------- // return (gzstreambuf*)0;
// class gzstreambuf: // opened = 1;
// -------------------------------------- // return this;
// }
gzstreambuf* gzstreambuf::open( const char* name, int open_mode) { //
if ( is_open()) // gzstreambuf * gzstreambuf::close() {
return (gzstreambuf*)0; // if ( is_open()) {
mode = open_mode; // sync();
// no append nor read/write mode // opened = 0;
if ((mode & std::ios::ate) || (mode & std::ios::app) // if ( gzclose( file) == Z_OK)
|| ((mode & std::ios::in) && (mode & std::ios::out))) // return this;
return (gzstreambuf*)0; // }
char fmode[10]; // return (gzstreambuf*)0;
char* fmodeptr = fmode; // }
if ( mode & std::ios::in) //
*fmodeptr++ = 'r'; // int gzstreambuf::underflow() { // used for input buffer only
else if ( mode & std::ios::out) // if ( gptr() && ( gptr() < egptr()))
*fmodeptr++ = 'w'; // return * reinterpret_cast<unsigned char *>( gptr());
*fmodeptr++ = 'b'; //
*fmodeptr = '\0'; // if ( ! (mode & std::ios::in) || ! opened)
file = gzopen( name, fmode); // return EOF;
if (file == 0) // // Josuttis' implementation of inbuf
return (gzstreambuf*)0; // int n_putback = gptr() - eback();
opened = 1; // if ( n_putback > 4)
return this; // n_putback = 4;
} // memcpy( buffer + (4 - n_putback), gptr() - n_putback, n_putback);
//
gzstreambuf * gzstreambuf::close() { // int num = gzread( file, buffer+4, bufferSize-4);
if ( is_open()) { // if (num <= 0) // ERROR or EOF
sync(); // return EOF;
opened = 0; //
if ( gzclose( file) == Z_OK) // // reset buffer pointers
return this; // setg( buffer + (4 - n_putback), // beginning of putback area
} // buffer + 4, // read position
return (gzstreambuf*)0; // buffer + 4 + num); // end of buffer
} //
// // return next character
int gzstreambuf::underflow() { // used for input buffer only // return * reinterpret_cast<unsigned char *>( gptr());
if ( gptr() && ( gptr() < egptr())) // }
return * reinterpret_cast<unsigned char *>( gptr()); //
// int gzstreambuf::flush_buffer() {
if ( ! (mode & std::ios::in) || ! opened) // // Separate the writing of the buffer from overflow() and
return EOF; // // sync() operation.
// Josuttis' implementation of inbuf // int w = pptr() - pbase();
int n_putback = gptr() - eback(); // if ( gzwrite( file, pbase(), w) != w)
if ( n_putback > 4) // return EOF;
n_putback = 4; // pbump( -w);
memcpy( buffer + (4 - n_putback), gptr() - n_putback, n_putback); // return w;
// }
int num = gzread( file, buffer+4, bufferSize-4); //
if (num <= 0) // ERROR or EOF // int gzstreambuf::overflow( int c) { // used for output buffer only
return EOF; // if ( ! ( mode & std::ios::out) || ! opened)
// return EOF;
// reset buffer pointers // if (c != EOF) {
setg( buffer + (4 - n_putback), // beginning of putback area // *pptr() = c;
buffer + 4, // read position // pbump(1);
buffer + 4 + num); // end of buffer // }
// if ( flush_buffer() == EOF)
// return next character // return EOF;
return * reinterpret_cast<unsigned char *>( gptr()); // return c;
} // }
//
int gzstreambuf::flush_buffer() { // int gzstreambuf::sync() {
// Separate the writing of the buffer from overflow() and // // Changed to use flush_buffer() instead of overflow( EOF)
// sync() operation. // // which caused improper behavior with std::endl and flush(),
int w = pptr() - pbase(); // // bug reported by Vincent Ricard.
if ( gzwrite( file, pbase(), w) != w) // if ( pptr() && pptr() > pbase()) {
return EOF; // if ( flush_buffer() == EOF)
pbump( -w); // return -1;
return w; // }
} // return 0;
// }
int gzstreambuf::overflow( int c) { // used for output buffer only //
if ( ! ( mode & std::ios::out) || ! opened) // // --------------------------------------
return EOF; // // class gzstreambase:
if (c != EOF) { // // --------------------------------------
*pptr() = c; //
pbump(1); // gzstreambase::gzstreambase( const char* name, int mode) {
} // init( &buf);
if ( flush_buffer() == EOF) // open( name, mode);
return EOF; // }
return c; //
} // gzstreambase::~gzstreambase() {
// buf.close();
int gzstreambuf::sync() { // }
// Changed to use flush_buffer() instead of overflow( EOF) //
// which caused improper behavior with std::endl and flush(), // void gzstreambase::open( const char* name, int open_mode) {
// bug reported by Vincent Ricard. // if ( ! buf.open( name, open_mode))
if ( pptr() && pptr() > pbase()) { // clear( rdstate() | std::ios::badbit);
if ( flush_buffer() == EOF) // }
return -1; //
} // void gzstreambase::close() {
return 0; // if ( buf.is_open())
} // if ( ! buf.close())
// clear( rdstate() | std::ios::badbit);
// -------------------------------------- // }
// class gzstreambase: //
// -------------------------------------- // #ifdef GZSTREAM_NAMESPACE
// } // namespace GZSTREAM_NAMESPACE
gzstreambase::gzstreambase( const char* name, int mode) { // #endif
init( &buf); //
open( name, mode); // // ============================================================================
} // // EOF //
gzstreambase::~gzstreambase() {
buf.close();
}
void gzstreambase::open( const char* name, int open_mode) {
if ( ! buf.open( name, open_mode))
clear( rdstate() | std::ios::badbit);
}
void gzstreambase::close() {
if ( buf.is_open())
if ( ! buf.close())
clear( rdstate() | std::ios::badbit);
}
#ifdef GZSTREAM_NAMESPACE
} // namespace GZSTREAM_NAMESPACE
#endif
// ============================================================================
// EOF //

149
libsrc/general/gzstream.h
View File

@ -32,84 +32,89 @@
// standard C++ with new header file names and std:: namespace // standard C++ with new header file names and std:: namespace
#include <iostream> #include <iostream>
#include <fstream> #include <fstream>
#include <zlib.h> // #include "/usr/include/zlib.h"
#ifdef GZSTREAM_NAMESPACE #ifdef GZSTREAM_NAMESPACE
namespace GZSTREAM_NAMESPACE { namespace GZSTREAM_NAMESPACE {
#endif #endif
// ---------------------------------------------------------------------------- typedef ofstream ogzstream;
// Internal classes to implement gzstream. See below for user classes. typedef ifstream igzstream;
// ---------------------------------------------------------------------------- typedef fstream gzstream;
typedef fstream gzstreambase;
class gzstreambuf : public std::streambuf { // // ----------------------------------------------------------------------------
private: // // Internal classes to implement gzstream. See below for user classes.
static const int bufferSize = 47+256; // size of data buff // // ----------------------------------------------------------------------------
// totals 512 bytes under g++ for igzstream at the end. //
// class gzstreambuf : public std::streambuf {
gzFile file; // file handle for compressed file // private:
char buffer[bufferSize]; // data buffer // static const int bufferSize = 47+256; // size of data buff
char opened; // open/close state of stream // // totals 512 bytes under g++ for igzstream at the end.
int mode; // I/O mode //
// gzFile file; // file handle for compressed file
int flush_buffer(); // char buffer[bufferSize]; // data buffer
public: // char opened; // open/close state of stream
gzstreambuf() : opened(0) { // int mode; // I/O mode
setp( buffer, buffer + (bufferSize-1)); //
setg( buffer + 4, // beginning of putback area // int flush_buffer();
buffer + 4, // read position // public:
buffer + 4); // end position // gzstreambuf() : opened(0) {
// ASSERT: both input & output capabilities will not be used together // setp( buffer, buffer + (bufferSize-1));
} // setg( buffer + 4, // beginning of putback area
int is_open() { return opened; } // buffer + 4, // read position
gzstreambuf* open( const char* name, int open_mode); // buffer + 4); // end position
gzstreambuf* close(); // // ASSERT: both input & output capabilities will not be used together
~gzstreambuf() { close(); } // }
// int is_open() { return opened; }
virtual int overflow( int c = EOF); // gzstreambuf* open( const char* name, int open_mode);
virtual int underflow(); // gzstreambuf* close();
virtual int sync(); // ~gzstreambuf() { close(); }
}; //
// virtual int overflow( int c = EOF);
class gzstreambase : virtual public std::ios { // virtual int underflow();
protected: // virtual int sync();
gzstreambuf buf; // };
public: //
gzstreambase() { init(&buf); } // class gzstreambase : virtual public std::ios {
DLL_HEADER gzstreambase( const char* name, int open_mode); // protected:
DLL_HEADER ~gzstreambase(); // gzstreambuf buf;
void open( const char* name, int open_mode); // public:
void close(); // gzstreambase() { init(&buf); }
gzstreambuf* rdbuf() { return &buf; } // DLL_HEADER gzstreambase( const char* name, int open_mode);
}; // DLL_HEADER ~gzstreambase();
// void open( const char* name, int open_mode);
// ---------------------------------------------------------------------------- // void close();
// User classes. Use igzstream and ogzstream analogously to ifstream and // gzstreambuf* rdbuf() { return &buf; }
// ofstream respectively. They read and write files based on the gz* // };
// function interface of the zlib. Files are compatible with gzip compression. //
// ---------------------------------------------------------------------------- // // ----------------------------------------------------------------------------
// // User classes. Use igzstream and ogzstream analogously to ifstream and
class DLL_HEADER igzstream : public gzstreambase, public std::istream { // // ofstream respectively. They read and write files based on the gz*
public: // // function interface of the zlib. Files are compatible with gzip compression.
igzstream() : std::istream( &buf) {} // // ----------------------------------------------------------------------------
igzstream( const char* name, int open_mode = std::ios::in) //
: gzstreambase( name, open_mode), std::istream( &buf) {} // class DLL_HEADER igzstream : public gzstreambase, public std::istream {
gzstreambuf* rdbuf() { return gzstreambase::rdbuf(); } // public:
void open( const char* name, int open_mode = std::ios::in) { // igzstream() : std::istream( &buf) {}
gzstreambase::open( name, open_mode); // igzstream( const char* name, int open_mode = std::ios::in)
} // : gzstreambase( name, open_mode), std::istream( &buf) {}
}; // gzstreambuf* rdbuf() { return gzstreambase::rdbuf(); }
// void open( const char* name, int open_mode = std::ios::in) {
class DLL_HEADER ogzstream : public gzstreambase, public std::ostream { // gzstreambase::open( name, open_mode);
public: // }
ogzstream() : std::ostream( &buf) {} // };
ogzstream( const char* name, int mode = std::ios::out) //
: gzstreambase( name, mode), std::ostream( &buf) {} // class DLL_HEADER ogzstream : public gzstreambase, public std::ostream {
gzstreambuf* rdbuf() { return gzstreambase::rdbuf(); } // public:
void open( const char* name, int open_mode = std::ios::out) { // ogzstream() : std::ostream( &buf) {}
gzstreambase::open( name, open_mode); // ogzstream( const char* name, int mode = std::ios::out)
} // : gzstreambase( name, mode), std::ostream( &buf) {}
}; // gzstreambuf* rdbuf() { return gzstreambase::rdbuf(); }
// void open( const char* name, int open_mode = std::ios::out) {
// gzstreambase::open( name, open_mode);
// }
// };
#ifdef GZSTREAM_NAMESPACE #ifdef GZSTREAM_NAMESPACE
} // namespace GZSTREAM_NAMESPACE } // namespace GZSTREAM_NAMESPACE

2
libsrc/general/ngsimd.hpp
View File

@ -6,7 +6,7 @@
/* Date: 25. Mar. 16 */ /* Date: 25. Mar. 16 */
/**************************************************************************/ /**************************************************************************/
#include <immintrin.h> // #include <immintrin.h>
#include <tuple> #include <tuple>
#include <ostream> #include <ostream>
#include <stdexcept> #include <stdexcept>

2
libsrc/meshing/CMakeLists.txt
View File

@ -23,7 +23,7 @@ endif(APPLE)
target_link_libraries( mesh PUBLIC ngcore PRIVATE gprim la gen ) target_link_libraries( mesh PUBLIC ngcore PRIVATE gprim la gen )
target_link_libraries( mesh PRIVATE netgen_metis netgen_python ${ZLIB_LIBRARIES} ) target_link_libraries( mesh PRIVATE netgen_metis netgen_python )
if(NOT WIN32) if(NOT WIN32)
install( TARGETS mesh ${NG_INSTALL_DIR}) install( TARGETS mesh ${NG_INSTALL_DIR})
endif(NOT WIN32) endif(NOT WIN32)

2
nglib/CMakeLists.txt
View File

@ -31,7 +31,7 @@ endif(NOT WIN32)
# target_link_libraries(nglib PRIVATE gen la gprim PUBLIC ngcore) # target_link_libraries(nglib PRIVATE gen la gprim PUBLIC ngcore)
target_link_libraries(nglib PUBLIC ngcore) target_link_libraries(nglib PUBLIC ngcore)
target_link_libraries( nglib PRIVATE ${OCC_LIBRARIES} ${MPI_CXX_LIBRARIES} ${OPENGL_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${X11_Xmu_LIB} ${JPEG_LIBRARIES} ${MKL_LIBRARIES} ${ZLIB_LIBRARIES} ${OCC_LIBRARIES} netgen_cgns ) target_link_libraries( nglib PRIVATE ${OCC_LIBRARIES} ${MPI_CXX_LIBRARIES} ${OPENGL_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${X11_Xmu_LIB} ${JPEG_LIBRARIES} ${MKL_LIBRARIES} ${OCC_LIBRARIES} netgen_cgns )
if(USE_OCC AND NOT WIN32) if(USE_OCC AND NOT WIN32)
target_link_libraries(nglib PUBLIC occ) target_link_libraries(nglib PUBLIC occ)

2
py_tutorials/csg2d.py
View File

@ -25,7 +25,7 @@ g.Add(inner)
g.Add(outer) g.Add(outer)
geo = g.GenerateSplineGeometry() geo = g.GenerateSplineGeometry()
m = geo.GenerateMesh(maxh=0.1) m = geo.GenerateMesh(maxh=0.1, delaunay2d=True)
try: try:
from ngsolve import Draw, Mesh from ngsolve import Draw, Mesh