Changeset 17 for nrEngine


Ignore:
Timestamp:
01/05/07 00:02:16 (13 years ago)
Author:
art
Message:
 
Location:
nrEngine
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • nrEngine/include/ITask.h

    r1 r17  
    279279                NR_FORCEINLINE TaskProperty getTaskProperty() const { return _taskProperty; } 
    280280                 
     281                #if 0 
    281282                /** 
    282283                * Add a new task id of a task on which one this task depends. 
     
    297298                **/ 
    298299                Result addTaskDependency(const ITask* pTask); 
    299  
     300                #endif 
     301                 
     302                /** 
     303                * Add a new task on which one this task depends. 
     304                * 
     305                * @param task Smart poitner to the task 
     306                * @return either OK or: 
     307                **/ 
     308                Result addTaskDependency(SharedPtr<ITask> task); 
     309         
    300310        protected: 
    301311 
     
    338348                int32   _taskGraphColor; 
    339349 
    340                 //! This vector does store all task id's on which one this depends 
    341                 std::vector<TaskId>             _taskDependencies; 
     350                //! This list does store all tasks on which one this depends 
     351                std::list< SharedPtr<ITask> >   _taskDependencies; 
    342352 
    343353                //! Set the task type. This method is private, so only friends can set the type 
  • nrEngine/include/ResourcePtr.h

    r16 r17  
    141141                        * Get the holder to which one this pointer shows 
    142142                        **/ 
    143                         NR_FORCEINLINE const SharedPtr<ResourceHolder>& getResourceHolder() const 
     143                        NR_FORCEINLINE SharedPtr<ResourceHolder> getResourceHolder() const 
    144144                        { 
    145145                                return mHolder; 
  • nrEngine/src/ITask.cpp

    r14 r17  
    109109        } 
    110110 
     111        struct _taskSort : std::less<SharedPtr<ITask> > 
     112        { 
     113                public: 
     114                        bool operator () (const SharedPtr<ITask>& a, const SharedPtr<ITask>& b) 
     115                        { 
     116                                return (*a) < (*b); 
     117                        } 
     118        }; 
     119 
    111120        //-------------------------------------------------------------------- 
    112         Result ITask::addTaskDependency(TaskId id) 
     121        Result ITask::addTaskDependency(SharedPtr<ITask> task) 
     122        { 
     123                // add the task into the list of dependencies 
     124                _taskDependencies.push_back(task); 
     125 
     126                // sort the dependency list  
     127                _taskDependencies.sort(_taskSort()); 
     128                 
     129                // debug info 
     130                NR_Log(Log::LOG_KERNEL, Log::LL_DEBUG, "Task %s depends now on task %s", getTaskName(), task->getTaskName()); 
     131 
     132                return OK; 
     133        } 
     134         
     135        //-------------------------------------------------------------------- 
     136        /*Result ITask::addTaskDependency(TaskId id) 
    113137        { 
    114138                _taskDependencies.push_back(id); 
     
    130154                return addTaskDependency(pTask->getTaskID()); 
    131155        } 
    132  
     156        */ 
     157         
    133158        //-------------------------------------------------------------------- 
    134159        void ITask::_noticeSuspend(){ 
  • nrEngine/src/Kernel.cpp

    r12 r17  
    7676                } 
    7777                 
     78                // resetup to the beginning 
     79                it = taskList.begin(); 
     80                 
    7881                // we go always from teh first element in the list, because it is 
    7982                // the system root task 
     
    9194                                        sprintf(name, "%s::update", t->getTaskName()); 
    9295                                        _nrEngineProfile(name); 
     96                                         
    9397                                        t->updateTask(); 
    9498 
     
    101105                } 
    102106                _loopEndCycle(); 
    103  
     107                 
    104108                PipelineIterator thisIt; 
    105109                TaskId tempID; 
     
    304308                        t->_taskOrder = order; 
    305309                         
    306                         if (proper & TASK_IS_THREAD) 
    307                                 NR_Log(Log::LOG_KERNEL, "Add Task \"%s\" as thread", t->getTaskName()); 
    308                         else 
    309                                 NR_Log(Log::LOG_KERNEL, "Add Task \"%s\" at order = %s", t->getTaskName(), orderToString(int32(t->getTaskOrder())).c_str()); 
    310  
    311310                        // check whenever such task already exists 
    312311                        std::list< SharedPtr<ITask> >::iterator it; 
     
    337336                        t->setTaskID(++lastTaskID); 
    338337 
     338                        // some debug info 
     339                        if (proper & TASK_IS_THREAD) 
     340                                NR_Log(Log::LOG_KERNEL, "Add Task \"%s\" as thread (id = %d)", t->getTaskName(), t->getTaskID()); 
     341                        else 
     342                                NR_Log(Log::LOG_KERNEL, "Add Task \"%s\" at order = %s (id = %d)", t->getTaskName(), orderToString(int32(t->getTaskOrder())).c_str(), t->getTaskID()); 
     343 
    339344                        // init task and check its return code 
    340345                        if (t->onAddTask() != OK){ 
     
    343348                        } 
    344349 
    345                         // find the place for our task according to his order 
     350                        // find the place for our task according to its order 
    346351                        for( it=taskList.begin(); it != taskList.end(); it++){ 
    347352                                SharedPtr<ITask> &comp = (*it); 
     
    359364                // also there is no dependency if this is a thread 
    360365                if (t->_taskOrder != ORDER_SYS_ROOT && !(t->getTaskProperty() & TASK_IS_THREAD)) 
    361                         mRootTask->addTaskDependency(t->getTaskID()); 
     366                        mRootTask->addTaskDependency(t); 
    362367 
    363368                // return the id 
     
    776781                 
    777782                // now check if the task has got childrens 
    778                 if (t->_taskDependencies.size() > 0){ 
     783                if (t->_taskDependencies.size() > 0) 
     784                { 
    779785 
    780786                        // do for each child call this function recursively 
    781                         for (uint32 i = 0; i < t->_taskDependencies.size(); i++){ 
    782  
     787                        /*for (uint32 i = 0; i < t->_taskDependencies.size(); i++) 
     788                        { 
    783789                                PipelineIterator jt; 
    784790                                if (!_getTaskByID(t->_taskDependencies[i], jt, TL_RUNNING | TL_SLEEPING)) return KERNEL_TASK_MISSING; 
     
    796802                                        } 
    797803                                } 
    798                         } 
    799  
     804                        }*/ 
     805                         
     806                        // iterate through all dependencies and check them  
     807                        std::list<SharedPtr<ITask> >::iterator jt = t->_taskDependencies.begin(); 
     808                        for (; jt != t->_taskDependencies.end(); jt ++) 
     809                        { 
     810                                // check whenever the child was already visited 
     811                                if ((*jt)->_taskGraphColor != 2){ 
     812                                        Result ret = _loopGetNextTask(jt, result, depth+1); 
     813 
     814                                        // we return OK only if we have not found any circularity 
     815                                        // and we are on the top (root-node) 
     816                                        if (ret != OK){ 
     817                                                t->_taskGraphColor = 0; 
     818                                                if (depth == 0 && ret != KERNEL_CIRCULAR_DEPENDENCY) return OK; 
     819                                                return ret; 
     820                                        } 
     821                                } 
     822                         
     823                        } 
     824                         
    800825                // we do not have childs, so this is a leaf node 
    801826                } 
Note: See TracChangeset for help on using the changeset viewer.