mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-09-03 18:29:48 +00:00
sequence - target independent framework When the DAGcombiner selects instruction sequences it could increase the critical path or resource len. For example, on arm64 there are multiply-accumulate instructions (madd, msub). If e.g. the equivalent multiply-add sequence is not on the crictial path it makes sense to select it instead of the combined, single accumulate instruction (madd/msub). The reason is that the conversion from add+mul to the madd could lengthen the critical path by the latency of the multiply. But the DAGCombiner would always combine and select the madd/msub instruction. This patch uses machine trace metrics to estimate critical path length and resource length of an original instruction sequence vs a combined instruction sequence and picks the faster code based on its estimates. This patch only commits the target independent framework that evaluates and selects code sequences. The machine instruction combiner is turned off for all targets and expected to evolve over time by gradually handling DAGCombiner pattern in the target specific code. This framework lays the groundwork for fixing rdar://16319955 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@214666 91177308-0d34-0410-b5e6-96231b3b80d8
182 lines
6.7 KiB
C++
182 lines
6.7 KiB
C++
//===-- llvm/CodeGen/TargetSchedule.h - Sched Machine Model -----*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines a wrapper around MCSchedModel that allows the interface to
|
|
// benefit from information currently only available in TargetInstrInfo.
|
|
// Ideally, the scheduling interface would be fully defined in the MC layer.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_CODEGEN_TARGETSCHEDULE_H
|
|
#define LLVM_CODEGEN_TARGETSCHEDULE_H
|
|
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include "llvm/MC/MCInstrItineraries.h"
|
|
#include "llvm/MC/MCSchedule.h"
|
|
#include "llvm/Target/TargetSubtargetInfo.h"
|
|
|
|
namespace llvm {
|
|
|
|
class TargetRegisterInfo;
|
|
class TargetSubtargetInfo;
|
|
class TargetInstrInfo;
|
|
class MachineInstr;
|
|
|
|
/// Provide an instruction scheduling machine model to CodeGen passes.
|
|
class TargetSchedModel {
|
|
// For efficiency, hold a copy of the statically defined MCSchedModel for this
|
|
// processor.
|
|
MCSchedModel SchedModel;
|
|
InstrItineraryData InstrItins;
|
|
const TargetSubtargetInfo *STI;
|
|
const TargetInstrInfo *TII;
|
|
|
|
SmallVector<unsigned, 16> ResourceFactors;
|
|
unsigned MicroOpFactor; // Multiply to normalize microops to resource units.
|
|
unsigned ResourceLCM; // Resource units per cycle. Latency normalization factor.
|
|
public:
|
|
TargetSchedModel(): STI(nullptr), TII(nullptr) {}
|
|
|
|
/// \brief Initialize the machine model for instruction scheduling.
|
|
///
|
|
/// The machine model API keeps a copy of the top-level MCSchedModel table
|
|
/// indices and may query TargetSubtargetInfo and TargetInstrInfo to resolve
|
|
/// dynamic properties.
|
|
void init(const MCSchedModel &sm, const TargetSubtargetInfo *sti,
|
|
const TargetInstrInfo *tii);
|
|
|
|
/// Return the MCSchedClassDesc for this instruction.
|
|
const MCSchedClassDesc *resolveSchedClass(const MachineInstr *MI) const;
|
|
|
|
/// \brief TargetInstrInfo getter.
|
|
const TargetInstrInfo *getInstrInfo() const { return TII; }
|
|
|
|
/// \brief Return true if this machine model includes an instruction-level
|
|
/// scheduling model.
|
|
///
|
|
/// This is more detailed than the course grain IssueWidth and default
|
|
/// latency properties, but separate from the per-cycle itinerary data.
|
|
bool hasInstrSchedModel() const;
|
|
|
|
const MCSchedModel *getMCSchedModel() const { return &SchedModel; }
|
|
|
|
/// \brief Return true if this machine model includes cycle-to-cycle itinerary
|
|
/// data.
|
|
///
|
|
/// This models scheduling at each stage in the processor pipeline.
|
|
bool hasInstrItineraries() const;
|
|
|
|
const InstrItineraryData *getInstrItineraries() const {
|
|
if (hasInstrItineraries())
|
|
return &InstrItins;
|
|
return nullptr;
|
|
}
|
|
|
|
/// \brief Identify the processor corresponding to the current subtarget.
|
|
unsigned getProcessorID() const { return SchedModel.getProcessorID(); }
|
|
|
|
/// \brief Maximum number of micro-ops that may be scheduled per cycle.
|
|
unsigned getIssueWidth() const { return SchedModel.IssueWidth; }
|
|
|
|
/// \brief Return the number of issue slots required for this MI.
|
|
unsigned getNumMicroOps(const MachineInstr *MI,
|
|
const MCSchedClassDesc *SC = nullptr) const;
|
|
|
|
/// \brief Get the number of kinds of resources for this target.
|
|
unsigned getNumProcResourceKinds() const {
|
|
return SchedModel.getNumProcResourceKinds();
|
|
}
|
|
|
|
/// \brief Get a processor resource by ID for convenience.
|
|
const MCProcResourceDesc *getProcResource(unsigned PIdx) const {
|
|
return SchedModel.getProcResource(PIdx);
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
const char *getResourceName(unsigned PIdx) const {
|
|
if (!PIdx)
|
|
return "MOps";
|
|
return SchedModel.getProcResource(PIdx)->Name;
|
|
}
|
|
#endif
|
|
|
|
typedef const MCWriteProcResEntry *ProcResIter;
|
|
|
|
// \brief Get an iterator into the processor resources consumed by this
|
|
// scheduling class.
|
|
ProcResIter getWriteProcResBegin(const MCSchedClassDesc *SC) const {
|
|
// The subtarget holds a single resource table for all processors.
|
|
return STI->getWriteProcResBegin(SC);
|
|
}
|
|
ProcResIter getWriteProcResEnd(const MCSchedClassDesc *SC) const {
|
|
return STI->getWriteProcResEnd(SC);
|
|
}
|
|
|
|
/// \brief Multiply the number of units consumed for a resource by this factor
|
|
/// to normalize it relative to other resources.
|
|
unsigned getResourceFactor(unsigned ResIdx) const {
|
|
return ResourceFactors[ResIdx];
|
|
}
|
|
|
|
/// \brief Multiply number of micro-ops by this factor to normalize it
|
|
/// relative to other resources.
|
|
unsigned getMicroOpFactor() const {
|
|
return MicroOpFactor;
|
|
}
|
|
|
|
/// \brief Multiply cycle count by this factor to normalize it relative to
|
|
/// other resources. This is the number of resource units per cycle.
|
|
unsigned getLatencyFactor() const {
|
|
return ResourceLCM;
|
|
}
|
|
|
|
/// \brief Number of micro-ops that may be buffered for OOO execution.
|
|
unsigned getMicroOpBufferSize() const { return SchedModel.MicroOpBufferSize; }
|
|
|
|
/// \brief Number of resource units that may be buffered for OOO execution.
|
|
/// \return The buffer size in resource units or -1 for unlimited.
|
|
int getResourceBufferSize(unsigned PIdx) const {
|
|
return SchedModel.getProcResource(PIdx)->BufferSize;
|
|
}
|
|
|
|
/// \brief Compute operand latency based on the available machine model.
|
|
///
|
|
/// Compute and return the latency of the given data dependent def and use
|
|
/// when the operand indices are already known. UseMI may be NULL for an
|
|
/// unknown user.
|
|
unsigned computeOperandLatency(const MachineInstr *DefMI, unsigned DefOperIdx,
|
|
const MachineInstr *UseMI, unsigned UseOperIdx)
|
|
const;
|
|
|
|
/// \brief Compute the instruction latency based on the available machine
|
|
/// model.
|
|
///
|
|
/// Compute and return the expected latency of this instruction independent of
|
|
/// a particular use. computeOperandLatency is the preferred API, but this is
|
|
/// occasionally useful to help estimate instruction cost.
|
|
///
|
|
/// If UseDefaultDefLatency is false and no new machine sched model is
|
|
/// present this method falls back to TII->getInstrLatency with an empty
|
|
/// instruction itinerary (this is so we preserve the previous behavior of the
|
|
/// if converter after moving it to TargetSchedModel).
|
|
unsigned computeInstrLatency(const MachineInstr *MI,
|
|
bool UseDefaultDefLatency = true) const;
|
|
unsigned computeInstrLatency(unsigned Opcode) const;
|
|
|
|
/// \brief Output dependency latency of a pair of defs of the same register.
|
|
///
|
|
/// This is typically one cycle.
|
|
unsigned computeOutputLatency(const MachineInstr *DefMI, unsigned DefIdx,
|
|
const MachineInstr *DepMI) const;
|
|
};
|
|
|
|
} // namespace llvm
|
|
|
|
#endif
|