protected void FloodFillAreas(Node rootNode, int area) { var list = PoolQueue <Node> .Spawn(this.nodes.Count); list.Enqueue(rootNode); while (list.Count > 0) { var node = list.Dequeue(); var connections = node.GetConnections(); for (int j = 0; j < connections.Length; ++j) { var connection = connections[j]; if (connection.index >= 0) { var nb = this.nodes[connection.index]; if (nb.area == 0 && nb.walkable == true) { nb.area = area; //this.FloodFillAreas(nb, area); list.Enqueue(nb); } } } } PoolQueue <Node> .Recycle(ref list); }
protected ListCopyable <Node> AstarSearch(Graph graph, ListCopyable <Node> visited, Node startNode, Node endNode, Constraint constraint, int threadIndex) { var openList = PoolQueue <Node> .Spawn(10); startNode.startToCurNodeLen[threadIndex] = 0f; openList.Enqueue(startNode); startNode.isOpened[threadIndex] = true; while (openList.Count > 0) { var node = openList.Dequeue(); node.isClosed[threadIndex] = true; visited.Add(node); if (node.index == endNode.index) { PoolQueue <Node> .Recycle(ref openList); return(this.RetracePath(threadIndex, endNode)); } var neighbors = node.GetConnections(); foreach (var conn in neighbors) { if (conn.index < 0) { continue; } var neighbor = graph.nodes[conn.index]; if (neighbor.isClosed[threadIndex] == true) { continue; } if (neighbor.IsSuitable(constraint) == false) { continue; } float ng = node.startToCurNodeLen[threadIndex] + conn.cost; if (neighbor.isOpened[threadIndex] == false || ng < neighbor.startToCurNodeLen[threadIndex]) { neighbor.startToCurNodeLen[threadIndex] = ng; neighbor.parent[threadIndex] = node; if (neighbor.isOpened[threadIndex] == false) { openList.Enqueue(neighbor); visited.Add(neighbor); neighbor.isOpened[threadIndex] = true; } } } } PoolQueue <Node> .Recycle(ref openList); return(null); }
void Awake(){ if(useAsSingleton) Instance = this; if(poolDictionary == null) poolDictionary = new Dictionary<string, PoolQueue<GameObject>>(); else return; for(int i = 0; i < pools.Count; i++) { Pool pool = pools[i]; PoolQueue<GameObject> objectPool = new PoolQueue<GameObject>(); for(int j = 0;j<pool.size; j++) { GameObject obj = Instantiate(pool.prefab, gameObject.transform); obj.SetActive(false); MonoBehaviourPooledObject PooledObjectScript = obj.GetComponent<MonoBehaviourPooledObject>(); if(PooledObjectScript != null) { PooledObjectScript.SetQueue(objectPool); } objectPool.Enqueue(obj); } poolDictionary.Add(pool.tag, objectPool); objectPool.poolParent = pool; } }
void Awake() { if (poolQueue == null) { poolQueue = new PoolQueue <GameObject>(); } else { return; } for (int j = 0; j < pool.size; j++) { GameObject obj = Instantiate(pool.prefab, gameObject.transform); obj.SetActive(false); MonoBehaviourPooledObject PooledObjectScript = obj.GetComponent <MonoBehaviourPooledObject>(); if (PooledObjectScript != null) { PooledObjectScript.SetQueue(poolQueue); } poolQueue.Enqueue(obj); } poolQueue.poolParent = pool; }
public GameObject SpawnFromPool(string tag, Vector3 position, Quaternion rotation) { if (!poolDictionary.ContainsKey(tag)) { Debug.LogWarning("Pool with tag " + tag + " doesn't exist."); return(null); } PoolQueue <GameObject> poolQueue = poolDictionary[tag]; GameObject objectToSpawn; if (poolQueue.Count > 0) { objectToSpawn = (GameObject)poolQueue.Dequeue(); } else { objectToSpawn = CreateObjectBlank(poolQueue.poolParent); } IPooledObject ObjectInterface = objectToSpawn.GetComponent <IPooledObject>(); //Get rid of GetComponent call. if (ObjectInterface != null) { ObjectInterface.OnObjectSpawn(); } objectToSpawn.transform.position = position; objectToSpawn.transform.rotation = rotation; objectToSpawn.SetActive(true); return(objectToSpawn); }
private void DoTestLoad(Taste.Recommender.Recommender recommender, int allowedTimeSec) { // TODO: how to specify number of threads PoolQueue queue = new PoolQueue(new DefaultThreadPool(), new CommandExecutor()); Command cmd = delegate { for (int i = 0; i < NUM_USERS; i++) { string id = random.Next(NUM_USERS).ToString(); recommender.Recommend(id, 10); if (i % 100 == 50) { recommender.Refresh(); } } }; long start = DateTime.Now.Ticks; for (int i = 0; i < NUM_THREADS; i++) { queue.Enqueue(cmd); } long end = DateTime.Now.Ticks; double timeMS = TimeSpan.FromTicks(end - start).TotalMilliseconds; log.Info("Load test completed in " + timeMS + "ms"); Assert.IsTrue(timeMS < 1000L * (long)allowedTimeSec); }
/////////////////////////////////////////////////////////////////////// /// <summary> /// We do not have to thread-lock anything in this function, because it /// is only called by other functions above which already take the lock. /// </summary> /// <param name="queue"> /// The pool queue to resize. /// </param> /// <param name="add"> /// If a function intends to add to the pool, this is true, which /// forces the resize to take one more than it needs from the pool. /// </param> private static void ResizePool( PoolQueue queue, bool add ) { int target = queue.MaxPoolSize; if (add && target > 0) { target--; } Queue <WeakReference> poolQueue = queue.Queue; if (poolQueue == null) { return; } while (poolQueue.Count > target) { WeakReference connection = poolQueue.Dequeue(); if (connection == null) { continue; } SQLiteConnectionHandle handle = connection.Target as SQLiteConnectionHandle; if (handle != null) { handle.Dispose(); } GC.KeepAlive(handle); } }
private VerifyCenter(int maxTask) { try { MaxThreads = maxTask; this.maxAccepted = new Semaphore(MaxThreads, MaxThreads); tmpRequest = new Dictionary <string, Action <VerifyResult> >(); evtHandlers = new PoolQueue <VerifyProcess>(MaxThreads + 2); for (int i = 0; i < MaxThreads; i++) { VerifyProcess verTask = new VerifyProcess(); verTask.OnCompleted += verTask_OnCompleted; evtHandlers.Enqueue(verTask); } } catch (Exception exp) { Logger.AddLog(this.GetType(), "VerifyCenter", exp.Message); } }
/////////////////////////////////////////////////////////////////////// /// <summary> /// Removes a connection from the pool of those associated with the /// specified database file name with the intent of using it to /// interact with the database. /// </summary> /// <param name="fileName"> /// The database file name. /// </param> /// <param name="maxPoolSize"> /// The new maximum size of the connection pool for the specified /// database file name. /// </param> /// <param name="version"> /// The connection pool version associated with the returned database /// connection handle, if any. /// </param> /// <returns> /// The database connection handle associated with the specified /// database file name or null if it cannot be obtained. /// </returns> internal static SQLiteConnectionHandle Remove( string fileName, int maxPoolSize, out int version ) { ISQLiteConnectionPool connectionPool = GetConnectionPool(); if (connectionPool != null) { return(connectionPool.Remove(fileName, maxPoolSize, out version) as SQLiteConnectionHandle); } else { int localVersion; Queue <WeakReference> poolQueue; // // NOTE: This lock cannot be held while checking the queue for // available connections because other methods of this // class are called from the GC finalizer thread and we // use the WaitForPendingFinalizers method (below). // Holding this lock while calling that method would // therefore result in a deadlock. Instead, this lock // is held only while a temporary copy of the queue is // created, and if necessary, when committing changes // back to that original queue prior to returning from // this method. // lock (_syncRoot) { PoolQueue queue; // // NOTE: Default to the highest pool version. // version = _poolVersion; // // NOTE: If we didn't find a pool for this file, create one // even though it will be empty. We have to do this // here because otherwise calling ClearPool() on the // file will not work for active connections that have // never seen the pool yet. // if (!_queueList.TryGetValue(fileName, out queue)) { queue = new PoolQueue(_poolVersion, maxPoolSize); _queueList.Add(fileName, queue); return(null); } // // NOTE: We found a pool for this file, so use its version // number. // version = localVersion = queue.PoolVersion; queue.MaxPoolSize = maxPoolSize; // // NOTE: Now, resize the pool to the new maximum size, if // necessary. // ResizePool(queue, false); // // NOTE: Try and get a pooled connection from the queue. // poolQueue = queue.Queue; if (poolQueue == null) { return(null); } // // NOTE: Temporarily tranfer the queue for this file into // a local variable. The queue for this file will // be modified and then committed back to the real // pool list (below) prior to returning from this // method. // _queueList.Remove(fileName); poolQueue = new Queue <WeakReference>(poolQueue); } try { while (poolQueue.Count > 0) { WeakReference connection = poolQueue.Dequeue(); if (connection == null) { continue; } SQLiteConnectionHandle handle = connection.Target as SQLiteConnectionHandle; if (handle == null) { continue; } // // BUGFIX: For ticket [996d13cd87], step #1. After // this point, make sure that the finalizer for // the connection handle just obtained from the // queue cannot START running (i.e. it may // still be pending but it will no longer start // after this point). // GC.SuppressFinalize(handle); try { // // BUGFIX: For ticket [996d13cd87], step #2. Now, // we must wait for all pending finalizers // which have STARTED running and have not // yet COMPLETED. This must be done just // in case the finalizer for the connection // handle just obtained from the queue has // STARTED running at some point before // SuppressFinalize was called on it. // // After this point, checking properties of // the connection handle (e.g. IsClosed) // should work reliably without having to // worry that they will (due to the // finalizer) change out from under us. // GC.WaitForPendingFinalizers(); // // BUGFIX: For ticket [996d13cd87], step #3. Next, // verify that the connection handle is // actually valid and [still?] not closed // prior to actually returning it to our // caller. // if (!handle.IsInvalid && !handle.IsClosed) { Interlocked.Increment(ref _poolOpened); return(handle); } } finally { // // BUGFIX: For ticket [996d13cd87], step #4. Next, // we must re-register the connection // handle for finalization now that we have // a strong reference to it (i.e. the // finalizer will not run at least until // the connection is subsequently closed). // GC.ReRegisterForFinalize(handle); } GC.KeepAlive(handle); } } finally { // // BUGFIX: For ticket [996d13cd87], step #5. Finally, // commit any changes to the pool/queue for this // database file. // lock (_syncRoot) { // // NOTE: We must check [again] if a pool exists for // this file because one may have been added // while the search for an available connection // was in progress (above). // PoolQueue queue; Queue <WeakReference> newPoolQueue; bool addPool; if (_queueList.TryGetValue(fileName, out queue)) { addPool = false; } else { addPool = true; queue = new PoolQueue(localVersion, maxPoolSize); } newPoolQueue = queue.Queue; while (poolQueue.Count > 0) { newPoolQueue.Enqueue(poolQueue.Dequeue()); } ResizePool(queue, false); if (addPool) { _queueList.Add(fileName, queue); } } } return(null); } }
/////////////////////////////////////////////////////////////////////// /// <summary> /// We do not have to thread-lock anything in this function, because it /// is only called by other functions above which already take the lock. /// </summary> /// <param name="queue"> /// The pool queue to resize. /// </param> /// <param name="add"> /// If a function intends to add to the pool, this is true, which /// forces the resize to take one more than it needs from the pool. /// </param> private static void ResizePool( PoolQueue queue, bool add ) { int target = queue.MaxPoolSize; if (add && target > 0) target--; Queue<WeakReference> poolQueue = queue.Queue; if (poolQueue == null) return; while (poolQueue.Count > target) { WeakReference connection = poolQueue.Dequeue(); if (connection == null) continue; SQLiteConnectionHandle handle = connection.Target as SQLiteConnectionHandle; if (handle != null) handle.Dispose(); GC.KeepAlive(handle); } }
/////////////////////////////////////////////////////////////////////// /// <summary> /// Removes a connection from the pool of those associated with the /// specified database file name with the intent of using it to /// interact with the database. /// </summary> /// <param name="fileName"> /// The database file name. /// </param> /// <param name="maxPoolSize"> /// The new maximum size of the connection pool for the specified /// database file name. /// </param> /// <param name="version"> /// The connection pool version associated with the returned database /// connection handle, if any. /// </param> /// <returns> /// The database connection handle associated with the specified /// database file name or null if it cannot be obtained. /// </returns> internal static SQLiteConnectionHandle Remove( string fileName, int maxPoolSize, out int version ) { ISQLiteConnectionPool connectionPool = GetConnectionPool(); if (connectionPool != null) { return connectionPool.Remove(fileName, maxPoolSize, out version) as SQLiteConnectionHandle; } else { int localVersion; Queue<WeakReference> poolQueue; // // NOTE: This lock cannot be held while checking the queue for // available connections because other methods of this // class are called from the GC finalizer thread and we // use the WaitForPendingFinalizers method (below). // Holding this lock while calling that method would // therefore result in a deadlock. Instead, this lock // is held only while a temporary copy of the queue is // created, and if necessary, when committing changes // back to that original queue prior to returning from // this method. // lock (_syncRoot) { PoolQueue queue; // // NOTE: Default to the highest pool version. // version = _poolVersion; // // NOTE: If we didn't find a pool for this file, create one // even though it will be empty. We have to do this // here because otherwise calling ClearPool() on the // file will not work for active connections that have // never seen the pool yet. // if (!_queueList.TryGetValue(fileName, out queue)) { queue = new PoolQueue(_poolVersion, maxPoolSize); _queueList.Add(fileName, queue); return null; } // // NOTE: We found a pool for this file, so use its version // number. // version = localVersion = queue.PoolVersion; queue.MaxPoolSize = maxPoolSize; // // NOTE: Now, resize the pool to the new maximum size, if // necessary. // ResizePool(queue, false); // // NOTE: Try and get a pooled connection from the queue. // poolQueue = queue.Queue; if (poolQueue == null) return null; // // NOTE: Temporarily tranfer the queue for this file into // a local variable. The queue for this file will // be modified and then committed back to the real // pool list (below) prior to returning from this // method. // _queueList.Remove(fileName); poolQueue = new Queue<WeakReference>(poolQueue); } try { while (poolQueue.Count > 0) { WeakReference connection = poolQueue.Dequeue(); if (connection == null) continue; SQLiteConnectionHandle handle = connection.Target as SQLiteConnectionHandle; if (handle == null) continue; // // BUGFIX: For ticket [996d13cd87], step #1. After // this point, make sure that the finalizer for // the connection handle just obtained from the // queue cannot START running (i.e. it may // still be pending but it will no longer start // after this point). // GC.SuppressFinalize(handle); try { // // BUGFIX: For ticket [996d13cd87], step #2. Now, // we must wait for all pending finalizers // which have STARTED running and have not // yet COMPLETED. This must be done just // in case the finalizer for the connection // handle just obtained from the queue has // STARTED running at some point before // SuppressFinalize was called on it. // // After this point, checking properties of // the connection handle (e.g. IsClosed) // should work reliably without having to // worry that they will (due to the // finalizer) change out from under us. // GC.WaitForPendingFinalizers(); // // BUGFIX: For ticket [996d13cd87], step #3. Next, // verify that the connection handle is // actually valid and [still?] not closed // prior to actually returning it to our // caller. // if (!handle.IsInvalid && !handle.IsClosed) { Interlocked.Increment(ref _poolOpened); return handle; } } finally { // // BUGFIX: For ticket [996d13cd87], step #4. Next, // we must re-register the connection // handle for finalization now that we have // a strong reference to it (i.e. the // finalizer will not run at least until // the connection is subsequently closed). // GC.ReRegisterForFinalize(handle); } GC.KeepAlive(handle); } } finally { // // BUGFIX: For ticket [996d13cd87], step #5. Finally, // commit any changes to the pool/queue for this // database file. // lock (_syncRoot) { // // NOTE: We must check [again] if a pool exists for // this file because one may have been added // while the search for an available connection // was in progress (above). // PoolQueue queue; Queue<WeakReference> newPoolQueue; bool addPool; if (_queueList.TryGetValue(fileName, out queue)) { addPool = false; } else { addPool = true; queue = new PoolQueue(localVersion, maxPoolSize); } newPoolQueue = queue.Queue; while (poolQueue.Count > 0) newPoolQueue.Enqueue(poolQueue.Dequeue()); ResizePool(queue, false); if (addPool) _queueList.Add(fileName, queue); } } return null; } }
private void DoTestLoad(Taste.Recommender.Recommender recommender, int allowedTimeSec) { // TODO: how to specify number of threads PoolQueue queue = new PoolQueue(new DefaultThreadPool(), new CommandExecutor()); Command cmd = delegate { for (int i = 0; i < NUM_USERS; i++) { string id = random.Next(NUM_USERS).ToString(); recommender.Recommend(id, 10); if (i % 100 == 50) { recommender.Refresh(); } } }; long start = DateTime.Now.Ticks; for (int i = 0; i < NUM_THREADS; i++) { queue.Enqueue(cmd); } long end = DateTime.Now.Ticks; double timeMS = TimeSpan.FromTicks(end - start).TotalMilliseconds; log.Info("Load test completed in " + timeMS + "ms"); Assert.IsTrue(timeMS < 1000L * (long) allowedTimeSec); }
public void SetQueue(PoolQueue <GameObject> queue) { queueBelongsTo = queue; }