Question

I am designing a project management app for a factory. The app is expected to produce draft project plans. To schedule a task, the app should check three conditions:

1. task dependency – do not start before,
2. machine availability, and
3. shift work hours

I keep track of machine engagement in machine_allocations table:

machine_allocations
+------------+--------------+-----------------+---------------+
| machine_id | operation_id | start_timestamp | end_timestamp |
+------------+--------------+-----------------+---------------+

Shift hours follow a pattern.

Now, to find the earliest possible date-time for an operation I am thinking of a function:

function earliest_slot($machine_id, $for_duration, $no_sooner_than) {
   // pseudo code
   1. get records for the machine in question for after $no_sooner_than 
   2. put start and end timestamps into $unavailable array
   3. add non-working times as new elements to the array
   4. in a loop find timeslots which are not in the array
   5. if a timeslot is found which is equal to or bigger than $for_duration, return that
}

My question is, is this a good approach? Are there simpler ways to do this?

Answer 1

Finding the earliest date-time for one operation at a time may not give you the best result. Consider the example where operation A uses machine 1 for a long time, operation B uses machine 1 for a short time and operation C uses machine 2 for a short time, but operation C must be done after B.

In this case, it is better to schedule B before A on machine 1, but your approach would not achieve this. Of course, writing and using software to manage this would be more difficult than what you have suggested, so you need to decide whether the benefit is worth the extra effort.

Have a look at Scheduling, Job Shop Scheduling and Scheduling algorithm.

First you need to think about what sort of information you can collect about tasks (such as dependencies, priorities, deadlines) and then decide how best to put it together.

You may find that an approach like you propose is good enough in your case. My addition to your proposed algorithm would be to sort the list of existing machine operations to make searching through them faster, that is you can stop as soon as you find a time where your operation fits because it’s guaranteed to be the earliest time.

A relatively simple extension would be a priority system that allows you to bump lower-priority tasks forward (which may require the adjustment of their dependencies as well), but more complicated algorithms would consider multiple tasks at once and try to optimise the outcome. In the end it comes down to what’s appropriate for your specific problem.