int main() {
TIL311 = 0x98;
srand();
sem_init(&lcd_sem);
lcd_init();
serial_start(SERIAL_SAFE);
puts("Hello! Starting tasks.\n");
enter_critical();
create_task(&task_time,0);
create_task(&task_echo,0);
create_task(&task_scroller,0);
create_task(&task_wav_play,0);
/* for (int i = 0; i < 16; i++)
create_task(&breeder_task,0);*/
leave_critical();
yield();
puts("Tasks started, main() returning.\n");
return 0;
}
volatile task_t* timer_callback(task_t *regs) {
tick++;
millis_from_boot += 1000 / timer_frequency;
#ifdef DEBUG
#ifdef TIMER_VERBOSE_TICKS
kprintf("[%s : %d]\r\n", "Tick", tick);
#endif
#endif
io_out8(0x20, 0x20); //重设时钟中断
volatile task_t* oregs = regs;
if (a) {
create_task(regs, stb + 4096, taskb);
create_task(regs, sta + 4096, taska);
a = false;
ptra = sta + 4096 - sizeof(task_t);
ptrb = stb + 4096 - sizeof(task_t);
oregs = ptra;
} else if (!b) {
ptra = regs;
oregs = ptrb;
} else {
ptrb = regs;
oregs = ptra;
}
b=!b;
//
return oregs;
}
int main(void)
{
unsigned int user_stacks[TASK_LIMIT][STACK_SIZE];
unsigned int *usertasks[TASK_LIMIT];
size_t task_count = 0;
size_t current_task;
task_init();
print_str("OS: Starting...\n");
print_str("OS: First create task 1\n");
usertasks[0] = create_task(user_stacks[0], &task1_func);
task_count += 1;
print_str("OS: Back to OS, create task 2\n");
usertasks[1] = create_task(user_stacks[1], &task2_func);
task_count += 1;
print_str("\nOS: Start round-robin scheduler!\n");
/* SysTick configuration */
*SYSTICK_LOAD = ( SystemCoreClock / TICK_RATE_HZ) - 1UL;
*SYSTICK_VAL = 0;
*SYSTICK_CTRL = 0x07;
current_task = 0;
while (1) {
print_str("OS: Activate next task\n");
usertasks[current_task] = activate(usertasks[current_task]);
print_str("OS: Back to OS\n");
current_task = current_task == (task_count - 1) ? 0 : current_task + 1;
}
return 0;
}
int main(void) {
if(init_kernel() != OK)
{
/* Memory allocation problems */
while(1);
}
if(create_task( car_movement, 3000 ) != OK )
{
/* Memory allocation problems */
while(1);
}
if (create_task(cruisecontrol, 3500 ) != OK )
{
/* Memory allocation problems */
while(1);
}
if ((mbi=create_mailbox(1,sizeof(int))) == NULL) {
/* Memory allocation problems */
while (1);
}
if ((mbf=create_mailbox(1,sizeof(double))) == NULL) {
/* Memory allocation problems */
while (1);
}
run();
return 0;
}
/********************************************************
MAIN
*********************************************************/
int main(void)
{
int map[XMAX][YMAX], bmap[XMAX][YMAX][2];
SPLAYER player;
LPTCB task;
floor_cnt = 1;
init_genrand((unsigned long)time(NULL)); // 必ずmainに入れること
init_task();
init_monster();
task = create_task(title_load, NULL, PRIO_00);
task->p[0] = &player;
task->p[1] = &floor_cnt;
task = create_task(game_start, NULL, PRIO_00);
task->p[0] = map;
task->p[1] = &player;
task->p[2] = bmap;
loop_task();
// printf("taskcnt =%d\n", count_task());
return 0;
}
int main(void)
{
unsigned int user_stacks[TASK_LIMIT][STACK_SIZE];
unsigned int *usertasks[TASK_LIMIT];
size_t task_count = 0;
size_t current_task;
usart_init();
task_init();
print_str("OS: Starting...\n");
print_str("OS: First create task 1\n");
usertasks[0] = create_task(user_stacks[0], &task1_func);
task_count += 1;
print_str("OS: Back to OS, create task 2\n");
usertasks[1] = create_task(user_stacks[1], &task2_func);
task_count += 1;
print_str("\nOS: Start multitasking, back to OS till task yield!\n");
current_task = 0;
while (1) {
print_str("OS: Activate next task\n");
usertasks[current_task] = activate(usertasks[current_task]);
print_str("OS: Back to OS\n");
current_task = current_task == (task_count - 1) ? 0 : current_task + 1;
}
return 0;
}
static void Init(rtems_task_argument arg)
{
test_context *ctx = &test_instance;
TEST_BEGIN();
ctx->low = rtems_task_self();
create_task(&ctx->mid, 3);
create_task(&ctx->high, 1);
create_task(&ctx->inversion, 2);
create_sema(&ctx->sem_a);
create_sema(&ctx->sem_b);
obtain_sema(ctx->sem_a);
start_task(ctx->mid, mid_task);
start_task(ctx->high, high_task);
/*
* Here we see that the priority of the high priority task blocked on
* semaphore B propagated to the low priority task owning semaphore A
* on which the owner of semaphore B depends.
*/
assert_prio(ctx->low, 1);
assert_prio(ctx->mid, 1);
assert_prio(ctx->high, 1);
assert_prio(ctx->inversion, 2);
TEST_END();
rtems_test_exit(0);
}
static void initialize(int minor)
{
console_tbl *ct = &Console_Port_Tbl [minor];
uart_bridge_master_control *control = ct->pDeviceParams;
intercom_type type = control->type;
qoriq_intercom_service_install(type, uart_bridge_master_service, control);
create_task('R', receive_task, control);
control->transmit_task = create_task('T', transmit_task, control);
}
int main(int argc, char** argv, char** envp) {
if(argv[1]) {
if(strcmp(argv[1], "-gui") == 0)
create_task(tmain_gui);
else if(strcmp(argv[1], "-text") == 0)
create_task(tmain_text);
else
_exit(-1);
}
}
void init_multitasking()
{
asm volatile("cli");
//memset((void*)(200*1024*1024),0,(40*1024*1024));
kernel_proc = create_process("microkernel", 0, 1, 0);
new_process = (uint32_t)kernel_proc;
current_task = (uint32_t)create_task("initiating_task",tasking_initiator, 20, 0x202, kernel_proc); //Scheduler initalization task
old_task = current_task;
Idle_task = create_task("System_idle_task",idle, 20, 0x202, kernel_proc); //default task
Activate_task_direct(Idle_task);
Activate_task_direct(create_task("idle2",idle2, 10, 0x202, kernel_proc));
Activate_task_direct(create_task("idle3",idle3, 10, 0x202, kernel_proc));
Activate_task_direct(create_task("idle4",idle4, 10, 0x202, kernel_proc));
Activate_task_direct(create_task("idle5",idle5, 10, 0x202, kernel_proc));
Activate_task_direct(create_task("idle6",idle6, 10, 0x202, kernel_proc));
//Activate_task_direct(create_task("Main_Kernel",kernel_main, 10, 0x202, kernel_proc));
Shell_proc = create_process("Shell", 0, 1, kernel_proc);
Activate_task_direct(create_task("Shell_Ostream", Console_Writer, 10, 0x202, Shell_proc));
reached_bottom = 0;
Scheduler_init(); // Let the FUN Begin :D Lets Switch from the old monotasking world to Multitasking World :D defined in tasking.asm
}
int create_kernel_task(tid_t* id, entry_point_t ep, void* args, uint8_t prio)
{
if (prio > MAX_PRIO)
prio = NORMAL_PRIO;
return create_task(id, ep, args, prio, CORE_ID);
}
dove_status dcs_statistics_init(char *pythonpath)
{
dove_status status = DOVE_STATUS_OK;
do
{
status = python_functions_init(pythonpath);
if (status != DOVE_STATUS_OK)
{
break;
}
/* Initialize mutex and condition variable objects */
if (pthread_mutex_init(&dps_statistics_mp, NULL) != 0) {
status = DOVE_STATUS_INVALID_PARAMETER;
break;
}
if (pthread_cond_init (&dps_statistics_cv, NULL) != 0) {
status = DOVE_STATUS_INVALID_PARAMETER;
break;
}
/* Create a thread for statistics collection */
if (create_task((const char *)"Stat", 0, OSW_DEFAULT_STACK_SIZE,
dps_statistics_main, 0,
&statisticsTaskId) != OSW_OK)
{
status = DOVE_STATUS_THREAD_FAILED;
break;
}
} while (0);
return status;
}
int create_kernel_task_on_core(tid_t* id, entry_point_t ep, void* args, uint8_t prio, uint32_t core_id)
{
if (prio > MAX_PRIO)
prio = NORMAL_PRIO;
return create_task(id, ep, args, prio, core_id);
}
/**
* All data has been delivered. Your implementation should now finish writing out sorted data and verbose info.
* The output stream will be closed for you after this call returns
*/
void stream_end() {
// do awesome stuff
// then print to outfile e.g.
menqueue(NULL);
//merge = 1;
//create_task(NULL, 0, nitems);
int i;
worker_funcs(NULL);
for(i = 1; i < nthreads; i++){
pthread_join(tid[i], NULL);
}
merge = 1;
//create_task(NULL, 0, nitems);
for(i = 1; i < nthreads; i++){
pthread_create(&tid[i], NULL, worker_merge, NULL);
}
create_task(NULL, 0, nitems);
worker_merge(NULL);
for(i = 1; i < nthreads; i++){
pthread_join(tid[i], NULL);
}
for(int i = 0; i < nitems ;i++)
fprintf(outfile,"%d\n", data[i]);
if(outfile != stdout)
fclose(outfile);
}
dove_status dps_statistics_start(void)
{
dove_status status = DOVE_STATUS_OK;
do
{
if (search_task("Stat") != 0)
{
log_info(PythonDataHandlerLogLevel, "Thread is running\r\n");
break;
}
log_info(PythonDataHandlerLogLevel, "Starting thread\r\n");
/* Re-initialize resources and create a thread */
if (pthread_mutex_init(&dps_statistics_mp, NULL) != 0)
{
status = DOVE_STATUS_INVALID_PARAMETER;
break;
}
if (pthread_cond_init (&dps_statistics_cv, NULL) != 0)
{
status = DOVE_STATUS_INVALID_PARAMETER;
break;
}
if (create_task((const char *)"Stat", 0, OSW_DEFAULT_STACK_SIZE,
dps_statistics_main, 0,
&statisticsTaskId) != OSW_OK)
{
status = DOVE_STATUS_THREAD_FAILED;
break;
}
} while (0);
return status;
}
akj::tTAFHandle cFontLoader::CreateTexAtlasFont(
tFaceHandle handle, uint32_t initial_size)
{
if(!handle.IsValid()) return tTAFHandle();
FreeTypeFace& face = TypeFace(handle);
cCreateTexAtlasTask create_task(face, initial_size);
while(!create_task.IsDone()) create_task.DoWork();
std::unique_ptr<cTexAtlasFont> taf(
new cTexAtlasFont(face,
std::unique_ptr<FreeTypeLibrary>(new FreeTypeLibrary),
std::move(create_task.GetFinishedAtlas())));
cArray<16, uint32_t> sizes = {14, 12, 21};
for(uint32_t i: sizes)
{
if(i == initial_size) continue;
cCreateTexAtlasTask create_task2(face, i);
while(!create_task2.IsDone()) create_task2.DoWork();
taf->AddAtlas(create_task2.GetFinishedAtlas());
}
taf->RepackAtlasTexture();
return InsertTAF(std::move(taf));
}
void
rb_mtp_thread_set_device_name (RBMtpThread *thread, const char *name)
{
RBMtpThreadTask *task = create_task (SET_DEVICE_NAME);
task->name = g_strdup (name);
queue_task (thread, task);
}
static int create_task_21(starpu_data_handle_t dataA, unsigned k, unsigned j, unsigned reclevel)
{
int ret;
struct starpu_task *task = create_task(TAG21_AUX(k, j, reclevel));
task->cl = &cl21;
/* which sub-data is manipulated ? */
task->handles[0] = starpu_data_get_sub_data(dataA, 2, k, k);
task->handles[1] = starpu_data_get_sub_data(dataA, 2, k, j);
if (j == k+1)
{
task->priority = STARPU_MAX_PRIO;
}
/* enforce dependencies ... */
if (k > 0)
{
starpu_tag_declare_deps(TAG21_AUX(k, j, reclevel), 2, TAG11_AUX(k, reclevel), TAG22_AUX(k-1, k, j, reclevel));
}
else
{
starpu_tag_declare_deps(TAG21_AUX(k, j, reclevel), 1, TAG11_AUX(k, reclevel));
}
int n = starpu_matrix_get_nx(task->handles[0]);
task->flops = FLOPS_STRSM(n, n);
ret = starpu_task_submit(task);
if (ret != -ENODEV) STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
return ret;
}
static struct starpu_task * create_task_11(starpu_data_handle_t dataA, unsigned k)
{
/* FPRINTF(stdout, "task 11 k = %d TAG = %llx\n", k, (TAG11(k))); */
struct starpu_task *task = create_task(TAG11(k));
task->cl = &cl11;
/* which sub-data is manipulated ? */
task->handles[0] = starpu_data_get_sub_data(dataA, 2, k, k);
/* this is an important task */
if (!noprio)
task->priority = STARPU_MAX_PRIO;
/* enforce dependencies ... */
if (k > 0)
{
starpu_tag_declare_deps(TAG11(k), 1, TAG22(k-1, k, k));
}
int n = starpu_matrix_get_nx(task->handles[0]);
task->flops = FLOPS_SPOTRF(n);
return task;
}
void Directory::refresh() {
need_update = false;
refresh_timer.restart();
if (uri.isEmpty()) {
emit error(tr("Address is empty"));
return;
}
if (Special_uri(uri).name() == Special_uri::mounts) { //mounting of unmounted volume was requested
//uri is something like "places/mounts/42"
int id = uri.split("/").last().toInt();
QList<Gio_volume*> volumes = core->get_mount_manager()->get_volumes();
if (id < 0 || id >= volumes.count()) {
emit error(tr("Invalid volume id"));
return;
}
GVolume* volume = volumes.at(id)->get_gvolume();
interrupt_gio_operation();
gcancellable = g_cancellable_new();
async_result_type = async_result_mount_volume;
g_volume_mount(volume, GMountMountFlags(), 0, gcancellable, async_result, this);
return;
}
create_task(uri);
}
static void
allservice_check_start_HT(struct namespace_data_s *ns_data, GHashTable *ht)
{
gsize offset;
struct taskdata_checksrv_s td_scheme;
GHashTableIter iter_serv;
gpointer k, v;
TRACE_POSITION();
g_hash_table_iter_init(&iter_serv, ht);
while (g_hash_table_iter_next(&iter_serv, &k, &v)) {
struct service_info_s *si = v;
memset(&td_scheme, 0x00, sizeof(td_scheme));
offset = g_snprintf(td_scheme.task_name, sizeof(td_scheme.task_name), "%s.", TASK_ID);
addr_info_to_string(&(si->addr), td_scheme.task_name+offset, sizeof(td_scheme.task_name)-offset);
g_strlcpy(td_scheme.ns_name, ns_data->name, sizeof(td_scheme.ns_name)-1);
if (!_agent_check_enabled(si)) {
GRID_DEBUG("Task [%s] disabled by "
NAME_TAGNAME_AGENT_CHECK, td_scheme.task_name);
} else if (!is_task_scheduled(td_scheme.task_name)) {
GError *error_local = NULL;
task_t *task = NULL;
struct taskdata_checksrv_s *task_data;
TRACE_POSITION();
agent_get_service_key(si, td_scheme.srv_key, sizeof(td_scheme.srv_key));
g_strlcpy(td_scheme.srv_key, (gchar*)k, sizeof(td_scheme.srv_key)-1);
/* prepare the task structure */
task_data = g_memdup(&td_scheme, sizeof(td_scheme));
if (!task_data) {
ERROR("Memory allocation failure");
continue;
}
task = create_task(period_check_services, td_scheme.task_name);
task = set_task_callbacks(task, _check_tcp_service_task,
g_free, task_data);
if (!task) {
ERROR("Memory allocation failure");
continue;
}
/* now start the task! */
if (add_task_to_schedule(task, &error_local))
INFO("Task started: %s", td_scheme.task_name);
else {
ERROR("Failed to add task to scheduler [%s] : %s", td_scheme.task_name, gerror_get_message(error_local));
g_free(task);
}
if (error_local)
g_clear_error(&error_local);
}
}
TRACE_POSITION();
}
static gboolean
task_starter(gpointer udata, GError **error)
{
gpointer ns_k, ns_v;
GHashTableIter ns_iterator;
task_t *task;
gchar ns_id[sizeof(TASK_ID)+1+LIMIT_LENGTH_NSNAME];
namespace_data_t *ns_data;
(void)udata;
g_hash_table_iter_init(&ns_iterator, namespaces);
while (g_hash_table_iter_next(&ns_iterator,&ns_k,&ns_v)) {
ns_data = ns_v;
g_snprintf(ns_id,sizeof(ns_id),TASK_ID".%s",ns_data->name);
if (!namespace_is_available(ns_data)) {
if (!is_task_scheduled(ns_id)) {
task = create_task(period_get_ns, ns_id);
task = set_task_callbacks(task, task_worker, g_free, g_strdup(ns_data->name));
if (!add_task_to_schedule(task, error)) {
ERROR("[task_id="TASK_ID"] Failed to start a sub worker for namespace '%s'", (gchar*)ns_k);
g_free(task);
}
else
INFO("[task_id="TASK_ID"] subtask started [%s]", ns_id);
}
}
}
task_done(TASK_ID);
return 1;
}
int insert_timer_directional(u_int8_t task_type, u_int64_t delay,
u_int8_t retries, u_int32_t src_ip, u_int32_t dst_ip, unsigned char tos) {
task *new_timer = NULL;
new_timer = create_task(task_type);
// get memory
if (!(new_timer)) {
printk("Error allocating timer!\n");
return -ENOMEM;
}
new_timer->src_ip = src_ip;
new_timer->dst_ip = dst_ip;
new_timer->tos = tos;
if (delay != 0)
new_timer->time = getcurrtime() + delay;
else if (task_type == TASK_RESEND_RREQ) {
new_timer->retries = retries;
new_timer->ttl = 30;
new_timer->time = getcurrtime() + ((2 ^ (RREQ_RETRIES - retries))
* NET_TRAVERSAL_TIME);
} else
new_timer->time = getcurrtime() + delay;
queue_timer(new_timer);
//update_timer_queue();
return 0;
}
static void create_task_12(starpu_data_handle *dataAp, unsigned nblocks, unsigned k, unsigned j,
starpu_data_handle (* get_block)(starpu_data_handle *, unsigned, unsigned, unsigned))
{
// printf("task 12 k,i = %d,%d TAG = %llx\n", k,i, TAG12(k,i));
struct starpu_task *task = create_task();
task->cl = &cl12;
task->cl_arg = NULL;
/* which sub-data is manipulated ? */
task->buffers[0].handle = get_block(dataAp, nblocks, k, k);
task->buffers[0].mode = STARPU_R;
task->buffers[1].handle = get_block(dataAp, nblocks, j, k);
task->buffers[1].mode = STARPU_RW;
if (!no_prio && (j == k+1)) {
task->priority = STARPU_MAX_PRIO;
}
/* enforce dependencies ... */
#if 0
starpu_tag_declare_deps(TAG12(k, i), 1, PIVOT(k, i));
#endif
if (k > 0) {
starpu_task_declare_deps_array(task, 1, &EVENT(k,k));
starpu_task_declare_deps_array(task, 1, &EVENT(k,j));
}
else {
starpu_task_declare_deps_array(task, 1, &EVENT(k,k));
}
starpu_task_submit(task, NULL);
}
rust_scheduler::rust_scheduler(rust_kernel *kernel,
rust_message_queue *message_queue, rust_srv *srv,
const char *name) :
interrupt_flag(0),
_log(srv, this),
log_lvl(log_note),
srv(srv),
name(name),
newborn_tasks(this, "newborn"),
running_tasks(this, "running"),
blocked_tasks(this, "blocked"),
dead_tasks(this, "dead"),
cache(this),
root_task(NULL),
curr_task(NULL),
rval(0),
kernel(kernel),
message_queue(message_queue)
{
LOGPTR(this, "new dom", (uintptr_t)this);
isaac_init(this, &rctx);
#ifndef __WIN32__
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, 1024 * 1024);
pthread_attr_setdetachstate(&attr, true);
#endif
root_task = create_task(NULL, name);
}
static void create_task_21(starpu_data_handle_t dataA, unsigned k, unsigned j)
{
int ret;
struct starpu_task *task = create_task(TAG21(k, j));
task->cl = &cl21;
/* which sub-data is manipulated ? */
task->handles[0] = starpu_data_get_sub_data(dataA, 2, k, k);
task->handles[1] = starpu_data_get_sub_data(dataA, 2, k, j);
if (!no_prio && (j == k+1))
{
task->priority = STARPU_MAX_PRIO;
}
/* enforce dependencies ... */
if (k > 0)
{
starpu_tag_declare_deps(TAG21(k, j), 2, TAG11(k), TAG22(k-1, k, j));
}
else
{
starpu_tag_declare_deps(TAG21(k, j), 1, TAG11(k));
}
ret = starpu_task_submit(task);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
}
int main( int argc, char **argv )
{
void *pTaskHandle = NULL;
enable_log( 1 );
set_log( LOG_TYPE_CONSOLE, NULL, 0 );
if( init_session( ) < 0 )
return -1;
pTaskHandle = create_task( task_test, 5, 100 );
if ( pTaskHandle )
{
CMessage stMsg;
memset( &stMsg, 0x00, sizeof(stMsg) );
post_task_msg( pTaskHandle, &stMsg );
log_print( "create task ok................." );
}
else
log_print( "create task failed?????????????????????" );
while ( 1 )
os_sleep( 1000 );
release_session( );
return 0;
}
static void create_task_12(starpu_data_handle_t dataA, unsigned k, unsigned i)
{
int ret;
/* printf("task 12 k,i = %d,%d TAG = %llx\n", k,i, TAG12(k,i)); */
struct starpu_task *task = create_task(TAG12(k, i));
task->cl = &cl12;
/* which sub-data is manipulated ? */
task->handles[0] = starpu_data_get_sub_data(dataA, 2, k, k);
task->handles[1] = starpu_data_get_sub_data(dataA, 2, i, k);
if (!no_prio && (i == k+1))
{
task->priority = STARPU_MAX_PRIO;
}
/* enforce dependencies ... */
if (k > 0)
{
starpu_tag_declare_deps(TAG12(k, i), 2, TAG11(k), TAG22(k-1, i, k));
}
else
{
starpu_tag_declare_deps(TAG12(k, i), 1, TAG11(k));
}
ret = starpu_task_submit(task);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
}
cFontLoader::tDistanceFontHandle
cFontLoader::CreateDistanceFieldFont(FreeTypeFace& face, uint32_t tex_size)
{
std::unique_ptr<cDistanceFieldFont> font;
try
{
cCreateBitmapFontTask create_task(face, tex_size);
do
{
Log::Debug("Font creation progress: %d",
static_cast<int>(100.0f*create_task.Progress()));
create_task.DoWork();
} while (!create_task.IsDone());
font = create_task.GetCompletedFont();
}
catch(const FreeTypeException& fail)
{
Log::Error("Failed Distance font creation with freetype error:"
"\n\t%s: \"%s\"",fail.what(),
FreeTypeLibrary::ErrorString(fail.mFreeTypeError));
return tDistanceFontHandle();
}
return InsertDistanceFont(std::move(font));
}
/*
******************************************************************************
* dcs_server_rest_init *//**
*
* \brief - Initializes the DCS Server REST infrastructure
*
* \param[in] rest_port - The Port on which the REST Services should run on
*
* \retval DOVE_STATUS_RESTC_INIT_FAILED Cannot initialize REST Client
* \retval DOVE_STATUS_THREAD_FAILED Cannot start HTTP Server
* \retval DOVE_STATUS_OK Success
*
******************************************************************************
*/
dove_status dcs_server_rest_init(short rest_port)
{
int ret = 0;
dove_status status = DOVE_STATUS_OK;
log_notice(RESTHandlerLogLevel, "dcs_server_rest_init Enter: Port %d", rest_port);
do
{
ret = dove_rest_client_init();
if (ret)
{
status = DOVE_STATUS_RESTC_INIT_FAILED;
break;
}
log_notice(RESTHandlerLogLevel, "dcs_server_rest_init: Initialized REST Client");
/* Create a thread for configuration sync */
if (create_task((const char *)"RSTS", 0, OSW_DEFAULT_STACK_SIZE,
http_server_main, (void *)(long)rest_port,
&httpsrvTaskId) != OSW_OK)
{
status = DOVE_STATUS_THREAD_FAILED;
break;
}
}while(0);
log_notice(RESTHandlerLogLevel, "dcs_server_rest_init Exit: status %s", DOVEStatusToString(status));
return status;
}
