ForkMaster/netgen
1
0
Fork 0
mirror of https://github.com/NGSolve/netgen.git synced 2024-11-11 16:49:16 +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()
set(CMAKE_CXX_STANDARD 17)
set(CXX_EXTENSIONS OFF)
set(CMAKE_CXX_EXTENSIONS OFF)
if(WIN32)
set(CMAKE_MFC_FLAG 0)
# build convenience (aka object) libraries in windows)
@ -233,7 +231,7 @@ endif(APPLE)
if(NOT ZLIB_INCLUDE_DIRS)
find_package(ZLIB REQUIRED)
endif(NOT ZLIB_INCLUDE_DIRS)
# include_directories(${ZLIB_INCLUDE_DIRS})
include_directories(${ZLIB_INCLUDE_DIRS})
#######################################################################
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 = __rdtsc();
static size_t calibrate_init_tsc = GetTimeCounter();
typedef std::chrono::system_clock TClock;
static TClock::time_point calibrate_init_clock = TClock::now();
void TaskManager :: StopWorkers()
{
done = true;
double delta_tsc = 0-calibrate_init_tsc;
// double delta_tsc = __rdtsc()-calibrate_init_tsc;
double delta_tsc = GetTimeCounter()-calibrate_init_tsc;
double delta_sec = std::chrono::duration<double>(TClock::now()-calibrate_init_clock).count();
double frequ = (delta_sec != 0) ? delta_tsc/delta_sec : 2.7e9;
@ -423,7 +421,11 @@ namespace ngcore
if (workers_on_node[j])
{
while (complete[j] != jobnr)
; // _mm_pause();
{
#ifdef NETGEN_ARCH_AMD64
_mm_pause();
#endif // NETGEN_ARCH_AMD64
}
}
func = nullptr;

12
libsrc/core/utils.hpp
View File

@ -8,19 +8,19 @@
#include <sstream>
#include <string>
#include "ngcore_api.hpp" // for NGCORE_API and CPU arch macros
#if defined(__APPLE__) && defined(NETGEN_ARCH_ARM)
#include <mach/mach_time.h>
#endif
/*
#ifdef NETGEN_ARCH_AMD64
#ifdef WIN32
#include <intrin.h> // for __rdtsc() CPU time step counter
#else
#include <x86intrin.h> // for __rdtsc() CPU time step counter
#endif // WIN32
*/
#include "ngcore_api.hpp" // for NGCORE_API
#endif // NETGEN_ARCH_AMD64
namespace ngcore
{
@ -176,7 +176,9 @@ namespace ngcore
while (!m.compare_exchange_weak(should, true))
{
should = false;
// _mm_pause();
#ifdef NETGEN_ARCH_AMD64
_mm_pause();
#endif // NETGEN_ARCH_AMD64
}
}
void unlock()

332
libsrc/general/gzstream.cpp
View File

@ -1,167 +1,167 @@
// // ============================================================================
// // gzstream, C++ iostream classes wrapping the zlib compression library.
// // 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".
// // ============================================================================
// ============================================================================
// gzstream, C++ iostream classes wrapping the zlib compression library.
// 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
//
// #include <mystdlib.h>
// #include <myadt.hpp>
// //#include "gzstream.h"
// //#include <iostream>
// //#include <string.h> // for memcpy
//
// #ifdef GZSTREAM_NAMESPACE
// namespace GZSTREAM_NAMESPACE {
// #endif
//
// // ----------------------------------------------------------------------------
// // Internal classes to implement gzstream. See header file for user classes.
// // ----------------------------------------------------------------------------
//
// // --------------------------------------
// // class gzstreambuf:
// // --------------------------------------
//
// gzstreambuf* gzstreambuf::open( const char* name, int open_mode) {
// if ( is_open())
// return (gzstreambuf*)0;
// mode = open_mode;
// // no append nor read/write mode
// if ((mode & std::ios::ate) || (mode & std::ios::app)
// || ((mode & std::ios::in) && (mode & std::ios::out)))
// return (gzstreambuf*)0;
// char fmode[10];
// char* fmodeptr = fmode;
// if ( mode & std::ios::in)
// *fmodeptr++ = 'r';
// else if ( mode & std::ios::out)
// *fmodeptr++ = 'w';
// *fmodeptr++ = 'b';
// *fmodeptr = '\0';
// file = gzopen( name, fmode);
// if (file == 0)
// return (gzstreambuf*)0;
// opened = 1;
// return this;
// }
//
// gzstreambuf * gzstreambuf::close() {
// if ( is_open()) {
// sync();
// opened = 0;
// if ( gzclose( file) == Z_OK)
// return this;
// }
// return (gzstreambuf*)0;
// }
//
// int gzstreambuf::underflow() { // used for input buffer only
// if ( gptr() && ( gptr() < egptr()))
// return * reinterpret_cast<unsigned char *>( gptr());
//
// if ( ! (mode & std::ios::in) || ! opened)
// return EOF;
// // Josuttis' implementation of inbuf
// int n_putback = gptr() - eback();
// if ( n_putback > 4)
// n_putback = 4;
// memcpy( buffer + (4 - n_putback), gptr() - n_putback, n_putback);
//
// int num = gzread( file, buffer+4, bufferSize-4);
// if (num <= 0) // ERROR or EOF
// return EOF;
//
// // reset buffer pointers
// setg( buffer + (4 - n_putback), // beginning of putback area
// buffer + 4, // read position
// buffer + 4 + num); // end of buffer
//
// // return next character
// return * reinterpret_cast<unsigned char *>( gptr());
// }
//
// int gzstreambuf::flush_buffer() {
// // Separate the writing of the buffer from overflow() and
// // sync() operation.
// int w = pptr() - pbase();
// if ( gzwrite( file, pbase(), w) != w)
// return EOF;
// pbump( -w);
// return w;
// }
//
// int gzstreambuf::overflow( int c) { // used for output buffer only
// if ( ! ( mode & std::ios::out) || ! opened)
// return EOF;
// if (c != EOF) {
// *pptr() = c;
// pbump(1);
// }
// if ( flush_buffer() == EOF)
// return EOF;
// return c;
// }
//
// int gzstreambuf::sync() {
// // Changed to use flush_buffer() instead of overflow( EOF)
// // which caused improper behavior with std::endl and flush(),
// // bug reported by Vincent Ricard.
// if ( pptr() && pptr() > pbase()) {
// if ( flush_buffer() == EOF)
// return -1;
// }
// return 0;
// }
//
// // --------------------------------------
// // class gzstreambase:
// // --------------------------------------
//
// gzstreambase::gzstreambase( const char* name, int mode) {
// init( &buf);
// open( name, mode);
// }
//
// 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 //
// Standard streambuf implementation following Nicolai Josuttis, "The
// Standard C++ Library".
// ============================================================================
#include <mystdlib.h>
#include <myadt.hpp>
//#include "gzstream.h"
//#include <iostream>
//#include <string.h> // for memcpy
#ifdef GZSTREAM_NAMESPACE
namespace GZSTREAM_NAMESPACE {
#endif
// ----------------------------------------------------------------------------
// Internal classes to implement gzstream. See header file for user classes.
// ----------------------------------------------------------------------------
// --------------------------------------
// class gzstreambuf:
// --------------------------------------
gzstreambuf* gzstreambuf::open( const char* name, int open_mode) {
if ( is_open())
return (gzstreambuf*)0;
mode = open_mode;
// no append nor read/write mode
if ((mode & std::ios::ate) || (mode & std::ios::app)
|| ((mode & std::ios::in) && (mode & std::ios::out)))
return (gzstreambuf*)0;
char fmode[10];
char* fmodeptr = fmode;
if ( mode & std::ios::in)
*fmodeptr++ = 'r';
else if ( mode & std::ios::out)
*fmodeptr++ = 'w';
*fmodeptr++ = 'b';
*fmodeptr = '\0';
file = gzopen( name, fmode);
if (file == 0)
return (gzstreambuf*)0;
opened = 1;
return this;
}
gzstreambuf * gzstreambuf::close() {
if ( is_open()) {
sync();
opened = 0;
if ( gzclose( file) == Z_OK)
return this;
}
return (gzstreambuf*)0;
}
int gzstreambuf::underflow() { // used for input buffer only
if ( gptr() && ( gptr() < egptr()))
return * reinterpret_cast<unsigned char *>( gptr());
if ( ! (mode & std::ios::in) || ! opened)
return EOF;
// Josuttis' implementation of inbuf
int n_putback = gptr() - eback();
if ( n_putback > 4)
n_putback = 4;
memcpy( buffer + (4 - n_putback), gptr() - n_putback, n_putback);
int num = gzread( file, buffer+4, bufferSize-4);
if (num <= 0) // ERROR or EOF
return EOF;
// reset buffer pointers
setg( buffer + (4 - n_putback), // beginning of putback area
buffer + 4, // read position
buffer + 4 + num); // end of buffer
// return next character
return * reinterpret_cast<unsigned char *>( gptr());
}
int gzstreambuf::flush_buffer() {
// Separate the writing of the buffer from overflow() and
// sync() operation.
int w = pptr() - pbase();
if ( gzwrite( file, pbase(), w) != w)
return EOF;
pbump( -w);
return w;
}
int gzstreambuf::overflow( int c) { // used for output buffer only
if ( ! ( mode & std::ios::out) || ! opened)
return EOF;
if (c != EOF) {
*pptr() = c;
pbump(1);
}
if ( flush_buffer() == EOF)
return EOF;
return c;
}
int gzstreambuf::sync() {
// Changed to use flush_buffer() instead of overflow( EOF)
// which caused improper behavior with std::endl and flush(),
// bug reported by Vincent Ricard.
if ( pptr() && pptr() > pbase()) {
if ( flush_buffer() == EOF)
return -1;
}
return 0;
}
// --------------------------------------
// class gzstreambase:
// --------------------------------------
gzstreambase::gzstreambase( const char* name, int mode) {
init( &buf);
open( name, mode);
}
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
#include <iostream>
#include <fstream>
// #include "/usr/include/zlib.h"
#include <zlib.h>
#ifdef GZSTREAM_NAMESPACE
namespace GZSTREAM_NAMESPACE {
#endif
typedef ofstream ogzstream;
typedef ifstream igzstream;
typedef fstream gzstream;
typedef fstream gzstreambase;
// ----------------------------------------------------------------------------
// Internal classes to implement gzstream. See below for user classes.
// ----------------------------------------------------------------------------
// // ----------------------------------------------------------------------------
// // Internal classes to implement gzstream. See below for user classes.
// // ----------------------------------------------------------------------------
//
// class gzstreambuf : public std::streambuf {
// private:
// static const int bufferSize = 47+256; // size of data buff
// // totals 512 bytes under g++ for igzstream at the end.
//
// gzFile file; // file handle for compressed file
// char buffer[bufferSize]; // data buffer
// char opened; // open/close state of stream
// int mode; // I/O mode
//
// int flush_buffer();
// public:
// gzstreambuf() : opened(0) {
// setp( buffer, buffer + (bufferSize-1));
// setg( buffer + 4, // beginning of putback area
// buffer + 4, // read position
// buffer + 4); // end position
// // ASSERT: both input & output capabilities will not be used together
// }
// int is_open() { return opened; }
// gzstreambuf* open( const char* name, int open_mode);
// gzstreambuf* close();
// ~gzstreambuf() { close(); }
//
// virtual int overflow( int c = EOF);
// virtual int underflow();
// virtual int sync();
// };
//
// class gzstreambase : virtual public std::ios {
// protected:
// gzstreambuf buf;
// public:
// gzstreambase() { init(&buf); }
// DLL_HEADER gzstreambase( const char* name, int open_mode);
// 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.
// // ----------------------------------------------------------------------------
//
// class DLL_HEADER igzstream : public gzstreambase, public std::istream {
// public:
// igzstream() : std::istream( &buf) {}
// 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) {
// 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)
// : 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);
// }
// };
class gzstreambuf : public std::streambuf {
private:
static const int bufferSize = 47+256; // size of data buff
// totals 512 bytes under g++ for igzstream at the end.
gzFile file; // file handle for compressed file
char buffer[bufferSize]; // data buffer
char opened; // open/close state of stream
int mode; // I/O mode
int flush_buffer();
public:
gzstreambuf() : opened(0) {
setp( buffer, buffer + (bufferSize-1));
setg( buffer + 4, // beginning of putback area
buffer + 4, // read position
buffer + 4); // end position
// ASSERT: both input & output capabilities will not be used together
}
int is_open() { return opened; }
gzstreambuf* open( const char* name, int open_mode);
gzstreambuf* close();
~gzstreambuf() { close(); }
virtual int overflow( int c = EOF);
virtual int underflow();
virtual int sync();
};
class gzstreambase : virtual public std::ios {
protected:
gzstreambuf buf;
public:
gzstreambase() { init(&buf); }
DLL_HEADER gzstreambase( const char* name, int open_mode);
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.
// ----------------------------------------------------------------------------
class DLL_HEADER igzstream : public gzstreambase, public std::istream {
public:
igzstream() : std::istream( &buf) {}
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) {
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)
: 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
} // 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 PRIVATE netgen_metis netgen_python )
target_link_libraries( mesh PRIVATE netgen_metis netgen_python ${ZLIB_LIBRARIES} )
if(NOT WIN32)
install( TARGETS mesh ${NG_INSTALL_DIR})
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 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)
target_link_libraries(nglib PUBLIC occ)

2
py_tutorials/csg2d.py
View File

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