[FSSDK-11177] lock implementation

Author: junaed-optimizely

OptimizelySDK.Tests/CmabTests/DefaultCmabServiceTest.cs

@@ -489,6 +489,103 @@ public void ConstructorUsesProvidedClientInstance()
             Assert.AreSame(mockClient, client);
         }
 
+        [Test]
+        public void ConcurrentRequestsForSameUserUseCacheAfterFirstNetworkCall()
+        {
+            var experiment = CreateExperiment(TEST_RULE_ID, new List<string> { AGE_ATTRIBUTE_ID });
+            var attributeMap = new Dictionary<string, AttributeEntity>
+            {
+                { AGE_ATTRIBUTE_ID, new AttributeEntity { Id = AGE_ATTRIBUTE_ID, Key = "age" } },
+            };
+            var projectConfig = CreateProjectConfig(TEST_RULE_ID, experiment, attributeMap);
+            var userContext = CreateUserContext(TEST_USER_ID,
+                new Dictionary<string, object> { { "age", 25 } });
+
+            var clientCallCount = 0;
+            var clientCallLock = new object();
+
+            _mockCmabClient.Setup(c => c.FetchDecision(
+                TEST_RULE_ID,
+                TEST_USER_ID,
+                It.Is<IDictionary<string, object>>(attrs =>
+                    attrs != null && attrs.Count == 1 && attrs.ContainsKey("age") &&
+                    (int)attrs["age"] == 25),
+                It.IsAny<string>(),
+                It.IsAny<TimeSpan?>()))
+                .Returns(() =>
+                {
+                    lock (clientCallLock)
+                    {
+                        clientCallCount++;
+                    }
+                    System.Threading.Thread.Sleep(100);
+
+                    return "varConcurrent";
+                });
+
+            var tasks = new System.Threading.Tasks.Task<CmabDecision>[10];
+
+            for (int i = 0; i < tasks.Length; i++)
+            {
+                tasks[i] = System.Threading.Tasks.Task.Run(() =>
+                    _cmabService.GetDecision(projectConfig, userContext, TEST_RULE_ID));
+            }
+
+            System.Threading.Tasks.Task.WaitAll(tasks);
+
+            foreach (var task in tasks)
+            {
+                Assert.IsNotNull(task.Result);
+                Assert.AreEqual("varConcurrent", task.Result.VariationId);
+            }
+
+            Assert.AreEqual(1, clientCallCount,
+                "Client should only be called once - subsequent requests should use cache");
+
+            _mockCmabClient.VerifyAll();
+        }
+
+        [Test]
+        public void SameUserRuleCombinationUsesConsistentLock()
+        {
+            var userId = "test_user";
+            var ruleId = "test_rule";
+
+            var index1 = _cmabService.GetLockIndex(userId, ruleId);
+            var index2 = _cmabService.GetLockIndex(userId, ruleId);
+            var index3 = _cmabService.GetLockIndex(userId, ruleId);
+
+            Assert.AreEqual(index1, index2, "Same user/rule should always use same lock");
+            Assert.AreEqual(index2, index3, "Same user/rule should always use same lock");
+        }
+
+        [Test]
+        public void LockStripingDistribution()
+        {
+            var testCases = new[]
+            {
+                new { UserId = "user1", RuleId = "rule1" },
+                new { UserId = "user2", RuleId = "rule1" },
+                new { UserId = "user1", RuleId = "rule2" },
+                new { UserId = "user3", RuleId = "rule3" },
+                new { UserId = "user4", RuleId = "rule4" },
+            };
+
+            var lockIndices = new HashSet<int>();
+            foreach (var testCase in testCases)
+            {
+                var index = _cmabService.GetLockIndex(testCase.UserId, testCase.RuleId);
+
+                Assert.GreaterOrEqual(index, 0, "Lock index should be non-negative");
+                Assert.Less(index, 1000, "Lock index should be less than NUM_LOCK_STRIPES (1000)");
+
+                lockIndices.Add(index);
+            }
+
+            Assert.Greater(lockIndices.Count, 1,
+                "Different user/rule combinations should generally use different locks");
+        }
+
         private static ICache<CmabCacheEntry> GetInternalCache(DefaultCmabService service)
         {
             return Reflection.GetFieldValue<ICache<CmabCacheEntry>, DefaultCmabService>(service,
@@ -554,5 +651,9 @@ private static Experiment CreateExperiment(string ruleId, List<string> attribute
                 Cmab = attributeIds == null ? null : new Entity.Cmab(attributeIds),
             };
         }
+
+        
+
+        
     }
 }

OptimizelySDK/Cmab/DefaultCmabService.cs

@@ -83,9 +83,16 @@ public class CmabCacheEntry
     /// </summary>
     public class DefaultCmabService : ICmabService
     {
+        /// <summary>
+        /// Number of lock stripes to use for concurrency control.
+        /// Using multiple locks reduces contention while ensuring the same user/rule combination always uses the same lock.
+        /// </summary>
+        private const int NUM_LOCK_STRIPES = 1000;
+
         private readonly ICache<CmabCacheEntry> _cmabCache;
         private readonly ICmabClient _cmabClient;
         private readonly ILogger _logger;
+        private readonly object[] _locks;
 
         /// <summary>
         /// Initializes a new instance of the DefaultCmabService class.
@@ -100,12 +107,46 @@ public DefaultCmabService(ICache<CmabCacheEntry> cmabCache,
             _cmabCache = cmabCache;
             _cmabClient = cmabClient;
             _logger = logger;
+            _locks = Enumerable.Range(0, NUM_LOCK_STRIPES).Select(_ => new object()).ToArray();
+        }
+
+        /// <summary>
+        /// Calculate the lock index for a given user and rule combination.
+        /// Uses MurmurHash to ensure consistent lock selection for the same user/rule while distributing different combinations across locks.
+        /// </summary>
+        /// <param name="userId">The user ID.</param>
+        /// <param name="ruleId">The experiment/rule ID.</param>
+        /// <returns>The lock index in the range [0, NUM_LOCK_STRIPES).</returns>
+        internal int GetLockIndex(string userId, string ruleId)
+        {
+            var hashInput = $"{userId}{ruleId}";
+            var murmer32 = Murmur.MurmurHash.Create32(0, true);
+            var data = Encoding.UTF8.GetBytes(hashInput);
+            var hash = murmer32.ComputeHash(data);
+            var hashValue = BitConverter.ToUInt32(hash, 0);
+            return (int)(hashValue % NUM_LOCK_STRIPES);
         }
 
         public CmabDecision GetDecision(ProjectConfig projectConfig,
             OptimizelyUserContext userContext,
             string ruleId,
             OptimizelyDecideOption[] options = null)
+        {
+            var lockIndex = GetLockIndex(userContext.GetUserId(), ruleId);
+            lock (_locks[lockIndex])
+            {
+                return GetDecisionInternal(projectConfig, userContext, ruleId, options);
+            }
+        }
+
+        /// <summary>
+        /// Internal implementation of GetDecision that performs the actual decision logic.
+        /// This method should only be called while holding the appropriate lock.
+        /// </summary>
+        private CmabDecision GetDecisionInternal(ProjectConfig projectConfig,
+            OptimizelyUserContext userContext,
+            string ruleId,
+            OptimizelyDecideOption[] options = null)
         {
             var optionSet = options ?? new OptimizelyDecideOption[0];
             var filteredAttributes = FilterAttributes(projectConfig, userContext, ruleId);