[System Model] [TTI] Add TTI interfaces for write-combining buffers

[greened]

Summary

Add interfaces for subtargets to return the number of write-combining buffers available. Also provide TTI interfaces that delegate to the subtarget interface.

[hfinkel]

How do you imagine that we'd use this? Do we need some kind of size to go along with this?

[greened]

In D68793#1704266, @hfinkel wrote:

How do you imagine that we'd use this? Do we need some kind of size to go along with this?

See the Intel optimization guide, section 3.6.9.

https://software.intel.com/sites/default/files/managed/9e/bc/64-ia-32-architectures-optimization-manual.pdf

Basically, this information can be used to inform loop transformations as well as use of non-temporal instructions. A write-combining buffer is not the same as a store buffer. A write-combining buffer is always one cache line in size, so I don't think we need size information.

[hfinkel]

In D68793#1704496, @greened wrote:

In D68793#1704266, @hfinkel wrote:

How do you imagine that we'd use this? Do we need some kind of size to go along with this?

See the Intel optimization guide, section 3.6.9.

https://software.intel.com/sites/default/files/managed/9e/bc/64-ia-32-architectures-optimization-manual.pdf

Basically, this information can be used to inform loop transformations as well as use of non-temporal instructions. A write-combining buffer is not the same as a store buffer. A write-combining buffer is always one cache line in size, so I don't think we need size information.

Alright, thanks. First, we should document this in the interface. Instead of just saying:

\return the number of write-combining buffers.

we might say something like:

\return the number of write-combining buffers. A write-combining buffer is a per-core resource used for collecting writes to a particular cache line before further processing those writes using other parts of the memory subsystem.

we already have getCacheLineSize(), so we know how big that is, but we don't currently have a way to account for how many hardware threads per core, right? Don't we need that to estimate how many write-combining buffers we get for the current hardware thread? (Presumably, we'd want the same thing to use the total-cache-size functions too, because we need to generate code assuming a working-set size per thread?)

The Intel optimization guide talks about using this number to drive loop distribution, where we don't update more arrays (cache lines) at a time than can fit into the thread's WC buffers. Is this what you had in mind?

[greened]

we might say something like:

\return the number of write-combining buffers. A write-combining buffer is a per-core resource used for collecting writes to a particular cache line before further processing those writes using other parts of the memory subsystem.

Will do.

we already have getCacheLineSize(), so we know how big that is, but we don't currently have a way to account for how many hardware threads per core, right? Don't we need that to estimate how many write-combining buffers we get for the current hardware thread? (Presumably, we'd want the same thing to use the total-cache-size functions too, because we need to generate code assuming a working-set size per thread?)

This is something that will become available once more bits of the system model are implemented. The model can specify things like number of cores and threads per core. The subtarget will be able to examine its execution resource configuration and return an appropriate number. After this patch makes it through I will be in a place where I can start posting the TableGen changes to generate models and then post the TableGen model classes after that. At that point targets can define their own models and away we go.

The Intel optimization guide talks about using this number to drive loop distribution, where we don't update more arrays (cache lines) at a time than can fit into the thread's WC buffers. Is this what you had in mind?

Yes. It's useful for anything that cares about performance of writes to memory.

[greened]

Added comment explaining what a write-combining buffer is and one possibility of how to use this information.

[greened]

Ok, I think I've addressed all the comments so this is ready for another review. Thanks!

[greened]

Ping. This is ready for another review.

[jdoerfert]

Seems fine to me, @hfinkel?

[greened]

Updated to latest master.

[greened]

@jdoerfert @hfinkel should I consider Johannes' comment a LGTM? This has been waiting for two months now.

llvm/include/llvm/Analysis/TargetTransformInfo.h

public:
   /// i.e. prefetch with any stride.
   unsigned getMinPrefetchStride() const;
 
   /// \return The maximum number of iterations to prefetch ahead.  If
   /// the required number of iterations is more than this number, no
   /// prefetching is performed.
   unsigned getMaxPrefetchIterationsAhead() const;
 
+  /// \return the number of write-combining buffers. A write-combining buffer is
+  /// a per-core resource used for collecting writes to a particular cache line
+  /// before further processing those writes using other parts of the memory
+  /// subsystem.  Knowledge of the number of write-combining buffers available
+  /// can help the optimizer manage those resources, for example fissioning
+  /// loops to avoid oversubscribing write-combining buffers.
+  unsigned getNumWriteCombiningBuffers() const;
+
   /// \return The maximum interleave factor that any transform should try to
   /// perform for this target. This number depends on the level of parallelism
   /// and the number of execution units in the CPU.
   unsigned getMaxInterleaveFactor(unsigned VF) const;
 
   /// Collect properties of V used in cost analysis, e.g. OP_PowerOf2.
   static OperandValueKind getOperandInfo(Value *V,
                                          OperandValueProperties &OpProps);
public:
   /// i.e. prefetch with any stride.
   virtual unsigned getMinPrefetchStride() const = 0;
 
   /// \return The maximum number of iterations to prefetch ahead.  If
   /// the required number of iterations is more than this number, no
   /// prefetching is performed.
   virtual unsigned getMaxPrefetchIterationsAhead() const = 0;
 
+  /// \return the number of write-combining buffers.
+  virtual unsigned getNumWriteCombiningBuffers() const = 0;
+
   virtual unsigned getMaxInterleaveFactor(unsigned VF) = 0;
   virtual unsigned getArithmeticInstrCost(
       unsigned Opcode, Type *Ty, OperandValueKind Opd1Info,
       OperandValueKind Opd2Info, OperandValueProperties Opd1PropInfo,
       OperandValueProperties Opd2PropInfo, ArrayRef<const Value *> Args,
       const Instruction *CxtI = nullptr) = 0;
   virtual int getShuffleCost(ShuffleKind Kind, Type *Tp, int Index,
                              Type *SubTp) = 0;
public:
 
   /// Return the maximum prefetch distance in terms of loop
   /// iterations.
   ///
   unsigned getMaxPrefetchIterationsAhead() const override {
     return Impl.getMaxPrefetchIterationsAhead();
   }
 
+  /// Return the number of write-combining buffers.
+  unsigned getNumWriteCombiningBuffers() const override {
+    return Impl.getNumWriteCombiningBuffers();
+  }
+
   unsigned getMaxInterleaveFactor(unsigned VF) override {
     return Impl.getMaxInterleaveFactor(VF);
   }
   unsigned getEstimatedNumberOfCaseClusters(const SwitchInst &SI,
                                             unsigned &JTSize,
                                             ProfileSummaryInfo *PSI,
                                             BlockFrequencyInfo *BFI) override {
     return Impl.getEstimatedNumberOfCaseClusters(SI, JTSize, PSI, BFI);

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

llvm::Optional<unsigned> getCacheAssociativity(
 
     llvm_unreachable("Unknown TargetTransformInfo::CacheLevel");
   }
 
   unsigned getPrefetchDistance() const { return 0; }
   unsigned getMinPrefetchStride() const { return 1; }
   unsigned getMaxPrefetchIterationsAhead() const { return UINT_MAX; }
 
+  /// Return the default number of write-combining buffers.
+  unsigned getNumWriteCombiningBuffers() const {
+    return 0;
+  }
+
   unsigned getMaxInterleaveFactor(unsigned VF) { return 1; }
 
   unsigned getArithmeticInstrCost(unsigned Opcode, Type *Ty,
                                   TTI::OperandValueKind Opd1Info,
                                   TTI::OperandValueKind Opd2Info,
                                   TTI::OperandValueProperties Opd1PropInfo,
                                   TTI::OperandValueProperties Opd2PropInfo,
                                   ArrayRef<const Value *> Args,

llvm/include/llvm/CodeGen/BasicTTIImpl.h

public:
   virtual unsigned getMinPrefetchStride() const {
     return getST()->getMinPrefetchStride();
   }
 
   virtual unsigned getMaxPrefetchIterationsAhead() const {
     return getST()->getMaxPrefetchIterationsAhead();
   }
 
+  /// Return the number of write-combining buffers.
+  unsigned getNumWriteCombiningBuffers() const {
+    return getST()->getNumWriteCombiningBuffers();
+  }
+
   /// @}
 
   /// \name Vector TTI Implementations
   /// @{
 
   unsigned getRegisterBitWidth(bool Vector) const { return 32; }
 
   /// Estimate the overhead of scalarizing an instruction. Insert and Extract

llvm/include/llvm/MC/MCSubtargetInfo.h

public:
   /// iterations.
   ///
   virtual unsigned getMaxPrefetchIterationsAhead() const;
 
   /// Return the minimum stride necessary to trigger software
   /// prefetching.
   ///
   virtual unsigned getMinPrefetchStride() const;
+
+  /// Return the number of write-combining buffers.
+  virtual unsigned getNumWriteCombiningBuffers() const;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCSUBTARGETINFO_H

llvm/lib/Analysis/TargetTransformInfo.cpp

 unsigned TargetTransformInfo::getMinPrefetchStride() const {
   return TTIImpl->getMinPrefetchStride();
 }
 
 unsigned TargetTransformInfo::getMaxPrefetchIterationsAhead() const {
   return TTIImpl->getMaxPrefetchIterationsAhead();
 }
 
+unsigned TargetTransformInfo::getNumWriteCombiningBuffers() const {
+  return TTIImpl->getNumWriteCombiningBuffers();
+}
+
 unsigned TargetTransformInfo::getMaxInterleaveFactor(unsigned VF) const {
   return TTIImpl->getMaxInterleaveFactor(VF);
 }
 
 TargetTransformInfo::OperandValueKind
 TargetTransformInfo::getOperandInfo(Value *V, OperandValueProperties &OpProps) {
   OperandValueKind OpInfo = OK_AnyValue;
   OpProps = OP_None;

llvm/lib/MC/MCSubtargetInfo.cpp

 
 unsigned MCSubtargetInfo::getMaxPrefetchIterationsAhead() const {
   return UINT_MAX;
 }
 
 unsigned MCSubtargetInfo::getMinPrefetchStride() const {
   return 1;
 }
+
+unsigned MCSubtargetInfo::getNumWriteCombiningBuffers() const {
+  return 0;
+}