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