FreeCalypso > hg > fc-magnetite
view src/cs/riviera/rvm/rvm_mem.c @ 581:a0a45c5eb3ef
gsmcomp.c: bumping trace partition size to 220 like in gprscomp.c
This change is safe in terms of RAM usage because all of these partition
pools have already been moved from XRAM to IRAM earlier, and our IRAM
usage in VO configs is currently quite low - the one near the limit
is XRAM on C11x.
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Tue, 29 Jan 2019 03:52:49 +0000 |
parents | 945cf7f506b2 |
children |
line wrap: on
line source
/** * * @file rvm_mem.c * * This file contains the functions related to memory management within RVM. * * @author David Lamy-Charrier (d-lamy@ti.com) * @version 0.1 * */ /* * Revision History: * * 10/26/2001 David Lamy-Charrier Create for Riviera 1.6. * * (C) Copyright 2001 by Texas Instruments Incorporated, All Rights Reserved */ #include "rvm/rvm_i.h" #include "rvm/rvm_gen.h" #include "rvm/rvm_api.h" #include "rvm/rvm_use_id_list.h" #include "rvf/rvf_env.h" extern T_RVM_GET_INFO_FUNC RVM_SWE_GET_INFO_ARRAY[]; extern T_RVM_KNOWN_SWE * rvm_swe_array; /******************************************************************************* ** Function rvm_delete_used_memory ** ** Description Internal function which deletes used local mem if an error ** was received or at the end of the start/stop process. ** *******************************************************************************/ T_RVM_RETURN rvm_delete_used_memory ( T_RVM_PROCESSING_SWE * appli) { T_RVF_BUFFER_Q buffer_to_free_q = {0, 0, 0}; T_RVM_PROCESSING_SWE * cur_elem = appli; while (cur_elem != NULL) { rvf_enqueue (&buffer_to_free_q, cur_elem); cur_elem = cur_elem->next_swe; } while (buffer_to_free_q.p_first) { rvf_free_buf (rvf_dequeue (&buffer_to_free_q)); } return RVM_OK; } /******************************************************************************* ** Function rvm_delete_created_mb ** ** Description Internal function which deletes all created MB if an error ** was received, or in case application has to be stopped. ** *******************************************************************************/ T_RVM_RETURN rvm_delete_created_mb (T_RVM_PROCESSING_SWE * appli) { UINT8 mb_index; T_RVM_PROCESSING_SWE * cur_elem = appli; volatile T_RV_RET ret_value = RV_OK; UINT8 mb_to_delete; while (cur_elem != NULL ) { UINT8 swe_index = cur_elem->swe_id; /* If more than one appli is using this SWE, cannot delete MB Process to the next SWE. */ if (rvm_swe_array[swe_index].nb_using_appli > 1) { cur_elem = cur_elem->next_swe; /* process the next SWE */ continue; } /* If the state is running, it means that this SWE has not to be stopped. */ if (rvm_swe_array[swe_index].swe_state == SWE_RUNNING) { cur_elem = cur_elem->next_swe; /* process the next SWE */ continue; } /* We're here: - either because swe_state == SWE_NOT_STARTED => error in starting prcess - either because swe_state == SWE_STOPPING => regular stopping process */ if (cur_elem->nb_created_mb == 0) { cur_elem = cur_elem->next_swe; /* process the next SWE */ continue; } mb_to_delete = cur_elem->nb_created_mb; for( mb_index = 0; mb_index < mb_to_delete; mb_index++) { ret_value = rvf_delete_mb(cur_elem->swe_mem_bank[mb_index].mb_name); if (ret_value != RV_OK) { rvf_send_trace("RVM: Error in deletion of memory bank: ", 39, NULL_PARAM, RV_TRACE_LEVEL_WARNING, RVM_USE_ID ); rvf_send_trace(cur_elem->swe_mem_bank[mb_index].mb_name, RVF_MAX_MB_LEN, NULL_PARAM, RV_TRACE_LEVEL_WARNING, RVM_USE_ID ); } else { (cur_elem->nb_created_mb)--; } ret_value = RVM_OK; } cur_elem = cur_elem->next_swe; /* process the next SWE */ } return ret_value; } /******************************************************************************* ** ** Function rvm_check_memory_requirement ** ** Description This function checks if there is enough memory ** to start a SWE(and all the linked SWEs) ** ** Parameters: T_RVM_PROCESSING_SWE * appli: list of required SWEs with their parameters. ** ** Returns T_RVM_RETURN: RVM_OK if there is enough memory, else RVM_MEMORY_ERR. ** *******************************************************************************/ T_RVM_RETURN rvm_verify_memory_requirement( T_RVM_PROCESSING_SWE * appli, T_RVM_GROUP_DIRECTIVE* gd, UINT8 cnt) { T_RVM_PROCESSING_SWE * cur_swe = appli; UINT32 required_mem = 0; UINT32 total_mem = 0; UINT32 used_mem = 0; UINT8 mb_index; UINT8 i=0; UINT16 host_task_mem=0; /* get available memory from the rvf */ if ( rvf_get_available_mem( &total_mem, &used_mem) != RVF_OK ) { return RVM_MEMORY_ERR; } /* count required memory */ while (cur_swe !=NULL ) /* for each SWE */ { UINT8 swe_index = cur_swe->swe_id; /* ** If SWE is already running => MB already created => do nothing */ if (rvm_swe_array[swe_index].swe_state != SWE_RUNNING ) { for( mb_index = 0; mb_index < cur_swe->nb_requested_mb; mb_index++) /* for each mb */ { required_mem += cur_swe->swe_mem_bank[mb_index].mb_initial_param.size; } /* add the necessary stack sizes */ /* TO DO: add the stack size for host groups not yet started */ if( (cur_swe->swe_type == RVM_SWE_TYPE_3) || (cur_swe->swe_type == RVM_SWE_TYPE_4) ) /* || ((cur_swe->swe_type == RVM_SWE_TYPE_2) && (rvm_swe_array[swe_index].group_index == RVM_OWN_GROUP) )) */ { required_mem += rvm_swe_array[swe_index].swe_stack_size; required_mem += SYSTEM_TASK_MEM; /* only for type 3 & 4. A-M-E-N-D-E-D! */ } } cur_swe = cur_swe->next_swe; } /* type 2 group host system and stack mem. is catered for here */ for(i=0; i<cnt; i++) host_task_mem+=gd[i].stack_size; /* A-M-E-N-D-E-D! */ host_task_mem+=(cnt*SYSTEM_TASK_MEM); /* compare available memory and required memory (eventually, use a percentage to improve performances) */ if ((required_mem+host_task_mem) + used_mem > total_mem ) { /* A-M-E-N-D-E-D! */ RVM_TRACE_WARNING_PARAM("RVM: Memory required (incl. used): ", (UINT32)(required_mem+host_task_mem+ used_mem) ); RVM_TRACE_WARNING_PARAM("RVM: Total Memory available : ", (UINT32)total_mem); return RVM_MEMORY_ERR; } else{ return RVM_OK; } } /******************************************************************************* ** ** Function rvm_allocate_mem ** ** Description This function creates all the required memory banks or ** increases their size if needed, to start a SWE. ** ** Parameters: T_RVM_PROCESSING_SWE * appli: list of required SWEs with their parameters. ** ** Returns T_RVM_RETURN: RVM_OK if all allocations are successful, ** else RVM_MEMORY_ERR and it releases all the allocated memory. ** *******************************************************************************/ T_RVM_RETURN rvm_allocate_mb( T_RVM_PROCESSING_SWE * appli) { T_RVM_PROCESSING_SWE * cur_swe = appli; UINT8 mb_index; volatile T_RVM_RETURN rvm_ret_value = RVM_OK; /* for each SWE in the list */ while ((cur_swe != NULL ) && (rvm_ret_value == RVM_OK)) { UINT8 swe_index = cur_swe->swe_id; if (rvm_swe_array[swe_index].swe_state == SWE_NOT_STARTED) /* If the state is not SWE_RUNNING, then the MBs have to be created */ { for( mb_index = 0; mb_index < cur_swe->nb_requested_mb; mb_index++) /* for each mb */ { T_RVF_MB_PARAM mb_param; /* add the initial size */ mb_param.size = cur_swe->swe_mem_bank[mb_index].mb_initial_param.size; mb_param.watermark = cur_swe->swe_mem_bank[mb_index].mb_initial_param.watermark; /* create the mb */ if ( mb_param.size != 0) { /* create the mb */ if ( rvf_create_mb( cur_swe->swe_mem_bank[mb_index].mb_name, mb_param, &(cur_swe->bk_id_table[mb_index]) ) != RVF_OK) { /* if an error occurs */ rvm_ret_value = RVM_MEMORY_ERR; break; } else { cur_swe->nb_created_mb++; } } } } cur_swe = cur_swe->next_swe; /* process the next SWE */ } if (rvm_ret_value != RVM_OK) /* Something went wrong, should release all used memory */ { rvf_send_trace("RVM: Problem in memory bank creation !!!", 40, NULL_PARAM, RV_TRACE_LEVEL_WARNING, RVM_USE_ID ); if (rvm_delete_created_mb (appli) != RVM_OK) { rvf_send_trace("RVM: MB deleting error!!!", 25, NULL_PARAM, RV_TRACE_LEVEL_WARNING, RVM_USE_ID ); } } return rvm_ret_value; } /******************************************************************************* ** ** Function rvm_allocate_stack_buffer ** ** Description This function allocates a buffer for the stack of a new ** task created by RVM. ** ** Parameters: UINT32 stack_size: size of stack. ** T_RVF_BUFFER** stack_ptr: pointer to the allocated buffer. ** ** Returns T_RVM_RETURN: RVM_OK if all allocation is successful, ** else RVM_MEMORY_ERR. ** *******************************************************************************/ T_RVM_RETURN rvm_allocate_stack_buffer( UINT32 stack_size, T_RVF_BUFFER** stack_ptr ) { T_RVF_MB_PARAM mb_params; /* increase the size of the stack MB before allocating the new buffer */ if( rvf_get_mb_param( RVM_STACK_MB, &mb_params) != RV_OK) { return RVM_MEMORY_ERR; } mb_params.size += stack_size; mb_params.watermark += stack_size; if( rvf_set_mb_param( RVM_STACK_MB, &mb_params) != RV_OK) { return RVM_MEMORY_ERR; } if( rvf_get_buf( rvm_stack_mem_bank, stack_size, stack_ptr) == RVF_RED) { return RVM_MEMORY_ERR; } return RVM_OK; }