VMK_ReturnStatus
LogFS_CommonInit(void)
{
logfsHeap = Heap_Create("logfs",
VMK_PAGE_SIZE,
LogFS_HEAP_MAX,
MM_PHYS_ANY_CONTIGUITY,
MM_TYPE_ANY);
if (logfsHeap == INVALID_HEAP_ID) {
Warning("Unable to create heap for logfs module");
return VMK_NO_MEMORY;
}
return VMK_OK;
}
/**
* @brief Initializes the TLSF based PAL dynamic memory subsystem.
*
* FYI: TLSF == Two-Level Segregated Fit
*
* Initialize Heap with static pool if it isn't already initialized.
*
* @return SIRF_SUCCESS if successful, SIRF_FAILURE otherwise.
*/
tSIRF_RESULT SIRF_PAL_OS_MEM_Init(void)
{
tSIRF_RESULT result = SIRF_SUCCESS;
if (SIRF_FALSE == s_mem_initialized)
{
result = SIRF_PAL_OS_MUTEX_Create(&s_MemoryMutex);
if (SIRF_SUCCESS != result)
{
return result;
}
s_MemoryHeap = Heap_Create(NullHeapNotify, s_HeapMem, sizeof(s_HeapMem));
if (NULL == s_MemoryHeap)
{
result = SIRF_FAILURE;
}
else
{
s_mem_initialized = SIRF_TRUE;
}
}
return result;
}
void
LB_superblock_formation (L_Func * fn)
{
LB_TraceRegion_Header *header;
LB_TraceRegion *tr_index;
Heap *tr_heap;
int list_size, i, code_size = 0, max_code_size, growth, do_frp;
if (fn->n_cb == 0)
return;
do_frp = !strcmp (LB_predicate_formation_type, "frp");
header = LB_function_init (fn);
L_partial_dead_code_removal (fn);
L_do_flow_analysis (fn, DOMINATOR_CB|SUPPRESS_PG);
L_loop_detection (fn, 0);
L_compute_oper_weight (fn, 0, 1);
LB_convert_to_strict_basic_block_code (fn,
L_CB_SUPERBLOCK | L_CB_HYPERBLOCK |
L_CB_ENTRANCE_BOUNDARY | L_CB_EXIT_BOUNDARY);
L_do_flow_analysis (fn, DOMINATOR_CB);
L_compute_oper_weight (fn, 0, 1);
LB_mark_jrg_flag (fn);
LB_make_traceregions (fn, TRUE, header);
LB_order_traceregions (fn, header);
LB_layout_function (fn, header);
tr_heap = Heap_Create (HEAP_MAX);
List_start (header->traceregions);
while ((tr_index = (LB_TraceRegion *) List_next (header->traceregions)))
{
code_size += LB_traceregion_code_size (tr_index);
Graph_dfs_topo_sort (tr_index->flow_graph);
if ((tr_index->weight >= LB_minimum_superblock_weight) &&
!(tr_index->flags &
(L_TRACEREGION_HYPERBLOCK | L_TRACEREGION_SUPERBLOCK)) &&
(tr_index->header != LB_last_cb_in_region (tr_index)))
Heap_Insert (tr_heap, tr_index, tr_index->weight);
}
max_code_size = (int) (LB_maximum_code_growth * code_size);
LB_predicate_init ();
while ((tr_heap->size > 0) && (code_size < max_code_size))
{
tr_index = (LB_TraceRegion *) Heap_ExtractTop (tr_heap);
growth = LB_tail_duplication (fn, tr_index, LB_DUP_INSIDE_REGION, 1);
if ((code_size + growth) > max_code_size)
continue;
code_size += LB_tail_duplication (fn, tr_index, LB_DUP_INSIDE_REGION, 0);
LB_predicate_traceregion (fn, tr_index, do_frp);
L_set_hb_no_fallthru_flag (fn);
L_check_func (fn);
tr_index->flags |= L_TRACEREGION_SUPERBLOCK;
L_rebuild_src_flow (fn);
LB_mark_jrg_flag (fn);
/* Make traces with the new end cb's */
list_size = List_size (header->traceregions);
LB_make_traceregions (fn, FALSE, header);
LB_order_traceregions (fn, header);
LB_layout_function (fn, header);
i = 0;
while ((tr_index = (LB_TraceRegion *) List_next (header->traceregions)))
{
if (++i <= list_size)
continue;
Graph_dfs_topo_sort (tr_index->flow_graph);
if ((tr_index->weight >= LB_minimum_superblock_weight) &&
!(tr_index->flags & (L_TRACEREGION_HYPERBLOCK |
L_TRACEREGION_SUPERBLOCK)) &&
(tr_index->header != LB_last_cb_in_region (tr_index)))
Heap_Insert (tr_heap, tr_index, tr_index->weight);
}
}
tr_heap = Heap_Dispose (tr_heap, NULL);
LB_predicate_deinit (fn);
fn->flags = L_SET_BIT_FLAG (fn->flags, L_FUNC_SUPERBLOCK);
L_rebuild_src_flow (fn);
if (do_frp || LB_hb_do_combine_exits)
{
L_create_uncond_pred_defines (fn);
L_combine_pred_defines (fn);
}
/* For each source code function we process deinit */
LB_function_deinit (header);
return;
}
/**
* Create the AT Command server instance
*
* @param port_name Name of the uart port the Modem is connected
*
* @return Success if the port was opened successfully
*/
tSIRF_RESULT SIRF_GPRS_AT_COMMAND_SERVER_Create(
tSIRF_CHAR const * const port_name,
tSIRF_CHAR const * const apn )
{
tSIRF_RESULT result;
tSIRF_MSG_SSB_EXT_UART_OPEN_PORT port_settings;
/* This only works initially if gprs_at_command is in ZI data */
if (NULL != gprs_at_command.listener_mx)
{
return SIRF_GPRS_AT_COMMAND_SERVER_ALREADY_CREATED;
}
/* This is necessar if Create is ever called a second time */
memset( &gprs_at_command, 0, sizeof(gprs_at_command) );
/* Initialize the queues. These fucntion cannot fail */
fifo_queue_init( &gprs_at_command.msg_queue_gprs );
fifo_queue_init( &gprs_at_command.msg_queue_gprs_input );
gprs_at_command.command_timeout = DEFAULT_GPRS_RESPONSE_TIMEOUT;
/* Open a uart port to the modem */
strlcpy(port_settings.port_name,port_name,sizeof(port_settings.port_name));
port_settings.baud_rate = SIRF_GPRS_AT_COMMAND_BAUD_RATE;
port_settings.flow_control = SIRF_GPRS_AT_COMMAND_FLOW_CONTROL;
/* Create the semaphore */
result = SIRF_PAL_OS_SEMAPHORE_Create(&gprs_at_command.semaphore,0);
if ( SIRF_SUCCESS != result )
{
return result;
}
result = SIRF_PAL_OS_MUTEX_Create( &gprs_at_command.listener_mx );
if ( SIRF_SUCCESS != result )
{
goto GPRS_ERROR_1;
}
result = SIRF_PAL_OS_MUTEX_Create( &gprs_at_command.queue_mx );
if ( SIRF_SUCCESS != result )
{
goto GPRS_ERROR_2;
}
gprs_at_command.msg_heap = Heap_Create( GprsMsgQueueHeap_notify,
gprs_heap_space,
sizeof(gprs_heap_space) );
if (NULL == gprs_at_command.msg_heap)
{
goto GPRS_ERROR_3;
}
/* Must open the UART last since it might call the callback fuctnion which
* uses the heap and queues mutex's and semaphores, but before the
* queue reading thread since the queue reading thread calls into the
* uart */
result = SIRF_EXT_UART_Open(&gprs_at_command.uartno,
&port_settings,
SIRF_GPRS_AT_COMMAND_UartPacketCallbackATCommand,
SIRF_PROTO_GPRS_AT_COMMAND_Parser);
if ( SIRF_SUCCESS != result )
{
goto GPRS_ERROR_4;
}
gprs_at_command.thread_running = SIRF_TRUE;
result = SIRF_PAL_OS_THREAD_Create(
SIRFLPL_THREAD_GPRS,
(tSIRF_HANDLE)SIRF_GPRS_AT_COMMAND_ReadThread,
&gprs_at_command.server_thread );
if (SIRF_SUCCESS != result)
{
goto GPRS_ERROR_5;
}
result = gprs_start(gprs_at_command.uartno,
SIRF_GPRS_AT_COMMAND_FLOW_CONTROL,
apn);
if (SIRF_SUCCESS != result)
{
goto GPRS_ERROR_5;
}
return SIRF_SUCCESS;
GPRS_ERROR_5:
/* Must kill our own thread and delete it */
gprs_at_command.thread_running = SIRF_FALSE;
(void)SIRF_PAL_OS_SEMAPHORE_Release(gprs_at_command.semaphore);
(void)SIRF_PAL_OS_THREAD_Delete(gprs_at_command.server_thread);
GPRS_ERROR_4:
/* Heap_Create doesn't have a Heap Destroy */
GPRS_ERROR_3:
(void)SIRF_PAL_OS_MUTEX_Delete(gprs_at_command.queue_mx);
gprs_at_command.queue_mx = NULL;
GPRS_ERROR_2:
(void)SIRF_PAL_OS_MUTEX_Delete(gprs_at_command.listener_mx);
gprs_at_command.listener_mx = NULL;
GPRS_ERROR_1:
(void)SIRF_PAL_OS_SEMAPHORE_Delete(gprs_at_command.semaphore);
gprs_at_command.semaphore = NULL;
return result;
} /* SIRF_GPRS_AT_COMMAND_Create()*/
void scalanative_init() {
heap = Heap_Create(INITIAL_HEAP_SIZE);
stack = Stack_Alloc(INITIAL_STACK_SIZE);
}
