Computer-assisted generative task scheduling

Abstract

Methods, systems, and apparatus for computer-aided generative task scheduling, including medium-encoded computer program products, include obtaining a set of data describing a schedule of one or more items to be rescheduled, the set of data including tasks to be scheduled, resource requirements, and dependencies between the tasks; generating variants of the schedule, each of the variants having a different characteristic that determines when to schedule each task in time for the tasks in the schedule, and each of the variants satisfying the resource requirements and the dependencies; selecting among the different characteristics for the task in the variation of the schedule to form a revised schedule for the one or more items; and providing the revised schedule of the one or more items for display to a user or for output to manage the one or more items.

Description

[0001] Cross - Reference to Related Applications

[0002] This application claims the benefit of priority of U.S. Patent Application No. 63 / 516,966, entitled "Computer - Aided Generative Task Scheduling", filed on August 1, 2023. Background Art Technical Field

[0003] This specification relates to computer - aided task scheduling.

[0004] Description of the Related Art

[0005] Creating and revising schedules at real - world scales (due to size, complexity, or both) is a time - consuming and largely manual process that typically prevents schedulers from exploring alternative scenarios and causes them to overlook potential opportunities to save time, labor, and cost. The initial schedule for a project is often created manually, taking a significant amount of time and effort to construct, as schedulers strive to manually achieve a level resource utilization for the tasks to be completed while accommodating the dependencies and constraints of their project.

[0006] While the first round of scheduling may be reasonably appropriate, due to many reasons, the plan will inevitably change. When it is too time - consuming and burdensome to adjust their schedules in response to changes, instead, schedulers will attempt to continue using their original schedules. As a result, the project must make other sacrifices to adhere to its initial plan, and the other sacrifices typically take the following forms: the project's staff works overtime, or worse, exceeds the project's budget or misses important deadlines. Summary of the Invention

[0007] This specification describes techniques related to computer-aided generative task scheduling, and particularly describes the scheduling of tasks to optimize the utilization of resource categories based on the requirements for task completion. Generative scheduling provides solutions and workflows that focus on the following problems: scheduling or rescheduling complex projects (or two or more interrelated projects) while efficiently and optimally using resources, and facilitating rapid iteration of alternative scheduling scenarios (whether in initial planning or in response to changes that make the original schedule unsuitable) to explore trade-offs under different time and resource goals and constraints. Generative scheduling is an algorithmic approach that can create a time-based task schedule that includes a hierarchical task structure, dependencies, time constraints, and resource requirements. This approach can be specifically designed to generate a feasible schedule based on the imposed structure, and more importantly, can be optimized for resource utilization. In addition, a schedule can be generated to (a) increase (or optimize) the continuity of tasks with projects and / or subprojects, and / or (b) improve (or optimize) the timing for tasks based on assigned priorities, while concurrently optimizing for resource utilization.

[0008] In some implementations, generative scheduling uses machine learning (such as evolutionary algorithms) to explore the vast search space of possible feasible schedules. The system can adapt to guide the schedule towards a desired solution based on one or more comprehensive objective measures (also known as objective functions) of schedule quality. Note that due to the NP-hard (non-deterministic polynomial time) complexity of the problem, exhaustive or even iterative refinement search and optimization methods are generally not applicable to many real-world scheduling problems. In addition, machine learning methods that rely on training based on a canonical dataset are generally not available because there is a poor (if any) correlation between one scheduling problem and another.

[0009] Specific embodiments of the subject matter described in this specification can be implemented to achieve one or more of the following advantages. By enabling rapid rescheduling of tasks in one or more projects, the functionality of the computer is improved, even when no similar existing project schedule is available to guide the rescheduling. Using schedule variant generation (e.g., random variants of task scheduling characteristics) and selection improves the technical field of task scheduling, which addresses the following technical problem: how to automate task rescheduling when no similar previous project schedule is available to guide the rescheduling. In addition, user interface controls are described that provide continuous and guided human-machine interaction to facilitate the technical task of rescheduling complex projects (or two or more interrelated projects), for example, by employing resource utilization shaping user interface controls.

[0010] In some implementations, an evolutionary artificial intelligence (AI) algorithm is used to evolve better schedules from existing schedules using a simplified simulation of a basic genetic process and informed contributors to good schedules, as measured by a goal that can be defined using high-level controls understandable to a user. State-of-the-art multi-objective evolutionary techniques can be applied to scheduling problems in a way that takes into account real-world scale and / or usability. Additionally, scheduling problems can be solved without having to make simplifying assumptions about how time is represented or processed.

[0011] As described in this application, generative scheduling can fundamentally transform the creation of schedules for complex projects from a tedious manual process into an interactive and productive experience, enabling faster responses to dynamic changes and more proactive strategies to reduce risk, as schedules must be changed in accordance with new developments. Generative scheduling does not focus on single-objective problems, such as minimizing "makespan" (the total duration of a schedule) typical in the study of "resource-constrained scheduling problems" (RCSP), but can focus on the following more general multi-objective problem: optimizing resource utilization with reference to the desired target utilization of multiple potentially competing resource categories. Additionally, multiple alternative schedules can be generated quickly, allowing users of the system to rapidly explore alternative ways to reschedule a project in response to changes that render the original schedule inappropriate or even impossible, enabling schedule changes to be made as soon as they are needed, which can be daily or even hourly, whereas rescheduling a project using traditional scheduling software would take two days or a week or more. Moreover, since existing methods typically or necessarily limit the set of potential scheduling solutions to a tiny subset of the overall possibilities, the resulting schedules typically exhibit a higher degree of optimization than what is actually possible with traditional scheduling software.

[0012] Details of one or more embodiments of the subject matter described in this specification are set forth in the accompanying drawings and the following description. Other features, aspects, and advantages of the invention will become apparent from the description, the drawings, and the claims. BRIEF DESCRIPTION OF THE DRAWINGS

[0013] Figure 1 An example of a system that can be used to facilitate computer-aided generative task scheduling is shown.

[0014] Figure 2 An example of a process for generative task scheduling is shown.

[0015] Figure 3 Another example of a process for generative task scheduling is shown.

[0016] Figures 4A to 4C An example of a user interface for resource category shaping is shown.

[0017] Figure 5Shows an example of a layered data model that can be used by the systems and / or processes described in this document.

[0018] Figure 6 Is a schematic diagram of a data processing system including a data processing device, which can be programmed as a client or programmed as a server and implement the technologies described in this document.

[0019] Figure 7 Shows another example of the process of generative task scheduling.

[0020] In the various figures, like reference numerals and names indicate like elements. Detailed Description

[0021] Figure 1 Shows an example of a system 100 that can be used to facilitate computer-aided generative task scheduling. The computer 110 includes a processor 112 and a memory 114, and the computer 110 can be connected to a network 140, which can be a private network, a public network, a virtual private network, etc. The processor 112 can be one or more hardware processors, and each of the one or more hardware processors can include multiple processor cores. The memory 114 can include both volatile memory and non-volatile memory, such as random access memory (RAM) and flash RAM. The computer 110 can include various types of computer storage media and devices, which can include the memory 114 to store instructions of a program running on the processor 112, and the program includes a generative task scheduler 116, which is one or more programs 116 for implementing task scheduling, for example, to optimize the utilization of resource categories based on the resource requirements for task completion.

[0022] Program 116 can run locally on computer 110, run remotely on a computer of one or more remote computer systems 150 (e.g., one or more server systems of one or more third-party providers accessible by computer 110 via network 140), or run both locally and remotely. In some implementations, the generative scheduling technology can be obtained via cloud-based software as a service accessed from a web browser, and the web browser can include one or more code plugins. Additionally, the generative task scheduler 116 can use an open scheduling format for the scheduled data sets, such as scheduling a data store in JSON (JavaScript Object Notation) schema, where the data set describes one or more items to be rescheduled. In some implementations, the generative task scheduler 116 includes one or more user interfaces that enable a user to create a data set that describes an initial schedule. In some implementations, the generative task scheduler 116 imports a data set that describes an initial schedule from another project or scheduling or tracking system and / or program (such as a production management product (recently renamed Process Generation Management TM ))).

[0023] In any case, the current schedule 132 (as defined by the data set) can be presented in a user interface (UI) 122 on a display device 120 of computer 110, and the user interface can be operated using one or more input devices 118 of computer 110 (e.g., keyboard and mouse). In some implementations, UI 122 provides a general Gantt chart view of the data in the current schedule for one or more items. Regardless of the presentation format of UI 122, UI 122 enables user 160 to view, introspect, and adjust the resource utilization of one or more projects open in the generative task scheduler 116. Thus, the generative task scheduler 116 can be used as a scenario planner, regardless of whether the generative task scheduler 116 is also used as a primary resource tracking system.

[0024] Note that although in Figure 1Shown as separate devices herein, the display device 120 and / or the input device 118 may also be integrated with each other and / or with the computer 110, such as in a tablet computer (e.g., a touch screen may be the input / output devices 118, 120). Moreover, the computer 110 may include or be part of a virtual reality (VR) and / or augmented reality (AR) system. For example, the input / output devices 118 and 120 may include a VR / AR input controller, gloves or other manual manipulation tools 118a, and / or a VR / AR headset 120a. In some instances, the input / output device may include a sensor-based hand tracking device that tracks movement and re-creates interactions as if performed using a physical input device. In some embodiments, the VR device and / or the AR device may be stand-alone devices that may not need to be connected to the computer 110. The VR and / or AR device may be a stand-alone device with processing capabilities and / or an integrated computer such as the computer 110, e.g., having input / output hardware components such as controllers, sensors, detectors, etc.

[0025] In any case, the user 160 may interact with the generative task scheduler 116 to create multiple scheduling scenarios from a baseline schedule. In each scenario, the user 160 may add, delete, or modify time constraints, specify relative priorities, and control resource utilization goals and constraints. For each scenario, the generative task scheduler 116 may be invoked, for example, using a generative scheduling artificial intelligence (AI)-based engine to automatically generate a feasible and resource-optimized schedule. Note that as used herein, "optimized" ("optimal" or "optimization") does not mean achieving the best schedule among all possible schedules in all cases, but rather means selecting the best (or nearly best) schedule from a limited set of possible schedules that approach an ideal utilization of the multiple goals according to the schedule.

[0026] Then, one or more selected scenarios may: save their optimized scheduling data to a scheduling document 130 (locally at computer 110 and / or remotely at computer 150), where the scheduling document may be presented on a display screen; and / or export their optimized scheduling data 135 for production management or other applications 170. Other applications 170 may include physical structure (e.g., office building) construction task scheduling, manufacturing (e.g., additive and / or subtractive) machine task scheduling, animation / graphic rendering task scheduling (e.g., movie production projects), and computer resource task scheduling (e.g., predicting utilization, including prefetching computer resources and balancing competing resources for computing). As will be appreciated, different application domains may have different specific constraints on task scheduling, including potentially location-based constraints. In any case, the core workflow is one of the following: manipulating scheduling characteristics by providing simple, direct, and interactive high-level control to iterate and explore multiple alternative schedules (scenarios); and having a computer-aided generative scheduling (e.g., an AI scheduling engine) do the heavy lifting of optimizing the schedule and ensuring feasibility is retained.

[0027] Figure 2 An example of a process 200 for generative task scheduling is shown. The goal of process 200 is to optimally utilize resources in the scheduling of a project. At 205, a data set describing the schedule of one or more projects to be scheduled / rescheduled is obtained by a scheduling computer program (e.g., generative task scheduler 116 and / or scheduler 604). Obtaining 205 may include generating a data set to define the schedule or receiving / importing a data set (defining a previously specified schedule) from a project scheduling or tracking system. Generally, project scheduling involves meeting constraints, efficiently using resources, and reacting to changes. Scheduling constraints may include dependencies (defined precedence relationships), time constraints (defined relationships with time points), and bounds (defined intervals within which an activity can start or end). Resources may have categories (defined resource types related to the project), requirements (defined workloads for various resource categories), and goals (defined ideal utilization over time for various resource categories). The data set obtained at 205 may include a work breakdown structure of the tasks to be scheduled, resource requirements (e.g., workloads for each resource category), dependencies between tasks, and optionally one or more scheduling constraints in addition to dependencies (e.g., at least one time constraint, which may be shared by two or more projects).

[0028] A work breakdown structure may be described (or derived from) based on standard scheduling terminology that details a set of activities to be scheduled arranged in a hierarchical structure. Activities may be tasks, milestones, or summaries. A task may represent an activity that requires a specified set of resources (resource requirements) for a specified work duration, where each resource requirement consists of the required resource category and the number of units of the required category. A milestone may indicate a key point in the schedule that indicates the start or end of a sub-section of the overall schedule. A summary may consist of a group of activities. Each activity may describe dependencies (precedence relationships) to any other activity, as well as specific time constraints, applicable work time calendars, and other parameters. Precedence relationships do not necessarily indicate that activities follow their temporal dependencies strictly. Instead, precedence relationships may describe how the expected activities are related in time. In some implementations, the input data set is a data model described in an open scheduling format schema (e.g., a JSON-based manifest where the description model is defined as part of generative scheduling product development). In some implementations, a Python library is provided to enable the programmatic construction of the open scheduling format.

[0029] Since the goal of process 200 is to optimally utilize resources in the scheduling of a project, and since the number of possible alternatives for the schedule can be very large (for a typical project such as a movie production project, there are approximately millions or billions of possible schedules, where multiple projects can run simultaneously, share resources, and each project can include tens of thousands of activities and hundreds of thousands of tasks), an exhaustive search of the entire scheduling space is not feasible. Thus, the resulting "optimized" schedule is one that provides a good compromise between the best utilization of each of the competing resource categories and has the ability to quickly generate new schedules to facilitate a user's exploration of the trade-offs between schedules with different resource availabilities (timing and / or quantity) or time constraints to determine "right-sizing", minimize risk, and manage costs.

[0030] At 210, variants of the schedule are generated by a scheduling computer program (e.g., generative task scheduler 116 and / or scheduler 604). Each of the variants of the schedule may have different characteristics that determine when each task in the schedule is scheduled in time, and each of the variants may satisfy the resource requirements, dependencies, and optionally one or more scheduling constraints in addition to the dependencies. In some implementations, the set of two or more variants generated at 210 is a set of random variants, which may include pseudo-random variants. In some implementations, the set of two or more variants is deterministically generated at 210 using predefined rules and / or heuristics.

[0031] The different possible variants generated 210 can be based on the concept of floating. Any given activity can float within a time bound without causing a violation of any viable specified constraint. In some implementations, the internal representation of the data set (e.g., a layered data model, which can include a directed acyclic graph (DAG) as described below) is preprocessed to determine the maximum floating bounds for each activity. Based on this, scheduling variants can be generated by combining one of the leading viable traversals (e.g., of the DAG) with the value of each activity (e.g., within the range [0..1]), defining the relative free floating amount to be used, but scheduling all predecessors according to the traversal order. In some implementations, two or more numerical values are encoded for each activity. Additionally, during generation 210, the utilization of each resource class can be accumulated.

[0032] At 215, a scheduling computer program (e.g., the generative task scheduler 116 and / or the scheduler 604) selects among different characteristics of the tasks in the scheduling variants to form a revised schedule for one or more projects. In some implementations, generation 210 and selection 215 are performed by an evolutionary AI algorithm. Further details of such implementations are described below, but other algorithms can be used in various implementations, including other AI algorithms or iterative heuristic algorithms such as the branch and bound algorithm. Generally, any suitable algorithm (multi-objective optimization algorithm) that handles multi-objective optimization problems can be used. Additionally, the results of generation 210 and selection 215 can be a single revised schedule or more than one revised schedule.

[0033] In any case, the set of generated schedules can be evaluated according to one or more objective measures (e.g., one or more numerical values can be evaluated for each objective), and a subset is selected based on the objective measures, attempting to include both the best solutions while maintaining diversity. Then, this subset can be used, for example, in the genetic algorithm concept using pseudo-gene reproduction operators (crossover and mutation) to generate a new set. This process can be repeated through subsequent generations until certain stopping criteria are met, leaving an evolved set of solutions. In some implementations, a measure of meaningful improvement relative to the previous generation can be used as a stopping criterion in combination with a fixed maximum determined according to scheduling complexity or acceptable time to produce the result.

[0034] The generative process can learn values that contribute to generating good schedules, where "goodness" is classified according to the objectives. The final set of solutions can be the output result, presenting a set of solutions optimized according to the measure. In some cases, the output result is a single solution for the schedule, but in other cases, multiple solutions can be presented, showing different trade-offs due to the multi-objective problem of the schedule. In some implementations, each of the final solutions has an associated simple metric that indicates (for each objective measure, e.g., for each resource category) its similarity to the desired optimal utilization objective.

[0035] Note that the core criteria for evaluating the quality of a schedule can include a multi-objective (usually multiple objectives) formulation. Specifically, the objective is to optimize the resource utilization of each resource category required for the schedule. For each resource category, this resource utilization can be calculated as a time series during schedule generation. This forms a set of data that has a high similarity to a (discrete) probability distribution function. A single-objective measure can be formed by creating a desired distribution function for the purpose (including potentially shaping this distribution through user control, as further described below), and then the actual distribution can be compared to the ideal distribution for similarity, resulting in an objective measure / function. Note that additional objective measures related to sequential continuity, relative priority, and other factors can be introduced as additional dimensions in the multi-objective formulation. For example, the objective measure of sequential continuity can seek to minimize the amount of delay introduced between the start of a task and the completion of a related task. The objective measure of relative priority can quantify the scheduled times of two or more tasks with different priorities (related to the desired relative priorities of these tasks), regardless of dependencies.

[0036] At 220, a revised schedule for one or more items is provided by a scheduling computer program (e.g., the generative task scheduler 116 and / or the scheduler 604). This can involve presenting the revised schedule for display to the user (e.g., on the UI 122 on the display device 120 for review by the user 160) and / or for output to manage one or more items (e.g., output to the scheduling document 130 and / or output via the scheduling data export 135 for production management or other applications 170).

[0037] In some implementations, two or more revised schedules are presented 222, optionally in the case of showing the associated trade-offs (e.g., the simple metrics cited above) for different schedules, and a user selection of the preferred schedule is received 224 before outputting a particular revised schedule to manage one or more items. In some implementations, an option to reject 230 all the provided schedules is presented to the user, and then, the process 200 returns to the generation 210 of a new variant (e.g., with its newly selected parameters).

[0038] Figure 3 Shows another example of the process 300 for generative task scheduling. At 305, a data set describing the schedules of two or more items to be rescheduled is imported by a scheduling computer program (e.g., generative task scheduler 116 and / or scheduler 604). In this example, the two or more items share at least one resource category, but generally, the two or more items may each have partially or fully unrelated resource requirements. Additionally, the data set imported at 305 may include a work breakdown structure of the tasks to be scheduled, resource requirements (e.g., workload for each resource category), dependencies between tasks, and at least one time constraint for each of the two or more items.

[0039] In some implementations, the current planned utilization rate of the selected resource category (e.g., the resources selected by the user and / or at least one resource category shared by two or more items) and the calculated ideal utilization rate of the selected resource category are presented at 310 by a scheduling computer program (e.g., generative task scheduler 116 and / or scheduler 604). Then, user input is received at 315 by the scheduling computer program (e.g., generative task scheduler 116 and / or scheduler 604), which changes the shape of the calculated ideal utilization rate of the selected resource category to create a user-specified ideal utilization rate of the selected resource category. Then, a revised schedule can be formed by modifying the current planned utilization rate of the selected resource category to approximate the user-specified ideal utilization rate based on an objective function for workload distribution, which is expressed as the deviation between the utilization rate of the selected resource category and the user-specified ideal utilization rate of the selected resource category. For example, at 320, the utilization rate of at least one resource category is maximized (e.g., by executing the AI algorithms of generation 210 and selection 215 in generative task scheduler 116 and / or scheduler 604), while also satisfying at least one time constraint for each of the two or more items.

[0040] In some implementations, a revised schedule for one or more items is provided at 220 as described above. In some implementations, at least one of the revised schedules automatically becomes the new schedule and the process 300 returns to 310. Since the revised schedule can be generated very quickly, the revised schedule can be provided to the user in real time, and the process 300 can act as an effective scenario planner.

[0041] In some implementations, an evolutionary AI algorithm (also known as a genetic algorithm) is used to maximize the utilization of one or more resource categories 320. The genetic algorithm reproduction operators (crossover and mutation) require a representation of variable scheduling parameters that are subject to these operators and in a way that encourages favorable traits while maintaining diversity (avoiding premature convergence or overpopulation). Two sets of parameters that can be used to influence schedule generation are (1) the traversal order of a graph (e.g., a DAG as discussed in conjunction with Figure 5 the DAG discussed) and (2) the relative float of each activity. The float can be parameterized as a vector of length n, where n is the number of nodes in the graph and each value is in the range [0..1], representing the amount of relative float.

[0042] A second vector can also be used to encode the traversal order in the same way, where each [0..1] value represents the priority of a node in the traversal order, subject to precedence. Encoding in this way ensures that all possible variants exist and that operators suitable for the problem domain can be used. In addition, these operators can be made to ensure that the offspring produced will all constitute a feasible schedule. In some implementations, simulated binary crossover and polynomial mutation are used because of their good properties in this regard.

[0043] In addition, in some implementations, the specific ranking and selection criteria used during the evolutionary process are based on the Adaptive Geometry Estimation technique for Multi-objective problems (AGE-MOEA), which uses non-Euclidean geometry to estimate the Pareto optimal front of a multi-objective problem. For each generation, this algorithm ranks a set of schedules using a non-dominated sorting method based on a multi-valued objective measure (for each resource category) and then estimates the Pareto optimal front and selects candidates for the parents to form the next generation based on a complex survival score to purposefully sample this front with diversity coverage.

[0044] Finally, in various implementations, additional optimization and metaheuristic methods can be interleaved in both the schedule generation and the evolutionary process. These can include: local iterative search to attempt to meet strict constraints on maximum utilization; local improvement of the results based on bi-directional alignment and refinement; and a pre-conditioned distribution function to seed an initial set of schedules based on heuristics that promote continuity within the work breakdown structure hierarchy.

[0045] Figure 4A An example of a user interface (UI) 450 is shown that presents multiple resource categories associated with one or more items to be rescheduled. Figure 4BShows UI 450 after resource category 455 has been selected, where UI 450 shows the actual utilization of resource category 455 in the current schedule by showing time on a first axis 470 and showing workload on a second axis 472. Additionally, UI 450 shows UI element 460 ( Figure 4B the box in), which represents the theoretically ideal resource utilization that can be automatically calculated based on the earliest possible start date and the latest possible end date of one or more activities (each including multiple tasks) in one or more projects using this resource category (i.e., based on scheduling constraints). Then, resource shaping can be used to allow the user to interactively modify the theoretically ideal resource utilization through UI 450.

[0046] To facilitate this process, UI element 460 can include one or more parts that the user can directly modify to change the start date of using the selected resource category and / or the end date of using the selected resource category. For example, the user can select and drag start date UI element 462A and / or end date UI element 462B to adjust the start and end dates of using the selected resource category. As another example, the user can select and ramp up curve UI element 464A and / or ramp down curve UI element 464B to modify the ramp up and ramp down curves of the workload for the selected resource category. In some implementations, Bezier curves are used to define the ramp up and ramp down curves, but various types of UI elements can be used.

[0047] Figure 4C Shows UI 450 after the start date has been advanced and the ramp up and ramp down curves have been adjusted. As will be understood, this is merely an example of the type of modification that the user can make. In some implementations, changing the start or end date using UI element 460 causes the system to automatically recalculate the total area under UI element 460 (for resource utilization purposes) based on all work scheduling calendars (which can be non - consecutive work days) and scheduling constraints. Additionally, in some implementations, changing the ramp up or ramp down using UI element 460 causes the system (e.g., an AI algorithm) to automatically optimize the schedule to achieve the specified target workload ramp up and / or ramp down.

[0048] Therefore, resource shaping via UI element 460 accomplishes two things: (1) It provides high-level control to create an actual real-world objective function for the scheduling computer program to use resource utilization when optimizing the schedule; and (2) it is user-friendly because a graphical user interface (GUI) can be provided to the user to provide a general description of what the resource utilization should be like, and then let the scheduling computer program figure out how to derive the correct objective function and update both the resource utilization goal in real time, and then use both to determine a revised schedule for this new resource utilization goal. Note that this adjustment via UI 450 not only changes the objective function that the scheduling computer program can use to accomplish the optimization; the adjustment also uses the objective function as a form of control over the schedule.

[0049] The ideal distribution definition can be combined with time constraints as a method for high-level control and manipulation. Additionally, rather than simply representing and / or deriving the model distribution function as a fixed quantity, a user-defined monotonic curve can be utilized to represent and / or derive the model distribution function. It should also be noted that according to the work schedule, the amount of time available for work on a given day varies daily. Therefore, when calculating the area, the area is not a simple sum / integral, but is calculated over discontinuous time. Calculating the distribution function with non-uniform and discontinuous independent variables is important for real-world problems with different work schedules (including varying work hours each day).

[0050] Referring again to Figure 1 , in some implementations, the objective function for the work distribution uses non-uniform and discontinuous independent variables that represent clock time 116a as the cumulative available work time amount that monotonically increases since the start time. The computer resources required to perform the schedule graph evaluation are dominated by indexing forward and backward in time according to a certain clock. However, in real-world scheduling, the clock can be both discontinuous and non-uniform (but monotonic). Additionally, there can be many different clocks within the same schedule, and key operations for the scheduling computer program may require transformation from one clock space to another. Using non-uniform and discontinuous dependent variables representing clock time 116a facilitates both indexing forward and backward in time (since this can be done within the shared clock time 116a) and transformation from one clock space to another (since each different clock space can be easily converted to or from the shared clock time 116a).

[0051] In some implementations, the system provides access mode 116b, including both a concurrency-safe lazy construction mode and a high-performance lock-free read-only mode for evaluating clock time 116a. For both modes, indexing and increment calculations can be done against a monotonic cumulative representation of available working time, which allows an efficient binary search method to increment in discontinuous and non-uniform time. Additionally, the time can be aligned with the start of a normalized day to factor out time zone information. The clock for a day can be represented as the number of working seconds (relative time) versus absolute time. This is efficient for certain scheduling scenarios (although not for general time / clock representations), and thus reduces the computational resources required to perform generative scheduling as described in this document.

[0052] In some implementations, a target function is defined for each resource category (which can be further restricted to each item), taking into account the total workload to be scheduled. The ideal target function can be described as the discrete distribution of the workload over a certain time range. The integral of the ideal target function should equal the total workload. Given a particular scheduling variant, the actual discrete distribution of the work can be calculated. The measure of the divergence between the actual and the ideal serves as the value of the target function.

[0053] The ideal distribution can be derived by scaling the unit distribution such that the discrete integral (or just the area under the distribution curve) equals the total workload. Common distributions can be defined using: start and finish points in time, and optionally points at which the distribution "ramps" up to its peak and "ramps" down from its peak. The interpolation between the start / finish points and the ramp points can use a Bézier curve as described above, or the interpolation can be linear or some other suitable non-linear definition. Note that the calculation of the scaling factor for the unit distribution should factor in that the scaling factor is non-uniform (in terms of the available workload that can be assumed) or discontinuous in the time dimension. Additionally, in addition to defining the intended distribution, the start and end points of the ideal curve also serve as constraints such that the start and end points form bounds for the earliest allowable start time and the latest allowable finish time for tasks that require this resource category.

[0054] Refer again to Figure 4B, the adjustment of the control points 462A, 464A, 462B, and 464B of the ideal curve 460 can result in the scaling of the real-time calculated workload distribution such that, according to the calculation requirements defined above, its integral matches the total workload. Additionally, the time series of the available capacity for the resource category can be referred to. Then, the ideal curve 460 can be clipped (if necessary) to ensure that the ideal curve does not exceed the available variable capacity, and the scaling of the resulting ideal curve compensates for any capacity clipping. In some implementations, the scheduling computer program continuously calculates the number of resources required based on the work to be done and the work schedule (including non-working days and scheduled overtime) in response to user editing of the ideal curve 460 for the resource category.

[0055] The scheduling definition can include one or more work schedules (or work-time calendars), where each work schedule defines the amount of work time available on a given date. Each task has an associated work schedule. When generating a schedule, each task will obtain the earliest possible start time based on its preceding scheduled time (according to dependencies) and optional constraints. To calculate the actual scheduled start time, the earliest start time should be transformed into the work-time calendar of the task to be scheduled. And, to calculate the completion time of a task, the duration within the work time should be added to the start time in the work-time calendar of the task. This involves calculating time increments / offsets (essentially additions) in a non-uniform and discontinuous space. Accomplishing this efficiently (as described in this document) enables achieving the desired (e.g., real-time) performance because the affected operations are executed a large number of times during the rescheduling of real-world projects. Additionally, it is also useful to support the concept of date / time being independent of time zones. Without this efficient method, iterative forward search and incrementation would be required, which would require many steps forward when the duration is not very short, while the workload would increase relative to the length of the duration.

[0056] To achieve the desired efficiency, the work schedule for the range of interest can be transformed into the cumulative amount of work time starting from a given start point. Specifically, the start date is defined as the number of seconds since a certain epoch in Coordinated Universal Time (UTC). For each subsequent day, in the entry for the clock (referred to as a "timesheet"), the cumulative amount of work time (including the end of the current day) is stored. This defines a clock that is not affected by time zones (i.e., relative time), which may be non-uniform and discontinuous. The efficiency comes from leveraging this distribution of the clock. Thus, given any point in time, a binary search can be used to find the interval in which the time point exists and then convert from the cumulative time to relative time to obtain the actual date and time, which can then be simply transformed into the actual date / time. For example, even in the case where the total schedule duration is approximately three years, for any duration up to three years, at most ten increments are required. Using a pure forward search strategy, any duration of ten days or longer (and potentially shorter) would exceed this time and be inefficient in terms of scaling. Additionally, these timesheets can be constructed greedily (including in a multi-threaded context) and then continuously queried using a read-only lock-free implementation 116b to achieve even further improved performance.

[0057] To complete the rescheduling of a project, the calendars associated with multiple resources are evaluated multiple times, and each of these calendars can have different workdays and different available hours on each workday. The custom clock implementation allows each different work calendar to be represented in universal time, where the clock represents how much available work time has passed since the start of the project's time. Thus, a single clock time for a resource can correspond to many different real clock times, and the clock time for this resource only advances during the work hours for this resource. This implementation of the clock enables an efficient search for the actual time point during rescheduling (e.g., using a binary search algorithm), and thereby provides high performance on a large scale. Note that a unique clock can be implemented not only at the individual resource level but also at the individual task level. Each task can have its own unique clock time because a task may require more than one resource, and such a task will have a composite calendar that covers all the resources required for this task.

[0058] In addition, Figure 5An example of a layered data model 500 is shown, which can be adopted by the systems and / or processes described in this document to reduce the computing resources used and / or reduce the bandwidth consumed by computer communication between program 116 on local computer 110 and program 116 on remote computer 150, thereby enabling the computer to actually execute the scheduling process for complex real-world projects within a reasonable amount of time by reducing the operation latency between a user performing an operation on the UI and the result of the operation being displayed. The layered data model 500 can be understood as three layers (although there does not need to be a strict boundary between each of these three layers), where each layer differs in terms of what is modeled in this layer and the way this layer is persisted (saved for long-term storage) and transported (transmitted over the network).

[0059] Although different numbers of layers can be used in various implementations, the layered data model 500 is designed to address the following problem. A fundamental property of the scheduling graph model is that local changes can have a propagation effect on some (or all) of the nodes in the graph. In desktop applications where the dataset resides, this is usually not a problem. However, in cloud-based services, there is persistence on the server side while the data is delivered to the client via a certain network protocol. As the size of the dataset grows, this can cause problems because a single local change may require (a) reloading and repersisting the entire data model; and / or (b) retransmitting the entire data model. This problem is typical in REST APIs (Representational State Transfer Application Programming Interfaces) in a service or microservices architecture. These problems are also exacerbated when using a multi-tenant and / or serverless architecture where cache coherence is difficult to achieve. The layered data model 500 can be used to achieve composability (i.e., sub-components implemented by a program, such as modular software routines, can be easily combined to form a complex system), rather than using REST mechanisms to propagate local edits, which can lead to an overload of the network connection and a significant increase in operation latency due to the high level of sending and receiving data from the cloud.

[0060] In some implementations, the first layer 505 of the three-layer data model specifies the topology of a graph representing a schedule. This first layer represents most of the immutable data topology of the graph and can also represent a point-in-time view of mutable attributes. Essentially, a relatively fixed schedule topology (encoding work breakdown structure and schedule topology are basic planning, as shown in the figure) is established across a certain number of schedules. For example, a generated or imported data set (e.g., a JSON-based manifest) can be transformed (for internal system representation) into a single-partition directed acyclic graph (DAG). This DAG is based on precedence relationships from the input model but can also include the transformation of all hierarchical constructs and constraints into a single unified DAG model for efficient evaluation. The internal representation can be optimized specifically for schedule generation and can include a discontinuous monotonic clock (clock time 116a) that implements deduplication for calculating time offsets with multiple work calendars.

[0061] The second layer 510 of the three-layer data model specifies at least edit operations that make local changes to the first layer. As shown in the figure, sparse edit operations can be used as modifiers to the underlying schedule topology. These edit operations can be embedded and composed into an evaluation graph 515 (network) that can operate at runtime. In addition, schedule variant encodings can go into a separate data stream that is composed and layered on top of the evaluation graph 515, which facilitates high-performance caching, data delivery, and execution of edit operations that may cause a large number of changes to propagate in the overall resulting composite evaluation data structure but can be described by small local changes in the layered data model in a guaranteed reproducible manner.

[0062] The third layer 520 of the three-layer data model specifies a graph representing a schedule, including all details of the dependencies between tasks in the schedule and all scheduled start and end times of the tasks in the schedule. In addition, the third layer 520 can include in the specification of the graph representing the schedule characteristics that define schedule variants and other parameters that determine the potential range of changes for each task. The third layer can be understood as a flattened layer containing the highly variable nature of the entire graph with propagation effects.

[0063] In addition, in some implementations, the scheduling computer program runs at least on a server computer 150 that is remote from the client computer 110 operated by the user. The first layer 505 of the layered data model 500 is fully loaded into the memory of the client computer 110, and updates to the second layer 510 in response to edit operations are performed locally and concurrently on the client computer 110 and persisted to the server computer 150. In some implementations, in addition to server-side storage and operations, the client 110 also has a three-level cache in memory for maintaining current and recent working sets, and the three-level cache can be implemented as an embedded service running on different threads. The cache can be used to supplement (fill or populate) the complete evaluation data structure by loading the first layer 505 from the cache, applying the second layer 510, and then evaluating to generate the third layer 520.

[0064] The combination produces an efficient and complete real-time data model. During an edit operation, the only data that needs to be transferred over the network is the locally changed attributes (elements of the second layer). The changes can be persisted (and potentially operated on) from the client cache to the server side, and the results of the operation can be evaluated optimistically and deterministically.

[0065] In some implementations, a common component 550 that forms the layered data model implementation can be utilized across the platform architecture. On the server computer (which can include a transient serverless runtime), the operation on the layered data model can be deployed and / or compiled from the native language of the operation (e.g., the Go open-source programming language) and optionally using GraphQL (or a similar API query language). For larger-scale computing requirements (optimization processes being run, e.g., when the user finishes making changes and triggers optimization of the schedule), the same implementation can be deployed, but multi-threading can be used to generate results faster. For example, each solution runs multi-threadedly on many (50 to 100, or 64 to 100, 500, 1000 or more) central processing units (CPUs) 150, and in some implementations, a scalable worker pool can be used. Note that using multi-threading with independent evolution (e.g., generation in an evolutionary AI algorithm) in the respective threads can provide a significant improvement in processing time (up to a 100-fold improvement) compared to running the solution in a fully serialized manner. Finally, the application on the client computer can include embedded microservices and may include a multi-level cache (as described above), where the same operations are performed on the layered data model compiled into WASM (WebAssembly) components.

[0066] In such implementations, the exact same code can be used to make the composable evaluation graph available, which runs in a compute engine, in a serverless scalable component from an API, or in a microservice compiled into WebAssembly and embedded with a communication protocol within the Web client itself. Thus, despite the cloud-based service model, a consistent graph structure and a consistent interface for data access are provided, where optimization can be easily done in real time, such that edits to constraints affecting large amounts of data can be computed nearly in real time (e.g., in real time) within the client application (e.g., within a browser program) and results are presented to the user.

[0067] Figure 6 FIG. 4 is a schematic diagram of a data processing system including a data processing device 600, which can be programmed as a client or as a server and implements the techniques described in this document. The data processing device 600 is connected to one or more computers 690 via a network 680. Although only one computer is shown as the data processing device 600 in Figure 6 FIG. 4, multiple computers can be used. The data processing device 600 includes various software modules that can be distributed between the application layer and the operating system. These can include executable and / or interpretable software programs or libraries, including tools and services for one or more schedulers 604 that implement resource category utilization optimization. The scheduler 604 can be a project scheduler or a project tracker, or the scheduler 604 can be an add-on component to a project scheduler or a project tracker. In any case, the scheduler 604 can provide scenario planning functionality to evaluate the trade-offs associated with various possible schedules. The number of software modules used can vary depending on the implementation. Additionally, the software modules can be distributed across one or more data processing devices connected by one or more computer networks or other suitable communication networks.

[0068] The data processing device 600 also includes hardware or firmware devices, including one or more processors 612, one or more additional devices 614, a computer-readable medium 616, a communication interface 618, and one or more user interface devices 620. Each processor 612 is capable of processing instructions for execution within the data processing device 600. In some implementations, the processor 612 is a single-threaded or multi-threaded processor. Each processor 612 is capable of processing instructions stored on the computer-readable medium 616 or a storage device (such as one of the additional devices 614). The data processing device 600 communicates with one or more computers 690 using the communication interface 618, for example, via a network 680. Examples of the user interface device 620 include a display, a camera, a speaker, a microphone, a haptic feedback device, a keyboard, a mouse, and VR and / or AR devices. The data processing device 600 may store instructions for implementing operations associated with the above programs on, for example, the computer-readable medium 616 or one or more additional devices 614 (such as one or more of a hard disk device, an optical disk device, a magnetic tape device, and a solid-state memory device).

[0069] Figure 7 Another example of the process 700 for generative task scheduling is shown. At 705, a data set defining a schedule for one or more items to be scheduled / rescheduled is defined by a scheduling computer program (e.g., the generative task scheduler 116 and / or the scheduler 604). The definition 705 may include obtaining 205, importing 305, presenting 310, and / or receiving 315, as described above. Additionally, presenting 310 may include presenting the current (or default) set of priority values assigned to tasks sharing one or more specified resource classes, and receiving 315 may include receiving user-specified changes to the priority values assigned to tasks.

[0070] This allows the user to define soft time constraints for the schedule, which encourage scheduling important items and / or tasks as early as possible. As noted above, additional objective measures related to relative priorities can be introduced as additional dimensions in the multi-objective formulation. In many cases, it is desirable to be able to specify that a task requiring a resource class is relatively more important than another task also requiring the same resource class. Specifically, if possible, the relatively less important task should be scheduled to start at or after the scheduled start time of the relatively more important task. However, relative priorities should not be strictly enforced at the expense of optimizing resource utilization. Thus, relative priorities can be defined as an objective function rather than a constraint.

[0071] Accordingly, the user interface can be designed to allow a user to add a priority value (e.g., an integer from 0 to 100) to guide a multi-objective optimization algorithm (e.g., the evolutionary AI algorithm described above) to order tasks in a manner preferred by the user. Accordingly, one or more additional objective functions in addition to the objective function for job distribution can be used to complete generating and selecting 710 to form a revised schedule, the objective function being expressed as the deviation of the current utilization rate of a specified resource class from the ideal utilization rate of the specified resource class (as described above in connection with generating 210, selecting 215, and maximizing utilization 320). In some implementations, the one or more additional objective functions include an objective function for job distribution, the objective function being expressed as the deviation of the current time ordering of tasks using a specified resource class from the ideal time ordering of tasks using the specified resource class, wherein the ideal time ordering of tasks is determined from the priority values assigned to tasks using the specified resource class. Accordingly, at 710, generating and selecting 710 to form a revised schedule can be completed by a scheduling computer program (e.g., the generative task scheduler 116 and / or the scheduler 604) using additional objective functions related to the relative priorities of the various tasks to be scheduled.

[0072] In some implementations, this is done using a vector to represent each set of tasks for a resource class that needs to be shared, where the current time ordering of a task for this shared resource is defined by the current position of the task referenced in the vector, and the ideal time ordering of the task is determined by reordering the tasks in the vector based on the assigned priority values. Then, the runtime evaluation of the relative priority objective involves a simple comparison of the vectors to assess the deviation between the ideal time ordering of the tasks and the current time ordering of the tasks. Note that this deviation-based objective measure of relative priority is very similar to the deviation-based objective measure of the current utilization rate of a specified resource class described above.

[0073] For example, given a defined set of n unique but arbitrary integer priority values assigned to tasks that require a given resource class, we can normalize the set of relative priorities to a sequence of integers [1..n]. Given a set of m tasks that require the same resource class, we can then derive an objective vector of length m, each element being the normalized priority value of a task, and the vector being sorted in priority order. For example, for a set of 9 tasks with 3 unique priority values, this would result in the vector [1,1,1,2,2,2,3,3,3]. Similar objective vectors can be derived for each resource class.

[0074] When evaluating the schedule, a similar vector is created for each resource category, but now it is sorted according to the scheduled start time of the tasks. For example, a possible vector [1,1,1,2,2,3,2,3,3] is generated. The objective function can be derived, which measures the divergence between the priority and the target priority ordering. For example, the L2 norm that measures the distance between two vectors is used, or another divergence metric such as the Kullback-Leibler or Jensen-Shannon divergence. Using this method ensures that the greater the divergence of the individual elements of the vector, the more exponentially scaled the objective measure will be. For example, the objective value for the above example will be 2 0.5 (1.4142), while the divergence value for [1,1,3,2,2,2,1,3,3] will be 8 0.5 (2.8284). Additionally, on a per-resource-category basis, the weights of the relative priority and utilization objectives can also be scaled to give equal or preferential weights. For example, for a given resource category, the evaluated objective function value can be considered as a single combined and normalized objective function, where if the objective value for utilization is u, the objective value for priority is p, and the importance of priority is w, where w is in [0..1], then the combined objective function r = w*p+(1 - w)*u, such that a value of w = 0.5 gives equal importance to both priority and utilization, and a value of w = 0.8 gives considerably more importance to priority compared to utilization.

[0075] In addition, in some implementations and when defining two or more items, a two-round approach is used for scheduling / rescheduling. Two or more items may share one or more resource categories and thus need to be scheduled / rescheduled together as part of an all-inclusive item. For such all-inclusive item scheduling, the user may want the tasks in each defined sub-item to be kept close in time, even if this may not be appropriate when there are other sub-items competing for the same resources. To achieve this goal, generation and selection can be performed in two stages. The generation and selection in the first stage 710 will apply relative floating (as described above) at the item (or sub-item) level to the scheduling variants, and the generation and selection in the second stage 715 will apply relative floating at the activity (or task) level. Note that in some implementations, the generation and selection 715 can also employ a second objective function for relative priority, as described above. Additionally, the two-stage method described now can be implemented as an additional dimension in a multi-objective formulation in combination with using or not using the above additional objective measure related to sequential continuity (seeking to minimize the amount of delay introduced between the start of a task and the completion of a related task).

[0076] As noted above, the two-phase method may include generation and selection 710 of a first phase that applies relative float at the item or sub-item level to schedule variants. Additionally, each sub-item may be a predefined and / or user-defined block of a work breakdown structure (WBS) within a single item or two or more items that need to be coordinated. Thus, the two-phase method can be used within a single item at the sub-item level in the first phase.

[0077] When tasks are scheduled to optimize resource utilization, individual tasks may be delayed from their earliest start times. Selecting a delay amount to apply to a given set of tasks that require the same resource class may result in an undesired lack of continuity in a common subset of the work breakdown structure (WBS). For example, consider two unconnected subtrees of the WBS, each consisting of three related tasks, A 1 , B 1 , C1 and A 2 , B 2 , C 2 . And, where tasks A 1 and A 2 require resource class A, and the same is true for B and C. The schedule shown in Table 1 below demonstrates an optimized use of each resource class.

[0078]

[0079] Table 1

[0080] However, compared to the alternative schedule shown in Table 2 below, the first work breakdown (A1, A2, A3) shown above has an undesired interruption in terms of continuity.

[0081]

[0082]

[0083] Table 2

[0084] Although this is a simple example, in a schedule with thousands of subtrees of the WBS, ensuring reasonable continuity while optimizing resource utilization rates results in astronomical possible arrangements.

[0085] Using the concept of a multi-resolution method (conceptually similar to the multi-grid method in numerical algorithms), the population of schedules in the evolutionary algorithm can be pre-conditioned in the first phase of the two-phase method. First, the initial population is constrained such that the subtrees of the WBS are delayed in blocks, i.e., delayed in units of subtrees, where A 1 -> B 1 -> C 1 (in a leading relationship), only A 1 can be delayed, while B1 and C 1 Then it will be scheduled as soon as possible in accordance with its precedence relationships and other constraints. This can be referred to as block constraints (where relative floating is applied to the entire block rather than to activities or tasks). The evolutionary algorithm running at this stage has coarser (lower resolution) results as its outcome, but continuity is strictly maintained. Next, the block constraints are removed, and the second stage of the evolutionary algorithm is carried out. However, the population is now pre-conditioned in order to obtain high-resolution results, but tends to retain the desired continuity. In addition, in this second stage, an objective measure of continuity (the optional amount of delay used) can be introduced to add additional pressure to retain continuity.

[0086] Generally speaking, in the first stage, projects (or sub-projects) are moved back and forth to generate different scheduling options for selection, and in the second stage, activities (or tasks) are moved back and forth to generate different scheduling options for selection. Therefore, when generating the initial rough schedule, the tasks within each project (or sub-project) are kept together in the first stage, and then in the second stage, not much task movement is required in the schedule to reach the optimal solution. The final resulting schedule provides more sequential continuity within each project (or sub-project) as expected by the user, without requiring the use of a sequential continuity objective function as an additional dimension in the multi-objective formulation.

[0087] Embodiments of the subject matter and the functional operations described in this specification can be implemented in digital electronic circuitry, or in computer software, firmware, or hardware (including the structures disclosed in this specification and their structural equivalents), or in combinations of one or more of them. Embodiments of the subject matter described in this specification can be implemented using one or more computer program instruction modules encoded on a non-transitory computer-readable medium for execution by, or to control the operation of, a data processing apparatus. The computer-readable medium can be a manufactured product, such as a hard disk drive in a computer system, or an optical disc sold through a retail channel, or an embedded system. The computer-readable medium can be obtained separately and later encoded with one or more computer program instruction modules, for example, after one or more computer program instruction modules are delivered via a wired or wireless network. The computer-readable medium can be a machine-readable storage device, a machine-readable storage substrate, a memory device, or a combination of one or more of them.

[0088] The term "data processing apparatus" encompasses all apparatus, equipment, and machines for processing data, including, by way of example, a programmable processor, a computer, or multiple processors or computers. In addition to hardware, the apparatus may also include code that creates an execution environment for the computer program being discussed, for example, code that constitutes processor firmware, a protocol stack, a database management system, an operating system, a runtime environment, or a combination of one or more of them. Further, the apparatus may adopt various different computing model infrastructures, such as web services, distributed computing, and grid computing infrastructures.

[0089] A computer program (also referred to as a program, software, a software application, a script, or code) can be written in any suitable form of programming language, which includes compiled or interpreted languages, declarative or procedural languages, and the computer program can be deployed in any suitable form, including deployment as a stand-alone program or as modules, components, subroutines, or other units suitable for use in a computing environment. A computer program does not necessarily correspond to a file in a file system. The program can be stored in a part of a file that holds other programs or data (for example, one or more scripts in a markup language document), in a single file dedicated to the program being discussed, or in multiple cooperating files (for example, files that hold one or more modules, subroutines, or portions of code). The computer program can be deployed to execute on one computer or on multiple computers distributed at one site or across multiple sites and interconnected by a communication network.

[0090] The processes and logical flows described in this specification can be performed by one or more programmable processors that execute one or more computer programs to perform functions by operating on input data and generating output. The processes and logical flows can also be performed by dedicated logic circuitry and the apparatus can also be implemented as dedicated logic circuitry systems, such as, for example, an FPGA (Field Programmable Gate Array) or an ASIC (Application Specific Integrated Circuit).

[0091] Processors suitable for executing computer programs include, for example, both general and special purpose microprocessors, as well as any one or more processors of any kind of digital computer. In general, a processor will receive instructions and data from a read only memory or a random access memory or both. The basic elements of a computer are a processor for executing the instructions and one or more memory devices for storing the instructions and data. In general, a computer will also include one or more mass storage devices for storing data, such as, magnetic disks, magneto-optical disks, or optical disks, or be operatively coupled to receive data from or transfer data to the one or more mass storage devices, or both. However, a computer need not have such devices. Moreover, a computer may be embedded in another device, such as a mobile telephone, a personal digital assistant (PDA), a mobile audio or video player, a game console, a global positioning system (GPS) receiver, or a portable storage device (e.g., a universal serial bus (USB) flash drive), to name just a few. Devices suitable for storing computer program instructions and data include all forms of non-volatile memory, media, and memory devices, including, for example: exemplary semiconductor memory devices, such as, EPROM (erasable programmable read only memory), EEPROM (electrically erasable programmable read only memory), and flash memory devices; magnetic disks, such as, internal hard disks or removable disks; magneto-optical disks; and CD-ROM and DVD-ROM disks. The processor and the memory may be supplemented by, or incorporated in, special purpose logic circuitry.

[0092] To provide for interaction with a user, embodiments of the subject matter described in this specification may be implemented on a computer having: a display device, such as, a LCD (liquid crystal display) display device, an OLED (organic light emitting diode) display device, or another monitor for displaying information to the user; and a keyboard and a pointing device, such as, a mouse or a trackball, by which the user may provide input to the computer. Other kinds of devices may also be used to provide for interaction with the user; for example, feedback provided to the user may be any suitable form of sensory feedback, such as, visual feedback, auditory feedback, or tactile feedback; and input received from the user may be in any suitable form, including acoustic, speech, or tactile input.

[0093] A computing system may include clients and servers. The clients and servers are generally far apart from each other and typically interact via a communication network. The relationship between the clients and servers arises from computer programs that run on respective computers and have a client-server relationship with each other. Embodiments of the subject matter described in this specification may be implemented in a computing system that includes: backend components, such as, for example, a data server; or includes middleware components, such as, for example, an application server; or includes frontend components, such as, for example, a client computer having a graphical user interface or a browser user interface through which a user may interact with an implementation of the subject matter described in this specification; or any combination of one or more such backend components, middleware components, or frontend components. The components of the system may be interconnected by digital data communication in any suitable form or medium (e.g., a communication network). Examples of communication networks include local area networks (“LANs”) and wide area networks (“WANs”), the Internet (e.g., the Internet), and peer-to-peer networks (e.g., ad-hoc peer-to-peer networks).

[0094] Although this specification contains many implementation details, these should not be construed as limitations on the scope of what is claimed or of what may be claimed, but rather as descriptions of features that are specific to particular embodiments of the disclosed subject matter. Certain features that are described in this specification in the context of separate embodiments may also be implemented in combination within a single embodiment. Conversely, various features that are described in the context of a single embodiment may also be implemented separately in multiple embodiments or in any suitable sub-combination. Moreover, although the features may be described above as acting in certain combinations and even initially claimed as such, one or more features from a claimed combination may in some cases be separable from the combination, and the claimed combination may refer to a sub-combination or a variation of a sub-combination.

[0095] Similarly, although operations are depicted in the figures in a particular order, this should not be understood as requiring that such operations be performed in the particular order shown or in a sequential order, or that all of the illustrated operations be performed, to achieve the desired result. In some cases, multitasking and parallel processing may be advantageous. Additionally, the separation of various system components in the embodiments described above should not be understood as required in all embodiments, and it should be understood that the described program components and systems may generally be integrated together in a single software product or packaged into multiple software products.

[0096] Accordingly, particular embodiments of the invention have been described. Other embodiments are within the scope of the appended claims. Additionally, the acts recited in the claims may be performed in a different order and still achieve the desired result.

[0097] Example: Although the present application is defined by the appended claims, it should be understood that the present invention may also (additionally or alternatively) be defined according to the following examples:

[0098] Example 1. A method, the method comprising: obtaining, by a scheduling computer program, a data set describing the schedule of one or more items to be rescheduled, the data set including a work breakdown structure, resource requirements, and dependencies between the tasks to be scheduled; generating, by the scheduling computer program, variants of the schedule, wherein each of the variants of the schedule has different characteristics, the different characteristics determining when to schedule each task in a timely manner for the tasks in the schedule, and each of the variants satisfies the resource requirements and the dependencies; selecting, by the scheduling computer program, among the different characteristics of the tasks in the variants of the schedule to form a revised schedule for the one or more items; and providing, by the scheduling computer program, the revised schedule for the one or more items for display to a user or for output to manage the one or more items.

[0099] Example 2. The method according to Example 1, wherein the data set further includes one or more scheduling constraints in addition to the dependencies, and each of the variants satisfies the one or more scheduling constraints in addition to satisfying the dependencies.

[0100] Example 3. The method according to any one of Examples 1 to 2, wherein the generating and the selecting are performed by an evolutionary artificial intelligence algorithm.

[0101] Example 4. The method according to any one of Examples 1 to 3, wherein the one or more items are two or more items sharing at least one resource category, the one or more scheduling constraints include at least one time constraint for each of the two or more items, and the generating and the selecting form the revised schedule by maximizing the utilization of the at least one resource category while also satisfying the at least one time constraint for each of the two or more items.

[0102] Example 5. The method according to any one of Examples 1 to 4, the method comprising applying a hierarchical data model to the data set, wherein the hierarchical data model includes: a first layer that specifies the topology of a graph representing the schedule; a second layer that specifies at least edit operations that make local changes to the first layer; and a third layer that specifies the graph representing the schedule, including all details of the dependencies between the tasks in the schedule and all scheduled start and end times for the tasks in the schedule.

[0103] Example 6. The method according to Example 5, wherein the scheduling computer program runs at least on a server computer remote from the client computer operated by the user, the first layer of the layered data model is fully loaded into the memory of the client computer, and the update to the second layer in response to an edit operation is executed locally and concurrently on the client computer and persisted to the server computer.

[0104] Example 7. The method according to any one of Examples 1 to 6, the method comprising: presenting in a graphical user interface a currently planned utilization rate of a selected resource category and a calculated ideal utilization rate of the selected resource category; and receiving user input via the graphical user interface, the user input changing the shape of the calculated ideal utilization rate of the selected resource category to create a user-specified ideal utilization rate of the selected resource category; wherein the generating and the selecting form the revised schedule by: modifying the currently planned utilization rate of the selected resource category based on an objective function for workload distribution to approximate the user-specified ideal utilization rate, the objective function being expressed as a deviation between the utilization rate of the selected resource category and the user-specified ideal utilization rate of the selected resource category.

[0105] Example 8. The method according to Example 7, wherein the graphical user interface shows time on a first axis and workload on a second axis, and the user input changes the start date of using the selected resource category, the end date of using the selected resource category, the ramp curve of the workload for the selected resource category, the ramp-down curve of the workload for the selected resource category, or a combination thereof.

[0106] Example 9. The method according to any one of Examples 7 to 8, wherein the objective function for workload distribution uses non-uniform and discontinuous independent variables, the non-uniform and discontinuous independent variables representing clock time as a monotonically increasing cumulative available workload amount since a start time.

[0107] Example 10. The method according to Example 9, the method comprising providing both a concurrent-safe lazy construction mode and a high-performance lock-free read-only mode for evaluating the clock time.

[0108] Example 11. The method according to any one of Examples 1 to 10, wherein the generating and the selecting form the revised schedule by modifying the current planned utilization rate of the selected resource category based on (i) a first objective function for the job distribution and (ii) a second objective function for the job distribution, the first objective function being expressed as the deviation between the current utilization rate of the specified resource category and the ideal utilization rate of the specified resource category, the second objective function being expressed as the deviation between the current time sequencing of the tasks using the specified resource category and the ideal time sequencing of the tasks using the specified resource category, wherein the ideal time sequencing of the tasks is determined from the priority values assigned to the tasks using the specified resource category.

[0109] Example 12. The method according to any one of Examples 1 to 11, wherein the generating and the selecting are performed in two stages, in an initial stage of the two stages, applying a relative float for schedule variations by project or by sub - project, and in a subsequent stage of the two stages, applying a relative float for schedule variations by activity.

[0110] Example 13. A non - transitory computer - readable medium encoding a computer - aided design program operable to cause one or more data - processing devices to perform the operations according to any one of Examples 1 to 12.

[0111] Example 14. A system comprising: one or more data - processing devices; and one or more non - transitory computer - readable media encoding instructions executable by the one or more data - processing devices to perform the operations according to any one of Examples 1 to 12.

Claims

1. A method, comprising: obtaining, by a scheduling computer program, a data set describing a schedule of one or more projects to be rescheduled, the data set including a work breakdown structure of tasks to be scheduled, resource requirements, and dependencies between the tasks; generating, by the scheduling computer program, variations of the schedule, wherein each of the variations of the schedule has different characteristics that determine when each task in the schedule is scheduled in a timely manner, and each of the variations satisfies the resource requirements and the dependencies; selecting, by the scheduling computer program, among the variations of the schedule for the different characteristics of the tasks to form a revised schedule for the one or more projects; as well as The revised schedule of the one or more projects is provided by the scheduling computer program for display to a user or for output to manage the one or more projects. 2 . The method of claim 1 , wherein the data set includes one or more scheduling constraints in addition to the dependencies, and each of the variants satisfies the one or more scheduling constraints in addition to satisfying the dependencies.

3. The method of claim 1, wherein said generating and said selecting are performed by an evolutionary artificial intelligence algorithm.

4. A method according to any one of claims 1, 2 and 3, wherein the one or more projects are two or more projects that share at least one resource category, the one or more scheduling constraints include at least one time constraint for each of the two or more projects, and the generating and selecting form the revised schedule by maximizing the utilization of the at least one resource category while also satisfying the at least one time constraint for each of the two or more projects.

5. The method according to any one of claims 1, 2 and 3, comprising adopting a layered data model for the data set, wherein the layered data model comprises A first layer, which specifies the topology of the graph representing the schedule; a second layer that specifies at least an editing operation that makes a local change to the first layer; and A third layer specifies the graph representing the schedule, including all details of the dependencies between the tasks in the schedule and all scheduled start and end times for the tasks in the schedule.

6. A method according to claim 5, wherein the scheduling computer program runs on at least a server computer remote from the client computer operated by the user, the first layer of the layered data model is completely loaded into the memory of the client computer, and updates to the second layer in response to editing operations are concurrently executed locally on the client computer and persisted to the server computer.

7. The method according to any one of claims 1, 2 and 3, comprising: presenting in a graphical user interface a current planned utilization rate of a selected resource category and a calculated ideal utilization rate of the selected resource category; as well as receiving, via the graphical user interface, a user input that changes a shape of the calculated ideal usage of the selected resource category to create a user-specified ideal usage of the selected resource category; wherein the generating and the selecting form the revised schedule by modifying the currently planned utilization of the selected resource class to approximate the user-specified ideal utilization based on an objective function for work distribution, the objective function being expressed as a deviation of the utilization of the selected resource class from the user-specified ideal utilization of the selected resource class.

8. A method according to claim 7, wherein the graphical user interface shows time on a first axis and workload on a second axis, and the user input changes the start date of using the selected resource category, the end date of using the selected resource category, the ramp-up curve of the workload for the selected resource category, the ramp-down curve of the workload for the selected resource category, or a combination thereof.

9. The method of claim 7, wherein the objective function for work distribution uses a non-uniform and discontinuous independent variable that represents clock time as a monotonically increasing cumulative amount of available work time since a start time.

10. The method of claim 9, comprising providing both a concurrency-safe lazy build mode and a high-performance lock-free read-only mode for assessing the clock time.

11. A method according to claim 7, wherein the generating and the selecting form the revised schedule by: modifying the current planned utilization of the selected resource class based on (i) a first objective function for work distribution and (ii) a second objective function for work distribution, wherein the first objective function is expressed as a deviation of the current utilization of the specified resource class from the ideal utilization of the specified resource class, and the second objective function is expressed as a deviation of the current time sequencing of the tasks using the specified resource class from the ideal time sequencing of the tasks using the specified resource class, wherein the ideal time sequencing of the tasks is determined from the priority value assigned to the tasks using the specified resource class.

12. The method according to claim 1, wherein the generating and the selecting are performed in two stages, in an initial stage of the two stages, the relative float for the scheduling variant is applied by project or by sub-project, and in a subsequent stage of the two stages, the relative float for the scheduling variant is applied by activity.

13. A non-transitory computer-readable medium encoding a computer-aided design program operable to cause one or more data processing devices to perform the operations of any one of claims 1 to 12.

14. A system, comprising: one or more data processing devices; as well as One or more non-transitory computer-readable media encoding instructions executable by the one or more data processing devices to perform the operations of any of claims 1 to 12.

Images