39 render_pass_state_.reset_state();
40 compute_state_.reset_state();
43void MTLCommandBufferManager::register_encoder_counters()
51 if (active_command_buffer_ == nil) {
66 MTLCommandBufferDescriptor *desc = [[MTLCommandBufferDescriptor alloc]
init];
67 desc.errorOptions = MTLCommandBufferErrorOptionEncoderExecutionStatus;
68 desc.retainedReferences = YES;
70 active_command_buffer_ = [context_.
queue commandBufferWithDescriptor:desc];
73 [active_command_buffer_ setLabel:@(group_name.c_str())];
77 active_command_buffer_ = [context_.queue commandBuffer];
80 [active_command_buffer_ retain];
81 context_.main_command_buffer.inc_active_command_buffer_count();
85 MTLScratchBufferManager &mem = context_.memory_manager;
92 return active_command_buffer_;
100 if (empty_ && !wait) {
105 if (active_command_buffer_ == nil) {
117 BLI_assert(active_command_encoder_type_ == MTL_NO_COMMAND_ENCODER);
120 context_.memory_manager.flush_active_scratch_buffer();
131 active_safe_free_list_ =
nullptr;
134 [cmd_buffer_ref retain];
142 [cmd_buffer_ref release];
145 context_.main_command_buffer.dec_active_command_buffer_count();
149 [active_command_buffer_ commit];
158 "Maximum number of command buffers in flight. Host will wait until GPU work has "
159 "completed. Consider increasing GHOST_ContextMTL::max_command_buffer_count or reducing "
160 "work fragmentation to better utilize system hardware. Command buffers are flushed upon "
161 "GPUContext switches, this is the most common cause of excessive command buffer "
167 [active_command_buffer_ waitUntilCompleted];
173 NSError *error = [active_command_buffer_ error];
175 CLOG_ERROR(&
LOG,
"Command buffer error: %s", [[error localizedDescription] UTF8String]);
182 if (last_submitted_command_buffer_ != nil) {
185 [last_submitted_command_buffer_ autorelease];
186 last_submitted_command_buffer_ = nil;
188 last_submitted_command_buffer_ = active_command_buffer_;
189 active_command_buffer_ = nil;
203 return (active_command_encoder_type_ == MTL_RENDER_COMMAND_ENCODER);
208 return (active_command_encoder_type_ == MTL_BLIT_COMMAND_ENCODER);
213 return (active_command_encoder_type_ == MTL_COMPUTE_COMMAND_ENCODER);
219 return active_render_command_encoder_;
225 return active_blit_command_encoder_;
231 return active_compute_command_encoder_;
238 return active_frame_buffer_;
248 if (active_command_encoder_type_ == MTL_NO_COMMAND_ENCODER) {
250 BLI_assert(active_render_command_encoder_ == nil);
251 BLI_assert(active_blit_command_encoder_ == nil);
252 BLI_assert(active_compute_command_encoder_ == nil);
257 fold_remaining_debug_groups();
260 switch (active_command_encoder_type_) {
261 case MTL_RENDER_COMMAND_ENCODER:
262 BLI_assert(active_render_command_encoder_ != nil);
263 [active_render_command_encoder_ endEncoding];
264 [active_render_command_encoder_ release];
265 active_render_command_encoder_ = nil;
267 if (!retain_framebuffers) {
268 active_frame_buffer_ =
nullptr;
269 active_pass_descriptor_ =
nullptr;
272 case MTL_BLIT_COMMAND_ENCODER:
273 BLI_assert(active_blit_command_encoder_ != nil);
274 [active_blit_command_encoder_ endEncoding];
275 [active_blit_command_encoder_ release];
276 active_blit_command_encoder_ = nil;
278 case MTL_COMPUTE_COMMAND_ENCODER:
279 BLI_assert(active_compute_command_encoder_ != nil);
280 [active_compute_command_encoder_ endEncoding];
281 [active_compute_command_encoder_ release];
282 active_compute_command_encoder_ = nil;
284 case MTL_ACCELERATION_STRUCTURE_COMMAND_ENCODER:
285 BLI_assert(active_acceleration_structure_command_encoder_ != nil);
286 [active_acceleration_structure_command_encoder_ endEncoding];
287 [active_acceleration_structure_command_encoder_ release];
288 active_acceleration_structure_command_encoder_ = nil;
291 BLI_assert(
false &&
"Invalid command encoder type");
295 active_command_encoder_type_ = MTL_NO_COMMAND_ENCODER;
300 MTLFrameBuffer *ctx_framebuffer,
bool force_begin,
bool *r_new_pass)
311 if (active_command_encoder_type_ != MTL_RENDER_COMMAND_ENCODER ||
312 active_frame_buffer_ != ctx_framebuffer || force_begin)
317 bool is_rebind = (active_frame_buffer_ == ctx_framebuffer);
321 active_frame_buffer_ = ctx_framebuffer;
323 is_rebind && (!active_frame_buffer_->get_pending_clear()));
326 gpu::MTLBuffer *visibility_buffer = context_.get_visibility_buffer();
327 this->active_pass_descriptor_.visibilityResultBuffer =
329 context_.clear_visibility_dirty();
332 BLI_assert(active_render_command_encoder_ == nil);
335 active_render_command_encoder_ = [cmd_buf
336 renderCommandEncoderWithDescriptor:active_pass_descriptor_];
337 [active_render_command_encoder_ retain];
338 active_command_encoder_type_ = MTL_RENDER_COMMAND_ENCODER;
342 std::string debug_name =
"FrameBuf: " + std::string(active_frame_buffer_->name_get());
343 [active_render_command_encoder_ setLabel:@(debug_name.c_str())];
352 this->register_encoder_counters();
356 active_frame_buffer_->apply_state();
360 active_frame_buffer_->mark_cleared();
363 render_pass_state_.reset_state();
373 BLI_assert(active_render_command_encoder_ != nil);
374 return active_render_command_encoder_;
384 if (active_command_encoder_type_ != MTL_BLIT_COMMAND_ENCODER) {
389 if (active_blit_command_encoder_ == nil) {
391 active_blit_command_encoder_ = [cmd_buf blitCommandEncoder];
392 BLI_assert(active_blit_command_encoder_ != nil);
393 [active_blit_command_encoder_ retain];
394 active_command_encoder_type_ = MTL_BLIT_COMMAND_ENCODER;
399 [active_blit_command_encoder_ setLabel:@(debug_name.c_str())];
407 this->register_encoder_counters();
409 BLI_assert(active_blit_command_encoder_ != nil);
410 return active_blit_command_encoder_;
420 if (active_command_encoder_type_ != MTL_COMPUTE_COMMAND_ENCODER) {
425 if (active_compute_command_encoder_ == nil) {
426 active_compute_command_encoder_ = [cmd_buf computeCommandEncoder];
427 BLI_assert(active_compute_command_encoder_ != nil);
428 [active_compute_command_encoder_ retain];
429 active_command_encoder_type_ = MTL_COMPUTE_COMMAND_ENCODER;
434 [active_compute_command_encoder_ setLabel:@(debug_name.c_str())];
443 this->register_encoder_counters();
446 compute_state_.reset_state();
448 BLI_assert(active_compute_command_encoder_ != nil);
449 return active_compute_command_encoder_;
460 if (active_command_encoder_type_ != MTL_ACCELERATION_STRUCTURE_COMMAND_ENCODER) {
465 if (active_acceleration_structure_command_encoder_ == nil) {
466 active_acceleration_structure_command_encoder_ = [cmd_buf accelerationStructureCommandEncoder];
467 BLI_assert(active_acceleration_structure_command_encoder_ != nil);
468 [active_acceleration_structure_command_encoder_ retain];
469 active_command_encoder_type_ = MTL_ACCELERATION_STRUCTURE_COMMAND_ENCODER;
474 [active_acceleration_structure_command_encoder_ setLabel:@(debug_name.c_str())];
483 this->register_encoder_counters();
485 BLI_assert(active_acceleration_structure_command_encoder_ != nil);
486 return active_acceleration_structure_command_encoder_;
498 current_draw_call_count_++;
499 vertex_submitted_count_ += vertex_submission;
507 current_draw_call_count_ = 0;
509 vertex_submitted_count_ = 0;
516 if (active_command_buffer_ == nil) {
525 return ((current_draw_call_count_ > 30000) || (vertex_submitted_count_ > 100000000) ||
526 (encoder_count_ > 25));
542 MTLCaptureManager *capture_manager = [MTLCaptureManager sharedCaptureManager];
543 if (![capture_manager isCapturing]) {
547 if (active_command_buffer_ == nil) {
553 switch (active_command_encoder_type_) {
554 case MTL_RENDER_COMMAND_ENCODER:
555 [active_render_command_encoder_ pushDebugGroup:@(name)];
557 case MTL_BLIT_COMMAND_ENCODER:
558 [active_blit_command_encoder_ pushDebugGroup:@(name)];
560 case MTL_COMPUTE_COMMAND_ENCODER:
561 [active_compute_command_encoder_ pushDebugGroup:@(name)];
573 MTLCaptureManager *capture_manager = [MTLCaptureManager sharedCaptureManager];
574 if (![capture_manager isCapturing]) {
578 if (active_command_buffer_ == nil) {
584 switch (active_command_encoder_type_) {
585 case MTL_RENDER_COMMAND_ENCODER:
586 [active_render_command_encoder_ popDebugGroup];
588 case MTL_BLIT_COMMAND_ENCODER:
589 [active_blit_command_encoder_ popDebugGroup];
591 case MTL_COMPUTE_COMMAND_ENCODER:
592 [active_compute_command_encoder_ popDebugGroup];
604 MTLCaptureManager *capture_manager = [MTLCaptureManager sharedCaptureManager];
605 if (![capture_manager isCapturing]) {
609 if (active_command_buffer_ != nil) {
617 for ([[maybe_unused]]
int i : mtl_stack.index_range().drop_front(groups.
size())) {
619 mtl_stack.pop_last();
623 int first_mismatch = 0;
624 for (
int i : mtl_stack.index_range()) {
625 if (mtl_stack[i] != groups[i]) {
631 for ([[maybe_unused]]
int i : mtl_stack.index_range().drop_front(first_mismatch)) {
633 mtl_stack.pop_last();
638 std::string s_name = name;
640 mtl_stack.append(name);
646void MTLCommandBufferManager::fold_remaining_debug_groups()
649 MTLCaptureManager *capture_manager = [MTLCaptureManager sharedCaptureManager];
650 if (![capture_manager isCapturing]) {
654 if (active_command_buffer_ != nil) {
656 for ([[maybe_unused]]
int i : mtl_stack.index_range()) {
658 mtl_stack.pop_last();
677 if (is_tile_based_arch) {
678 if (active_command_encoder_type_ == MTL_RENDER_COMMAND_ENCODER) {
688 MTLBarrierScope scope = 0;
690 bool is_compute = (active_command_encoder_type_ != MTL_RENDER_COMMAND_ENCODER);
691 scope |= (is_compute ? 0 : MTLBarrierScopeRenderTargets) | MTLBarrierScopeTextures;
697 scope = scope | MTLBarrierScopeBuffers;
702 switch (active_command_encoder_type_) {
703 case MTL_NO_COMMAND_ENCODER:
704 case MTL_BLIT_COMMAND_ENCODER:
705 case MTL_ACCELERATION_STRUCTURE_COMMAND_ENCODER: {
711 case MTL_RENDER_COMMAND_ENCODER: {
714 MTLRenderStages before_stage_flags = 0;
715 MTLRenderStages after_stage_flags = 0;
719 before_stage_flags = before_stage_flags | MTLRenderStageVertex;
722 before_stage_flags = before_stage_flags | MTLRenderStageFragment;
725 after_stage_flags = after_stage_flags | MTLRenderStageVertex;
728 after_stage_flags = MTLRenderStageFragment;
733 [rec memoryBarrierWithScope:scope
734 afterStages:after_stage_flags
735 beforeStages:before_stage_flags];
740 case MTL_COMPUTE_COMMAND_ENCODER: {
743 [rec memoryBarrierWithScope:scope];
758 [cmd_buf encodeSignalEvent:
event value:signal_value];
759 register_encoder_counters();
768 [cmd_buf encodeWaitForEvent:
event value:signal_value];
769 register_encoder_counters();
796 (
uint)((
fb !=
nullptr) ?
fb->get_width() : 0),
797 (
uint)((
fb !=
nullptr) ?
fb->get_height() : 0)};
815 [rec setComputePipelineState:pso];
826 bool use_samplers_argument_buffer,
830 this->ctx.get_sampler_array(),
832 sampler_binding.
state,
833 use_samplers_argument_buffer,
846 this->ctx.get_scratch_buffer_manager(),
858 bool use_samplers_argument_buffer,
862 this->ctx.get_sampler_array(),
864 sampler_binding.
state,
865 use_samplers_argument_buffer,
880 this->ctx.get_scratch_buffer_manager(),
892 bool use_samplers_argument_buffer,
896 this->ctx.get_sampler_array(),
898 sampler_binding.
state,
899 use_samplers_argument_buffer,
914 this->ctx.get_scratch_buffer_manager(),
930 [
enc setBufferOffset:offset atIndex:
index];
934 [
enc setBuffer:buf offset:offset atIndex:
index];
946 [
enc setSamplerState:sampler_state atIndex:
index];
951 [
enc setAccelerationStructure:accel atBufferIndex:
index];
955 [
enc useResource:resource usage:usage];
960 [
enc setVertexBufferOffset:offset atIndex:
index];
964 [
enc setVertexBuffer:buf offset:offset atIndex:
index];
972 [
enc setVertexTexture:tex atIndex:
index];
976 [
enc setVertexSamplerState:sampler_state atIndex:
index];
981 [
enc setVertexAccelerationStructure:accel atBufferIndex:
index];
985 [
enc useResource:resource usage:usage stages:MTLRenderStageVertex];
990 [
enc setFragmentBufferOffset:offset atIndex:
index];
994 [
enc setFragmentBuffer:buf offset:offset atIndex:
index];
1002 [
enc setFragmentTexture:tex atIndex:
index];
1006 [
enc setFragmentSamplerState:sampler_state atIndex:
index];
1011 [
enc setFragmentAccelerationStructure:accel atBufferIndex:
index];
1015 [
enc useResource:resource usage:usage stages:MTLRenderStageFragment];
#define CLOG_ERROR(clg_ref,...)
static const int max_command_buffer_count
constexpr Span drop_front(int64_t n) const
constexpr int64_t size() const
static MTLBackend * get()
MTLSafeFreeList * acquire_current_safe_list()
id< MTLBuffer > get_metal_buffer() const
MTLFrameBuffer * get_active_framebuffer()
bool end_active_command_encoder(bool retain_framebuffers=false)
void encode_signal_event(id< MTLEvent > event, uint64_t value)
id< MTLComputeCommandEncoder > get_active_compute_command_encoder()
bool do_break_submission()
void register_draw_counters(int vertex_submission)
void prepare(bool supports_render=true)
void wait_until_active_command_buffers_complete()
id< MTLRenderCommandEncoder > ensure_begin_render_command_encoder(MTLFrameBuffer *ctx_framebuffer, bool force_begin, bool *r_new_pass)
bool is_inside_render_pass()
id< MTLComputeCommandEncoder > ensure_begin_compute_encoder()
bool insert_memory_barrier(GPUBarrier barrier_bits, GPUStageBarrierBits before_stages, GPUStageBarrierBits after_stages)
id< MTLBlitCommandEncoder > ensure_begin_blit_encoder()
void push_debug_group(const char *name, int index)
id< MTLAccelerationStructureCommandEncoder > ensure_begin_acceleration_structure_encoder()
id< MTLRenderCommandEncoder > get_active_render_command_encoder()
void unfold_pending_debug_groups()
static volatile std::atomic< int > num_active_cmd_bufs_in_system
void encode_wait_for_event(id< MTLEvent > event, uint64_t value)
id< MTLBlitCommandEncoder > get_active_blit_command_encoder()
void bind_compute_bytes(const void *bytes, uint64_t length, uint index)
id< MTLComputePipelineState > bound_pso
MTLCommandBufferManager & cmd
void bind_compute_texture(id< MTLTexture > tex, uint slot)
MTLBindingCache< gpu::MTLComputeCommandEncoder > compute_bindings
void bind_compute_buffer(id< MTLBuffer > buffer, uint64_t buffer_offset, uint index)
void bind_compute_sampler(MTLSamplerBinding &sampler_binding, bool use_samplers_argument_buffer, uint slot)
void bind_pso(id< MTLComputePipelineState > pso)
id< MTLSamplerState > get_sampler_from_state(MTLSamplerState state)
static MTLContext * get()
id< MTLSamplerState > get_default_sampler_state()
id< MTLCommandQueue > queue
static MTLBufferPool * get_global_memory_manager()
MTLRenderPassDescriptor * bake_render_pass_descriptor(bool load_contents)
void bind_fragment_bytes(const void *bytes, uint64_t length, uint index)
void bind_vertex_buffer(id< MTLBuffer > buffer, uint64_t buffer_offset, uint index)
MTLBindingCache< gpu::MTLVertexCommandEncoder > vertex_bindings
void bind_vertex_texture(id< MTLTexture > tex, uint slot)
void bind_vertex_bytes(const void *bytes, uint64_t length, uint index)
id< MTLDepthStencilState > bound_ds_state
MTLScissorRect last_scissor_rect
uint last_used_stencil_ref_value
MTLCommandBufferManager & cmd
MTLBindingCache< gpu::MTLFragmentCommandEncoder > fragment_bindings
void bind_vertex_sampler(MTLSamplerBinding &sampler_binding, bool use_samplers_argument_buffer, uint slot)
id< MTLRenderPipelineState > bound_pso
void bind_fragment_sampler(MTLSamplerBinding &sampler_binding, bool use_samplers_argument_buffer, uint slot)
MTLBoundShaderState last_bound_shader_state
void bind_fragment_texture(id< MTLTexture > tex, uint slot)
void bind_fragment_buffer(id< MTLBuffer > buffer, uint64_t buffer_offset, uint index)
void decrement_reference()
void ensure_increment_scratch_buffer()
float length(VecOp< float, D >) RET
#define MTL_LOG_WARNING(info,...)
const MTLSamplerState DEFAULT_SAMPLER_STATE
Vector< StringRef > DebugStack
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
unsigned __int64 uint64_t
@ GPU_BARRIER_STAGE_FRAGMENT
@ GPU_BARRIER_STAGE_VERTEX
BLI_INLINE float fb(float length, float L)
bool GPU_type_matches(GPUDeviceType device, GPUOSType os, GPUDriverType driver)
GPUArchitectureType GPU_platform_architecture()
@ GPU_BARRIER_VERTEX_ATTRIB_ARRAY
@ GPU_BARRIER_BUFFER_UPDATE
@ GPU_BARRIER_TEXTURE_FETCH
@ GPU_BARRIER_SHADER_STORAGE
@ GPU_BARRIER_SHADER_IMAGE_ACCESS
@ GPU_BARRIER_ELEMENT_ARRAY
void GPU_debug_get_groups_names(int name_buf_maxncpy, char *r_name_buf)
void set_sampler(id< MTLSamplerState > sampler_state, int index)
void set_bytes(const void *bytes, size_t length, int index)
void set_buffer_offset(size_t offset, int index)
void set_buffer(id< MTLBuffer > buf, size_t offset, int index)
void set_texture(id< MTLTexture > tex, int index)
id< MTLComputeCommandEncoder > enc
void use_resource(id< MTLResource > resource, MTLResourceUsage usage)
void set_acceleration_structure(id< MTLAccelerationStructure > accel, int index)
void set_acceleration_structure(id< MTLAccelerationStructure > accel, int index)
void set_texture(id< MTLTexture > tex, int index)
id< MTLRenderCommandEncoder > enc
void set_buffer_offset(size_t offset, int index)
void set_sampler(id< MTLSamplerState > sampler_state, int index)
void set_buffer(id< MTLBuffer > buf, size_t offset, int index)
void use_resource(id< MTLResource > resource, MTLResourceUsage usage)
void set_bytes(const void *bytes, size_t length, int index)
gpu::MTLSamplerState state
id< MTLSamplerState > get_mtl_sampler(MTLContext &ctx)
void set_bytes(const void *bytes, size_t length, int index)
void set_buffer_offset(size_t offset, int index)
void use_resource(id< MTLResource > resource, MTLResourceUsage usage)
void set_acceleration_structure(id< MTLAccelerationStructure > accel, int index)
void set_sampler(id< MTLSamplerState > sampler_state, int index)
void set_buffer(id< MTLBuffer > buf, size_t offset, int index)
id< MTLRenderCommandEncoder > enc
void set_texture(id< MTLTexture > tex, int index)