private void SafetySystem()
    {
        //1. DEPENDENCIES
        //2. COMBINE DEPENDENCIES
        //2. READING FROM THE SAME ARRAY IS OK [Read/WriteOnly]
        //2. SAFETY OVERRIDE

        var powJobA = new PowJob
        {
            dataSize = dataSize,
            dataIn   = dataA,
            dataOut  = dataB
        };
        JobHandle jobHndlA = powJobA.Schedule();

        var powJobB = new PowJob
        {
            dataSize = dataSize,
            dataIn   = dataB,
            //dataIn = dataA, //also uncomment [READ/WRITE] attributes in the PowJob
            dataOut = dataC
        };
        JobHandle jobHndlB = powJobB.Schedule();

        //Dependecy
        //JobHandle jobHndlB = powJobB.Schedule(jobHndlA);

        JobHandle jobHndl = JobHandle.CombineDependencies(jobHndlA, jobHndlB);

        jobHndl.Complete();
    }
    private void ScheduleSequentialInForLoop()
    {
        JobHandle jobHandle = default(JobHandle);

        for (int i = 0; i < forLoopSchedulesCount; i++)
        {
            var powJob = new PowJob
            {
                dataSize = dataIns[i].Length,
                dataIn   = dataIns[i],
                dataOut  = dataOuts[i]
            };
            jobHandle = powJob.Schedule(jobHandle);
        }
        jobHandle.Complete();
    }
    private void JobsScheduling()
    {
        var powJob = new PowJob
        {
            dataSize = dataSize,
            dataIn   = dataA,
            dataOut  = dataB
        };

        //SINGLE THREADED
        // powJob.Run();

        JobHandle jobHndl = powJob.Schedule();

        jobHndl.Complete();
    }
    private void ScheduleParallelInForLoop()
    {
        JobHandle jobHandle = default(JobHandle);
        NativeArray <JobHandle> parallelJobHandles = new NativeArray <JobHandle>(forLoopSchedulesCount, Allocator.Temp);

        for (int i = 0; i < forLoopSchedulesCount; i++)
        {
            var powJob = new PowJob
            {
                dataSize = dataIns[i].Length,
                dataIn   = dataIns[i],
                dataOut  = dataOuts[i]
            };
            parallelJobHandles[i] = powJob.Schedule(jobHandle);
        }

        jobHandle = JobHandle.CombineDependencies(parallelJobHandles);
        parallelJobHandles.Dispose();

        jobHandle.Complete();
    }
    // Update is called once per frame
    void Update()
    {
        var powJob = new PowJob
        {
            dataSize = dataSize,
            dataIn   = dataA[READ],
            dataOut  = dataB[WRITE]
        };

        powJobHndl = powJob.Schedule();


        var addJob = new AddJob
        {
            dataSize = dataSize,
            dataIn   = dataB[READ],
            dataOut  = dataC[WRITE]
        };

        addJobHndl = addJob.Schedule();

        JobHandle.ScheduleBatchedJobs();
    }