1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 // This file contains the common parts of command buffer formats. 6 7 #ifndef GPU_COMMAND_BUFFER_COMMON_CMD_BUFFER_COMMON_H_ 8 #define GPU_COMMAND_BUFFER_COMMON_CMD_BUFFER_COMMON_H_ 9 10 #include <stddef.h> 11 12 #include "gpu/command_buffer/common/bitfield_helpers.h" 13 #include "gpu/command_buffer/common/logging.h" 14 #include "gpu/command_buffer/common/types.h" 15 #include "gpu/gpu_export.h" 16 17 namespace gpu { 18 19 namespace cmd { 20 enum ArgFlags { 21 kFixed = 0x0, 22 kAtLeastN = 0x1 23 }; 24 } // namespace cmd 25 26 // Computes the number of command buffer entries needed for a certain size. In 27 // other words it rounds up to a multiple of entries. 28 inline uint32 ComputeNumEntries(size_t size_in_bytes) { 29 return static_cast<uint32>( 30 (size_in_bytes + sizeof(uint32) - 1) / sizeof(uint32)); // NOLINT 31 } 32 33 // Rounds up to a multiple of entries in bytes. 34 inline size_t RoundSizeToMultipleOfEntries(size_t size_in_bytes) { 35 return ComputeNumEntries(size_in_bytes) * sizeof(uint32); // NOLINT 36 } 37 38 // Struct that defines the command header in the command buffer. 39 struct CommandHeader { 40 Uint32 size:21; 41 Uint32 command:11; 42 43 GPU_EXPORT static const int32 kMaxSize = (1 << 21) - 1; 44 45 void Init(uint32 _command, int32 _size) { 46 GPU_DCHECK_LE(_size, kMaxSize); 47 command = _command; 48 size = _size; 49 } 50 51 // Sets the header based on the passed in command. Can not be used for 52 // variable sized commands like immediate commands or Noop. 53 template <typename T> 54 void SetCmd() { 55 COMPILE_ASSERT(T::kArgFlags == cmd::kFixed, Cmd_kArgFlags_not_kFixed); 56 Init(T::kCmdId, ComputeNumEntries(sizeof(T))); // NOLINT 57 } 58 59 // Sets the header by a size in bytes of the immediate data after the command. 60 template <typename T> 61 void SetCmdBySize(uint32 size_of_data_in_bytes) { 62 COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN); 63 Init(T::kCmdId, 64 ComputeNumEntries(sizeof(T) + size_of_data_in_bytes)); // NOLINT 65 } 66 67 // Sets the header by a size in bytes. 68 template <typename T> 69 void SetCmdByTotalSize(uint32 size_in_bytes) { 70 COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN); 71 GPU_DCHECK_GE(size_in_bytes, sizeof(T)); // NOLINT 72 Init(T::kCmdId, ComputeNumEntries(size_in_bytes)); 73 } 74 }; 75 76 COMPILE_ASSERT(sizeof(CommandHeader) == 4, Sizeof_CommandHeader_is_not_4); 77 78 // Union that defines possible command buffer entries. 79 union CommandBufferEntry { 80 CommandHeader value_header; 81 Uint32 value_uint32; 82 Int32 value_int32; 83 float value_float; 84 }; 85 86 const size_t kCommandBufferEntrySize = 4; 87 88 COMPILE_ASSERT(sizeof(CommandBufferEntry) == kCommandBufferEntrySize, 89 Sizeof_CommandBufferEntry_is_not_4); 90 91 // Make sure the compiler does not add extra padding to any of the command 92 // structures. 93 #pragma pack(push, 1) 94 95 // Gets the address of memory just after a structure in a typesafe way. This is 96 // used for IMMEDIATE commands to get the address of the place to put the data. 97 // Immediate command put their data direclty in the command buffer. 98 // Parameters: 99 // cmd: Address of command. 100 template <typename T> 101 void* ImmediateDataAddress(T* cmd) { 102 COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN); 103 return reinterpret_cast<char*>(cmd) + sizeof(*cmd); 104 } 105 106 // Gets the address of the place to put the next command in a typesafe way. 107 // This can only be used for fixed sized commands. 108 template <typename T> 109 // Parameters: 110 // cmd: Address of command. 111 void* NextCmdAddress(void* cmd) { 112 COMPILE_ASSERT(T::kArgFlags == cmd::kFixed, Cmd_kArgFlags_not_kFixed); 113 return reinterpret_cast<char*>(cmd) + sizeof(T); 114 } 115 116 // Gets the address of the place to put the next command in a typesafe way. 117 // This can only be used for variable sized command like IMMEDIATE commands. 118 // Parameters: 119 // cmd: Address of command. 120 // size_of_data_in_bytes: Size of the data for the command. 121 template <typename T> 122 void* NextImmediateCmdAddress(void* cmd, uint32 size_of_data_in_bytes) { 123 COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN); 124 return reinterpret_cast<char*>(cmd) + sizeof(T) + // NOLINT 125 RoundSizeToMultipleOfEntries(size_of_data_in_bytes); 126 } 127 128 // Gets the address of the place to put the next command in a typesafe way. 129 // This can only be used for variable sized command like IMMEDIATE commands. 130 // Parameters: 131 // cmd: Address of command. 132 // size_of_cmd_in_bytes: Size of the cmd and data. 133 template <typename T> 134 void* NextImmediateCmdAddressTotalSize(void* cmd, uint32 total_size_in_bytes) { 135 COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN); 136 GPU_DCHECK_GE(total_size_in_bytes, sizeof(T)); // NOLINT 137 return reinterpret_cast<char*>(cmd) + 138 RoundSizeToMultipleOfEntries(total_size_in_bytes); 139 } 140 141 namespace cmd { 142 143 // This macro is used to safely and convienently expand the list of commnad 144 // buffer commands in to various lists and never have them get out of sync. To 145 // add a new command, add it this list, create the corresponding structure below 146 // and then add a function in gapi_decoder.cc called Handle_COMMAND_NAME where 147 // COMMAND_NAME is the name of your command structure. 148 // 149 // NOTE: THE ORDER OF THESE MUST NOT CHANGE (their id is derived by order) 150 #define COMMON_COMMAND_BUFFER_CMDS(OP) \ 151 OP(Noop) /* 0 */ \ 152 OP(SetToken) /* 1 */ \ 153 OP(SetBucketSize) /* 2 */ \ 154 OP(SetBucketData) /* 3 */ \ 155 OP(SetBucketDataImmediate) /* 4 */ \ 156 OP(GetBucketStart) /* 5 */ \ 157 OP(GetBucketData) /* 6 */ \ 158 159 // Common commands. 160 enum CommandId { 161 #define COMMON_COMMAND_BUFFER_CMD_OP(name) k ## name, 162 163 COMMON_COMMAND_BUFFER_CMDS(COMMON_COMMAND_BUFFER_CMD_OP) 164 165 #undef COMMON_COMMAND_BUFFER_CMD_OP 166 167 kNumCommands, 168 kLastCommonId = 255 // reserve 256 spaces for common commands. 169 }; 170 171 COMPILE_ASSERT(kNumCommands - 1 <= kLastCommonId, Too_many_common_commands); 172 173 const char* GetCommandName(CommandId id); 174 175 // A Noop command. 176 struct Noop { 177 typedef Noop ValueType; 178 static const CommandId kCmdId = kNoop; 179 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 180 181 void SetHeader(uint32 skip_count) { 182 GPU_DCHECK_GT(skip_count, 0u); 183 header.Init(kCmdId, skip_count); 184 } 185 186 void Init(uint32 skip_count) { 187 SetHeader(skip_count); 188 } 189 190 static void* Set(void* cmd, uint32 skip_count) { 191 static_cast<ValueType*>(cmd)->Init(skip_count); 192 return NextImmediateCmdAddress<ValueType>( 193 cmd, skip_count * sizeof(CommandBufferEntry)); // NOLINT 194 } 195 196 CommandHeader header; 197 }; 198 199 COMPILE_ASSERT(sizeof(Noop) == 4, Sizeof_Noop_is_not_4); 200 COMPILE_ASSERT(offsetof(Noop, header) == 0, Offsetof_Noop_header_not_0); 201 202 // The SetToken command puts a token in the command stream that you can 203 // use to check if that token has been passed in the command stream. 204 struct SetToken { 205 typedef SetToken ValueType; 206 static const CommandId kCmdId = kSetToken; 207 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 208 209 void SetHeader() { 210 header.SetCmd<ValueType>(); 211 } 212 213 void Init(uint32 _token) { 214 SetHeader(); 215 token = _token; 216 } 217 static void* Set(void* cmd, uint32 token) { 218 static_cast<ValueType*>(cmd)->Init(token); 219 return NextCmdAddress<ValueType>(cmd); 220 } 221 222 CommandHeader header; 223 uint32 token; 224 }; 225 226 COMPILE_ASSERT(sizeof(SetToken) == 8, Sizeof_SetToken_is_not_8); 227 COMPILE_ASSERT(offsetof(SetToken, header) == 0, 228 Offsetof_SetToken_header_not_0); 229 COMPILE_ASSERT(offsetof(SetToken, token) == 4, 230 Offsetof_SetToken_token_not_4); 231 232 // Sets the size of a bucket for collecting data on the service side. 233 // This is a utility for gathering data on the service side so it can be used 234 // all at once when some service side API is called. It removes the need to add 235 // special commands just to support a particular API. For example, any API 236 // command that needs a string needs a way to send that string to the API over 237 // the command buffers. While you can require that the command buffer or 238 // transfer buffer be large enough to hold the largest string you can send, 239 // using this command removes that restriction by letting you send smaller 240 // pieces over and build up the data on the service side. 241 // 242 // You can clear a bucket on the service side and thereby free memory by sending 243 // a size of 0. 244 struct SetBucketSize { 245 typedef SetBucketSize ValueType; 246 static const CommandId kCmdId = kSetBucketSize; 247 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 248 249 void SetHeader() { 250 header.SetCmd<ValueType>(); 251 } 252 253 void Init(uint32 _bucket_id, uint32 _size) { 254 SetHeader(); 255 bucket_id = _bucket_id; 256 size = _size; 257 } 258 static void* Set(void* cmd, uint32 _bucket_id, uint32 _size) { 259 static_cast<ValueType*>(cmd)->Init(_bucket_id, _size); 260 return NextCmdAddress<ValueType>(cmd); 261 } 262 263 CommandHeader header; 264 uint32 bucket_id; 265 uint32 size; 266 }; 267 268 COMPILE_ASSERT(sizeof(SetBucketSize) == 12, Sizeof_SetBucketSize_is_not_8); 269 COMPILE_ASSERT(offsetof(SetBucketSize, header) == 0, 270 Offsetof_SetBucketSize_header_not_0); 271 COMPILE_ASSERT(offsetof(SetBucketSize, bucket_id) == 4, 272 Offsetof_SetBucketSize_bucket_id_4); 273 COMPILE_ASSERT(offsetof(SetBucketSize, size) == 8, 274 Offsetof_SetBucketSize_size_8); 275 276 // Sets the contents of a portion of a bucket on the service side from data in 277 // shared memory. 278 // See SetBucketSize. 279 struct SetBucketData { 280 typedef SetBucketData ValueType; 281 static const CommandId kCmdId = kSetBucketData; 282 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 283 284 void SetHeader() { 285 header.SetCmd<ValueType>(); 286 } 287 288 void Init(uint32 _bucket_id, 289 uint32 _offset, 290 uint32 _size, 291 uint32 _shared_memory_id, 292 uint32 _shared_memory_offset) { 293 SetHeader(); 294 bucket_id = _bucket_id; 295 offset = _offset; 296 size = _size; 297 shared_memory_id = _shared_memory_id; 298 shared_memory_offset = _shared_memory_offset; 299 } 300 static void* Set(void* cmd, 301 uint32 _bucket_id, 302 uint32 _offset, 303 uint32 _size, 304 uint32 _shared_memory_id, 305 uint32 _shared_memory_offset) { 306 static_cast<ValueType*>(cmd)->Init( 307 _bucket_id, 308 _offset, 309 _size, 310 _shared_memory_id, 311 _shared_memory_offset); 312 return NextCmdAddress<ValueType>(cmd); 313 } 314 315 CommandHeader header; 316 uint32 bucket_id; 317 uint32 offset; 318 uint32 size; 319 uint32 shared_memory_id; 320 uint32 shared_memory_offset; 321 }; 322 323 COMPILE_ASSERT(sizeof(SetBucketData) == 24, Sizeof_SetBucketData_is_not_24); 324 COMPILE_ASSERT(offsetof(SetBucketData, header) == 0, 325 Offsetof_SetBucketData_header_not_0); 326 COMPILE_ASSERT(offsetof(SetBucketData, bucket_id) == 4, 327 Offsetof_SetBucketData_bucket_id_not_4); 328 COMPILE_ASSERT(offsetof(SetBucketData, offset) == 8, 329 Offsetof_SetBucketData_offset_not_8); 330 COMPILE_ASSERT(offsetof(SetBucketData, size) == 12, 331 Offsetof_SetBucketData_size_not_12); 332 COMPILE_ASSERT(offsetof(SetBucketData, shared_memory_id) == 16, 333 Offsetof_SetBucketData_shared_memory_id_not_16); 334 COMPILE_ASSERT(offsetof(SetBucketData, shared_memory_offset) == 20, 335 Offsetof_SetBucketData_shared_memory_offset_not_20); 336 337 // Sets the contents of a portion of a bucket on the service side from data in 338 // the command buffer. 339 // See SetBucketSize. 340 struct SetBucketDataImmediate { 341 typedef SetBucketDataImmediate ValueType; 342 static const CommandId kCmdId = kSetBucketDataImmediate; 343 static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; 344 345 void SetHeader(uint32 size) { 346 header.SetCmdBySize<ValueType>(size); 347 } 348 349 void Init(uint32 _bucket_id, 350 uint32 _offset, 351 uint32 _size) { 352 SetHeader(_size); 353 bucket_id = _bucket_id; 354 offset = _offset; 355 size = _size; 356 } 357 static void* Set(void* cmd, 358 uint32 _bucket_id, 359 uint32 _offset, 360 uint32 _size) { 361 static_cast<ValueType*>(cmd)->Init( 362 _bucket_id, 363 _offset, 364 _size); 365 return NextImmediateCmdAddress<ValueType>(cmd, _size); 366 } 367 368 CommandHeader header; 369 uint32 bucket_id; 370 uint32 offset; 371 uint32 size; 372 }; 373 374 COMPILE_ASSERT(sizeof(SetBucketDataImmediate) == 16, 375 Sizeof_SetBucketDataImmediate_is_not_24); 376 COMPILE_ASSERT(offsetof(SetBucketDataImmediate, header) == 0, 377 Offsetof_SetBucketDataImmediate_header_not_0); 378 COMPILE_ASSERT(offsetof(SetBucketDataImmediate, bucket_id) == 4, 379 Offsetof_SetBucketDataImmediate_bucket_id_not_4); 380 COMPILE_ASSERT(offsetof(SetBucketDataImmediate, offset) == 8, 381 Offsetof_SetBucketDataImmediate_offset_not_8); 382 COMPILE_ASSERT(offsetof(SetBucketDataImmediate, size) == 12, 383 Offsetof_SetBucketDataImmediate_size_not_12); 384 385 // Gets the start of a bucket the service has available. Sending a variable size 386 // result back to the client and the portion of that result that fits in the 387 // supplied shared memory. If the size of the result is larger than the supplied 388 // shared memory the rest of the bucket's contents can be retrieved with 389 // GetBucketData. 390 // 391 // This is used for example for any API that returns a string. The problem is 392 // the largest thing you can send back in 1 command is the size of your shared 393 // memory. This command along with GetBucketData implements a way to get a 394 // result a piece at a time to help solve that problem in a generic way. 395 struct GetBucketStart { 396 typedef GetBucketStart ValueType; 397 static const CommandId kCmdId = kGetBucketStart; 398 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 399 400 typedef uint32 Result; 401 402 void SetHeader() { 403 header.SetCmd<ValueType>(); 404 } 405 406 void Init(uint32 _bucket_id, 407 uint32 _result_memory_id, 408 uint32 _result_memory_offset, 409 uint32 _data_memory_size, 410 uint32 _data_memory_id, 411 uint32 _data_memory_offset) { 412 SetHeader(); 413 bucket_id = _bucket_id; 414 result_memory_id = _result_memory_id; 415 result_memory_offset = _result_memory_offset; 416 data_memory_size = _data_memory_size; 417 data_memory_id = _data_memory_id; 418 data_memory_offset = _data_memory_offset; 419 } 420 static void* Set(void* cmd, 421 uint32 _bucket_id, 422 uint32 _result_memory_id, 423 uint32 _result_memory_offset, 424 uint32 _data_memory_size, 425 uint32 _data_memory_id, 426 uint32 _data_memory_offset) { 427 static_cast<ValueType*>(cmd)->Init( 428 _bucket_id, 429 _result_memory_id, 430 _result_memory_offset, 431 _data_memory_size, 432 _data_memory_id, 433 _data_memory_offset); 434 return NextCmdAddress<ValueType>(cmd); 435 } 436 437 CommandHeader header; 438 uint32 bucket_id; 439 uint32 result_memory_id; 440 uint32 result_memory_offset; 441 uint32 data_memory_size; 442 uint32 data_memory_id; 443 uint32 data_memory_offset; 444 }; 445 446 COMPILE_ASSERT(sizeof(GetBucketStart) == 28, Sizeof_GetBucketStart_is_not_28); 447 COMPILE_ASSERT(offsetof(GetBucketStart, header) == 0, 448 Offsetof_GetBucketStart_header_not_0); 449 COMPILE_ASSERT(offsetof(GetBucketStart, bucket_id) == 4, 450 Offsetof_GetBucketStart_bucket_id_not_4); 451 COMPILE_ASSERT(offsetof(GetBucketStart, result_memory_id) == 8, 452 Offsetof_GetBucketStart_result_memory_id_not_8); 453 COMPILE_ASSERT(offsetof(GetBucketStart, result_memory_offset) == 12, 454 Offsetof_GetBucketStart_result_memory_offset_not_12); 455 COMPILE_ASSERT(offsetof(GetBucketStart, data_memory_size) == 16, 456 Offsetof_GetBucketStart_data_memory_size_not_16); 457 COMPILE_ASSERT(offsetof(GetBucketStart, data_memory_id) == 20, 458 Offsetof_GetBucketStart_data_memory_id_not_20); 459 COMPILE_ASSERT(offsetof(GetBucketStart, data_memory_offset) == 24, 460 Offsetof_GetBucketStart_data_memory_offset_not_24); 461 462 // Gets a piece of a result the service as available. 463 // See GetBucketSize. 464 struct GetBucketData { 465 typedef GetBucketData ValueType; 466 static const CommandId kCmdId = kGetBucketData; 467 static const cmd::ArgFlags kArgFlags = cmd::kFixed; 468 469 void SetHeader() { 470 header.SetCmd<ValueType>(); 471 } 472 473 void Init(uint32 _bucket_id, 474 uint32 _offset, 475 uint32 _size, 476 uint32 _shared_memory_id, 477 uint32 _shared_memory_offset) { 478 SetHeader(); 479 bucket_id = _bucket_id; 480 offset = _offset; 481 size = _size; 482 shared_memory_id = _shared_memory_id; 483 shared_memory_offset = _shared_memory_offset; 484 } 485 static void* Set(void* cmd, 486 uint32 _bucket_id, 487 uint32 _offset, 488 uint32 _size, 489 uint32 _shared_memory_id, 490 uint32 _shared_memory_offset) { 491 static_cast<ValueType*>(cmd)->Init( 492 _bucket_id, 493 _offset, 494 _size, 495 _shared_memory_id, 496 _shared_memory_offset); 497 return NextCmdAddress<ValueType>(cmd); 498 } 499 500 CommandHeader header; 501 uint32 bucket_id; 502 uint32 offset; 503 uint32 size; 504 uint32 shared_memory_id; 505 uint32 shared_memory_offset; 506 }; 507 508 COMPILE_ASSERT(sizeof(GetBucketData) == 24, Sizeof_GetBucketData_is_not_20); 509 COMPILE_ASSERT(offsetof(GetBucketData, header) == 0, 510 Offsetof_GetBucketData_header_not_0); 511 COMPILE_ASSERT(offsetof(GetBucketData, bucket_id) == 4, 512 Offsetof_GetBucketData_bucket_id_not_4); 513 COMPILE_ASSERT(offsetof(GetBucketData, offset) == 8, 514 Offsetof_GetBucketData_offset_not_8); 515 COMPILE_ASSERT(offsetof(GetBucketData, size) == 12, 516 Offsetof_GetBucketData_size_not_12); 517 COMPILE_ASSERT(offsetof(GetBucketData, shared_memory_id) == 16, 518 Offsetof_GetBucketData_shared_memory_id_not_16); 519 COMPILE_ASSERT(offsetof(GetBucketData, shared_memory_offset) == 20, 520 Offsetof_GetBucketData_shared_memory_offset_not_20); 521 522 } // namespace cmd 523 524 #pragma pack(pop) 525 526 } // namespace gpu 527 528 #endif // GPU_COMMAND_BUFFER_COMMON_CMD_BUFFER_COMMON_H_ 529 530
