1 /* 2 * Copyright 2016 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #ifndef SKIASL_MEMORYLAYOUT 9 #define SKIASL_MEMORYLAYOUT 10 11 #include <algorithm> 12 13 #include "src/sksl/ir/SkSLType.h" 14 15 namespace SkSL { 16 17 class MemoryLayout { 18 public: 19 enum Standard { 20 k140_Standard, 21 k430_Standard, 22 kMetal_Standard 23 }; 24 MemoryLayout(Standard std)25 MemoryLayout(Standard std) 26 : fStd(std) {} 27 vector_alignment(size_t componentSize,int columns)28 static size_t vector_alignment(size_t componentSize, int columns) { 29 return componentSize * (columns + columns % 2); 30 } 31 32 /** 33 * Rounds up to the nearest multiple of 16 if in std140, otherwise returns the parameter 34 * unchanged (std140 requires various things to be rounded up to the nearest multiple of 16, 35 * std430 does not). 36 */ roundUpIfNeeded(size_t raw)37 size_t roundUpIfNeeded(size_t raw) const { 38 switch (fStd) { 39 case k140_Standard: return (raw + 15) & ~15; 40 case k430_Standard: return raw; 41 case kMetal_Standard: return raw; 42 } 43 SkUNREACHABLE; 44 } 45 46 /** 47 * Returns a type's required alignment when used as a standalone variable. 48 */ alignment(const Type & type)49 size_t alignment(const Type& type) const { 50 // See OpenGL Spec 7.6.2.2 Standard Uniform Block Layout 51 switch (type.typeKind()) { 52 case Type::TypeKind::kScalar: 53 case Type::TypeKind::kEnum: 54 return this->size(type); 55 case Type::TypeKind::kVector: 56 return vector_alignment(this->size(type.componentType()), type.columns()); 57 case Type::TypeKind::kMatrix: 58 return this->roundUpIfNeeded(vector_alignment(this->size(type.componentType()), 59 type.rows())); 60 case Type::TypeKind::kArray: 61 return this->roundUpIfNeeded(this->alignment(type.componentType())); 62 case Type::TypeKind::kStruct: { 63 size_t result = 0; 64 for (const auto& f : type.fields()) { 65 size_t alignment = this->alignment(*f.fType); 66 if (alignment > result) { 67 result = alignment; 68 } 69 } 70 return this->roundUpIfNeeded(result); 71 } 72 default: 73 SK_ABORT("cannot determine size of type %s", String(type.name()).c_str()); 74 } 75 } 76 77 /** 78 * For matrices and arrays, returns the number of bytes from the start of one entry (row, in 79 * the case of matrices) to the start of the next. 80 */ stride(const Type & type)81 size_t stride(const Type& type) const { 82 switch (type.typeKind()) { 83 case Type::TypeKind::kMatrix: { 84 size_t base = vector_alignment(this->size(type.componentType()), type.rows()); 85 return this->roundUpIfNeeded(base); 86 } 87 case Type::TypeKind::kArray: { 88 int stride = this->size(type.componentType()); 89 if (stride > 0) { 90 int align = this->alignment(type.componentType()); 91 stride += align - 1; 92 stride -= stride % align; 93 stride = this->roundUpIfNeeded(stride); 94 } 95 return stride; 96 } 97 default: 98 SK_ABORT("type does not have a stride"); 99 } 100 } 101 102 /** 103 * Returns the size of a type in bytes. 104 */ size(const Type & type)105 size_t size(const Type& type) const { 106 switch (type.typeKind()) { 107 case Type::TypeKind::kScalar: 108 if (type.isBoolean()) { 109 return 1; 110 } 111 // FIXME need to take precision into account, once we figure out how we want to 112 // handle it... 113 return 4; 114 case Type::TypeKind::kEnum: 115 return 4; 116 case Type::TypeKind::kVector: 117 if (fStd == kMetal_Standard && type.columns() == 3) { 118 return 4 * this->size(type.componentType()); 119 } 120 return type.columns() * this->size(type.componentType()); 121 case Type::TypeKind::kMatrix: // fall through 122 case Type::TypeKind::kArray: 123 return type.columns() * this->stride(type); 124 case Type::TypeKind::kStruct: { 125 size_t total = 0; 126 for (const auto& f : type.fields()) { 127 size_t alignment = this->alignment(*f.fType); 128 if (total % alignment != 0) { 129 total += alignment - total % alignment; 130 } 131 SkASSERT(total % alignment == 0); 132 total += this->size(*f.fType); 133 } 134 size_t alignment = this->alignment(type); 135 SkASSERT(!type.fields().size() || 136 (0 == alignment % this->alignment(*type.fields()[0].fType))); 137 return (total + alignment - 1) & ~(alignment - 1); 138 } 139 default: 140 SK_ABORT("cannot determine size of type %s", String(type.name()).c_str()); 141 } 142 } 143 144 /** 145 * Not all types are compatible with memory layout. 146 */ LayoutIsSupported(const Type & type)147 static size_t LayoutIsSupported(const Type& type) { 148 switch (type.typeKind()) { 149 case Type::TypeKind::kScalar: 150 case Type::TypeKind::kEnum: 151 case Type::TypeKind::kVector: 152 case Type::TypeKind::kMatrix: 153 return true; 154 155 case Type::TypeKind::kArray: 156 return LayoutIsSupported(type.componentType()); 157 158 case Type::TypeKind::kStruct: 159 return std::all_of( 160 type.fields().begin(), type.fields().end(), 161 [](const Type::Field& f) { return LayoutIsSupported(*f.fType); }); 162 163 default: 164 return false; 165 } 166 } 167 168 const Standard fStd; 169 }; 170 171 } // namespace SkSL 172 173 #endif 174