[TableGen] Emit a fatal error on inconsistencies in resource units vs cycles.

[courbet]

Summary

See PR37310.

For targets I'm not familiar with, I've automatically made the "default to 1 for each resource" behaviour explicit in the td files.
For more obvious cases, I've ventured a fix.

Some notes:

• The change to X86ScheduleBtVer2.td is an NFC, it just makes values more explicit.
• Exynos is especially fishy.
• AArch64SchedThunderX2T99.td had some truncated entries. If I understand correctly, the person who wrote that interpreted the ResourceCycle as a range. I made the decision to use the upper/lower bound for consistency with the 'Latency' value. I'm sure there is a better choice.
• MIPS has the same issue for DIVs.

[courbet]

Fix some MIPS scheduling info revealed by the checks.

[RKSimon]

Not sure if I want to have to specify resource cycles every time - we should be able to assume a default=1, same for latency and micro-ops. This helps reduce bulkiness of the models considerably. In fact I might go further and maybe suggest a debug warning that values set to the default value could be removed?

But I'd definitely happy with the idea that if ResourceCycles are set it must be equal in size to ResourceUnits, (and similar ambiguities).

[andreadb]

Hi Clement,

I think that your new check is a bit too strict.
It is okay to have less ResourceCycle elements than resources in ProcResources. It simply means that some resources would implicitly be consumed for 1cy.

Example:

// Reserve A9UnitFP for 2 consecutive cycles.
def A9Write2V4 : SchedWriteRes<[A9UnitFP, A9UnitAGU]> {
  let Latency = 4;
  let ResourceCycles = [2];

It is okay not to have an explicit [2,1] here. The A9UnitAGU should get an implicit 1cy.

Same here:

defm : ZnWriteResPair<WriteIMul, [ZnALU1, ZnMultiplier], 4>;

We shouldn't have to explicitly pass a ResourceCycles to [1,1]. IMHO That should be the implied default.

On the other hand, I totally agree with you that the following case is a bug:

def BWWriteResGroup138 : SchedWriteRes<[BWPort0,BWPort5,BWPort23]> {
  let Latency = 13;
  let NumMicroOps = 4;
  let ResourceCycles = [1,2,1,7];

Here ResourceCycles has more elements than the number of resources specified by the write (i.e. 4 entries versus 3 resources).

The next example is "well-formed", although semantically incorrect. We should have that 70 is associated to SLMFPDivider. However, strictly speaking, it is not wrong to have only a list of two cycles (instead of three).

def SLMriteResGroup13 : SchedWriteRes<[SLM_MEC_RSV,SLM_FPC_RSV0,SLMFPDivider]> {
  let Latency = 74;
  let NumMicroOps = 1;
  let ResourceCycles = [1,70];
}

I am not against introducing/enforcing more constraints. Personally, I would only error if Cycles.size() > PRVec.size(), and not if Cycles.size() != PRVec.size().
This is just my opinion though.
I do recognize though that this would help catching bugs similar to the div from the last example.

[courbet]

• revert changes to btver2, use a saner default.

[courbet]

In D46356#1085159, @RKSimon wrote:

Not sure if I want to have to specify resource cycles every time - we should be able to assume a default=1, same for latency and micro-ops. This helps reduce bulkiness of the models considerably. In fact I might go further and maybe suggest a debug warning that values set to the default value could be removed?

OK, I've changed list<int> Res = [1] to list<int> Res = [] in the definition of JWriteResFpuPair, and added a condition so that the folded version avoids the concat when relying in the default.

[courbet]

Hi Andrea,

In D46356#1085164, @andreadb wrote:

I think that your new check is a bit too strict.
It is okay to have less ResourceCycle elements than resources in ProcResources. It simply means that some resources would implicitly be consumed for 1cy.

Yes, I understand that this is the current behaviour. But I think this change shows that relying on this implicit behaviour is way too dangerous as shown by the bugs it has uncovered in MIPS, Exynos (I think), ThunderX, Broadwell, and Silvermont.

Example:

// Reserve A9UnitFP for 2 consecutive cycles.
def A9Write2V4 : SchedWriteRes<[A9UnitFP, A9UnitAGU]> {
  let Latency = 4;
  let ResourceCycles = [2];

It is okay not to have an explicit [2,1] here. The A9UnitAGU should get an implicit 1cy.

It's semantically similar, but not obvious: someone unfamiliar with the schema could think that this is 1 cycle on A9UnitFP and one on A9UnitAGU. I think it's clearer to spell it out explicitly.

Same here:

defm : ZnWriteResPair<WriteIMul, [ZnALU1, ZnMultiplier], 4>;

We shouldn't have to explicitly pass a ResourceCycles to [1,1]. IMHO That should be the implied default.

That's Simon's point in him comment. Agreed, I'm going to apply the same approach.

The next example is "well-formed", although semantically incorrect.

That's the point of the change: it's currently too easy to accidentally write well-formed but incorrect specs.

[courbet]

• Allow fully implicit ResourceCycles in ZnXXXPair model. as per Andrea's comment.
• Update TargetSchedule.td documentation.

[courbet]

• Update llvm-mca SLM tests.

[andreadb]

In D46356#1085183, @courbet wrote:

Hi Andrea,

In D46356#1085164, @andreadb wrote:

I think that your new check is a bit too strict.
It is okay to have less ResourceCycle elements than resources in ProcResources. It simply means that some resources would implicitly be consumed for 1cy.

Yes, I understand that this is the current behaviour. But I think this change shows that relying on this implicit behaviour is way too dangerous as shown by the bugs it has uncovered in MIPS, Exynos (I think), ThunderX, Broadwell, and Silvermont.

Example:

// Reserve A9UnitFP for 2 consecutive cycles.
def A9Write2V4 : SchedWriteRes<[A9UnitFP, A9UnitAGU]> {
  let Latency = 4;
  let ResourceCycles = [2];

It is okay not to have an explicit [2,1] here. The A9UnitAGU should get an implicit 1cy.

It's semantically similar, but not obvious: someone unfamiliar with the schema could think that this is 1 cycle on A9UnitFP and one on A9UnitAGU. I think it's clearer to spell it out explicitly.

My opinion is that the description in TargetSchedule.td is quite clear.

// Optionally, ResourceCycles indicates the number of cycles the
// resource is consumed. Each ResourceCycles item is paired with the
// ProcResource item at the same position in its list. Since
// ResourceCycles are rarely specialized, the list may be
// incomplete. By default, resources are consumed for a single cycle [...]

The next example is "well-formed", although semantically incorrect.

That's the point of the change: it's currently too easy to accidentally write well-formed but incorrect specs.

I agree with your last point. It would definitely force people to be more careful when they write those cycles.

If Simon/other people are happy with it, then I am happy too.

About your patch:
you should probably update the comment in TargetSchedule.td (lines [283:292]). Your patch slightly changes the set of constraints on the resource cycles; I think that one of the statements in that paragraph may not say the truth anymore.

utils/TableGen/SubtargetEmitter.cpp

1123

Please remove this TODO (or remove your name from the TODO comment).

[courbet]

In D46356#1085209, @andreadb wrote:

In D46356#1085183, @courbet wrote:

Hi Andrea,

In D46356#1085164, @andreadb wrote:

I think that your new check is a bit too strict.
It is okay to have less ResourceCycle elements than resources in ProcResources. It simply means that some resources would implicitly be consumed for 1cy.

Yes, I understand that this is the current behaviour. But I think this change shows that relying on this implicit behaviour is way too dangerous as shown by the bugs it has uncovered in MIPS, Exynos (I think), ThunderX, Broadwell, and Silvermont.

Example:

// Reserve A9UnitFP for 2 consecutive cycles.
def A9Write2V4 : SchedWriteRes<[A9UnitFP, A9UnitAGU]> {
  let Latency = 4;
  let ResourceCycles = [2];

It is okay not to have an explicit [2,1] here. The A9UnitAGU should get an implicit 1cy.

It's semantically similar, but not obvious: someone unfamiliar with the schema could think that this is 1 cycle on A9UnitFP and one on A9UnitAGU. I think it's clearer to spell it out explicitly.

My opinion is that the description in TargetSchedule.td is quite clear.

// Optionally, ResourceCycles indicates the number of cycles the
// resource is consumed. Each ResourceCycles item is paired with the
// ProcResource item at the same position in its list. Since
// ResourceCycles are rarely specialized, the list may be
// incomplete. By default, resources are consumed for a single cycle [...]

It is, but it clearly does not prevent bugs in practice :)

you should probably update the comment in TargetSchedule.td (lines [283:292]). Your patch slightly changes the set of constraints on the resource cycles; I think that one of the statements in that paragraph may not say the truth anymore.

Yep, this was done in update 3 of this diff

[courbet]

lib/Target/Mips/MipsScheduleGeneric.td

77 ↗

(On Diff #144869)

@sdardis Can you have a look at this one ? Thanks.

[sdardis]

lib/Target/Mips/MipsScheduleGeneric.td

77 ↗

(On Diff #144869)

Bug. The divide unit in the generic model is supposed to be separate from the ALU. It's a hold-over from when I developed the generic model, as I cribbed it from the P5600 model with has two units working on the divide according to the model.

This change is correct.

82 ↗

(On Diff #144869)

As is this.

[RKSimon]

Can you pull out the SLM / BW fixes into their own commits please?

lib/Target/X86/X86SchedBroadwell.td

1657

This fix can be committed now in its own commit.

lib/Target/X86/X86ScheduleSLM.td

393

This fix (and the llvm-mca test change) can be committed in its own commit.

[courbet]

lib/Target/Mips/MipsScheduleGeneric.td

77 ↗

(On Diff #144869)

Thanks !

lib/Target/X86/X86SchedBroadwell.td

1657

Will do.

[courbet]

Submit MIPS change, rebase.

[courbet]

Submit SLM+BDW fixes and rebase.

[javed.absar]

Thanks for this check.
If ResourceCycles is not specified then it should default to 1 . I believe most people write with that interpretation.
If ResourceCycles is specified for at least one resource, it makes sense from correctness POV that it be specified for all (even though it might get verbose at time).

[courbet]

Rebase.

[andreadb]

Thanks Clement,

It looks good to me now. I only have one minor nit (see below).

utils/TableGen/SubtargetEmitter.cpp

1123

This comment should be modified or removed.

[courbet]

Get rid of the FIXME to remove the default ResourceCyles.

[RKSimon]

I think it'd be clearer if we could keep Btver2/Znver1 to the Res = [1] default tbh

[courbet]

Thanks.

@andreadb, @RKSimon, @javed.absar: I'll submit the X86 and A9 changes as they are safe.

I'll wait for confirmation for Exynos and Thunder for the rest.

[courbet]

In D46356#1085328, @RKSimon wrote:

I think it'd be clearer if we could keep Btver2/Znver1 to the Res = [1] default tbh

Hm, not sure how I can do that without triggering the check for cases when the user erroneously specified [1] when they wanted to use the default (now []). Did I miss a possibility ?
This makes is no difference for the user, but allows more checking. Best of both worlds ? :)

[javed.absar]

In D46356#1085333, @courbet wrote:

In D46356#1085328, @RKSimon wrote:

I think it'd be clearer if we could keep Btver2/Znver1 to the Res = [1] default tbh

Hm, not sure how I can do that without triggering the check for cases when the user erroneously specified [1] when they wanted to use the default (now []). Did I miss a possibility ?
This makes is no difference for the user, but allows more checking. Best of both worlds ? :)

I am bit confused on - "user erroneously specified [1] when they wanted to use the default ". But the default was always [1]

[RKSimon]

In D46356#1085333, @courbet wrote:

In D46356#1085328, @RKSimon wrote:

I think it'd be clearer if we could keep Btver2/Znver1 to the Res = [1] default tbh

Hm, not sure how I can do that without triggering the check for cases when the user erroneously specified [1] when they wanted to use the default (now []). Did I miss a possibility ?
This makes is no difference for the user, but allows more checking. Best of both worlds ? :)

Which cases fail?

[courbet]

In D46356#1085339, @javed.absar wrote:

In D46356#1085333, @courbet wrote:

In D46356#1085328, @RKSimon wrote:

I think it'd be clearer if we could keep Btver2/Znver1 to the Res = [1] default tbh

Hm, not sure how I can do that without triggering the check for cases when the user erroneously specified [1] when they wanted to use the default (now []). Did I miss a possibility ?
This makes is no difference for the user, but allows more checking. Best of both worlds ? :)

I am bit confused on - "user erroneously specified [1] when they wanted to use the default ". But the default was always [1]

Now that we're checking what the user wrote, we want the following cases to be valid:

def : WriteRes<SchedRW, [P0, P1]> {
    let ResourceCycles = [1, 1];  // explicit
}

def : WriteRes<SchedRW, [P0, P1]> {
    let ResourceCycles = [];  // explicitly use default, same as let ResourceCycles = [1,1]
}

def : WriteRes<SchedRW, [P0, P1]> {
    // implicitly use default, same as let ResourceCycles = [1,1]
}

But this one to be invalid:

def : WriteRes<SchedRW, [P0, P1]> {
    let ResourceCycles = [1];  // Did the user expect [1,1]; or did they make a mistake ? Throw an error.
}

In this specific case we want:

defm : ZnWriteResPair<WriteIMul,   [ZnALU1, ZnMultiplier], 4>;            // (A) ok, [1,1]
defm : ZnWriteResPair<WriteIMul,   [ZnALU1, ZnMultiplier], 4, [1,1]>;  // (B) ok, [1,1]
defm : ZnWriteResPair<WriteIMul,   [ZnALU1, ZnMultiplier], 4, [1]>;     // (C) Error, not sure if this is a mistake or not.

If I keep the default Res = [1] in the definition of ZnWriteResPair, I cannot make a difference between (A) and (C). Using the the default Res = [] allows making the difference and is consistent with what WriteRes uses as a default.

Am I making more sense ?

[javed.absar]

Ah! OK, I see. Thanks for the clarification.

[RKSimon]

In D46356#1085378, @javed.absar wrote:

Ah! OK, I see. Thanks for the clarification.

Yup - me too! LGTM if @javed.absar is happy as well.

[evandro]

lib/Target/AArch64/AArch64SchedExynosM3.td

307

Please, make this [8, 8]...

311

[13, 13]...

315

[19, 19]...

319

[26, 26]...

391

[6, 6, 6]...

411

[6, 1, 1, 6, 1]...

419

[6, 1, 1, 6, 1, 1]...

425

[6, 6, 6, 6]...

434

[1, 3, 1, 3]...

442

[1, 3, 1, 3, 1, 3]...

451

[1, 3, 3, 1, 3, 1, 3]...

462

[1, 3, 3, 1, 3, 1, 3, 1, 3]...

469

[1, 3, 3, 1, 3]...

[evandro]

lib/Target/AArch64/AArch64SchedExynosM3.td

480

[1, 3, 3, 1, 3, 1, 3, 1, 3].

[courbet]

Submit NFC changes to ARM and AMD, rebase.

[courbet]

lib/Target/AArch64/AArch64SchedExynosM3.td

307

Note that the two following definitions are strictly equivalent:

def M3WriteNEONV   : SchedWriteRes<[M3UnitFDIV, M3UnitFDIV]>  {
  let Latency = 7;
  let NumMicroOps = 1;
  let ResourceCycles = [8,8];
}

def M3WriteNEONV   : SchedWriteRes<[M3UnitFDIV]>  {
  let Latency = 7;
  let NumMicroOps = 1;
  let ResourceCycles = [16];
}

What's the semantics that you're trying to express by splitting into 8*M3UnitFDIV + 8*M3UnitFDIV vs 16*M3UnitFDIV ? The SubtargetEmitter is destroying these semantics anyway.

For reference before this change the definition is equivalent to:

def M3WriteNEONV   : SchedWriteRes<[M3UnitFDIV]>  {
  let Latency = 7;
  let NumMicroOps = 1;
  let ResourceCycles = [9];
}

[evandro]

lib/Target/AArch64/AArch64SchedExynosM3.td

307

There are two FDIV units in M3:

def M3UnitFDIV : ProcResGroup<[M3UnitFDIV0, M3UnitFDIV1]>;

[courbet]

lib/Target/AArch64/AArch64SchedExynosM3.td

307

Yes indeed, but this is already covered by the M3UnitFDIV referencing these two.

I'm not familiar with Exynos, what's the semantics that you're trying to express here ?

As written before this change, M3WriteNEONV dispatches one Uop that writes its output with latency 7 and uses either of {M3UnitFDIV0, M3UnitFDIV1} for 9 cycles.
After that change, whatever way ([8,8] or [16]) we write it, M3WriteNEONV dispatches one Uop that writes its output with latency 7 and uses either of {M3UnitFDIV0, M3UnitFDIV1} for 16 cycles.

Maybe that's the case, but since that sounds weird, I just want to confirm.

[javed.absar]

Does FDIV use both the resources for 8 cycles? Writing [8,8] would imply that.

[evandro]

In D46356#1086531, @javed.absar wrote:

Does FDIV use both the resources for 8 cycles? Writing [8,8] would imply that.

For FDIVv4f32, yes.

[evandro]

lib/Target/AArch64/AArch64SchedExynosM3.td

307

I mean that with M3WriteNEONV, for FDIVv4f32, one uop is dispatched to both [M3UnitFDIV0, M3UnitFDIV1] (don't ask me how this is done inside the machine) and each used up for 8 cycles.

311

And here I mean that with M3WriteNEONV, for FDIVv2f64, one uop is dispatched to both [M3UnitFDIV0, M3UnitFDIV1] and each used up for 13 cycles.

[courbet]

• [ExynosM3] Fix scheduling info.

[courbet]

@evandro Do you have benchmarks to evaluate the impact of this change ?

lib/Target/AArch64/AArch64SchedExynosM3.td

307

Thanks for the explanation. So you wanted to write:

def M3WriteNEONV   : SchedWriteRes<[M3UnitFDIV0, M3UnitFDIV1]>  {
  let Latency = 7;
  let NumMicroOps = 2;
  let ResourceCycles = [8,8];
}

I've updated the diff with that.

[courbet]

lib/Target/AArch64/AArch64SchedExynosM3.td

376

This still feels weirdly asymetric. Is that correct ?

[evandro]

In D46356#1087529, @courbet wrote:

@evandro Do you have benchmarks to evaluate the impact of this change ?

Yes. They're not done yet. Will let you know when I get the results.

Thank you.

lib/Target/AArch64/AArch64SchedExynosM3.td

307

Thank you.

311

Err, I meant M3WriteNEONW here. Thank you.

376

No, it should be [5, 5], thank you.

[courbet]

Fix a last exynos M3 entry.

[courbet]

In D46356#1087868, @evandro wrote:

In D46356#1087529, @courbet wrote:

@evandro Do you have benchmarks to evaluate the impact of this change ?

Yes. They're not done yet. Will let you know when I get the results.

Any news ?
Thanks.

[evandro]

In D46356#1089483, @courbet wrote:

@evandro Do you have benchmarks to evaluate the impact of this change ?

Yes. They're not done yet. Will let you know when I get the results.

Any news ?

Sorry, they slipped my mind. I see a minor improvement overall, especially in FP workloads, with a few minor regressions.

Thank you.

[courbet]

In D46356#1099581, @evandro wrote:

In D46356#1089483, @courbet wrote:

@evandro Do you have benchmarks to evaluate the impact of this change ?

Yes. They're not done yet. Will let you know when I get the results.

Any news ?

Sorry, they slipped my mind. I see a minor improvement overall, especially in FP workloads, with a few minor regressions.

Thank you.

OK, thanks. I'll submit this part then.

[courbet]

I accidentally closed this when submitting r332713.

[courbet]

rebase after r332713

[RKSimon]

What is still outstanding on this? Have regression tests been done on all the AArch64 cpus @javed.absar @evandro ?

It'd be very useful to get this error reporting added to trunk ASAP as people are taking an interest in improving scheduling right now.

[courbet]

In D46356#1120096, @RKSimon wrote:

What is still outstanding on this?

A review of ExynosM1 /ThunderX2, as I'm not familiar with these CPUs.

[RKSimon]

@joel_k_jones Can you comment on these aarch64 model changes please?

[evandro]

In D46356#1120407, @courbet wrote:

A review of ExynosM1 /ThunderX2, as I'm not familiar with these CPUs.

I'm sorry, I completely forgot about M1.

lib/Target/AArch64/AArch64SchedExynosM1.td

329

[1, 1]

343

[2, 2, 2]

349

[2, 1, 1, 1]

356

[2, 1, 1, 1, 1]

363

[1, 1, 1, 1, 1]

371

[1, 1, 1, 1, 1, 1]

377

[2, 1, 2, 1]

392

[7, 1, 1, 1, 1]

401

[1, 7, 1, 7, 1, 1, 1]

412

[1, 7, 1, 7, 1, 1, 1, 1, 1]

419

[1, 7, 1, 7, 1]

432

[1, 7, 1, 7, 1, 1, 1, 1, 1, 1, 1]

[courbet]

Update ExynosM1.

lib/Target/AArch64/AArch64SchedExynosM1.td

343

I set NumMicroOps = 6 to be consistent. Is that OK ?

349

NumMicroOps = 5

356

NumMicroOps = 6

377

NumMicroOps = 6

392

NumMicroOps = 11

401

ditto

412

ditto

419

ditto

432

ditto

[courbet]

• fix btver2

[courbet]

More X86 typos crept in while this was pending; I fixed some harmless ones in r334164, but fixing the ones in BtVer2 would actually introduce semantic differences, so I've added it back here.

[RKSimon]

lib/Target/X86/X86ScheduleBtVer2.td

353–354

These are 2 uops not 4, btver2 splits the issue and execution resource.

[courbet]

lib/Target/X86/X86ScheduleBtVer2.td

353–354

OK cool, thanks. So this is an NFC.

[RKSimon]

lib/Target/X86/X86ScheduleBtVer2.td

353–354

No, you need to set it back to 2

[courbet]

Rebase after r334178.

[courbet]

lib/Target/X86/X86ScheduleBtVer2.td

353–354

Sorry, yes, that's what I meant; I just did not re-export to phabricator. I submitted r334178 with 2 here.

[RKSimon]

@evandro Does AArch64SchedExynosM1.td and AArch64SchedThunderX2T99.td look correct now please?

[evandro]

In D46356#1124577, @courbet wrote:

Update ExynosM1.

No, the number of uops was correct. Don't ask how, but some uops can be dispatched to different units at the same time. Please, restore the original number, unless it creates any error. Then, we can talk.

[evandro]

In D46356#1126217, @RKSimon wrote:

@evandro Does AArch64SchedExynosM1.td and AArch64SchedThunderX2T99.td look correct now please?

Except for my remark above on M1, the changes to X2T99 seem reasonable to me. But I am not familiar with this Cavium processor. It'd be better if someone from Cavium would chime in, but their silence, after so long, might be taken as consent.

[courbet]

revert NumMicroOps changes to ExynosM1.

[courbet]

Rebase after submitting ExynosM1 changes as r334391.

[courbet]

I'll submit the cavium changes in a couple of days unless there are reservations.
@joel_k_jones any comments ?

[evandro]

Thank you, @courbet.

[RKSimon]

LGTM - thank @courbet

[courbet]

Thanks all for the reviews.

lib/Target/AArch64/AArch64SchedExynosM1.td

def M1WriteLB : SchedWriteRes<[M1UnitL,
                                M1UnitA]> { let Latency = 4;
                                            let NumMicroOps = 2; }
 def M1WriteLC : SchedWriteRes<[M1UnitL,
                                M1UnitA]> { let Latency = 5;
                                            let NumMicroOps = 2; }
 def M1WriteLD : SchedWriteRes<[M1UnitL,
                                M1UnitA]> { let Latency = 6;
                                            let NumMicroOps = 2;
-                                           let ResourceCycles = [2]; }
+                                           let ResourceCycles = [2, 1]; }
 def M1WriteLH : SchedWriteRes<[]>        { let Latency = 5;
                                            let NumMicroOps = 0; }
 def M1WriteLX : SchedWriteVariant<[SchedVar<M1ShiftLeftFastPred, [M1WriteL5]>,
                                    SchedVar<NoSchedPred,         [M1WriteLC]>]>;
 def M1WriteLY : SchedWriteVariant<[SchedVar<M1ShiftLeftFastPred, [M1WriteL5]>,
                                    SchedVar<NoSchedPred,         [M1WriteLD]>]>;
 
 def M1WriteS1 : SchedWriteRes<[M1UnitS]>   { let Latency = 1; }

 def M1WriteVLDC    : SchedWriteRes<[M1UnitL,
                                     M1UnitL,
                                     M1UnitL,
                                     M1UnitL]>      { let Latency = 8;
                                                      let NumMicroOps = 4; }
 def M1WriteVLDD    : SchedWriteRes<[M1UnitL,
                                     M1UnitNALU]>   { let Latency = 7;
                                                      let NumMicroOps = 2;
-                                                     let ResourceCycles = [2]; }
+                                                     let ResourceCycles = [2, 1]; }
 def M1WriteVLDE    : SchedWriteRes<[M1UnitL,
                                     M1UnitNALU]>   { let Latency = 6;
                                                      let NumMicroOps = 2; }
 def M1WriteVLDF    : SchedWriteRes<[M1UnitL,
                                     M1UnitL]>      { let Latency = 10;
                                                      let NumMicroOps = 2;
-                                                     let ResourceCycles = [5]; }
+                                                     let ResourceCycles = [5, 1]; }
 def M1WriteVLDG    : SchedWriteRes<[M1UnitL,
                                     M1UnitNALU,
                                     M1UnitNALU]>   { let Latency = 7;
                                                      let NumMicroOps = 3;
-                                                     let ResourceCycles = [2]; }
+                                                     let ResourceCycles = [2, 1, 1]; }
 def M1WriteVLDH    : SchedWriteRes<[M1UnitL,
                                     M1UnitNALU,
                                     M1UnitNALU]>   { let Latency = 6;
                                                      let NumMicroOps = 3; }
 def M1WriteVLDI    : SchedWriteRes<[M1UnitL,
                                     M1UnitL,
                                     M1UnitL]>      { let Latency = 12;
                                                      let NumMicroOps = 3;
-                                                     let ResourceCycles = [6]; }
+                                                     let ResourceCycles = [6, 1, 1]; }
 def M1WriteVLDJ    : SchedWriteRes<[M1UnitL,
                                     M1UnitNALU,
                                     M1UnitNALU,
                                     M1UnitNALU]>   { let Latency = 9;
                                                      let NumMicroOps = 4;
-                                                     let ResourceCycles = [4]; }
+                                                     let ResourceCycles = [4, 1, 1, 1]; }
 def M1WriteVLDK    : SchedWriteRes<[M1UnitL,
                                     M1UnitNALU,
                                     M1UnitNALU,
                                     M1UnitNALU,
                                     M1UnitNALU]>   { let Latency = 9;
                                                      let NumMicroOps = 5;
-                                                     let ResourceCycles = [4]; }
+                                                     let ResourceCycles = [4, 1, 1, 1, 1]; }
 def M1WriteVLDL    : SchedWriteRes<[M1UnitL,
                                     M1UnitNALU,
                                     M1UnitNALU,
                                     M1UnitL,
                                     M1UnitNALU]>   { let Latency = 7;
                                                      let NumMicroOps = 5;
-                                                     let ResourceCycles = [2]; }
+                                                     let ResourceCycles = [2, 1, 1, 1, 1]; }
 def M1WriteVLDM    : SchedWriteRes<[M1UnitL,
                                     M1UnitNALU,
                                     M1UnitNALU,
                                     M1UnitL,
                                     M1UnitNALU,
                                     M1UnitNALU]>   { let Latency = 7;
                                                      let NumMicroOps = 6;
-                                                     let ResourceCycles = [2]; }
+                                                     let ResourceCycles = [2, 1, 1, 1, 1, 1]; }
 def M1WriteVLDN    : SchedWriteRes<[M1UnitL,
                                     M1UnitL,
                                     M1UnitL,
                                     M1UnitL]>      { let Latency = 14;
                                                      let NumMicroOps = 4;
-                                                     let ResourceCycles = [7]; }
+                                                     let ResourceCycles = [7, 1, 1, 1]; }
 def M1WriteVSTA    : WriteSequence<[WriteVST], 2>;
 def M1WriteVSTB    : WriteSequence<[WriteVST], 3>;
 def M1WriteVSTC    : WriteSequence<[WriteVST], 4>;
 def M1WriteVSTD    : SchedWriteRes<[M1UnitS,
                                     M1UnitFST,
                                     M1UnitFST]>    { let Latency = 7;
                                                      let NumMicroOps = 2;
-                                                     let ResourceCycles = [7]; }
+                                                     let ResourceCycles = [7, 1, 1]; }
 def M1WriteVSTE    : SchedWriteRes<[M1UnitS,
                                     M1UnitFST,
                                     M1UnitS,
                                     M1UnitFST,
                                     M1UnitFST]>    { let Latency = 8;
                                                      let NumMicroOps = 3;
-                                                     let ResourceCycles = [8]; }
+                                                     let ResourceCycles = [8, 1, 1, 1, 1]; }
 def M1WriteVSTF    : SchedWriteRes<[M1UnitNALU,
                                     M1UnitS,
                                     M1UnitFST,
                                     M1UnitS,
                                     M1UnitFST,
                                     M1UnitFST,
                                     M1UnitFST]>     { let Latency = 15;
                                                       let NumMicroOps = 5;
-                                                      let ResourceCycles = [15]; }
+                                                      let ResourceCycles = [15, 1, 1, 1, 1, 1, 1]; }
 def M1WriteVSTG    : SchedWriteRes<[M1UnitNALU,
                                     M1UnitS,
                                     M1UnitFST,
                                     M1UnitS,
                                     M1UnitFST,
                                     M1UnitS,
                                     M1UnitFST,
                                     M1UnitFST,
                                     M1UnitFST]>     { let Latency = 16;
                                                       let NumMicroOps = 6;
-                                                      let ResourceCycles = [16]; }
+                                                      let ResourceCycles = [16, 1, 1, 1, 1, 1, 1, 1, 1]; }
 def M1WriteVSTH    : SchedWriteRes<[M1UnitNALU,
                                     M1UnitS,
                                     M1UnitFST,
                                     M1UnitFST,
                                     M1UnitFST]>      { let Latency = 14;
                                                        let NumMicroOps = 4;
-                                                       let ResourceCycles = [14]; }
+                                                       let ResourceCycles = [14, 1, 1, 1, 1]; }
 def M1WriteVSTI    : SchedWriteRes<[M1UnitNALU,
                                     M1UnitS,
                                     M1UnitFST,
                                     M1UnitS,
                                     M1UnitFST,
                                     M1UnitS,
                                     M1UnitFST,
                                     M1UnitS,
                                     M1UnitFST,
                                     M1UnitFST,
                                     M1UnitFST]>      { let Latency = 17;
                                                        let NumMicroOps = 7;
-                                                       let ResourceCycles = [17]; }
+                                                       let ResourceCycles = [17, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]; }
 
 // Branch instructions
 def : InstRW<[M1WriteB1], (instrs Bcc)>;
 def : InstRW<[M1WriteA1], (instrs BL)>;
 def : InstRW<[M1WriteBX], (instrs BLR)>;
 def : InstRW<[M1WriteC1], (instregex "^CBN?Z[WX]")>;
 def : InstRW<[M1WriteAD], (instregex "^TBN?Z[WX]")>;
 

lib/Target/AArch64/AArch64SchedExynosM3.td

def M3WriteNEONH   : SchedWriteRes<[M3UnitNALU,
                                     M3UnitS]>     { let Latency = 5;
                                                     let NumMicroOps = 2; }
 def M3WriteNEONI   : SchedWriteRes<[M3UnitNSHF,
                                     M3UnitS]>     { let Latency = 5;
                                                     let NumMicroOps = 2; }
 def M3WriteNEONV   : SchedWriteRes<[M3UnitFDIV,
                                     M3UnitFDIV]>  { let Latency = 7;
                                                     let NumMicroOps = 1;
-                                                    let ResourceCycles = [8]; }
+                                                    let ResourceCycles = [8, 1]; }
 def M3WriteNEONW   : SchedWriteRes<[M3UnitFDIV,
                                     M3UnitFDIV]>  { let Latency = 12;
                                                     let NumMicroOps = 1;
-                                                    let ResourceCycles = [13]; }
+                                                    let ResourceCycles = [13, 1]; }
 def M3WriteNEONX   : SchedWriteRes<[M3UnitFSQR,
                                     M3UnitFSQR]>  { let Latency = 18;
                                                     let NumMicroOps = 1;
-                                                    let ResourceCycles = [19]; }
+                                                    let ResourceCycles = [19, 1]; }
 def M3WriteNEONY   : SchedWriteRes<[M3UnitFSQR,
                                     M3UnitFSQR]>  { let Latency = 25;
                                                     let NumMicroOps = 1;
-                                                    let ResourceCycles = [26]; }
+                                                    let ResourceCycles = [26, 1]; }
 def M3WriteNEONZ   : SchedWriteRes<[M3UnitNMSC,
                                     M3UnitNMSC]>  { let Latency = 5;
                                                     let NumMicroOps = 2; }
 def M3WriteFADD2   : SchedWriteRes<[M3UnitFADD]>  { let Latency = 2; }
 def M3WriteFCVT2   : SchedWriteRes<[M3UnitFCVT]>  { let Latency = 2; }
 def M3WriteFCVT3   : SchedWriteRes<[M3UnitFCVT]>  { let Latency = 3; }
 def M3WriteFCVT3A  : SchedWriteRes<[M3UnitFCVT0]> { let Latency = 3; }
 def M3WriteFCVT4A  : SchedWriteRes<[M3UnitFCVT0]> { let Latency = 4; }

 def M3WriteVLDC    : SchedWriteRes<[M3UnitL,
                                     M3UnitL,
                                     M3UnitL,
                                     M3UnitL]>     { let Latency = 6;
                                                     let NumMicroOps = 4; }
 def M3WriteVLDD    : SchedWriteRes<[M3UnitL,
                                     M3UnitNALU]>  { let Latency = 7;
                                                     let NumMicroOps = 2;
-                                                    let ResourceCycles = [2]; }
+                                                    let ResourceCycles = [2, 1]; }
 def M3WriteVLDE    : SchedWriteRes<[M3UnitL,
                                     M3UnitNALU]>  { let Latency = 6;
                                                     let NumMicroOps = 2;
-                                                    let ResourceCycles = [2]; }
+                                                    let ResourceCycles = [2, 1]; }
 def M3WriteVLDF    : SchedWriteRes<[M3UnitL,
                                     M3UnitL]>     { let Latency = 10;
                                                     let NumMicroOps = 2;
-                                                    let ResourceCycles = [5]; }
+                                                    let ResourceCycles = [5, 1]; }
 def M3WriteVLDG    : SchedWriteRes<[M3UnitL,
                                     M3UnitNALU,
                                     M3UnitNALU]>  { let Latency = 7;
                                                     let NumMicroOps = 3;
-                                                    let ResourceCycles = [2]; }
+                                                    let ResourceCycles = [2, 1, 1]; }
 def M3WriteVLDH    : SchedWriteRes<[M3UnitL,
                                     M3UnitNALU,
                                     M3UnitNALU]>  { let Latency = 6;
                                                     let NumMicroOps = 3;
-                                                    let ResourceCycles = [2]; }
+                                                    let ResourceCycles = [2, 1, 1]; }
 def M3WriteVLDI    : SchedWriteRes<[M3UnitL,
                                     M3UnitL,
                                     M3UnitL]>     { let Latency = 12;
                                                     let NumMicroOps = 3;
-                                                    let ResourceCycles = [6]; }
+                                                    let ResourceCycles = [6, 1, 1]; }
 def M3WriteVLDJ    : SchedWriteRes<[M3UnitL,
                                     M3UnitNALU,
                                     M3UnitNALU,
                                     M3UnitNALU]>  { let Latency = 7;
                                                     let NumMicroOps = 4;
-                                                    let ResourceCycles = [2]; }
+                                                    let ResourceCycles = [2, 1, 1, 1]; }
 def M3WriteVLDK    : SchedWriteRes<[M3UnitL,
                                     M3UnitNALU,
                                     M3UnitNALU,
                                     M3UnitNALU,
                                     M3UnitNALU]>  { let Latency = 9;
                                                     let NumMicroOps = 5;
-                                                    let ResourceCycles = [4]; }
+                                                    let ResourceCycles = [4, 1, 1, 1, 1]; }
 def M3WriteVLDL    : SchedWriteRes<[M3UnitL,
                                     M3UnitNALU,
                                     M3UnitNALU,
                                     M3UnitL,
                                     M3UnitNALU]>  { let Latency = 6;
                                                     let NumMicroOps = 5;
-                                                    let ResourceCycles = [3]; }
+                                                    let ResourceCycles = [3, 1, 1, 1, 1]; }
 def M3WriteVLDM    : SchedWriteRes<[M3UnitL,
                                     M3UnitNALU,
                                     M3UnitNALU,
                                     M3UnitL,
                                     M3UnitNALU,
                                     M3UnitNALU]>  { let Latency = 7;
                                                     let NumMicroOps = 6;
-                                                    let ResourceCycles = [3]; }
+                                                    let ResourceCycles = [3, 1, 1, 1, 1, 1]; }
 def M3WriteVLDN    : SchedWriteRes<[M3UnitL,
                                     M3UnitL,
                                     M3UnitL,
                                     M3UnitL]>     { let Latency = 14;
                                                     let NumMicroOps = 4;
-                                                    let ResourceCycles = [7]; }
+                                                    let ResourceCycles = [7, 1, 1, 1]; }
 def M3WriteVSTA    : WriteSequence<[WriteVST], 2>;
 def M3WriteVSTB    : WriteSequence<[WriteVST], 3>;
 def M3WriteVSTC    : WriteSequence<[WriteVST], 4>;
 def M3WriteVSTD    : SchedWriteRes<[M3UnitS,
                                     M3UnitFST,
                                     M3UnitS,
                                     M3UnitFST]>   { let Latency = 7;
                                                     let NumMicroOps = 2;
-                                                    let ResourceCycles = [7]; }
+                                                    let ResourceCycles = [7, 1, 1, 1]; }
 def M3WriteVSTE    : SchedWriteRes<[M3UnitS,
                                     M3UnitFST,
                                     M3UnitS,
                                     M3UnitFST,
                                     M3UnitS,
                                     M3UnitFST]>   { let Latency = 8;
                                                     let NumMicroOps = 3;
-                                                    let ResourceCycles = [8]; }
+                                                    let ResourceCycles = [8, 1, 1, 1, 1, 1]; }
 def M3WriteVSTF    : SchedWriteRes<[M3UnitNALU,
                                     M3UnitFST,
                                     M3UnitFST,
                                     M3UnitS,
                                     M3UnitFST,
                                     M3UnitS,
                                     M3UnitFST]>   { let Latency = 15;
                                                     let NumMicroOps = 5;
-                                                    let ResourceCycles = [15]; }
+                                                    let ResourceCycles = [15, 1, 1, 1, 1, 1, 1]; }
 def M3WriteVSTG    : SchedWriteRes<[M3UnitNALU,
                                     M3UnitFST,
                                     M3UnitFST,
                                     M3UnitS,
                                     M3UnitFST,
                                     M3UnitS,
                                     M3UnitFST,
                                     M3UnitS,
                                     M3UnitFST]>   { let Latency = 16;
                                                     let NumMicroOps = 6;
-                                                    let ResourceCycles = [16]; }
+                                                    let ResourceCycles = [16, 1, 1, 1, 1, 1, 1, 1, 1]; }
 def M3WriteVSTH    : SchedWriteRes<[M3UnitNALU,
                                     M3UnitFST,
                                     M3UnitFST,
                                     M3UnitS,
                                     M3UnitFST]>   { let Latency = 14;
                                                     let NumMicroOps = 4;
-                                                    let ResourceCycles = [14]; }
+                                                    let ResourceCycles = [14, 1, 1, 1, 1]; }
 def M3WriteVSTI    : SchedWriteRes<[M3UnitNALU,
                                     M3UnitFST,
                                     M3UnitFST,
                                     M3UnitS,
                                     M3UnitFST,
                                     M3UnitS,
                                     M3UnitFST,
                                     M3UnitS,
                                     M3UnitFST]>   { let Latency = 17;
                                                     let NumMicroOps = 7;
-                                                    let ResourceCycles = [17]; }
+                                                    let ResourceCycles = [17, 1, 1, 1, 1, 1, 1, 1, 1]; }
 
 // Special cases.
 def M3WriteAES     : SchedWriteRes<[M3UnitNCRY]>  { let Latency = 1; }
 def M3ReadAES      : SchedReadAdvance<1, [M3WriteAES]>;
 def M3ReadFMAC     : SchedReadAdvance<1, [M3WriteFMAC4,
                                           M3WriteFMAC5]>;
 def M3WriteMOVI    : SchedWriteVariant<[SchedVar<M3ResetFastPred, [M3WriteZ0]>,
                                         SchedVar<NoSchedPred,     [M3WriteNALU1]>]>;

lib/Target/AArch64/AArch64SchedThunderX2T99.td

 
 
 // ALU, basic
 // Conditional compare
 // Conditional select
 // Address generation
 def : WriteRes<WriteI,       [THX2T99I012]> {
   let Latency = 1;
-  let ResourceCycles = [1, 3];
+  let ResourceCycles = [1];
   let NumMicroOps = 2;
 }
 
 def : InstRW<[WriteI],
             (instregex "ADD?(W|X)r(i|r|s|x)",   "ADDS?(W|X)r(i|r|s|x)(64)?",
                        "AND?(W|X)r(i|r|s|x)",   "ANDS?(W|X)r(i|r|s|x)",
                        "ADC(W|X)r",
                        "BIC?(W|X)r(i|r|s|x)",   "BICS?(W|X)r(i|r|s|x)",
                        "EON?(W|X)r(i|r|s|x)",   "ORN?(W|X)r(i|r|s|x)",
                        "ORR?(W|X)r(i|r|s|x)",   "SUB?(W|X)r(i|r|s|x)",
                        "SUBS?(W|X)r(i|r|s|x)",  "SBC(W|X)r",
                        "SBCS(W|X)r",            "CCMN(W|X)(i|r)",
                        "CCMP(W|X)(i|r)",        "CSEL(W|X)r",
                        "CSINC(W|X)r",           "CSINV(W|X)r",
                        "CSNEG(W|X)r")>;
 
 def : InstRW<[WriteI], (instrs COPY)>;
 
 // ALU, extend and/or shift
 def : WriteRes<WriteISReg,   [THX2T99I012]> {
   let Latency = 2;
-  let ResourceCycles = [2, 3];
+  let ResourceCycles = [2];
   let NumMicroOps = 2;
 }
 
 def : InstRW<[WriteISReg],
             (instregex "ADD?(W|X)r(i|r|s|x)",   "ADDS?(W|X)r(i|r|s|x)(64)?",
                        "AND?(W|X)r(i|r|s|x)",   "ANDS?(W|X)r(i|r|s|x)",
                        "ADC(W|X)r",
                        "BIC?(W|X)r(i|r|s|x)",   "BICS?(W|X)r(i|r|s|x)",
                        "EON?(W|X)r(i|r|s|x)",   "ORN?(W|X)r(i|r|s|x)",
                        "ORR?(W|X)r(i|r|s|x)",   "SUB?(W|X)r(i|r|s|x)",
                        "SUBS?(W|X)r(i|r|s|x)",  "SBC(W|X)r",
                        "SBCS(W|X)r",            "CCMN(W|X)(i|r)",
                        "CCMP(W|X)(i|r)",        "CSEL(W|X)r",
                        "CSINC(W|X)r",           "CSINV(W|X)r",
                        "CSNEG(W|X)r")>;
 
 def : WriteRes<WriteIEReg,   [THX2T99I012]> {
   let Latency = 1;
-  let ResourceCycles = [1, 3];
+  let ResourceCycles = [1];
   let NumMicroOps = 2;
 }
 
 def : InstRW<[WriteIEReg],
             (instregex "ADD?(W|X)r(i|r|s|x)",   "ADDS?(W|X)r(i|r|s|x)(64)?",
                        "AND?(W|X)r(i|r|s|x)",   "ANDS?(W|X)r(i|r|s|x)",
                        "ADC(W|X)r",
                        "BIC?(W|X)r(i|r|s|x)",   "BICS?(W|X)r(i|r|s|x)",

 //---
 // 3.4 Divide and Multiply Instructions
 //---
 
 // Divide, W-form
 // Latency range of 13-23/13-39.
 def : WriteRes<WriteID32,    [THX2T99I1]> {
   let Latency = 39;
-  let ResourceCycles = [13, 39];
+  let ResourceCycles = [39];
   let NumMicroOps = 4;
 }
 
 // Divide, X-form
 def : WriteRes<WriteID64,    [THX2T99I1]> {
   let Latency = 23;
-  let ResourceCycles = [13, 23];
+  let ResourceCycles = [23];
   let NumMicroOps = 4;
 }
 
 // Multiply accumulate, W-form
 def : WriteRes<WriteIM32,    [THX2T99I012]> {
   let Latency = 5;
   let NumMicroOps = 3;
 }

 // ASIMD shift by immed, complex
 // ASIMD shift by register, basic, D-form
 // ASIMD shift by register, basic, Q-form
 // ASIMD shift by register, complex, D-form
 // ASIMD shift by register, complex, Q-form
 def : WriteRes<WriteV, [THX2T99F01]> {
   let Latency = 7;
   let NumMicroOps = 4;
-  let ResourceCycles = [4, 23];
+  let ResourceCycles = [4];
 }
 
 // ASIMD arith, reduce, 4H/4S
 // ASIMD arith, reduce, 8B/8H
 // ASIMD arith, reduce, 16B
 
 // ASIMD logical (MVN (alias for NOT), ORN, ORR)
 def : InstRW<[THX2T99Write_5Cyc_F01],

lib/Target/ARM/ARMScheduleA9.td

 def : WriteRes<WriteVST1, []>;
 def : WriteRes<WriteVST2, []>;
 def : WriteRes<WriteVST3, []>;
 def : WriteRes<WriteVST4, []>;
 
 // Reserve A9UnitFP for 2 consecutive cycles.
 def A9Write2V4 : SchedWriteRes<[A9UnitFP, A9UnitAGU]> {
   let Latency = 4;
-  let ResourceCycles = [2];
+  let ResourceCycles = [2, 1];
 }
 def A9Write2V7 : SchedWriteRes<[A9UnitFP, A9UnitAGU]> {
   let Latency = 7;
-  let ResourceCycles = [2];
+  let ResourceCycles = [2, 1];
 }
 def A9Write2V9 : SchedWriteRes<[A9UnitFP, A9UnitAGU]> {
   let Latency = 9;
-  let ResourceCycles = [2];
+  let ResourceCycles = [2, 1];
 }
 
 // Branches don't have a def operand but still consume resources.
 def A9WriteB : SchedWriteRes<[A9UnitB]>;
 
 // Address generation.
 def A9WriteAdr : SchedWriteRes<[A9UnitAGU]> { let NumMicroOps = 0; }
 

lib/Target/X86/X86SchedBroadwell.td

def BWWriteResGroup137_1 : SchedWriteRes<[BWPort0,BWFPDivider]> {
   let NumMicroOps = 1;
   let ResourceCycles = [1,4];
 }
 def: InstRW<[BWWriteResGroup137_1], (instregex "(V?)SQRTSSr")>;
 
 def BWWriteResGroup138 : SchedWriteRes<[BWPort0,BWPort5,BWPort23]> {
   let Latency = 13;
   let NumMicroOps = 4;
-  let ResourceCycles = [1,2,1,7];
+  let ResourceCycles = [1,2,1];
 }
 def: InstRW<[BWWriteResGroup138], (instregex "VMPSADBWYrmi")>;
 
 def BWWriteResGroup139 : SchedWriteRes<[BWPort0,BWFPDivider]> {
   let Latency = 14;
   let NumMicroOps = 1;
   let ResourceCycles = [1,8];
 }

lib/Target/X86/X86ScheduleBtVer2.td

def : WriteRes<SchedRW.Folded, !listconcat([JLAGU], ExePorts)> {
     let Latency = !add(Lat, 3);
     let ResourceCycles = !listconcat([1], Res);
     let NumMicroOps = UOps;
   }
 }
 
 multiclass JWriteResFpuPair<X86FoldableSchedWrite SchedRW,
                             list<ProcResourceKind> ExePorts,
-                            int Lat, list<int> Res = [1], int UOps = 1> {
+                            int Lat, list<int> Res, int UOps = 1> {
   // Register variant is using a single cycle on ExePort.
   def : WriteRes<SchedRW, ExePorts> {
     let Latency = Lat;
     let ResourceCycles = Res;
     let NumMicroOps = UOps;
   }
 
   // Memory variant also uses a cycle on JLAGU and adds 5 cycles to the

 ////////////////////////////////////////////////////////////////////////////////
 // Floating point. This covers both scalar and vector operations.
 ////////////////////////////////////////////////////////////////////////////////
 
 def  : WriteRes<WriteFLoad,        [JLAGU, JFPU01, JFPX]> { let Latency = 5; }
 def  : WriteRes<WriteFStore,        [JSAGU, JFPU1, JSTC]>;
 def  : WriteRes<WriteFMove,               [JFPU01, JFPX]>;
 
-defm : JWriteResFpuPair<WriteFAdd,         [JFPU0, JFPA],  3>;
+defm : JWriteResFpuPair<WriteFAdd,         [JFPU0, JFPA],  3, [1,1]>;
 defm : JWriteResYMMPair<WriteFAddY,        [JFPU0, JFPA],  3, [2,2], 2>;
-defm : JWriteResFpuPair<WriteFCmp,         [JFPU0, JFPA],  2>;
+defm : JWriteResFpuPair<WriteFCmp,         [JFPU0, JFPA],  2, [1,1]>;
 defm : JWriteResYMMPair<WriteFCmpY,        [JFPU0, JFPA],  2, [2,2], 2>;
-defm : JWriteResFpuPair<WriteFCom,  [JFPU0, JFPA, JALU0],  3>;
-defm : JWriteResFpuPair<WriteFMul,         [JFPU1, JFPM],  2>;
+defm : JWriteResFpuPair<WriteFCom,  [JFPU0, JFPA, JALU0],  3, [1,1,1]>;
+defm : JWriteResFpuPair<WriteFMul,         [JFPU1, JFPM],  2, [1,1]>;
 defm : JWriteResYMMPair<WriteFMulY,        [JFPU1, JFPM],  2, [2,2], 2>;
-defm : JWriteResFpuPair<WriteFMA,          [JFPU1, JFPM],  2>; // NOTE: Doesn't exist on Jaguar.
-defm : JWriteResFpuPair<WriteFMAS,         [JFPU1, JFPM],  2>; // NOTE: Doesn't exist on Jaguar.
-defm : JWriteResFpuPair<WriteFMAY,         [JFPU1, JFPM],  2>; // NOTE: Doesn't exist on Jaguar.
-defm : JWriteResFpuPair<WriteFRcp,         [JFPU1, JFPM],  2>;
+defm : JWriteResFpuPair<WriteFMA,          [JFPU1, JFPM],  2, [1,1]>; // NOTE: Doesn't exist on Jaguar.
+defm : JWriteResFpuPair<WriteFMAS,         [JFPU1, JFPM],  2, [1,1]>; // NOTE: Doesn't exist on Jaguar.
+defm : JWriteResFpuPair<WriteFMAY,         [JFPU1, JFPM],  2, [1,1]>; // NOTE: Doesn't exist on Jaguar.
+defm : JWriteResFpuPair<WriteFRcp,         [JFPU1, JFPM],  2, [1,1]>;
 defm : JWriteResYMMPair<WriteFRcpY,        [JFPU1, JFPM],  2, [2,2], 2>;
-defm : JWriteResFpuPair<WriteFRsqrt,       [JFPU1, JFPM],  2>;
+defm : JWriteResFpuPair<WriteFRsqrt,       [JFPU1, JFPM],  2, [1,1]>;
 defm : JWriteResYMMPair<WriteFRsqrtY,      [JFPU1, JFPM],  2, [2,2], 2>;
 defm : JWriteResFpuPair<WriteFDiv,         [JFPU1, JFPM], 19, [1, 19]>;
 defm : JWriteResYMMPair<WriteFDivY,        [JFPU1, JFPM], 38, [2, 38], 2>;
 defm : JWriteResFpuPair<WriteFSqrt,        [JFPU1, JFPM], 21, [1, 21]>;
 defm : JWriteResYMMPair<WriteFSqrtY,       [JFPU1, JFPM], 42, [2, 42], 2>;
-defm : JWriteResFpuPair<WriteFSign,        [JFPU1, JFPM],  2>;
-defm : JWriteResFpuPair<WriteFLogic,      [JFPU01, JFPX],  1>;
+defm : JWriteResFpuPair<WriteFSign,        [JFPU1, JFPM],  2, [1,1]>;
+defm : JWriteResFpuPair<WriteFLogic,      [JFPU01, JFPX],  1, [1,1]>;
 defm : JWriteResYMMPair<WriteFLogicY,     [JFPU01, JFPX],  1, [2, 2], 2>;
-defm : JWriteResFpuPair<WriteFShuffle,    [JFPU01, JFPX],  1>;
+defm : JWriteResFpuPair<WriteFShuffle,    [JFPU01, JFPX],  1, [1,1]>;
 defm : JWriteResYMMPair<WriteFShuffleY,   [JFPU01, JFPX],  1, [2, 2], 2>;
 defm : JWriteResFpuPair<WriteFVarShuffle, [JFPU01, JFPX],  2, [1, 4], 3>;
 defm : JWriteResYMMPair<WriteFVarShuffleY,[JFPU01, JFPX],  3, [2, 6], 6>;
-defm : JWriteResFpuPair<WriteFBlend,      [JFPU01, JFPX],  1>;
+defm : JWriteResFpuPair<WriteFBlend,      [JFPU01, JFPX],  1, [1,1]>;
 defm : JWriteResYMMPair<WriteFBlendY,     [JFPU01, JFPX],  1, [2, 2], 2>;
 defm : JWriteResFpuPair<WriteFVarBlend,   [JFPU01, JFPX],  2, [1, 4], 3>;
 defm : JWriteResYMMPair<WriteFVarBlendY,  [JFPU01, JFPX],  3, [2, 6], 6>;
-defm : JWriteResFpuPair<WriteFShuffle256, [JFPU01, JFPX],  1>;
-defm : JWriteResFpuPair<WriteFVarShuffle256, [JFPU01, JFPX],  1>; // NOTE: Doesn't exist on Jaguar.
+defm : JWriteResFpuPair<WriteFShuffle256, [JFPU01, JFPX],  1, [1,1]>;
+defm : JWriteResFpuPair<WriteFVarShuffle256, [JFPU01, JFPX],  1, [1,1]>; // NOTE: Doesn't exist on Jaguar.
 
 ////////////////////////////////////////////////////////////////////////////////
 // Conversions.
 ////////////////////////////////////////////////////////////////////////////////
 
-defm : JWriteResFpuPair<WriteCvtF2I,       [JFPU1, JSTC], 3>; // Float -> Integer.
-defm : JWriteResFpuPair<WriteCvtI2F,       [JFPU1, JSTC], 3>; // Integer -> Float.
-defm : JWriteResFpuPair<WriteCvtF2F,       [JFPU1, JSTC], 3>; // Float -> Float size conversion.
+defm : JWriteResFpuPair<WriteCvtF2I,       [JFPU1, JSTC], 3, [1,1]>; // Float -> Integer.
+defm : JWriteResFpuPair<WriteCvtI2F,       [JFPU1, JSTC], 3, [1,1]>; // Integer -> Float.
+defm : JWriteResFpuPair<WriteCvtF2F,       [JFPU1, JSTC], 3, [1,1]>; // Float -> Float size conversion.
 def  : WriteRes<WriteCvtF2FSt, [JFPU1, JSTC, JSAGU]> { let Latency = 4; }
 
 def JWriteCVTF2F : SchedWriteRes<[JFPU1, JSTC]> {
   let Latency = 7;
   let ResourceCycles = [1, 2];
   let NumMicroOps = 2;
 }
 def : InstRW<[JWriteCVTF2F], (instregex "(V)?CVTS(D|S)2S(D|S)rr")>;

 ////////////////////////////////////////////////////////////////////////////////
 // Vector integer operations.
 ////////////////////////////////////////////////////////////////////////////////
 
 def  : WriteRes<WriteVecLoad,      [JLAGU, JFPU01, JVALU]> { let Latency = 5; }
 def  : WriteRes<WriteVecStore,       [JSAGU, JFPU1, JSTC]>;
 def  : WriteRes<WriteVecMove,             [JFPU01, JVALU]>;
 
-defm : JWriteResFpuPair<WriteVecALU,      [JFPU01, JVALU], 1>;
-defm : JWriteResFpuPair<WriteVecShift,    [JFPU01, JVALU], 1>;
-defm : JWriteResFpuPair<WriteVecIMul,     [JFPU0, JVIMUL], 2>;
+defm : JWriteResFpuPair<WriteVecALU,      [JFPU01, JVALU], 1, [1, 1]>;
+defm : JWriteResFpuPair<WriteVecShift,    [JFPU01, JVALU], 1, [1, 1]>;
+defm : JWriteResFpuPair<WriteVecIMul,     [JFPU0, JVIMUL], 2, [1, 1]>;
 defm : JWriteResFpuPair<WritePMULLD,      [JFPU0, JFPU01, JVIMUL, JVALU], 4, [2, 1, 2, 1], 3>;
 defm : JWriteResFpuPair<WriteMPSAD,       [JFPU0, JVIMUL], 3, [1, 2]>;
-defm : JWriteResFpuPair<WritePSADBW,      [JFPU01, JVALU], 2>;
-defm : JWriteResFpuPair<WritePHMINPOS,    [JFPU0,  JVALU], 2>;
-defm : JWriteResFpuPair<WriteShuffle,     [JFPU01, JVALU], 1>;
+defm : JWriteResFpuPair<WritePSADBW,      [JFPU01, JVALU], 2, [1, 1]>;
+defm : JWriteResFpuPair<WritePHMINPOS,    [JFPU0,  JVALU], 2, [1, 1]>;
+defm : JWriteResFpuPair<WriteShuffle,     [JFPU01, JVALU], 1, [1, 1]>;
 defm : JWriteResFpuPair<WriteVarShuffle,  [JFPU01, JVALU], 2, [1, 4], 3>;
-defm : JWriteResFpuPair<WriteBlend,       [JFPU01, JVALU], 1>;
+defm : JWriteResFpuPair<WriteBlend,       [JFPU01, JVALU], 1, [1, 1]>;
 defm : JWriteResFpuPair<WriteVarBlend,    [JFPU01, JVALU], 2, [1, 4], 3>;
-defm : JWriteResFpuPair<WriteVecLogic,    [JFPU01, JVALU], 1>;
-defm : JWriteResFpuPair<WriteVecLogicY,   [JFPU01, JVALU], 1>; // NOTE: Doesn't exist on Jaguar.
-defm : JWriteResFpuPair<WriteShuffle256,  [JFPU01, JVALU], 1>;
-defm : JWriteResFpuPair<WriteVarShuffle256, [JFPU01, JVALU], 1>; // NOTE: Doesn't exist on Jaguar.
-defm : JWriteResFpuPair<WriteVarVecShift, [JFPU01, JVALU], 1>; // NOTE: Doesn't exist on Jaguar.
+defm : JWriteResFpuPair<WriteVecLogic,    [JFPU01, JVALU], 1, [1, 1]>;
+defm : JWriteResFpuPair<WriteVecLogicY,   [JFPU01, JVALU], 1, [1, 1]>; // NOTE: Doesn't exist on Jaguar.
+defm : JWriteResFpuPair<WriteShuffle256,  [JFPU01, JVALU], 1, [1, 1]>;
+defm : JWriteResFpuPair<WriteVarShuffle256, [JFPU01, JVALU], 1, [1, 1]>; // NOTE: Doesn't exist on Jaguar.
+defm : JWriteResFpuPair<WriteVarVecShift, [JFPU01, JVALU], 1, [1, 1]>; // NOTE: Doesn't exist on Jaguar.
 
 ////////////////////////////////////////////////////////////////////////////////
 // Vector insert/extract operations.
 ////////////////////////////////////////////////////////////////////////////////
 
-defm : JWriteResFpuPair<WriteVecInsert,   [JFPU01, JVALU], 1>;
+defm : JWriteResFpuPair<WriteVecInsert,   [JFPU01, JVALU], 1, [1, 1]>;
 def  : WriteRes<WriteVecExtract,     [JFPU0, JFPA, JALU0]> { let Latency = 3; }
 def  : WriteRes<WriteVecExtractSt,   [JFPU1, JSTC, JSAGU]> { let Latency = 3; }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SSE42 String instructions.
 ////////////////////////////////////////////////////////////////////////////////
 
 defm : JWriteResFpuPair<WritePCmpIStrI, [JFPU1, JVALU1, JFPA, JALU0], 7, [1, 2, 1, 1], 3>;
 defm : JWriteResFpuPair<WritePCmpIStrM, [JFPU1, JVALU1, JFPA, JALU0], 8, [1, 2, 1, 1], 3>;
 defm : JWriteResFpuPair<WritePCmpEStrI, [JFPU1, JSAGU, JLAGU, JVALU, JVALU1, JFPA, JALU0], 14, [1, 2, 2, 6, 4, 1, 1], 9>;
 defm : JWriteResFpuPair<WritePCmpEStrM, [JFPU1, JSAGU, JLAGU, JVALU, JVALU1, JFPA, JALU0], 14, [1, 2, 2, 6, 4, 1, 1], 9>;
 
 ////////////////////////////////////////////////////////////////////////////////
 // MOVMSK Instructions.
 ////////////////////////////////////////////////////////////////////////////////
 
 def  : WriteRes<WriteFMOVMSK, [JFPU0, JFPA, JALU0]> { let Latency = 3; }
 def  : WriteRes<WriteVecMOVMSK, [JFPU0, JFPA, JALU0]> { let Latency = 3; }
 def  : WriteRes<WriteMMXMOVMSK, [JFPU0, JFPA, JALU0]> { let Latency = 3; }
 
 ////////////////////////////////////////////////////////////////////////////////
 // AES Instructions.
 ////////////////////////////////////////////////////////////////////////////////
 
-defm : JWriteResFpuPair<WriteAESIMC,      [JFPU0, JVIMUL], 2>;
-defm : JWriteResFpuPair<WriteAESKeyGen,   [JFPU0, JVIMUL], 2>;
-defm : JWriteResFpuPair<WriteAESDecEnc,   [JFPU0, JVIMUL], 3, [1], 2>;
+defm : JWriteResFpuPair<WriteAESIMC,      [JFPU0, JVIMUL], 2, [1, 1]>;
+defm : JWriteResFpuPair<WriteAESKeyGen,   [JFPU0, JVIMUL], 2, [1, 1]>;
+defm : JWriteResFpuPair<WriteAESDecEnc,   [JFPU0, JVIMUL], 3, [1, 1], 2>;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Horizontal add/sub  instructions.
 ////////////////////////////////////////////////////////////////////////////////
 
-defm : JWriteResFpuPair<WriteFHAdd,         [JFPU0, JFPA], 3>;
-defm : JWriteResYMMPair<WriteFHAddY,        [JFPU0, JFPA], 3, [2,2], 2>;
-defm : JWriteResFpuPair<WritePHAdd,       [JFPU01, JVALU], 1>;
+defm : JWriteResFpuPair<WriteFHAdd,         [JFPU0, JFPA], 3, [1, 1]>;
+defm : JWriteResYMMPair<WriteFHAddY,        [JFPU0, JFPA], 3, [2, 2], 2>;
+defm : JWriteResFpuPair<WritePHAdd,       [JFPU01, JVALU], 1, [1, 1]>;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Carry-less multiplication instructions.
 ////////////////////////////////////////////////////////////////////////////////
 
-defm : JWriteResFpuPair<WriteCLMul,       [JFPU0, JVIMUL], 2>;
+defm : JWriteResFpuPair<WriteCLMul,       [JFPU0, JVIMUL], 2, [1, 1]>;
 
 ////////////////////////////////////////////////////////////////////////////////
 // SSE4.1 instructions.
 ////////////////////////////////////////////////////////////////////////////////
 
 def JWriteDPPS: SchedWriteRes<[JFPU1, JFPM, JFPA]> {
   let Latency = 11;
   let ResourceCycles = [1, 3, 3];

lib/Target/X86/X86ScheduleSLM.td

def SLMriteResGroup12 : SchedWriteRes<[SLM_FPC_RSV0,SLMFPDivider]> {
   let NumMicroOps = 1;
   let ResourceCycles = [1,20];
 }
 def: InstRW<[SLMriteResGroup12], (instregex "(V?)SQRTSSr")>;
 
 def SLMriteResGroup13 : SchedWriteRes<[SLM_MEC_RSV,SLM_FPC_RSV0,SLMFPDivider]> {
   let Latency = 74;
   let NumMicroOps = 1;
-  let ResourceCycles = [1,70];
+  let ResourceCycles = [1,1,70];
 }
 def: InstRW<[SLMriteResGroup13], (instregex "(V?)SQRTPDm")>;
 
 def SLMriteResGroup14 : SchedWriteRes<[SLM_MEC_RSV,SLM_FPC_RSV0,SLMFPDivider]> {
   let Latency = 44;
   let NumMicroOps = 1;
   let ResourceCycles = [1,1,40];
 }

lib/Target/X86/X86ScheduleZnver1.td

 
 def : WriteRes<WriteStore, [ZnAGU]>;
 def : WriteRes<WriteMove,  [ZnALU]>;
 def : WriteRes<WriteLoad,  [ZnAGU]> { let Latency = 8; }
 
 def : WriteRes<WriteZero,  []>;
 def : WriteRes<WriteLEA, [ZnALU]>;
 defm : ZnWriteResPair<WriteALU,   [ZnALU], 1>;
-defm : ZnWriteResPair<WriteIMul,   [ZnALU1, ZnMultiplier], 4>;
+defm : ZnWriteResPair<WriteIMul,   [ZnALU1, ZnMultiplier], 4, [1, 1]>;
 defm : ZnWriteResPair<WriteShift, [ZnALU], 1>;
 defm : ZnWriteResPair<WriteJump,  [ZnALU], 1>;
 defm : ZnWriteResFpuPair<WriteCRC32, [ZnFPU0], 3>;
 
 defm : ZnWriteResPair<WriteCMOV,   [ZnALU], 1>;
 def  : WriteRes<WriteSETCC,  [ZnALU]>;
 def  : WriteRes<WriteSETCCStore,  [ZnALU, ZnAGU]>;
 

utils/TableGen/SubtargetEmitter.cpp

Record *SubtargetEmitter::FindReadAdvance(const CodeGenSchedRW &SchedRead,
   return ResDef;
 }
 
 // Expand an explicit list of processor resources into a full list of implied
 // resource groups and super resources that cover them.
 void SubtargetEmitter::ExpandProcResources(RecVec &PRVec,
                                            std::vector<int64_t> &Cycles,
                                            const CodeGenProcModel &PM) {
-  // Default to 1 resource cycle.
-  Cycles.resize(PRVec.size(), 1);
+  assert(PRVec.size() == Cycles.size() && "failed precondition");
   for (unsigned i = 0, e = PRVec.size(); i != e; ++i) {
     Record *PRDef = PRVec[i];
     RecVec SubResources;
     if (PRDef->isSubClassOf("ProcResGroup"))
       SubResources = PRDef->getValueAsListOfDefs("Resources");
     else {
       SubResources.push_back(PRDef);
       PRDef = SchedModels.findProcResUnits(PRDef, PM, PRDef->getLoc());
for (unsigned W : Writes) {
         SCDesc.BeginGroup |= WriteRes->getValueAsBit("SingleIssue");
         SCDesc.EndGroup |= WriteRes->getValueAsBit("SingleIssue");
 
         // Create an entry for each ProcResource listed in WriteRes.
         RecVec PRVec = WriteRes->getValueAsListOfDefs("ProcResources");
         std::vector<int64_t> Cycles =
           WriteRes->getValueAsListOfInts("ResourceCycles");
 
+        // FIXME: We should make `ResourceCycles` mandatory so that we can
+        // validate more.
+        if (Cycles.empty()) {
+          // If ResourceCycles is not provided, default to one cycle per
+          // resource.
+          Cycles.resize(PRVec.size(), 1);
+        } else if (Cycles.size() != PRVec.size()) {
+          // If ResourceCycles is provided, check consistency.
+          PrintFatalError(
+              WriteRes->getLoc(),
+              Twine("Inconsistent resource cycles: !size(ResourceCycles) != "
+                    "!size(ProcResources): ")
+                  .concat(Twine(PRVec.size()))
+                  .concat(" vs ")
+                  .concat(Twine(Cycles.size())));
+        }
+        // TODO(courbet): check NumMicroOps.
+
         ExpandProcResources(PRVec, Cycles, ProcModel);
 
         for (unsigned PRIdx = 0, PREnd = PRVec.size();
              PRIdx != PREnd; ++PRIdx) {
           MCWriteProcResEntry WPREntry;
           WPREntry.ProcResourceIdx = ProcModel.getProcResourceIdx(PRVec[PRIdx]);
           assert(WPREntry.ProcResourceIdx && "Bad ProcResourceIdx");
           WPREntry.Cycles = Cycles[PRIdx];