Modeling Enterprise Architecture Using Timed Colored PETRI Net: Single Processor Scheduling

The purpose of modeling enterprise architecture and analysis of it is to ease decision making about architecture of information systems. Planning is one of the most important tasks in an organization and has a major role in increasing the productivity of it. Scope of this paper is scheduling processes in the enterprise architecture. Scheduling is decision making on execution start time of processes that are used in manufacturing and service systems. Different methods and tools have been proposed for modeling enterprise architecture. Colored Petri net is extension of traditional Petri net that its modeling capability has grown dramatically. A developed model with Colored Petri net is suitable for verification of operational aspects and performance evaluation of information systems. With having ability of hierarchical modeling, colored Petri nets permits that using predesigned modules for smaller parts of the system and with a general algorithm, any kind of enterprise architecture can be modeled. A two level hierarchical model is presented as a building block for modeling architecture of Transaction Processing Systems (TPS) in this paper. This model schedules and runs processes based on a predetermined non-preemptive scheduling method. The model can be used for scheduling of processes with four non-preemptive methods named, priority based (PR), shortest job first (SJF), first come first served (FCFS) and highest response ratio next (HRRN). The presented model is designed such can be used as one of the main components in modeling any type of enterprise architecture. Most enterprise architectures can be modeled by putting together appropriate number of these modules and proper composition of them.

💡 Research Summary

The paper presents a hierarchical timed colored Petri net (HTCPN) model for scheduling processes on a single processor, with the aim of providing a reusable building block for enterprise‑architecture (EA) modeling. The authors argue that enterprise‑architecture design, especially the operational layer dealing with workflow and scheduling, benefits from a formal, analyzable representation. Traditional Petri nets lack the ability to carry data and time together, so the authors adopt the colored‑time extension, which allows tokens to carry rich information (process attributes) and timestamps.

The model defines several color sets:

• RT – a pair of integers representing a priority’s integer and fractional parts (used because CPN Tools does not support real numbers).
• Process – a record containing process index (PI), arrival time (IT), service time (ST), waiting time (WT), execution start time (ES), and priority (PR).
• ProcList – a list of Process records.
• SCHTYPE – an enumeration of the four non‑preemptive scheduling policies examined: First‑Come‑First‑Served (FCFS), Shortest‑Job‑First (SJF), static Priority (PR), and Highest‑Response‑Ratio‑Next (HRRN).

All color sets are declared as timed so that each token carries a timestamp, enabling the simulation engine to advance time automatically.

Initial marking supplies six example processes with varying arrival times, service times, and static priorities. These serve as a case study for the four scheduling algorithms.

The HTCPN model is organized in two hierarchical layers. The top‑level net handles the overall flow: receiving the process list, selecting the scheduling policy, and collecting results. The lower‑level net implements the actual scheduling logic. Tokens flow through places representing “waiting”, “ready”, “running”, and “completed” states, while transitions fire based on time conditions and priority comparisons.

Key functions (written in the functional language of CPN Tools) include:

• curTime(): returns the current simulation time.
• onTime(q): checks whether a process’s arrival time has been reached.
• select, exists, remove: manipulate the list of processes to extract those that are ready.
• updatePR(sm,q): recomputes a process’s priority according to the selected policy. For FCFS the priority is the arrival time; for SJF it is the service time (with arrival time as a tie‑breaker); for PR it uses the static priority; for HRRN it computes ((ST+WT)/ST).
• updateProcWait(q) and updateWait(L): compute waiting times as the difference between the current time and the arrival time.
• cmp and compare: compare two priority values, taking into account that for FCFS/SJF a lower numeric value means higher priority, while for PR/HRRN a higher numeric value means higher priority.

The simulation proceeds as follows: at each time step the model checks which processes have arrived (onTime), moves them to the ready list, updates waiting times and priorities (update), selects the highest‑priority process (compare), records its start time, and lets it run for its service duration. When a process finishes, it is moved to the completed list, and the processor may become idle, generating an “idle” token that is later used to compute total idle time.

The authors run the model with the six sample processes under each of the four policies. They report average waiting time, average turnaround time, and processor idle time for each policy. The results match theoretical expectations: FCFS yields the highest average waiting time, SJF reduces waiting by favoring short jobs, PR behaves according to the static priority assignment, and HRRN balances waiting and service time, often achieving the lowest overall turnaround.

A major contribution of the work is modularity. By encapsulating a single‑processor scheduler as a self‑contained HTCPN module, the same component can be instantiated multiple times to model multi‑processor systems, pipelines, or more elaborate enterprise workflows. The use of colored tokens (records and lists) simplifies the net structure compared with models that would need separate places for each attribute, and it improves simulation performance.

The paper also discusses limitations. Only non‑preemptive policies are covered, so real‑time or interrupt‑driven environments would require extensions. The model relies on integer time units; finer‑grained timing (e.g., sub‑millisecond) would need a different representation or scaling. Finally, CPN Tools’ graphical interface and state‑space exploration become cumbersome for very large systems (thousands of processes), suggesting that integration with external simulation engines or distributed simulation techniques could be beneficial.

In conclusion, the study demonstrates that timed colored Petri nets provide a rigorous yet flexible foundation for representing and analyzing scheduling aspects of enterprise architectures. The hierarchical, parameterized design enables reuse across different architectural scenarios, and the formal semantics support verification of functional correctness and performance metrics. Future work could extend the approach to preemptive scheduling, resource constraints, and real‑time deadlines, thereby broadening its applicability to a wider range of enterprise‑level information systems.