In the presence of Deadlines, Constraints, variable Calendars, and resource leveling, Total Slack becomes unreliable as an indicator of the Critical Path (or of nearness to the Critical Path). In addition, many projects include Key Completion Milestones that occur long before the final scheduled activity of the project, so a Longest-Path approach doesn’t apply. For these projects, I use the Task Logic Tracer to find the Driving Path and Near-Driving Paths of each Key Completion Milestone.
In the presence of Deadlines, Constraints, variable Calendars, and resource leveling, Total Slack becomes unreliable as an indicator of the Critical Path (or of nearness to the Critical Path). For projects where the project completion is designated by the last task in the schedule, I use the Near Longest Path Filter to keep an eye on next week’s concerns….
See also a related blog entry: Tracing Near Longest Paths with BPC Logic Filter
In the presence of Deadlines, Constraints, variable Calendars, and resource leveling, Total Slack becomes unreliable as an indicator of the Critical Path. For projects where the project completion is designated by the last task in the schedule, I use the Longest Path Filter to identify the Critical Path….
For more information and some background, have a look at this entry: What is the Longest Path in a Project Schedule
This article uses BPC Logic Filter to present the progression of a single logic tracing example from a simple approach to a more focused analysis. [June 2020: revised for updated versions of MS Project and BPC Logic Filter.]
[If you came here looking for a simple logic tracing macro and are comfortable using Visual Basic for Applications (VBA), have a look at these two other entries: Macro for tracing filtering and sorting task paths in Microsoft Project and Simple Macro for Listing Driving Predecessor(s) in MS Project. They may give you what you want as long as your project has simple logic.]
BPC Logic Filter is an excellent tool for defining and visualizing the Critical Path and Near-Critical Paths of a project when Total Slack proves inadequate – namely in the presence of constraints, variable calendars, and resource leveling. As I’ve written elsewhere, however, the first version of BPC Logic Filter was prompted by a very different, though straightforward stakeholder request: “My people can’t see why they need to finish these tasks so soon. Isn’t there a report or something to show what other tasks (in other departments) are depending on them?” In other words, couldn’t I group, filter, and sort tasks simply according to logical relationships – in addition to Work Breakdown Structure, responsible department, and other codes. At its core, the resulting solution was a simple logic tracing routine for exploring, marking, and displaying logical relationships in an existing project schedule.
This article presents the progression of a single logic tracing example from a simple approach to a more focused analysis.
Consider the example of the small installation project presented below. There is a deadline on the “Substantial Completion” milestone, and the project is 10-days behind schedule. For unrelated reasons, the project manager has identified a need to examine the predecessor and successor logic paths around one task – “A3 Install Line D” – which is selected in the figure.
We can first examine the task’s dependencies using MSP’s Task Detail Form and the Task Inspector pane. The form shows that the task has two finish-to-start predecessors and two finish-to-start successors, but it provides no other schedule information for these dependencies. Task Inspector identifies the second predecessor — ID 22 – A3 Install Line C — as the driving predecessor. That is the predecessor whose logic is controlling the start date for our task.
This driving predecessor is hyperlinked, so clicking on it automatically selects the corresponding task in the task table and updates the details. In addition, a new “Go back to” task link is added to the Inspector pane. Starting from a specific ending task, the user can use these tools to “click-trace” backwards and forwards along the driving predecessor logic path to the selected task.
Click-tracing of driven successor paths is not possible using the Inspector pane, and predecessors that are hidden by filtering or outlining can’t be traced. Moreover, neither external links nor resource-driving links can be traced. Finally, the driving predecessors can be incorrect when relationships other than finish-to-start are used.
BPC Logic Filter – Task Logic Inspector
The Logic Inspector in BPC Logic Filter presents consolidated views of a task’s driving and non-driving predecessors and successors, including other relevant information like dates, resources, or user-selected fields. Driving relationships are highlighted and listed at the top, while links to inactive predecessors are de-emphasized and listed at the bottom. For logical significance, the ERF column indicates how far (in days) the predecessor is from controlling/driving the successor’s early dates, and the LRF column indicates how far the successor is from controlling/driving the predecessor’s late dates. The latter is most useful when click-tracing to explore successor logic paths. (The yellow-on-red color scheme in the figure highlights relationships that are driving in both directions.)
With the Jump buttons in the Logic Inspector windows, users can click-trace logic paths forward and backward through the project schedule. Unlike the built-in tools, the Logic Inspector windows allow inspection and click-tracing of both driving and non-driving logic along successor paths, external (i.e. master/sub-project) paths, resource-constrained logic paths, and hierarchical logic paths.
Task Paths and Task Path Filters
Recent versions of MS Project (2013+) include Task Path bar styles for graphically highlighting predecessor and successor paths on the Gantt chart. In addition, it is possible to use a simple “QuickTrace” macro (like the one linked above or one of the freeware settings in BPC Logic Filter), to identify the same set of related tasks. In the next figure, the Path Predecessors bar style has been applied to color the bars of all tasks that are path predecessors of the selected one. The QuickTrace macro (included in BPC Logic Filter) has also been used to highlight the same related tasks.
Alternately, QuickTrace can display the related tasks using a filter rather than a highlighter, as shown below. In either case, the actual driving logic for the selected task is not apparent. (And no, Total Slack does not define driving logic for this task.)
The next figure displays both the Path Predecessors (orange) and the Path Driving Predecessors (red-orange) bar styles for the selected task, and QuickTrace has been used to highlight the driving predecessors in the table. A corresponding filter could also be applied.
Although generally less useful for analysis, corresponding bar styles and filters can be applied for the path successors and path driven successors of the selected task.
BPC Logic Filter – Advanced Tracing
With advanced logic analysis features, the relative float of all the predecessor task paths can be defined and displayed. The following chart shows the entire project, with the predecessor paths of the selected task highlighted according to their path relative float in days. (Path relative float indicates how much a particular task or path may be delayed before affecting the selected task; i.e. “days away from driving”.) Path relative float is indicated numerically at the right side of each related bar. Unrelated bars are de-emphasized and colored green. The bar chart shown is similar to that obtained using the Task Path bar styles, with the key exception that non-driving predecessor paths can be ranked.
BPC Logic Filter allows one variation – bounded network analysis – to only show connections to a particular target task. The figure below highlights the connections between the selected task, A3 Install Line D, and the target task, A2 Civil.
The previous two figures displayed the related task paths in-line and within the context of the overall project view. A more focused view of the driving and near-driving paths is provided by applying a filter to hide all unrelated tasks, as shown here.
It is often useful to group and sort tasks to clearly display the chain of driving logic and associated near-driving paths. The first group in the figure below – “BPC Relative Float (d): 0” – indicates the driving logical path for the selected activity. The next two groups depict branching logical paths (one task each) that are 10- and 20-days away from driving the selected task.
Finally, when attempting to accelerate a task by shortening its driving logical path, Drag quantifies the maximum acceleration that may be gained by shortening a particular task along that path. Drag is limited by the existence of parallel paths, as clearly evidenced by Tasks 6 and 11 in the figure below. For focused acceleration of complex projects, the Drag metric can assist in prioritizing actions.
The examples shown here represent successively more powerful analyses of driving logic for an arbitrary task in a project schedule. If that task were the final task or a key completion milestone for the project, then the resulting special case of the driving path would be the “Critical Path” for the project.
See a related video entry:
[I’ve slightly edited this old article – mostly figures. After “upgrading” to Microsoft Project 2016, I can confirm that MSP 2016’s resource leveler appears similar to MSP 2013’s leveler in the simple case examined; both are substantially different from MSP 2010’s.]
Over the last few years, some tests of resource leveling algorithms in various software packages have been reported informally over at Planning Planet.
- Planning Planet: Test report on comparison of resource leveling engine of Microsoft Project, Primavera, Asta Powerproject, and Spider Project
- Planning Planet: Comparison of resource levelling algorithms of different Project Management tools
When using “default” conditions (i.e. without implementing any user-defined priority schemes), the general picture was that leveled schedules from MSP 2010 were significantly longer than those from MSP 2007. There have also been reports that MSP 2013 (and MSP 2016, which seems to use the same leveling rules) produces even longer leveled schedules than MSP 2010. Other software (Spider Project in particular) tend to produce shorter schedules under resource constraints. I haven’t paid too much attention to these reports because a) I don’t use resource leveling often, and b) when I do use leveling, I always define some specific leveling priorities, so the “default” results are not so relevant.
Last week, a French planner (“Alexandre”) on PP noted some significant changes in default leveling results when migrating a simple schedule from MSP 2010 to MSP 2013, wondering what might be the reason for the changes. I’m still on 2010, so I haven’t noticed the change in 2013. While it’s clear that Microsoft has modified the leveling rules from version to version, they don’t publish the details, so addressing the “reason for the change” is just speculation. My own speculation is that minor changes to the leveling algorithm were made to limit apparent changes to the pre-leveling “Critical Path,” even at the expense of extending the schedule. For Alexandre’s specific example:
- The project has a total duration of 7.5 days, and the pre-leveling (i.e. CPM) critical path runs through task 5. Task 5 has 0 days of total slack, while task 8 has 2 days of slack.
- In resolving the resource conflict between task 5 and task 8, MSP 2010’s default rule gives greater scheduling priority to task 5 because:
- The CPM schedule has it starting earlier;
- It has lower total slack in the CPM schedule;
- It has a longer duration;
- It comes first on the task list;
- It is marked as “Critical” (?);
- Some other factors…(?).
(I have no idea what the relative contributions of these factors are in the scoring. Some might be zero.)
- As a consequence of leveling, task 5 (the “critical” one) is scheduled first, while task 8 is delayed, and the project is extended 1 day for a total duration of 8.5 days. Total slack is re-computed after incorporating the leveling delays, and a new “Critical Path” is displayed.
- Perversely, Task 5 – which was clearly “critical” before leveling and is also clearly a resource driver for the project completion – now has 1 day of Total Slack.
- Task 7 is now shown as “Critical,” even though there is neither a logical nor a resource-driving reason justifying it.
- So in short, the MSP 2010 leveling algorithm can substantially change the “Critical Path,” and the resulting slack values can be completely misleading. (I wrote about this here: Logic Analysis of Resource-Leveled Schedules (MS Project).)
- The next figures (from BPC Logic Filter) illustrate the actual resource-constrained Longest Path (Fig. 2) and Multiple Float Paths (2a) through the 2010 schedule.
- As a consequence of leveling, task 5 (the “critical” one) is scheduled first, while task 8 is delayed, and the project is extended 1 day for a total duration of 8.5 days. Total slack is re-computed after incorporating the leveling delays, and a new “Critical Path” is displayed.
- In contrast, MSP 2013 task gives greater scheduling priority to task 8, delaying task 5. I suspect this is driven by some complex tuning of the leveling rules around Total Slack.
- Alexandre provided the MSP 2013 leveled schedule here (which also includes a minor date shift).
- I’ve repeated it below in my [MSP 2016 model using Standard leveling order.] The resulting “Critical Path” appears essentially the same as the pre-leveling version, but with an added 3-day leveling delay before task 5. This may give project managers confidence that the leveling exercise has not “screwed up” their critical path.
Unfortunately, the project finish has been extended by an additional 2 days compared to the MSP 2010 leveler. It is now 10.5 days.
- The project manager’s confidence in the critical path is still misplaced. Task 7 and task 8 are now shown as far from critical, with 5 days of total slack. As shown in the next two figures from BPC Logic Filter, however, they are obviously on the resource-constrained longest path through the schedule.
Comparing the 0-Float Paths of the two schedules (Figures 2a and 5a), we see that unlike MSP 2010, MSP 2013 and MSP 2016’s leveling engine has preserved the logic drivers from the pre-leveling CPM schedule while implicitly inserting task 7 and task 8 into the driving path to project completion. Although the project is extended as a result, the appearance of a stable critical path is preserved. Fortunately, BPC Logic Filter depicts the resulting resource-constrained critical path clearly in both cases.
My speculation on the reason for the changed algorithm is based on the Project development team’s demonstrated preference for the appearance of stability (for mid-level users) over behavior that might be more technically correct from an advanced user’s point of view. (See the handling of inactive tasks in MSP 2013 for another example.)
For an update on this topic, see Resource Leveling Changes from MSP 2010 to MSP 2016 – Revisited
BPC Logic Filter for Microsoft Project provides an automated method for extracting and presenting the Resource Critical Path (a.k.a Resource-Constrained Critical Path or Critical Chain) from a leveled schedule.
In a previous entry (Logic Analysis of Resource-Leveled Schedules), I investigated the impact of resource leveling on the logical analysis of Microsoft Project schedules. Conclusions were not encouraging, i.e.:
- Project’s Total Slack calculation – and as a consequence, the “Critical” flag – fails to adequately account for resource constraints in the schedule. Neither the “Resource Critical Path” nor any other resource-leveled logical path can be deduced from the schedule by analyzing the logical relationships and slack (nor even the “Leveling Delay” artifacts). Even worse, tasks that are clearly schedule critical when considering resource constraints can have unexpectedly high values for Total Slack and may therefore be neglected during crashing exercises or disruption analysis.
- BPC Logic Filter – our preferred tool for logical analysis of Microsoft Project schedules – could not completely overcome the weaknesses of MSP when it came to resource leveling.
- To be amenable for logical analysis, it seemed that schedules needed to be constructed with “soft” logic links to mimic the impacts of the resource leveling algorithm.
As the developer and primary user of BPC Logic Filter, I was not satisfied with these latter conclusions. After all, I had developed the tool specifically to overcome MSP’s shortcomings in the context of multiple deadlines/constraints and variable calendars. Why should it stop there?
While I have intended to address resource constraints in BPC Logic Filter since the beginning, I didn’t have much need for it until recently. Now the latest code revision incorporates full analysis and comparison of resource assignments in parallel with the existing logic analysis algorithm. I’m pleased with the results and feel confident that BPC Logic Filter can now depict the Resource Critical Path (or any resource-constrained driving path) in a Microsoft Project Schedule.
Figure 8 of the earlier article showed the resource-leveled schedule of a simple construction project, while Figure 9 showed BPC Logic Filter’s multiple-float-path analysis of the schedule. The latter figure demonstrated how resource leveling introduced gaps into the logical arrangement of the schedule, but it did not track the resource constraints behind those gaps. Figure 11 of the earlier article demonstrated the analysis after replacing the resource-leveling delays with soft (“preferential”) logic links to create exactly the same (early) schedule dates. I’ve included these figures below.
Now I’ve added a figure (let’s call it Figure 12) showing the “new and improved” analysis from BPC Logic Filter. The top band of the figure illustrates the Resource Constrained Critical Path for the project as originally scheduled and leveled (i.e. without preferential logic). The dates remain unchanged. The relative float values for all tasks are identical to those of the revised (preferential-logic) schedule, but the total slack, critical flag, and bar colors are as originally scheduled and leveled. The next figure (13) shows a revised version of the bar chart with custom bar colors applied to clarify the logic- and resource-driven paths. This is comparable to MSP’s “Task Path” graphical display (though of course that tool is limited to logical paths, does not differentiate among relative float paths, and has no filter.)
Figure 13 – BPC Logic Filter Bar Colors
To summarize, BPC Logic Filter now includes full analysis of driving resource constraints for leveled schedules.
I’ve tested the upgraded functionality against some of the more sophisticated leveling scenarios, like split-assignments, split-tasks, and in-progress tasks with splits. I’ve also stress-tested the algorithms against some public-domain resource-constrained schedule datasets – namely PSPLIB files j1201_7 and j12060_10, both leveled by MSP with default parameters. For the latter project, BPC Logic Filter required nearly two minutes to chug through the numerous parallel resource-driving paths. (The project includes large pools of homogeneous resources distributed among many small tasks, which I hope is not typical.)
For now, the resource-analysis features do not work across multiple projects (i.e. linked master/sub-project structures.)
Finally, the banner/featured image at the top of this article is an updated version of the project schedule, with a couple arrows added to depict the inherent logic of the resource leveling delays. It would be great for the program to insert these arrows automatically, but I’m afraid the necessary effort isn’t justified at this time. Maybe I’ll revisit in the future.
[See a related video entry here: Video-Using BPC Logic Filter to Analyze Resource Leveled Critical Path]
[31Mar’16: The latest release of BPC Logic Filter now includes resource leveling constraints in the logical path analysis. I’ve written another article to summarize and amend this one: The Resource Critical Path – Logic Analysis of Resource-Leveled Schedules (MS Project), Part 2 .]
Effective management of resources – i.e. planning, procuring, mobilizing, and deploying – is a core competency for successful companies in project-focused industries like construction. Most scheduling tools based on the Critical Path Method (CPM) – like Microsoft Project – can generate project schedules without resources, but they also include methods for assigning, analyzing, and “leveling” project resources. In this context, “leveling” means selectively delaying some work (compared to the CPM-based schedule) pending the completion of other, more urgent works that demand the same resources.
This simple description might imply that a certain logical/sequential relationship is imposed between two competing tasks (i.e. the “less urgent” work can only start after the “more urgent” work is finished with the resources) – sometimes called “soft logic”. Unfortunately, the leveling engine in Project 2010 does not appear to use, much less preserve, any such soft logic. Consequently, logical analysis of the leveled schedule – including interpretation of Total Slack to determine critical path or driving logical path – appears invalid.
Figure 1 is a simplified CPM model of a construction project involving multiple trades working in multiple areas. The model includes realistic resource loading, but the logical links have been limited to “hard logic” only (i.e. physical constraints). In other words, there is no preferential logic to guide the resource deployments. The default 5dx8h weekly calendar is universally applied, and a deadline of 25Feb’04 has been imposed. The unleveled CPM schedule includes a forecast completion that is nearly 3 months ahead of the deadline, but resources are severely over-allocated – the schedule appears unrealistic and needs to be leveled.
- Three civil works tasks are running concurrently, but there is only sufficient manpower to run them sequentially. (Figure 2.)
- Three structural tasks are also running concurrently, and these require both manpower (Figure 3) and a crane (Figure 4), which is the limiting resource. They must be done sequentially.
- There is room to install the five separate processing lines concurrently in Area 3, but there is only enough skilled manpower to install them one at a time. (Figure 5).
- An electrical change order has been approved in Area 2, but this requires the same specialized crew that is already working there. The Change-order work must be delayed (Figure 6).
It is a simple matter to remove the over-allocations by manually executing Project’s leveling engine using near-default conditions (Figure 7).
The leveling engine resolves the over-allocations by selectively delaying those tasks (and task resource assignments, if specified) which are judged to be lower-priority according to Project’s proprietary rules. Figure 8 illustrates the results of the leveling exercise:
- The primary artifact of the leveling process is the “leveling delay” task property, which is in units of elapsed-duration (i.e. “edays”). The leveling delay is incorporated into the forward-pass schedule calculation, pushing the early start dates of the affected tasks. (Separate leveling delays can also be applied to resource assignments, which can extend task durations. This has not been done here and is generally not recommended when assigned resources are expected to work concurrently – e.g. Crane and structural erection crew.) Leveling delay is also incorporated into the backward pass, removing “phantom slack” from logically-connected tasks.
- Through the task leveling delay, the civil, structural, mechanical, and electrical tasks have been re-scheduled sequentially.
- Substantial Completion has been delayed until two weeks after the deadline, resulting in 10 days of negative slack on the milestone and its logical driving predecessors.
- There is not an obvious (-10d) total-slack path from beginning to end of the project.
Figure 9 illustrates the use of BPC Logic Filter to determine the driving path logic of the Substantial Completion task after leveling. The driving path is comprised of four tasks and two milestones separated by gaps, and the intervals of the gaps are determined by the “leveling delay.” Unfortunately, this does not describe a “resource constrained critical path.” In fact, the obviously critical tasks without leveling delay – including the first (i.e. “A1”) Civil and Structural works and the A2 Electrical works – now have high values of total slack and are shown far from the critical path. Consequently, it is clear that logical path analysis – including any evaluation of Total Slack – is not consistent with the rule-based resource leveling algorithm used by Microsoft Project.
Figure 10 illustrates the un-leveled schedule, revised to include obvious preferential logic for avoiding resource conflicts. The resulting task sequences and schedule dates are identical to those of the leveled schedule seen earlier, but the associated total slack values and “critical” flags are substantially different. As shown in Figure 11, however, the logic paths are clear and consistent with the real resource constraints of the project. The “BPC Relative Float (d): 0” group appears to represent the true resource constrained critical path for the project.
To recap, Microsoft Project’s proprietary resource leveling engine offers a convenient tool for resolving resource conflicts in project schedules, and this functionality seems heavily used and highly valued in some industries. It does not appear appropriate, however, for use in complex projects where formal logical sequencing of tasks – including identification of Critical Path or Critical Chain – is required. In particular, Project’s “Critical” flag will fail to accurately mark the critical path in a resource-leveled schedule. Consequently, a project specification that requires both a logic-driven schedule basis and heuristic resource leveling appears contradictory.
[Click here to proceed to the follow-up article: The Resource-Constrained Critical Path – Logic Analysis of Resource-Leveled Schedules (MS Project), Part 2 .]
This entry is intended to review the use of the Multiple Float-Path calculation option in Primavera Project Management (P6) and to offer a brief example of its use compared to BPC Logic Filter (for Microsoft Project).
Project schedules generated using the Critical Path Method (CPM) are commonly used to model – and to document – the project team’s plan for executing the scope of work. Such a plan normally involves identifying necessary activities at an appropriate level of detail and specifying the necessary sequential relationships between them. The output from the CPM analysis is a list of activities with associated durations, dates, and float values – this constitutes “the schedule”.
Unfortunately, the sequential relationships that ultimately drive the schedule (i.e. the logical “plan”) can be difficult to communicate or analyze for all but the simplest projects. This is because Total Float – the telltale indicator of logical-path connectivity in simple projects – becomes unreliable (or unintelligible) for such purposes in the presence of variable activity calendars or late constraints. As a result, complex schedule models lose both usefulness and credibility among project stakeholders unless schedule managers go beyond the simple communication of dates, durations, and float.
Multiple Float Paths
Oracle’s Primavera P6 software (P6) has always included an option to compute “Multiple Float Paths” when calculating the schedule, but many experienced planners seem unfamiliar with it. The option facilitates the identification of the “driving” and “near-driving” logical paths for a single selected activity. The selected activity can be a key project milestone that may or may not correspond to the end of the project, or it may be a simple intermediate activity of particular or urgent concern.
Figure 1 represents a simple project for construction and handover of a small utility installation – originally modeled in Microsoft Project and then converted to Primavera P6. (The model was developed primarily for illustrating the impact of calendars and constraints; the work techniques illustrated are neither typical nor ideal.)
- There are contractually-derived late-finish constraints on the Construction Project Complete milestone (24Apr’15) and the final Project Acceptance milestone (29Apr’15). These constraints affect the late dates (and consequently Total Float) for these activities and (parts of) their chains of predecessors.
- There is a late-finish constraint (25Feb’15) on the “Install Fence” activity (reason not known), with similar impacts on late dates and Total Float.
- Activities are scheduled using a 4d x 8h work week (M-Th), except for the two initial milestones which utilize a 24-hour calendar, and the final two Customer Checkout activies which utilize a 5d x 8h workweek.
- The “Notice to Proceed” milestone is constrained to start no earlier than 10:00 PM on 05Jan’15.
- P6’s scheduling options are set to define critical path activities on the basis of “Longest Path” rather than Total Float, and the Gantt chart appears to properly display the Critical Path by this definition. Thus, the two initial milestones are marked as critical because they are driving the project’s completion, even though their calendars allow a higher value for total float.
Although “Longest Path” appears to correctly identify the driving path to the project completion (the Project Acceptance milestone), the contractor is equally interested in identifying the driving path to the “Construction Project Complete” intermediate milestone.
In P6’s advanced schedule options, we select “calculate multiple float paths” ending with the “Construction Project Complete” milestone” (Figure 2). As a rule, we calculate the multiple paths using “free float” rather than “total float”, since the former option best mimics “longest path” behavior.* The default number of paths to calculate is ten.
* See “P6-multiple-float-path-analysis-total-float-and-free-float-options” for more on these options.
Figure 3 illustrates the result of re-calculating the schedule then displaying a layout that arranges the activities by “Float Path” and sorting by “Float Path Order”. In this figure, “Float Path 1” is the driving logical path leading to the Construction Project Complete milestone. “Float Path 2” defines the first near-driving-path, “Float Path 3” defines the next near-driving path, etc. Each “float path” is essentially a discrete branch from the main, driving logical path. Obviously, Float Path 1 defines the activities that offer the most opportunity to accelerate the construction project (and maybe the most risk of extending it.) According to the figure, higher float paths tend to have higher values of total float, though the correlation is not universal.
Figure 3: (P6) Multiple Float Paths to Interim Milestone
Unfortunately, P6 does not rigidly distinguish between driving-paths and near-driving paths. That is, while float path 1 is always “the” driving path, float path 2 may designate another, parallel driving path or a path that is 2 days from the driving path. It is not obvious how far a certain numbered path may be from driving; that is, what is its “relative float” with respect to the end activity? You can try to estimate this manually by looking at start and finish dates of various related activities in the output. More rigorously, the relative float of each path can be computed by summing the “Relationship Free Float” of all the relationships between the given path and the end activity. [Jul’18 Edit: In certain cases P6’s path-selection criteria can relegate parallel driving-path activities – even Longest-Path activities – to high-numbered float paths that appear far from the driving path. I described this in a later article – Relationship Free Float and Float Paths in Multi-Calendar Projects (P6 MFP Free Float Option).]
Ongoing management of projects often requires what-if analysis of prospective disruptions, and P6’s MFP can be useful. For example, the subcontractor for the “Install Bus and Jumpers” activity may request early access to accommodate a staffing conflict. Running MFP ending with “Install Bus and Jumpers” will identify the driving path of predecessors for this work (Figure 4), assisting in the review and consideration of the request.
Figure 4 demonstrates the utter lack of correlation between Total Float and the driving logical path for any given activity in the schedule.
A Word about LOE Activities and ALAP Constraints (P6)
Depending on the scheduled dates, P6 automatically sets the relationships of LOE (level-of-effort) activities to “Driving”. As a consequence, P6’s Longest Path algorithm traces driving flags directly through LOE activities to their non-critical predecessors, and these end up – incorrectly – on the Longest Path. Fortunately, this error seems to be avoided in Multiple-Float Path analysis. MFP tracing correctly identifies only true driving logic and excludes LOE activities from the trace. (I’ve illustrated this in another entry HERE.)
Like LOEs, predecessor relationships from activities with ALAP (as-late-as-possible) constraints in P6 can be flagged as “Driving” based on their dates alone. Consequently, each ALAP-constrained predecessor creates a new parallel driving path to the selected end activity, and these paths are mapped in the MFP analysis. Since ALAP-constrained activities are rarely actually driving anything, it can be useful to filter them out from standard MFP layouts.
Multiple Float Path Analysis in Microsoft Project
(Microsoft Project provides neither Longest-Path nor Multiple-Float-Path analysis. BPC Logic Filter is an add-in that applies similar calculations to MSP schedules.) Figure 5, Figure 6, and Figure 7 illustrate the same steps as above, but this time executed on the Microsoft Project version of the schedule using BPC Logic Filter. In this type of analysis, the primary difference between P6 and BPC Logic Filter is that BPC Logic Filter explicitly computes and displays “Relative Float” (i.e. days away from driving) for each path. Thus two logical paths with the same relative float (i.e. parallel paths) are grouped together in BPC Logic Filter, while P6 assigns separate float paths. The MSP add-in also re-colors Gantt bars based on their path relative float with respect to the “selected” task.
Finally, BPC Logic Filter allows a more substantial evaluation of the upstream and downstream logic affected by the potential change to “Install Bus and Jumpers”. Figure 8 identifies the predecessor and successor paths for the selected task, all arranged according to their path relative float (shown at the end of each bar) with respect to the selected task. This illustrates that, while the selected work cannot be accelerated without violating (or modifying) its driving predecessor logic, it may be delayed by up to 12 days without affecting any successor work.
As a long-time Primavera user accustomed to MFP analysis options, I was continually disappointed when faced with the need for logical path analysis in Microsoft Project. I wrote BPC Logic Filter in part to cover this gap; now I find myself facing disappointment in the opposite direction.
Here I address the fundamental inability of MSP users – even supposed experts – to correctly analyze a logic-driven schedule.
While rooting around Planning Planet this morning, I stumbled across this link to an 8-month old blog entry from Ten Six Consulting: Monitoring Near Critical Tasks in Microsoft Project 2013 | Ten Six Consulting. In light of my work on BPC Logic Filter, this was a subject of interest to me. I started to reply on PP, but as my response grew I decided to transform it into an entry over here….
Overall I believe the article presents a perfect example of the fundamental inability of MSP users – even supposed experts – to correctly analyze a logic-driven schedule. The primary reason for this is the user community’s reliance on Total Slack as the sole indicator of a given task’s “criticality” or its inclusion on a particular logical path – all while continuing to use constraints, deadlines, and variable calendars.
As usual, the article is a well written and nicely presented illustration of a fairly elementary concept, i.e. generating and applying a “Near Critical Filter” to show only tasks with Total Slack values between 0.1 and 10 days. Ten Six then applied this filter to “clearly see all the tasks that are non-critical but in danger of becoming critical if they are delayed in any way.” Here is the resulting chart (taken from their article) with the four “Near Critical” tasks highlighted. The chart implicitly tells us that a Finish-No-Later-Than (2/22/15) constraint has been applied to the “Install Fence” task, reducing its Total Slack to 4 days. Now the Fence and its only predecessor (Grade Site) are highlighted as Near-Critical. (The TS=2 on the “Above Grade” summary task, also highlighted, seems to be a fluke of MSP’s screwy roll-up rule for TS; it reflects no logical relationship. [See Total Slack Calculation for Summary Tasks in Microsoft Project.])
So, if the fence is delayed by 5 days, is the project’s completion delayed? Clearly No; not according to this schedule. The fence is not Near Critical for the project. It merely has a constraint that may be violated (generating negative slack) if it slips too much. Since it is a common practice to represent such commitments with late constraints or deadlines, this example is fairly typical of a situation that occurs routinely in complex schedules with multiple contract milestones. It demonstrates why total slack is an unreliable indicator of the critical/near-critical path – i.e. the driving/near-driving path for project completion (or for anything else) –for all but the simplest projects.
There are some traditionalists in the scheduling profession who aim to preserve the sanctity of Total Slack (and Total Float in other tools) by prohibiting the use of any deadlines or late constraints in the schedule at all, regardless of contract commitments. The same group should also prohibit the use of variable task calendars, resource calendars, and any kind of resource leveling, since these can also invalidate their interpretation of total slack. I understand and empathize with this point of view – after all, without meaningful Total Slack (especially in MSP), the typical planner or analyst is reduced to hand-waving explanations when it comes to answering the tough questions. I’ve been there. Nevertheless, I also think alarm bells should ring and the schedule should bleed red whenever there is a forecast failure to meet a commitment. I advocate for methods other than setting aside 30 years of software development.
I spent a few minutes duplicating Ten Six’s schedule in MSP 2010 – thankful that they seem to be using the same (standard) example for the two articles published eight months apart. I think I got it close enough for illustrative purposes – with the main factors being a 4-day project work-week (M-Th), a 24-hour calendar on the first two milestones, and the aforementioned late constraint on the fence. Then I used BPC Logic Filter to trace the logic for the “Project Complete” task.
Here’s the resulting chart. It shows the driving path for project completion (i.e. the “Critical Path”) – at Relative Float of 0. The CP includes all the tasks with TS=0 plus the two project milestones which, because of their different calendars, have a different Total Slack value. The first “Near-Critical Path” is actually 12-days (not 4 days) away from driving the project completion, and it includes the “Grade Site” task with the (synthetically reduced) TS=4. The “Install Fence” task, also with TS=4, is 24 days away from driving the project completion.
I didn’t write BPC Logic Filter to overcome all the shortcomings of MSP; rather I wrote it to extract and present the logic-related information that is already there but which MSP does not show. In this case – as in most – it tells a more complete story than Total Slack alone.