예제 #1
0
void PtrQueueSet::deallocate_buffer(void** buf) {
  assert(_sz > 0, "Didn't set a buffer size.");
  MutexLockerEx x(_fl_owner->_fl_lock, Mutex::_no_safepoint_check_flag);
  BufferNode *node = BufferNode::make_node_from_buffer(buf);
  node->set_next(_fl_owner->_buf_free_list);
  _fl_owner->_buf_free_list = node;
  _fl_owner->_buf_free_list_sz++;
}
예제 #2
0
int PtrQueueSet::completed_buffers_list_length() {
  int n = 0;
  BufferNode* cbn = _completed_buffers_head;
  while (cbn != NULL) {
    n++;
    cbn = cbn->next();
  }
  return n;
}
예제 #3
0
파일: Array.cpp 프로젝트: umar456/arrayfire
Node_ptr Array<T>::getNode() const {
    if (node->isBuffer()) {
        BufferNode<T> *bufNode = reinterpret_cast<BufferNode<T> *>(node.get());
        unsigned bytes         = this->getDataDims().elements() * sizeof(T);
        bufNode->setData(data, bytes, getOffset(), dims().get(),
                         strides().get(), isLinear());
    }
    return node;
}
예제 #4
0
파일: Array.cpp 프로젝트: FloopCZ/arrayfire
 Node_ptr Array<T>::getNode()
 {
     if (node->isBuffer()) {
         unsigned bytes = this->getDataDims().elements() * sizeof(T);
         BufferNode<T> *bufNode = reinterpret_cast<BufferNode<T> *>(node.get());
         Param<T> param = *this;
         bufNode->setData(param, data, bytes, isLinear());
     }
     return node;
 }
예제 #5
0
void DirtyCardQueueSet::apply_closure_to_all_completed_buffers() {
  BufferNode* nd = _completed_buffers_head;
  while (nd != NULL) {
    bool b =
      DirtyCardQueue::apply_closure_to_buffer(_closure,
                                              BufferNode::make_buffer_from_node(nd),
                                              0, _sz, false);
    guarantee(b, "Should not stop early.");
    nd = nd->next();
  }
}
예제 #6
0
void DirtyCardQueueSet::par_apply_closure_to_all_completed_buffers(CardTableEntryClosure* cl) {
  BufferNode* nd = _cur_par_buffer_node;
  while (nd != NULL) {
    BufferNode* next = nd->next();
    void* actual = Atomic::cmpxchg_ptr(next, &_cur_par_buffer_node, nd);
    if (actual == nd) {
      bool b = apply_closure_to_buffer(cl, nd, false);
      guarantee(b, "Should not stop early.");
      nd = next;
    } else {
      nd = static_cast<BufferNode*>(actual);
    }
  }
}
예제 #7
0
// Deallocates any completed log buffers
void DirtyCardQueueSet::clear() {
  BufferNode* buffers_to_delete = NULL;
  {
    MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);
    while (_completed_buffers_head != NULL) {
      BufferNode* nd = _completed_buffers_head;
      _completed_buffers_head = nd->next();
      nd->set_next(buffers_to_delete);
      buffers_to_delete = nd;
    }
    _n_completed_buffers = 0;
    _completed_buffers_tail = NULL;
    DEBUG_ONLY(assert_completed_buffer_list_len_correct_locked());
  }
  while (buffers_to_delete != NULL) {
    BufferNode* nd = buffers_to_delete;
    buffers_to_delete = nd->next();
    deallocate_buffer(nd);
  }

}
예제 #8
0
BufferNode*
DirtyCardQueueSet::get_completed_buffer(int stop_at) {
  BufferNode* nd = NULL;
  MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);

  if ((int)_n_completed_buffers <= stop_at) {
    _process_completed = false;
    return NULL;
  }

  if (_completed_buffers_head != NULL) {
    nd = _completed_buffers_head;
    _completed_buffers_head = nd->next();
    if (_completed_buffers_head == NULL)
      _completed_buffers_tail = NULL;
    _n_completed_buffers--;
    assert(_n_completed_buffers >= 0, "Invariant");
  }
  debug_only(assert_completed_buffer_list_len_correct_locked());
  return nd;
}
예제 #9
0
void PtrQueueSet::enqueue_complete_buffer(void** buf, size_t index) {
  MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);
  BufferNode* cbn = BufferNode::new_from_buffer(buf);
  cbn->set_index(index);
  if (_completed_buffers_tail == NULL) {
    assert(_completed_buffers_head == NULL, "Well-formedness");
    _completed_buffers_head = cbn;
    _completed_buffers_tail = cbn;
  } else {
    _completed_buffers_tail->set_next(cbn);
    _completed_buffers_tail = cbn;
  }
  _n_completed_buffers++;

  if (!_process_completed && _process_completed_threshold >= 0 &&
      _n_completed_buffers >= _process_completed_threshold) {
    _process_completed = true;
    if (_notify_when_complete)
      _cbl_mon->notify();
  }
  debug_only(assert_completed_buffer_list_len_correct_locked());
}
예제 #10
0
void TsFrameBufferBase::insertNewNode(TsFrameBase *packet)
{
	if(sync_status == buffer_cannot_be_synced)
	{
		insertFailed(packet);
		return;
	}
	
	if(sync_status == buffer_syncing_waiting_for_pts)
	{
		if(packet->PTS < sync_PTS)
		{
			insertFailed(packet);
			return;
		}
		else if(packet->PTS == sync_PTS)
		{
			sync_status = buffer_syncing_pts_received;
		}
		else
		{
			printDebugMessage("greater than the expected PTS " + buffer_id, STATUS);
			sync_status = buffer_syncing_pts_received;
		}
	}

	unsigned int first_PTS = getFirstPTS();
	unsigned int received_PTS = packet->PTS;
	unsigned int expected_PTS = last->packet->PTS + pts_per_frame;
	int frame_difference = ((int)received_PTS - (int)expected_PTS) / (int)pts_per_frame;
	if(frame_difference == 0)
	{
		packet->PTS = expected_PTS;
		received_PTS = packet->PTS;
	}

	if(received_PTS > expected_PTS)
	{
		printDebugMessage("buffer " + buffer_id + " missed " + to_str(frame_difference) + " frames in insert", WARNING);
		insertNullFrame(frame_difference, expected_PTS);
	}

	writeDebugMessage(buffer_id + "_insert.txt", to_str(received_PTS) + "\t" + now_str() + " " + getStatusStr() + " " + to_str(getFillRatio()) + "%" + " " + to_str(current_size) + "/" + to_str(total_size), STATUS);

	if(received_PTS >= expected_PTS)
	{
		insertTail(packet);
		packet->setArrivalTime();
	}
	else
	{
		if(received_PTS < first_PTS)
		{
			/*if(frame_difference + FRAME_NUMBER_FOR_LOOP_DETECTION < 0)
			{
				loop_on = true;
				printDebugMessage("buffer " + buffer_id + " loop at " + now_str(), WARNING);
				insertTail(packet);
				packet->setArrivalTime();
			}
			else
			{*/
				printDebugMessage("buffer " + buffer_id + " very early PTS", WARNING);
				insertFailed(packet);
			//}
		}
		else
		{
			lock();
			printDebugMessage("buffer " + buffer_id + " early PTS", WARNING);
			BufferNode<TsFrameBase> *current;
			BufferNode<TsFrameBase> *prev = first;
			for(current = first; current != NULL; current = current->next)
			{
				if(current->packet->PTS < packet->PTS)
				{
					prev = current;
				}
				else if(current->packet->PTS == packet->PTS)
				{
					printDebugMessage("buffer " + buffer_id + " existing PTS", WARNING);
					insertFailed(packet);
					return;
				}
				else
				{
					break;
				}
			}
			prev->insertAfter(new BufferNode<TsFrameBase>(packet));
			insertSuccessful(packet);
			packet->setArrivalTime();
		}
	}
}