void test( const std::string & filename, const Vector3<uint_t> & size, const std::string & datatype, const bool vtkOut )
{
WALBERLA_LOG_INFO( "Testing unscaled" );
BinaryRawFile brf( filename, size, datatype );
auto blocks = blockforest::createUniformBlockGrid( uint_t(1), uint_t( 1 ), uint_t( 1 ),
size[0], size[1], size[2],
real_t( 1 ),
uint_t( 1 ), uint_t( 1 ), uint_t( 1 ) );
typedef GhostLayerField< uint8_t, uint_t( 1 ) > ScalarField;
BlockDataID scalarFieldID = field::addToStorage<ScalarField>( blocks, "BinaryRawFile" );
for ( auto & block : *blocks)
{
auto field = block.getData<ScalarField>( scalarFieldID );
CellInterval ci( 0, 0, 0, cell_idx_c( size[0] ) - 1, cell_idx_c( size[1] ) - 1, cell_idx_c( size[2] ) - 1 );
for (const Cell & c : ci)
{
field->get( c ) = brf.get( uint_c( c[0] ), uint_c( c[1] ), uint_c( c[2] ) );
}
}
if (vtkOut)
{
WALBERLA_LOG_INFO( "Writing unscaled" );
auto vtkOutput = vtk::createVTKOutput_BlockData( blocks, "BinaryRawFile" );
vtkOutput->addCellDataWriter( make_shared< field::VTKWriter< ScalarField, uint8_t > >( scalarFieldID, "BinaryRawFile" ) );
writeFiles( vtkOutput, true )();
}
}
/********************************************************
* handleOneClient
********************************************************/
void handleOneClient(int sd){
int clientSd, numberOfFiles;
struct file* file;
numberOfFiles = 1;
//(7)accept connection from each of the socket in filesSocketsArr
puts("\n------------(3.4)accept connection;--------------");
clientSd = acceptConnection(sd);
//connectedFilesSocketsArr = accept_connection_from_array_of_sockets(filesSocketsArr, numberOfFiles, "filesSocketsArr");
//(8)get file from each of the socket in connectedFilesSocketsArr
puts("\n------------(3.5)get files--------------");
file = get_files_from_array_of_sockets(&clientSd, numberOfFiles);
//(8)get file from each of the socket in connectedFilesSocketsArr
puts("\n------------(3.6)save files--------------");
writeFiles(file, numberOfFiles);
//(9)close master_socket, client_socket and all the socket in filesSockets
puts("\n------------(3.7)close sockets and free file--------------");
closeSocket(clientSd);
freeFiles(file,numberOfFiles,"file");
}
//Main function to read keys from file and then matrix, yeah!
int main (int argc, char * argv[]) {
char *res;
bigInt *numbers;
if (argc != 2) {
printf("error, syntax is %s <file name>\n", argv[0]);
return 0;
}
int numKeys = readFile(argv[1], &numbers, &res);
//Lets gcd
#ifdef GMP
gmpGCDs(numbers, numKeys, res);
#else
for (int offset = 0; offset < numKeys; offset += WORK_SIZE)
findGCDs(numbers, numKeys, res, offset);
#endif
writeFiles("privateKeys", numKeys, numbers, res);
free(numbers);
free(res);
return 0;
}
void ZendParser::parse() {
setupReader();
getReader()->removeDir(outputDir);
getReader()->createDir(outputDir);
if (isRecurisve())
getReader()->read(getReader()->getPath(), "/");
else
getReader()->read();
vector<DirectoryReader::Item> *readerResult = reader->getResults();
int generated = 0, processed = 0;
vector<string> tmpOut, tmpVector;
set<string> tmpSet;
vector<pair<string, string>> tmpOutPairs;
File file;
buildFiles(file, tmpOut, processed, readerResult, tmpOutPairs, tmpVector);
filterPreparedTypes(*typesRegistryUnfiltered, *typesRegistry);
generatePreparedTypesGlobal(tmpVector);
writeFiles(tmpSet, generated);
writeTypesRegistryFile();
cout << "\n";
cout << "files processed : " << processed << "\n";
cout << "types found : " << typesRegistry->size() << "\n";
cout << "files generated : " << generated << "\n";
cout << "\n";
cout << "finished...";
}
static void flushOutstandingDataInObjectToFile(struct FileWriteObject *object)
{
if(listSize(object->writeObjects) > 0)
{
printf("Outstanding data: %i\n",listSize(object->writeObjects));
writeFiles();
}
}
/********************************************************
* server2
* general without select
********************************************************/
void server2()
{
int masterSocket, connectedMasterSocket, numberOfFiles, *filesSocketsArr, *freePortsArr, * connectedFilesSocketsArr;
struct file* files;
//(1)listen on control master_socket
masterSocket = listenOnPort(CONTROL_PORT);
while(1){
//(2)accept new connection form master_socket
puts("\n------------(1)wait for connection--------------");
connectedMasterSocket = acceptConnection(masterSocket);
//(3)get port Number from client
puts("\n------------(2)get number of files--------------");
numberOfFiles = getIntFromClient(connectedMasterSocket,"numberOfFiles");
//(4)listen to socket on random free ports
puts("\n------------(3)listen on random ports--------------");
filesSocketsArr = listenOnSocketWithFreePorts(numberOfFiles);
//(5)get filesSockets port
puts("\n------------(4)random ports--------------");
freePortsArr = getPortNumberFromSockets(filesSocketsArr, numberOfFiles);
//(6)send to client the free ports
puts("\n------------(5)send free ports to client--------------");
SendIntArrayToClient(connectedMasterSocket,freePortsArr, numberOfFiles ,"freePortsArr");
//(7)accept connection from each of the socket in filesSocketsArr
puts("\n------------(6)accept connection from new sockets--------------");
connectedFilesSocketsArr = accept_connection_from_array_of_sockets(filesSocketsArr, numberOfFiles, "filesSocketsArr");
//(8)get file from each of the socket in connectedFilesSocketsArr
puts("\n------------(7)get files--------------");
files = get_files_from_array_of_sockets(connectedFilesSocketsArr, numberOfFiles);
//(8)get file from each of the socket in connectedFilesSocketsArr
puts("\n------------(8)save files--------------");
writeFiles(files, numberOfFiles);
//(9)close master_socket, client_socket and all the socket in filesSockets
puts("\n------------(9)close sockets--------------");
closeSocket(connectedMasterSocket);
closeSockets(filesSocketsArr, numberOfFiles, "filesSocketsArr");
closeSockets(connectedFilesSocketsArr, numberOfFiles, "connectedFilesSocketsArr");
//(10)free filesSocketsArr and freePortsArr
puts("\n------------(10)free memory--------------");
myFree(connectedFilesSocketsArr,"connectedFilesSocketsArr");
myFree(filesSocketsArr,"filesSocketsArr");
myFree(freePortsArr,"freePortsArr");
freeFiles(files, numberOfFiles,"files");
}
closeSocket(masterSocket);
puts("server close");
}
static void* fileWritingThread(void *arg)
{
fileWriteThreadInitialized = 1;
for(;;)
{
openPendingFiles();
writeFiles();
closePendingFiles();
usleep(1000);
}
return NULL;
}
void testScaled( const std::string & filename, const Vector3<uint_t> & size, const std::string & datatype, const bool vtkOut )
{
WALBERLA_LOG_INFO( "Testing scaled" );
BinaryRawFile brf( filename, size, datatype );
Vector3<uint_t> scaledSize( std::max( uint_t( 1 ), size[0] / uint_t( 2 ) ),
std::max( uint_t( 1 ), size[1] / uint_t( 3 ) ),
std::max( uint_t( 1 ), size[2] / uint_t( 5 ) ) );
auto blocks = blockforest::createUniformBlockGrid( uint_t( 1 ), uint_t( 1 ), uint_t( 1 ),
scaledSize[0], scaledSize[1], scaledSize[2],
real_t( 1 ),
uint_t( 1 ), uint_t( 1 ), uint_t( 1 ) );
BinaryRawFileInterpolator brfi( blocks->getDomain(), brf, BinaryRawFileInterpolator::NEAREST_NEIGHBOR );
typedef GhostLayerField< uint8_t, uint_t( 1 ) > ScalarField;
BlockDataID scalarFieldID = field::addToStorage<ScalarField>( blocks, "BinaryRawFile" );
for (auto & block : *blocks)
{
auto field = block.getData<ScalarField>( scalarFieldID );
CellInterval ci( 0, 0, 0, cell_idx_c( scaledSize[0] ) - 1, cell_idx_c( scaledSize[1] ) - 1, cell_idx_c( scaledSize[2] ) - 1 );
for (const Cell & c : ci)
{
auto pos = blocks->getBlockLocalCellCenter( block, c );
field->get( c ) = brfi.get( pos );
}
}
if (vtkOut)
{
WALBERLA_LOG_INFO( "Writing scaled" );
auto vtkOutput = vtk::createVTKOutput_BlockData( blocks, "BinaryRawFileScaled" );
vtkOutput->addCellDataWriter( make_shared< field::VTKWriter< ScalarField, uint8_t > >( scalarFieldID, "BinaryRawFile" ) );
writeFiles( vtkOutput, true )();
}
}
void GroupDef::writeDocumentation(OutputList &ol)
{
//static bool generateTreeView = Config_getBool("GENERATE_TREEVIEW");
ol.pushGeneratorState();
startFile(ol,getOutputFileBase(),name(),title,HLI_None);
ol.startHeaderSection();
writeSummaryLinks(ol);
ol.startTitleHead(getOutputFileBase());
ol.pushGeneratorState();
ol.disable(OutputGenerator::Man);
ol.parseText(title);
ol.popGeneratorState();
ol.endTitleHead(getOutputFileBase(),title);
addGroupListToTitle(ol,this);
ol.endHeaderSection();
ol.startContents();
if (Doxygen::searchIndex)
{
Doxygen::searchIndex->setCurrentDoc(title,getOutputFileBase());
static QRegExp we("[a-zA-Z_][-a-zA-Z_0-9]*");
int i=0,p=0,l=0;
while ((i=we.match(title,p,&l))!=-1) // foreach word in the title
{
Doxygen::searchIndex->addWord(title.mid(i,l),TRUE);
p=i+l;
}
}
Doxygen::indexList.addIndexItem(this,0,title);
if (!Config_getString("GENERATE_TAGFILE").isEmpty())
{
Doxygen::tagFile << " <compound kind=\"group\">" << endl;
Doxygen::tagFile << " <name>" << convertToXML(name()) << "</name>" << endl;
Doxygen::tagFile << " <title>" << convertToXML(title) << "</title>" << endl;
Doxygen::tagFile << " <filename>" << convertToXML(getOutputFileBase()) << Doxygen::htmlFileExtension << "</filename>" << endl;
}
//---------------------------------------- start flexible part -------------------------------
QListIterator<LayoutDocEntry> eli(
LayoutDocManager::instance().docEntries(LayoutDocManager::Group));
LayoutDocEntry *lde;
for (eli.toFirst();(lde=eli.current());++eli)
{
switch (lde->kind())
{
case LayoutDocEntry::BriefDesc:
writeBriefDescription(ol);
break;
case LayoutDocEntry::MemberDeclStart:
startMemberDeclarations(ol);
break;
case LayoutDocEntry::GroupClasses:
{
LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
writeClasses(ol,ls->title);
}
break;
case LayoutDocEntry::GroupInlineClasses:
{
writeInlineClasses(ol);
}
break;
case LayoutDocEntry::GroupNamespaces:
{
LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
writeNamespaces(ol,ls->title);
}
break;
case LayoutDocEntry::MemberGroups:
writeMemberGroups(ol);
break;
case LayoutDocEntry::MemberDecl:
{
LayoutDocEntryMemberDecl *lmd = (LayoutDocEntryMemberDecl*)lde;
writeMemberDeclarations(ol,lmd->type,lmd->title);
}
break;
case LayoutDocEntry::MemberDeclEnd:
endMemberDeclarations(ol);
break;
case LayoutDocEntry::DetailedDesc:
{
LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
writeDetailedDescription(ol,ls->title);
}
break;
case LayoutDocEntry::MemberDefStart:
startMemberDocumentation(ol);
break;
case LayoutDocEntry::MemberDef:
{
LayoutDocEntryMemberDef *lmd = (LayoutDocEntryMemberDef*)lde;
writeMemberDocumentation(ol,lmd->type,lmd->title);
}
break;
case LayoutDocEntry::MemberDefEnd:
endMemberDocumentation(ol);
break;
case LayoutDocEntry::GroupNestedGroups:
{
LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
writeNestedGroups(ol,ls->title);
}
break;
case LayoutDocEntry::GroupPageDocs:
writePageDocumentation(ol);
break;
case LayoutDocEntry::GroupDirs:
{
LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
writeDirs(ol,ls->title);
}
break;
case LayoutDocEntry::GroupFiles:
{
LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
writeFiles(ol,ls->title);
}
break;
case LayoutDocEntry::GroupGraph:
writeGroupGraph(ol);
break;
case LayoutDocEntry::AuthorSection:
writeAuthorSection(ol);
break;
case LayoutDocEntry::ClassIncludes:
case LayoutDocEntry::ClassInheritanceGraph:
case LayoutDocEntry::ClassNestedClasses:
case LayoutDocEntry::ClassCollaborationGraph:
case LayoutDocEntry::ClassAllMembersLink:
case LayoutDocEntry::ClassUsedFiles:
case LayoutDocEntry::ClassInlineClasses:
case LayoutDocEntry::NamespaceNestedNamespaces:
case LayoutDocEntry::NamespaceClasses:
case LayoutDocEntry::NamespaceInlineClasses:
case LayoutDocEntry::FileClasses:
case LayoutDocEntry::FileNamespaces:
case LayoutDocEntry::FileIncludes:
case LayoutDocEntry::FileIncludeGraph:
case LayoutDocEntry::FileIncludedByGraph:
case LayoutDocEntry::FileSourceLink:
case LayoutDocEntry::FileInlineClasses:
case LayoutDocEntry::DirSubDirs:
case LayoutDocEntry::DirFiles:
case LayoutDocEntry::DirGraph:
err("Internal inconsistency: member %d should not be part of "
"LayoutDocManager::Group entry list\n",lde->kind());
break;
}
}
//---------------------------------------- end flexible part -------------------------------
endFile(ol);
ol.popGeneratorState();
if (!Config_getString("GENERATE_TAGFILE").isEmpty())
{
writeDocAnchorsToTagFile();
Doxygen::tagFile << " </compound>" << endl;
}
if (Config_getBool("SEPARATE_MEMBER_PAGES"))
{
allMemberList->sort();
writeMemberPages(ol);
}
}
bool QueueInterface::writeInputFiles(Structure *s) const
{
return writeFiles(s, m_opt->optimizer()->getInterpretedTemplates(s));
}
void QMenuFilesRecentlyOpened::openFile(const std::string &file)
{
FilesRecentlyOpenedManager::openFile(file);
updateWidget();
writeFiles();
}
void OutputCrosstab::debrief() {
if (hasSummary())
writeFiles();
}
void OutputCrosstab::cleanup() {
if (!hasSummary())
writeFiles();
}
