[Article 1 of 2.] This is a summary of the standard definitions and uses of driving logic relationships between activities in project schedules, as applied in Primavera P6 and Microsoft Project software. Driving relationships are often considered fundamental elements of the project critical path.
This winter I worked with a colleague to prepare a paper – Interpreting Logic Paths in Multi-Calendar Project Schedules – for presentation at this year’s AACE International Conference and Expo in Chicago. The paper reflects a deep dive into the Multiple Float Path calculation options in Primavera P6 scheduling software. During the technical study, I had a lot of opportunities to think about driving logic relationships. This entry summarizes the standard definitions and uses. I’ve summarized a couple alternate definitions and uses in another article.
The Importance of Driving Logic
The planning and execution of complex projects requires the project team to understand, implement, and communicate the consequences of schedule logic flow to the other stakeholders. Through schedule logic, each activity in the project has the potential to constrain or disrupt numerous other activities – and to be constrained or disrupted by them. The most obvious artifacts of logic flow are the important logic paths, like the critical path, the Longest Path (in Primavera P6), or the driving path to a key delivery milestone. Regardless of the detailed definition, each of these important paths is governed by driving logic relationships from the first activity to the last activity in the path.
Standard Definition and Uses of Driving Logic Relationships
A driving relationship is “A relationship between two activities in which the start or completion of the predecessor activity determines the early dates for the successor activity with multiple predecessors. See also: Free Float.” [That’s the standard definition from AACE International.] Alternately, “A driving relationship is one that controls the start or finish of a successor activity.” [That’s from the PMI publication on CPM Scheduling for Construction.]
For practical purposes, a driving relationship is a predecessor relationship that prevents a successor activity’s early start or early finish from being scheduled any earlier than it is. When an otherwise unconstrained activity has only one predecessor, then it is normally, and obviously, a driving predecessor. When an activity has multiple predecessors, then one or more of them may be driving while the others are non-driving. These distinctions answer the key questions, “Why is this activity scheduled when it is? Why can’t we do it sooner?”
Driving Logic in Primavera P6
Like its predecessors, P6 routinely illustrates driving logic relationships using solid lines on bar charts – either red or black depending on the “Critical” status of the connected activities. Non-driving relationships are depicted with the same colors, and those that are also non-critical use dotted lines. This is demonstrated in the figure below, where the non-critical activity “Task” (A1020) has two predecessors and five successors. One of the predecessor relationships and all five of the successor relationships are depicted with solid black lines and marked as driving (but not critical) in the relationship tables. The non-driving relationships – one from “pred a” to “Task” and five more from Task’s successors to the project’s finish milestone – are depicted with dotted lines. The two critical, driving relationships that connect the “CP” activity to the project’s start and finish milestones are depicted with solid red lines.
In small projects it is often easy to identify driving logic flow in printed P6 bar charts by visually tracing the solid relationship lines between activities. As project schedules become larger and more complex, however, the number of relationship lines increases to the point that visual tracing becomes impractical. Then driving relationships are primarily identified using the relevant columns of the associated relationship tables. Experienced P6 users often use the “GoTo” buttons in the relationship tables to click-trace along driving logic paths – backward and forward through complex project schedules – to review and confirm important chains of sequential logic (i.e. driving logic paths).
In general, Primavera P6 identifies driving relationships by analyzing the intervals between early dates of the linked activities, after completion of the core scheduling calculations. With a few minor exceptions, a driving relationship is identified when the Relationship Successor Free Float (RSFF) equals zero. In addition to providing a basis for the graphical and tabular depictions of driving logic flow, P6 uses these driving attributes to automatically identify the Longest Path, or the driving path to project completion.
Driving Logic in Microsoft Project
Unlike P6, Microsoft Project (MSP) does not graphically differentiate driving and non-driving relationship lines in Gantt-chart views, and the standard relationship (i.e. dependency) tables provide no driving-logic indicators. The Task Inspector pane provides the primary method for identifying driving predecessors of the currently-selected task; there is no corresponding method for identifying driven successors. The figure below depicts the same schedule as before, now in MSP format, with the Inspector pane identifying a single (driving) predecessor task, “pred b”, for the currently-selected task (“Task.”) As far as it goes, this agrees with P6.
Although not presented to users, driving relationship indicators are developed by MSP (at least since MSP 2007), with the results being stored in the PredecessorDrivers collection for each task. This collection forms the basis of the Predecessors list of the Inspector pane.
It’s also apparent that the PredecessorDrivers data are used to define the Driving Predecessors and Driven Successors bar styles that were introduced as part of the Task Path functionality in MSP 2013. This functionality is illustrated below, where the driving and non-driving predecessors of “Task” – and its driven successors – are all differentiated by bar color. Although there are clear limitations to this graphical approach, the ability to show driving and driven logic paths (if not individual driving relationships) is a major improvement for MSP users.
Unfortunately, the internal MSP calculation of driving logic attributes – and the explicit paths of driving logic that they purport to illustrate – have proven unreliable for complex schedules with other than finish-to-start relationships, out-of-sequence progress, or external links.
Standard Driving Logic in BPC Logic Filter for Microsoft Project
BPC Logic Filter (my company’s add-in for MSP) identifies driving logic by independently analyzing relationship relative floats after completion of the schedule calculations. This is a bit like the P6 approach and has proven, at least for me, more reliable than the internal MSP data when things get complicated. This figure shows the combination of a logic tracer view (with special bar styles depicting driving and near-driving logic paths) together with the task logic inspector tables. Driving relationships are highlighted yellow in the tables. Overall, this seems to combine the best parts of the corresponding P6 and MSP layouts, and the Jump buttons allow for logic-based navigation forward or backward through the schedule network.
In Project schedules, the Longest Path yields the Shortest Time. Aside from the mental gymnastics needed to digest that phrase, the concept of Longest Path – especially as implemented in current software – has deviated enough from its origins that a different term may be needed.
Critical Path as Longest Path
Authoritative definitions of the “Critical Path” in project schedules typically employ the words “longest path,” “longest chain,” or “longest sequence” of activities … (that determine the earliest completion date of the project.) In other words, the path, chain, or sequence with the greatest measured length is the Critical Path. As a rule, however, none of the associated documents are able to clearly define what constitutes the length of a logic path, nor how such length will be measured and compared in a modern project schedule. Without a clear standard for measuring the length of something, explicitly defining the Critical Path in terms of the longestanything is just sloppy in my view.
The Original Path Length
Assessing path length used to be much easier. In the early days of CPM (Critical Path Method) scheduling, any project schedule could be guaranteed to have ALL Finish-to-Start relationships, NO constraints, NO lags or leads, NO calendars, and only ONE Critical Path. Under these conditions, the length of a logic path could be clearly defined (and measured) as the sum of the durations of its member activities. Thus, the overall duration of a Project was equal to the “length” (i.e. duration) of its Critical Path, which itself was made up of the durations of its constituent activities. That result is indicated in the figure below, where the 64-day project length is determined by the durations of the 5 (highlighted) activities on the Critical Path. Adding up the activity durations along any other path in the schedule results in a corresponding path length that is less than 64-days – i.e. not the “longest” path. [The network diagram was taken from John W. Fondahl’s 1961 paper, “A Non-Computer Approach to the Critical Path Method for the Construction Industry,” which introduced what we now call the Precedence Diagramming Method. Unfortunately, Microsoft Project (MSP) has an early limit on dates, so his presumed ~1961 dates could not be matched.]
Fortunately, in such simple projects, it’s never been necessary to aggregate and compare the lengths of every logic path to select the “longest path.” The CPM backward pass calculations already identify that path by the activities with zero-Total Float/Slack, and successively “shorter” paths are identified by successively higher Total Float/Slack values. This fact has been verified in countless student exercises involving simple project schedule networks, typically concluding with the axiom that “the Critical Path equals the longest path, which equals the path of zero-Total Float/Slack.”
Float/Slack and Path-Length Difficulties
In general, modern complex project schedules have, or can be expected to have, complicating factors that make Total Float/Slack unreliable as an indicator of the Critical Path – e.g. non-Finish-to-Start relationships, various early and late constraints, multiple calendars, and even resource leveling. See this other article for details. Therefore, as noted earlier, the axiomatic definition has been shortened to “the Critical Path equals the longest path.”
Unfortunately, finding the “longest path” by arithmetically summing the activity lengths (i.e. durations) along all possible logic paths and comparing the results – not easy to begin with – has gotten more difficult. Lags, excess calendar non-working time, early constraints, and resource leveling delays all add to the true “length” of a logic path compared to the simple summation of activity durations. On the other hand, leads (negative lags), excess calendar working-time, and the use of overlapping-activity relationships (e.g. SS/FF) reduce its length. In addition, any hammocks, level-of-effort, and summary activities need to be excluded. All such factors must be accounted for if the “longest path” is to be established by the implied method of measuring and comparing path lengths in the project schedule. I don’t know of any mainstream project scheduling software that performs that kind of calculation. Alternatively, Deep Schedule AnalysisTM using the proprietary HCP (Hidden Critical Path) Method – from HCP Project Management Consulting – appears to compute and compare the lengths of all logic paths in Primavera and MSP schedules.
Longest Path as Driving Path
Contrary to summing up and comparing logic path lengths, current notions of the “longest path” are based on an approach that does not involve path “length” at all. As a key attribute, the longest path in a simple, un-progressed project schedule also happens to be the driving logic path from the start of the first project activity to the finish of the last project activity. It is a “driving logic path” because each relationship in the path is “driving”, that is it prevents its successor from being scheduled any earlier than it is. Driving relationships are typically identified during the forward-pass CPM calculations. Subsequently, the driving path to the finish of the last activity can be identified by tracing driving logic backward from that activity, terminating the trace when no driving predecessors are found or the Data Date is reached. The resulting driving path to project finish is also called the “longest path” even though its “length” has not been established. This is the “Longest Path” technique that has been applied for nearly two decades by (Oracle) Primavera and adopted more recently in other project scheduling tools.
As of today, MSP continues to define Critical tasks on the basis of Total Slack, but it provides no explicit method for identifying the “Critical Path” using a “longest path” criterion. How is the responsible MSP scheduler supposed to respond to a demand for the “critical path” when the longest path has been obscured? Here are several options:
Continue to make simple projects, avoiding all complicating factors like calendars (including resource calendars), early and late constraints, deadlines, and resource leveling. Then assume that “Total Slack = 0” correctly identifies the Critical Path.
If you are using MSP version 2013 or later,
Ensure that your project is properly scheduled with logic open-ends only present at a single start and single finish task/milestone, then select the single finish task,
Try to use the “Task Path” bar highlighter to highlight the “Driving Predecessors” of your selected finish task. In the example below, a Deadline (a non-mandatory late-finish constraint) has been applied to task Op12 in the 1961 example, and MSP has responded by applying the “Critical” flag (based on TS=0) to Op12 and its predecessors Op10 and Op2. As a result, the Critical Path is obscured. Applying the bar highlighter and selecting task Op18 (the project’s finish task) correctly identifies the driving path to project completion, i.e. the “longest path.” (For clarity, I manually added the corresponding cell highlighting in the table; the bar highlighter doesn’t do that.)
If necessary, create and apply a corresponding filter for the highlighted bars. I’ve posted a set of macros to make and apply the filter automatically in this article.
If you are using MSP version 2007 or later,
Ensure that your project is properly scheduled with logic open-ends only present at a single start and single finish task/milestone, then select the single finish task,
Try to use the Task Inspector to identify the driving predecessor of the selected task, then go to it and flag it as being part of the driving path. Repeat this until the entire driving path is marked.
If necessary, create and apply a filter and/or highlighting bar styles for the flagged tasks.
I’ve posted another set of macros to do all this (except bar highlighting) automatically in this other article.
Note: The previous two approaches both rely on MSP’s StartDriver task object to identify driving relationships. As noted in this article, however, the resulting driving logic is not reliable in the presence of tasks with multiple predecessors, non-FS predecessors, or actual progress.
Use BPC Logic Filter or some other appropriate add-in to identify the “longest path” in the schedule.
Whichever method or software is used, expressing the Longest Path using the Driving Path methodology has one key weakness: it has not been proved generally useful for analysis of near-critical paths. While the Longest Path may be known, its actual length is not readily apparent. More importantly, there is no basis for computing the lengths, and hence the relative criticality, of the 2nd, 3rd, and 4th etc. Longest Paths. Consequently, Near-Critical paths continue to be identified based on Total Float/Slack, which is still unreliable, or – in P6 – based on unit-less “Float Paths” from multiple float path analysis.
“Longest Path” and Early Constraints
As noted several times here, the methods described for identifying the “longest path” are in fact describing the “driving path to the project finish.” This distinction can raise confusion when an activity is delayed by an early constraint. Consider the case below, where an activity on the longest path (Op13) has been delayed 2 days by an early start constraint. Consequently, its sole predecessor relationship (from Op3) is no longer driving, and Op3 gains 2 days of Total Float/Slack. As shown by MSP’s “Driving Predecessor” bar highlighter, the driving logic trace is terminated (going backwards) after reaching the constrained task.
Identical results are obtained from Primavera’s (P6) Longest Path algorithm. This is neither surprising nor incorrect; the project’s completion is in fact driven by the external constraint on Op13, and its predecessor Op3 is quite properly excluded.
It’s clear therefore that the driving path to project completion and the longest path from the project start (or Data Date) to the project completion can differ when an early constraint is present. P6’s “Longest Path” algorithm automatically defaults to the driving path, not the actual longest path, and to date there have been no built-in alternatives to that behavior. As a result, some consultants suggest that P6 Longest Path analyses should be rejected when external constraints – even legitimate ones like arrival dates for Customer Furnished Equipment – are present. (A P6 add-in, Schedule Analyzer Software, does claim to provide a true Longest Path representation in the presence of early constraints.)
BPC Logic Filter – Longest Path Filter
BPC Logic Filter is a schedule analysis add-in for MSP that my company developed for internal use. The Longest Path Filter module is a pre-configured version of the software’s Task Logic Tracer. The module is specifically configured to identify the project’s longest path (as driving path) through the following actions:
Automatically find the last task (or tasks) in the project schedule.
Excluding tasks or milestones that have no logical predecessors. (E.g. completion milestones that are constrained to be scheduled at the end of the project but are not logically tied to the actual execution of the project. The resulting trace would be trivial.)
Excluding tasks or milestones that are specifically flagged to be ignored, e.g. (“hammocks”)
Trace the driving logic backwards from the last task to the beginning of the project.
Driving logic is robustly identified by direct computation and examination of relative floats. (Driving relationships have zero relative float according to the successor calendar.) The unreliable StartDriver task objects are ignored.
Neither completed nor in-progress tasks are excluded from the trace.
Either apply a filter to show only the driving logic path, or color the bars to view the driving logic path together (in-line) with the non-driving tasks. The example below is identical to the previous one, but BPC Logic Filter formats the bar chart to ignore the impacts of the applied deadline. The resulting in-line view is substantially identical to the bar chart of the original, unconstrained project schedule.
BPC Logic Filter and the (True) Longest Path
As noted earlier, an early constraint can truncate the driving path to project completion. In that case, it is debatable in my view whether the addition of non-driving, float-possessing activities into the “longest path” makes that term itself more or less useful with respect to the typical uses of the “Critical Path” in managing and controlling project performance. Nevertheless, such an addition is easily allowed in BPC Logic Filter by checking a box. The bar chart below shows the results of the Longest Path Filter on the early-constrained example schedule, as set up according to the driving-path (Primavera) standard. Results are identical to those of the built-in “Driving Predecessors” highlighter in MSP (above) and of P6.
The next chart shows the complete “longest path” for the project, including the non-driving Op3 activity.
The second chart is different because the check box for “Override if successor task is delayed by constraint” has been checked in the analysis parameters form. Checking the box causes the non-driving predecessor with the least relative float to be treated as driving, and therefore included in the Longest Path, in the event of a constraint-caused delay.
As noted earlier, the normal methods for identifying the “longest path” (i.e. the driving path) in a project schedule have not been generally adopted for analyzing near-longest paths. P6 offers multiple float path analysis, which I wrote about here. In addition, Schedule Analyzer (the P6 add-in mentioned earlier) computes what it calls the “Longest Path Value” for each activity in the schedule – this is the number of days an activity is away from being on the Longest Path (i.e. the driving path to project completion.) In the absence of demonstrated user demand, however, MSP seems unlikely to gain much beyond the Task Path bar highlighters.
BPC Logic Filter routinely computes and aggregates relative float to identify driving and near-driving logic paths in MSP project schedules. In this context, “near-driving” is quantified in terms of path relative float, i.e. days away from driving a particular end task (or days away from being driven by a particular start task.) Its “Longest Path” and “Near Longest Path” analyses are special cases where the automatically-selected end task is the last task in the project. For the Near Longest Path Filter, tasks can be shown in-line (with bar coloring) or grouped and sorted based on path relative float. The “override if successor is delayed by constraint” setting has no effect when the Near Longest Path Filter is generated. In that case, the non-driving task will be displayed according to its actual relative float. For example Op3 is shown below with a relative float of 2 days (its true value), not 0 days as shown on the earlier Longest Path Filter view.
In the development of the Critical Path Method, the “longest path” originated as one of several defining characteristics of the “Critical Path” in simple project schedules. Specifically, the “Critical Path” included the sequence of activities with the highest aggregated duration – i.e. the “longest path”. Actual computation and comparison of path lengths was not necessary since relative path lengths could be inferred directly from Total Float – a much easier calculation.
Complicating factors in modern project schedule networks tend to confuse the interpretation of Total Float, such that it is no longer a reliable surrogate for path length. As a result, the most recent, authoritative definitions of the Critical Path tend to omit references to float while retaining references to “longest path” and, typically, logical control of the project completion date. [Notably, the measurement and comparison of aggregated path durations (path lengths) has not been an explicit feature of any mainstream project scheduling tool, so the “longest-path” part of the definition cannot be definitively tested in general practice.]
Notions of “longest-path” among current schedule practitioners are heavily influenced by the deceptively-named “Longest Path” feature in Oracle/Primavera’s P6 software. Perversely, that feature DOES NOT aggregate activity durations along any logic paths. Rather, it identifies the driving/controlling logic path to the project’s early finish date.
The “Longest Path” in P6 (i.e. the Driving Path to Project Completion) and the “longest path” (i.e. the logic path with highest aggregated duration) are NOT equivalent, particularly when the “Longest Path” is constrained by an early date constraint. There is at least one P6 add-in claiming to identify the true “longest path” (and near-“longest paths”) in this case.
Microsoft Project provides several inefficient methods to identify the Driving Path to Project Completion in simple projects, but these methods are not reliable in the presence of non- Finish-to-Start relationships. There are no native MSP methods for identifying near-driving tasks nor the true “longest path” in the presence of early date constraints. BPC Logic Filter is an MSP add-in that automatically fills these gaps.
As conceived, the “longest path” criterion implied the transparent calculation and comparison of aggregated activity durations along each logic path in a project schedule. As for Total Float, however, such calculations in complex schedules have been obfuscated by complications like non- Finish-to-Start relationships, lags, and multiple calendars. Since such obfuscation makes path lengths essentially un-testable, it appears that future Critical Path definitions should omit the “longest path” criterion in favor of a simple “driving path to project completion.”
Longest Paths in Backward Scheduled Projects (MSP) [Jan’19 Edit]
As pointed out in this recent article, the Longest Path in a backward scheduled project is essentially the “driven path from the project start,” not the “driving path to project completion.”
The “critical” activity flags in modern project schedules often do not correctly identify the true critical paths. Blind acceptance of such “critical” flags to identify the critical path inhibits proper understanding, communication, and management of project schedule performance – and gives CPM a bad rap.
Basic CPM Concepts (in General):
The “critical path method” (CPM) – a ~60-year-old algorithm of fairly straightforward arithmetic – lies at the core of most modern project scheduling tools, and most project managers worthy of the name have been exposed to at least the basic CPM concepts. Any discussion of the critical path must address the underlying conceptual basis:
A CPM project schedule is comprised of all the activities necessary to complete the project’s scope of work.
Activity durations are estimated, and required/planned sequential restraints between activities are identified: e.g. Predecessor task “A” must finish before successor task “B” can start, and predecessor task “C” must finish before successor task “D” can start. The combination of activities and relationships forms a schedule logic network. Below is a diagram of a simple schedule logic network, with activities as nodes (blocks) and relationships as arrows.
Logic Relationships. A logic relationship represents a simple (i.e. one-sided) schedule constraint that is imposed on the successor by the predecessor. Thus, a finish-to-start (FS) relationship between activities A and B dictates only that the start of activity B may NOT occur before the finish of activity A. (It does not REQUIRE that B start immediately after A finishes.) Other relationship types – SS, FF, SF, which were added as part of the precedence diagramming method (PDM) extension of traditional CPM – are similarly interpreted. E.g. A–>(SS)–>B dictates only that the start of B may not occur before the start of A. Activities with multiple predecessor relationships must be scheduled to satisfy ALL of them.
Logic Paths. A continuous route through the activities and relationships of the network – connecting an earlier activity to a later one – is called a “logic path.” Logic paths can be displayed – together or in isolation – to show the sequential plans for executing selected portions of the project. The simple network shown has only two logic paths between the start and finish milestones: Path 1 = (StartProject) <<A><B>> (FinishProject); and Path 2 = (StartProject) <<C><D>> (FinishProject). [Experimenting with some shorthand logic notation: “<” = logic connection to activity’s Start; “>” = logic connection to activity’s Finish.]
Schedule Calculations. Schedule dates are calculated using three essential steps:
During the forward pass, the earliest possible start and finish dates of each activity are computed by considering the aggregated durations of its predecessor paths, beginning from the project start milestone and working forward in time.
Assuming an implicit requirement to finish the project as soon as possible, the early finish of the project completion milestone is adopted as its latest allowable finish date. This can be called the finish reflection. (Most CPM summaries ignore this step. I include it because it is the basis for important concepts and complications to be introduced later.)
During the backward pass, the latest allowable start and finish dates of each activity are computed by considering the aggregated durations of its successor paths, beginning from the project completion milestone and working backward in time.
Driving and Non-Driving Logic. A logic relationship may be categorized as “driving” or “non-driving” depending on its influence over the early dates of the successor activity – as calculated during the forward pass. A driving relationship controls the early start/finish of the successor; a non-driving relationship does not. In other words, a “driving” relationship prevents the successor activity from being scheduled any sooner than it is. A logic path (or path segment) may be categorized as “driving” (to its terminal activity) when all of its relationships are driving. [Such a path is sometimes called a “string.”]
Total Float. In simplified terms, the difference between the early start/finish and late start/finish of each activity is termed the activity’s “total float” (or “total slack”). A positive value denotes a finite range of time over which the activity may be allowed to slip without delaying “the project.” A zero value (i.e. TF=0) indicates that the activity’s early dates and late dates are exactly equal, and any delay from the early dates may delay “the project.” It is important to remember that total float/slack is nominally computed as a property of each individual activity, not of a particular logic path nor of the project schedule as a whole. [While computed individually for each activity, the float is not possessed solely by that activity and is in fact shared among all the activities within a driving logic path. In the absence of certain complicating factors, it is common to refer to a shared float value as a property of that path.]
Critical Path. A project’s critical path is the path (i.e. the unique sequence of logically-connected activities and relationships) that determines the earliest possible completion of “the project.” I prefer to call this the “driving path to project completion.” Other logic paths through the schedule are considered “near-critical paths” if they are at risk of becoming the critical path – possibly extending the project – at some time during project execution. In our simple project shown below, the critical path is Path 1, whose total duration of 4 weeks (20 days on a standard 5dx8h calendar) controls the early finish of the completion milestone.
In unconstrained schedule models incorporating only a single calendar (and without other complicating factors), the finish reflection causes the activities on the critical path to have late dates equal to their early dates; i.e. TF = 0. Consequently, any delay of a critical-path activity cascades directly to delay of the project completion. The near-critical paths are then defined as those paths whose activities have TF more than zero but less than some threshold. In traditional “critical path management,” activities that are NOT on or near the critical path may be allowed to slip, while management attention and resources are devoted to protecting those activities that are on or near the critical path. More importantly, acceleration of the project completion (or recovery from a prior delay) may only be accomplished by first addressing the activities and relationships on the critical path.
[Note: The definition of “critical path” has evolved with the introduction of new concepts and scheduling methods over the years. The earliest definitions – based on robust schedule networks containing only finish-to-start relationships, with no constraints, no lags, and no calendars – were characterized by the following common elements:
It contained those activities that determined the overall duration of the project (i.e. the “driving path to project completion.”)
It contained those activities that, if allowed to slip, would extend the duration of the project (hence the word “critical”).
A delay of any of its activities would be directly transmitted to an equal (matching) delay of the project completion.
Its activities comprised the “longest path” through the schedule network. That is, the arithmetic sum of their durations was greater than the corresponding sum for any other path in the network.
After completion of the forward and backward passes, its activities could be readily identified by a shared total float value of zero. Thus TF=0 became the primary criterion for identifying the critical path.
With the incorporation of non-FS relationships, early and late constraints, lags, and calendars in modern project scheduling software, these observations are no longer consistent with each other nor sometimes with a single logic path. Some of these inconsistencies are addressed later in this article. Only the first of these defining elements (“driving path to project completion”) has been generally retained in recent scheduling standards and guidance publications, though implied equivalence of the others continues to persist among some professionals.]
Software – the Critical Activities / Critical Tasks:
The basic element of modern project schedules is the activity or task. In most scheduling tools, logic paths are not explicitly defined. Nevertheless, the obvious importance of the critical path dictates that software packages attempt to identify it – indirectly– by marking activities that meet certain criteria with the “critical” flag. Activities with the “critical” flag are called “critical activities” (or “critical tasks”) and are typically highlighted red in network and bar-chart graphics.
Applying Critical Flags using Default Total Float Criteria
The simplest criterion for flagging a task as “critical” is TF=0. This is the primary method that most new schedulers seem familiar with, and it is the default criterion for some software packages. As noted earlier, this criterion is applicable to schedules with no constraints and only a single calendar. In Microsoft Project (MSP) and Oracle Primavera P6 (P6), the default “critical” flag criterion is TF<=0, and the threshold value of “0” can be adjusted. The differences between these criteria and the simpler TF=0 criterion are justified by four primary concerns:
Risk Management. Due to the inherent uncertainty of activity duration estimates, the critical path of a real-world project schedule – as ultimately executed – often includes an unpredictable mix of activities from the as-scheduled critical path and near-critical paths. In the absence of quantitative schedule risk assessment, it is reasonable to consider all such (potentially-critical-path) activities equally when evaluating project schedule risks. This purpose is easily served by applying the “critical” flag to all activities whose TF value is less than or equal to some near-critical threshold.
Late Constraints. Overall project completion priorities (and contractual requirements) often lead to the imposition of deadlines (in MSP), late-finish constraints (in MSP and P6), or project constraints (in P6). Such constraints can override the finish reflection and cause the late dates of some activities to be earlier or later than they would be in the absence of the constraints. As a result, total float can vary among the activities on the driving path to project completion. In a project with multiple constrained milestones, the driving path to only one of them (the most “urgent”) can be expected to have a constant total float value (i.e. the lowest total float.) Due to intersecting logic paths, total float can vary along the driving paths to other constrained milestones. Applying the “critical” flag to activities with total float less than or equal to the project’s lowest total float marks those activities that are on the driving path to the most urgent constrained milestone in the project. If a project constraint (in P6 only) is applied, the lowest total float value may be greater than zero; without a more urgent constraint, the marked activities then denote the driving path to the final activity in the project.
Negative Float. Late constraints can cause late dates to precede early dates for certain activities. This results in negative values for total float/slack (i.e. TF<0). In practically all cases, negative total float indicates that the activity cannot be scheduled in time to satisfy one or more of the deadlines or constraints (though which one of these is violated may not be clear); and some corrective action is necessary. [*The concept of negative float – and the constraints that create it – were not included in the foundations of CPM and PDM. Negative float is not universally accepted among scheduling professionals today, and not all scheduling software supports its calculation.]
Applying the “critical” flag to all activities with total float less than or equal to zero then marks all activities that:
Are on the driving path to an unconstrained project completion (i.e. TF=0, controlled by the project’s finish reflection); or
Are on the driving path to a constrained project completion or intermediate milestone that is just barely met (i.e. TF=0, controlled by deadline/constraint); or
Are on the driving path to project completion where an explicit project completion milestone is violated (i.e. TF<0, controlled by project deadline/constraint); OR
Are on the driving path to some intermediate activity whose constraint is violated (i.e. TF<0, controlled by intermediate deadline/constraint); or
Are on any number of non/near-driving paths to one or more constrained project completion or intermediate milestones, (i.e. TF<0). Though non-driving, these paths must still be shortened (in addition to shortening the driving and nearer-driving paths) to meet the milestones.
Working-Time Calendar Effects. When activities with different calendars are logically connected in a schedule network, the interval between the finish of a predecessor task and the start of its successor may sometimes contain working time for the predecessor but not for the successor. If this occurs, then a driving logic relationship exists, but the predecessor still has room to slip without delaying any other tasks or the project (i.e. it possesses float.) Thus, total float may vary along a single driving logic path, including the critical path. The amount of this variation depends on the size of potential offsets between calendars: from a few hours (for shift calendar offsets) to a few days (for 5-day and 7-day weekly calendars offsets) to a few months (for seasonal-shutdown calendar offsets).
Applying the “critical” flag to all activities with total float less than or equal to the largest calendar-related offset will mark all activities that:
Are on the driving path to project completion with TF<=0;
Are on the driving path to project completion but with TF>0 (and less than the specified offset);
Are NOT on the driving path to project completion but have TF less than the specified offset. These are false positives. For these activities, total float could be controlled either by the finish reflection (TF>=0) or by some other constraint.
Critical Flags and Critical Paths
Unfortunately, applying the “critical” flag as noted for most of these considerations has one consistent result: the continuous sequence of activities and relationships constituting a “critical path” often remains obscured. It is disappointing that the majority of project schedulers – using MSP or P6 – continue to issue filtered lists of “critical” activities as “the critical path.” Much of the time – especially in MSP – they are not. Even among expert schedulers, there is a persistent habit of declaring total float as the sole attribute that defines the critical path rather than as a conditional indicator of an activity’s presence on that path.
When an activity is automatically marked “critical” based on total float/slack, the primary conclusion to be drawn is simply, “this activity has total float/slack that is at or below the threshold value. That is, there is insufficient working time available between the early- and late- start/finish dates.” If total float/slack is less than zero, then one might also conclude, “this activity is scheduled too late to meet one or more of the project’s deadlines/constraints.” [If automatic resource leveling has been applied, then even these simple conclusions are probably incorrect.] These are important facts, but a useful management response still requires knowledge of the driving logic path(s) to the specific activities/milestones whose deadlines/constraints are violated – knowledge that total float/slack and its associated “critical” flag do not always provide.
Workarounds for Total Float Criteria
P6 provides several features, not available out-of-the-box in MSP, for correctly identifying the critical path when total float criteria do not. Specifically:
For Risk Management. P6’s multiple-float path analysis (MFP) allows the identification of successive driving and near-driving paths to specified project completion milestones. Monitoring progress on these paths is worthwhile for risk management. I’ve previously written about MFP analysis HERE. P6 does not support using float paths (the output of MFP analysis) as an explicit criterion for the “critical” activity flag.
For Late Constraints and Negative Float. P6 allows a negative critical float threshold. It is possible to set this threshold low enough so that only the “path of lowest total float” is marked as critical. In the absence of working time calendar effects, this criterion can be effective in identifying the (most) critical path. Thus it is possible to correctly identify the project’s critical path when: a) there is only a single constraint on the project; and b) that constraint coincides with the sole project completion milestone; and c) that constraint is violated (creating negative float).
MSP does not allow a negative critical float threshold, so correct identification of the critical path in a negative float scenario is not possible. All tasks with negative total slack are automatically and unavoidably flagged as “critical.”
If the P6 schedule has a project “must finish by” constraint, then the activities on the critical path may have positive total float. In that case, the lowest-float criterion may be applied (using a positive threshold) to correctly identify the critical path.
For Working-Time Calendar Effects. Unlike other project scheduling software, P6 allows the “critical” activity flag to be assigned on the basis of some criterion other than total float – called Longest Path. The name is misleading, as the method is based on driving logic rather than activity durations. Any activity that is found on the driving logic path to project completion is flagged as “critical.” (The algorithm tracks driving logic backward from the task(s) with the latest early finish in the project.) The Longest Path criterion ignores the total float impacts of multiple calendars and constraints. While it is effective in identifying the project’s critical (logic) path, Longest Path alone is not useful for identifying near-critical paths. MFP analysis (noted above) is useful for this purpose. “Longest path value ™,” a relative-float metric available in Schedule Analyzer Software (a P6 add-in) also helps to identify near-critical paths in these circumstances. For a more detailed review, see What is the Longest Path in a Project Schedule?
MSP provides no out-of-the-box solutions to address these weaknesses in critical path identification. Total float/slack remains the sole basis for applying the “critical” flag, yet the impacts of constraints, deadlines, and calendars remain unaddressed. In MSP 2013 and later versions, the “task path” bar style modifier does provide a basis for graphically identifying the driving path to a selected completion activity, and this is helpful. Nevertheless, a logic tracing add-in (like the BPC Logic Filter program that I helped to develop) is necessary to correctly identify the controlling schedule logic – including the true critical path – in a complex MSP schedule.
Definitions and Recommended Practices
Defense Contract Management Agency (DCMA – 2009)
DCMA’s in-house training course, Integrated Master Plan/Integrated Master Schedule Basic Analysis (Rev 21Nov09) is the source of the “14-Point Assessment” that – because its explicit “trigger” values are easily converted to pass/fail thresholds and red/yellow/green dashboards – is seen as a de-facto industry standard for schedule health assessment. The course materials contain the following definitions:
(Slide 28) Critical Path ~ Sequence of discrete work packages that has the longest total duration through an end point. ~ has the least amount of total float ~ cannot be delayed without delaying the completion date of the contract (assuming zero float). (Slide 98) Critical Path – Definition: a sequence of discrete tasks/activities in the network that has the longest total duration through the contract with the least amount of float. ~ A contract’s critical path is made up of those tasks in which a delay of one day on any task along the critical path will cause the project end date to be delayed one day (assuming zero float). (Slide 99) The critical path is ‘broken’ whenever there is not a sequence of connected critical path tasks that goes from the first task of the schedule until the last task. A broken Critical Path is indicative of a defective schedule.
These definitions are mostly (though not entirely) consistent with each other. They do share a common emphasis on the … “longest”… “sequence” … with “lowest total float” and direct transmission of delay from any critical-path task directly to the project’s completion. Obviously, the reliance on total float makes them incompatible with any project schedule that incorporates multiple calendars, late constraints, or resource leveling.
(Slide 97) Critical Task: Some tasks possess no float…they are known as critical tasks. ~Any delay to a critical task on the critical path will cause a delay to the project’s end date.
Unlike most of the later definitions, DCMA’s appears to contemplate the existence of critical tasks that are not on the critical path. Obviously, the expectation that such critical tasks possess “no float” is not compatible with negative-float regimes, nor is it compatible with the positive-float regimes that accompany project “must finish by” constraints in P6.
AACE International (2010 & 2018)
AACE International (formerly the Association for the Advancement of Cost Engineering) maintains and regularly updates its Recommended Practice No. 10S-90: Cost Engineering Terminology. The most recent issue of RP 10S-90 (June 2018) includes the following definitions:
CRITICAL PATH – The longest continuous chain of activities (may be more than one path) which establishes the minimum overall project duration. A slippage or delay in completion of any activity by one time period will extend final completion correspondingly. The critical path by definition has no “float.” See also: LONGEST PATH (LP). (June 2007)
CRITICAL ACTIVITY – An activity on the project’s critical path. A delay to a critical activity causes a corresponding delay in the completion of the project. Although some activities are “critical,” in the dictionary sense, without being on the critical path, this meaning is seldom used in the project context. (June 2007)
Unfortunately, these definitions fall apart in the presence of multiple calendars, multiple late constraints, or negative total float – when the second and third clauses in both definitions no longer agree with the first. They appear distinctly out of sync with modern project scheduling practices, and (according to AACE International’s Planning and Scheduling Subcommittee Chair) an update is pending.
AACE International’s RP No. 49R-06, Identifying the Critical Path (last revised in March 2010) instead defines the Critical Path as
…the longest logical path through the CPM network and consists of those activities that determine the shortest time for project completion. Activities within this [group (sic)] or list form a series (or sequence) of logically connected activities that is called the critical path.
Aside from the apparently inadvertent omission of a word, I don’t have any problem with this definition. It is certainly better, in my opinion, than the first.
RP 49R-06 notes the existence of “several accepted methods for determining the critical path” and goes on to describe the four “most frequently used” methods:
Lowest Total Float. This is as I described under Workarounds for Total Float Criteria, above. Although this method is listed first, the RP spends four pages detailing the issues that make total float unreliable as a CP indicator. As long as the CP is to be defined only with respect to the most urgent constraint in the schedule (including the finish reflection) – and there are no calendar issues – then this method provides a useful result.
Negative Total Float. In apparent acquiescence to the limitations of MSP, the RP describes this method by first abandoning the fundamental definition of the critical path as a specific logic path. It then allows the “critical” classification for any activity that must be accelerated in order to meet an applied deadline or constraint. Ultimately, the RP attempts to justify this method based solely on certain legal/contractual considerations of concurrent delay. It is not useful for those whose primary interest is timely completion of the project, or a particular part of the project, using critical path management principles.
Longest Path. This “driving path to project completion” algorithm, as I described above in Workarounds for Total Float Criteria, has been implemented in versions of (Oracle) Primavera software since P3 (2.0b). It is the preferred method for P6 schedules with constraints and/or multiple activity calendars. A similar algorithm is included in BPC Logic Filter, our add-in for Microsoft Project. While the method is nominally aimed at finding the driving path(s) to the last activity(ies) in the schedule, it can be combined with other techniques (namely a super-long trailing dummy activity) to derive the driving path to any specific activity, e.g. a specific “substantial completion” or “sectional-completion” milestone.
“Longest Path Value.” This is an expanded method for identifying the driving and near-driving paths to project completion. The method works by adding up relationship floats leading to a specific substantial completion milestone. If the aggregate value of these floats along a specific logic path (i.e. “Longest Path Value”) is zero, then that path is identified as the critical path. While the RP suggests that this method can be performed manually (presumably by “click-tracing” through the network of a P6 schedule), manual implementation in complex schedules is tedious and error prone. As implemented in Schedule Analyzer Software, this method is essentially an improved version of P6’s Longest Path method (except that the add-in cannot change the “critical” flag for activities.) It is a preferred method in P6 for those possessing the Schedule Analyzer Software. BPC Logic Filter performs similar analyses – using “path relative float” instead of “Longest Path Value” – for MSP schedules.
While not listed among the “most frequently used” methods, P6’s MFP analysis option is briefly addressed by the RP in the context of identifying near-critical paths. BPC Logic Filter performs similar analyses for MSP schedules.
None of the four methods described are useful for identifying the resource critical path (or resource-constrained critical path) of a leveled schedule.
Project Management Institute (PMI-2011)
PMI’s Practice Standard for Scheduling (Second Edition, 2011) explicitly defines the critical path as…
Generally, but not always, the sequence of schedule activities determining the duration of the project. Generally, it is the longest path through the project. However, a critical path can end, as an example, on a schedule milestone that is in the middle of the schedule model and that has a finish-no-later-than imposed date schedule constraint.
Unlike the RP (49R-06) from AACE International, PMI’s Practice Standard provides no meaningful method for quantitatively identifying the activities of the critical path (or any logic paths) in a particular schedule model. In fact, in its description of the precedence diagram method (PDM – the modern version of CPM used by most modern scheduling software) the Practice Standard acknowledges the complicating factors of constraints and multiple calendars but notes that “today’s computerized scheduling applications complete the additional calculations without problems.” Then it concludes, “In most projects the critical path is no longer a zero float path, as it was in early CPM.” The Practice Standard goes on to scrupulously avoid any explicit link between total float and the critical path. The impact of all this is to just take the software’s word for what’s “critical” and what isn’t. That’s not particularly helpful.
Finally, educating senior stakeholders on the subtle difference between “schedule critical” and “critical” is always one of the first issues faced when implementing systematic project management in non-project focused organizations. The Practice Standard’s several conflicting definitions of critical activities tend to confuse rather than clarify this distinction.
U.S. Government Accountability Office (GAO-2015)
The GAO’s Schedule Assessment Guide: Best Practices for Project Schedules (GAO-16-89G, 2015) has been taken to supersede the earlier DCMA internal guidance in many formal uses. (Nevertheless, the GAO’s decision to discard any formal trigger/threshold values – a good decision in my view – means that the DCMA-based assessments and dashboards remain popular.) The GAO document contains the following formal definitions:
Critical path: The longest continuous sequence of activities in a schedule. Defines the program’s earliest completion date or minimum duration.
[With some minor reservations related to meaning of “longest,” I believe this is a good definition.]
Critical activity: An activity on the critical path. When the network is free of date constraints, critical activities have zero float, and therefore any delay in the critical activity causes the same day-for-day amount of delay in the program forecast finish date.
[Unfortunately, the caveats after the first clause are insufficient, ignoring the complicating effects of multiple calendars.]
For the most part – and despite the float-independent formal definition above – the Schedule Assessment Guide’s “Best Practices” tend to perpetuate continued reliance on total float as the sole indicator of the critical path. In fact, “Best Practice 6: Confirming That the Critical Path Is Valid” does a good job of illustrating the complicating factors of late constraints and multiple calendars, but this review leads essentially to the differentiation of “critical path” (based on total float alone) from “longest path” (based on driving logic). This is a direct contradiction of the formal definition above. In general, the text appears to be written by a committee comprised of P6 users (with robust driving/Longest Path analysis tools) and MSP users (without such tools.) Thus, for every “longest path is preferred,” there seems to be an equal and opposite, “the threshold for total float criticality may have to be raised.” This is silly.
National Defense Industrial Association (NDIA-2016)
The NDIA’s Integrated Program Management Division has maintained a Planning & Scheduling Excellence Guide (PASEG), with Version 3.0 published in 2016. The PASEG 3.0 includes the following key definitions:
Critical Path: The longest sequence of tasks from Timenow until the program end. If a task on the critical path slips, the forecasted program end date should slip.
Driving Path(s): The longest sequence of tasks from Timenow to an interim program milestone. If a task on a Driving Path slips, the forecasted interim program milestone date should slip.
The second clause of each definition – which presumes a single calendar – is included in the Schedule Analysis chapter but is excluded from the formal definition in Appendix A. Timenow is effectively the data/status date. The PASEG does not define or mention critical task/activity as distinct from a “task on the critical path.”
The PASEG notes, “Some of the major schedule software tools have the ability to identify and display critical and driving paths. Additionally, there are many options available for add-in/bolt-on tools that work with the schedule software to assist in this analysis.” [I suppose BPC Logic Filter would be one of the mentioned add-in tools for Microsoft Project.]
The PASEG also mentions some manual methods for identifying critical and driving paths, e.g.:
a. Imposing a temporary, super-aggressive late constraint and grouping/sorting the output (presumably by total float and early start. Though not explicitly mentioned in the method description, total float is the key output affected by the imposed constraint.) Obviously, this method isn’t reliable when more than one calendar is used.
b. Building a custom filter by manually “click-tracing” through driving logic and marking the activities. This method is most reliable in P6, with some caveats. It is reliable in MSP only under some fairly restrictive conditions.
In general, these methods are non-prescriptive, though the emphasis on driving logic paths (rather than total float) seems clear.
Guild of Project Controls (GPC, “The Guild” – 2018)
The Guild is a relatively young (~2013) international community of project controls practitioners – initially associated with the PlanningPlanet.com web site – whose founding members have assembled a Project Controls Compendium and Reference (GPCCaR). The GPCCar takes the form (more or less) of an introductory training course on Project Controls, including Planning and Scheduling. The GPCCaR includes no formal Glossary, Terminology, or Definitions section, so “critical path” and “critical path activities” accumulate several slightly varying definitions in the applicable Modules (07-01, 07-7, and 07-8). In general, “zero total float” and “critical path” are used interchangeably, and the complications of multiple calendars and multiple constraints in P6 and MSP are ignored. This is not a suitable reference for complex projects that are scheduled using these tools.
A full understanding of driving and non-driving schedule logic paths for major schedule activities is useful for managing and communicating a project execution plan.
The most important logic path in the project schedule is the “critical path,” i.e. the driving path to project completion. Overall acceleration (or recovery) of a project is only made possible by first shortening the critical path. Acceleration of activities that are not on the critical path yields no corresponding project benefit to project completion. Multiple critical paths may exist.
Some traditional notions of critical path path attributes – e.g. critical path activities possess no float; slippage or acceleration of critical path activities always translates directly to project completion – are not reliable in modern project schedules.
Total float remains a valuable indicator of an activity’s scheduling flexibility with respect to completion constraints of the project. An activity with TF=0 may not be allowed to slip if all project completion constraints are to be met. Activities with TF<0 must be accelerated if all the constraints are to be met.
Project scheduling software typically defines individual activities as “critical” without fully accounting for common complicating factors like multiple constraints and calendars. As a result, the collection of “critical” tasks/activities in a complex project schedule often fails to identify a true critical path.
A critical task/activity is best defined (in my opinion) as either:
An activity that resides on the critical path; or
An activity whose delay will lead to unacceptable delay of the project completion; or
An activity whose delay will lead to unacceptable delay of some other constrained activity or milestone.
In general, these conditions are mutually exclusive, and different activities within a single project schedule may satisfy one or more of them.
Professional project managers and schedulers should be careful not to automatically characterize “critical” tasks (i.e. those with low total float) as indicators of a project’s critical path when complicating factors are present.
This short entry demonstrates why Level of Effort activities in Oracle Primavera P6 should be constructed using predecessor successor relationships only – especially when designating Critical activities using the Longest Path algorithm.
P6 LOE Activities
Level-of-Effort (LOE) activities in Oracle Primavera P6 project scheduling software are useful for summarizing the schedule dates of other (primary) activities. They are effectively a replacement for the “hammock” activities that existed in prior versions of Primavera products, including Primavera Project Planner (P3) and SureTrak Project Manager.
In prior software versions, hammocks were constructed by establishing a group of start-controlling activities as SS predecessors and a separate group of finish-controlling activities as FF successors. To avoid circular logic, the same activity could not be included in both predecessor (i.e. Start) and successor (i.e. Finish) groups.
In P6, LOE activities can be constructed using practically any mix of predecessors and successors, and the help file implies that the two can be used almost interchangeably. Although the same activity may not be included as both a predecessor and a successor, it MAY be included multiple times (e.g. as both an SS and FF predecessor) in either group. This allows for more flexibility in modeling activities that are not strictly hammocks.
P6 Help – Level of effort activity
Here’s a portion of the LOE Help topic in P6, which seems indifferent to the types of relationships used in specifying primary activities.
A level of effort activity is similar to but different from a hammock activity.
A level of effort activity uses its assigned calendar to summarize its dates. Hammocks are not scheduled using their own calendar.
Any type of relationship can be assigned to a level of effort activity. Only a start-to-start and finish-to-finish relationship can be assigned to a hammock activity.
A level of effort activity’s duration is calculated from the earliest early start of its predecessors/successors (linked to the start end of the level of effort activity) to the latest early finish of its predecessors/successors (linked to the finish end of the level of effort activity).A hammock activity’s duration is calculated from the earliest early start of its predecessors to the latest early finish of its successor activities.
Problems with LOEs and Longest Path
Despite the increased flexibility afforded by LOE activities in P6 – and its implied indifference to predecessor or successor relationships – many users continue to use SS-predecessors and FF-successors when establishing LOE dates. This can create issues when the project’s Critical Path is defined using the Longest Path option.
Here is a simple example project comprising a Critical Path of activities A-B-C-D-E-F-G with a side branch of associated activities A1-B1-C1-D1-E1-F1. The side activities must be completed before the final activity G can start. All activities are on the same calendar, and there are no constraints or resources. The corresponding Critical Path, as determined by Total Float (TF=0), is highlighted red on the Gantt Chart.
For this simple project, the Critical Path based on Total Float should be identical to the Critical Path based on “Longest Path” – i.e. the “driving path to project completion.” Unfortunately, this is not the case, as activities A1 (TF=10) and B1 (TF=8) are now included – incorrectly – on the Longest Path.
This error is caused by the Level of Effort activity LOE-1, which summarizes the dates of the side activities in Branch 1. Similar to P3 hammocks, this LOE activity is constructed using SS-predecessors to govern its start and FF-successors to govern its finish. The resulting dates are correct, but two complications are introduced.
As a rule, P6 marks all relationships to and from LOE activities as “Driving,” even when the relationship does not control any of the LOE’s dates.
The Longest Path algorithm, which traces driving logic backward from the project completion, does not differentiate LOE driving relationships from other driving relationships during the trace.
As a result of these complications, the Longest Path calculation traces driving logic backward from activity F1 through LOE-1 to its two driving predecessors A1 and B1. The latter two – along with their entire chains of driving predecessor logic, if any – are now included on the Longest Path. P6 automatically removes the LOE activity and its relationships from the Longest Path (after the backward pass), but the “Critical” flag on its “driving” predecessors remains.
Activities that are incorrectly included on the Longest Path may be identified by first noting those “Critical” activities whose successor relationships are NOT BOTH “Driving” and “Critical.” Then their “driving” predecessors are traced until either 1) there are no more driving predecessors, or 2) an activity is reached that has a separate successor relationship that is BOTH “Driving” and “Critical,” provided that this successor does not ultimately lead to another incorrect LOE predecessor. Such an examination can be tedious.
A quicker identification is obtained by re-calculating the schedule using Multiple Float Paths (Free Float option), with no End activity specified. Unlike the erroneous LP algorithm, MFP analysis correctly truncates the backward trace at LOE activities. Consequently, the true driving path to project completion (i.e. the correct Longest Path) of our simple project is identified as “Float Path 1,” and activities A1 and B1 are correctly relegated to Float Paths 6 and 5, respectively.
When analyzing Multiple Float Paths under the Longest Path regime: if a “Critical” activity has a Float Path that is higher than the Float Path of even one non-critical activity (all computed using the Free Float option), then that “Critical” flag may be incorrect.*
The simplest way to avoid this Longest Path LOE bug is to avoid including a mix of predecessors and successors when specifying the primary references for LOE activities. That is, use ONLY predecessors or ONLY successors. Since LOEs are technically inheriting their dates entirely from the primary activities, my initial preference was to use only predecessor relationships in the LOE.
Using Predecessor-Only Relationships
As shown here, the Longest Path of our simple example project is fixed by re-constructing LOE-1 logic using predecessors only. The two activities that were formerly “FF” successors of the LOE are now “FF” predecessors of the same LOE. The dates and float calculations are essentially unchanged, but the Longest Path is now correct.
Sometimes we want to make an LOE activity whose finish corresponds to the finish date of the project. Creating such an LOE using predecessor-only relationships doesn’t work as intended, however, because P6 picks the new LOE as the starting point of its Longest Path trace during the backward pass. Thus, our intention to stop logic flow through the LOE is foiled. In the next figure, this is shown by the new LOE-2 activity, whose finish is determined by the finish milestone (FM) of the project. Since LOE-2 is the latest-finishing activity with no successors, P6 starts the backward pass with it, ultimately including its non-critical predecessors A1 and B1 (incorrectly) on the Longest Path.
Predecessor-Only Relationships – LOE-2
Using Successor-Only Relationships
In contrast, if LOE-2 is constructed using successor-only relationships, then P6 will never choose it as the starting point of the Longest Path trace. Moreover, the absence of predecessors will ensure that when P6 does encounter such an LOE during the backward pass, the Longest Path trace will not continue past the LOE. As shown below, constructing LOE-2 using successor-only relationships leads to dates, float calculations, and Longest Path calculation that are all correct. This example suggests that successor-only relationships should be the preferred method for specifying LOE activities in P6.*
*Thanks to astute reader A Lou Gonzalez, who pointed out the special issue with using predecessor-only relationships to define LOE activities at the project completion date.
Late Cost Curves for LOE Activities
While using predecessors-only to specify LOE activity dates seems to fix the logic-flow issues, it has no effect on another defect of LOE activities. As Wail Menesi, has described in his LinkedIn Pulse entry, P6 incorrectly computes the remaining late start dates of certain in-progress LOE activities. As a consequence, the “Remaining Late” resource distribution for the affected activity is skewed to the left of the data date. In other words, P6 indicates that certain incomplete work must be completed in the past to avoid delaying the project, even when there is no negative float. That’s clearly incorrect. Fortunately, the issue seems to be limited to LOE activities who’s start dates are determined by Finish-to-Start relationships – a relatively rare structure in practice.
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….
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….
This article highlights the creation of a new targeted report from BPC Logic Filter to identify the “Near Longest Paths” of a project.
While BPC Logic Filter was originally developed as a pure logic tracer, I added a few targeted reports early on to reflect some specific needs, including the “Longest Path Filter” and the “Local Network Filter.” This article highlights the creation of a new targeted report to identify the “Near Longest Paths” of a project.
Often, when presented with a new project schedule in Microsoft Project, my first step (in concert with a logic health check) has been to run a Longest Path Filter analysis using BPC Logic Filter. This report quickly and clearly identifies the driving path to project completion. While the resulting filtered task list is useful for reporting, it rarely satisfies the needs of a serious analysis. The second step, therefore, is to identify the associated near-longest-paths of the project by running a “Task Logic Tracer” predecessor analysis – with a positive relative float limit – for the project completion task. The result is a clear description of the driving and near-driving paths to project completion. The latest release of BPC Logic Filter adds a specific command to combine these two actions and generate a single “Near Longest Path Filter” for the project.
The mechanics are pretty simple. As usual – with a Gantt view active in a project that contains logic – just open the Add-Ins ribbon [changed to the BPC ribbon in subsequent versions] and click on the button for “Near Longest Path Filter.”
The add-in will initialize, and the user is given a choice of modifying the default analysis parameters. Some of the parameters are pre-set and can’t be changed here. The key parameter for a formal Near-Longest-Path analysis is the Relative Float Limit, highlighted below. Any related task with a Path Relative Float that is less than the specified limit will be included in the filter; all others will be ignored and considered unrelated. The default value is 100 days away from the driving/longest path (which can be changed in the Settings).
The standard output for a simple project (using the parameters selected above) is provided here. Selecting “Re-Color Bars” instructs the add-in to generate the custom output shown, including the header, the legend, and five different bar colors depending on proximity to the Longest Path. Thresholds for applying these bar colors can be manually adjusted in the program settings or, if desired, automatically adjusted by the add-in.
Here’s an alternate view showing the Near Longest Paths in-line in the context of an existing Outline/WBS organization. In this analysis I reduced the Relative Float Limit from 100 to 20 days, and the three tasks at the bottom of the earlier figure were ignored. Here they are given a green “BPC Unrelated Task” bar.
While I’ve always hated redundant work, this particular improvement to BPC Logic Filter was kick-started by my recent review of the draft of “Analyzing Near-Critical Paths,” a pending Recommended Practice from AACE International. The new draft recommended practice is based largely on the previously-published (2010) Recommended Practice 49R-06 – Identifying the Critical Path. According to both documents, Critical- and Near-Critical paths may be identified on the basis of total float/slack thresholds (in the absence of variable calendars, constraints, or other complicating factors) and – when total float/slack does not suffice – “closeness to the longest path.” For the latter cases, 49R-06 suggests two methods of analysis:
Longest Path Value – a metric that appears similar to Path Relative Float (in BPC Logic Filter) for the project completion task. This metric has been applied as an add-on to Oracle Primavera scheduling tools: See Ron Winter’s Schedule Analyzer.
Multiple Float Path analysis. Like the Longest Path Value, Multiple Float Path analysis is primarily associated with Oracle’s Primavera scheduling tools – it is presented as an advanced scheduling option in P6. As I’ve noted in Beyond the Critical Path – multiple float path analysis indicates closeness to the longest path without explicitly measuring and presenting it. Detailed examination of the results, including relationship free floats, is necessary to determine the apparent relative float of each activity.
From its start, BPC Logic Filter has supported a similar analysis for Microsoft Project schedules through its Path Relative Float metric, Multiple-Float-Paths views, and other reporting. The new “Near Longest Path Filter” offers a single-step approach to identifying and analyzing near-critical paths in the presence of variable calendars, constraints, and other complicating factors – when Total Slack becomes unreliable as an indicator of logical significance.
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 for many years 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.
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.