#define _CRT_SECURE_NO_WARNINGS #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "barrier_rules.h" static void require(bool ok,const char* why) { if(!ok) { std::fprintf(stderr,"FAIL: %s\n",why); std::exit(1); } } struct Allocation { std::vector cpu,visible; }; using VmaAllocation=Allocation*; struct { VkDevice device{}; VkQueue queue{}; VkPhysicalDeviceProperties props{}; std::mutex present_mu; } dev; std::map buffers; uintptr_t serial=100; template T handle() { return reinterpret_cast(++serial); } bool coherent=false,fail_buffer=false; unsigned flushed=0,queued=0; std::mutex par_mutex; struct ParLock { std::lock_guard lock{par_mutex}; }; void logf(const char*,...) {} bool create_buffer(uint64_t size,VkBufferUsageFlags,bool,VkBuffer& buffer,VmaAllocation& allocation,void** mapped,bool=false) { if(fail_buffer) return false; buffer=handle(); auto& a=buffers[buffer]; a.cpu.assign((size_t)size,0x9a); a.visible.assign((size_t)size,0xc3); allocation=&a; *mapped=a.cpu.data(); return true; } void destroy_buffer(VkBuffer buffer,VmaAllocation allocation) { require(&buffers.at(buffer)==allocation,"allocation owner"); buffers.erase(buffer); } void flush_mapped(VmaAllocation allocation,uint64_t size) { if(!size)return; require(allocation && size<=allocation->cpu.size(),"valid stream flush range"); std::copy_n(allocation->cpu.begin(),(size_t)size,allocation->visible.begin()); flushed++; } /* RES */ std::deque res; thread_local RecordingRes* cur=nullptr; const uint64_t kStream=1024; constexpr VkBufferUsageFlags kStreamUse=VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT|VK_BUFFER_USAGE_STORAGE_BUFFER_BIT|VK_BUFFER_USAGE_TRANSFER_SRC_BIT|VK_BUFFER_USAGE_TRANSFER_DST_BIT|VK_BUFFER_USAGE_INDEX_BUFFER_BIT|VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; std::atomic stream_extra{0},stream_grown{0},stream_peak{0}; bool stream_grow_off() { return false; } struct BufferRef { VkBuffer buffer{}; uint64_t offset=0,size=0,address=0; }; void draw_flush_recording(int slot); /* STREAM */ VkCommandBuffer rec_cmd{}; uint64_t rec_value=0,targets_serial=0; VkBuffer zero_buffer{}; VmaAllocation zero_alloc{}; VkDescriptorPool make_pool() { return handle(); } VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice,VkDescriptorPool,VkDescriptorPoolResetFlags) { return VK_SUCCESS; } VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(VkDevice,VkDescriptorPool,const VkAllocationCallbacks*) {} struct Pass {}; Pass& pass() { static Pass p;return p; } bool work_since_barrier=false,last_dyn_valid=false,last_desc_valid=false,last_vb_valid=false; VkPipeline last_pipeline{}; struct { bool on=false; } vertex_set,last_ib; void descriptors_disturbed() {} std::unordered_map& handle_hits() { static std::unordered_map h;return h; } struct BankCache { uint64_t at=0; }; std::array,2>& bank_cache() { static std::array,2> b;return b; } void make_dummies() {} thread_local uint64_t desc_rec=0; // (vk_draw.cpp: the recording the kept descriptors are of) /* FLUSH */ /* BEGIN */ struct Recording { int slot;VkCommandBuffer cmd,upload,init; VkFence fence;uint64_t value=1,batch=0;bool submitted=false; }; struct Expected { BufferRef ref;std::vector bytes; }; std::map> expected; std::vector submitted_slots; std::map slots; bool texture_uploads_recorded() { return true; } void gprof_submitted(int,bool) {} void gpu_time_end(Recording&) {} VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer) { return VK_SUCCESS; } VkSemaphore timeline{},rec_timeline{}; uint64_t rec_seq=0; std::mutex rec_map_mu; std::multimap value_rec; std::set rec_open_values; struct { std::vector cbs;uint64_t signal=0,rec=0;bool any_signal=false;size_t recs=0; } pend; uint64_t batch_next=0;std::chrono::steady_clock::time_point pend_since; bool batch=false;bool batch_on() { return batch; } namespace barrier_rules = mkwvk::barrier_rules; // (the held submits' rule, gpu/vk/barrier_rules.h: RX_VK_BATCH=1 here) barrier_rules::Batch batch_way() { return batch ? barrier_rules::Batch::Hold : barrier_rules::Batch::Off; } int submit_depth=0; int flush_reason=0;constexpr int FR_OTHER=0,FR_CAP=1; bool event_writes_held(VkCommandBuffer) { return false; } // (no event's write held: RX_VK_EVENT_BARRIER's, not this test's) void split_part_submitted(VkCommandBuffer,bool) {} // (RX_VK_SPLIT_BARRIER's count) void end_pass(VkCommandBuffer) { require(false,"a pass ended at a submit"); } void full_barrier(VkCommandBuffer,const char*) { require(false,"a barrier at a submit"); } void device_lost() { require(false,"unexpected device loss"); } #define PROF(x) ((void)0) VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2(VkQueue,uint32_t count,const VkSubmitInfo2* submits,VkFence) { for(unsigned i=0;i& jobs) { bool init_lost=false; for(auto& job:jobs) { Job* j=&job; /* SEGMENT */ } } static Recording recording(int slot) { Recording r{slot,handle(),handle(),handle(),handle()}; slots[r.cmd]=slot; return r; } static void write(Recording& r,size_t bytes,unsigned seed) { std::vector data(bytes);for(size_t i=0;i large(3000,9);auto missing=stream_copy(large.data(),large.size());fail_buffer=false; require(!missing.buffer && res[0].si==0,"failed growth must leave the current stream usable"); } if(mode=="segments" || mode=="failed-segment") { Recording b=recording(1),c=recording(2); std::thread worker([&]{draw_begin_recording(1,b.cmd,1);write(b,997,4);write(b,3009,5);});worker.join(); draw_begin_recording(2,c.cmd,1);write(c,487,6);require(cur==&res[2],"main thread current slot differs from submitted worker slots"); std::vector jobs{{&a,1,true},{&b,mode=="failed-segment"?-1:0,true},{&c,0,false}};submit_segments(jobs); require(submitted_slots==(mode=="failed-segment"?std::vector{0}:std::vector{0,1,2}),"segment failure/ordering contract");return 0; } batch=mode=="batch";submit_recording(a); if(batch) {require(queued==0,"batch retained before queue use");queue_flush_locked();} if(mode=="reuse") { expected[a.cmd].clear();draw_begin_recording(0,a.cmd,2);require(res[0].si==0 && res[0].used==0 && res[0].streams.size()==3,"real begin resets used range and retains grown streams"); write(a,69,7);submit_recording(a); } require(a.submitted,"healthy recording submitted");std::puts("PASS: production draw stream input visibility and submission paths"); }