Pith. sign in

REVIEW 2 major objections 4 minor 35 references

Analytical Performance Models for NoCs with Multiple Priority Traffic Classes

T0 review · 2 major / 4 minor · reviewed 2026-08-14 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read This paper claims that priority-aware NoC latency can be computed analytically by decomposing the network into independent queues with modified service times, matching cycle-accurate simulation to about 97% accuracy and speeding up…

desk verdict A legitimate new step for priority-aware NoC analytical models, but the headline 97% accuracy is conditional on an unvalidated independence assumption in the service-rate transformation and a calibrated residual time. read the letter →

arxiv 1908.02408 v2 pith:7QKHNFMP submitted 2019-08-07 cs.PF cs.SYeess.SY

Sumit K. Mandal , Raid Ayoub , Michael Kishinevsky , Umit Y. Ogras This is my paper · ORCID
classification cs.PFcs.SYeess.SY
keywords network-on-chippriorityarbitrationanalyticalperformancemodelqueueingtheoryGeo/G/1queueslatencypredictiondesignspaceexplorationfull-systemsimulation
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper sets out to replace slow cycle-accurate simulation of on-chip networks with a fast analytical formula. The obstacle is that production NoCs arbitrate packets by priority, and flits of different priority classes can wait in the same physical queue, so older analytical models that assume round-robin or one-class-per-queue arbitration do not apply. The authors claim that any priority-based NoC can be decomposed into separate queues by two transformations: one for the case where a high-priority queue splits into two flows, the other for the case where a low-priority queue splits into two flows. They report that the resulting end-to-end latency estimates match an industrial cycle-accurate simulator to about 97% on meshes, rings, and a production server processor, and that replacing the network simulator in a full-system simulator cuts total simulation time by up to 2.5x. If true, this gives architects a fast, accurate way to explore NoC design space under realistic priority arbitration.

What carries the argument

The central objects are two canonical queuing structures and two transformations that turn them into standard priority queues. The structural transformation (split at high priority queue) decomposes traffic at a high-priority queue by computing the coefficient of variation of class-1 inter-departure time via the input-traffic decomposition of [9], then treating the remaining two-class structure as a basic priority queue whose waiting times are given by the paper's Lemma 1. The service-rate transformation (split at low priority queue) modifies the service time and residual time of a low-priority class to account for blocking by a higher-priority class: class-3's service time becomes $T_3^* = T_3 + T_1 p/(1-p)$ with $p = \rho_1 + \lambda_1 R_3$, and its residual time $R_3^*$ is set by equating the two ways of computing $W_3$ (Equation 6 and Equation 10). Algorithm 1 iterates these two transformations over all queues and classes to produce the end-to-end waiting-time expression. The machinery is what carries the argument: it converts a messy network of shared priority queues into independent Geo/G/1 queues, each solvable by the closed-form waiting-time formula in Lemma 1.

What would settle it

Compare the proposed analytical model against a cycle-accurate simulator on the two-queue split-at-low-priority structure (Figure 8a) using a bursty class-1 arrival process, such as alternating high-injection and low-injection periods at the same average rate. If the predicted class-3 waiting time from Equation 12 deviates from simulation by more than the few percent reported for geometric traffic, the independence assumption in Transformation 2 is the cause.

Watch

Extended reading notes

Core claim

The paper's central claim is that priority-aware NoC latency reduces to a per-class waiting-time formula in which each shared queue has been replaced by an equivalent queue with modified service-time statistics. Transformation 1 (split at high priority queue) handles the case where two classes share a high-priority queue and one of them leaves at a separate output; it uses the first two moments of the inter-departure time of the competing class so that the remaining structure becomes a standard priority queue. Transformation 2 (split at low priority queue) handles the case where a low-priority class shares its output with a higher-priority class; it inflates the low-priority service time by the expected extra busy period caused by higher-priority blocking, $T_3^* = T_3 + \Delta T_3$ with $\Delta T_3 = T_1 p/(1-p)$ for $p = \rho_1 + \lambda_1 R_3$. An iterative algorithm applies these transformations queue-by-queue to produce closed-form end-to-end latency for each traffic class. The paper evaluates this recipe on ring and mesh NoCs and on an industrial server processor floorplan, reporting average accuracy of 97% versus cycle-accurate simulation and up to 2.5x speedup in full-system simulation. The claim, in short: priority arbitration in an NoC can be modeled as a network of independent Geo/G/1 queues with modified service times, without losing the accuracy needed for design-space exploration.

Load-bearing premise

The whole calculation rests on treating each block of a low-priority flit as an independent, memoryless event; if real traffic comes in bursts, so that one block tends to follow another, the predicted waiting times for lower-priority classes will be too low.

Editorial extensions

If this is right

  • For any NoC with priority arbitration and multiple traffic classes, end-to-end latency per class can be computed from injection rates, topology, and routing alone, without cycle-by-cycle simulation.
  • The same two transformations can be applied iteratively to arbitrary ring and 2D-mesh topologies, so the method scales to the 64-router mesh whose 4096 source-destination pairs would be intractable for probability-generating-function approaches.
  • Since network simulation takes 40-70% of total full-system simulation time, replacing it with the analytical model shortens full-system runtime by up to 2.5x, giving designers more simulations per day.
  • Accuracy holds across cache-coherency traffic at different cache hit rates (around 96-99% on the address and data networks) and across real application traces, with average error around 3%, though error grows near saturation (up to 11% at the highest injection rates).

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • A natural test of the paper's idea is to relax the geometric inter-arrival assumption: replace the fixed per-class injection rate with burstiness parameters estimated from traces, and recompute p and the modified service time. The paper leaves that as future work, but the two transformations are stated in terms of moments, so they could plausibly accept burstier inputs.
  • The same decompose-the-queue, inflate-the-lower-priority-service-time recipe could be applied to other shared-server arbitration policies, such as weighted round-robin or reservation-based bandwidth, by redefining p as the probability that a flit is blocked by a competing flow; the paper makes no such claim.
  • The speedup number depends on the workload: if the network consumes only the low end of the reported 40-70% of simulation time, the expected full-system speedup from replacing the NoC simulator would be closer to 1.5x than 2.5x.
  • Because the paper validates on a particular industrial architecture and a few real applications, the strongest test of generality is to run the same two transformations on other production NoC floorplans and traffic mixes; that test is not reported in the paper.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

2 major / 4 minor

Summary. The paper proposes an analytical performance modeling framework for priority-based networks-on-chip (NoCs) with multiple traffic classes sharing queues. The authors identify two canonical queuing structures that arise in industrial priority-based NoCs and introduce two transformations: a structural transformation that splits traffic at a high-priority queue, and a service-rate transformation that modifies the service time and residual time of lower-priority classes to account for blocking by higher-priority traffic. They also present an iterative algorithm that applies these transformations to decompose an arbitrary NoC into independent queues and compute end-to-end latencies per traffic class. The approach is validated against a cycle-accurate industrial simulator on ring and mesh topologies, a server-like floorplan, and PARSEC application traces, reporting about 97% average accuracy and up to 2.5x speedup of full-system simulation when replacing the cycle-accurate NoC simulation with the analytical model.

Significance. If the reported accuracy and speedup hold, this is a valuable contribution to pre-silicon evaluation of industrial NoCs, where priority arbitration and multiple traffic classes in the same queue are common but prior analytical models either assume fair arbitration or do not handle multi-class queues. The paper provides complete derivations for the discrete-time Geo/G/1 waiting-time formulas (Lemma 1 and Appendix A), a systematic decomposition algorithm, and extensive validation on realistic architectures and workloads. The two-moment decomposition for the structural transformation is standard and well grounded. The service-rate transformation is more heuristic: it calibrates the modified residual time on a special case (lambda2 = 0) rather than deriving it from first principles, and it relies on an independence assumption for blocking runs that is not directly tested. These caveats affect the generality of the central 97% accuracy claim but do not invalidate the overall approach, which can likely be strengthened with additional validation and clearer statement of assumptions.

major comments (2)
  1. [Section 4.2, Eq. (11)] The derivation of the additional busy period DeltaT3 assumes that each time a class-3 flit is blocked by class-1 traffic, the blocking events are independent and geometrically distributed with probability p = rho1 + lambda1*R3. This is a load-bearing assumption: DeltaT3 enters the modified service time T*3, the utilization rho*3, and the residual time R*3 in Eqs. (9)-(11), and these in turn determine the predicted waiting times W2 and W3 in Eq. (12). The paper does not test this assumption under bursty or correlated arrival processes, even though real application traffic is known to deviate from geometric inter-arrival times (as the authors themselves note in Section 3.2 and Section 6.5). The reported results already show accuracy degradation near saturation (11% error at the highest injection rate for 6x6 and 8x8 meshes in Section 6.4, and 93.9% accuracy for the data network at 100% LLC hit rate in Table 2), which is consistent with the Geo/G/1 assumption breaking down. The authors should either add a validation experiment with bursty/correlated traffic to support the independence assumption, or explicitly characterize the traffic conditions under which the geometric blocking model is expected to be accurate.
  2. [Section 4.2, Eq. (11)] The calibration of R*3 in Eq. (11) is a model-fitting step, not a derivation. The paper should highlight this and distinguish the calibrated prediction from the independently derived parts of the model. The current presentation gives the impression that R*3 is derived from the Geo/G/1 residual-time theory, when in fact it is chosen to match a known special case. This distinction matters for assessing the strength of the 97% accuracy claim.
minor comments (4)
  1. [Algorithm 1] In Algorithm 1, the reference waiting time W_ref is computed using Eq. 6, but Eq. 6 is specific to the two-class case. The algorithm should explain how this expression generalizes when more than one higher-priority class is present, or specify that the same form is used with sums over higher-priority classes.
  2. [Abstract and Section 6.4] The text in Section 6.4 says 'the proposed analytical models are on average 97% and 96% accurate' for the two mesh sizes, but the abstract and introduction state '97% accuracy' without this qualification. Please make the reported accuracy ranges explicit in the summary of results.
  3. [Appendix A] Equation (16) and the line following it introduce the discrete-time correction rho1; please add a sentence explaining that this term arises from the boundary of the summation for class-1 residual time, to make the derivation self-contained.
  4. [General] The manuscript contains a few instances where Cyrillic characters appear in English text (e.g., 'Q hiдh' in Section 3.2) and some figure labels are difficult to read. These should be corrected for a polished final version.

Circularity Check

1 steps flagged · score 4.0 of 10

Partial local calibration in Eq. 11 defines R*3 by construction, but the central 97%-accuracy claim rests on independent cycle-accurate simulation comparisons.

  1. self definitional [Section 4.2, Transformation 2, Equations (10)-(11)]
    "When λ2 is set to zero, this expression should give the class-3 waiting time W3|λ2=0 found in Equation 6. Hence, we can find the following expression for R∗3 by combining Equation 6 and Equation 10: R∗3 = (1− ρ∗3)(W3|λ2=0 − ∆T3) (11)"

    The modified residual time R*3 is not obtained from an independent analysis of the modified service process; it is defined as the value that forces the transformed Geo/G/1 formula in Eq. 10 to reproduce the paper's own waiting-time formula, Eq. 6, in the λ2=0 special case. Therefore, the statement that the transformed model 'should give' Eq. 6 is true by construction, and any validation of the model in that λ2=0 special case would be circular. The circularity is local: the nonzero-λ2 predictions of W2 and W3 in Eq. 12 are not forced by this definition, and the paper's headline 97% accuracy is an independent empirical comparison against cycle-accurate simulation, not a consequence of the calibration.

full rationale

The paper's central claim—97% accuracy versus cycle-accurate simulation and 2.5x full-system speedup—is an external, falsifiable comparison: no model parameter is fitted to the Garnet2.0/SystemC simulation data used in Section 6. The only by-construction step occurs in Transformation 2, where Eq. 11 defines R*3 as the value that makes the modified-service Geo/G/1 expression reproduce the paper's own discrete-time priority waiting-time formula (Eq. 6) when λ2=0. Thus the λ2=0 case is a consistency condition rather than an independent prediction; this is a mild calibration step, not a statistical fit to measured data. The subsequent predictions for nonzero λ2 in Eq. 12 use this calibrated R*3 together with the geometric blocking-run ansatz of Eqs. 7-8, so they retain genuine predictive content. The self-citations [23]-[25] are used only as caveats or as references to the in-house simulator, not to justify the transformations. The geometric i.i.d. blocking assumption near saturation is a correctness risk, not a circularity, because it is not obtained by assuming the conclusion. Overall, the derivation is largely self-contained, with a single local calibration that does not undermine the externally validated accuracy claim.

Assumptions & free parameters 0 free parameters · 5 assumptions · 2 invented entities

No free parameters are fitted to the simulator output; all inputs are measured injection rates, service times, and coefficients of variation. The central claim rests on three modeling axioms: geometric inter-arrival times, two-moment traffic decomposition, and independent blocking events for the service-rate transformation. The constructs Q1' and T*3/R*3 are analytical devices, not physical entities, and are validated indirectly through latency predictions.

assumptions (5)
  • domain assumption Flit inter-arrival times follow a geometric distribution (Geo/G/1 model)
    Adopted in Section 3.2 and used in Appendix A to derive residual times and Lemma 1; the paper acknowledges it degrades near saturation (Sections 3.2, 6.5).
  • domain assumption The first two moments (mean and squared coefficient of variation) of inter-arrival and inter-departure processes are sufficient to characterize traffic in the structural transformation
    Used in Section 4.1 via the decomposition technique from Bolch et al. [9] to compute C_D1^2 for Q1'; a standard two-moment approximation with no error bound.
  • ad hoc to paper Blocking of a low-priority class-3 flit by high-priority class-1 traffic occurs as independent geometric events with probability p = rho1 + lambda1*R3
    Invoked in Section 4.2, Equations 7-8, to compute the additional busy period DeltaT3; not justified from first principles and no sensitivity analysis is provided.
  • domain assumption Nonpreemptive priority arbitration: flits already in the network have priority over newly injected flits, and higher-class flits always win arbitration
    Assumed throughout, explicitly described in Sections 1 and 3.2.
  • domain assumption Steady-state and stationarity of traffic; injections are throttled by outstanding-request credits so interface blocking can be ignored
    Stated in Section 3.1: 'requesters are automatically throttled by these credits... we do not explicitly model blocking at the interfaces.'
invented entities (2)
  • Virtual queue Q1' in the structural transformation
    purpose: Represents the class-1 flow after removing class-2 from the shared high-priority queue, so the residual system becomes a basic priority queue (Section 4.1).
    Q1' is an analytical bookkeeping device introduced in Section 4.1; it has no directly observable physical signature. Its validity is only indirect through the model's latency predictions, which are tested against simulation.
  • Modified service time T*3 and residual time R*3 in the service rate transformation
    purpose: Absorbs the blocking effect of high-priority class-1 on low-priority class-3 into effective service statistics, enabling a single-queue Geo/G/1 analysis (Section 4.2, Equations 7-12).
    These are analytical constructs, not physical entities; R*3 is calibrated to reproduce the two-class formula, and the resulting latency predictions are compared with simulation. No independent observable handle exists outside the model's own predictions.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Analytical Performance Models for NoCs with Multiple Priority Traffic Classes." pith.science (2026). https://pith.science/paper/7QKHNFMP

@misc{pith2026190802408,
  author       = {Pith},
  title        = {Pith review of: Analytical Performance Models for NoCs with Multiple Priority Traffic Classes},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/7QKHNFMP}},
  note         = {Machine review of arXiv:1908.02408}
}
read the original abstract

Networks-on-chip (NoCs) have become the standard for interconnect solutions in industrial designs ranging from client CPUs to many-core chip-multiprocessors. Since NoCs play a vital role in system performance and power consumption, pre-silicon evaluation environments include cycle-accurate NoC simulators. Long simulations increase the execution time of evaluation frameworks, which are already notoriously slow, and prohibit design-space exploration. Existing analytical NoC models, which assume fair arbitration, cannot replace these simulations since industrial NoCs typically employ priority schedulers and multiple priority classes. To address this limitation, we propose a systematic approach to construct priority-aware analytical performance models using micro-architecture specifications and input traffic. Our approach consists of developing two novel transformations of queuing system and designing an algorithm which iteratively uses these two transformations to estimate end-to-end latency. Our approach decomposes the given NoC into individual queues with modified service time to enable accurate and scalable latency computations. Specifically, we introduce novel transformations along with an algorithm that iteratively applies these transformations to decompose the queuing system. Experimental evaluations using real architectures and applications show high accuracy of 97% and up to 2.5x speedup in full-system simulation.

Figures

Figures reproduced from arXiv: 1908.02408 by the authors.

Figure 1
Figure 1. Experiments of different applications show that 40%-70% of the total simulation time is spent on the [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. The high priority queue (Qhigh) stores two different traffic classes which are already in the NoC, while the low priority queue (Qlow) stores the newly injected flits from the local node. As flits from class–2 are routed to the local node, low-priority flits compete with only class–1 flits in Qhigh. ACM Transactions on Embedded Computing Systems, Vol. 1, No. 1, Article 1. Publication date: January 2019 [PITH_FULL_I… view at source ↗
Figure 3
Figure 3. Overview of the proposed methodology. ACM Transactions on Embedded Computing Systems, Vol. 1, No. 1, Article 1. Publication date: January 2019 [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (16 more)
Figure 4
Figure 4. Figure 4: (a) A system with two queues. Flits in Qh [PITH_FULL_IMAGE:figures/full_fig_p005_4.png]
Figure 5
Figure 5. Figure 5: Split at high priority: Structural Transformation. [PITH_FULL_IMAGE:figures/full_fig_p006_5.png]
Figure 6
Figure 6. Figure 6: Comparison of simulation with the basic priority-based queuing model and proposed analytical model. waiting time of traffic class-3, the resulting waiting time will be highly pessimistic, as shown in [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]
Figure 7
Figure 7. Figure 7: Decomposition technique: In phase 1, different traffic flows merge into a single flow with an inter [PITH_FULL_IMAGE:figures/full_fig_p008_7.png]
Figure 8
Figure 8. Figure 8: Split at low priority: Service Rate Transformation. [PITH_FULL_IMAGE:figures/full_fig_p008_8.png]
Figure 9
Figure 9. Figure 9: Comparison of simulation with the basic priority-based queuing model and proposed analytical model. Proposed Transformation: The high-priority flow (class-1) is not affected by class-2 traffic since they do not share the same server. Therefore, the waiting time of clas…
Figure 10
Figure 10. Figure 10: illustrates the proposed approach on a representative example of a priority-based network to decompose the system [PITH_FULL_IMAGE:figures/full_fig_p011_10.png]
Figure 11
Figure 11. Figure 11: The fraction of simulation time spent by different functions while running Streamcluster in gem5. [PITH_FULL_IMAGE:figures/full_fig_p013_11.png]
Figure 12
Figure 12. Figure 12: Evaluation of the proposed model on a ring with eight nodes. [PITH_FULL_IMAGE:figures/full_fig_p013_12.png]
Figure 13
Figure 13. Figure 13: Evaluation of the proposed model on a 6×6 mesh. 1 Injection Rate (flits/cycle) max 0 0.5 1 Average Latency (normalized) Simulation State-of-the-art ST only RT only Analytical (proposed) [PITH_FULL_IMAGE:figures/full_fig_p014_13.png]
Figure 15
Figure 15. Figure 15: Effect of coefficient of variation of inter-arrival time on average latency for a 6×6 mesh. ACM Transactions on Embedded Computing Systems, Vol. 1, No. 1, Article 1. Publication date: January 2019 [PITH_FULL_IMAGE:figures/full_fig_p014_15.png]
Figure 16
Figure 16. Figure 16: Evaluation of the proposed model on one variant of the Xeon server architecture. Evaluation with Intel® Xeon® Scalable Server Processor Architecture: This section evaluates the proposed analytical model with the floorplan of a variant of the Intel® Xeon® Scalable Serv…
Figure 17
Figure 17. Figure 17: Per-class latency comparison for the server example. Finally, we evaluate the proposed technique with different LLC hit rates [PITH_FULL_IMAGE:figures/full_fig_p015_17.png]
Figure 18
Figure 18. Figure 18: Model comparison for different applications from PARSEC suite. [PITH_FULL_IMAGE:figures/full_fig_p017_18.png]
Figure 19
Figure 19. Figure 19: Evaluation of the proposed model under a finer level of time granularity (100K cycles) for Streamcluster application. ACM Transactions on Embedded Computing Systems, Vol. 1, No. 1, Article 1. Publication date: January 2019 [PITH_FULL_IMAGE:figures/full_fig_p017_19.png]
Figure 20
Figure 20. Figure 20: Residual time calculation. R (1) = M1(Ttot ) Ttot 1 M1(Ttot ) M1X (Tt ot ) i=1 T 2 i −Ti 2  + M2(Ttot ) Ttot 1 M2(Ttot ) M2X (Tt ot ) j=1 T 2 j −Tj 2  (a) = 1 2 λ1(T 2 1 −T1) + 1 2 λ2(T 2 2 −T2) (b) = R1 + R2 (15) Where (a) follows from the fact that Mi (Tt ot ) T…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

35 extracted references · 35 canonical work pages

  1. [20]

    A. E. Kiasari, Z. Lu, and A. Jantsch. An Analytical Latency Model for Networks-on-Chip. IEEE Trans. on Very Large Scale Integration (VLSI) Systems , 21(1):113–123, 2013

    work page 2013

  2. [1]

    Agarwal et al

    N. Agarwal et al. GARNET: A Detailed on-chip Network Model Inside a Full-system Simulator. In 2009 IEEE intl. symp. on performance analysis of systems and software , pages 33–42

    work page 2009

  3. [2]

    Awan and R

    I. Awan and R. Fretwell. Analysis of Discrete-Time Queues with Space and Service Priorities for Arbitrary Arrival Processes. In Parallel and Distributed Systems. Proc. 11th Intl Conf. on , volume 2, pages 115–119, 2005

    work page 2005

  4. [3]

    Bartolini et al

    A. Bartolini et al. A Virtual Platform Environment For Exploring Power, Thermal And Reliability Management Control Strategies In High-Performance Multicores. In Proc. of the Great lakes Symp. on VLSI , pages 311–316, 2010

    work page 2010

  5. [4]

    A. W. Berger and W. Whitt. Workload Bounds in Fluid Models with Priorities. Performance evaluation, 41(4):249–267, 2000

    work page 2000

  6. [5]

    D. P. Bertsekas, R. G. Gallager, and P. Humblet. Data Networks, volume 2. Prentice-Hall International New Jersey, 1992

    work page 1992

  7. [6]

    Bienia, S

    C. Bienia, S. Kumar, J. P. Singh, and K. Li. The PARSEC Benchmark Suite: Characterization and Architectural Implications. In Proc. of the Intl. Conf. on Parallel Arch. and Compilation Tech. , pages 72–81, 2008

    work page 2008

  8. [7]

    Binkert et al

    N. Binkert et al. The Gem5 Simulator. SIGARCH Comp. Arch. News, May. 2011

    work page 2011

Show all 35 references
  1. [8]

    Bogdan and R

    P. Bogdan and R. Marculescu. Non-stationary Traffic Analysis and its Implications on Multicore Platform Design. IEEE Trans. on Computer-Aided Design of Integrated Circuits and Systems , 30(4):508–519, 2011

    2011

  2. [9]

    Bolch, S

    G. Bolch, S. Greiner, H. De Meer, and K. S. Trivedi. Queueing Networks and Markov Chains: Modeling and Performance Evaluation with Computer Science Applications . John Wiley & Sons, 2006

    2006

  3. [10]

    Choi et al

    W. Choi et al. On-Chip Communication Network for Efficient Training of Deep Convolutional Networks on Heteroge- neous Manycore Systems. IEEE Trans. on Computers , 67(5):672–686, 2017

    2017

  4. [11]

    A. C. de Melo. The New Linux Perf Tools. In Linux Kongress, volume 18, 2010

    2010

  5. [12]

    Doweck et al

    J. Doweck et al. Inside 6th-generation Intel Core: New Microarchitecture Code-named Skylake. IEEE Micro, (2):52–62, 2017

    2017

  6. [13]

    Ikehara and M

    S. Ikehara and M. Miyazaki. Approximate Analysis of Queueing Networks with Nonpreemptive Priority Scheduling. In Proc. 11th Int. Teletraffic Congr

  7. [14]

    Jeffers, J

    J. Jeffers, J. Reinders, and A. Sodani. Intel Xeon Phi Processor High Performance Programming: Knights Landing Edition . Morgan Kaufmann, 2016

    2016

  8. [15]

    Jiang et al

    N. Jiang et al. A Detailed and Flexible Cycle-accurate Network-on-chip Simulator. In 2013 IEEE Intl. Symp. on Performance Analysis of Systems and Software (ISPASS) , pages 86–96

    2013

  9. [16]

    Jin and G

    X. Jin and G. Min. Modelling and Analysis of Priority Queueing Systems with Multi-class Self-similar Network Traffic: a Novel and Efficient Queue-decomposition Approach. IEEE Trans. on Communications , 57(5), 2009

    2009

  10. [17]

    J. A. Kahle et al. Introduction to the Cell multiprocessor. IBM journal of Research and Development , 49(4.5):589–604, 2005

    2005

  11. [18]

    Kashif and H

    H. Kashif and H. Patel. Bounding Buffer Space Requirements for Real-time Priority-aware Networks. In Asia and South Pacific Design Autom. Conf. , pages 113–118, 2014

    2014

  12. [19]

    C. N. Keltcher, K. J. McGrath, A. Ahmed, and P. Conway. The AMD Opteron Processor for Multiprocessor Servers. IEEE Micro, 23(2):66–76, 2003

    2003

  13. [21]

    Leupers et al

    R. Leupers et al. Virtual Manycore platforms: Moving towards 100+ processor cores. In Proc. of DATE, pages 1–6, 2011

    2011

  14. [22]

    P. S. Magnusson et al. Simics: A Full System Simulation Platform. Computer, 35(2):50–58. ACM Transactions on Embedded Computing Systems, Vol. 1, No. 1, Article 1. Publication date: January 2019. Analytical Performance Models for NoCs with Multiple Priority Traffic Classes 1:19

    2019

  15. [23]

    U. Y. Ogras, P. Bogdan, and R. Marculescu. An Analytical Approach for Network-on-Chip Performance Analysis. IEEE Trans. on Computer-Aided Design of Integrated Circuits and Systems , 29(12):2001–2013, 2010

    2001

  16. [24]

    U. Y. Ogras, Y. Emre, J. Xu, T. Kam, and M. Kishinevsky. Energy-Guided Exploration of On-Chip Network Design for Exa-Scale Computing. In Proc. of Intl. Workshop on System Level Interconnect Prediction , pages 24–31, 2012

    2012

  17. [25]

    U. Y. Ogras, M. Kishinevsky, and S. Chatterjee. xPLORE: Communication Fabric Design and Optimization Framework. Developed at Strategic CAD Labs, Intel Corp

  18. [26]

    P. P. Pande, C. Grecu, M. Jones, A. Ivanov, and R. Saleh. Performance Evaluation and Design Trade-offs for Network- on-Chip Interconnect Architectures. IEEE transactions on Computers , 54(8):1025–1040, 2005

    2005

  19. [27]

    Patel et al

    A. Patel et al. MARSS: a Full System Simulator for Multicore x86 CPUs. In Design Autom. Conf., pages 1050–1055, 2011

    2011

  20. [28]

    Y. Qian, Z. Lu, and W. Dou. Analysis of Worst-case Delay Bounds for Best-effort Communication in Wormhole Networks on Chip. In 2009 3rd ACM/IEEE Interl. Symp. on Networks-on-Chip , pages 44–53

    2009

  21. [29]

    Qian et al

    Z.-L. Qian et al. A Support Sector Regression (SVR)-based Latency Model for Network-on-Chip (NoC) Architectures. IEEE Trans. on Computer-Aided Design of Integrated Circuits and Systems , 35(3):471–484, 2015

    2015

  22. [30]

    Rico et al

    A. Rico et al. ARM HPC Ecosystem and the Reemergence of Vectors. In Proc. of the Computing Frontiers Conf. , pages 329–334. ACM, 2017

    2017

  23. [31]

    Rotem and S

    E. Rotem and S. P. Engineer. Intel Architecture, Code Name Skylake Deep Dive: A New Architecture to Manage Power Performance and Energy Efficiency. In Intel Developer Forum, 2015

    2015

  24. [32]

    M. P. Singh and M. K. Jain. Evolution of Processor Architecture in Mobile Phones. Intl. Journ. of Computer Applications, 90(4), 2014

    2014

  25. [33]

    Walraevens

    J. Walraevens. Discrete-time Queueing Models with Priorities . PhD thesis, Ghent University, 2004

    2004

  26. [34]

    Wettin et al

    P. Wettin et al. Performance Evaluation of Wireless NoCs in Presence of Irregular Network Routing Strategies. In Proc. of the conf. on DATE, page 272, 2014

    2014

  27. [35]

    Wu et al

    Y. Wu et al. Analytical Modelling of Networks in Multicomputer Systems under Bursty and Batch Arrival Traffic. The Journ. of Supercomputing, 51(2):115–130, 2010. APPENDIX A Residual time calculation: Residual time is the delay of serving the next flit due to the remaining serv...

    2010

Pith tools

Reviewed August 14, 2026 · model on record in the stance chip above.