Пример #1
0
BOOL Thread_setValue(MVALUE** stack_ptr, MVALUE* lvar, sVMInfo* info, CLObject vm_type, sCLClass* klass)
{
    CLObject self;
    CLObject value;

    vm_mutex_lock();

    self = lvar->mObjectValue.mValue;
    if(!check_type_with_class_name(self, "Thread", info)) {
        vm_mutex_unlock();
        return FALSE;
    }

    value = (lvar+1)->mObjectValue.mValue;
    if(!check_type_with_class_name(value, "Thread", info)) {
        vm_mutex_unlock();
        return FALSE;
    }

    CLTHREAD(self)->mThread = CLTHREAD(value)->mThread;

    vm_mutex_unlock();

    return TRUE;
}
Пример #2
0
BOOL bool_setValue(MVALUE** stack_ptr, MVALUE* lvar, sVMInfo* info, CLObject vm_type, sCLClass* klass)
{
    CLObject self, value;
    CLObject new_obj;

    vm_mutex_lock();

    self = lvar->mObjectValue.mValue;
    value = (lvar+1)->mObjectValue.mValue;

    if(!check_type(self, gBoolTypeObject, info)) {
        vm_mutex_unlock();
        return FALSE;
    }
    if(!check_type(value, gBoolTypeObject, info)) {
        vm_mutex_unlock();
        return FALSE;
    }

    CLBOOL(self)->mValue = CLBOOL(value)->mValue;

    new_obj = create_bool_object(CLBOOL(self)->mValue);

    (*stack_ptr)->mObjectValue.mValue = new_obj;  // push result
    (*stack_ptr)++;

    vm_mutex_unlock();

    return TRUE;
}
Пример #3
0
BOOL Bytes_cmp(MVALUE** stack_ptr, MVALUE* lvar, sVMInfo* info, CLObject vm_type, sCLClass* klass)
{
    CLObject self, right;
    char* chars;
    char* chars2;

    vm_mutex_lock();

    self = lvar->mObjectValue.mValue;

    if(!check_type(self, gBytesTypeObject, info)) {
        vm_mutex_unlock();
        return FALSE;
    }

    chars = CLBYTES_DATA(self)->mChars;

    right = (lvar+1)->mObjectValue.mValue;

    if(!check_type(right, gBytesTypeObject, info)) {
        vm_mutex_unlock();
        return FALSE;
    }

    chars2 = CLBYTES_DATA(right)->mChars;

    (*stack_ptr)->mObjectValue.mValue = create_int_object(strcmp(chars, chars));
    (*stack_ptr)++;

    vm_mutex_unlock();

    return TRUE;
}
Пример #4
0
static void new_task(handle_details* details, hx711_op op, int delay, void (*callback)(void*, int), void* callback_env)
{
	vm_mutex_lock(&details->mutex);
	details->task.op = op;
	details->task.delay = delay;
	details->task.callback = callback;
	details->task.callback_env = callback_env;
	vm_mutex_unlock(&details->mutex);
}
/* set thread priority, return 1 if successful */
Ipp32s vm_thread_set_priority(vm_thread *thread, vm_thread_priority priority)
{
    Ipp32s i_res = 1;
    Ipp32s policy, pmin, pmax, pmean;
    struct sched_param param;

    /* check error(s) */
    if (NULL == thread)
        return 0;

    if (thread->is_valid)
    {
        vm_mutex_lock(&thread->access_mut);
        pthread_getschedparam(thread->handle,&policy,&param);

        pmin = sched_get_priority_min(policy);
        pmax = sched_get_priority_max(policy);
        pmean = (pmin + pmax) / 2;

        switch (priority)
        {
        case VM_THREAD_PRIORITY_HIGHEST:
            param.sched_priority = pmax;
            break;

        case VM_THREAD_PRIORITY_LOWEST:
            param.sched_priority = pmin;
            break;

        case VM_THREAD_PRIORITY_NORMAL:
            param.sched_priority = pmean;
            break;

        case VM_THREAD_PRIORITY_HIGH:
            param.sched_priority = (pmax + pmean) / 2;
            break;

        case VM_THREAD_PRIORITY_LOW:
            param.sched_priority = (pmin + pmean) / 2;
            break;

        default:
            i_res = 0;
            break;
        }

        if (i_res)
            i_res = !pthread_setschedparam(thread->handle, policy, &param);
        vm_mutex_unlock(&thread->access_mut);
    }
    return i_res;

} /* Ipp32s vm_thread_set_priority(vm_thread *thread, vm_thread_priority priority) */
Пример #6
0
BOOL Bytes_replace(MVALUE** stack_ptr, MVALUE* lvar, sVMInfo* info, CLObject vm_type, sCLClass* klass)
{
    CLObject self;
    int index;
    unsigned char character;
    CLObject ovalue1, ovalue2;
    unsigned char* chars;

    vm_mutex_lock();

    self = lvar->mObjectValue.mValue;

    if(!check_type(self, gBytesTypeObject, info)) {
        vm_mutex_unlock();
        return FALSE;
    }

    ovalue1 = (lvar+1)->mObjectValue.mValue;
    if(!check_type(ovalue1, gIntTypeObject, info)) {
        vm_mutex_unlock();
        return FALSE;
    }
    index = CLINT(ovalue1)->mValue;

    ovalue2 = (lvar+2)->mObjectValue.mValue;
    if(!check_type(ovalue2, gByteTypeObject, info)) {
        vm_mutex_unlock();
        return FALSE;
    }
    character = CLBYTE(ovalue2)->mValue;

    if(index < 0) index += CLBYTES(self)->mLen;

    if(index < 0 || index >= CLBYTES(self)->mLen) {
        entry_exception_object(info, gExRangeClass, "rage exception");
        vm_mutex_unlock();
        return FALSE;
    }

    chars = CLBYTES_DATA(self)->mChars;

    chars[index] = character;

    (*stack_ptr)->mObjectValue.mValue = create_byte_object(character);
    (*stack_ptr)++;

    vm_mutex_unlock();

    return TRUE;
}
/* wait until a thread exists */
void vm_thread_wait(vm_thread *thread)
{
    /* check error(s) */
    if (NULL == thread)
        return;

    if (thread->is_valid)
    {
        vm_mutex_lock(&thread->access_mut);
        thread->i_wait_count++;
        vm_mutex_unlock(&thread->access_mut);

        vm_event_wait(&thread->exit_event);

        vm_mutex_lock(&thread->access_mut);
        thread->i_wait_count--;
        if (0 == thread->i_wait_count)
        {
            pthread_join(thread->handle, NULL);
            thread->is_valid = 0;
        }
        vm_mutex_unlock(&thread->access_mut);
    }
} /* void vm_thread_wait(vm_thread *thread) */
Пример #8
0
static VMINT32 measurement(VM_THREAD_HANDLE thread_handle, void* user_data)
{
	VMINT measured_result;
	handle_details* details;
	hx711_task current_task;


	write_console("thread enter\n");
	details = (handle_details*) user_data;
	get_task(details, &current_task);
	enter_standby(&current_task);

	while (1)
	{
		get_task(details, &current_task);

		if (current_task.op == TERMINATE)
		{
			break;
		}

		if (current_task.op == WAIT)
		{
			enter_standby(&current_task);
			continue;
		}

		if (current_task.op != A128)
		{
			wait_result(&current_task);
			read_result(&current_task);
			clock_setup_pulses(&current_task);
		}
		wait_result(&current_task);
		measured_result = read_result(&current_task);
		current_task.callback(current_task.callback_env, measured_result);
		enter_standby(&current_task);
	}

	write_console("thread exit\n");
	enter_standby(&current_task);
	vm_mutex_lock(&details->mutex);
	vm_dcl_close(current_task.sda_handle);
	vm_dcl_close(current_task.scl_handle);
	current_task.callback(current_task.callback_env, 0);
	vm_free(details);
	return 0;
}
Пример #9
0
BOOL Bytes_setValue(MVALUE** stack_ptr, MVALUE* lvar, sVMInfo* info, CLObject vm_type, sCLClass* klass)
{
    CLObject self, value;
    unsigned int chars_size;
    CLObject obj2;
    CLObject new_obj;
    unsigned char* chars;
    unsigned char* chars2;
    int i;

    vm_mutex_lock();

    self = lvar->mObjectValue.mValue; // self

    if(!check_type(self, gBytesTypeObject, info)) {
        vm_mutex_unlock();
        return FALSE;
    }

    value = (lvar+1)->mObjectValue.mValue;

    if(!check_type(value, gBytesTypeObject, info)) {
        vm_mutex_unlock();
        return FALSE;
    }

    chars_size = chars_object_size(CLBYTES(value)->mLen+1);
    obj2 = alloc_heap_mem(chars_size, 0);
    CLBYTES(self)->mData = obj2;
    CLBYTES(self)->mLen = CLBYTES(value)->mLen;

    chars = CLBYTES_DATA(self)->mChars;
    chars2 = CLBYTES_DATA(value)->mChars;

    for(i=0; i<CLBYTES(value)->mLen; i++) {
        chars[i] = chars2[i];
    }
    chars[i] = 0;

    new_obj = create_bytes_object(CLBYTES_DATA(value)->mChars, CLBYTES(value)->mLen, gBytesTypeObject, info);

    (*stack_ptr)->mObjectValue.mValue = new_obj;  // push result
    (*stack_ptr)++;

    vm_mutex_unlock();

    return TRUE;
}
Пример #10
0
static int bt_server_spp_read(void* data)
{
	
	  VMINT ret = 0;
	  VMINT i = 0;
    if(g_serverContext.conn_id < 0)
    {
        //not connected yet

        APP_LOG((char*)"[BTC]bt_server_spp_read : not connected yet");

        return true;
    }
    char *readdata = new char[LBT_SERIAL_BUFFER_SIZE];
    if(readdata == NULL)
  	{
  		APP_LOG((char*)"[BTC]bt_server_spp_read : allocate memory fail");
  		return false;
  	}
    ret = vm_btspp_read(g_serverContext.conn_id, (void*)readdata, LBT_SERIAL_BUFFER_SIZE);

    APP_LOG("[BTC]bt_server_spp_read, ret: %d", ret);

    if (ret < 0)
    {
       APP_LOG((char*)"[BTC]bt_server_spp_read : read data fail");

    }
    else 
    {

    	  if(server_mutex.guard == 0)
    	  {
    	      vm_mutex_create(&server_mutex);
    	  }
    	  vm_mutex_lock(&server_mutex);
        for(i=0;i<ret;i++)
        {
        	LBTServer._rx_buffer->store_char(readdata[i]);
        }
        vm_mutex_unlock(&server_mutex);

        APP_LOG((char*)"[BTC]btServerRead : read data success");
    }
    delete[] readdata;
	return ret;
}
Пример #11
0
int LBTServerClass::read(void)
{

  if(_rx_buffer->_iHead == _rx_buffer->_iTail)
  {
  	return -1;
  }
	if(server_mutex.guard == 0)
	{
		vm_mutex_create(&server_mutex);
	}	
 	vm_mutex_lock(&server_mutex); 
  uint8_t uc = _rx_buffer->_aucBuffer[_rx_buffer->_iTail];
  _rx_buffer->_iTail = (unsigned int)(_rx_buffer->_iTail + 1) % LBT_SERIAL_BUFFER_SIZE;
  vm_mutex_unlock(&server_mutex);
  return uc;
  
}
Пример #12
0
int32_t vm_thread_set_scheduling(vm_thread* thread, void* params)
{
    int32_t i_res = 1;
    struct sched_param param;
    vm_thread_linux_schedparams* linux_params = (vm_thread_linux_schedparams*)params;

    /* check error(s) */
    if (!thread || !linux_params)
        return 0;

    if (thread->is_valid)
    {
        vm_mutex_lock(&thread->access_mut);
        param.sched_priority = linux_params->priority;
        i_res = !pthread_setschedparam(thread->handle, linux_params->schedtype, &param);
        vm_mutex_unlock(&thread->access_mut);
    }
    return i_res;
}
/* create a thread. return 1 if success */
Ipp32s vm_thread_create(vm_thread *thread,
                        Ipp32u (*vm_thread_func)(void *),
                        void *arg)
{
    Ipp32s i_res = 1;
    pthread_attr_t attr;

    /* check error(s) */
    if ((NULL == thread) ||
        (NULL == vm_thread_func))
        return 0;

    if (0 != i_res)
    {
        if (VM_OK != vm_event_init(&thread->exit_event, 1, 0))
            i_res = 0;
    }

    if ((0 != i_res) &&
        (VM_OK != vm_mutex_init(&thread->access_mut)))
        i_res = 0;

    if (0 != i_res)
    {
        vm_mutex_lock(&thread->access_mut);
        thread->p_thread_func = vm_thread_func;
        thread->p_arg = arg;
        pthread_attr_init(&attr);
        pthread_attr_setschedpolicy(&attr, geteuid() ? SCHED_OTHER : SCHED_RR);

        thread->is_valid =! pthread_create(&thread->handle,
                                           &attr,
                                           vm_thread_proc,
                                           (void*)thread);
        i_res = (thread->is_valid) ? 1 : 0;
        vm_mutex_unlock(&thread->access_mut);
        pthread_attr_destroy(&attr);
    }
    vm_thread_set_priority(thread, VM_THREAD_PRIORITY_LOWEST);
    return i_res;

} /* Ipp32s vm_thread_create(vm_thread *thread, */
Пример #14
0
BOOL Thread_join(MVALUE** stack_ptr, MVALUE* lvar, sVMInfo* info, CLObject vm_type, sCLClass* klass)
{
    CLObject self;
    pthread_t thread;

    vm_mutex_lock();

    self = lvar->mObjectValue.mValue;
    if(!check_type_with_class_name(self, "Thread", info)) {
        vm_mutex_unlock();
        return FALSE;
    }

    thread = CLTHREAD(self)->mThread;
    vm_mutex_unlock();

    pthread_join(thread, NULL);

    return TRUE;
}
/* verify if the thread handler is valid */
Ipp32s vm_thread_is_valid(vm_thread *thread)
{
    /* check error(s) */
    if (NULL == thread)
        return 0;

    if (thread->is_valid)
    {
        vm_mutex_lock(&thread->access_mut);
        if (VM_OK == vm_event_timed_wait(&thread->exit_event, 0))
        {
            vm_mutex_unlock(&thread->access_mut);
            vm_thread_wait(thread);
        }
        else
            vm_mutex_unlock(&thread->access_mut);
    }
    return thread->is_valid;

} /* Ipp32s vm_thread_is_valid(vm_thread *thread) */
Пример #16
0
void* thread_func(void* param)
{
    MVALUE result;
    struct sThreadFuncArg* arg;

    vm_mutex_lock();

    arg = param;

    if(!cl_excute_block_with_new_stack(&result, arg->mBlock, arg->mResultExistance, arg->mNewVMInfo, 0)) // 1 --> block
    {
        FREE(arg->mNewVMInfo);
        FREE(arg);
        exit(1);
    }

    FREE(arg->mNewVMInfo);
    FREE(arg);

    return NULL;
}
Пример #17
0
/* create a thread. return 1 if success */
int32_t vm_thread_create(vm_thread *thread,
                        uint32_t (*vm_thread_func)(void *),
                        void *arg)
{
    int32_t i_res = 1;
//    pthread_attr_t attr;

    /* check error(s) */
    if ((NULL == thread) ||
        (NULL == vm_thread_func))
        return 0;

    if (0 != i_res)
    {
        if (VM_OK != vm_event_init(&thread->exit_event, 1, 0))
            i_res = 0;
    }

    if ((0 != i_res) &&
        (VM_OK != vm_mutex_init(&thread->access_mut)))
        i_res = 0;

    if (0 != i_res)
    {
        vm_mutex_lock(&thread->access_mut);
        thread->p_thread_func = vm_thread_func;
        thread->p_arg = arg;

        thread->is_valid =! pthread_create(&thread->handle,
                                           NULL,
                                           vm_thread_proc,
                                           (void*)thread);

        i_res = (thread->is_valid) ? 1 : 0;
        vm_mutex_unlock(&thread->access_mut);
//        pthread_attr_destroy(&attr);
    }
    return i_res;

} /* int32_t vm_thread_create(vm_thread *thread, */
Пример #18
0
BOOL Bytes_toString(MVALUE** stack_ptr, MVALUE* lvar, sVMInfo* info, CLObject vm_type, sCLClass* klass)
{
    CLObject self;
    char* buf;
    int len;
    wchar_t* wstr;
    CLObject new_obj;

    vm_mutex_lock();

    self = lvar->mObjectValue.mValue; // self

    if(!check_type(self, gBytesTypeObject, info)) {
        vm_mutex_unlock();
        return FALSE;
    }

    buf = CLBYTES_DATA(self)->mChars;
    len = CLBYTES(self)->mLen;

    wstr = CALLOC(1, sizeof(wchar_t)*(len+1));

    if((int)mbstowcs(wstr, buf, len+1) < 0) {
        entry_exception_object(info, gExConvertingStringCodeClass, "failed to mbstowcs");
        FREE(wstr);
        vm_mutex_unlock();
        return FALSE;
    }
    new_obj = create_string_object(wstr, len, gStringTypeObject, info);

    (*stack_ptr)->mObjectValue.mValue = new_obj;  // push result
    (*stack_ptr)++;

    FREE(wstr);
    vm_mutex_unlock();

    return TRUE;
}
Пример #19
0
BOOL Bytes_getValue(MVALUE** stack_ptr, MVALUE* lvar, sVMInfo* info, CLObject vm_type, sCLClass* klass)
{
    CLObject self;
    CLObject new_obj;

    vm_mutex_lock();

    self = lvar->mObjectValue.mValue; // self

    if(!check_type(self, gBytesTypeObject, info)) {
        vm_mutex_unlock();
        return FALSE;
    }

    new_obj = create_bytes_object(CLBYTES_DATA(self)->mChars, CLBYTES(self)->mLen, gBytesTypeObject, info);

    (*stack_ptr)->mObjectValue.mValue = new_obj;  // push result
    (*stack_ptr)++;

    vm_mutex_unlock();

    return TRUE;
}
Пример #20
0
BOOL Thread_Thread(MVALUE** stack_ptr, MVALUE* lvar, sVMInfo* info, CLObject vm_type, sCLClass* klass)
{
    CLObject self;
    CLObject block;
    BOOL result_existance;
    struct sThreadFuncArg* arg;
    sVMInfo* new_info;
    MVALUE* lvar2;
    pthread_t thread_id;
    int real_param_num;

    vm_mutex_lock();

    result_existance = FALSE;

    self = lvar->mObjectValue.mValue;
    block = (lvar+1)->mObjectValue.mValue;

    /// make new stack to the sub thread on the main thread because of GC ///

    /// create new stack ///
    new_info = CALLOC(1, sizeof(sVMInfo));

    new_info->stack = CALLOC(1, sizeof(MVALUE)*CL_STACK_SIZE);
    new_info->stack_size = CL_STACK_SIZE;
    new_info->stack_ptr = new_info->stack;

    //real_param_num = 2;             // this param is Thread and Block
    lvar2 = new_info->stack;

    new_info->thread_obj = (info->stack_ptr-2)->mObjectValue.mValue;
    new_info->thread_block_obj = (info->stack_ptr-1)->mObjectValue.mValue;

    /// copy params to current local vars ///
    //memmove(lvar2 + CLBLOCK(block)->mNumParentVar, info->stack_ptr-real_param_num, sizeof(MVALUE)*real_param_num);

    /// copy caller local vars to current local vars ///
    memmove(lvar2, CLBLOCK(block)->mParentLocalVar, sizeof(MVALUE)*CLBLOCK(block)->mNumParentVar);

    new_info->stack_ptr += CLBLOCK(block)->mNumParentVar;
    //new_info->stack_ptr += CLBLOCK(block)->mNumParentVar + real_param_num;

/*
    if(CLBLOCK(block)->mNumLocals - real_param_num > 0) {
        new_info->stack_ptr += (CLBLOCK(block)->mNumLocals - real_param_num);     // forwarded stack pointer for local variable
    }
*/

    new_info->stack_ptr += CLBLOCK(block)->mNumLocals;

    push_vminfo(new_info);

    /// make arg for thread ///
    arg = CALLOC(1, sizeof(struct sThreadFuncArg));

    arg->mBlock = block;
    arg->mResultExistance = result_existance;
    arg->mNewVMInfo = MANAGED new_info;

    vm_mutex_unlock();

    if(pthread_create(&thread_id, NULL, thread_func, MANAGED arg) != 0) {
        pthread_detach(thread_id);
        entry_exception_object(info, gExceptionClass, "error pthread_create", info);
        return FALSE;
    }

    vm_mutex_lock();

    (*stack_ptr)->mObjectValue.mValue = self;
    (*stack_ptr)++;

    CLTHREAD(self)->mThread = thread_id;
    vm_mutex_unlock();

    return TRUE;
}
Пример #21
0
static void get_task(handle_details* details, hx711_task* task)
{
	vm_mutex_lock(&details->mutex);
	*task = details->task;
	vm_mutex_unlock(&details->mutex);
}
Пример #22
0
BOOL RegularFile_RegularFile(MVALUE** stack_ptr, MVALUE* lvar, sVMInfo* info, CLObject vm_type, sCLClass* klass)
{
    CLObject self;
    CLObject file_name;
    CLObject mode;
    CLObject ovalue1;
    int permission;
    char file_name_mbs[PATH_MAX];
    char mode_mbs[128];
    int oflag;
    char* p;
    
    int fd;

    vm_mutex_lock();

    self = lvar->mObjectValue.mValue;
    file_name = (lvar+1)->mObjectValue.mValue;                 // String
    mode = (lvar+2)->mObjectValue.mValue;                      // String
    ovalue1 = (lvar+3)->mObjectValue.mValue;
    permission = CLINT(ovalue1)->mValue;                       // int

    if((int)wcstombs(file_name_mbs, CLSTRING_DATA(file_name)->mChars, PATH_MAX) < 0) 
    {
        entry_exception_object(info, gExConvertingStringCodeClass, "error wcstombs on file_name");
        vm_mutex_unlock();
        return FALSE;
    }

    if((int)wcstombs(mode_mbs, CLSTRING_DATA(mode)->mChars, 128) < 0) 
    {
        entry_exception_object(info, gExConvertingStringCodeClass, "error wcstombs on mode");
        vm_mutex_unlock();
        return FALSE;
    }

    oflag = 0;

    p = mode_mbs;
    if(*p == 'r') {
        oflag = O_RDONLY;
    }
    else if(*p == 'w') {
        oflag = O_WRONLY|O_CREAT|O_TRUNC;
    }
    else if(*p == 'a') {
        oflag = O_WRONLY|O_CREAT|O_APPEND;
    }
    else {
        entry_exception_object(info, gExceptionClass, "ivalid file mode");
        vm_mutex_unlock();
        return FALSE;
    }
    p++;
    
    if(*p == '+') {
        p++;
        oflag |= O_RDWR;
    }

    if(*p != 0) {
        entry_exception_object(info, gExceptionClass, "ivalid file mode");
        vm_mutex_unlock();
        return FALSE;
    }

    fd = open(file_name_mbs, oflag, permission);

    if(fd < 0) {
        entry_exception_object(info, gExIOClass, "can't open file");
        vm_mutex_unlock();
        return FALSE;
    }

    CLFILE(self)->mFD = fd;

    (*stack_ptr)->mObjectValue.mValue = self;
    (*stack_ptr)++;

    vm_mutex_unlock();

    return TRUE;
}