bool Constructor::needBuilding(UnitType type)
{
if (AgentManager::getInstance()->hasBuilding(type)) return false;
if (isBeingBuilt(type)) return false;
if (containsType(type)) return false;
return true;
}
Project::Project(const QString &mimeType, const Utils::FileName &fileName,
const ProjectDocument::ProjectCallback &callback) :
d(new ProjectPrivate(mimeType, fileName, callback))
{
d->m_macroExpander.setDisplayName(tr("Project"));
d->m_macroExpander.registerVariable("Project:Name", tr("Project Name"),
[this] { return displayName(); });
// Only set up containernode after d is set so that it will find the project directory!
d->m_containerNode = std::make_unique<ContainerNode>(this);
setRequiredKitPredicate([this](const Kit *k) {
return !containsType(projectIssues(k), Task::TaskType::Error);
});
}
void BuildPlanner::expand(UnitType commandCenterUnit)
{
if (containsType(commandCenterUnit))
{
return;
}
TilePosition pos = CoverMap::getInstance()->findExpansionSite();
if (pos.x() == -1)
{
//No expansion site found.
return;
}
addBuildingFirst(commandCenterUnit);
}
bool DeployConfigurationFactory::canHandle(Target *target) const
{
if (m_supportedProjectType.isValid()) {
if (target->project()->id() != m_supportedProjectType)
return false;
}
if (containsType(target->project()->projectIssues(target->kit()), Task::TaskType::Error))
return false;
if (!m_supportedTargetDeviceTypes.isEmpty()) {
if (!m_supportedTargetDeviceTypes.contains(
DeviceTypeKitAspect::deviceTypeId(target->kit())))
return false;
}
return true;
}
void Constructor::expand(UnitType commandCenterUnit)
{
if (isBeingBuilt(commandCenterUnit))
{
return;
}
if (containsType(commandCenterUnit))
{
return;
}
TilePosition pos = BuildingPlacer::getInstance()->findExpansionSite();
if (pos.x == -1)
{
//No expansion site found.
return;
}
buildPlan.insert(buildPlan.begin(), commandCenterUnit);
}
bool Metadata::typeWritten(void) const
{
return containsType(m_dataWrite);
}
bool Metadata::haveType(void) const
{
return containsType(m_dataRead);
}
// Hook to visit each operand type and result type of an instruction.
// Will be called multiple times for one instruction, once for each typed
// operand and the result.
void Builder::postProcessType(const Instruction& inst, Id typeId)
{
// Characterize the type being questioned
Id basicTypeOp = getMostBasicTypeClass(typeId);
int width = 0;
if (basicTypeOp == OpTypeFloat || basicTypeOp == OpTypeInt)
width = getScalarTypeWidth(typeId);
// Do opcode-specific checks
switch (inst.getOpCode()) {
case OpLoad:
case OpStore:
if (basicTypeOp == OpTypeStruct) {
if (containsType(typeId, OpTypeInt, 8))
addCapability(CapabilityInt8);
if (containsType(typeId, OpTypeInt, 16))
addCapability(CapabilityInt16);
if (containsType(typeId, OpTypeFloat, 16))
addCapability(CapabilityFloat16);
} else {
StorageClass storageClass = getStorageClass(inst.getIdOperand(0));
if (width == 8) {
switch (storageClass) {
case StorageClassUniform:
case StorageClassStorageBuffer:
case StorageClassPushConstant:
break;
default:
addCapability(CapabilityInt8);
break;
}
} else if (width == 16) {
switch (storageClass) {
case StorageClassUniform:
case StorageClassStorageBuffer:
case StorageClassPushConstant:
case StorageClassInput:
case StorageClassOutput:
break;
default:
if (basicTypeOp == OpTypeInt)
addCapability(CapabilityInt16);
if (basicTypeOp == OpTypeFloat)
addCapability(CapabilityFloat16);
break;
}
}
}
break;
case OpAccessChain:
case OpPtrAccessChain:
case OpCopyObject:
case OpFConvert:
case OpSConvert:
case OpUConvert:
break;
default:
if (basicTypeOp == OpTypeFloat && width == 16)
addCapability(CapabilityFloat16);
if (basicTypeOp == OpTypeInt && width == 16)
addCapability(CapabilityInt16);
if (basicTypeOp == OpTypeInt && width == 8)
addCapability(CapabilityInt8);
break;
}
}
int ProbabilisticType::getIndex(Type* probableType) {
AvmAssert(containsType(probableType));
return _probableType->indexOf(probableType);
}
