Resolve gcc 5 compilation problem

src/exec/Device_Parameter_Set.cpp

@@ -6,7 +6,7 @@
 int Device_Parameter_Set::Seed = 123;//Seed for random number generation (used in device's random number generators)
 bool Device_Parameter_Set::Enabled_Preconditioning = true;
 NVM::NVM_Type Device_Parameter_Set::Memory_Type = NVM::NVM_Type::FLASH;
-HostInterface_Type Device_Parameter_Set::HostInterface_Type = HostInterface_Type::NVME;
+HostInterface_Types Device_Parameter_Set::HostInterface_Type = HostInterface_Types::NVME;
 uint16_t Device_Parameter_Set::IO_Queue_Depth = 1024;//For NVMe, it determines the size of the submission/completion queues; for SATA, it determines the size of NCQ_Control_Structure
 uint16_t Device_Parameter_Set::Queue_Fetch_Size = 512;//Used in NVMe host interface
 SSD_Components::Caching_Mechanism Device_Parameter_Set::Caching_Mechanism = SSD_Components::Caching_Mechanism::ADVANCED;
@@ -73,10 +73,10 @@ void Device_Parameter_Set::XML_serialize(Utils::XmlWriter& xmlwriter)
 	val;
 	switch (HostInterface_Type)
 	{
-	case HostInterface_Type::NVME:
+	case HostInterface_Types::NVME:
 		val = "NVME";
 		break;
-	case HostInterface_Type::SATA:
+	case HostInterface_Types::SATA:
 		val = "SATA";
 		break;
 	default:
@@ -164,7 +164,7 @@ void Device_Parameter_Set::XML_serialize(Utils::XmlWriter& xmlwriter)
 	xmlwriter.Write_attribute_string(attr, val);
 
 	attr = "Ideal_Mapping_Table";
-	val = (Ideal_Mapping_Table ? "true" : "false");
+	val = (Use_Copyback_for_GC ? "true" : "false");
 	xmlwriter.Write_attribute_string(attr, val);
 
 	attr = "CMT_Capacity";
@@ -411,9 +411,9 @@ void Device_Parameter_Set::XML_deserialize(rapidxml::xml_node<> *node)
 				std::string val = param->value();
 				std::transform(val.begin(), val.end(), val.begin(), ::toupper);
 				if (strcmp(val.c_str(), "NVME") == 0)
-					HostInterface_Type = HostInterface_Type::NVME;
+					HostInterface_Type = HostInterface_Types::NVME;
 				else if (strcmp(val.c_str(), "SATA") == 0)
-					HostInterface_Type = HostInterface_Type::SATA;
+					HostInterface_Type = HostInterface_Types::SATA;
 				else PRINT_ERROR("Unknown host interface type specified in the SSD configuration file")
 			}
 			else if (strcmp(param->name(), "IO_Queue_Depth") == 0)
@@ -693,4 +693,4 @@ void Device_Parameter_Set::XML_deserialize(rapidxml::xml_node<> *node)
 	{
 		PRINT_ERROR("Error in Device_Parameter_Set!")
 	}
-}
+}

src/exec/Device_Parameter_Set.h

@@ -19,7 +19,7 @@ class Device_Parameter_Set : public Parameter_Set_Base
 	static int Seed;//Seed for random number generation (used in device's random number generators)
 	static bool Enabled_Preconditioning;
 	static NVM::NVM_Type Memory_Type;
-	static HostInterface_Type HostInterface_Type;
+	static HostInterface_Types HostInterface_Type;
 	static uint16_t IO_Queue_Depth;//For NVMe, it determines the size of the submission/completion queues; for SATA, it determines the size of NCQ_Control_Structure
 	static uint16_t Queue_Fetch_Size;//Used in NVMe host interface
 	static SSD_Components::Caching_Mechanism Caching_Mechanism;

src/exec/Host_System.cpp

@@ -14,7 +14,7 @@ Host_System::Host_System(Host_Parameter_Set* parameters, bool preconditioning_re
 	Simulator->AddObject(this);
 
 	//Create the main components of the host system
-	if (((SSD_Components::Host_Interface_NVMe*)ssd_host_interface)->GetType() == HostInterface_Type::SATA)
+	if (((SSD_Components::Host_Interface_NVMe*)ssd_host_interface)->GetType() == HostInterface_Types::SATA)
 		this->SATA_hba = new Host_Components::SATA_HBA(ID() + ".SATA_HBA", ((SSD_Components::Host_Interface_SATA*)ssd_host_interface)->Get_ncq_depth(), parameters->SATA_Processing_Delay, NULL, NULL);
 	else
 		this->SATA_hba = NULL;
@@ -35,7 +35,7 @@ Host_System::Host_System(Host_Parameter_Set* parameters, bool preconditioning_re
 		uint16_t nvme_sq_size = 0, nvme_cq_size = 0;
 		switch (((SSD_Components::Host_Interface_NVMe*)ssd_host_interface)->GetType())
 		{
-		case HostInterface_Type::NVME:
+		case HostInterface_Types::NVME:
 			nvme_sq_size = ((SSD_Components::Host_Interface_NVMe*)ssd_host_interface)->Get_submission_queue_depth();
 			nvme_cq_size = ((SSD_Components::Host_Interface_NVMe*)ssd_host_interface)->Get_completion_queue_depth();
 			break;
@@ -82,7 +82,7 @@ Host_System::Host_System(Host_Parameter_Set* parameters, bool preconditioning_re
 		Simulator->AddObject(io_flow);
 	}
 	this->PCIe_root_complex->Set_io_flows(&this->IO_flows);
-	if (((SSD_Components::Host_Interface_NVMe*)ssd_host_interface)->GetType() == HostInterface_Type::SATA)
+	if (((SSD_Components::Host_Interface_NVMe*)ssd_host_interface)->GetType() == HostInterface_Types::SATA)
 	{
 		this->SATA_hba->Set_io_flows(&this->IO_flows);
 		this->SATA_hba->Set_root_complex(this->PCIe_root_complex);
@@ -94,7 +94,7 @@ Host_System::~Host_System()
 	delete this->Link;
 	delete this->PCIe_root_complex;
 	delete this->PCIe_switch;
-	if (ssd_device->Host_interface->GetType() == HostInterface_Type::SATA)
+	if (ssd_device->Host_interface->GetType() == HostInterface_Types::SATA)
 		delete this->SATA_hba;
 
 	for (uint16_t flow_id = 0; flow_id < this->IO_flows.size(); flow_id++)
@@ -117,14 +117,14 @@ void Host_System::Start_simulation()
 {
 	switch (ssd_device->Host_interface->GetType())
 	{
-	case HostInterface_Type::NVME:
+	case HostInterface_Types::NVME:
 		for (uint16_t flow_cntr = 0; flow_cntr < IO_flows.size(); flow_cntr++)
 			((SSD_Components::Host_Interface_NVMe*) ssd_device->Host_interface)->Create_new_stream(
 				IO_flows[flow_cntr]->Priority_class(),
 				IO_flows[flow_cntr]->Get_start_lsa_on_device(), IO_flows[flow_cntr]->Get_end_lsa_address_on_device(),
 				IO_flows[flow_cntr]->Get_nvme_queue_pair_info()->Submission_queue_memory_base_address, IO_flows[flow_cntr]->Get_nvme_queue_pair_info()->Completion_queue_memory_base_address);
 		break;
-	case HostInterface_Type::SATA:
+	case HostInterface_Types::SATA:
 		((SSD_Components::Host_Interface_SATA*) ssd_device->Host_interface)->Set_ncq_address(
 			SATA_hba->Get_sata_ncq_info()->Submission_queue_memory_base_address, SATA_hba->Get_sata_ncq_info()->Completion_queue_memory_base_address);
 

src/exec/SSD_Device.cpp

@@ -187,7 +187,7 @@ SSD_Device::SSD_Device(Device_Parameter_Set* parameters, std::vector<IO_Flow_Par
 		{
 			switch (parameters->HostInterface_Type)
 			{
-			case HostInterface_Type::SATA:
+			case HostInterface_Types::SATA:
 			{
 				stream_count = 1;
 				std::vector<flash_channel_ID_type> channel_ids;
@@ -208,7 +208,7 @@ SSD_Device::SSD_Device(Device_Parameter_Set* parameters, std::vector<IO_Flow_Par
 					flow_plane_id_assignments[i].push_back(j);
 				break;
 			}
-			case HostInterface_Type::NVME:
+			case HostInterface_Types::NVME:
 			{
 				stream_count = (unsigned int)io_flows->size();
 				std::vector<flash_channel_ID_type> channel_ids;
@@ -313,12 +313,12 @@ SSD_Device::SSD_Device(Device_Parameter_Set* parameters, std::vector<IO_Flow_Par
 		//Step 10: create Host_Interface
 		switch (parameters->HostInterface_Type)
 		{
-		case HostInterface_Type::NVME:
+		case HostInterface_Types::NVME:
 			device->Host_interface = new SSD_Components::Host_Interface_NVMe(device->ID() + ".HostInterface",
 				Utils::Logical_Address_Partitioning_Unit::Get_total_device_lha_count(), parameters->IO_Queue_Depth, parameters->IO_Queue_Depth,
 				(unsigned int)io_flows->size(), parameters->Queue_Fetch_Size, parameters->Flash_Parameters.Page_Capacity / SECTOR_SIZE_IN_BYTE, dcm);
 			break;
-		case HostInterface_Type::SATA:
+		case HostInterface_Types::SATA:
 			device->Host_interface = new SSD_Components::Host_Interface_SATA(device->ID() + ".HostInterface",
 				parameters->IO_Queue_Depth, Utils::Logical_Address_Partitioning_Unit::Get_total_device_lha_count(), parameters->Flash_Parameters.Page_Capacity / SECTOR_SIZE_IN_BYTE, dcm);
 

src/host/IO_Flow_Base.cpp

@@ -8,7 +8,7 @@ namespace Host_Components
 	IO_Flow_Base::IO_Flow_Base(const sim_object_id_type& name, uint16_t flow_id, LHA_type start_lsa_on_device, LHA_type end_lsa_on_device, uint16_t io_queue_id,
 		uint16_t nvme_submission_queue_size, uint16_t nvme_completion_queue_size, 
 		IO_Flow_Priority_Class priority_class, sim_time_type stop_time, double initial_occupancy_ratio, unsigned int total_requets_to_be_generated,
-		HostInterface_Type SSD_device_type, PCIe_Root_Complex* pcie_root_complex, SATA_HBA* sata_hba,
+		HostInterface_Types SSD_device_type, PCIe_Root_Complex* pcie_root_complex, SATA_HBA* sata_hba,
 		bool enabled_logging, sim_time_type logging_period, std::string logging_file_path) : 
 		MQSimEngine::Sim_Object(name), flow_id(flow_id), start_lsa_on_device(start_lsa_on_device), end_lsa_on_device(end_lsa_on_device), io_queue_id(io_queue_id),
 		priority_class(priority_class), stop_time(stop_time), initial_occupancy_ratio(initial_occupancy_ratio), total_requests_to_be_generated(total_requets_to_be_generated), SSD_device_type(SSD_device_type), pcie_root_complex(pcie_root_complex), sata_hba(sata_hba),
@@ -28,7 +28,7 @@ namespace Host_Components
 
 		switch (SSD_device_type)
 		{
-		case HostInterface_Type::NVME:
+		case HostInterface_Types::NVME:
 			for (uint16_t cmdid = 0; cmdid < (uint16_t)(0xffffffff); cmdid++)
 				available_command_ids.insert(cmdid);
 			for (uint16_t cmdid = 0; cmdid < nvme_submission_queue_size; cmdid++)
@@ -115,12 +115,12 @@ namespace Host_Components
 
 		switch (SSD_device_type)
 		{
-		case HostInterface_Type::NVME:
+		case HostInterface_Types::NVME:
 			for (auto &req : nvme_software_request_queue)
 				if (req.second)
 					delete req.second;
 			break;
-		case HostInterface_Type::SATA:
+		case HostInterface_Types::SATA:
 			break;
 		default:
 			PRINT_ERROR("Unsupported host interface type in IO_Flow_Base!")
@@ -375,7 +375,7 @@ namespace Host_Components
 	{
 		switch (SSD_device_type)
 		{
-		case HostInterface_Type::NVME:
+		case HostInterface_Types::NVME:
 			if (NVME_SQ_FULL(nvme_queue_pair) || available_command_ids.size() == 0)//If either of software or hardware queue is full
 				waiting_requests.push_back(request);
 			else
@@ -394,7 +394,7 @@ namespace Host_Components
 				pcie_root_complex->Write_to_device(nvme_queue_pair.Submission_tail_register_address_on_device, nvme_queue_pair.Submission_queue_tail);//Based on NVMe protocol definition, the updated tail pointer should be informed to the device
 			}
 			break;
-		case HostInterface_Type::SATA:
+		case HostInterface_Types::SATA:
 			request->Source_flow_id = flow_id;
 			sata_hba->Submit_io_request(request);
 			break;

src/host/IO_Flow_Base.h

@@ -45,7 +45,7 @@ namespace Host_Components
 		IO_Flow_Base(const sim_object_id_type& name, uint16_t flow_id, LHA_type start_lsa_on_device, LHA_type end_lsa_address_on_device, uint16_t io_queue_id,
 			uint16_t nvme_submission_queue_size, uint16_t nvme_completion_queue_size, IO_Flow_Priority_Class priority_class,
 			sim_time_type stop_time, double initial_occupancy_ratio, unsigned int total_requets_to_be_generated,
-			HostInterface_Type SSD_device_type, PCIe_Root_Complex* pcie_root_complex, SATA_HBA* sata_hba,
+			HostInterface_Types SSD_device_type, PCIe_Root_Complex* pcie_root_complex, SATA_HBA* sata_hba,
 			bool enabled_logging, sim_time_type logging_period, std::string logging_file_path);
 		~IO_Flow_Base();
 		void Start_simulation();
@@ -73,7 +73,7 @@ namespace Host_Components
 		double initial_occupancy_ratio;//The initial amount of valid logical pages when pereconditioning is performed
 		sim_time_type stop_time;//The flow stops generating request when simulation time reaches stop_time
 		unsigned int total_requests_to_be_generated;//If stop_time is zero, then the flow stops generating request when the number of generated requests is equal to total_req_count
-		HostInterface_Type SSD_device_type;
+		HostInterface_Types SSD_device_type;
 		PCIe_Root_Complex* pcie_root_complex;
 		SATA_HBA* sata_hba;
 		LHA_type start_lsa_on_device, end_lsa_on_device;

src/host/IO_Flow_Synthetic.cpp

@@ -12,7 +12,7 @@ namespace Host_Components
 		Utils::Request_Size_Distribution_Type request_size_distribution, unsigned int average_request_size, unsigned int variance_request_size,
 		Utils::Request_Generator_Type generator_type, sim_time_type Average_inter_arrival_time_nano_sec, unsigned int average_number_of_enqueued_requests,
 		bool generate_aligned_addresses, unsigned int alignment_value,
-		int seed, sim_time_type stop_time, double initial_occupancy_ratio, unsigned int total_req_count, HostInterface_Type SSD_device_type, PCIe_Root_Complex* pcie_root_complex, SATA_HBA* sata_hba,
+		int seed, sim_time_type stop_time, double initial_occupancy_ratio, unsigned int total_req_count, HostInterface_Types SSD_device_type, PCIe_Root_Complex* pcie_root_complex, SATA_HBA* sata_hba,
 		bool enabled_logging, sim_time_type logging_period, std::string logging_file_path) :
 		IO_Flow_Base(name, flow_id, start_lsa_on_device, LHA_type(start_lsa_on_device + (end_lsa_on_device - start_lsa_on_device) * working_set_ratio), io_queue_id, nvme_submission_queue_size, nvme_completion_queue_size, priority_class, stop_time, initial_occupancy_ratio, total_req_count, SSD_device_type, pcie_root_complex, sata_hba, enabled_logging, logging_period, logging_file_path),
 		read_ratio(read_ratio), address_distribution(address_distribution),

src/host/IO_Flow_Synthetic.h

@@ -17,7 +17,7 @@ namespace Host_Components
 			Utils::Request_Size_Distribution_Type request_size_distribution, unsigned int average_request_size, unsigned int variance_request_size,
 			Utils::Request_Generator_Type generator_type, sim_time_type Average_inter_arrival_time_nano_sec, unsigned int average_number_of_enqueued_requests,
 			bool generate_aligned_addresses, unsigned int alignment_value,
-			int seed, sim_time_type stop_time, double initial_occupancy_ratio, unsigned int total_req_count, HostInterface_Type SSD_device_type, PCIe_Root_Complex* pcie_root_complex, SATA_HBA* sata_hba,
+			int seed, sim_time_type stop_time, double initial_occupancy_ratio, unsigned int total_req_count, HostInterface_Types SSD_device_type, PCIe_Root_Complex* pcie_root_complex, SATA_HBA* sata_hba,
 			bool enabled_logging, sim_time_type logging_period, std::string logging_file_path);
 		~IO_Flow_Synthetic();
 		Host_IO_Reqeust* Generate_next_request();

src/host/IO_Flow_Trace_Based.cpp

@@ -8,7 +8,7 @@ namespace Host_Components
 	IO_Flow_Trace_Based::IO_Flow_Trace_Based(const sim_object_id_type& name, uint16_t flow_id, LHA_type start_lsa_on_device, LHA_type end_lsa_on_device, uint16_t io_queue_id,
 		uint16_t nvme_submission_queue_size, uint16_t nvme_completion_queue_size, IO_Flow_Priority_Class priority_class, double initial_occupancy_ratio,
 		std::string trace_file_path, Trace_Time_Unit time_unit, unsigned int total_replay_count, unsigned int percentage_to_be_simulated,
-		HostInterface_Type SSD_device_type, PCIe_Root_Complex* pcie_root_complex, SATA_HBA* sata_hba,
+		HostInterface_Types SSD_device_type, PCIe_Root_Complex* pcie_root_complex, SATA_HBA* sata_hba,
 		bool enabled_logging, sim_time_type logging_period, std::string logging_file_path) :
 		IO_Flow_Base(name, flow_id, start_lsa_on_device, end_lsa_on_device, io_queue_id, nvme_submission_queue_size, nvme_completion_queue_size, priority_class, 0, initial_occupancy_ratio, 0, SSD_device_type, pcie_root_complex, sata_hba, enabled_logging, logging_period, logging_file_path),
 		trace_file_path(trace_file_path), time_unit(time_unit), total_replay_no(total_replay_count), percentage_to_be_simulated(percentage_to_be_simulated),

src/host/IO_Flow_Trace_Based.h

@@ -15,7 +15,7 @@ namespace Host_Components
 		IO_Flow_Trace_Based(const sim_object_id_type& name, uint16_t flow_id, LHA_type start_lsa_on_device, LHA_type end_lsa_on_device, uint16_t io_queue_id,
 			uint16_t nvme_submission_queue_size, uint16_t nvme_completion_queue_size, IO_Flow_Priority_Class priority_class, double initial_occupancy_ratio,
 			std::string trace_file_path, Trace_Time_Unit time_unit, unsigned int total_replay_count, unsigned int percentage_to_be_simulated,
-			HostInterface_Type SSD_device_type, PCIe_Root_Complex* pcie_root_complex, SATA_HBA* sata_hba,
+			HostInterface_Types SSD_device_type, PCIe_Root_Complex* pcie_root_complex, SATA_HBA* sata_hba,
 			bool enabled_logging, sim_time_type logging_period, std::string logging_file_path);
 		~IO_Flow_Trace_Based();
 		Host_IO_Reqeust* Generate_next_request();

src/host/PCIe_Root_Complex.cpp

@@ -3,7 +3,7 @@
 
 namespace Host_Components
 {
-	PCIe_Root_Complex::PCIe_Root_Complex(PCIe_Link* pcie_link, HostInterface_Type SSD_device_type, SATA_HBA* sata_hba, std::vector<Host_Components::IO_Flow_Base*>* IO_flows) :
+	PCIe_Root_Complex::PCIe_Root_Complex(PCIe_Link* pcie_link, HostInterface_Types SSD_device_type, SATA_HBA* sata_hba, std::vector<Host_Components::IO_Flow_Base*>* IO_flows) :
 		pcie_link(pcie_link), SSD_device_type(SSD_device_type), sata_hba(sata_hba), IO_flows(IO_flows) {}
 
 	void PCIe_Root_Complex::Write_to_memory(const uint64_t address, const void* payload)
@@ -16,13 +16,13 @@ namespace Host_Components
 		{
 			switch (SSD_device_type)
 			{
-			case HostInterface_Type::NVME:
+			case HostInterface_Types::NVME:
 			{
 				unsigned int flow_id = QUEUE_ID_TO_FLOW_ID(((Completion_Queue_Entry*)payload)->SQ_ID);
 				((*IO_flows)[flow_id])->NVMe_consume_io_request((Completion_Queue_Entry*)payload);
 				break;
 			}
-			case HostInterface_Type::SATA:
+			case HostInterface_Types::SATA:
 				sata_hba->SATA_consume_io_request((Completion_Queue_Entry*)payload);
 				break;
 			default:
@@ -59,14 +59,14 @@ namespace Host_Components
 		{
 			switch (SSD_device_type)
 			{
-			case HostInterface_Type::NVME:
+			case HostInterface_Types::NVME:
 			{
 				uint16_t flow_id = QUEUE_ID_TO_FLOW_ID(uint16_t(address >> NVME_COMP_Q_MEMORY_REGION));
 				new_pcie_message->Payload = (*IO_flows)[flow_id]->NVMe_read_sqe(address);
 				new_pcie_message->Payload_size = sizeof(Submission_Queue_Entry);
 				break;
 			}
-			case HostInterface_Type::SATA:
+			case HostInterface_Types::SATA:
 				new_pcie_message->Payload = sata_hba->Read_ncq_entry(address);
 				new_pcie_message->Payload_size = sizeof(Submission_Queue_Entry);
 				break;

src/host/PCIe_Root_Complex.h

@@ -18,7 +18,7 @@ namespace Host_Components
 	class PCIe_Root_Complex
 	{
 	public:
-		PCIe_Root_Complex(PCIe_Link* pcie_link, HostInterface_Type SSD_device_type, SATA_HBA* sata_hba, std::vector<Host_Components::IO_Flow_Base*>* IO_flows);
+		PCIe_Root_Complex(PCIe_Link* pcie_link, HostInterface_Types SSD_device_type, SATA_HBA* sata_hba, std::vector<Host_Components::IO_Flow_Base*>* IO_flows);
 
 		void Consume_pcie_message(PCIe_Message* messages)//Modern processors support DDIO, where all writes to memory are going through LLC
 		{
@@ -39,7 +39,7 @@ namespace Host_Components
 		void Set_io_flows(std::vector<Host_Components::IO_Flow_Base*>* IO_flows);
 	private:
 		PCIe_Link* pcie_link;
-		HostInterface_Type SSD_device_type;
+		HostInterface_Types SSD_device_type;
 		SATA_HBA * sata_hba;
 		std::vector<Host_Components::IO_Flow_Base*>* IO_flows;
 

src/ssd/Data_Cache_Manager_Flash_Advanced.cpp

@@ -493,16 +493,13 @@ namespace SSD_Components
 							((Data_Cache_Manager_Flash_Advanced*)_my_instance)->per_stream_cache[transaction->Stream_id]->Remove_slot(transaction->Stream_id, ((NVM_Transaction_Flash_WR*)transaction)->LPA);
 					}
 
-					auto &req_list = static_cast<Data_Cache_Manager_Flash_Advanced*>(_my_instance)->waiting_user_requests_queue_for_dram_free_slot[sharing_id];
-					for (auto it = req_list.begin(); it != req_list.end(); )
+					auto user_request = ((Data_Cache_Manager_Flash_Advanced*)_my_instance)->waiting_user_requests_queue_for_dram_free_slot[sharing_id].begin();
+					while (user_request != ((Data_Cache_Manager_Flash_Advanced*)_my_instance)->waiting_user_requests_queue_for_dram_free_slot[sharing_id].end())
 					{
-						static_cast<Data_Cache_Manager_Flash_Advanced*>(_my_instance)->write_to_destage_buffer(*it);
-
-						if (!((*it)->Transaction_list.size()))
-							((Data_Cache_Manager_Flash_Advanced*)_my_instance)->waiting_user_requests_queue_for_dram_free_slot[sharing_id].remove(*(it++));
-						else
-							it++;
-
+						((Data_Cache_Manager_Flash_Advanced*)_my_instance)->write_to_destage_buffer(*user_request);
+						if ((*user_request)->Transaction_list.size() == 0)
+							((Data_Cache_Manager_Flash_Advanced*)_my_instance)->waiting_user_requests_queue_for_dram_free_slot[sharing_id].erase(user_request++);
+						else user_request++;
 						if (((Data_Cache_Manager_Flash_Advanced*)_my_instance)->back_pressure_buffer_depth[sharing_id] > ((Data_Cache_Manager_Flash_Advanced*)_my_instance)->back_pressure_buffer_max_depth)//The traffic load on the backend is high and the waiting requests cannot be serviced
 							break;
 					}