Random = Violent Rage

[pro4never]

So, putting this in copservers instead of coprogramming due to someone else having had a similar issue with server related random methods.


Issue:

System.Random is obviously pseudo random but works reasonably well.... or DOES it?

When my server runs for long enough (regardless of sharing a single static Random or even if I test by re-setting the random each time it's called) it starts just throwing out junk numbers.


Example:

public static int RandomNext(int maxVal)
        {
            var v = RND.Next( maxVal);
            if (v > maxVal)
            {
                Console.WriteLine("Resetting random seed!! (Past Max)");
                RND = new Random();
                v = RND.Next(maxVal);
            }
            if (v == 0)
            {
                nullValues++;
                if (nullValues > 5)
                {
                    Console.WriteLine("Resetting random seed!! (Too many Zeros)");
                    RND = new Random();
                    v = RND.Next(maxVal);
                    nullValues = 0;
                }
            }
            else
                nullValues = 0;
            return v;
        }

This is just a super basic example which counts how many times in a row zero is returned.

In virtually ALL of my calls of this code I'm rolling a 100,000 value (percent success accurate to 3 decimal places).

This runs perfectly fine for a very long time... but eventually we start getting zeros thrown almost every time.

I've tried various quick fixes including resetting the random seed, ALWAYS returning from a new random class instead of all these sanity checks... hell we tried reverse engineering tq's own random class from the eudemons source.

No matter what, we always eventually end up with junk values being returned.



Note: Here's our test implementation of tq's random class... I don't consider it that special as anyone could download their source and reverse it damn easy.

public static int RandGet(int max, bool reset = false)
        {
            if (reset) _randomSeed = UnixTimestamp;

            long x = 0xffffffff;
            double i;
            long final;

            _randomSeed *= 134775813L;
            _randomSeed += 1;
            _randomSeed = Math.Abs(_randomSeed);
            _randomSeed = _randomSeed % x;
            i = _randomSeed / (double)0xffffffff;
            if (i > 1)
            {
                Console.WriteLine("\r\r\r\tReturned Number: " + (long)(max * i) + " where max is: " + max + " Seed state of " + _randomSeed + " i value: " + i +"\r\r");               
            }
            final = (long)(max * i);

            if (final > max)
            {
                Console.WriteLine("\r\r\r\tReturned Number: " + final + " where max is: " + max + " Seed state of " + _randomSeed + " i value: " + i+"\r\r\r");
                Console.WriteLine("ERROR! Invalid number thrown from call stack:");
                Console.WriteLine(Environment.StackTrace.ToString());
                final = new Random().Next(max);
                _randomSeed = UnixTimestamp;
            }
            return (int)final;
        }

What's interesting here is... it works perfectly fine if we try to do massive numbers of iterations (I think most we tested was 100 million in a row without issue)... again if we let it run over TIME (day or so) it starts to return complete garbage (greater than max)

Some examples of junk data being returned...

Returned: 17867370611
Max #: 14
Seed: 3998188691
Value of i: 1276240757.9309


Returned: 4063877655
Max #: 150
Seed: 1023408433
Value of i: 27092485.5720175



So yah... looking for options and also just scratching my head going "wtf" (at the system random, I expected nothing much from a basic reverse engineered tq random generator lol).

What would be causing System.Random to start returning zeros virtually every time we call it when the maxvalue entered was greater than 1 (and most often 100,000)



<edit>

After talking to korv I'm gonna try doing it so that if it returns junk too many times I set the random seed using tq's random generator (cause even if it returns greater then max value, it's still a random seed not related to computer time which I'm fairly sure must be the issue)

Side question. Does Random() by default use Environment.Tickcount to set its seed? A few seconds on google just said it was related to the computer time so I'm fairly sure it is... just curious though.

[BaussHacker]

If RND is referring to System.Random, then remember it's not exactly random, but it's based on time.

So doing this:

Console.WriteLine(new Random().Next(1000000));
Console.WriteLine(new Random().Next(1000000));
Console.WriteLine(new Random().Next(1000000));
Console.WriteLine(new Random().Next(1000000));
Console.WriteLine(new Random().Next(1000000));

Will return the same value all the times.

Where this will return 2 different values:

Console.WriteLine(new Random().Next(1000000));
Console.WriteLine(new Random().Next(1000000));
Console.WriteLine(new Random().Next(1000000));
System.Threading.Thread.Sleep(25);
Console.WriteLine(new Random().Next(1000000));
Console.WriteLine(new Random().Next(1000000));

[Spirited]

    [Serializable, ComVisible(true)]
    public class Random
    {
        // Fields
        private int inext;
        private int inextp;
        private const int MBIG = 0x7fffffff;
        private const int MSEED = 0x9a4ec86;
        private const int MZ = 0;
        private int[] SeedArray;

        // Methods
        public Random()
            : this(Environment.TickCount)
        {
        }

        public Random(int Seed)
        {
            this.SeedArray = new int[0x38];
            int num4 = (Seed == -2147483648) ? 0x7fffffff : Math.Abs(Seed);
            int num2 = 0x9a4ec86 - num4;
            this.SeedArray[0x37] = num2;
            int num3 = 1;
            for (int i = 1; i < 0x37; i++)
            {
                int index = (0x15 * i) % 0x37;
                this.SeedArray[index] = num3;
                num3 = num2 - num3;
                if (num3 < 0)
                {
                    num3 += 0x7fffffff;
                }
                num2 = this.SeedArray[index];
            }
            for (int j = 1; j < 5; j++)
            {
                for (int k = 1; k < 0x38; k++)
                {
                    this.SeedArray[k] -= this.SeedArray[1 + ((k + 30) % 0x37)];
                    if (this.SeedArray[k] < 0)
                    {
                        this.SeedArray[k] += 0x7fffffff;
                    }
                }
            }
            this.inext = 0;
            this.inextp = 0x15;
            Seed = 1;
        }

        private double GetSampleForLargeRange()
        {
            int num = this.InternalSample();
            if ((this.InternalSample() % 2) == 0)
            {
                num = -num;
            }
            double num2 = num;
            num2 += 2147483646.0;
            return (num2 / 4294967293);
        }

        private int InternalSample()
        {
            int inext = this.inext;
            int inextp = this.inextp;
            if (++inext >= 0x38)
            {
                inext = 1;
            }
            if (++inextp >= 0x38)
            {
                inextp = 1;
            }
            int num = this.SeedArray[inext] - this.SeedArray[inextp];
            if (num == 0x7fffffff)
            {
                num--;
            }
            if (num < 0)
            {
                num += 0x7fffffff;
            }
            this.SeedArray[inext] = num;
            this.inext = inext;
            this.inextp = inextp;
            return num;
        }

        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public virtual int Next()
        {
            return this.InternalSample();
        }

        public virtual int Next(int maxValue)
        {
            if (maxValue < 0)
            {
                throw new ArgumentOutOfRangeException("maxValue", Environment.GetResourceString("ArgumentOutOfRange_MustBePositive", new object[] { "maxValue" }));
            }
            return (int)(this.Sample() * maxValue);
        }

        public virtual int Next(int minValue, int maxValue)
        {
            if (minValue > maxValue)
            {
                throw new ArgumentOutOfRangeException("minValue", Environment.GetResourceString("Argument_MinMaxValue", new object[] { "minValue", "maxValue" }));
            }
            long num = maxValue - minValue;
            if (num <= 0x7fffffffL)
            {
                return (((int)(this.Sample() * num)) + minValue);
            }
            return (((int)((long)(this.GetSampleForLargeRange() * num))) + minValue);
        }

        public virtual void NextBytes(byte[] buffer)
        {
            if (buffer == null)
            {
                throw new ArgumentNullException("buffer");
            }
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = (byte)(this.InternalSample() % 0x100);
            }
        }

        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public virtual double NextDouble()
        {
            return this.Sample();
        }

        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        protected virtual double Sample()
        {
            return (this.InternalSample() * 4.6566128752457969E-10);
        }
    }

[-Shunsui-]

It works for me just fine, if i declare a static Random as new just once in like Program.cs when the server is starting up. Insted of declaring a new instance every time i'm going to use it. I knew about this problem because of impulse. and it works fine the way i did it.

[pro4never]

Originally Posted by -Shunsui-

It works for me just fine, if i declare a static Random as new just once in like Program.cs when the server is starting up. Insted of declaring a new instance every time i'm going to use it. I knew about this problem because of impulse. and it works fine the way i did it.

it is a static random. I only reset it if there are junk values being returned.

Originally Posted by BaussHacker

If RND is referring to System.Random, then remember it's not exactly random, but it's based on time.

So doing this:

Console.WriteLine(new Random().Next(1000000));
Console.WriteLine(new Random().Next(1000000));
Console.WriteLine(new Random().Next(1000000));
Console.WriteLine(new Random().Next(1000000));
Console.WriteLine(new Random().Next(1000000));

Will return the same value all the times.

Where this will return 2 different values:

Console.WriteLine(new Random().Next(1000000));
Console.WriteLine(new Random().Next(1000000));
Console.WriteLine(new Random().Next(1000000));
System.Threading.Thread.Sleep(25);
Console.WriteLine(new Random().Next(1000000));
Console.WriteLine(new Random().Next(1000000));

By default new Random() sets the seed based on environment tick count (aka computer time) so obviously it will be the same if you keep resetting it/creating new randoms.

If you use the SAME random object and continue calling .Next() from it, it will modify the random seed and give varying values.

[Mr_PoP]

public class CRandom {
		private int seed = 0;

		public CRandom(int seed) {
			this.seed = seed;
		}

		public short Next() {
			seed *= 0x343fd;
			seed += 0x269EC3;
			return (short)((seed >> 0x10) & 0x7FFF);
		}
	}

that's the basic idea , so everytime u call next it will give u a new random number

[CptSky]

I have the same problem, but I should be able to fix it. After looking in the Microsoft documentation, I found a comment about this error...

There is a very nasty side effect that can happen when the same Random object is used by multiple threads: it just stops working (i.e. there is a race condition which when triggered, the return value from the 'random.Next....' methods will be 0 (for all subsequent calls))

There are some solutions at the bottom of the page.

PS. I know that it's a bump...

[pro4never]

Originally Posted by CptSky

I have the same problem, but I should be able to fix it. After looking in the Microsoft documentation, I found a comment about this error...





There are some solutions at the bottom of the page.

PS. I know that it's a bump...

Thank you SO much for the bump.

It's obviously being called from multiple threads as I started organizing all my randoms into a single static class (to AVOID and simplify the debugging of issues) Which I'm sure made it worse.

It most likely started as a much less pressing issue and as I noticed it I tried to centralize my randoms so that I could track the issue more easily.

Thanks a bunch. Maybe this will finally re-spark my pserver development as hellmouth has been stagnant since it really started ******* me off (Any time I added stuff and a decent amount of ppl on it would start happening and cause all sorts of havoc to the server)

[Korvacs]

Shoulda created a random based on the amount of solar radiation detected in our atmosphere, ive heard thats one of the best randoms available

[BaussHacker]

Originally Posted by Korvacs

Shoulda created a random based on the amount of solar radiation detected in our atmosphere, ive heard thats one of the best randoms available

If it just was that easy.

[.Kinshi]

Originally Posted by Korvacs

Shoulda created a random based on the amount of solar radiation detected in our atmosphere, ive heard thats one of the best randoms available

Haha! Actually made me lol irl

[Korvacs]

Originally Posted by .Kinshi

Haha! Actually made me lol irl

You laugh but its an actual method to generate seeds! Same with quantum wave decay, that can be used as a random number generator.

[.Kinshi]

Originally Posted by Korvacs

You laugh but its an actual method to generate seeds! Same with quantum wave decay, that can be used as a random number generator.

Oh yes, I just did not expect a response like that :P