public override void Run()
{
var clientsPool = new ThreadwisePool <string>();
var clientsCount = 0;
// display ping times continuously
var pingTimes = pingThread(clientsPool)
.ToObservable()
.ObserveOn(Scheduler.NewThread)
.SubscribeOn(Scheduler.CurrentThread)
.Sample(TimeSpan.FromMilliseconds(PingStatInterval / PingStatWindow))
.Buffer(TimeSpan.FromMilliseconds(PingStatInterval))
.Select(times => times.DefaultIfEmpty(0.0).Average())
.Subscribe(logPingTime);
// begin spawing clients
while (clientsCount < MaxClients)
{
var diff = (clientsCount * ClientsStepping) - clientsCount;
diff = Math.Max(1, Math.Min(diff, MaxClients - clientsCount));
GC.Collect();
spawnThreads(clientsPool, diff);
clientsCount += diff;
Thread.Sleep(SteppingDelay);
}
// stall
WriteLine("Spawned all clients. To stop, close this application.");
Thread.Sleep(Timeout.Infinite);
}
public override void Run()
{
var clientsPool = new ThreadwisePool<string>();
var clientsCount = 0;
// display ping times continuously
var pingTimes = pingThread(clientsPool)
.ToObservable()
.ObserveOn(Scheduler.NewThread)
.SubscribeOn(Scheduler.CurrentThread)
.Sample(TimeSpan.FromMilliseconds(PingStatInterval / PingStatWindow))
.BufferWithTime(TimeSpan.FromMilliseconds(PingStatInterval))
.Select(times => times.DefaultIfEmpty(0.0).Average())
.Subscribe(logPingTime);
// begin spawing clients
while (clientsCount < MaxClients) {
var diff = (clientsCount * ClientsStepping) - clientsCount;
diff = Math.Max(1, Math.Min(diff, MaxClients - clientsCount));
GC.Collect();
spawnThreads(clientsPool, diff);
clientsCount += diff;
Thread.Sleep(SteppingDelay);
}
// stall
WriteLine("Spawned all clients. To stop, close this application.");
Thread.Sleep(Timeout.Infinite);
}
public override void Run()
{
var pool = new ThreadwisePool <string>();
var mainClient = pool.GetClient();
// setup a bag of keys to randomly increments
var keys = Enumerable
.Range(0, TotalKeys)
.Select(k => "counter" + k.ToString())
.ToArray();
var keysBag = new ConcurrentBag <string>();
var keySets = TotalTasks / TotalKeys;
for (var i = 0; i < keySets; i++)
{
foreach (var key in keys)
{
keysBag.Add(key);
}
}
// ensure key is empty
foreach (var key in keys)
{
mainClient.Del(key);
}
// increment keys from multiple thread
WriteLine("Incrementing keys: " + string.Join(", ", keys));
Task.WaitAll(Enumerable
.Range(0, TotalTasks)
.Select(n => Task.Factory.StartNew(() =>
{
// obtain a key to increment
string key;
if (!keysBag.TryTake(out key))
{
WriteLine("ERROR");
}
// obtain an IRedisClient from the pool
// and use it to INCR a key
var client = pool.GetClient();
client.Incr(key);
}))
.ToArray());
// log result
WriteLine("Result (should be equal):");
foreach (var key in keys)
{
WriteLine(key + " : " + mainClient.Get(key));
}
}
public Server()
{
string redisAddr = API.GetConvar("trackm_redis_addr", "127.0.0.1:6379");
SplitHostPort(redisAddr, out string redisHost, out int redisPort);
int redisDb = API.GetConvarInt("trackm_redis_db", 0);
var settings = RedisSettings.Build()
.Host(redisHost)
.Port(redisPort)
.ReconnectOnIdle(true)
.ReissueCommandsOnReconnect(false);
pool = new ThreadwisePool(settings, redisDb);
IRedisClient <string> client = pool.GetClient();
client.FlushDb();
updateInterval = API.GetConvarInt("trackm_update_interval", 1000);
if (updateInterval < MinimumUpdateInterval)
{
Debug.WriteLine("trackm_update_interval set too low ({0}ms) using minimum {1}ms.", updateInterval, MinimumUpdateInterval);
updateInterval = MinimumUpdateInterval;
}
movementThreshold = API.GetConvarInt("trackm_movement_threshold", 1);
if (movementThreshold < MinimumMovementThreshold)
{
Debug.WriteLine("trackm_movement_threshold set too low ({0}m) using minimum {1}m.", movementThreshold, MinimumMovementThreshold);
movementThreshold = MinimumMovementThreshold;
}
// clients deal with squared distances
movementThreshold *= movementThreshold;
// fivem events
EventHandlers["playerDropped"] += new Action <Player, string>(PlayerDropped);
// internal events
EventHandlers[Prefix + "register"] += new Action <Player, int, string, string>(Register);
EventHandlers[Prefix + "unregister"] += new Action <Player, int>(Unregister);
// public events
EventHandlers[Prefix + "Track"] += new Action <int, int>(Track);
EventHandlers[Prefix + "Untrack"] += new Action <int, int>(Untrack);
EventHandlers[Prefix + "MetadataGet"] += new Action <int, int, string, CallbackDelegate>(MetadataGet);
EventHandlers[Prefix + "MetadataSet"] += new Action <int, int, string, string>(MetadataSet);
EventHandlers[Prefix + "MetadataDelete"] += new Action <int, int, string>(MetadataDelete);
}
public override void Run()
{
var pool = new ThreadwisePool<string>();
var mainClient = pool.GetClient();
// setup a bag of keys to randomly increments
var keys = Enumerable
.Range(0, TotalKeys)
.Select(k => "counter" + k.ToString())
.ToArray();
var keysBag = new ConcurrentBag<string>();
var keySets = TotalTasks / TotalKeys;
for (var i = 0; i < keySets; i++)
foreach (var key in keys)
keysBag.Add(key);
// ensure key is empty
foreach (var key in keys)
mainClient.Del(key);
// increment keys from multiple thread
WriteLine("Incrementing keys: " + string.Join(", ", keys));
Task.WaitAll(Enumerable
.Range(0, TotalTasks)
.Select(n => Task.Factory.StartNew(() =>
{
// obtain a key to increment
string key;
if (!keysBag.TryTake(out key))
WriteLine("ERROR");
// obtain an IRedisClient from the pool
// and use it to INCR a key
var client = pool.GetClient();
client.Incr(key);
}))
.ToArray());
// log result
WriteLine("Result (should be equal):");
foreach (var key in keys)
WriteLine(key + " : " + mainClient.Get(key));
}
