コード例 #1
0
ファイル: TaskManager.cs プロジェクト: sam-j-mair/Xeno-Engine
        //-------------------------------------------------------------------------------
        /// <summary>
        /// start created task.
        /// </summary>
        /// <param name="taskHandle">task identifier.</param>
        //-------------------------------------------------------------------------------
        #region Execute / Destory
        public void ExecuteTask(TaskHandle taskHandle)
        {
            TaskType   taskType   = GetTaskByHandle(taskHandle);
            QueueEntry queueEntry = new QueueEntry(taskType);

            m_queueLock.TryEnterWriteLock(1000);
            m_taskQueue.Enqueue(queueEntry);
            m_queueLock.ExitWriteLock();
        }
コード例 #2
0
ファイル: TaskManager.cs プロジェクト: sam-j-mair/Xeno-Engine
        //-------------------------------------------------------------------------------
        /// <summary>
        /// Destroys created task.
        /// </summary>
        /// <param name="taskHandle">task identifier.</param>
        //-------------------------------------------------------------------------------
        public void DestroyTask(TaskHandle taskHandle)
        {
            TaskType taskType = GetTaskByHandle(taskHandle);

            Console.WriteLine("Removing " + taskType.Name);
            m_dictionaryLock.TryEnterWriteLock(5);
            m_tasks.Remove(taskHandle);
            m_dictionaryLock.ExitWriteLock();
        }
コード例 #3
0
        //----------------------------------------------------------------------------------
        /// <summary>
        /// unload assets
        /// </summary>
        /// <param name="task"></param>
        //----------------------------------------------------------------------------------
        public void Unload(Object task)
        {
            Task <Object> theTask  = task as Task <Object>;
            Asset         theAsset = theTask.UserData as Asset;
            TaskHandle    handle   = TaskManager.Instance.CreateTask <bool>(theAsset, theAsset.UnloadAssets, false);

            TaskManager.Instance.ExecuteTask(handle);
            TaskManager.Instance.GetTaskByHandle(handle).Event.WaitOne();
            theTask.ReturnData = theAsset;
        }
コード例 #4
0
ファイル: TaskManager.cs プロジェクト: sam-j-mair/Xeno-Engine
        //-------------------------------------------------------------------------------
        //-------------------------------------------------------------------------------
        public ManualResetEvent GetResetEvent(TaskHandle taskHandle)
        {
            ManualResetEvent resetEvent;

            m_dictionaryLock.TryEnterReadLock(5);
            {
                resetEvent = m_tasks[taskHandle].Event;
            }
            m_dictionaryLock.ExitReadLock();

            return(resetEvent);
        }
コード例 #5
0
ファイル: TaskManager.cs プロジェクト: sam-j-mair/Xeno-Engine
        //-------------------------------------------------------------------------------
        /// <summary>
        /// accessors
        /// </summary>
        /// <param name="taskHandle">the handle for the task to access.</param>
        /// <returns>Task</returns>
        //-------------------------------------------------------------------------------
        #region Get Functions
        public TaskType GetTaskByHandle(TaskHandle taskHandle)
        {
            TaskType taskType;

            m_dictionaryLock.TryEnterReadLock(5);
            {
                taskType = m_tasks[taskHandle];
            }
            m_dictionaryLock.ExitReadLock();

            return(taskType);
        }
コード例 #6
0
ファイル: TaskManager.cs プロジェクト: sam-j-mair/Xeno-Engine
        //-------------------------------------------------------------------------------
        /// <summary>
        /// overloaded: Creates a task.
        /// </summary>
        /// <typeparam name="T">data type.</typeparam>
        /// <param name="aTaskCompletedCallBacks"> callback array upon complete.</param>
        /// <param name="userData">user data to be used in task.</param>
        /// <param name="task">thread</param>
        /// <param name="bContinuousExecution">if allow continuous execution.</param>
        /// <returns></returns>
        //-------------------------------------------------------------------------------
        public TaskHandle CreateTask <T>(TaskCompleted[] aTaskCompletedCallBacks, object userData, ParameterizedThreadStart task, bool bContinuousExecution)
        {
            Task <T> theTask = new Task <T>(aTaskCompletedCallBacks, userData, task, bContinuousExecution);

            theTask.Name = "Task " + m_nTaskCount;
            TaskHandle taskHandle = new TaskHandle(m_nTaskCount++);

            theTask.Handle = taskHandle;

            m_dictionaryLock.TryEnterWriteLock(5);
            {
                m_tasks.Add(taskHandle, theTask);
            }
            m_dictionaryLock.ExitWriteLock();

            return(taskHandle);
        }
コード例 #7
0
ファイル: TaskManager.cs プロジェクト: sam-j-mair/Xeno-Engine
        //-------------------------------------------------------------------------------
        /// <summary>
        /// Get return data from task after completion.
        /// </summary>
        /// <typeparam name="T">data type</typeparam>
        /// <param name="taskHandle">handle for particular task.</param>
        /// <returns>data from task.</returns>
        //-------------------------------------------------------------------------------
        public T GetReturnData <T>(TaskHandle taskHandle)
        {
            TaskType task;

            m_dictionaryLock.TryEnterReadLock(5);
            task = m_tasks[taskHandle];
            m_dictionaryLock.ExitReadLock();

            Debug.Assert(task != null);

            Type type = task.GetType();

            PropertyInfo property   = type.GetProperty("ReturnData");
            MethodInfo   methodInfo = property.GetGetMethod();

            T returnData = (T)methodInfo.Invoke(task, null);

            DestroyTask(taskHandle);

            return(returnData);
        }
コード例 #8
0
ファイル: TaskManager.cs プロジェクト: sam-j-mair/Xeno-Engine
        //-------------------------------------------------------------------------------
        /// <summary>
        /// Creates a new task.
        /// </summary>
        /// <typeparam name="T">T is the stored data type</typeparam>
        /// <param name="userData">user data to be used in the task.</param>
        /// <param name="task">the thread for the task.</param>
        /// <param name="bContinuousExecution">if the task is to continuously execute and readd its self.</param>
        /// <returns></returns>
        //-------------------------------------------------------------------------------
        #region Create Task Methods
        public TaskHandle CreateTask <T>(object userData, ParameterizedThreadStart task, bool bContinuousExecution)
        {
            //create reset event object.
            ManualResetEvent resetEvent = new ManualResetEvent(false);
            Task <T>         theTask    = new Task <T>(resetEvent, userData, task, bContinuousExecution);

            theTask.Name = "Task " + m_nTaskCount;
            //create new task handle to identify this task
            TaskHandle taskHandle = new TaskHandle(m_nTaskCount++);

            theTask.Handle = taskHandle;

            //lock and add task to dictionary.
            m_dictionaryLock.TryEnterWriteLock(5);
            {
                m_tasks.Add(taskHandle, theTask);
            }
            m_dictionaryLock.ExitWriteLock();

            return(taskHandle);
        }
コード例 #9
0
        //----------------------------------------------------------------------------------
        /// <summary>
        /// Stream assets in.
        /// </summary>
        /// <param name="szAssetGroupName"></param>
        /// <returns></returns>
        //----------------------------------------------------------------------------------
        private StreamChunk StreamAssets(String szAssetGroupName)
        {
            List <LoadingTask>      loadingTasks = new List <LoadingTask>();
            List <ManualResetEvent> resetEvents  = new List <ManualResetEvent>();

            RegionLoader regionLoader = new RegionLoader(m_iServerProvider);

            regionLoader.RootDirectory = "Content";

            StreamChunkDefinition streamChunkDefinition;
            String szFullPath = szAssetGroupName;

            streamChunkDefinition = regionLoader.Load <StreamChunkDefinition>(szFullPath);

            List <TaskHandle> aTaskHandles = new List <TaskHandle>(streamChunkDefinition.m_assetDefinitions.Count);

            StreamChunk streamChunk = new StreamChunk(szAssetGroupName);

            foreach (AssetDefinition assetDef in streamChunkDefinition.m_assetDefinitions)
            {
#if MT_LOAD
                #region Multi-Threaded Version

                LoadingTask loadTask   = new LoadingTask();
                TaskHandle  taskHandle = TaskManager.Instance.CreateTask <Object>(new LoadingData(assetDef, regionLoader), loadTask.Load, false);
                aTaskHandles.Add(taskHandle);
                loadingTasks.Add(loadTask);

                #endregion
#else
                #region Single-Thread Version
                //                 Object assetObject;
                //                 String szFullName = assetDef.m_szDirectory + assetDef.m_szAssetName;
                //                 Type creationType;
                //
                //                 creationType = Type.GetType(assetDef.m_szAssetType, true);
                //                 Debug.Assert(creationType != null);
                //
                //                 MethodInfo genericMethod = methodInfo.MakeGenericMethod(creationType);
                //                 assetObject = genericMethod.Invoke(contentManager, new object[] { szFullName });
                //                 Debug.Assert(assetObject != null);
                //
                //                 streamChunk.AddAsset(assetObject);
                #endregion
#endif
            }

            //These two steps could be merged to one...saving memory ...but doing it like this for clarity atm.
            foreach (TaskHandle taskHandle in aTaskHandles)
            {
                TaskManager.Instance.ExecuteTask(taskHandle);
                resetEvents.Add(TaskManager.Instance.GetTaskByHandle(taskHandle).Event);
            }

            WaitHandle.WaitAll(resetEvents.ToArray());
            Console.WriteLine("Load Job done.");

            foreach (LoadingTask task in loadingTasks)
            {
                streamChunk.AddAsset(task.HashCode, task.AssetObject);
            }

            streamChunk.OwnContentManager = regionLoader;

            return(streamChunk);
        }