Changeset 1612 for XIOS/dev/dev_olga/src/node/context.cpp
- Timestamp:
- 11/23/18 14:48:14 (6 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
XIOS/dev/dev_olga/src/node/context.cpp
r1542 r1612 33 33 , idServer_(), client(0), server(0) 34 34 , allProcessed(false), countChildCtx_(0) 35 35 36 { /* Ne rien faire de plus */ } 36 37 … … 65 66 */ 66 67 CContextGroup* CContext::getRoot(void) 68 TRY 67 69 { 68 70 if (root.get()==NULL) root=std::shared_ptr<CContextGroup>(new CContextGroup(xml::CXMLNode::GetRootName())); 69 71 return root.get(); 70 72 } 73 CATCH 71 74 72 75 //---------------------------------------------------------------- … … 77 80 */ 78 81 std::shared_ptr<CCalendar> CContext::getCalendar(void) const 82 TRY 79 83 { 80 84 return (this->calendar); 81 85 } 86 CATCH 82 87 83 88 //---------------------------------------------------------------- … … 88 93 */ 89 94 void CContext::setCalendar(std::shared_ptr<CCalendar> newCalendar) 95 TRY 90 96 { 91 97 this->calendar = newCalendar; 92 98 } 99 CATCH_DUMP_ATTR 93 100 94 101 //---------------------------------------------------------------- … … 98 105 */ 99 106 void CContext::parse(xml::CXMLNode & node) 107 TRY 100 108 { 101 109 CContext::SuperClass::parse(node); … … 152 160 } 153 161 } 162 CATCH_DUMP_ATTR 154 163 155 164 //---------------------------------------------------------------- 156 165 //! Show tree structure of context 157 166 void CContext::ShowTree(StdOStream & out) 167 TRY 158 168 { 159 169 StdString currentContextId = CContext::getCurrent() -> getId(); … … 176 186 CContext::setCurrent(currentContextId); 177 187 } 178 188 CATCH 179 189 180 190 //---------------------------------------------------------------- … … 182 192 //! Convert context object into string (to print) 183 193 StdString CContext::toString(void) const 194 TRY 184 195 { 185 196 StdOStringStream oss; … … 201 212 202 213 } 203 204 214 oss << "</" << CContext::GetName() << " >"; 205 206 215 return (oss.str()); 207 216 } 217 CATCH 208 218 209 219 //---------------------------------------------------------------- … … 216 226 */ 217 227 void CContext::solveDescInheritance(bool apply, const CAttributeMap * const UNUSED(parent)) 228 TRY 218 229 { 219 230 #define DECLARE_NODE(Name_, name_) \ … … 223 234 #include "node_type.conf" 224 235 } 236 CATCH_DUMP_ATTR 225 237 226 238 //---------------------------------------------------------------- … … 228 240 //! Verify if all root definition in the context have child. 229 241 bool CContext::hasChild(void) const 242 TRY 230 243 { 231 244 return ( … … 236 249 false); 237 250 } 251 CATCH 238 252 239 253 //---------------------------------------------------------------- 240 254 241 255 void CContext::CleanTree(void) 256 TRY 242 257 { 243 258 #define DECLARE_NODE(Name_, name_) C##Name_##Definition::ClearAllAttributes(); … … 245 260 #include "node_type.conf" 246 261 } 262 CATCH 263 247 264 ///--------------------------------------------------------------- 248 265 249 266 //! Initialize client side 250 267 void CContext::initClient(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtServer /*= 0*/) 268 TRY 251 269 { 252 270 … … 298 316 } 299 317 } 318 CATCH_DUMP_ATTR 300 319 301 320 /*! … … 306 325 */ 307 326 void CContext::setClientServerBuffer(CContextClient* contextClient, bool bufferForWriting) 327 TRY 308 328 { 309 329 // Estimated minimum event size for small events (10 is an arbitrary constant just for safety) … … 352 372 } 353 373 contextClient->setBufferSize(bufferSize, maxEventSize); 354 355 }374 } 375 CATCH_DUMP_ATTR 356 376 357 377 //! Verify whether a context is initialized 358 378 bool CContext::isInitialized(void) 379 TRY 359 380 { 360 381 return hasClient; 361 382 } 383 CATCH_DUMP_ATTR 362 384 363 385 void CContext::initServer(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtClient /*= 0*/) 386 TRY 364 387 { 365 388 hasServer=true; … … 394 417 client = new CContextClient(this,intraCommClient,interCommClient, cxtClient); 395 418 } 419 CATCH_DUMP_ATTR 396 420 397 421 //! Try to send the buffers and receive possible answers 398 422 bool CContext::checkBuffersAndListen(bool enableEventsProcessing /*= true*/) 423 TRY 399 424 { 400 425 bool clientReady, serverFinished; … … 434 459 } 435 460 } 461 CATCH_DUMP_ATTR 436 462 437 463 //! Terminate a context 438 464 void CContext::finalize(void) 465 TRY 439 466 { 440 467 if (hasClient && !hasServer) // For now we only use server level 1 to read data … … 527 554 } 528 555 } 556 CATCH_DUMP_ATTR 529 557 530 558 //! Free internally allocated communicators 531 559 void CContext::freeComms(void) 560 TRY 532 561 { 533 562 for (std::list<MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it) … … 535 564 comms.clear(); 536 565 } 566 CATCH_DUMP_ATTR 537 567 538 568 //! Deallocate buffers allocated by clientContexts 539 569 void CContext::releaseClientBuffers(void) 570 TRY 540 571 { 541 572 client->releaseBuffers(); … … 543 574 clientPrimServer[i]->releaseBuffers(); 544 575 } 576 CATCH_DUMP_ATTR 545 577 546 578 void CContext::postProcessingGlobalAttributes() 579 TRY 547 580 { 548 581 if (allProcessed) return; … … 608 641 allProcessed = true; 609 642 } 643 CATCH_DUMP_ATTR 610 644 611 645 void CContext::sendPostProcessingGlobalAttributes() 646 TRY 612 647 { 613 648 // Use correct context client to send message … … 634 669 } 635 670 } 671 CATCH_DUMP_ATTR 636 672 637 673 void CContext::recvPostProcessingGlobalAttributes(CEventServer& event) 674 TRY 638 675 { 639 676 CBufferIn* buffer=event.subEvents.begin()->buffer; … … 642 679 get(id)->recvPostProcessingGlobalAttributes(*buffer); 643 680 } 681 CATCH 644 682 645 683 void CContext::recvPostProcessingGlobalAttributes(CBufferIn& buffer) 684 TRY 646 685 { 647 686 postProcessingGlobalAttributes(); 648 687 } 688 CATCH_DUMP_ATTR 649 689 650 690 /*! … … 657 697 and the active fields (fields will be written onto active files) 658 698 */ 699 659 700 void CContext::closeDefinition(void) 701 TRY 660 702 { 661 703 CTimer::get("Context : close definition").resume() ; … … 688 730 CTimer::get("Context : close definition").suspend() ; 689 731 } 732 CATCH_DUMP_ATTR 690 733 691 734 void CContext::findAllEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles) 735 TRY 692 736 { 693 737 for (unsigned int i = 0; i < activeFiles.size(); i++) 694 738 (void)activeFiles[i]->getEnabledFields(); 695 739 } 740 CATCH_DUMP_ATTR 696 741 697 742 void CContext::readAttributesOfEnabledFieldsInReadModeFiles() 743 TRY 698 744 { 699 745 for (unsigned int i = 0; i < this->enabledReadModeFiles.size(); ++i) 700 746 (void)this->enabledReadModeFiles[i]->readAttributesOfEnabledFieldsInReadMode(); 701 747 } 748 CATCH_DUMP_ATTR 702 749 703 750 void CContext::sendGridComponentEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles) 751 TRY 704 752 { 705 753 int size = activeFiles.size(); … … 709 757 } 710 758 } 759 CATCH_DUMP_ATTR 711 760 712 761 /*! … … 715 764 */ 716 765 void CContext::sendGridEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles) 766 TRY 717 767 { 718 768 int size = activeFiles.size(); … … 722 772 } 723 773 } 774 CATCH_DUMP_ATTR 724 775 725 776 void CContext::checkGridEnabledFields() 777 TRY 726 778 { 727 779 int size = enabledFiles.size(); … … 731 783 } 732 784 } 785 CATCH_DUMP_ATTR 733 786 734 787 /*! … … 737 790 */ 738 791 void CContext::checkGridEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles) 792 TRY 739 793 { 740 794 int size = activeFiles.size(); … … 744 798 } 745 799 } 800 CATCH_DUMP_ATTR 746 801 747 802 /*! … … 751 806 */ 752 807 void CContext::solveOnlyRefOfEnabledFields(bool sendToServer) 808 TRY 753 809 { 754 810 int size = this->enabledFiles.size(); … … 763 819 } 764 820 } 821 CATCH_DUMP_ATTR 765 822 766 823 /*! … … 771 828 */ 772 829 void CContext::solveAllRefOfEnabledFieldsAndTransform(bool sendToServer) 830 TRY 773 831 { 774 832 int size = this->enabledFiles.size(); … … 778 836 } 779 837 } 838 CATCH_DUMP_ATTR 780 839 781 840 void CContext::buildFilterGraphOfEnabledFields() 841 TRY 782 842 { 783 843 int size = this->enabledFiles.size(); … … 787 847 } 788 848 } 849 CATCH_DUMP_ATTR 789 850 790 851 void CContext::postProcessFilterGraph() 852 TRY 791 853 { 792 854 int size = enabledFiles.size(); … … 796 858 } 797 859 } 860 CATCH_DUMP_ATTR 798 861 799 862 void CContext::startPrefetchingOfEnabledReadModeFiles() 863 TRY 800 864 { 801 865 int size = enabledReadModeFiles.size(); … … 805 869 } 806 870 } 871 CATCH_DUMP_ATTR 807 872 808 873 void CContext::doPreTimestepOperationsForEnabledReadModeFiles() 874 TRY 809 875 { 810 876 int size = enabledReadModeFiles.size(); … … 814 880 } 815 881 } 882 CATCH_DUMP_ATTR 816 883 817 884 void CContext::doPostTimestepOperationsForEnabledReadModeFiles() 885 TRY 818 886 { 819 887 int size = enabledReadModeFiles.size(); … … 823 891 } 824 892 } 893 CATCH_DUMP_ATTR 825 894 826 895 void CContext::findFieldsWithReadAccess(void) 896 TRY 827 897 { 828 898 fieldsWithReadAccess.clear(); … … 838 908 } 839 909 } 910 CATCH_DUMP_ATTR 840 911 841 912 void CContext::solveAllRefOfFieldsWithReadAccess() 913 TRY 842 914 { 843 915 for (size_t i = 0; i < fieldsWithReadAccess.size(); ++i) 844 916 fieldsWithReadAccess[i]->solveAllReferenceEnabledField(false); 845 917 } 918 CATCH_DUMP_ATTR 846 919 847 920 void CContext::buildFilterGraphOfFieldsWithReadAccess() 921 TRY 848 922 { 849 923 for (size_t i = 0; i < fieldsWithReadAccess.size(); ++i) 850 924 fieldsWithReadAccess[i]->buildFilterGraph(garbageCollector, true); 851 925 } 926 CATCH_DUMP_ATTR 852 927 853 928 void CContext::solveAllInheritance(bool apply) 929 TRY 854 930 { 855 931 // Résolution des héritages descendants (cà d des héritages de groupes) … … 874 950 875 951 } 952 CATCH_DUMP_ATTR 876 953 877 954 void CContext::findEnabledFiles(void) 955 TRY 878 956 { 879 957 const std::vector<CFile*> allFiles = CFile::getAll(); … … 924 1002 925 1003 } 1004 CATCH_DUMP_ATTR 926 1005 927 1006 void CContext::distributeFiles(void) 1007 TRY 928 1008 { 929 1009 bool distFileMemory=false ; … … 933 1013 else distributeFileOverBandwith() ; 934 1014 } 935 1015 CATCH_DUMP_ATTR 936 1016 937 1017 void CContext::distributeFileOverBandwith(void) 1018 TRY 938 1019 { 939 1020 double eps=std::numeric_limits<double>::epsilon()*10 ; … … 1015 1096 } 1016 1097 } 1098 CATCH_DUMP_ATTR 1017 1099 1018 1100 void CContext::distributeFileOverMemoryBandwith(void) 1101 TRY 1019 1102 { 1020 1103 // If primary server … … 1107 1190 } 1108 1191 } 1109 1110 1192 CATCH_DUMP_ATTR 1111 1193 1112 1194 /*! … … 1114 1196 */ 1115 1197 void CContext::findEnabledWriteModeFiles(void) 1198 TRY 1116 1199 { 1117 1200 int size = this->enabledFiles.size(); … … 1123 1206 } 1124 1207 } 1208 CATCH_DUMP_ATTR 1125 1209 1126 1210 /*! … … 1128 1212 */ 1129 1213 void CContext::findEnabledReadModeFiles(void) 1214 TRY 1130 1215 { 1131 1216 int size = this->enabledFiles.size(); … … 1136 1221 } 1137 1222 } 1223 CATCH_DUMP_ATTR 1138 1224 1139 1225 void CContext::closeAllFile(void) 1226 TRY 1140 1227 { 1141 1228 std::vector<CFile*>::const_iterator … … 1148 1235 } 1149 1236 } 1237 CATCH_DUMP_ATTR 1150 1238 1151 1239 /*! … … 1157 1245 */ 1158 1246 bool CContext::dispatchEvent(CEventServer& event) 1247 TRY 1159 1248 { 1160 1249 … … 1198 1287 } 1199 1288 } 1289 CATCH 1200 1290 1201 1291 //! Client side: Send a message to server to make it close 1202 1292 void CContext::sendCloseDefinition(void) 1293 TRY 1203 1294 { 1204 1295 // Use correct context client to send message … … 1223 1314 } 1224 1315 } 1316 CATCH_DUMP_ATTR 1225 1317 1226 1318 //! Server side: Receive a message of client announcing a context close 1227 1319 void CContext::recvCloseDefinition(CEventServer& event) 1320 TRY 1228 1321 { 1229 1322 CBufferIn* buffer=event.subEvents.begin()->buffer; … … 1232 1325 get(id)->closeDefinition(); 1233 1326 } 1327 CATCH 1234 1328 1235 1329 //! Client side: Send a message to update calendar in each time step 1236 1330 void CContext::sendUpdateCalendar(int step) 1331 TRY 1237 1332 { 1238 1333 // Use correct context client to send message … … 1258 1353 } 1259 1354 } 1355 CATCH_DUMP_ATTR 1260 1356 1261 1357 //! Server side: Receive a message of client annoucing calendar update 1262 1358 void CContext::recvUpdateCalendar(CEventServer& event) 1359 TRY 1263 1360 { 1264 1361 CBufferIn* buffer=event.subEvents.begin()->buffer; … … 1267 1364 get(id)->recvUpdateCalendar(*buffer); 1268 1365 } 1366 CATCH 1269 1367 1270 1368 //! Server side: Receive a message of client annoucing calendar update 1271 1369 void CContext::recvUpdateCalendar(CBufferIn& buffer) 1370 TRY 1272 1371 { 1273 1372 int step; … … 1279 1378 } 1280 1379 } 1380 CATCH_DUMP_ATTR 1281 1381 1282 1382 //! Client side: Send a message to create header part of netcdf file 1283 1383 void CContext::sendCreateFileHeader(void) 1384 TRY 1284 1385 { 1285 1386 // Use correct context client to send message … … 1306 1407 } 1307 1408 } 1409 CATCH_DUMP_ATTR 1308 1410 1309 1411 //! Server side: Receive a message of client annoucing the creation of header part of netcdf file 1310 1412 void CContext::recvCreateFileHeader(CEventServer& event) 1413 TRY 1311 1414 { 1312 1415 CBufferIn* buffer=event.subEvents.begin()->buffer; … … 1315 1418 get(id)->recvCreateFileHeader(*buffer); 1316 1419 } 1420 CATCH 1317 1421 1318 1422 //! Server side: Receive a message of client annoucing the creation of header part of netcdf file 1319 1423 void CContext::recvCreateFileHeader(CBufferIn& buffer) 1424 TRY 1320 1425 { 1321 1426 if (!hasClient && hasServer) 1322 1427 createFileHeader(); 1323 1428 } 1429 CATCH_DUMP_ATTR 1324 1430 1325 1431 //! Client side: Send a message to do some post processing on server 1326 1432 void CContext::sendProcessingGridOfEnabledFields() 1433 TRY 1327 1434 { 1328 1435 // Use correct context client to send message … … 1348 1455 } 1349 1456 } 1457 CATCH_DUMP_ATTR 1350 1458 1351 1459 //! Server side: Receive a message to do some post processing 1352 1460 void CContext::recvProcessingGridOfEnabledFields(CEventServer& event) 1461 TRY 1353 1462 { 1354 1463 CBufferIn* buffer=event.subEvents.begin()->buffer; … … 1356 1465 *buffer>>id; 1357 1466 } 1467 CATCH 1358 1468 1359 1469 //! Client side: Send a message to do some post processing on server 1360 1470 void CContext::sendPostProcessing() 1471 TRY 1361 1472 { 1362 1473 // Use correct context client to send message … … 1382 1493 } 1383 1494 } 1495 CATCH_DUMP_ATTR 1384 1496 1385 1497 //! Server side: Receive a message to do some post processing 1386 1498 void CContext::recvPostProcessing(CEventServer& event) 1499 TRY 1387 1500 { 1388 1501 CBufferIn* buffer=event.subEvents.begin()->buffer; … … 1391 1504 get(id)->recvPostProcessing(*buffer); 1392 1505 } 1506 CATCH 1393 1507 1394 1508 //! Server side: Receive a message to do some post processing 1395 1509 void CContext::recvPostProcessing(CBufferIn& buffer) 1510 TRY 1396 1511 { 1397 1512 CCalendarWrapper::get(CCalendarWrapper::GetDefName())->createCalendar(); 1398 1513 postProcessing(); 1399 1514 } 1515 CATCH_DUMP_ATTR 1400 1516 1401 1517 const StdString& CContext::getIdServer() 1518 TRY 1402 1519 { 1403 1520 if (hasClient) … … 1409 1526 if (hasServer) return (this->getId()); 1410 1527 } 1528 CATCH_DUMP_ATTR 1411 1529 1412 1530 const StdString& CContext::getIdServer(const int i) 1531 TRY 1413 1532 { 1414 1533 idServer_ = this->getId(); … … 1417 1536 return idServer_; 1418 1537 } 1419 1538 CATCH_DUMP_ATTR 1420 1539 1421 1540 /*! … … 1426 1545 */ 1427 1546 void CContext::postProcessing() 1547 TRY 1428 1548 { 1429 1549 if (isPostProcessed) return; … … 1488 1608 isPostProcessed = true; 1489 1609 } 1610 CATCH_DUMP_ATTR 1490 1611 1491 1612 /*! … … 1498 1619 std::map<int, StdSize> CContext::getAttributesBufferSize(std::map<int, StdSize>& maxEventSize, 1499 1620 CContextClient* contextClient, bool bufferForWriting /*= "false"*/) 1621 TRY 1500 1622 { 1501 1623 // As calendar attributes are sent even if there are no active files or fields, maps are initialized according the size of calendar attributes … … 1529 1651 return attributesSize; 1530 1652 } 1653 CATCH_DUMP_ATTR 1531 1654 1532 1655 /*! … … 1539 1662 std::map<int, StdSize> CContext::getDataBufferSize(std::map<int, StdSize>& maxEventSize, 1540 1663 CContextClient* contextClient, bool bufferForWriting /*= "false"*/) 1664 TRY 1541 1665 { 1542 1666 std::map<int, StdSize> dataSize; … … 1547 1671 for (size_t i = 0; i < numEnabledFiles; ++i) 1548 1672 { 1549 // CFile* file = this->enabledFiles[i];1550 1673 CFile* file = fileList[i]; 1551 1674 if (file->getContextClient() == contextClient) … … 1575 1698 return dataSize; 1576 1699 } 1700 CATCH_DUMP_ATTR 1577 1701 1578 1702 //! Client side: Send infomation of active files (files are enabled to write out) 1579 1703 void CContext::sendEnabledFiles(const std::vector<CFile*>& activeFiles) 1704 TRY 1580 1705 { 1581 1706 int size = activeFiles.size(); … … 1595 1720 } 1596 1721 } 1722 CATCH_DUMP_ATTR 1597 1723 1598 1724 //! Client side: Send information of active fields (ones are written onto files) 1599 1725 void CContext::sendEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles) 1726 TRY 1600 1727 { 1601 1728 int size = activeFiles.size(); … … 1605 1732 } 1606 1733 } 1734 CATCH_DUMP_ATTR 1607 1735 1608 1736 //! Client side: Check if the defined axis, domains and grids are eligible for compressed indexed output 1609 1737 void CContext::checkAxisDomainsGridsEligibilityForCompressedOutput() 1738 TRY 1610 1739 { 1611 1740 if (!hasClient) return; … … 1623 1752 (*it)->checkEligibilityForCompressedOutput(); 1624 1753 } 1754 CATCH_DUMP_ATTR 1625 1755 1626 1756 //! Client side: Prepare the timeseries by adding the necessary files 1627 1757 void CContext::prepareTimeseries() 1758 TRY 1628 1759 { 1629 1760 if (!hasClient) return; … … 1723 1854 } 1724 1855 } 1856 CATCH_DUMP_ATTR 1725 1857 1726 1858 //! Client side: Send information of reference grid of active fields 1727 1859 void CContext::sendRefGrid(const std::vector<CFile*>& activeFiles) 1860 TRY 1728 1861 { 1729 1862 std::set<StdString> gridIds; … … 1757 1890 } 1758 1891 } 1892 CATCH_DUMP_ATTR 1759 1893 1760 1894 //! Client side: Send information of reference domain, axis and scalar of active fields 1761 1895 void CContext::sendRefDomainsAxisScalars(const std::vector<CFile*>& activeFiles) 1896 TRY 1762 1897 { 1763 1898 std::set<StdString> domainIds, axisIds, scalarIds; … … 1818 1953 } 1819 1954 } 1955 CATCH_DUMP_ATTR 1820 1956 1821 1957 //! Update calendar in each time step 1822 1958 void CContext::updateCalendar(int step) 1959 TRY 1823 1960 { 1824 1961 int prevStep = calendar->getStep(); … … 1850 1987 << "Illegal calendar update: previous step was " << prevStep << ", new step " << step << "is in the past!") 1851 1988 } 1989 CATCH_DUMP_ATTR 1852 1990 1853 1991 void CContext::initReadFiles(void) 1992 TRY 1854 1993 { 1855 1994 vector<CFile*>::const_iterator it; … … 1860 1999 } 1861 2000 } 2001 CATCH_DUMP_ATTR 1862 2002 1863 2003 //! Server side: Create header of netcdf file 1864 2004 void CContext::createFileHeader(void) 2005 TRY 1865 2006 { 1866 2007 vector<CFile*>::const_iterator it; … … 1872 2013 } 1873 2014 } 2015 CATCH_DUMP_ATTR 1874 2016 1875 2017 //! Get current context 1876 2018 CContext* CContext::getCurrent(void) 2019 TRY 1877 2020 { 1878 2021 return CObjectFactory::GetObject<CContext>(CObjectFactory::GetCurrentContextId()).get(); 1879 2022 } 2023 CATCH 1880 2024 1881 2025 /*! … … 1884 2028 */ 1885 2029 void CContext::setCurrent(const string& id) 2030 TRY 1886 2031 { 1887 2032 CObjectFactory::SetCurrentContextId(id); 1888 2033 CGroupFactory::SetCurrentContextId(id); 1889 2034 } 2035 CATCH 1890 2036 1891 2037 /*! … … 1895 2041 */ 1896 2042 CContext* CContext::create(const StdString& id) 2043 TRY 1897 2044 { 1898 2045 CContext::setCurrent(id); … … 1910 2057 return (context); 1911 2058 } 1912 2059 CATCH 1913 2060 1914 2061 //! Server side: Receive a message to do some post processing 1915 2062 void CContext::recvRegistry(CEventServer& event) 2063 TRY 1916 2064 { 1917 2065 CBufferIn* buffer=event.subEvents.begin()->buffer; … … 1920 2068 get(id)->recvRegistry(*buffer); 1921 2069 } 2070 CATCH 1922 2071 1923 2072 void CContext::recvRegistry(CBufferIn& buffer) 2073 TRY 1924 2074 { 1925 2075 if (server->intraCommRank==0) … … 1930 2080 } 1931 2081 } 2082 CATCH_DUMP_ATTR 1932 2083 1933 2084 void CContext::sendRegistry(void) 2085 TRY 1934 2086 { 1935 2087 registryOut->hierarchicalGatherRegistry() ; … … 1957 2109 } 1958 2110 } 2111 CATCH_DUMP_ATTR 1959 2112 1960 2113 /*! … … 1963 2116 */ 1964 2117 bool CContext::isFinalized(void) 2118 TRY 1965 2119 { 1966 2120 return finalized; 1967 2121 } 2122 CATCH_DUMP_ATTR 2123 ///-------------------------------------------------------------- 2124 StdString CContext::dumpClassAttributes(void) 2125 { 2126 StdString str; 2127 str.append("enabled files=\""); 2128 int size = this->enabledFiles.size(); 2129 for (int i = 0; i < size; ++i) 2130 { 2131 str.append(enabledFiles[i]->getId()); 2132 str.append(" "); 2133 } 2134 str.append("\""); 2135 return str; 2136 } 1968 2137 1969 2138 } // namespace xios
Note: See TracChangeset
for help on using the changeset viewer.