Exemple #1
0
Range<AsyncIO::Op**> AsyncIO::pollCompleted() {
  CHECK(ctx_);
  CHECK_NE(pollFd_, -1) << "pollCompleted() only allowed on pollable object";
  uint64_t numEvents;
  // This sets the eventFd counter to 0, see
  // http://www.kernel.org/doc/man-pages/online/pages/man2/eventfd.2.html
  ssize_t rc;
  do {
    rc = ::read(pollFd_, &numEvents, 8);
  } while (rc == -1 && errno == EINTR);
  if (UNLIKELY(rc == -1 && errno == EAGAIN)) {
    return Range<Op**>();  // nothing completed
  }
  checkUnixError(rc, "AsyncIO: read from event fd failed");
  DCHECK_EQ(rc, 8);

  DCHECK_GT(numEvents, 0);
  DCHECK_LE(numEvents, pending_);

  // Don't reap more than numEvents, as we've just reset the counter to 0.
  return doWait(numEvents, numEvents);
}
void ReshapeLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom,
    const vector<Blob<Dtype>*>& top) {
  CHECK_NE(top[0], bottom[0]) << this->type() << " Layer does not "
      "allow in-place computation.";
  inferred_axis_ = -1;
  copy_axes_.clear();
  const BlobShape& top_blob_shape = this->layer_param_.reshape_param().shape();
  const int top_num_axes = top_blob_shape.dim_size();
  constant_count_ = 1;
  for (int i = 0; i < top_num_axes; ++i) {
    const int top_dim = top_blob_shape.dim(i);
    if (top_dim == 0) {
      copy_axes_.push_back(i);
    } else if (top_dim == -1) {
      CHECK_EQ(inferred_axis_, -1) << "new shape contains multiple "
          << "-1 dims; at most a single (1) value of -1 may be specified";
      inferred_axis_ = i;
    } else {
      constant_count_ *= top_dim;
    }
  }
}
bool ReadOrderlyShutdown(int fd) {
    char buf[16];

    // Only call this function if you're sure that the peer does
    // orderly/graceful shutdown of the socket, closing the socket so that
    // adb_read() will return 0. If the peer keeps the socket open, adb_read()
    // will never return.
    int result = adb_read(fd, buf, sizeof(buf));
    if (result == -1) {
        // If errno is EAGAIN, that means this function was called on a
        // nonblocking socket and it would have blocked (which would be bad
        // because we'd probably block the main thread where nonblocking IO is
        // done). Don't do that. If you have a nonblocking socket, use the
        // fdevent APIs to get called on FDE_READ, and then call this function
        // if you really need to, but it shouldn't be needed for server sockets.
        CHECK_NE(errno, EAGAIN);

        // Note that on Windows, orderly shutdown sometimes causes
        // recv() == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET. That
        // can be ignored.
        return false;
    } else if (result == 0) {
        // Peer has performed an orderly/graceful shutdown.
        return true;
    } else {
        // Unexpectedly received data. This is essentially a protocol error
        // because you should not call this function unless you expect no more
        // data. We don't repeatedly call adb_read() until we get zero because
        // we don't know how long that would take, but we do know that the
        // caller wants to close the socket soon.
        VLOG(RWX) << "ReadOrderlyShutdown(" << fd << ") unexpectedly read "
                  << dump_hex(buf, result);
        // Shutdown the socket to prevent the caller from reading or writing to
        // it which doesn't make sense if we just read and discarded some data.
        adb_shutdown(fd);
        errno = EINVAL;
        return false;
    }
}
Exemple #4
0
int main() {
  LOG(INFO) << "Dump log test";

  // CHECK Operation
  CHECK_NE(1, 2) << ": The world must be ending!";
  // Check if it is euqual
  CHECK_EQ(std::string("abc")[1], 'b');

  int x = 2;
  int y = 1;
  LOG_IF(ERROR, x > y) << "2 > 1. This should be also OK";

  // Test dump log in different thread
  int err = pthread_create(&newTid, NULL, ThreadRunnable, NULL);
  if (err != 0) {
    LOG(FATAL) << "Unable to create a thread";
    return 1;
  }
  sleep(1);
  TestStopWatch();
  return 0;
}
Exemple #5
0
void nub_loop_dispose(nub_loop_t* loop) {
  ASSERT(0 == uv_loop_alive(&loop->uvloop));
  ASSERT(1 == fuq_empty(&loop->blocking_queue_));
  ASSERT(0 == loop->ref_);
  ASSERT(NULL != loop->work_ping_);
  ASSERT(0 == uv_has_ref((uv_handle_t*) loop->work_ping_));
  ASSERT(1 == fuq_empty(&loop->thread_dispose_queue_));

  uv_close((uv_handle_t*) loop->work_ping_, nub__free_handle_cb);
  uv_close((uv_handle_t*) &loop->queue_processor_, NULL);
  ASSERT(0 == uv_is_active((uv_handle_t*) loop->work_ping_));

  fuq_dispose(&loop->thread_dispose_queue_);
  uv_mutex_destroy(&loop->thread_dispose_lock_);
  uv_sem_destroy(&loop->loop_lock_sem_);
  fuq_dispose(&loop->blocking_queue_);
  uv_mutex_destroy(&loop->queue_processor_lock_);
  fuq_dispose(&loop->work_queue_);
  uv_mutex_destroy(&loop->work_lock_);

  CHECK_EQ(0, uv_run(&loop->uvloop, UV_RUN_NOWAIT));
  CHECK_NE(UV_EBUSY, uv_loop_close(&loop->uvloop));
}
void ResizeImagePeriodic(const cv::Mat& src_img,
    const int h_off, const int w_off, cv::Mat* dst_img) {
  const int h_src = src_img.rows;
  const int w_src = src_img.cols;
  const int h_dst = dst_img->rows;
  const int w_dst = dst_img->cols;
  const int num_channels = src_img.channels();
  CHECK_EQ(num_channels, dst_img->channels()) <<
    "number of channels of source and destimation images have to be equal";
  CHECK_NE(dst_img, &src_img) << "doesn't support in place calculation";
  const int cvwidth_src = w_src * num_channels;
  for (int h = 0; h < h_dst; ++h) {
    uchar* ptr_dst = dst_img->ptr<uchar>(h);
    const uchar* ptr_src = src_img.ptr<uchar>(positive_mod(h-h_off, h_src));
    int index_dst = 0;
    int index_src = positive_mod(-num_channels*w_off, cvwidth_src);
    for (int w = 0; w < w_dst; ++w) {
      for (int c = 0; c < num_channels; ++c) {
        ptr_dst[index_dst++] = ptr_src[positive_mod(index_src++, cvwidth_src)];
      }
    }
  }
}
HTTP2PriorityQueue::Handle
HTTP2PriorityQueue::updatePriority(HTTP2PriorityQueue::Handle handle,
                                   http2::PriorityUpdate pri) {
  Node* node = handle;
  pendingWeightChange_ = true;
  node->updateWeight(pri.weight);
  CHECK_NE(pri.streamDependency, node->getID()) <<
    "Tried to create a loop in the tree";;
  if (pri.streamDependency == node->parentID() && !pri.exclusive) {
    // no move
    return handle;
  }

  Node* newParent = find(pri.streamDependency);
  if (!newParent) {
    newParent = &root_;
  }

  if (newParent->isDescendantOf(node)) {
    newParent = newParent->reparent(node->getParent(), false);
  }
  return node->reparent(newParent, pri.exclusive);
}
// Add a new node as a child of this node
HTTP2PriorityQueue::Handle
HTTP2PriorityQueue::Node::emplaceNode(
  unique_ptr<HTTP2PriorityQueue::Node> node, bool exclusive) {
  CHECK(!node->isEnqueued());
  list<unique_ptr<Node>> children;
  CHECK_NE(id_, node->id_) << "Tried to create a loop in the tree";
  if (exclusive) {
    // this->children become new node's children
    std::swap(children, children_);
    totalChildWeight_ = 0;
    bool wasInEgressTree = inEgressTree();
    totalEnqueuedWeight_ = 0;
#ifndef NDEBUG
    totalEnqueuedWeightCheck_ = 0;
#endif
    if (wasInEgressTree && !inEgressTree()) {
      propagatePendingEgressClear(this);
    }
  }
  auto res = addChild(std::move(node));
  res->addChildren(std::move(children));
  return res;
}
Exemple #9
0
LDAStats::LDAStats() {
  // Topic model parameters.
  Context& context = Context::get_instance();
  K_ = context.get_int32("num_topics");
  V_ = context.get_int32("num_vocabs");
  CHECK_NE(-1, V_);
  beta_ = context.get_double("beta");
  beta_sum_ = beta_ * V_;
  alpha_ = context.get_double("alpha");
  alpha_sum_ = K_ * alpha_;

  loggamma_alpha_offset_.resize(kNumLogGammaAlpha_);
  loggamma_alpha_sum_offset_.resize(kNumLogGammaAlphaSum_);
  loggamma_beta_offset_.resize(kNumLogGammaBeta_);
  for (int i = 0; i < kNumLogGammaAlpha_; ++i) {
    loggamma_alpha_offset_[i] = LogGamma(i + alpha_);
  }
  for (int i = 0; i < kNumLogGammaAlphaSum_; ++i) {
    loggamma_alpha_sum_offset_[i] = LogGamma(i + alpha_sum_);
  }
  for (int i = 0; i < kNumLogGammaBeta_; ++i) {
    loggamma_beta_offset_[i] = LogGamma(i + beta_);
  }

  // Precompute LLH parameters
  log_doc_normalizer_ = LogGamma(alpha_sum_) - K_ * LogGamma(alpha_);
  log_topic_normalizer_ = K_ * (LogGamma(beta_sum_) - V_ * LogGamma(beta_));

  // PS tables.
  int32_t summary_table_id = context.get_int32("summary_table_id");
  int32_t word_topic_table_id = context.get_int32("word_topic_table_id");
  int32_t llh_table_id = context.get_int32("llh_table_id");
  summary_table_ = petuum::PSTableGroup::GetTableOrDie<int>(summary_table_id);
  word_topic_table_ = petuum::PSTableGroup::GetTableOrDie<int>(
      word_topic_table_id);
  llh_table_ = petuum::PSTableGroup::GetTableOrDie<double>(llh_table_id);
}
Exemple #10
0
void TopicCount::UpdateCount(int old_topic, int new_topic, int doc_id, std::unique_ptr<std::mutex[]> &mutex_pool_) {
  std::lock_guard<std::mutex>lock(mutex_pool_[doc_id]);
  if (old_topic == new_topic) return;
  // Find old and new index
  int old_index = -1;
  int new_index = -1;
  for (size_t i = 0; i < item_.size(); ++i) {
    if (item_[i].top_ == old_topic) old_index = i;
    if (item_[i].top_ == new_topic) new_index = i;
    if (old_index != -1 and new_index != -1) break; // early stop
  }
  CHECK_NE(old_index, -1);
  // Decrement old index while maintaining new index
  Pair temp(item_[old_index].top_, item_[old_index].cnt_ - 1);
  int last_index = item_.size() - 1;
  if (item_[old_index].cnt_ == 1) {
    if (new_index == last_index) new_index = old_index; // maintain
    std::swap(item_[old_index], item_.back()); // swap with last/self
    item_.pop_back();
  } // end of "need to shrink"
  else if (old_index < last_index and temp.cnt_ < item_[old_index+1].cnt_) {
    auto it = std::lower_bound(item_.begin() + old_index + 1,
                               item_.end(),
                               temp,
                               [](Pair a, Pair b){ return a.cnt_ > b.cnt_; })-1;
    if (item_.begin() + new_index == it) new_index = old_index; // maintain
    item_[old_index] = *it;
    *it = temp;
  } // end of "no need to shrink but need to rearrange"
  else {
    --item_[old_index].cnt_;
  } // end of "no need to rearrange"    
  // Increment new
  if (new_index != -1) IncrementExisting(new_index);
  else item_.emplace_back(new_topic, 1);
}
Exemple #11
0
const Distribution1D *SpatialLightDistribution::Lookup(const Point3f &p) const {
    ProfilePhase _(Prof::LightDistribLookup);
    ++nLookups;

    // First, compute integer voxel coordinates for the given point |p|
    // with respect to the overall voxel grid.
    Vector3f offset = scene.WorldBound().Offset(p);  // offset in [0,1].
    Point3i pi;
    for (int i = 0; i < 3; ++i)
        // The clamp should almost never be necessary, but is there to be
        // robust to computed intersection points being slightly outside
        // the scene bounds due to floating-point roundoff error.
        pi[i] = Clamp(int(offset[i] * nVoxels[i]), 0, nVoxels[i] - 1);

    // Pack the 3D integer voxel coordinates into a single 64-bit value.
    uint64_t packedPos = (uint64_t(pi[0]) << 40) | (uint64_t(pi[1]) << 20) | pi[2];
    CHECK_NE(packedPos, invalidPackedPos);

    // Compute a hash value from the packed voxel coordinates.  We could
    // just take packedPos mod the hash table size, but since packedPos
    // isn't necessarily well distributed on its own, it's worthwhile to do
    // a little work to make sure that its bits values are individually
    // fairly random. For details of and motivation for the following, see:
    // http://zimbry.blogspot.ch/2011/09/better-bit-mixing-improving-on.html
    uint64_t hash = packedPos;
    hash ^= (hash >> 31);
    hash *= 0x7fb5d329728ea185;
    hash ^= (hash >> 27);
    hash *= 0x81dadef4bc2dd44d;
    hash ^= (hash >> 33);
    hash %= hashTableSize;
    CHECK_GE(hash, 0);

    // Now, see if the hash table already has an entry for the voxel. We'll
    // use quadratic probing when the hash table entry is already used for
    // another value; step stores the square root of the probe step.
    int step = 1;
    int nProbes = 0;
    while (true) {
        ++nProbes;
        HashEntry &entry = hashTable[hash];
        // Does the hash table entry at offset |hash| match the current point?
        uint64_t entryPackedPos = entry.packedPos.load(std::memory_order_acquire);
        if (entryPackedPos == packedPos) {
            // Yes! Most of the time, there should already by a light
            // sampling distribution available.
            Distribution1D *dist = entry.distribution.load(std::memory_order_acquire);
            if (dist == nullptr) {
                // Rarely, another thread will have already done a lookup
                // at this point, found that there isn't a sampling
                // distribution, and will already be computing the
                // distribution for the point.  In this case, we spin until
                // the sampling distribution is ready.  We assume that this
                // is a rare case, so don't do anything more sophisticated
                // than spinning.
                ProfilePhase _(Prof::LightDistribSpinWait);
                while ((dist = entry.distribution.load(std::memory_order_acquire)) ==
                       nullptr)
                    // spin :-(. If we were fancy, we'd have any threads
                    // that hit this instead help out with computing the
                    // distribution for the voxel...
                    ;
            }
            // We have a valid sampling distribution.
            ReportValue(nProbesPerLookup, nProbes);
            return dist;
        } else if (entryPackedPos != invalidPackedPos) {
            // The hash table entry we're checking has already been
            // allocated for another voxel. Advance to the next entry with
            // quadratic probing.
            hash += step * step;
            if (hash >= hashTableSize)
                hash %= hashTableSize;
            ++step;
        } else {
            // We have found an invalid entry. (Though this may have
            // changed since the load into entryPackedPos above.)  Use an
            // atomic compare/exchange to try to claim this entry for the
            // current position.
            uint64_t invalid = invalidPackedPos;
            if (entry.packedPos.compare_exchange_weak(invalid, packedPos)) {
                // Success; we've claimed this position for this voxel's
                // distribution. Now compute the sampling distribution and
                // add it to the hash table. As long as packedPos has been
                // set but the entry's distribution pointer is nullptr, any
                // other threads looking up the distribution for this voxel
                // will spin wait until the distribution pointer is
                // written.
                Distribution1D *dist = ComputeDistribution(pi);
                entry.distribution.store(dist, std::memory_order_release);
                ReportValue(nProbesPerLookup, nProbes);
                return dist;
            }
        }
    }
}
int64_t AudioPlayer::getRealTimeUsLocked() const {
    CHECK(mStarted);
    CHECK_NE(mSampleRate, 0);
    return -mLatencyUs + (mNumFramesPlayed * 1000000) / mSampleRate;
}
Exemple #13
0
void RemoteFontFaceSource::FontLoadHistograms::recordLoadTimeHistogram(
    const FontResource* font,
    int duration,
    bool isInterventionTriggered) {
  CHECK_NE(FromUnknown, m_dataSource);

  if (font->errorOccurred()) {
    DEFINE_STATIC_LOCAL(CustomCountHistogram, loadErrorHistogram,
                        ("WebFont.DownloadTime.LoadError", 0, 10000, 50));
    DEFINE_STATIC_LOCAL(
        CustomCountHistogram, missedCacheLoadErrorHistogram,
        ("WebFont.MissedCache.DownloadTime.LoadError", 0, 10000, 50));
    loadErrorHistogram.count(duration);
    if (m_dataSource == FromNetwork)
      missedCacheLoadErrorHistogram.count(duration);
    return;
  }

  unsigned size = font->encodedSize();
  if (size < 10 * 1024) {
    DEFINE_STATIC_LOCAL(CustomCountHistogram, under10kHistogram,
                        ("WebFont.DownloadTime.0.Under10KB", 0, 10000, 50));
    DEFINE_STATIC_LOCAL(
        CustomCountHistogram, missedCacheUnder10kHistogram,
        ("WebFont.MissedCache.DownloadTime.0.Under10KB", 0, 10000, 50));
    under10kHistogram.count(duration);
    if (m_dataSource == FromNetwork)
      missedCacheUnder10kHistogram.count(duration);
    return;
  }
  if (size < 50 * 1024) {
    DEFINE_STATIC_LOCAL(CustomCountHistogram, under50kHistogram,
                        ("WebFont.DownloadTime.1.10KBTo50KB", 0, 10000, 50));
    DEFINE_STATIC_LOCAL(
        CustomCountHistogram, missedCacheUnder50kHistogram,
        ("WebFont.MissedCache.DownloadTime.1.10KBTo50KB", 0, 10000, 50));
    // Breakdowns metrics to understand WebFonts intervention.
    // Now we only cover this 10KBto50KB range because 70% of requests are
    // covered in this range, and having metrics for all size cases cost.
    DEFINE_STATIC_LOCAL(CustomCountHistogram,
                        missedCacheAndInterventionTriggeredUnder50kHistogram,
                        ("WebFont.MissedCacheAndInterventionTriggered."
                         "DownloadTime.1.10KBTo50KB",
                         0, 10000, 50));
    DEFINE_STATIC_LOCAL(CustomCountHistogram,
                        missedCacheAndInterventionNotTriggeredUnder50kHistogram,
                        ("WebFont.MissedCacheAndInterventionNotTriggered."
                         "DownloadTime.1.10KBTo50KB",
                         0, 10000, 50));
    under50kHistogram.count(duration);
    if (m_dataSource == FromNetwork) {
      missedCacheUnder50kHistogram.count(duration);
      if (isInterventionTriggered)
        missedCacheAndInterventionTriggeredUnder50kHistogram.count(duration);
      else
        missedCacheAndInterventionNotTriggeredUnder50kHistogram.count(duration);
    }
    return;
  }
  if (size < 100 * 1024) {
    DEFINE_STATIC_LOCAL(CustomCountHistogram, under100kHistogram,
                        ("WebFont.DownloadTime.2.50KBTo100KB", 0, 10000, 50));
    DEFINE_STATIC_LOCAL(
        CustomCountHistogram, missedCacheUnder100kHistogram,
        ("WebFont.MissedCache.DownloadTime.2.50KBTo100KB", 0, 10000, 50));
    under100kHistogram.count(duration);
    if (m_dataSource == FromNetwork)
      missedCacheUnder100kHistogram.count(duration);
    return;
  }
  if (size < 1024 * 1024) {
    DEFINE_STATIC_LOCAL(CustomCountHistogram, under1mbHistogram,
                        ("WebFont.DownloadTime.3.100KBTo1MB", 0, 10000, 50));
    DEFINE_STATIC_LOCAL(
        CustomCountHistogram, missedCacheUnder1mbHistogram,
        ("WebFont.MissedCache.DownloadTime.3.100KBTo1MB", 0, 10000, 50));
    under1mbHistogram.count(duration);
    if (m_dataSource == FromNetwork)
      missedCacheUnder1mbHistogram.count(duration);
    return;
  }
  DEFINE_STATIC_LOCAL(CustomCountHistogram, over1mbHistogram,
                      ("WebFont.DownloadTime.4.Over1MB", 0, 10000, 50));
  DEFINE_STATIC_LOCAL(
      CustomCountHistogram, missedCacheOver1mbHistogram,
      ("WebFont.MissedCache.DownloadTime.4.Over1MB", 0, 10000, 50));
  over1mbHistogram.count(duration);
  if (m_dataSource == FromNetwork)
    missedCacheOver1mbHistogram.count(duration);
}
Exemple #14
0
int main(int argc, char *argv[])
{
  void *lowest_segments[2] = { NULL, NULL };
  Elf32_Ehdr hdr;
  Elf32_Phdr *phdr;
  FILE *fi;
  maps_range maps[16];
  int map_cnt;
  int i, ret, envc, sfp;
  long *stack_frame;
  struct stat st;
  char buf[64];
  long lret;

  if (argc < 2) {
    fprintf(stderr, "usage: %s <program> [args]\n", argv[0]);
    return 1;
  }

  g_argv = argv;

  lret = g_personality(-1);
  if (g_syscall_error(lret) != -1) {
    lret |= 0x0240000; // ADDR_COMPAT_LAYOUT | ADDR_NO_RANDOMIZE
    g_personality(lret);
  }

  fi = fopen("/proc/self/maps", "r");
  CHECK_NE(fi, NULL, "fopen maps");

  for (i = 0; i < ARRAY_SIZE(maps); i++) {
    ret = fscanf(fi, "%lx-%lx %*s %*s %*s %*s %*s\n", &maps[i].start, &maps[i].end);
    if (ret <= 0)
      break;
    CHECK_EQ(ret, 2, "maps parse error");
  }
  fclose(fi);
  map_cnt = i;
  CHECK_NE(map_cnt, 0, "no maps");
  CHECK_NE(map_cnt, ARRAY_SIZE(maps), "too many maps");

  fi = fopen(argv[1], "rb");
  if (fi == NULL)
    FAIL_PERROR("fopen");

  if (fread(&hdr, 1, sizeof(hdr), fi) != sizeof(hdr))
    FAIL_PERROR("too small or");

  if (memcmp(hdr.e_ident, ELFMAG "\x01\x01", SELFMAG + 2) != 0) {
    fprintf(stderr, "not 32bit LE ELF?\n");
    return 1;
  }

  HDR_CHECK_EQ(e_type, ET_EXEC, "not executable");
  HDR_CHECK_EQ(e_machine, EM_ARM, "not ARM");
  HDR_CHECK_EQ(e_phentsize, sizeof(Elf32_Phdr), "bad PH entry size");
  HDR_CHECK_NE(e_phnum, 0, "no PH entries");

  phdr = malloc(hdr.e_phnum * hdr.e_phentsize);
  CHECK_NE(phdr, NULL, "OOM");

  if (fread(phdr, hdr.e_phentsize, hdr.e_phnum, fi) != hdr.e_phnum)
    FAIL_PERROR("too small or");

  for (i = 0; i < hdr.e_phnum; i++) {
    Elf32_Addr end_addr = phdr[i].p_vaddr + phdr[i].p_memsz;
    Elf32_Addr align;
    void *ptr, *map_ptr;

    if (phdr[i].p_type == PT_NOTE)
      continue;
    if (phdr[i].p_type != PT_LOAD) {
      fprintf(stderr, "skipping section %d\n", phdr[i].p_type);
      continue;
    }

    ret = is_range_used(maps, map_cnt, phdr[i].p_vaddr, end_addr);
    if (ret) {
      fprintf(stderr, "segment %d (%08x-%08x) hits %08lx-%08lx in maps\n",
        i, phdr[i].p_vaddr, end_addr, maps[ret - 1].start, maps[ret - 1].end);
      return 1;
    }

    log("load %d %08x-%08x from %08x\n", phdr[i].p_type,
      phdr[i].p_vaddr, end_addr, phdr[i].p_offset);

    align = phdr[i].p_vaddr & 0xfff;
    map_ptr = (void *)(phdr[i].p_vaddr - align);
    ptr = mmap(map_ptr, phdr[i].p_memsz + align, PROT_READ|PROT_WRITE|PROT_EXEC,
      MAP_FIXED|MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
    if (ptr == MAP_FAILED || ptr != map_ptr)
      FAIL_PERROR("mmap");

    if (phdr[i].p_filesz > 0) {
      if (fseek(fi, phdr[i].p_offset, SEEK_SET) != 0)
        FAIL_PERROR("fseek");
      if (fread((char *)ptr + align, 1, phdr[i].p_filesz, fi) != phdr[i].p_filesz)
        FAIL_PERROR("too small or");

      if (phdr[i].p_flags & PF_X)
        do_patches((char *)ptr + align, phdr[i].p_filesz);
    }

    if (lowest_segments[0] == NULL || map_ptr < lowest_segments[0])
      lowest_segments[0] = map_ptr;
  }

  // build self bin path
  snprintf(buf, sizeof(buf), "/proc/self/fd/%d", fileno(fi));
  if (lstat(buf, &st) != 0)
    FAIL_PERROR("lstat bin_path");
  bin_path = malloc(st.st_size + 1);
  CHECK_NE(bin_path, NULL, "bin_path");
  ret = readlink(buf, bin_path, st.st_size);
  if (ret < 0)
    FAIL_PERROR("readlink");
  bin_path[ret] = 0;

  fclose(fi);

  emu_init(lowest_segments, 0);

  // generate stack frame: argc, argv[], NULL, env[], NULL
  for (envc = 0; environ[envc] != NULL; envc++)
    ;

  stack_frame = calloc(argc + envc + 3, sizeof(stack_frame[0]));
  if (stack_frame == NULL) {
    fprintf(stderr, "stack_frame OOM\n");
    return 1;
  }

  // update the environment
  setenv("_", bin_path, 1);

  sfp = 0;
  stack_frame[sfp++] = argc - 1;
  for (i = 1; i < argc; i++)
    stack_frame[sfp++] = (long)argv[i];
  stack_frame[sfp++] = 0;
  for (i = 0; i < envc; i++)
    stack_frame[sfp++] = (long)environ[i];
  stack_frame[sfp++] = 0;

  log("entering %08x, %d stack entries\n", hdr.e_entry, sfp);
  do_entry(hdr.e_entry, stack_frame, sfp, NULL);

  fprintf(stderr, "do_entry failed!\n");
  return 1;
}
Exemple #15
0
AsyncIOOp::~AsyncIOOp() {
  CHECK_NE(state_, State::PENDING);
}
void zoo(RetBase* obj) {
  Base2* ret = obj->foo();
  CHECK_NE(0, ret);
  CHECK_EQ(2, ret->b);
}
Exemple #17
0
void AbsValLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
  NeuronLayer<Dtype>::LayerSetUp(bottom, top);
  CHECK_NE(top[0], bottom[0]) << this->type() << " Layer does not "
    "allow in-place computation.";
}
Exemple #18
0
void RTSPSource::onMessageReceived(const sp<AMessage> &msg) {
    if (msg->what() == kWhatDisconnect) {
        uint32_t replyID;
        CHECK(msg->senderAwaitsResponse(&replyID));

        mDisconnectReplyID = replyID;
        finishDisconnectIfPossible();
        return;
    } else if (msg->what() == kWhatPerformSeek) {
        int32_t generation;
        CHECK(msg->findInt32("generation", &generation));

        if (generation != mSeekGeneration) {
            // obsolete.
            return;
        }

        int64_t seekTimeUs;
        CHECK(msg->findInt64("timeUs", &seekTimeUs));

        performSeek(seekTimeUs);
        return;
    } else if (msg->what() == kWhatPerformPlay) {
        int64_t playTimeUs;
        CHECK(msg->findInt64("timeUs", &playTimeUs));
        performPlay(playTimeUs);
        return;
    } else if (msg->what() == kWhatPerformPause) {
        performPause();
        return;
    } else if (msg->what() == kWhatPerformResume) {
        performResume();
        return;
    } else if (msg->what() == kWhatPerformSuspend) {
        performSuspend();
        return;
    }

    CHECK_EQ(msg->what(), (uint32_t)kWhatNotify);

    int32_t what;
    int32_t isSeekable = 0;
    CHECK(msg->findInt32("what", &what));

    switch (what) {
        case RtspConnectionHandler::kWhatConnected:
            CHECK(msg->findInt32("isSeekable", &isSeekable));
            onConnected((isSeekable ? true:false));
            break;

        case RtspConnectionHandler::kWhatDisconnected:
            onDisconnected(msg);
            break;

        case RtspConnectionHandler::kWhatSeekDone:
        {
            mState = PLAYING;
            // Even if we have reset mLatestPausedUnit in performSeek(),
            // it's still possible that kWhatPausedDone event may arrive
            // because of previous performPause() command.
            for (size_t i = 0; i < mTracks.size(); ++i) {
                TrackInfo *info = &mTracks.editItemAt(i);
                info->mLatestPausedUnit = 0;
            }
            mLatestPausedUnit = 0;
            break;
        }

        case RtspConnectionHandler::kWhatPausedDone:
        {
            for (size_t i = 0; i < mTracks.size(); ++i) {
                TrackInfo *info = &mTracks.editItemAt(i);
                info->mLatestPausedUnit = info->mLatestReceivedUnit;
            }

            // The timestamp after a 'Pause' is done is the earliest
            // timestamp among all of the latest received units.
            TrackInfo *info = &mTracks.editItemAt(0);
            mLatestPausedUnit = info->mLatestReceivedUnit;
            for (size_t i = 1; i < mTracks.size(); ++i) {
                TrackInfo *info = &mTracks.editItemAt(i);
                if (mLatestPausedUnit > info->mLatestReceivedUnit) {
                    mLatestPausedUnit = info->mLatestReceivedUnit;
                }
            }
            break;
        }

        case RtspConnectionHandler::kWhatAccessUnit:
        {
            size_t trackIndex;
            CHECK(msg->findSize("trackIndex", &trackIndex));
            CHECK_LT(trackIndex, mTracks.size());

            sp<RefBase> obj;
            CHECK(msg->findObject("accessUnit", &obj));

            sp<ABuffer> accessUnit = static_cast<ABuffer *>(obj.get());

            int32_t damaged;
            if (accessUnit->meta()->findInt32("damaged", &damaged)
                    && damaged) {
                LOGI("dropping damaged access unit.");
                break;
            }

            TrackInfo *info = &mTracks.editItemAt(trackIndex);

            sp<AnotherPacketSource> source = info->mSource;
            if (source != NULL) {
                uint32_t rtpTime;
                CHECK(accessUnit->meta()->findInt32("rtp-time", (int32_t *)&rtpTime));

                if (!info->mNPTMappingValid) {
                    // This is a live stream, we didn't receive any normal
                    // playtime mapping. Assume the first packets correspond
                    // to time 0.

                    LOGV("This is a live stream, assuming time = 0");

                    info->mRTPTime = rtpTime;
                    info->mNormalPlaytimeUs = 0ll;
                    info->mNPTMappingValid = true;
                }

                int64_t nptUs =
                    ((double)rtpTime - (double)info->mRTPTime)
                        / info->mTimeScale
                        * 1000000ll
                        + info->mNormalPlaytimeUs;

                accessUnit->meta()->setInt64("timeUs", nptUs);
                info->mLatestReceivedUnit = nptUs;
                // Drop the frames that are older than the frames in the queue.
                if (info->mLatestPausedUnit && (int64_t)info->mLatestPausedUnit > nptUs) {
                  break;
                }
                source->queueAccessUnit(accessUnit);
            }

            onTrackDataAvailable(trackIndex);
            break;
        }

        case RtspConnectionHandler::kWhatEOS:
        {
            size_t trackIndex;
            CHECK(msg->findSize("trackIndex", &trackIndex));
            CHECK_LT(trackIndex, mTracks.size());

            int32_t finalResult;
            CHECK(msg->findInt32("finalResult", &finalResult));
            CHECK_NE(finalResult, (status_t)OK);

            TrackInfo *info = &mTracks.editItemAt(trackIndex);
            sp<AnotherPacketSource> source = info->mSource;
            if (source != NULL) {
                source->signalEOS(finalResult);
            }

            break;
        }

        case RtspConnectionHandler::kWhatSeekDiscontinuity:
        {
            size_t trackIndex;
            CHECK(msg->findSize("trackIndex", &trackIndex));
            CHECK_LT(trackIndex, mTracks.size());

            TrackInfo *info = &mTracks.editItemAt(trackIndex);
            sp<AnotherPacketSource> source = info->mSource;
            if (source != NULL) {
                source->queueDiscontinuity(ATSParser::DISCONTINUITY_SEEK, NULL);
            }

            break;
        }

        case RtspConnectionHandler::kWhatNormalPlayTimeMapping:
        {
            size_t trackIndex;
            CHECK(msg->findSize("trackIndex", &trackIndex));
            CHECK_LT(trackIndex, mTracks.size());

            uint32_t rtpTime;
            CHECK(msg->findInt32("rtpTime", (int32_t *)&rtpTime));

            int64_t nptUs;
            CHECK(msg->findInt64("nptUs", &nptUs));

            TrackInfo *info = &mTracks.editItemAt(trackIndex);
            info->mRTPTime = rtpTime;
            info->mNormalPlaytimeUs = nptUs;
            info->mNPTMappingValid = true;
            break;
        }

        case RtspConnectionHandler::kWhatTryTCPInterleaving:
        {
            // By default, we will request to deliver RTP over UDP. If the play
            // request timed out and we didn't receive any RTP packet, we will
            // fail back to use RTP interleaved in the existing RTSP/TCP
            // connection. And in this case, we have to explicitly perform
            // another play event to request the server to start streaming
            // again.
            int64_t playTimeUs;
            if (!msg->findInt64("timeUs", &playTimeUs)) {
                playTimeUs = 0;
            }
            performPlay(playTimeUs);
            break;
        }

        default:
            TRESPASS();
    }
}
Exemple #19
0
 // static
 void ThreadLocalPlatform::AllocateSlot(SlotType& slot)
 {
     slot = TlsAlloc();
     CHECK_NE(slot, TLS_OUT_OF_INDEXES);
 }
inline MassiveBody::Parameters::Parameters(Mass const& mass)
    : gravitational_parameter_(mass * GravitationalConstant),
      mass_(mass) {
  CHECK_NE(mass, Mass()) << "Massive body cannot have zero mass";
}
INITIALIZE_EASYLOGGINGPP

int main(void) {
    el::Loggers::addFlag(el::LoggingFlag::DisableApplicationAbortOnFatalLog);
    
    // These checks should fail
    LOG(INFO) << "----- DONT WORRY ABOUT FOLLOWING CHECKS FAILING - THEY ARE EXPECTED";
    CHECK(1 > 2) << "1 is not greater than 2";
    CHECK_EQ(1, 2) << "1 is not equal to 2";
    CHECK_NE(1, 1) << "Wow, I did not know 1 == 1";
    CHECK_STREQ("abc", "def") << " :)";
    CHECK_STRNE("abc", "abc") << " :(";
    CHECK_STRCASEEQ("abc", "ABCD") << " :p";
    CHECK_STRCASENE("abc", "ABC") << " B)";
    int* f = new int;
    CHECK_NOTNULL(f);

    delete f;
    f = nullptr;
    // These checks should pass 
    LOG(WARNING) << "----- START WORRYING ABOUT CHECKS NOW";
    CHECK(1 < 2) << " snap -- lib has bug!";
    CHECK_EQ(1, 1) << " snap -- lib has bug!";
    CHECK_NE(1, 2) << " snap -- lib has bug!";
    CHECK_STREQ("abc", "abc") << " snap -- lib has bug!";
    CHECK_STRNE("abc", "abe") << " snap -- lib has bug!";
    CHECK_STRCASEEQ("abc", "ABC") << " snap -- lib has bug!";
    CHECK_STRCASENE("abc", "ABE") << " snap -- lib has bug!";
    LOG(INFO) << "----- HOPEFULLY NO CHECK FAILED SINCE YOU STARTED WORRYING!";

    // DCHECKs
    DCHECK(1 > 2) << "1 is not greater than 2";
    DCHECK_EQ(1, 2) << "1 is not equal to 2";
    DCHECK_NE(1, 1) << "Wow, I did not know 1 == 1";
    DCHECK_STREQ("abc", "def") << " :)";
    DCHECK_STRNE("abc", "abc") << " :(";
    DCHECK_STRCASEEQ("abc", "ABCD") << " :p";
    DCHECK_STRCASENE("abc", "ABC") << " B)";
    
    // PCHECKs
    std::fstream fstr("a/file/that/does/not/exist", std::fstream::in);
    PCHECK(fstr.is_open());
    DPCHECK(fstr.is_open());

    int min = 1;
    int max = 5;
    CHECK_BOUNDS(1, min, max) << "Index out of bounds";
    CHECK_BOUNDS(2, min, max) << "Index out of bounds";
    CHECK_BOUNDS(3, min, max) << "Index out of bounds";
    CHECK_BOUNDS(4, min, max) << "Index out of bounds";
    CHECK_BOUNDS(5, min, max) << "Index out of bounds";
    CHECK_BOUNDS(6, min, max) << "Index out of bounds";
    DCHECK_BOUNDS(1, min, max) << "Index out of bounds";
    DCHECK_BOUNDS(2, min, max) << "Index out of bounds";
    DCHECK_BOUNDS(3, min, max) << "Index out of bounds";
    DCHECK_BOUNDS(4, min, max) << "Index out of bounds";
    DCHECK_BOUNDS(5, min, max) << "Index out of bounds";
    DCHECK_BOUNDS(6, min, max) << "Index out of bounds";

    return 0;
}
Exemple #22
0
    void Query::Execute()
    {
        std::ostream& output = GetEnvironment().GetOutputStream();

        if (m_isSingleQuery)
        {
            output
                << "Processing query \""
                << m_query
                << "\"" << std::endl;
            auto instrumentation =
                QueryRunner::Run(m_query.c_str(),
                                 GetEnvironment().GetSimpleIndex(),
                                 GetEnvironment().GetCompilerMode(),
                                 GetEnvironment().GetCacheLineCountMode());

            output << "Results:" << std::endl;
            CsvTsv::CsvTableFormatter formatter(output);
            QueryInstrumentation::Data::FormatHeader(formatter);
            instrumentation.Format(formatter);
        }
        else
        {
            CHECK_NE(*GetEnvironment().GetOutputDir().c_str(), '\0')
                << "Output directory not set. "
                << "Please use the 'cd' command to set an "
                << "output directory";

            output
                << "Processing queries from log at \""
                << m_query
                << "\"" << std::endl;

            std::string const & filename = m_query;
            auto fileSystem = Factories::CreateFileSystem();  // TODO: Use environment file system
            auto queries = ReadLines(*fileSystem, filename.c_str());
            const size_t c_threadCount = GetEnvironment().GetThreadCount();
            const size_t c_iterations = 1;
            auto statistics =
                QueryRunner::Run(GetEnvironment().GetSimpleIndex(),
                                 GetEnvironment().GetOutputDir().c_str(),
                                 c_threadCount,
                                 queries,
                                 c_iterations,
                                 GetEnvironment().GetCompilerMode(),
                                 GetEnvironment().GetCacheLineCountMode());
            output << "Results:" << std::endl;
            statistics.Print(output);

            // TODO: unify this with the fileManager that's passed into
            // QueryRunner::Run.
            auto outFileManager =
                Factories::CreateFileManager(GetEnvironment().GetOutputDir().c_str(),
                                             GetEnvironment().GetOutputDir().c_str(),
                                             GetEnvironment().GetOutputDir().c_str(),
                                             GetEnvironment().GetSimpleIndex().GetFileSystem());

            auto outSummary = outFileManager->QuerySummaryStatistics().OpenForWrite();
            statistics.Print(*outSummary);
        }
    }
Exemple #23
0
std::vector<llvm::Value*> Executor::codegen(const Analyzer::Expr* expr,
                                            const bool fetch_columns,
                                            const CompilationOptions& co) {
  if (!expr) {
    return {posArg(expr)};
  }
  auto iter_expr = dynamic_cast<const Analyzer::IterExpr*>(expr);
  if (iter_expr) {
#ifdef ENABLE_MULTIFRAG_JOIN
    if (iter_expr->get_rte_idx() > 0) {
      const auto offset = cgen_state_->frag_offsets_[iter_expr->get_rte_idx()];
      if (offset) {
        return {cgen_state_->ir_builder_.CreateAdd(posArg(iter_expr), offset)};
      } else {
        return {posArg(iter_expr)};
      }
    }
#endif
    return {posArg(iter_expr)};
  }
  auto bin_oper = dynamic_cast<const Analyzer::BinOper*>(expr);
  if (bin_oper) {
    return {codegen(bin_oper, co)};
  }
  auto u_oper = dynamic_cast<const Analyzer::UOper*>(expr);
  if (u_oper) {
    return {codegen(u_oper, co)};
  }
  auto col_var = dynamic_cast<const Analyzer::ColumnVar*>(expr);
  if (col_var) {
    return codegen(col_var, fetch_columns, co);
  }
  auto constant = dynamic_cast<const Analyzer::Constant*>(expr);
  if (constant) {
    if (constant->get_is_null()) {
      const auto& ti = constant->get_type_info();
      return {ti.is_fp() ? static_cast<llvm::Value*>(inlineFpNull(ti)) : static_cast<llvm::Value*>(inlineIntNull(ti))};
    }
    // The dictionary encoding case should be handled by the parent expression
    // (cast, for now), here is too late to know the dictionary id
    CHECK_NE(kENCODING_DICT, constant->get_type_info().get_compression());
    return {codegen(constant, constant->get_type_info().get_compression(), 0, co)};
  }
  auto case_expr = dynamic_cast<const Analyzer::CaseExpr*>(expr);
  if (case_expr) {
    return {codegen(case_expr, co)};
  }
  auto extract_expr = dynamic_cast<const Analyzer::ExtractExpr*>(expr);
  if (extract_expr) {
    return {codegen(extract_expr, co)};
  }
  auto dateadd_expr = dynamic_cast<const Analyzer::DateaddExpr*>(expr);
  if (dateadd_expr) {
    return {codegen(dateadd_expr, co)};
  }
  auto datediff_expr = dynamic_cast<const Analyzer::DatediffExpr*>(expr);
  if (datediff_expr) {
    return {codegen(datediff_expr, co)};
  }
  auto datetrunc_expr = dynamic_cast<const Analyzer::DatetruncExpr*>(expr);
  if (datetrunc_expr) {
    return {codegen(datetrunc_expr, co)};
  }
  auto charlength_expr = dynamic_cast<const Analyzer::CharLengthExpr*>(expr);
  if (charlength_expr) {
    return {codegen(charlength_expr, co)};
  }
  auto like_expr = dynamic_cast<const Analyzer::LikeExpr*>(expr);
  if (like_expr) {
    return {codegen(like_expr, co)};
  }
  auto regexp_expr = dynamic_cast<const Analyzer::RegexpExpr*>(expr);
  if (regexp_expr) {
    return {codegen(regexp_expr, co)};
  }
  auto likelihood_expr = dynamic_cast<const Analyzer::LikelihoodExpr*>(expr);
  if (likelihood_expr) {
    return {codegen(likelihood_expr->get_arg(), fetch_columns, co)};
  }
  auto in_expr = dynamic_cast<const Analyzer::InValues*>(expr);
  if (in_expr) {
    return {codegen(in_expr, co)};
  }
  auto in_integer_set_expr = dynamic_cast<const Analyzer::InIntegerSet*>(expr);
  if (in_integer_set_expr) {
    return {codegen(in_integer_set_expr, co)};
  }
  auto function_oper_with_custom_type_handling_expr =
      dynamic_cast<const Analyzer::FunctionOperWithCustomTypeHandling*>(expr);
  if (function_oper_with_custom_type_handling_expr) {
    return {codegenFunctionOperWithCustomTypeHandling(function_oper_with_custom_type_handling_expr, co)};
  }
  auto function_oper_expr = dynamic_cast<const Analyzer::FunctionOper*>(expr);
  if (function_oper_expr) {
    return {codegenFunctionOper(function_oper_expr, co)};
  }
  abort();
}
void NuPlayer::RTSPSource::onMessageReceived(const sp<AMessage> &msg) {
    if (msg->what() == kWhatDisconnect) {
        sp<AReplyToken> replyID;
        CHECK(msg->senderAwaitsResponse(&replyID));

        mDisconnectReplyID = replyID;
        finishDisconnectIfPossible();
        return;
    } else if (msg->what() == kWhatPerformSeek) {
        int32_t generation;
        CHECK(msg->findInt32("generation", &generation));
        CHECK(msg->senderAwaitsResponse(&mSeekReplyID));

        if (generation != mSeekGeneration) {
            // obsolete.
            finishSeek(OK);
            return;
        }

        int64_t seekTimeUs;
        CHECK(msg->findInt64("timeUs", &seekTimeUs));

        performSeek(seekTimeUs);
        return;
    } else if (msg->what() == kWhatPollBuffering) {
        onPollBuffering();
        return;
    } else if (msg->what() == kWhatSignalEOS) {
        onSignalEOS(msg);
        return;
    }

    CHECK_EQ(msg->what(), (int)kWhatNotify);

    int32_t what;
    CHECK(msg->findInt32("what", &what));

    switch (what) {
        case MyHandler::kWhatConnected:
        {
            onConnected();

            notifyVideoSizeChanged();

            uint32_t flags = 0;

            if (mHandler->isSeekable()) {
                flags = FLAG_CAN_PAUSE
                        | FLAG_CAN_SEEK
                        | FLAG_CAN_SEEK_BACKWARD
                        | FLAG_CAN_SEEK_FORWARD;
            }

            notifyFlagsChanged(flags);
            schedulePollBuffering();
            break;
        }

        case MyHandler::kWhatDisconnected:
        {
            onDisconnected(msg);
            break;
        }

        case MyHandler::kWhatSeekDone:
        {
            mState = CONNECTED;
            // Unblock seekTo here in case we attempted to seek in a live stream
            finishSeek(OK);
            break;
        }

        case MyHandler::kWhatSeekPaused:
        {
            sp<AnotherPacketSource> source = getSource(true /* audio */);
            if (source != NULL) {
                source->queueDiscontinuity(ATSParser::DISCONTINUITY_NONE,
                        /* extra */ NULL,
                        /* discard */ true);
            }
            source = getSource(false /* video */);
            if (source != NULL) {
                source->queueDiscontinuity(ATSParser::DISCONTINUITY_NONE,
                        /* extra */ NULL,
                        /* discard */ true);
            };

            status_t err = OK;
            msg->findInt32("err", &err);

            if (err == OK) {
                int64_t timeUs;
                CHECK(msg->findInt64("time", &timeUs));
                mHandler->continueSeekAfterPause(timeUs);
            } else {
                finishSeek(err);
            }
            break;
        }

        case MyHandler::kWhatAccessUnit:
        {
            size_t trackIndex;
            CHECK(msg->findSize("trackIndex", &trackIndex));

            if (mTSParser == NULL) {
                CHECK_LT(trackIndex, mTracks.size());
            } else {
                CHECK_EQ(trackIndex, 0u);
            }

            sp<ABuffer> accessUnit;
            CHECK(msg->findBuffer("accessUnit", &accessUnit));

            int32_t damaged;
            if (accessUnit->meta()->findInt32("damaged", &damaged)
                    && damaged) {
                ALOGI("dropping damaged access unit.");
                break;
            }

            if (mTSParser != NULL) {
                size_t offset = 0;
                status_t err = OK;
                while (offset + 188 <= accessUnit->size()) {
                    err = mTSParser->feedTSPacket(
                            accessUnit->data() + offset, 188);
                    if (err != OK) {
                        break;
                    }

                    offset += 188;
                }

                if (offset < accessUnit->size()) {
                    err = ERROR_MALFORMED;
                }

                if (err != OK) {
                    signalSourceEOS(err);
                }

                postSourceEOSIfNecessary();
                break;
            }

            TrackInfo *info = &mTracks.editItemAt(trackIndex);

            sp<AnotherPacketSource> source = info->mSource;
            if (source != NULL) {
                uint32_t rtpTime;
                CHECK(accessUnit->meta()->findInt32("rtp-time", (int32_t *)&rtpTime));

                if (!info->mNPTMappingValid) {
                    // This is a live stream, we didn't receive any normal
                    // playtime mapping. We won't map to npt time.
                    source->queueAccessUnit(accessUnit);
                    break;
                }

                int64_t nptUs =
                    ((double)rtpTime - (double)info->mRTPTime)
                        / info->mTimeScale
                        * 1000000ll
                        + info->mNormalPlaytimeUs;

                accessUnit->meta()->setInt64("timeUs", nptUs);

                source->queueAccessUnit(accessUnit);
            }
            postSourceEOSIfNecessary();
            break;
        }

        case MyHandler::kWhatEOS:
        {
            int32_t finalResult;
            CHECK(msg->findInt32("finalResult", &finalResult));
            CHECK_NE(finalResult, (status_t)OK);

            if (mTSParser != NULL) {
                signalSourceEOS(finalResult);
            }

            size_t trackIndex;
            CHECK(msg->findSize("trackIndex", &trackIndex));
            CHECK_LT(trackIndex, mTracks.size());

            TrackInfo *info = &mTracks.editItemAt(trackIndex);
            sp<AnotherPacketSource> source = info->mSource;
            if (source != NULL) {
                source->signalEOS(finalResult);
            }

            break;
        }

        case MyHandler::kWhatSeekDiscontinuity:
        {
            size_t trackIndex;
            CHECK(msg->findSize("trackIndex", &trackIndex));
            CHECK_LT(trackIndex, mTracks.size());

            TrackInfo *info = &mTracks.editItemAt(trackIndex);
            sp<AnotherPacketSource> source = info->mSource;
            if (source != NULL) {
                source->queueDiscontinuity(
                        ATSParser::DISCONTINUITY_TIME,
                        NULL,
                        true /* discard */);
            }

            break;
        }

        case MyHandler::kWhatNormalPlayTimeMapping:
        {
            size_t trackIndex;
            CHECK(msg->findSize("trackIndex", &trackIndex));
            CHECK_LT(trackIndex, mTracks.size());

            uint32_t rtpTime;
            CHECK(msg->findInt32("rtpTime", (int32_t *)&rtpTime));

            int64_t nptUs;
            CHECK(msg->findInt64("nptUs", &nptUs));

            TrackInfo *info = &mTracks.editItemAt(trackIndex);
            info->mRTPTime = rtpTime;
            info->mNormalPlaytimeUs = nptUs;
            info->mNPTMappingValid = true;
            break;
        }

        case SDPLoader::kWhatSDPLoaded:
        {
            onSDPLoaded(msg);
            break;
        }

        default:
            TRESPASS();
    }
}
Exemple #25
0
            } else {
              // no, so return nack.
              DVLOG(7) << "Failed with no more space available";
              return -1; // did not succeed
            }
          } );

        // insert succeeded, so move to next edge
        if( retval >= 0 ) {
          local_max++;
        }

        // no more space available on target, so move to next core
        if( local_max < read_count && retval != 0 ) {
          likely_consumer = (likely_consumer + 1) % Grappa::cores();
          CHECK_NE( likely_consumer, Grappa::mycore() ) << "No more space to place edge on cluster?";
        }
      }
      
      // wait for everybody else to fill in our remaining spaces
      Grappa::barrier();
      
      // discard temporary read buffer
      read_edges.clear();
    } );

  // done!
  return tg;
}

/// Matrix Market format loader
// Sets the landmark as a potential match for this observation. The observation
// still has not been incorporated into the landmark.
void Observation::SetMatchedLandmark(LandmarkIndex landmark_index) {
  CHECK_NE(kInvalidLandmark, landmark_index);
  landmark_index_ = landmark_index;
  is_matched_ = true;
}
Exemple #27
0
void ReshapeOp::Forward() {
  const auto *bottom = bottoms<float>(0);
  auto *top = mutable_tops<float>(0);

  CHECK_NE(bottom, top);

  int inferred_axis = -1, constant_count = 1;
  VecInt copy_axes;
  for (int d = 0; d < shape_.size(); ++d) {
    int top_dim = shape_[d];
    if (top_dim == 0) {
      copy_axes.push_back(d);
    } else if (top_dim == -1) {
      CHECK_EQ(inferred_axis, -1);
      inferred_axis = d;
    } else {
      constant_count *= top_dim;
    }
  }

  int start_axis = (axis_ >= 0) ? axis_ : (bottom->num_axes() + axis_ + 1);
  CHECK_GE(start_axis, 0);
  CHECK_LE(start_axis, bottom->num_axes());
  int end_axis =
      (num_axes_ == -1) ? bottom->num_axes() : (start_axis + num_axes_);
  CHECK_LE(end_axis, bottom->num_axes());
  int num_axes_replaced = end_axis - start_axis;
  int num_axes_retained = bottom->num_axes() - num_axes_replaced;

  VecInt top_shape(num_axes_retained + shape_.size());
  int top_shape_index = 0;
  for (int d = 0; d < start_axis; ++d) {
    top_shape[top_shape_index++] = bottom->shape(d);
  }
  for (auto dim : shape_) {
    top_shape[top_shape_index++] = dim;
  }
  for (int d = end_axis; d < bottom->num_axes(); ++d) {
    top_shape[top_shape_index++] = bottom->shape(d);
  }
  CHECK_EQ(top_shape_index, top_shape.size());

  for (auto d : copy_axes) {
    CHECK_GT(bottom->num_axes(), start_axis + d);
    top_shape[start_axis + d] = bottom->shape(start_axis + d);
  }

  if (inferred_axis >= 0) {
    int explicit_count = constant_count;
    explicit_count *= bottom->count(0, start_axis);
    explicit_count *= bottom->count(end_axis);
    for (auto d : copy_axes) {
      explicit_count *= top_shape[start_axis + d];
    }
    CHECK_EQ(0, bottom->count() % explicit_count);
    top_shape[start_axis + inferred_axis] = bottom->count() / explicit_count;
  }

  top->clear();
  top->set_shape(top_shape);
  CHECK_EQ(top->count(), bottom->count());

  top->share_data(*bottom);
}
Exemple #28
0
int check_ne_example(int x) {
  CHECK_NE(x, 5);
  return x;
}
Exemple #29
0
Subprocess::~Subprocess() {
  CHECK_NE(returnCode_.state(), ProcessReturnCode::RUNNING)
    << "Subprocess destroyed without reaping child";
  closeAll();
}
void HighResolutionTimer::restart() {
    int status = clock_gettime(CLOCK_MONOTONIC, &start_time_);
    CHECK_NE(-1, status) << "Couldn't initialize start_time_";
}