ForkMaster/netgen
1
0
Fork 0
mirror of https://github.com/NGSolve/netgen.git synced 2024-11-14 10:08:32 +05:00
Code Issues Packages Projects Releases Wiki Activity

cleanup

Browse Source
This commit is contained in:
Matthias Hochsteger 2020-12-07 11:17:11 +01:00
parent fc835e25a2
commit 9eb8e4f473
8 changed files with 256 additions and 259 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@ -215,8 +215,6 @@ 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)
@ -233,7 +231,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)

12
libsrc/core/taskmanager.cpp
View File

@ -201,16 +201,14 @@ namespace ngcore
; ;
} }
static size_t calibrate_init_tsc = 0; static size_t calibrate_init_tsc = GetTimeCounter();
// 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 = 0-calibrate_init_tsc; double delta_tsc = GetTimeCounter()-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;
@ -423,7 +421,11 @@ namespace ngcore
if (workers_on_node[j]) if (workers_on_node[j])
{ {
while (complete[j] != jobnr) while (complete[j] != jobnr)
; // _mm_pause(); {
#ifdef NETGEN_ARCH_AMD64
_mm_pause();
#endif // NETGEN_ARCH_AMD64
}
} }
func = nullptr; func = nullptr;

12
libsrc/core/utils.hpp
View File

@ -8,19 +8,19 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
#include "ngcore_api.hpp" // for NGCORE_API and CPU arch macros
#if defined(__APPLE__) && defined(NETGEN_ARCH_ARM) #if defined(__APPLE__) && defined(NETGEN_ARCH_ARM)
#include <mach/mach_time.h> #include <mach/mach_time.h>
#endif #endif
/* #ifdef NETGEN_ARCH_AMD64
#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
*/ #endif // NETGEN_ARCH_AMD64
#include "ngcore_api.hpp" // for NGCORE_API
namespace ngcore namespace ngcore
{ {
@ -176,7 +176,9 @@ namespace ngcore
while (!m.compare_exchange_weak(should, true)) while (!m.compare_exchange_weak(should, true))
{ {
should = false; should = false;
// _mm_pause(); #ifdef NETGEN_ARCH_AMD64
_mm_pause();
#endif // NETGEN_ARCH_AMD64
} }
} }
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".
// // ============================================================================
// //
// #include <mystdlib.h> // This library is free software; you can redistribute it and/or
// #include <myadt.hpp> // modify it under the terms of the GNU Lesser General Public
// //#include "gzstream.h" // License as published by the Free Software Foundation; either
// //#include <iostream> // version 2.1 of the License, or (at your option) any later version.
// //#include <string.h> // for memcpy
// //
// #ifdef GZSTREAM_NAMESPACE // This library is distributed in the hope that it will be useful,
// namespace GZSTREAM_NAMESPACE { // but WITHOUT ANY WARRANTY; without even the implied warranty of
// #endif // 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
// // Internal classes to implement gzstream. See header file for user classes. // 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
// // class gzstreambuf: // Revision : $Revision: 1.7 $
// // -------------------------------------- // Revision_date : $Date: 2003/01/08 14:41:27 $
// Author(s) : Deepak Bandyopadhyay, Lutz Kettner
// //
// gzstreambuf* gzstreambuf::open( const char* name, int open_mode) { // Standard streambuf implementation following Nicolai Josuttis, "The
// if ( is_open()) // Standard C++ Library".
// return (gzstreambuf*)0; // ============================================================================
// mode = open_mode;
// // no append nor read/write mode #include <mystdlib.h>
// if ((mode & std::ios::ate) || (mode & std::ios::app) #include <myadt.hpp>
// || ((mode & std::ios::in) && (mode & std::ios::out))) //#include "gzstream.h"
// return (gzstreambuf*)0; //#include <iostream>
// char fmode[10]; //#include <string.h> // for memcpy
// char* fmodeptr = fmode;
// if ( mode & std::ios::in) #ifdef GZSTREAM_NAMESPACE
// *fmodeptr++ = 'r'; namespace GZSTREAM_NAMESPACE {
// else if ( mode & std::ios::out) #endif
// *fmodeptr++ = 'w';
// *fmodeptr++ = 'b'; // ----------------------------------------------------------------------------
// *fmodeptr = '\0'; // Internal classes to implement gzstream. See header file for user classes.
// file = gzopen( name, fmode); // ----------------------------------------------------------------------------
// if (file == 0)
// return (gzstreambuf*)0; // --------------------------------------
// opened = 1; // class gzstreambuf:
// return this; // --------------------------------------
// }
// gzstreambuf* gzstreambuf::open( const char* name, int open_mode) {
// gzstreambuf * gzstreambuf::close() { if ( is_open())
// if ( is_open()) { return (gzstreambuf*)0;
// sync(); mode = open_mode;
// opened = 0; // no append nor read/write mode
// if ( gzclose( file) == Z_OK) if ((mode & std::ios::ate) || (mode & std::ios::app)
// return this; || ((mode & std::ios::in) && (mode & std::ios::out)))
// } return (gzstreambuf*)0;
// return (gzstreambuf*)0; char fmode[10];
// } char* fmodeptr = fmode;
// if ( mode & std::ios::in)
// int gzstreambuf::underflow() { // used for input buffer only *fmodeptr++ = 'r';
// if ( gptr() && ( gptr() < egptr())) else if ( mode & std::ios::out)
// return * reinterpret_cast<unsigned char *>( gptr()); *fmodeptr++ = 'w';
// *fmodeptr++ = 'b';
// if ( ! (mode & std::ios::in) || ! opened) *fmodeptr = '\0';
// return EOF; file = gzopen( name, fmode);
// // Josuttis' implementation of inbuf if (file == 0)
// int n_putback = gptr() - eback(); return (gzstreambuf*)0;
// if ( n_putback > 4) opened = 1;
// n_putback = 4; return this;
// memcpy( buffer + (4 - n_putback), gptr() - n_putback, n_putback); }
//
// int num = gzread( file, buffer+4, bufferSize-4); gzstreambuf * gzstreambuf::close() {
// if (num <= 0) // ERROR or EOF if ( is_open()) {
// return EOF; sync();
// opened = 0;
// // reset buffer pointers if ( gzclose( file) == Z_OK)
// setg( buffer + (4 - n_putback), // beginning of putback area return this;
// buffer + 4, // read position }
// buffer + 4 + num); // end of buffer return (gzstreambuf*)0;
// }
// // return next character
// return * reinterpret_cast<unsigned char *>( gptr()); int gzstreambuf::underflow() { // used for input buffer only
// } if ( gptr() && ( gptr() < egptr()))
// return * reinterpret_cast<unsigned char *>( gptr());
// int gzstreambuf::flush_buffer() {
// // Separate the writing of the buffer from overflow() and if ( ! (mode & std::ios::in) || ! opened)
// // sync() operation. return EOF;
// int w = pptr() - pbase(); // Josuttis' implementation of inbuf
// if ( gzwrite( file, pbase(), w) != w) int n_putback = gptr() - eback();
// return EOF; if ( n_putback > 4)
// pbump( -w); n_putback = 4;
// return w; memcpy( buffer + (4 - n_putback), gptr() - n_putback, n_putback);
// }
// int num = gzread( file, buffer+4, bufferSize-4);
// int gzstreambuf::overflow( int c) { // used for output buffer only if (num <= 0) // ERROR or EOF
// if ( ! ( mode & std::ios::out) || ! opened) return EOF;
// return EOF;
// if (c != EOF) { // reset buffer pointers
// *pptr() = c; setg( buffer + (4 - n_putback), // beginning of putback area
// pbump(1); buffer + 4, // read position
// } buffer + 4 + num); // end of buffer
// if ( flush_buffer() == EOF)
// return EOF; // return next character
// return c; return * reinterpret_cast<unsigned char *>( gptr());
// } }
//
// int gzstreambuf::sync() { int gzstreambuf::flush_buffer() {
// // Changed to use flush_buffer() instead of overflow( EOF) // Separate the writing of the buffer from overflow() and
// // which caused improper behavior with std::endl and flush(), // sync() operation.
// // bug reported by Vincent Ricard. int w = pptr() - pbase();
// if ( pptr() && pptr() > pbase()) { if ( gzwrite( file, pbase(), w) != w)
// if ( flush_buffer() == EOF) return EOF;
// return -1; pbump( -w);
// } return w;
// return 0; }
// }
// int gzstreambuf::overflow( int c) { // used for output buffer only
// // -------------------------------------- if ( ! ( mode & std::ios::out) || ! opened)
// // class gzstreambase: return EOF;
// // -------------------------------------- if (c != EOF) {
// *pptr() = c;
// gzstreambase::gzstreambase( const char* name, int mode) { pbump(1);
// init( &buf); }
// open( name, mode); if ( flush_buffer() == EOF)
// } return EOF;
// return c;
// gzstreambase::~gzstreambase() { }
// buf.close();
// } int gzstreambuf::sync() {
// // Changed to use flush_buffer() instead of overflow( EOF)
// void gzstreambase::open( const char* name, int open_mode) { // which caused improper behavior with std::endl and flush(),
// if ( ! buf.open( name, open_mode)) // bug reported by Vincent Ricard.
// clear( rdstate() | std::ios::badbit); if ( pptr() && pptr() > pbase()) {
// } if ( flush_buffer() == EOF)
// return -1;
// void gzstreambase::close() { }
// if ( buf.is_open()) return 0;
// if ( ! buf.close()) }
// clear( rdstate() | std::ios::badbit);
// } // --------------------------------------
// // class gzstreambase:
// #ifdef GZSTREAM_NAMESPACE // --------------------------------------
// } // namespace GZSTREAM_NAMESPACE
// #endif gzstreambase::gzstreambase( const char* name, int mode) {
// 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,89 +32,84 @@
// 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 "/usr/include/zlib.h" #include <zlib.h>
#ifdef GZSTREAM_NAMESPACE #ifdef GZSTREAM_NAMESPACE
namespace GZSTREAM_NAMESPACE { namespace GZSTREAM_NAMESPACE {
#endif #endif
typedef ofstream ogzstream; // ----------------------------------------------------------------------------
typedef ifstream igzstream; // Internal classes to implement gzstream. See below for user classes.
typedef fstream gzstream; // ----------------------------------------------------------------------------
typedef fstream gzstreambase;
// // ---------------------------------------------------------------------------- class gzstreambuf : public std::streambuf {
// // Internal classes to implement gzstream. See below for user classes. private:
// // ---------------------------------------------------------------------------- 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 {
// private: gzFile file; // file handle for compressed file
// static const int bufferSize = 47+256; // size of data buff char buffer[bufferSize]; // data buffer
// // totals 512 bytes under g++ for igzstream at the end. char opened; // open/close state of stream
// int mode; // I/O mode
// gzFile file; // file handle for compressed file
// char buffer[bufferSize]; // data buffer int flush_buffer();
// char opened; // open/close state of stream public:
// int mode; // I/O mode gzstreambuf() : opened(0) {
// setp( buffer, buffer + (bufferSize-1));
// int flush_buffer(); setg( buffer + 4, // beginning of putback area
// public: buffer + 4, // read position
// gzstreambuf() : opened(0) { buffer + 4); // end position
// setp( buffer, buffer + (bufferSize-1)); // ASSERT: both input & output capabilities will not be used together
// setg( buffer + 4, // beginning of putback area }
// buffer + 4, // read position int is_open() { return opened; }
// buffer + 4); // end position gzstreambuf* open( const char* name, int open_mode);
// // ASSERT: both input & output capabilities will not be used together gzstreambuf* close();
// } ~gzstreambuf() { close(); }
// int is_open() { return opened; }
// gzstreambuf* open( const char* name, int open_mode); virtual int overflow( int c = EOF);
// gzstreambuf* close(); virtual int underflow();
// ~gzstreambuf() { close(); } virtual int sync();
// };
// virtual int overflow( int c = EOF);
// virtual int underflow(); class gzstreambase : virtual public std::ios {
// virtual int sync(); protected:
// }; gzstreambuf buf;
// public:
// class gzstreambase : virtual public std::ios { gzstreambase() { init(&buf); }
// protected: DLL_HEADER gzstreambase( const char* name, int open_mode);
// gzstreambuf buf; DLL_HEADER ~gzstreambase();
// public: void open( const char* name, int open_mode);
// gzstreambase() { init(&buf); } void close();
// DLL_HEADER gzstreambase( const char* name, int open_mode); gzstreambuf* rdbuf() { return &buf; }
// DLL_HEADER ~gzstreambase(); };
// void open( const char* name, int open_mode);
// void close(); // ----------------------------------------------------------------------------
// gzstreambuf* rdbuf() { return &buf; } // User classes. Use igzstream and ogzstream analogously to ifstream and
// }; // 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
// // ofstream respectively. They read and write files based on the gz* class DLL_HEADER igzstream : public gzstreambase, public std::istream {
// // function interface of the zlib. Files are compatible with gzip compression. public:
// // ---------------------------------------------------------------------------- igzstream() : std::istream( &buf) {}
// igzstream( const char* name, int open_mode = std::ios::in)
// class DLL_HEADER igzstream : public gzstreambase, public std::istream { : gzstreambase( name, open_mode), std::istream( &buf) {}
// public: gzstreambuf* rdbuf() { return gzstreambase::rdbuf(); }
// igzstream() : std::istream( &buf) {} void open( const char* name, int open_mode = std::ios::in) {
// igzstream( const char* name, int open_mode = std::ios::in) gzstreambase::open( name, open_mode);
// : gzstreambase( name, open_mode), std::istream( &buf) {} }
// gzstreambuf* rdbuf() { return gzstreambase::rdbuf(); } };
// void open( const char* name, int open_mode = std::ios::in) {
// gzstreambase::open( name, open_mode); class DLL_HEADER ogzstream : public gzstreambase, public std::ostream {
// } public:
// }; ogzstream() : std::ostream( &buf) {}
// ogzstream( const char* name, int mode = std::ios::out)
// class DLL_HEADER ogzstream : public gzstreambase, public std::ostream { : gzstreambase( name, mode), std::ostream( &buf) {}
// public: gzstreambuf* rdbuf() { return gzstreambase::rdbuf(); }
// ogzstream() : std::ostream( &buf) {} void open( const char* name, int open_mode = std::ios::out) {
// ogzstream( const char* name, int mode = std::ios::out) gzstreambase::open( name, open_mode);
// : 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/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 ) target_link_libraries( mesh PRIVATE netgen_metis netgen_python ${ZLIB_LIBRARIES} )
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} ${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} ${ZLIB_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, delaunay2d=True) m = geo.GenerateMesh(maxh=0.1)
try: try:
from ngsolve import Draw, Mesh from ngsolve import Draw, Mesh