Example #1
0
    public static int test_0_large_nullable_invoke()
    {
        var s = new LargeStruct()
        {
            a = 1, b = 2, c = 3, d = 4
        };

        GetHasValue <LargeStruct> (s);

#if __MOBILE__
        var m = typeof(AotTests).GetMethod("GetHasValue", BindingFlags.Static | BindingFlags.Public);
#else
        var m = typeof(Tests).GetMethod("GetHasValue", BindingFlags.Static | BindingFlags.Public);
#endif

        Type type = typeof(LargeStruct?).GetGenericArguments() [0];
        bool b1   = (bool)m.MakeGenericMethod(new Type[] { type }).Invoke(null, new object[] { s });
        if (!b1)
        {
            return(1);
        }
        bool b2 = (bool)m.MakeGenericMethod(new Type[] { type }).Invoke(null, new object[] { null });
        if (b2)
        {
            return(2);
        }
        return(0);
    }
Example #2
0
        public void ConcurrentMutableStructTest()
        {
            LargeStruct mutable = new LargeStruct();

            ThreadPool.QueueUserWorkItem(delegate
            {
                decimal n = 0;
                while (true)
                {
                    var newStruct = new LargeStruct
                    {
                        D1 = n,
                        D2 = n,
                        D3 = n,
                        D4 = n,
                        D5 = n,
                    };
                    mutable = newStruct;
                    n++;
                }
            });

            Assert.Throws <AssertionException>(() =>
            {
                while (true)
                {
                    Validate(mutable);
                }
            });
        }
Example #3
0
        public void Execute(int i)
        {
            LargeStruct ls = new LargeStruct();

            ls.h1           = 1;
            largeStructs[i] = ls;
        }
 public void Setup()
 {
     _serializer = new Serializer();
     _stream     = new MemoryStream();
     _testStruct = LargeStruct.Create();
     _testPerson = TypicalPersonData.MakeRandom();
 }
Example #5
0
    public static int test_0_arm64_dyncall_vtypebyrefonstack()
    {
        var s = new LargeStruct()
        {
            a = 1, b = 2, c = 3, d = 4
        };

        NullableMethods.GetHasValueManyArgs <LargeStruct> (1, 2, 3, 4, 5, 6, 7, 8, s);

        Type type = typeof(LargeStruct?).GetGenericArguments() [0];
        var  m    = typeof(NullableMethods).GetMethod("GetHasValueManyArgs", BindingFlags.Static | BindingFlags.Public);
        bool b1   = (bool)m.MakeGenericMethod(new Type[] { type }).Invoke(null, new object[] { 1, 2, 3, 4, 5, 6, 7, 8, s });

        if (!b1)
        {
            return(1);
        }
        bool b2 = (bool)m.MakeGenericMethod(new Type[] { type }).Invoke(null, new object[] { 1, 2, 3, 4, 5, 6, 7, 8, null });

        if (b2)
        {
            return(2);
        }
        return(0);
    }
Example #6
0
            public unsafe static void Test1(int n)
            {
                Console.WriteLine("Enter Test1");
                LargeStruct s = new LargeStruct();

                s.i1 = 7;
                s.i2 = 9;
                BigArgSpace(s);

                // Localloc some space; this moves the outgoing argument space.

                if (n < 1)
                {
                    n = 1;
                }
                int *a = stackalloc int[n * 4096];

                a[0] = 7;
                int i;

                for (i = 1; i < 5; ++i)
                {
                    a[i] = i + a[i - 1];
                }

                // Now call a function that touches the potentially un-probed
                // outgoing argument space.

                SmallArgSpace(1, 2, 3, 4, 5, 6, 7, 8, 9, a[4]);

                iret = 100;
            }
Example #7
0
            public static void BigArgSpace(LargeStruct s)
            {
                long result = s.i1 + s.i2;

                Console.Write("BigArgSpace: ");
                Console.WriteLine(result);
            }
Example #8
0
 public bool Equals(LargeStruct other)
 => X == other.X &&
 Y == other.Y &&
 Z == other.Z &&
 C == other.C &&
 A == other.A &&
 B == other.B &&
 F == other.F;
 public void Cleanup()
 {
     _stream.Dispose();
     _stream     = null;
     _serializer = null;
     _testStruct = default(LargeStruct);
     _testPerson = null;
 }
Example #10
0
    static bool CheckBigStruct()
    {
        var v = new LargeStruct[4, 4, 4];
        var e = new LargeStruct(33f);

        v[1, 2, 3] = e;
        return(UseArrayElementAsCallArgument(v, e));
    }
Example #11
0
        private static void Validate(LargeStruct largeStruct)
        {
            decimal n = largeStruct.D1;

            Assert.IsTrue(n == largeStruct.D2);
            Assert.IsTrue(n == largeStruct.D3);
            Assert.IsTrue(n == largeStruct.D4);
            Assert.IsTrue(n == largeStruct.D5);
        }
Example #12
0
        public override bool Equals(object obj)
        {
            if (!(obj is LargeStruct))
            {
                return(false);
            }
            LargeStruct s2 = (LargeStruct)obj;

            return((f1 == s2.f1) && (f2 == s2.f2) && (f3 == s2.f3) && (f4 == s2.f4) && (f5 == s2.f5));
        }
Example #13
0
        public void Execute(int i)
        {
            LargeStruct ls = largeStructs[i];

            ls.h1           = 1;
            ls.h2           = 1;
            ls.h3           = 1;
            ls.h4           = 1;
            largeStructs[i] = ls;
        }
Example #14
0
        public void ForcePassByValueParameter()
        {
            var value = new LargeStruct();

            value.I[0] = 10;
            value.I[1] = 20;
            value.I[2] = 30;

            Assert.Equal(60, NativeFunctions.SumValues(value));
        }
Example #15
0
            internal void Read(out LargeStruct result)
            {
                var lockTaken = false;

                spinLock.Enter(ref lockTaken);
                result = value;
                if (lockTaken)
                {
                    spinLock.Exit(false);
                }
            }
        public override void Setup(BenchmarkContext context)
        {
            base.Setup(context);
            _testStruct = LargeStruct.Create();
            _testObject = TypicalPersonData.MakeRandom();

            var a = new CyclicA();
            var b = new CyclicB();

            a.B = b;
            b.A = a;

            _cyclic = a;
        }
 int Get(ref LargeStruct @class)
 {
     return @class.Val;
 }
Example #18
0
 public static void Escape(ref LargeStruct s)
 {
 }
 public void GlobalSetup()
 {
     _data = new byte[1000];
     new Random().NextBytes(_data);
     _control = new LargeStruct(_data[0], _data[1], _data[2], _data[3], _data[4], _data[5]);
 }
 public override void Setup(BenchmarkContext context)
 {
     base.Setup(context);
     InitStreamWith(LargeStruct.Create());
 }
Example #21
0
 public void Execute(int i)
 {
     largeStructs[i] = new LargeStruct();
 }
 internal void Read(out LargeStruct result) => result = value;
 int GetForceInlining(ref LargeStruct @class)
 {
     return @class.Val;
 }