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()

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