Shell.h

Go to the documentation of this file.

/**********************************************************************
** This program is part of 'MOOSE', the
** Messaging Object Oriented Simulation Environment.
**           Copyright (C) 2003-2009 Upinder S. Bhalla. and NCBS
** It is made available under the terms of the
** GNU Lesser General Public License version 2.1
** See the file COPYING.LIB for the full notice.
**********************************************************************/

#ifndef _SHELL_H
#define _SHELL_H

#include <string>

using namespace std;


class DestFinfo;

enum AssignmentType { SINGLE, VECTOR, REPEAT };

// These Finfo objects are exposed to other classes for convenience in test cases and other functions.
// NOTE: These should never be re-registered in an initCinfo of another class.
//extern SrcFinfo4< Id, DataId, FuncId, unsigned int >* requestGet(); // Not available
extern DestFinfo* receiveGet();
//extern SrcFinfo2< unsigned int, unsigned int >* ack(); // Not currently used.

enum NodePolicy { MooseGlobal, MooseBlockBalance, MooseSingleNode };
class NodeBalance
{
public:
    NodeBalance( unsigned int nd, NodePolicy np, unsigned int node )
        : numData( nd ), policy( np ), preferredNode( node )
    {
        ;
    }

    unsigned int numData;
    NodePolicy policy;
    unsigned int preferredNode;
};

class Shell
{
public:
    Shell();
    ~Shell();

#ifdef  CYMOOSE

    Shell* initShell();


    Id create( string type, string name, unsigned int numData,
               NodePolicy nodePolicy = MooseBlockBalance,
               unsigned int preferredNode = 1 );


#endif     /* -----  CYMOOSE  ----- */
    // Field functions

    string doVersion();

    void setCwe( ObjId cwe );

    ObjId getCwe() const;

    bool isRunning() const;

    // Parser functions

    Id doCreate( string type, ObjId parent, string name,
                 unsigned int numData,
                 NodePolicy nodePolicy = MooseBlockBalance,
                 unsigned int preferredNode = 1 );

    bool doDelete( ObjId oid );

    ObjId doAddMsg( const string& msgType,
                    ObjId src, const string& srcField,
                    ObjId dest, const string& destField );

    void doQuit( );

    void doStart( double runtime, bool notify = false );

    void doNonBlockingStart( double runtime );

    void doReinit();

    void doStop();

    void doTerminate();

    void doMove( Id orig, ObjId newParent );

    Id doCopy( Id orig, ObjId newParent, string newName,
               unsigned int n, bool toGlobal, bool copyExtMsgs );

    ObjId doFind( const string& path ) const;

    void doUseClock( string path, string field, unsigned int tick );

    Id doLoadModel( const string& fname, const string& modelpath,
                    const string& solverClass = "" );

    void doSaveModel( Id model, const string& fileName, bool qflag = 0 ) const;

    void doSyncDataHandler( Id tgt );

    void doReacDiffMesh( Id baseCompartment );

    void doSetParserIdleFlag( bool isParserIdle );

    static void clearRestructuringQ();
    // DestFinfo functions

    void start( double runTime );

    void initAck();

    void waitForAck();

    void handleAck( unsigned int ackNode, unsigned int status );

    bool isAckPending() const;

    void handleQuit();

    void handleCreate( const Eref& e,
                       string type, ObjId parent, Id newElm, string name,
                       NodeBalance nb, unsigned int parentMsgIndex );
    void destroy( const Eref& e, ObjId oid);

    void innerCreate( string type, ObjId parent, Id newElm, string name,
                      const NodeBalance& nb, unsigned int parentMsgIndex );

    bool innerCopy( const vector< ObjId >& args, const string& newName,
                    unsigned int n, bool toGlobal, bool copyExtMsgs );

    const Msg* innerAddMsg( string msgType, ObjId src, string srcField,
                            ObjId dest, string destField, unsigned int msgIndex );

    void handleAddMsg( const Eref& e,
                       string msgType,
                       ObjId src, string srcField,
                       ObjId dest, string destField,
                       unsigned int msgIndex );

    bool innerMove( Id orig, ObjId newParent );

    void handleMove( const Eref& e,
                     Id orig, ObjId newParent );

    void handleSync( const Eref& e, Id elm, FuncId fid);

    void handleCopy( const Eref& e,
                     vector< ObjId > args, string newName, unsigned int n,
                     bool toGlobal, bool copyExtMsgs );

    bool innerUseClock( string path, string field,
                        unsigned int tick, unsigned int msgIndex);

    void handleUseClock( const Eref& e,
                         string path, string field, unsigned int tick,
                         unsigned int msgIndex );

    void addClockMsgs( const vector< ObjId >& list,
                       const string& field, unsigned int tick, unsigned int msgIndex );

    static void dropClockMsgs(
        const vector< ObjId >& list, const string& field );

    // Thread and MPI handling functions

    static void setHardware(
        unsigned int numCores, unsigned int numNodes,
        unsigned int myNode );

    static unsigned int myNode();
    static unsigned int numNodes();
    static unsigned int numCores();
    static unsigned int numProcessThreads();

    static void loadBalance();

    static void launchParser();

    static bool inBlockingParserCall();

    static bool isSingleThreaded();

    static bool keepLooping();

    static bool isParserIdle();

    static void launchThreads();

    static unsigned int reduceInt( unsigned int val );

    // Sets up clock ticks. Essentially is a call into the
    // Clock::setupTick function, but may be needed to be called from
    // the parser so it is a Shell function too.
    void doSetClock( unsigned int tickNum, double dt );

    // Should set these up as streams so that we can build error
    // messages similar to cout.
    void warning( const string& text );
    void error( const string& text );

    static const Cinfo* initCinfo();

    // Utility functions
    static bool adopt( ObjId parent, Id child, unsigned int msgIndex );
    static bool adopt( Id parent, Id child, unsigned int msgIndex );

    static const unsigned int OkStatus;
    static const unsigned int ErrorStatus;

    // Initialization function, used only in main.cpp:init()
    void setShellElement( Element* shelle );

    static const ProcInfo* procInfo();

    const ProcInfo* getProcInfo( unsigned int index ) const;

    static bool chopString( const string& path, vector< string >& ret,
                            char separator = '/' );

    static bool isNameValid( const string& name );

    static bool chopPath( const string& path, vector< string >& ret,
                          vector< unsigned int >& index );

    // static void wildcard( const string& path, vector< Id >& list );

    static void cleanSimulation();

    void expectVector( bool flag );

private:
    Element* shelle_; // It is useful for the Shell to have this.

    vector< double* > getBuf_;

    bool gettingVector_;

    unsigned int numGetVecReturns_;

    static bool isBlockedOnParser_;

    static bool keepLooping_;

    static unsigned int numCores_;

    static unsigned int numProcessThreads_;

    static unsigned int numNodes_;

    static unsigned int myNode_;

    static ProcInfo p_;

    static vector< ProcInfo > threadProcs_;

    static unsigned int numAcks_;
    static vector< unsigned int > acked_;


    static bool doReinit_;

    static double runtime_;

    static bool isParserIdle_;

    ObjId cwe_;
};

/*
extern bool set( Eref& dest, const string& destField, const string& val );

extern bool get( const Eref& dest, const string& destField );
*/

#endif // _SHELL_H