public static void Example2(GPGPU gpu)
        {
            ArrayView view1 = new ArrayView();
            ArrayView view2 = new ArrayView();

            float[] data = Enumerable.Range(0, 1000).Select(t => (float)t).ToArray();
            // Two views of the array, simply applying an offset to the array; could slice instead for example.
            view1.CreateView(data, 100);
            view2.CreateView(data, 200);

            for (int i = 0; i < 1000; ++i)
            {
                data[i] = data[i] * 10f;
            }
            // Should copy the 'large' array to the device only once; this is referenced by each ArrayView instance.
            var dev_view1 = DeviceClassHelper.CreateDeviceObject(gpu, view1);
            var dev_view2 = DeviceClassHelper.CreateDeviceObject(gpu, view2);

            var dev_result = gpu.Allocate <float>(5);
            var hostResult = new float[5];

            gpu.Launch(1, 1).Test2(dev_view1, dev_view2, dev_result);
            gpu.CopyFromDevice(dev_result, hostResult);

            bool pass = (hostResult[0] == 1050f && hostResult[1] == 7f);

            Console.WriteLine(pass ? "Pass" : "Fail");
        }
Example #2
0
        public DataResult GetDeviceClass([FromQuery] int qId, int wId, bool menu)
        {
            var result = new DataResult();

            result.datas.AddRange(menu
                ? DeviceClassHelper.GetMenu(wId, qId)
                : DeviceClassHelper.GetDetail(qId, wId));
            if (qId != 0 && !result.datas.Any())
            {
                result.errno = Error.DeviceClassNotExist;
                return(result);
            }
            return(result);
        }
Example #3
0
        public Result PutDeviceClass([FromBody] IEnumerable <DeviceClass> details)
        {
            if (details == null || !details.Any())
            {
                return(Result.GenError <Result>(Error.ParamError));
            }
            if (details.Any(x => x.Name.IsNullOrEmpty()))
            {
                return(Result.GenError <Result>(Error.DeviceClassNotEmpty));
            }
            if (details.GroupBy(x => x.Name).Any(y => y.Count() > 1))
            {
                return(Result.GenError <Result>(Error.DeviceClassDuplicate));
            }

            var wId   = details.FirstOrDefault()?.WorkshopId ?? 0;
            var sames = details.Select(x => x.Name);
            var ids   = details.Select(x => x.Id);

            if (DeviceClassHelper.GetHaveSame(wId, sames, ids))
            {
                return(Result.GenError <Result>(Error.DeviceClassIsExist));
            }

            var cnt = DeviceClassHelper.Instance.GetCountByIds(ids);

            if (cnt != details.Count())
            {
                return(Result.GenError <Result>(Error.DeviceClassNotExist));
            }

            var markedDateTime = DateTime.Now;

            foreach (var process in details)
            {
                process.MarkedDateTime = markedDateTime;
                process.Remark         = process.Remark ?? "";
            }

            DeviceClassHelper.Instance.Update(details);
            return(Result.GenError <Result>(Error.Success));
        }
        public static void Example1(GPGPU gpu)
        {
            // Create instance and copy this to the GPU.
            // Includes a base class and another class as a member.
            DerivedClass[] array    = new DerivedClass[2];
            DerivedClass   instance = new DerivedClass();

            instance.PopulateMembers();
            instance.MemberClassInstance                  = new MemberClass();
            instance.MemberClassInstance.Field            = 5;
            instance.MemberClassInstance.MemberClassArray = new float[] { 3, 4, 5 };
            DerivedClass instance2 = new DerivedClass();

            instance2.PopulateMembers();
            instance2.MemberClassInstance                  = new MemberClass();
            instance2.MemberClassInstance.Field            = 6;
            instance2.MemberClassInstance.MemberClassArray = new float[] { 6, 7, 8 };
            array[0] = instance;
            array[1] = instance2;
            DeviceClassHelper.CreateDeviceObject(gpu, array);
            // could also use
            // var dev_array = DeviceClassHelper.CreateDeviceObject(gpu, array);
            // Note that this also copies reference type members to the GPU.

            // Create a result array and copy to the GPU:
            float[] result     = new float[5];
            var     dev_result = DeviceClassHelper.CreateDeviceObject(gpu, result);

            var dev_array = DeviceClassHelper.TryGetDeviceObjectFromHostObject(gpu, array);

            gpu.Launch(1, 1).Test(dev_array, dev_result);

            DeviceClassHelper.UpdateFromDevice(gpu, result);

            bool pass = (result[0] == 18.9f && result[1] == 8.8f && result[2] == 10f && result[3] == 36f);

            Console.WriteLine(pass ? "Pass" : "Fail");
        }
Example #5
0
        public Result PostDeviceClass([FromBody] IEnumerable <DeviceClass> details)
        {
            if (details == null || !details.Any())
            {
                return(Result.GenError <Result>(Error.ParamError));
            }
            if (details.Any(x => x.Name.IsNullOrEmpty()))
            {
                return(Result.GenError <Result>(Error.DeviceClassNotEmpty));
            }
            if (details.GroupBy(x => x.Name).Any(y => y.Count() > 1))
            {
                return(Result.GenError <Result>(Error.DeviceClassDuplicate));
            }

            var wId   = details.FirstOrDefault()?.WorkshopId ?? 0;
            var sames = details.Select(x => x.Name);

            if (DeviceClassHelper.GetHaveSame(wId, sames))
            {
                return(Result.GenError <Result>(Error.DeviceClassIsExist));
            }

            var userId         = Request.GetIdentityInformation();
            var markedDateTime = DateTime.Now;

            foreach (var process in details)
            {
                process.CreateUserId   = userId;
                process.MarkedDateTime = markedDateTime;
                process.Remark         = process.Remark ?? "";
            }

            DeviceClassHelper.Instance.Add(details);
            return(Result.GenError <Result>(Error.Success));
        }