示例#1
0
        public void StartLoad(BackgroundWorker worker)
        {
            var useParams = false;

            var badParams = new List <string>();

            foreach (var theKey in _paramMappings.Keys)
            {
                if ((_paramMappings[theKey] == null) || (_paramMappings[theKey].Length == 0))
                {
                    badParams.Add(theKey);
                }
            }

            foreach (var theKey in badParams)
            {
                _paramMappings.Remove(theKey);
            }

            //Need some parameters?
            if (_paramMappings.Count > 0)
            {
                ParamServer.Initialize(_paramQuery, _paramConnectionString, _paramMappings);
                useParams = true;
            }

            //Initialize the connection pool
            var conn = new SqlConnection(_connectionString);

            //TODO: use this or not??
            SqlConnection.ClearPool(conn);
            conn.Open();
            conn.Dispose();

            //make sure the run cancelled flag is not set
            QueryInput.RunCancelled = false;

            //Spin up the load threads
            for (var i = 0; i < _threads; i++)
            {
                conn = new SqlConnection(_connectionString);

                //TODO: Figure out how to make this option work (maybe)
                //conn.FireInfoMessageEventOnUserErrors = true;

                SqlCommand statsComm = null;

                var queryComm = new SqlCommand {
                    CommandTimeout = _commandTimeout, Connection = conn, CommandText = _query
                };

                if (useParams)
                {
                    queryComm.Parameters.AddRange(ParamServer.GetParams());
                }

                var setStatistics = (_collectIoStats ? @"SET STATISTICS IO ON;" : "") + (_collectTimeStats ? @"SET STATISTICS TIME ON;" : "");

                if (setStatistics.Length > 0)
                {
                    statsComm = new SqlCommand {
                        CommandTimeout = _commandTimeout, Connection = conn, CommandText = setStatistics
                    };
                }

                //Queue<queryOutput> queryOutInfo = new Queue<queryOutput>();

                var input = new QueryInput(statsComm, queryComm,
//                    this.queryOutInfo,
                                           _iterations, _forceDataRetrieval);

                var theThread = new Thread(input.StartLoadThread)
                {
                    Priority = ThreadPriority.BelowNormal
                };

                _threadPool.Add(theThread);
                _commandPool.Add(queryComm);
                //queryOutInfoPool.Add(queryOutInfo);
            }

            //Start the load threads
            for (var i = 0; i < _threads; i++)
            {
                _threadPool[i].Start();
            }

            //Start reading the queue...
            var finishedThreads = 0;
            var cancelled       = false;

            while (finishedThreads < _threads)
            {
//                for (int i = 0; i < threads; i++)
//                {
                // try
                // {
                QueryOutput theOut = null;
                //lock (queryOutInfoPool[i])
                lock (QueryOutInfo)
                {
                    //if (queryOutInfoPool[i].Count > 0)
                    //theOut = (queryOutput)queryOutInfoPool[i].Dequeue();
                    if (QueryOutInfo.Count > 0)
                    {
                        theOut = QueryOutInfo.Dequeue();
                    }
                    else
                    {
                        Monitor.Wait(QueryOutInfo);
                    }
                }

                if (theOut != null)
                {
                    //Report output to the UI
                    worker.ReportProgress((int)(finishedThreads / (decimal)_threads * 100), theOut);

                    //TODO: Make this actually remove the queue from the pool so that it's not checked again -- maintain this with a bitmap, perhaps?
                    if (theOut.Finished)
                    {
                        finishedThreads++;
                    }
                }

                /* }
                 *  catch (InvalidOperationException e)
                 *  {
                 *  }
                 */

                /*
                 *      if (theOut != null)
                 *          Thread.Sleep(200);
                 *      else
                 *          Thread.Sleep(10);
                 */
                //               }

                //TODO: Remove this ?
                GC.Collect();

                if (worker.CancellationPending && !cancelled)
                {
                    QueryInput.RunCancelled = true;

                    //First, kill connections as fast as possible
                    SqlConnection.ClearAllPools();

                    //for each 20 threads, create a new thread dedicated
                    //to killing them
                    var threadNum = _threadPool.Count;

                    var killerThreads = new List <Thread>();
                    while (threadNum > 0)
                    {
                        var i = threadNum <= 20 ? 0 : threadNum - 20;

                        var killThreads  = new Thread[threadNum - i < 1 ? threadNum : threadNum - i];
                        var killCommands = new SqlCommand[threadNum - i < 1 ? threadNum : threadNum - i];

                        _threadPool.CopyTo(i, killThreads, 0, killThreads.Length);
                        _commandPool.CopyTo(i, killCommands, 0, killCommands.Length);

                        for (var j = threadNum - 1; j >= i; j--)
                        {
                            _threadPool.RemoveAt(j);
                            _commandPool.RemoveAt(j);
                        }

                        var kill   = new ThreadKiller(killThreads, killCommands);
                        var killer = new Thread(kill.KillEm);
                        killer.Start();
                        Thread.Sleep(0);

                        killerThreads.Add(killer);

                        threadNum = i;
                    }

                    //wait for the kill threads to return
                    //before exiting...
                    foreach (var theThread in killerThreads)
                    {
                        theThread.Join();
                    }

                    cancelled = true;
                }
            }

            //clear any remaining messages -- these are almost certainly
            //execeptions due to thread cancellation
            //queryOutInfo.Clear();
        }
        public void StartLoad(BackgroundWorker worker)
        {
            bool useParams = false;

            List <string> badParams = new List <string>();

            foreach (string theKey in paramMappings.Keys)
            {
                if ((paramMappings[theKey] == null) ||
                    (paramMappings[theKey].Length == 0))
                {
                    badParams.Add(theKey);
                }
            }

            foreach (string theKey in badParams)
            {
                paramMappings.Remove(theKey);
            }

            //Need some parameters?
            if (paramMappings.Count > 0)
            {
                ParamServer.Initialize(paramQuery, paramConnectionString, paramMappings);
                useParams = true;
            }

            //Initialize the connection pool
            SqlConnection conn = new SqlConnection(this.connectionString);

            //TODO: use this or not??
            SqlConnection.ClearPool(conn);
            conn.Open();
            conn.Dispose();

            //make sure the run cancelled flag is not set
            queryInput.RunCancelled = false;

            //Spin up the load threads
            for (int i = 0; i < threads; i++)
            {
                conn = new SqlConnection(this.connectionString);

                //TODO: Figure out how to make this option work (maybe)
                //conn.FireInfoMessageEventOnUserErrors = true;

                SqlCommand stats_comm = null;

                SqlCommand query_comm = new SqlCommand();
                query_comm.CommandTimeout = this.commandTimeout;
                query_comm.Connection     = conn;
                query_comm.CommandText    = this.query;

                if (useParams)
                {
                    query_comm.Parameters.AddRange(ParamServer.GetParams());
                }

                string setStatistics =
                    ((collectIOStats) ? (@"SET STATISTICS IO ON;") : ("")) +
                    ((collectTimeStats) ? (@"SET STATISTICS TIME ON;") : (""));

                if (setStatistics.Length > 0)
                {
                    stats_comm = new SqlCommand();
                    stats_comm.CommandTimeout = this.commandTimeout;
                    stats_comm.Connection     = conn;
                    stats_comm.CommandText    = setStatistics;
                }

                //Queue<queryOutput> queryOutInfo = new Queue<queryOutput>();

                queryInput input = new queryInput(
                    stats_comm,
                    query_comm,
//                    this.queryOutInfo,
                    this.iterations,
                    this.forceDataRetrieval);

                Thread theThread = new Thread(new ThreadStart(input.startLoadThread));
                theThread.Priority = ThreadPriority.BelowNormal;

                threadPool.Add(theThread);
                commandPool.Add(query_comm);
                //queryOutInfoPool.Add(queryOutInfo);
            }

            //Start the load threads
            for (int i = 0; i < threads; i++)
            {
                threadPool[i].Start();
            }

            //Start reading the queue...
            int  finishedThreads = 0;
            bool cancelled       = false;

            while (finishedThreads < threads)
            {
//                for (int i = 0; i < threads; i++)
//                {
                // try
                // {
                queryOutput theOut = null;
                //lock (queryOutInfoPool[i])
                lock (queryOutInfo)
                {
                    //if (queryOutInfoPool[i].Count > 0)
                    //theOut = (queryOutput)queryOutInfoPool[i].Dequeue();
                    if (queryOutInfo.Count > 0)
                    {
                        theOut = queryOutInfo.Dequeue();
                    }
                    else
                    {
                        Monitor.Wait(queryOutInfo);
                    }
                }

                if (theOut != null)
                {
                    //Report output to the UI
                    worker.ReportProgress((int)(((decimal)finishedThreads / (decimal)threads) * 100), theOut);

                    //TODO: Make this actually remove the queue from the pool so that it's not checked again -- maintain this with a bitmap, perhaps?
                    if (theOut.finished)
                    {
                        finishedThreads++;
                    }
                }

                /* }
                 * catch (InvalidOperationException e)
                 * {
                 * }
                 */

                /*
                 *  if (theOut != null)
                 *      Thread.Sleep(200);
                 *  else
                 *      Thread.Sleep(10);
                 */
                //               }

                //TODO: Remove this ?
                GC.Collect();

                if (worker.CancellationPending && (!cancelled))
                {
                    queryInput.RunCancelled = true;

                    //First, kill connections as fast as possible
                    SqlConnection.ClearAllPools();

                    //for each 20 threads, create a new thread dedicated
                    //to killing them
                    int threadNum = threadPool.Count;

                    List <Thread> killerThreads = new List <Thread>();
                    while (threadNum > 0)
                    {
                        int i = (threadNum <= 20) ? 0 : (threadNum - 20);

                        Thread[]     killThreads  = new Thread[((threadNum - i) < 1) ? threadNum : (threadNum - i)];
                        SqlCommand[] killCommands = new SqlCommand[((threadNum - i) < 1) ? threadNum : (threadNum - i)];

                        threadPool.CopyTo(
                            i, killThreads, 0, killThreads.Length);
                        commandPool.CopyTo(
                            i, killCommands, 0, killCommands.Length);

                        for (int j = (threadNum - 1); j >= i; j--)
                        {
                            threadPool.RemoveAt(j);
                            commandPool.RemoveAt(j);
                        }

                        ThreadKiller kill = new ThreadKiller(
                            killThreads,
                            killCommands);
                        Thread killer = new Thread(new ThreadStart(kill.KillEm));
                        killer.Start();
                        Thread.Sleep(0);

                        killerThreads.Add(killer);

                        threadNum = i;
                    }

                    //wait for the kill threads to return
                    //before exiting...
                    foreach (Thread theThread in killerThreads)
                    {
                        theThread.Join();
                    }

                    cancelled = true;
                }
            }

            //clear any remaining messages -- these are almost certainly
            //execeptions due to thread cancellation
            //queryOutInfo.Clear();
        }
示例#3
0
        public void StartLoad(BackgroundWorker worker)
        {
            var useParams = false;

            var badParams = new List<string>();
            foreach (var theKey in _paramMappings.Keys)
            {
                if ((_paramMappings[theKey] == null) || (_paramMappings[theKey].Length == 0))
                {
                    badParams.Add(theKey);
                }
            }

            foreach (var theKey in badParams)
            {
                _paramMappings.Remove(theKey);
            }

            //Need some parameters?
            if (_paramMappings.Count > 0)
            {
                ParamServer.Initialize(_paramQuery, _paramConnectionString, _paramMappings);
                useParams = true;
            }

            //Initialize the connection pool            
            var conn = new SqlConnection(_connectionString);
            //TODO: use this or not??
            SqlConnection.ClearPool(conn);
            conn.Open();
            conn.Dispose();

            //make sure the run cancelled flag is not set
            QueryInput.RunCancelled = false;

            //Spin up the load threads
            for (var i = 0; i < _threads; i++)
            {
                conn = new SqlConnection(_connectionString);

                //TODO: Figure out how to make this option work (maybe)
                //conn.FireInfoMessageEventOnUserErrors = true;

                SqlCommand statsComm = null;

                var queryComm = new SqlCommand {CommandTimeout = _commandTimeout, Connection = conn, CommandText = _query};

                if (useParams)
                {
                    queryComm.Parameters.AddRange(ParamServer.GetParams());
                }

                var setStatistics = (_collectIoStats ? @"SET STATISTICS IO ON;" : "") + (_collectTimeStats ? @"SET STATISTICS TIME ON;" : "");

                if (setStatistics.Length > 0)
                {
                    statsComm = new SqlCommand {CommandTimeout = _commandTimeout, Connection = conn, CommandText = setStatistics};
                }

                //Queue<queryOutput> queryOutInfo = new Queue<queryOutput>();

                var input = new QueryInput(statsComm, queryComm,
//                    this.queryOutInfo,
                    _iterations, _forceDataRetrieval);

                var theThread = new Thread(input.StartLoadThread) {Priority = ThreadPriority.BelowNormal};

                _threadPool.Add(theThread);
                _commandPool.Add(queryComm);
                //queryOutInfoPool.Add(queryOutInfo);
            }

            //Start the load threads
            for (var i = 0; i < _threads; i++)
            {
                _threadPool[i].Start();
            }

            //Start reading the queue...
            var finishedThreads = 0;
            var cancelled = false;

            while (finishedThreads < _threads)
            {
//                for (int i = 0; i < threads; i++)
//                {
                // try
                // {
                QueryOutput theOut = null;
                //lock (queryOutInfoPool[i])
                lock (QueryOutInfo)
                {
                    //if (queryOutInfoPool[i].Count > 0)
                    //theOut = (queryOutput)queryOutInfoPool[i].Dequeue();
                    if (QueryOutInfo.Count > 0)
                        theOut = QueryOutInfo.Dequeue();
                    else
                        Monitor.Wait(QueryOutInfo);
                }

                if (theOut != null)
                {
                    //Report output to the UI
                    worker.ReportProgress((int) (finishedThreads / (decimal) _threads * 100), theOut);

                    //TODO: Make this actually remove the queue from the pool so that it's not checked again -- maintain this with a bitmap, perhaps?
                    if (theOut.Finished)
                        finishedThreads++;
                }
                /* }
                    catch (InvalidOperationException e)
                    {
                    }
                    */

                /*
                        if (theOut != null)
                            Thread.Sleep(200);
                        else
                            Thread.Sleep(10);
                     */
                //               }

                //TODO: Remove this ?
                GC.Collect();

                if (worker.CancellationPending && !cancelled)
                {
                    QueryInput.RunCancelled = true;

                    //First, kill connections as fast as possible
                    SqlConnection.ClearAllPools();

                    //for each 20 threads, create a new thread dedicated
                    //to killing them
                    var threadNum = _threadPool.Count;

                    var killerThreads = new List<Thread>();
                    while (threadNum > 0)
                    {
                        var i = threadNum <= 20 ? 0 : threadNum - 20;

                        var killThreads = new Thread[threadNum - i < 1 ? threadNum : threadNum - i];
                        var killCommands = new SqlCommand[threadNum - i < 1 ? threadNum : threadNum - i];

                        _threadPool.CopyTo(i, killThreads, 0, killThreads.Length);
                        _commandPool.CopyTo(i, killCommands, 0, killCommands.Length);

                        for (var j = threadNum - 1; j >= i; j--)
                        {
                            _threadPool.RemoveAt(j);
                            _commandPool.RemoveAt(j);
                        }

                        var kill = new ThreadKiller(killThreads, killCommands);
                        var killer = new Thread(kill.KillEm);
                        killer.Start();
                        Thread.Sleep(0);

                        killerThreads.Add(killer);

                        threadNum = i;
                    }

                    //wait for the kill threads to return
                    //before exiting...
                    foreach (var theThread in killerThreads)
                    {
                        theThread.Join();
                    }

                    cancelled = true;
                }
            }

            //clear any remaining messages -- these are almost certainly
            //execeptions due to thread cancellation
            //queryOutInfo.Clear();
        }
示例#4
0
		/// <summary>
		/// Starts the thread for scanning documents, creating the thread if necessary
		/// </summary>
		/// <remarks>When this returns, m_engineThread is set to the running thread,
		/// which is a newly created thread if m_engineThread was previously null</remarks>				
		private void StartScanningThread()
		{
			try
			{
				if (m_engineThread == null)
				{
					m_engineThread = new Thread(new ThreadStart(EngineWorker));
					m_engineThread.Name = MethodBase.GetCurrentMethod().DeclaringType.Name + ".EngineWorker";
					m_engineThread.IsBackground = true;
				}

				m_threadKiller = new ThreadKiller(m_engineThread);
				m_threadKiller.ReadyToDie = true;
				m_engineThread.Start();
			}
			catch (Exception ex)
			{
				Logger.LogError(ex);
				throw;
			}
		}
        public void StartLoad(BackgroundWorker worker)
        {
            bool useParams = false;

            List<string> badParams = new List<string>();
            foreach (string theKey in paramMappings.Keys)
            {
                if ((paramMappings[theKey] == null) ||
                    (paramMappings[theKey].Length == 0))
                {
                    badParams.Add(theKey);
                }
            }

            foreach (string theKey in badParams)
            {
                paramMappings.Remove(theKey);
            }

            //Need some parameters?
            if (paramMappings.Count > 0)
            {
                ParamServer.Initialize(paramQuery, paramConnectionString, paramMappings);
                useParams = true;
            }

            //Initialize the connection pool            
            SqlConnection conn = new SqlConnection(this.connectionString);
            //TODO: use this or not??
            SqlConnection.ClearPool(conn);
            conn.Open();
            conn.Dispose();

            //make sure the run cancelled flag is not set
            queryInput.RunCancelled = false;

            //Spin up the load threads
            for (int i = 0; i < threads; i++)
            {
                conn = new SqlConnection(this.connectionString);

                //TODO: Figure out how to make this option work (maybe)
                //conn.FireInfoMessageEventOnUserErrors = true;

                SqlCommand stats_comm = null;

                SqlCommand query_comm = new SqlCommand();
                query_comm.CommandTimeout = this.commandTimeout;
                query_comm.Connection = conn;
                query_comm.CommandText = this.query;

                if (useParams)
                {
                    query_comm.Parameters.AddRange(ParamServer.GetParams());
                }

                string setStatistics =
                    ((collectIOStats) ? (@"SET STATISTICS IO ON;") : ("")) +
                    ((collectTimeStats) ? (@"SET STATISTICS TIME ON;") : (""));

                if (setStatistics.Length > 0)
                {
                    stats_comm = new SqlCommand();
                    stats_comm.CommandTimeout = this.commandTimeout;
                    stats_comm.Connection = conn;
                    stats_comm.CommandText = setStatistics;
                }

                //Queue<queryOutput> queryOutInfo = new Queue<queryOutput>();

                queryInput input = new queryInput(
                    stats_comm,
                    query_comm,
//                    this.queryOutInfo,
                    this.iterations, 
                    this.forceDataRetrieval);

                Thread theThread = new Thread(new ThreadStart(input.startLoadThread));
                theThread.Priority = ThreadPriority.BelowNormal;

                threadPool.Add(theThread);
                commandPool.Add(query_comm);
                //queryOutInfoPool.Add(queryOutInfo);
            }

            //Start the load threads
            for (int i = 0; i < threads; i++)
            {
                threadPool[i].Start();
            }

            //Start reading the queue...
            int finishedThreads = 0;
            bool cancelled = false;

            while (finishedThreads < threads)
            {
//                for (int i = 0; i < threads; i++)
//                {
                   // try
                   // {
                        queryOutput theOut = null;
                        //lock (queryOutInfoPool[i])
                        lock(queryOutInfo)
                        {
                            //if (queryOutInfoPool[i].Count > 0)
                                //theOut = (queryOutput)queryOutInfoPool[i].Dequeue();
                            if (queryOutInfo.Count > 0)
                                theOut = queryOutInfo.Dequeue();
                            else
                                Monitor.Wait(queryOutInfo);
                        }

                        if (theOut != null)
                        {
                            //Report output to the UI
                            worker.ReportProgress((int)(((decimal)finishedThreads / (decimal)threads) * 100), theOut);

                            //TODO: Make this actually remove the queue from the pool so that it's not checked again -- maintain this with a bitmap, perhaps?
                            if (theOut.finished)
                                finishedThreads++;
                        }
                   /* }
                    catch (InvalidOperationException e)
                    {
                    }
                    */

                    /*
                        if (theOut != null)
                            Thread.Sleep(200);
                        else
                            Thread.Sleep(10);
                     */
 //               }

                //TODO: Remove this ?
                GC.Collect();

                if (worker.CancellationPending && (!cancelled))
                {
                    queryInput.RunCancelled = true;

                    //First, kill connections as fast as possible
                    SqlConnection.ClearAllPools();

                    //for each 20 threads, create a new thread dedicated
                    //to killing them
                    int threadNum = threadPool.Count;

                    List<Thread> killerThreads = new List<Thread>();
                    while (threadNum > 0)
                    {
                        int i = (threadNum <= 20) ? 0 : (threadNum - 20);

                        Thread[] killThreads = new Thread[((threadNum-i)<1) ? threadNum : (threadNum-i)];
                        SqlCommand[] killCommands = new SqlCommand[((threadNum - i) < 1) ? threadNum : (threadNum - i)];

                        threadPool.CopyTo(
                            i, killThreads, 0, killThreads.Length);
                        commandPool.CopyTo(
                            i, killCommands, 0, killCommands.Length);

                        for (int j = (threadNum-1); j >= i; j--)
                        {
                            threadPool.RemoveAt(j);
                            commandPool.RemoveAt(j);
                        }

                        ThreadKiller kill = new ThreadKiller(
                            killThreads,
                            killCommands);
                        Thread killer = new Thread(new ThreadStart(kill.KillEm));
                        killer.Start();
                        Thread.Sleep(0);

                        killerThreads.Add(killer);

                        threadNum = i;
                    }

                    //wait for the kill threads to return
                    //before exiting...
                    foreach (Thread theThread in killerThreads)
                    {
                        theThread.Join();
                    }

                    cancelled = true;
                }
            }

            //clear any remaining messages -- these are almost certainly
            //execeptions due to thread cancellation
            //queryOutInfo.Clear();
        }