예제 #1
0
        /// <summary>
        ///     Initializes the <see cref="StaticRandom" /> class.
        /// </summary>
        static StaticRandom()
        {
            int seed = Environment.TickCount;

            ThreadLocal = new ThreadLocal<Random>(
                () => new Random(Interlocked.Increment(ref seed)));
        }
예제 #2
0
        static void Main(string[] args)
        {
            Func<int> valueFactory = () => 1;
            ThreadLocal<int> tl = 
                new ThreadLocal<int>(valueFactory);

            LocalDataStoreSlot localDataStoreSlot = 
                Thread.GetNamedDataSlot("myThreadLocal");

            var value = valueFactory();

            Console.WriteLine("thread:{0} value:{1}", Thread.CurrentThread.ManagedThreadId, _value);
            _value = 10;
            ThreadStart action = () =>
            {
                _value = Thread.CurrentThread.ManagedThreadId;
                Console.WriteLine("thread:{0} value:{1}", Thread.CurrentThread.ManagedThreadId, _value);
            };

            var t1 = new Thread(action);
            var t2= new Thread(action);
            t1.Start();
            t2.Start();

            Console.ReadLine();


            var ints = new List<int>() {1, 2, 3, 4};
            var readOnlyCollection = ints.AsReadOnly();
            var count = readOnlyCollection.Count;

          
            
        }
예제 #3
0
		public void InitializeThrowingTest ()
		{
			int callTime = 0;
			threadLocal = new ThreadLocal<int> (() => {
					Interlocked.Increment (ref callTime);
					throw new ApplicationException ("foo");
					return 43;
				});

			Exception exception = null;

			try {
				var foo = threadLocal.Value;
			} catch (Exception e) {
				exception = e;
			}

			Assert.IsNotNull (exception, "#1");
			Assert.IsInstanceOfType (typeof (ApplicationException), exception, "#2");
			Assert.AreEqual (1, callTime, "#3");

			exception = null;

			try {
				var foo = threadLocal.Value;
			} catch (Exception e) {
				exception = e;
			}

			Assert.IsNotNull (exception, "#4");
			Assert.IsInstanceOfType (typeof (ApplicationException), exception, "#5");
			Assert.AreEqual (1, callTime, "#6");
		}
예제 #4
0
        public ChannelFactory(RawRabbitConfiguration config, IConnectionFactory connectionFactory)
        {
            _connectionFactory = connectionFactory;
            _accessDictionary = new ConcurrentDictionary<IModel, DateTime>();
            _config = config;
            _threadChannels = new ThreadLocal<IModel>(true);

            try
            {
                _logger.LogDebug("Connecting to primary host.");
                _connection = _connectionFactory.CreateConnection(_config.Hostnames);
                _logger.LogInformation("Successfully established connection.");
            }
            catch (BrokerUnreachableException e)
            {
                _logger.LogError("Unable to connect to broker", e);
                throw e.InnerException;
            }
            _closeTimer = new System.Threading.Timer(state =>
            {
                var enumerator = _accessDictionary.GetEnumerator();
                while (enumerator.MoveNext())
                {
                    if (DateTime.Now - enumerator.Current.Value > _config.RequestTimeout)
                    {
                        DateTime lastUsed;
                        if (_accessDictionary.TryRemove(enumerator.Current.Key, out lastUsed))
                        {
                            _logger.LogInformation($"Channel {enumerator.Current.Key.ChannelNumber} was last used {lastUsed}. Closing...");
                            enumerator.Current.Key.Close();
                        }
                    }
                }
            }, null, _config.RequestTimeout, _config.RequestTimeout);
        }
예제 #5
0
 public void MultipleReferenceToValueTest()
 {
     if (Environment.Version.Major >= 4)
     {
         throw new NotSupportedException("Results in stack overflow - blame Microsoft");
     }
     Assert.Throws(
         typeof(InvalidOperationException),
         () =>
         {
             ThreadLocal<int>[] threadLocal = { null };
             using (threadLocal[0] = new ThreadLocal<int>(() => threadLocal[0] != null ? threadLocal[0].Value + 1 : 0, false))
             {
                 GC.KeepAlive(threadLocal[0].Value);
             }
         }
     );
     Assert.Throws(
         typeof(InvalidOperationException),
         () =>
         {
             ThreadLocal<int>[] threadLocal = { null };
             using (threadLocal[0] = new ThreadLocal<int>(() => threadLocal[0] != null ? threadLocal[0].Value + 1 : 0, true))
             {
                 GC.KeepAlive(threadLocal[0].Value);
             }
         }
     );
 }
        public FairPartitionResolver(IReadOnlyList<string> collectionLinks)
        {
            Guard.NotNull("collectionLinks", collectionLinks);

            this.collectionLinks = collectionLinks;
            this.random = new ThreadLocal<Random>(CreateNewRandom);
        }
        public void TestWithPointers()
        {
            var path = Path.Combine(new[] { "..", "..", "TestData", "MaxMind-DB", "test-data", "maps-with-pointers.raw" });
            var stream = new ThreadLocal<Stream>(() => new MemoryStream(File.ReadAllBytes(path)));
            using (stream)
            {
                var decoder = new Decoder(stream, 0);

                var node = decoder.Decode(0).Node;
                Assert.That(node.Value<string>("long_key"), Is.EqualTo("long_value1"));

                node = decoder.Decode(22).Node;
                Assert.That(node.Value<string>("long_key"), Is.EqualTo("long_value2"));

                node = decoder.Decode(37).Node;
                Assert.That(node.Value<string>("long_key2"), Is.EqualTo("long_value1"));

                node = decoder.Decode(50).Node;
                Assert.That(node.Value<string>("long_key2"), Is.EqualTo("long_value2"));

                node = decoder.Decode(55).Node;
                Assert.That(node.Value<string>("long_key"), Is.EqualTo("long_value1"));

                node = decoder.Decode(57).Node;
                Assert.That(node.Value<string>("long_key2"), Is.EqualTo("long_value2"));
            }
        }
        public void Run() 
        {
            //if (!File.Exists("WordLookup.txt"))    // Contains about 150,000 words
            //    new WebClient().DownloadFile(
            //      "http://www.albahari.com/ispell/allwords.txt", "WordLookup.txt");

            var wordLookup = new HashSet<string>(
              File.ReadAllLines("WordLookup.txt"),
              StringComparer.InvariantCultureIgnoreCase);

            // Random is not thread-safe,所以無法簡單的使用AsParallel,
            // 解決方法,使用locks 的方式包住random.Next
            // 參考網址:http://csharpindepth.com/Articles/Chapter12/Random.aspx
            var random = new Random();
            string[] wordList = wordLookup.ToArray();

            // Fortunately, the new ThreadLocal<T> class in .NET 4 makes it very easy to write providers which need to have a single instance per thread
            // 使用ThreadLocal,建立分開的Random object 給每一個Thread

            //new Random(參數), 是為了確保如果兩個Random objects 被建立在很短的時間,會回傳不同的亂數序列
            var allocationRandom = new ThreadLocal<Random>(() => new Random(Guid.NewGuid().GetHashCode()));
            
            // 隨機取100W的值塞給wordsToTest
            string[] wordsToTest = Enumerable.Range(0, 1000000)
                .AsParallel()
              .Select(i => wordList[allocationRandom.Value.Next(0, wordList.Length)])
              .ToArray();            
                    
            var startTime = DateTime.Now.Ticks;

            var endTime = DateTime.Now.Ticks;
            Console.WriteLine("Time : " + (endTime - startTime).ToString());

        }
예제 #9
0
        public void TestBlockingQueueStress()
        {
            var queue = new BlockingQueue<int>(1);

            var rnd = new ThreadLocal<Random>(() => new Random());
            var generatedTotal = 0;
            var consummedTotal = 0;

            var producers = TestMonitorSimple.RunSimultanously(5, () =>
            {
                for (var i = 0; i < 1e6; i++)
                {
                    var value = rnd.Value.Next(100);
                    Interlocked.Add(ref generatedTotal, value);
                    queue.AddIfNotCompleted(value);
                }
            }, false);

            var consumers = TestMonitorSimple.RunSimultanously(5, () =>
            {
                foreach (var value in queue.GetConsumingEnumerable())
                {
                    Interlocked.Add(ref consummedTotal, value);
                }
            }, false);

            producers.ForEach(t => t.Join());
            queue.CompleteAdding();

            consumers.ForEach(t => t.Join());

            Assert.IsTrue(consummedTotal == generatedTotal);
        }
        public IModel GetChannel()
        {
            if (_threadModel == null)
            {
                _threadModel = new ThreadLocal<IModel>(() => _broker.GetConnection().CreateModel());
                _channelTimer = new Timer(state =>
                {
                    _threadModel?.Dispose();
                    _threadModel = null;
                }, null, TimeSpan.FromMilliseconds(200), new TimeSpan(-1));
            }
            else
            {
                _channelTimer.Change(TimeSpan.FromMilliseconds(100), new TimeSpan(-1));
            }

            if (_threadModel.IsValueCreated && _threadModel.Value.IsOpen)
            {
                return _threadModel.Value;
            }
            _threadModel?.Value?.Dispose();
            try
            {
                _threadModel.Value = _broker.GetConnection().CreateModel();
            }
            catch (ObjectDisposedException)
            {
                return GetChannel();
            }
            return _threadModel.Value;
        }
        /// <summary>Initializes the IOCompletionPortTaskScheduler.</summary>
        /// <param name="maxConcurrencyLevel">The maximum number of threads in the scheduler to be executing concurrently.</param>
        /// <param name="numAvailableThreads">The number of threads to have available in the scheduler for executing tasks.</param>
        public IOCompletionPortTaskScheduler(int maxConcurrencyLevel, int numAvailableThreads)
        {
            // Validate arguments
            if (maxConcurrencyLevel < 1) throw new ArgumentNullException("maxConcurrencyLevel");
            if (numAvailableThreads < 1) throw new ArgumentNullException("numAvailableThreads");

            m_tasks = new ConcurrentQueue<Task>();
            m_iocp = new IOCompletionPort(maxConcurrencyLevel);
            m_schedulerThread = new ThreadLocal<bool>();
            m_remainingThreadsToShutdown = new CountdownEvent(numAvailableThreads);

            // Create and start the threads
            for (int i = 0; i < numAvailableThreads; i++)
            {
                new Thread(() =>
                {
                    try
                    {
                        // Note that this is a scheduler thread.  Used for inlining checks.
                        m_schedulerThread.Value = true;

                        // Continually wait on the I/O completion port until
                        // there's a work item, then process it.
                        while (m_iocp.WaitOne())
                        {
                            Task next;
                            if (m_tasks.TryDequeue(out next)) TryExecuteTask(next);
                        }
                    }
                    finally { m_remainingThreadsToShutdown.Signal(); }
                }) { IsBackground = true }.Start();
            }
        }
 public HttpClient Client()
 {
     GatewayConfiguration = new HttpGatewayConfiguration();
     _timeout = Convert.ToDouble(GatewayConfiguration.OrderServiceConfiguration.Timeout);
     _client = new ThreadLocal<HttpClient>(() => CreateClient(_timeout));
     return _client.Value;
 }
예제 #13
0
 private TracePipeline(DebugContext debugContext)
 {
     _debugContext = debugContext;
     _traceFrame = new ThreadLocal<DebugFrame>();
     debugContext.DebugCallback = this;
     debugContext.DebugMode = DebugMode.FullyEnabled;
 }
예제 #14
0
 private void EnsureInitialized()
 {
     if (_random == null)
     {
         _random = new ThreadLocal<System.Random>(() => new System.Random(Seed.Value));
     }
 }
예제 #15
0
 static ThreadLocalRandom()
 {
     lock (Seeder)
     {
         Seed = new ThreadLocal<int>(() => Seeder.Next());
     }
 }
예제 #16
0
 public static void RunThreadLocalTest3_IsValueCreated()
 {
     ThreadLocal<string> tlocal = new ThreadLocal<string>(() => "Test");
     Assert.False(tlocal.IsValueCreated);
     string temp = tlocal.Value;
     Assert.True(tlocal.IsValueCreated);
 }
예제 #17
0
        public static void RunThreadLocalTest4_Value()
        {
            ThreadLocal<string> tlocal = null;

            // different threads call Value
            int numOfThreads = 10;
            Task[] threads = new Task[numOfThreads];
            object alock = new object();
            List<string> seenValuesFromAllThreads = new List<string>();
            int counter = 0;
            tlocal = new ThreadLocal<string>(() => (++counter).ToString());
            //CancellationToken ct = new CancellationToken();
            for (int i = 0; i < threads.Length; ++i)
            {
                // We are creating the task using TaskCreationOptions.LongRunning because...
                // there is no guarantee that the Task will be created on another thread.
                // There is also no guarantee that using this TaskCreationOption will force
                // it to be run on another thread.
                threads[i] = new Task(() =>
                {
                    string value = tlocal.Value;
                    Debug.WriteLine("Val: " + value);
                    seenValuesFromAllThreads.Add(value);
                }, TaskCreationOptions.LongRunning);
                threads[i].Start(TaskScheduler.Default);
                threads[i].Wait();
            }
            Assert.Equal(Enumerable.Range(1, threads.Length).Select(x => x.ToString()), seenValuesFromAllThreads);
        }
 public ReplyAuthenticationSessionAttacher(
     AuthenticationSessionCache cache,
     AuthenticatedServerRegistry registry)
     : base(cache, registry)
 {
     address = new ThreadLocal<EndpointAddress>();
 }
예제 #19
0
		static OAuthServerHelper()
		{
			RSAParameters privateRsaParameters;
			RSAParameters publicRsaParameters;
			using (var rsaKeyGen = new RSACryptoServiceProvider(RsaKeySize))
			{
				privateRsaParameters = rsaKeyGen.ExportParameters(true);
				publicRsaParameters = rsaKeyGen.ExportParameters(false);
			}

			Tuple<byte[], byte[]> aesKeyAndIV;
			using (var aesKeyGen = new AesCryptoServiceProvider())
			{
				aesKeyAndIV = Tuple.Create(aesKeyGen.Key, aesKeyGen.IV);
			}

			rsa = new ThreadLocal<RSACryptoServiceProvider>(() =>
			{
				var result = new RSACryptoServiceProvider();
				result.ImportParameters(privateRsaParameters);
				return result;
			});

			aes = new ThreadLocal<AesCryptoServiceProvider>(() =>
			{
				var result = new AesCryptoServiceProvider();
				result.Key = aesKeyAndIV.Item1;
				result.IV = aesKeyAndIV.Item2;
				return result;
			});

			rsaExponent = OAuthHelper.BytesToString(publicRsaParameters.Exponent);
			rsaModulus = OAuthHelper.BytesToString(publicRsaParameters.Modulus);
		}
예제 #20
0
		public override void InitializeComponent()
		{
			base.InitializeComponent();
			CurrentFakeHleThreads = new ThreadLocal<HleThread>(() => new HleThread(PspEmulatorContext, new CpuThreadState(CpuProcessor)));
			//throw new NotImplementedException();
			//CurrentFakeHleThread = ;
		}
예제 #21
0
파일: SspSyllabifier.cs 프로젝트: rmunn/cog
 public SspSyllabifier(bool combineVowels, bool combineConsonants, bool vowelsSameSonorityTautosyllabic, SegmentPool segmentPool, IEnumerable<SonorityClass> sonorityScale)
     : base(combineVowels, combineConsonants)
 {
     _vowelsSameSonorityTautosyllabic = vowelsSameSonorityTautosyllabic;
     _segmentPool = segmentPool;
     _sonorityScale = sonorityScale.ToList();
     _initialOnsets = new ThreadLocal<HashSet<string>>();
 }
예제 #22
0
        public void DefaultThreadLocalInitTest()
        {
            var local = new ThreadLocal<DateTime>();
            var local2 = new ThreadLocal<object>();

            Assert.AreEqual(default(DateTime), local.Value);
            Assert.AreEqual(default(object), local2.Value);
        }
예제 #23
0
        public string Crack(List<string> plaintext, string target)
        {
            var targetBytes = HexHelper.StringToByteArray(target);
            ThreadLocal<MD5> md5 = new ThreadLocal<MD5>(() => MD5.Create());

            var match = plaintext.AsParallel().Where(p => ByteArrayCompare(targetBytes, md5.Value.ComputeHash(Encoding.Default.GetBytes(p)))).FirstOrDefault();
            return match;
        }
        /// <summary>
        /// Constructs a new JsonNetObjectSerializationProvider.
        /// </summary>
        /// <param name="engine">The engine to de/serialize dependent sub-objects.</param>
        public JsonNetObjectSerializationProvider(IStorageEngine engine = null)
        {
            _guidResolver = new ThreadLocal<SerializedItemsToGuidResolver>(() =>
                new SerializedItemsToGuidResolver(engine));

            _serializer = new ThreadLocal<JsonSerializer>(() =>
                JsonSerializer.Create(new JsonSerializerSettings() {ContractResolver = _guidResolver.Value }));
        }
예제 #25
0
 public static void RunThreadLocalTest1_Ctor()
 {
     ThreadLocal<object> testObject;
     testObject = new ThreadLocal<object>();
     testObject = new ThreadLocal<object>(true);
     testObject = new ThreadLocal<object>(() => new object());
     testObject = new ThreadLocal<object>(() => new object(), true);
 }
        public ThreadLocalByteSegmentLocator(int memoryBlockSize)
        {
            _memoryBlockSize = memoryBlockSize;

            _currentBlock = new ThreadLocal<Tuple<byte[], int>>();

            RenewValue();
        }
예제 #27
0
        protected override object OnInvoke(params object[] lastMappingValues)
        {
            if(GA.IsWebRuntime) return Webx.GetTemp(Id, () => this._lazyCallback.Value(lastMappingValues));

            if(this._local == null) this._local = new ThreadLocal<object>();
            if(!this._local.IsValueCreated) this._local.Value = this._lazyCallback.Value(lastMappingValues);
            return this._local.Value;
        }
예제 #28
0
 public BaseClockSource()
 {
     clockEntries = new List<ClockEntry>();
     clockEntriesUpdateHandlers = new List<UpdateHandlerDelegate>();
     toNotify = new List<Action>();
     nearestTickIn = long.MaxValue;
     sync = new object();
     updateAlreadyInProgress = new ThreadLocal<bool>();
 }
예제 #29
0
        public MsmqJobQueue(string pathPattern)
        {
            if (pathPattern == null) throw new ArgumentNullException("pathPattern");

            _pathPattern = pathPattern;

            _formatter = new ThreadLocal<IMessageFormatter>(
                () => new BinaryMessageFormatter());
        }
예제 #30
0
 public InjectionRuntime(IApiBridge bridge, IDebuggerServer debuggerServer, ITimeSource timeSource)
 {
     interpreter = new ThreadLocal <Interpreter>(() => new Interpreter(Metadata, CurrentFileName, debuggerServer.Create()));
     Api         = new InjectionApi(bridge, Metadata, Globals, timeSource);
     RegisterNatives();
 }
예제 #31
0
        public static void TestTryUpdate()
        {
            var dictionary = new ConcurrentDictionary <string, int>();

            Assert.Throws <ArgumentNullException>(
                () => dictionary.TryUpdate(null, 0, 0));
            // "TestTryUpdate:  FAILED.  TryUpdate didn't throw ANE when null key is passed");

            for (int i = 0; i < 10; i++)
            {
                dictionary.TryAdd(i.ToString(), i);
            }

            for (int i = 0; i < 10; i++)
            {
                Assert.True(dictionary.TryUpdate(i.ToString(), i + 1, i), "TestTryUpdate:  FAILED.  TryUpdate failed!");
                Assert.Equal(i + 1, dictionary[i.ToString()]);
            }

            //test TryUpdate concurrently
            dictionary.Clear();
            for (int i = 0; i < 1000; i++)
            {
                dictionary.TryAdd(i.ToString(), i);
            }

            var mres = new ManualResetEventSlim();

            Task[] tasks = new Task[10];
            ThreadLocal <ThreadData> updatedKeys = new ThreadLocal <ThreadData>(true);

            for (int i = 0; i < tasks.Length; i++)
            {
                // We are creating the Task using TaskCreationOptions.LongRunning because...
                // there is no guarantee that the Task will be created on another thread.
                // There is also no guarantee that using this TaskCreationOption will force
                // it to be run on another thread.
                tasks[i] = Task.Factory.StartNew((obj) =>
                {
                    mres.Wait();
                    int index                     = (((int)obj) + 1) + 1000;
                    updatedKeys.Value             = new ThreadData();
                    updatedKeys.Value.ThreadIndex = index;

                    for (int j = 0; j < dictionary.Count; j++)
                    {
                        if (dictionary.TryUpdate(j.ToString(), index, j))
                        {
                            if (dictionary[j.ToString()] != index)
                            {
                                updatedKeys.Value.Succeeded = false;
                                return;
                            }
                            updatedKeys.Value.Keys.Add(j.ToString());
                        }
                    }
                }, i, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
            }

            mres.Set();
            Task.WaitAll(tasks);

            int numberSucceeded  = 0;
            int totalKeysUpdated = 0;

            foreach (var threadData in updatedKeys.Values)
            {
                totalKeysUpdated += threadData.Keys.Count;
                if (threadData.Succeeded)
                {
                    numberSucceeded++;
                }
            }

            Assert.True(numberSucceeded == tasks.Length, "One or more threads failed!");
            Assert.True(totalKeysUpdated == dictionary.Count,
                        string.Format("TestTryUpdate:  FAILED.  The updated keys count doesn't match the dictionary count, expected {0}, actual {1}", dictionary.Count, totalKeysUpdated));
            foreach (var value in updatedKeys.Values)
            {
                for (int i = 0; i < value.Keys.Count; i++)
                {
                    Assert.True(dictionary[value.Keys[i]] == value.ThreadIndex,
                                string.Format("TestTryUpdate:  FAILED.  The updated value doesn't match the thread index, expected {0} actual {1}", value.ThreadIndex, dictionary[value.Keys[i]]));
                }
            }

            //test TryUpdate with non atomic values (intPtr > 8)
            var dict = new ConcurrentDictionary <int, Struct16>();

            dict.TryAdd(1, new Struct16(1, -1));
            Assert.True(dict.TryUpdate(1, new Struct16(2, -2), new Struct16(1, -1)), "TestTryUpdate:  FAILED.  TryUpdate failed for non atomic values ( > 8 bytes)");
        }
예제 #32
0
        [Category("NotDotNet")]          // nunit results in stack overflow
        public void MultipleReferenceToValueTest()
        {
            threadLocal = new ThreadLocal <int> (() => threadLocal.Value + 1);

            var value = threadLocal.Value;
        }
예제 #33
0
        public HttpSocketServer(IServiceProvider locator)
        {
            this.Locator = locator;
            var endpoints   = new List <IPEndPoint>();
            var networkType = AddressFamily.InterNetworkV6;

            foreach (string key in ConfigurationManager.AppSettings.Keys)
            {
                if (key.StartsWith("HttpAddress", StringComparison.InvariantCultureIgnoreCase))
                {
                    var       addr = new Uri(ConfigurationManager.AppSettings[key]);
                    IPAddress ip;
                    if (!IPAddress.TryParse(addr.Host, out ip))
                    {
                        var ips = Dns.GetHostAddresses(addr.Host);
                        foreach (var i in ips)
                        {
                            if (i.AddressFamily == networkType)
                            {
                                endpoints.Add(new IPEndPoint(i, addr.Port));
                            }
                        }
                        if (endpoints.Count == 0 && ips.Length > 0)
                        {
                            if (ips[0].AddressFamily == AddressFamily.InterNetwork)
                            {
                                networkType = AddressFamily.InterNetwork;
                                foreach (var i in ips)
                                {
                                    if (i.AddressFamily == networkType)
                                    {
                                        endpoints.Add(new IPEndPoint(i, addr.Port));
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        endpoints.Add(new IPEndPoint(ip, addr.Port));
                    }
                }
            }
            if (endpoints.Count == 0)
            {
                Console.WriteLine("Http address not found in config. Starting IPv6 on all interfaces");
                endpoints.Add(new IPEndPoint(Socket.OSSupportsIPv6 ? IPAddress.IPv6Any : IPAddress.Any, 8999));
            }
            else if (endpoints.FindAll(it => it.AddressFamily == AddressFamily.InterNetwork).Count == endpoints.Count)
            {
                networkType = AddressFamily.InterNetwork;
            }
            else if (endpoints.FindAll(it => it.AddressFamily == AddressFamily.InterNetworkV6).Count != endpoints.Count)
            {
                throw new ConfigurationErrorsException(@"Unable to setup configuration for both IPv4 and IPv6. Use either only IPv4 or IPv6. 
Please check settings: " + string.Join(", ", endpoints));
            }
            Socket = new Socket(networkType, SocketType.Stream, ProtocolType.Tcp);
            //Socket.SetSocketOption(SocketOptionLevel.IPv6, (SocketOptionName)27, 0);
            foreach (var ep in endpoints)
            {
                Socket.Bind(ep);
                Console.WriteLine("Bound to: " + ep);
            }
            var maxLen = ConfigurationManager.AppSettings["Revenj.ContentLengthLimit"];

            if (!string.IsNullOrEmpty(maxLen))
            {
                MessageSizeLimit = int.Parse(maxLen);
            }
            var ka = ConfigurationManager.AppSettings["Revenj.KeepAliveLimit"];

            if (!string.IsNullOrEmpty(ka))
            {
                KeepAliveTimeout = int.Parse(ka);
            }
            Routes = new Routes(locator);
            var customAuth = ConfigurationManager.AppSettings["CustomAuth"];

            if (!string.IsNullOrEmpty(customAuth))
            {
                var authType = Type.GetType(customAuth);
                if (!typeof(HttpAuth).IsAssignableFrom(authType))
                {
                    throw new ConfigurationErrorsException("Custom auth does not inherit from HttpAuth. Please inherit from " + typeof(HttpAuth).FullName);
                }
                Authentication = locator.Resolve <HttpAuth>(authType);
            }
            else
            {
                Authentication = locator.Resolve <HttpAuth>();
            }
            Context = new ThreadLocal <HttpSocketContext>(() => new HttpSocketContext("http://127.0.0.1/", MessageSizeLimit));
            var ca = ConfigurationManager.AppSettings["Revenj.HttpCapacity"];

            if (!string.IsNullOrEmpty(ca))
            {
                Requests = new BlockingCollection <RequestInfo>(new ConcurrentQueue <RequestInfo>(), int.Parse(ca));
            }
            else
            {
                Requests = new BlockingCollection <RequestInfo>(new ConcurrentQueue <RequestInfo>());
            }
        }
예제 #34
0
 /// <summary>Initializes a new instance of the <see cref="ConcurrentBag{T}"/> class.</summary>
 public ConcurrentBag()
 {
     _locals = new ThreadLocal <WorkStealingQueue>();
 }
예제 #35
0
 public RuntimeLocal()
 {
     this._threadLocal = new ThreadLocal <TValue>();
 }
예제 #36
0
 static PerThreadContext()
 {
     _threadedContext = new ThreadLocal <PerThreadContext>();
 }
예제 #37
0
            /// <summary>
            /// Sends the batch request to the server and clears the cache and the batchId.
            /// </summary>
            /// <param name="context">The context that sends the request.</param>
            /// <param name="cache">The cache containing the parameters of cached methods.</param>
            /// <param name="batchId">The batchId to retrieve the cached parameters.</param>
            /// <returns>A Task.</returns>
            internal static async Task ExecuteBatch(IContext context, ParametersCache cache, ThreadLocal <Guid> batchId)
            {
                if (!BatchHelper.IsInBatchMode(batchId))
                {
                    throw new InvalidOperationException("The calling thread was trying to do batch operation but it didn't begin the batch operations before.");
                }

                Guid localBatchId = batchId.Value;

                // Clears the batchId before executing the batch operation since after do "await" the original
                // thread will be used to do ExecuteBatchAsync and a new thread will be created to do the rest work.
                // So we will not be able to clear the original thread any more.
                batchId.Value = Guid.Empty;

                List <ParametersGroup> requests             = cache.GetParameters(localBatchId);
                List <TaskCompletionSource <object> > tasks = cache.GetTasks(localBatchId);

                try
                {
                    await context.ExecuteBatchAsync(requests, tasks);
                }
                catch
                {
                    throw;
                }
                finally
                {
                    // Clear the cache for this thread.
                    cache.Clear(localBatchId);
                }
            }
예제 #38
0
 /// <summary>
 /// Checks if the current thread is in batch mode.
 /// </summary>
 /// <param name="batchId">The batchId of current thread.</param>
 /// <returns>True if current thread is in batch mode, otherwise false.</returns>
 internal static bool IsInBatchMode(ThreadLocal <Guid> batchId)
 {
     return(batchId != null && batchId.Value != null && batchId.Value != Guid.Empty);
 }
예제 #39
0
 internal SpeechJournalSource(DiagnosticTrace trace = null)
 {
     lastActionJournalEntryId = new ThreadLocal <long>(false);
     this.trace = trace;
 }
예제 #40
0
        private static void LazyAndThreadLocal()
        {
            //<snippet8>
            // Initialize the integer to the managed thread id of the
            // first thread that accesses the Value property.
            Lazy <int> number = new Lazy <int>(() => Thread.CurrentThread.ManagedThreadId);

            Thread t1 = new Thread(() => Console.WriteLine("number on t1 = {0} ThreadID = {1}",
                                                           number.Value, Thread.CurrentThread.ManagedThreadId));

            t1.Start();

            Thread t2 = new Thread(() => Console.WriteLine("number on t2 = {0} ThreadID = {1}",
                                                           number.Value, Thread.CurrentThread.ManagedThreadId));

            t2.Start();

            Thread t3 = new Thread(() => Console.WriteLine("number on t3 = {0} ThreadID = {1}", number.Value,
                                                           Thread.CurrentThread.ManagedThreadId));

            t3.Start();

            // Ensure that thread IDs are not recycled if the
            // first thread completes before the last one starts.
            t1.Join();
            t2.Join();
            t3.Join();

            /* Sample Output:
             *  number on t1 = 11 ThreadID = 11
             *  number on t3 = 11 ThreadID = 13
             *  number on t2 = 11 ThreadID = 12
             *  Press any key to exit.
             */
            //</snippet8>

            //<snippet9>
            // Initialize the integer to the managed thread id on a per-thread basis.
            ThreadLocal <int> threadLocalNumber = new ThreadLocal <int>(() => Thread.CurrentThread.ManagedThreadId);
            Thread            t4 = new Thread(() => Console.WriteLine("threadLocalNumber on t4 = {0} ThreadID = {1}",
                                                                      threadLocalNumber.Value, Thread.CurrentThread.ManagedThreadId));

            t4.Start();

            Thread t5 = new Thread(() => Console.WriteLine("threadLocalNumber on t5 = {0} ThreadID = {1}",
                                                           threadLocalNumber.Value, Thread.CurrentThread.ManagedThreadId));

            t5.Start();

            Thread t6 = new Thread(() => Console.WriteLine("threadLocalNumber on t6 = {0} ThreadID = {1}",
                                                           threadLocalNumber.Value, Thread.CurrentThread.ManagedThreadId));

            t6.Start();

            // Ensure that thread IDs are not recycled if the
            // first thread completes before the last one starts.
            t4.Join();
            t5.Join();
            t6.Join();

            /* Sample Output:
             * threadLocalNumber on t4 = 14 ThreadID = 14
             * threadLocalNumber on t5 = 15 ThreadID = 15
             * threadLocalNumber on t6 = 16 ThreadID = 16
             */
            //</snippet9>
        }
예제 #41
0
 public Clock(Int32 maximumIdleTime)
 {
     m_MaximumIdleTime = TimeSpan.FromSeconds(maximumIdleTime).Ticks;
     m_StartTime       = new ThreadLocal <DateTime>(() => DateTime.UtcNow, false);
     m_StartTimestamp  = new ThreadLocal <Double>(() => Stopwatch.GetTimestamp(), false);
 }
예제 #42
0
 private void InvalidateLastBlock()
 {
     lastBlockStorage = new ThreadLocal <Block>();
 }
예제 #43
0
 internal LocalDataStoreSlot(ThreadLocal <object?> data)
 {
     Data = data;
     GC.SuppressFinalize(this);
 }
예제 #44
0
        [PlatformSpecific(~TestPlatforms.Browser)] // Operation is not supported on this platform.
        public static void ValuesGetterDoesNotThrowUnexpectedExceptionWhenDisposed()
        {
            var startTest = new ManualResetEvent(false);
            var gotUnexpectedException    = new ManualResetEvent(false);
            ThreadLocal <int> threadLocal = null;
            bool stop = false;

            Action waitForCreatorDisposer;
            Thread creatorDisposer = ThreadTestHelpers.CreateGuardedThread(out waitForCreatorDisposer, () =>
            {
                startTest.CheckedWait();
                do
                {
                    var tl = new ThreadLocal <int>(trackAllValues: true);
                    Volatile.Write(ref threadLocal, tl);
                    tl.Value = 1;
                    tl.Dispose();
                } while (!Volatile.Read(ref stop));
            });

            creatorDisposer.IsBackground = true;
            creatorDisposer.Start();

            int readerCount    = Math.Max(1, Environment.ProcessorCount - 1);
            var waitsForReader = new Action[readerCount];

            for (int i = 0; i < readerCount; ++i)
            {
                Thread reader = ThreadTestHelpers.CreateGuardedThread(out waitsForReader[i], () =>
                {
                    startTest.CheckedWait();
                    do
                    {
                        var tl = Volatile.Read(ref threadLocal);
                        if (tl == null)
                        {
                            continue;
                        }

                        try
                        {
                            IList <int> values = tl.Values;
                        }
                        catch (ObjectDisposedException)
                        {
                        }
                        catch
                        {
                            gotUnexpectedException.Set();
                            throw;
                        }
                    } while (!Volatile.Read(ref stop));
                });
                reader.IsBackground = true;
                reader.Start();
            }

            startTest.Set();
            bool failed = gotUnexpectedException.WaitOne(500);

            Volatile.Write(ref stop, true);
            foreach (Action waitForReader in waitsForReader)
            {
                waitForReader();
            }
            waitForCreatorDisposer();
            Assert.False(failed);
        }
예제 #45
0
        /// <summary>Visualize the partitioning.</summary>
        private void btnVisualize_Click(object sender, EventArgs e)
        {
            int  numProcs = tbCores.Value;
            int  width = pbPartitionedImage.Width, height = pbPartitionedImage.Height;
            bool useParallelFor = rbParallelFor.Checked, useParallelForEach = rbParallelForEach.Checked;

            _workFactor = tbWorkFactor.Value;

            // If we're using Parallel.ForEach or PLINQ, ensure a partitioning scheme was selected and use it
            Tuple <string, Func <int[], Partitioner <int> > > selectedMethod = null;

            if (!useParallelFor)
            {
                if (lvPartitioningMethods.SelectedIndices.Count == 0)
                {
                    return;
                }
                else
                {
                    selectedMethod = (Tuple <string, Func <int[], Partitioner <int> > >)lvPartitioningMethods.SelectedItems[0].Tag;
                }
            }

            // Make sure a workload was selected and use it
            if (lvWorkloads.SelectedItems.Count == 0)
            {
                return;
            }
            var selectedWorkload = (Tuple <string, Func <int, int, int> >)lvWorkloads.SelectedItems[0].Tag;

            // Create a new Bitmap to store the rendered output
            var bmp = new Bitmap(width, height);

            // Disable the start button and kick off the background work
            btnVisualize.Enabled = false;
            Task.Factory.StartNew(() =>
            {
                int nextId   = -1; // assign each thread a unique id
                var threadId = new ThreadLocal <int>(() => Interlocked.Increment(ref nextId));

                using (FastBitmap fastBmp = new FastBitmap(bmp)) // get faster access to the Bitmap's contents
                {
                    var sw = Stopwatch.StartNew();               // time the operation
                    if (useParallelFor)
                    {
                        Parallel.For(0, height, new ParallelOptions {
                            MaxDegreeOfParallelism = numProcs
                        }, i =>
                        {
                            int id = threadId.Value;
                            DoWork(selectedWorkload.Item2(height, i));
                            for (int j = 0; j < width; j++)
                            {
                                fastBmp.SetColor(j, i, _colors[id % _colors.Length]);
                            }
                        });
                    }
                    else
                    {
                        // Create the partitioner to be used
                        var partitioner = selectedMethod.Item2(Enumerable.Range(0, height).ToArray());

                        if (useParallelForEach)
                        {
                            // Run the work with Parallel.ForEach
                            Parallel.ForEach(partitioner, new ParallelOptions {
                                MaxDegreeOfParallelism = numProcs
                            }, i =>
                            {
                                int id = threadId.Value;
                                DoWork(selectedWorkload.Item2(height, i));
                                for (int j = 0; j < width; j++)
                                {
                                    fastBmp.SetColor(j, i, _colors[id % _colors.Length]);
                                }
                            });
                        }
                        else // PLINQ
                        {
                            // Run the work with PLINQ.  If a special partitioning method was selected, use relevant query operators
                            // to get PLINQ to use that partitioning approach.
                            var source = partitioner.AsParallel().WithDegreeOfParallelism(numProcs);
                            if (selectedMethod.Item1 == PartitioningStripe)
                            {
                                source = source.TakeWhile(elem => true);
                            }
                            else if (selectedMethod.Item1 == PartitioningHash)
                            {
                                source = source.Join(Enumerable.Range(0, height).AsParallel(), i => i, i => i, (i, ignore) => i);
                            }
                            source.ForAll(i =>
                            {
                                int id = threadId.Value;
                                DoWork(selectedWorkload.Item2(height, i));
                                for (int j = 0; j < width; j++)
                                {
                                    fastBmp.SetColor(j, i, _colors[id % _colors.Length]);
                                }
                            });
                        }
                    }

                    // Return the total time from the task
                    return(sw.Elapsed);
                }

                // When the work completes, run the following on the UI thread
            }).ContinueWith(t =>
            {
                // Dispose of the old image (if there was one) and display the new one
                var old = pbPartitionedImage.Image;
                pbPartitionedImage.Image = bmp;
                if (old != null)
                {
                    old.Dispose();
                }

                // Re-enable controls on the form and display the elapsed time
                btnVisualize.Enabled = true;
                lblTime.Text         = "Time: " + t.Result.ToString();
            }, TaskScheduler.FromCurrentSynchronizationContext());
        }
 internal Entry(ThreadLocal<T> threadLocal, T value)
 {
     this.weak.SetTarget(threadLocal);
     this.Value = value;
 }
예제 #47
0
        public static void RunThreadLocalTest2_ToString()
        {
            ThreadLocal <object> tlocal = new ThreadLocal <object>(() => (object)1);

            Assert.Equal(1.ToString(), tlocal.ToString());
        }
예제 #48
0
 public IPIReadWriteLockInternal(int numReaders)
 {
     _readIndicator   = new CLRAtomicInt[numReaders + 1];
     _thisReaderIndex = new ThreadLocal <int>();
 }
예제 #49
0
        public static async Task AsyncMethodNotifications()
        {
            //
            // Define thread-local and async-local values.  The async-local value uses its notification
            // to keep the thread-local value in sync with the async-local value.
            //
            ThreadLocal <int> tls = new ThreadLocal <int>();
            AsyncLocal <int>  als = new AsyncLocal <int>(args =>
            {
                tls.Value = args.CurrentValue;
            });

            Assert.Equal(tls.Value, als.Value);

            als.Value = 1;
            Assert.Equal(tls.Value, als.Value);

            als.Value = 2;
            Assert.Equal(tls.Value, als.Value);

            await Run(async() =>
            {
                Assert.Equal(tls.Value, als.Value);
                Assert.Equal(2, als.Value);

                als.Value = 3;
                Assert.Equal(tls.Value, als.Value);

                Task t = Run(async() =>
                {
                    Assert.Equal(tls.Value, als.Value);
                    Assert.Equal(3, als.Value);

                    als.Value = 4;

                    Assert.Equal(tls.Value, als.Value);
                    Assert.Equal(4, als.Value);

                    await Task.Run(() =>
                    {
                        Assert.Equal(tls.Value, als.Value);
                        Assert.Equal(4, als.Value);

                        als.Value = 5;

                        Assert.Equal(tls.Value, als.Value);
                        Assert.Equal(5, als.Value);
                    });

                    Assert.Equal(tls.Value, als.Value);
                    Assert.Equal(4, als.Value);

                    als.Value = 6;

                    Assert.Equal(tls.Value, als.Value);
                    Assert.Equal(6, als.Value);
                });

                Assert.Equal(tls.Value, als.Value);
                Assert.Equal(3, als.Value);

                await Task.Yield();

                Assert.Equal(tls.Value, als.Value);
                Assert.Equal(3, als.Value);

                await t;

                Assert.Equal(tls.Value, als.Value);
                Assert.Equal(3, als.Value);
            });

            Assert.Equal(tls.Value, als.Value);
            Assert.Equal(2, als.Value);
        }
예제 #50
0
        public static void TestMaxItemsPerTask(int maxConcurrency, int maxItemsPerTask, bool completeBeforeTaskWait)
        {
            //Create a custom TaskScheduler with specified max concurrency (TrackingTaskScheduler is defined in Common\tools\CommonUtils\TPLTestSchedulers.cs)
            TrackingTaskScheduler scheduler = new TrackingTaskScheduler(maxConcurrency);
            //We need to use the custom scheduler to achieve the results. As a by-product, we test to ensure custom schedulers are supported
            ConcurrentExclusiveSchedulerPair schedPair = new ConcurrentExclusiveSchedulerPair(scheduler, maxConcurrency, maxItemsPerTask);
            TaskFactory readers = new TaskFactory(schedPair.ConcurrentScheduler); //get reader and writer schedulers
            TaskFactory writers = new TaskFactory(schedPair.ExclusiveScheduler);

            //These are threadlocals to ensure that no concurrency side effects occur
            ThreadLocal <int> itemsExecutedCount    = new ThreadLocal <int>(); //Track the items executed by CEScheduler Task
            ThreadLocal <int> schedulerIDInsideTask = new ThreadLocal <int>(); //Used to store the Scheduler ID observed by a Task Executed by CEScheduler Task

            //Work done by both reader and writer tasks
            Action work = () =>
            {
                //Get the id of the parent Task (which is the task created by the scheduler). Each task run by the scheduler task should
                //see the same SchedulerID value since they are run on the same thread
                int id = ((TrackingTaskScheduler)scheduler).SchedulerID.Value;
                if (id == schedulerIDInsideTask.Value)
                { //since ids match, this is one more Task being executed by the CEScheduler Task
                    itemsExecutedCount.Value = ++itemsExecutedCount.Value;
                    //This does not need to be thread safe since we are looking to ensure that only n number of tasks were executed and not the order
                    //in which they were executed. Also asserting inside the thread is fine since we just want the test to be marked as failure
                    Assert.True(itemsExecutedCount.Value <= maxItemsPerTask, string.Format("itemsExecutedCount={0} cant be greater than maxValue={1}. Parent TaskID={2}",
                                                                                           itemsExecutedCount, maxItemsPerTask, id));
                }
                else
                {                                     //Since ids don't match, this is the first Task being executed in the CEScheduler Task
                    schedulerIDInsideTask.Value = id; //cache the scheduler ID seen by the thread, so other tasks running in same thread can see this
                    itemsExecutedCount.Value    = 1;
                }
                //Give enough time for a Task to stay around, so that other tasks will be executed by the same CEScheduler Task
                //or else the CESchedulerTask will die and each Task might get executed by a different CEScheduler Task. This does not affect the
                //verifications, but its increases the chance of finding a bug if the maxItemPerTask is not respected
                new ManualResetEvent(false).WaitOne(1);
            };

            List <Task> taskList           = new List <Task>();
            int         maxConcurrentTasks = maxConcurrency * maxItemsPerTask * 5;
            int         maxExclusiveTasks  = maxConcurrency * maxItemsPerTask * 2;

            // Schedule Tasks in both concurrent and exclusive mode
            for (int i = 0; i < maxConcurrentTasks; i++)
            {
                taskList.Add(readers.StartNew(work));
            }
            for (int i = 0; i < maxExclusiveTasks; i++)
            {
                taskList.Add(writers.StartNew(work));
            }

            if (completeBeforeTaskWait)
            {
                schedPair.Complete();
                schedPair.Completion.Wait();
                Assert.True(taskList.TrueForAll(t => t.IsCompleted), "All tasks should have completed for scheduler to complete");
            }

            //finally wait for all of the tasks, to ensure they all executed properly
            Task.WaitAll(taskList.ToArray());

            if (!completeBeforeTaskWait)
            {
                schedPair.Complete();
                schedPair.Completion.Wait();
                Assert.True(taskList.TrueForAll(t => t.IsCompleted), "All tasks should have completed for scheduler to complete");
            }
        }
예제 #51
0
 /// <summary>释放所有会话</summary>
 internal void ReleaseSession()
 {
     //_store.Values.TryDispose();
     _store.TryDispose();
     _store = new ThreadLocal <IDbSession>();
 }
예제 #52
0
 public void Setup()
 {
     nTimes      = 0;
     threadLocal = new ThreadLocal <int> (() => { Interlocked.Increment(ref nTimes); return(42); });
 }
예제 #53
0
 private void initialize()
 {
     locals = new ThreadLocal <Locals>(() => new Locals());
 }
예제 #54
0
        public static void RunThreadLocalTest8_Values()
        {
            // Test adding values and updating values
            {
                var threadLocal = new ThreadLocal <int>(true);
                Assert.True(threadLocal.Values.Count == 0, "RunThreadLocalTest8_Values: Expected thread local to initially have 0 values");
                Assert.True(threadLocal.Value == 0, "RunThreadLocalTest8_Values: Expected initial value of 0");
                Assert.True(threadLocal.Values.Count == 1, "RunThreadLocalTest8_Values: Expected values count to now be 1 from initialized value");
                Assert.True(threadLocal.Values[0] == 0, "RunThreadLocalTest8_Values: Expected values to contain initialized value");

                threadLocal.Value = 1000;
                Assert.True(threadLocal.Values.Count == 1, "RunThreadLocalTest8_Values: Expected values count to still be 1 after updating existing value");
                Assert.True(threadLocal.Values[0] == 1000, "RunThreadLocalTest8_Values: Expected values to contain updated value");

                ((IAsyncResult)Task.Run(() => threadLocal.Value = 1001)).AsyncWaitHandle.WaitOne();
                Assert.True(threadLocal.Values.Count == 2, "RunThreadLocalTest8_Values: Expected values count to be 2 now that another thread stored a value");
                Assert.True(threadLocal.Values.Contains(1000) && threadLocal.Values.Contains(1001), "RunThreadLocalTest8_Values: Expected values to contain both thread's values");

                int    numTasks = 1000;
                Task[] allTasks = new Task[numTasks];
                for (int i = 0; i < numTasks; i++)
                {
                    // We are creating the task using TaskCreationOptions.LongRunning because...
                    // there is no guarantee that the Task will be created on another thread.
                    // There is also no guarantee that using this TaskCreationOption will force
                    // it to be run on another thread.
                    var task = Task.Factory.StartNew(() => threadLocal.Value = i, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
                    task.Wait();
                }

                var values = threadLocal.Values;
                if (values.Count != 1002)
                {
                    string message =
                        "RunThreadLocalTest8_Values: Expected values to contain both previous values and 1000 new values. Actual count: " +
                        values.Count +
                        '.';
                    if (values.Count != 0)
                    {
                        message += " Missing items:";
                        for (int i = 0; i < 1002; i++)
                        {
                            if (!values.Contains(i))
                            {
                                message += " " + i;
                            }
                        }
                    }
                    Assert.True(false, message);
                }
                for (int i = 0; i < 1000; i++)
                {
                    Assert.True(values.Contains(i), "RunThreadLocalTest8_Values: Expected values to contain value for thread #: " + i);
                }

                threadLocal.Dispose();
            }

            // Test that thread values remain after threads depart
            {
                var tl = new ThreadLocal <string>(true);
                var t  = Task.Run(() => tl.Value = "Parallel");
                t.Wait();
                t = null;
                GC.Collect();
                GC.WaitForPendingFinalizers();
                GC.Collect();
                Assert.True(tl.Values.Count == 1, "RunThreadLocalTest8_Values: Expected values count to be 1 from other thread's initialization");
                Assert.True(tl.Values.Contains("Parallel"), "RunThreadLocalTest8_Values: Expected values to contain 'Parallel'");
            }
        }
예제 #55
0
        protected override void InitializeCore()
        {
            base.InitializeCore();

            threadContext = new ThreadLocal <ThreadContext>(() => new ThreadContext(Context.GraphicsDevice), true);
        }
예제 #56
0
 private static void InitializeDownloadFileWatcher()
 {
     _fileSystemWatcher = new ThreadLocal <FileSystemWatcher>(() => new FileSystemWatcher(GetSystemDownloadsPath()));
     _fileSystemWatcher.Value.Changed            += FilesChanged;
     _fileSystemWatcher.Value.EnableRaisingEvents = true;
 }
예제 #57
0
        static void Main(string[] args)
        {
            var builder = new SqlConnectionStringBuilder()
            {
                DataSource = "test.db",
            };

            TypeMapper.SetSnakeToCamelCase <Model>();
            TypeMapper.SetSnakeToCamelCase <Texture>();
            TypeMapper.SetSnakeToCamelCase <ModelTextureId>();

#if false
            using (var conn = new SQLiteConnection(builder.ToString()))
            {
                conn.Open();
                conn.Execute("PRAGMA foreign_keys = ON");

                QueryBuilder.CreateTable <Model>(conn);
                QueryBuilder.CreateTable <Texture>(conn);

                conn.Execute("DROP TABLE IF EXISTS `model_texture_ids`");
                conn.Execute(string.Format(@"
CREATE TABLE `model_texture_ids` (
    `model_id` INTEGER,
    `texture_id` INTEGER,
    FOREIGN KEY(`model_id`) REFERENCES `models`(`id`) ON DELETE CASCADE ON UPDATE CASCADE,
    FOREIGN KEY(`texture_id`) REFERENCES `textures`(`id`) ON DELETE CASCADE ON UPDATE CASCADE,
    UNIQUE(`model_id`, `texture_id`)
)
"));
            }
#endif

            using (var conn = new SQLiteConnection(builder.ToString()))
            {
                conn.Open();
                conn.Execute("PRAGMA foreign_keys = ON");

                var iterations = 100000;
                var ids        = Enumerable.Range(0, iterations).OrderBy(_ => Guid.NewGuid()).ToArray();
                var rand       = new Random(0x12345678);

#if false
                var models = Enumerable.Range(0, iterations).Select(x => new Model()
                {
                    Name = $"model_{x}"
                }).ToArray();
                var textures = Enumerable.Range(0, iterations).Select(x => new Texture()
                {
                    Name = $"texture_{x}"
                }).ToArray();

                foreach (var model in models)
                {
                    var textureIds = Enumerable.Range(0, rand.Next(0, 5))
                                     .Select(_ => rand.Next(0, iterations))
                                     .Distinct();
                    model.Textures = textureIds.Select(x => textures[x]).ToArray();
                }

                using (new ScopedTimer())
                    using (var trans = conn.BeginTransaction())
                    {
                        foreach (var model in models)
                        {
                            conn.Execute("INSERT INTO `models` (`name`) values(@name)", new { name = model.Name });
                            model.Id = (int)conn.ExecuteScalar <long>("SELECT last_insert_rowid()");
                        }

                        foreach (var texture in textures)
                        {
                            conn.Execute("INSERT INTO `textures` (`name`) values(@name)", new { name = texture.Name });
                            texture.Id = (int)conn.ExecuteScalar <long>("SELECT last_insert_rowid()");
                        }

                        foreach (var model in models)
                        {
                            foreach (var texture in model.Textures)
                            {
                                conn.Execute(
                                    "INSERT INTO `model_texture_ids` (`model_id`, `texture_id`) values (@model_id, @texture_id)",
                                    new { model_id = model.Id, texture_id = texture.Id });
                            }
                        }

                        trans.Commit();
                    }

                using (new ScopedTimer())
                    using (var trans = conn.BeginTransaction())
                    {
                        for (var i = 0; i < iterations; ++i)
                        {
                            var model = models[ids[i]];
                            conn.Execute("UPDATE `models` SET `name`=@new_name WHERE `id`=@id", new { id = model.Id, new_name = $"{model.Name}_1" });
                        }
                        trans.Commit();
                    }
#endif

                GC.Collect();

                Model[] models;
                using (new ScopedTimer())
                {
                    var query = @"
SELECT * FROM `models` AS `m`
LEFT JOIN `model_texture_ids` AS `mt` ON `mt`.`model_id` = `m`.`id`
LEFT JOIN `textures` AS `t` ON `t`.`id` = `mt`.`texture_id`
";

                    var modelCache   = new Dictionary <int, Model>();
                    var textureCache = new Dictionary <int, Texture>();

                    models = conn.Query <Model, ModelTextureId, Texture, Model>(
                        query,
                        (m, _, t) =>
                    {
                        var isNew = false;

                        Model model;
                        if (!modelCache.TryGetValue(m.Id, out model))
                        {
                            model            = m;
                            model.Textures   = new List <Texture>();
                            modelCache[m.Id] = model;
                            isNew            = true;
                        }

                        if (t != null)
                        {
                            Texture tex;
                            if (!textureCache.TryGetValue(t.Id, out tex))
                            {
                                tex = t;
                                textureCache[t.Id] = tex;
                            }

                            model.Textures.Add(tex);
                        }

                        return(isNew ? model : null);
                    },
                        splitOn: "id,model_id,id")
                             .Where(x => x != null)
                             .ToArray();
                }
                Console.WriteLine(models.Length);
            }

#if false
            using (new ScopedTimer())
            {
                using (var conn = new ThreadLocal <SQLiteConnection>(() => { var item = new SQLiteConnection(builder.ToString()); item.Open(); return(item); }, true))
                {
                    Parallel.For(0, 100, i =>
                    {
                        Thread.Sleep(100);
                        using (var trans = conn.Value.BeginTransaction())
                        {
                            conn.Value.Execute("INSERT INTO `test_table` (`name`, `test_name`) values(@name, @test_name)", new { name = Guid.NewGuid().ToString(), test_name = "test_" + Guid.NewGuid().ToString() });
                        }
                    });

                    foreach (var item in conn.Values)
                    {
                        item.Dispose();
                    }
                }
            }

            using (new ScopedTimer())
            {
                using (var conn = new SQLiteConnection(builder.ToString()))
                {
                    conn.Open();
                    using (var trans = conn.BeginTransaction())
                    {
                        for (var i = 0; i < 100; ++i)
                        {
                            Thread.Sleep(100);
                            conn.Execute("INSERT INTO `test_table` (`name`, `test_name`) values(@name, @test_name)", new { name = Guid.NewGuid().ToString(), test_name = "test_" + Guid.NewGuid().ToString() });
                        }
                    }
                }
            }

            using (new ScopedTimer())
            {
                Parallel.For(0, 100, i => Thread.Sleep(100));
                using (var conn = new SQLiteConnection(builder.ToString()))
                {
                    conn.Open();
                    using (var trans = conn.BeginTransaction())
                    {
                        for (var i = 0; i < 100; ++i)
                        {
                            conn.Execute("INSERT INTO `test_table` (`name`, `test_name`) values(@name, @test_name)", new { name = Guid.NewGuid().ToString(), test_name = "test_" + Guid.NewGuid().ToString() });
                        }
                        trans.Commit();
                    }
                }
            }

            using (var conn = new SQLiteConnection(builder.ToString()))
            {
                SqlMapper.SetTypeMap(typeof(TestTable), new CustomPropertyTypeMap(typeof(TestTable), (type, name) =>
                {
                    // snake_case -> CamelCase
                    var propName = string.Join("", name.Split('_').Select(x => (x.Length > 1) ? x[0].ToString().ToUpper() + x.Substring(1) : x.ToUpper()));
                    return(type.GetProperty(propName));
                }));

                IEnumerable <TestTable> data;
                using (new ScopedTimer())
                {
                    data = conn.Query <TestTable>("SELECT * from `test_table`");
                }
                Console.WriteLine(data.Count());
            }
#endif

            Console.WriteLine("complete!!");
            Console.ReadKey();
        }
예제 #58
0
 public BufferPoolThreadLocal(ISerializationService serializationService)
 {
     _threadLocal = new ThreadLocal <BufferPool>(() => new BufferPool(serializationService), false);
 }
 /// <summary>
 /// Cleans up the dispatcher helpers.
 /// </summary>
 public static void Reset()
 {
     s_isOnDispatcherThread.Dispose();
     s_isOnDispatcherThread = null;
     s_mainDispatcher       = null;
 }
예제 #60
-1
파일: SpellChecker.cs 프로젝트: MIDNP/MIDNP
        public void Run()
        {
            var wordLookupFile = Path.Combine(Path.GetTempPath(), "WordLookup.txt");

            if (!File.Exists(wordLookupFile))
            {
                new WebClient().DownloadFile("http://www.albahari.com/ispell/allwords.txt", wordLookupFile);
            }

            var wordLookup = new HashSet<string>(File.ReadAllLines(wordLookupFile), StringComparer.InvariantCultureIgnoreCase);
            var wordList = wordLookup.ToArray();

            // Here, we're using ThreadLocal to generate a thread-safe random number generator,
            // so we can parallelize the building of the wordsToTest array.
            var localRandom = new ThreadLocal<Random>(() => new Random(Guid.NewGuid().GetHashCode()));
            var wordsToTest = Enumerable.Range(0, 1000000)
                .AsParallel()
                .Select(i => wordList[localRandom.Value.Next(0, wordList.Length)])
                .ToArray();

            wordsToTest[12345] = "woozsh";     // Introduce a couple
            wordsToTest[23456] = "wubsie";     // of spelling mistakes.

            var query = wordsToTest
                .AsParallel()
                //.Select((word, index) => new IndexedWord { Word = word, Index = index })
                .Select((word, index) => new { Word = word, Index = index })
                .Where(iword => !wordLookup.Contains(iword.Word))
                .OrderBy(iword => iword.Index);

            var result = query.ToList();
        }