1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67


gpu / command_buffer / common / sync_token.cc [blame]

// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "gpu/command_buffer/common/sync_token.h"

#include <sstream>

#include "base/ranges/algorithm.h"

namespace gpu {

SyncPointClientId::SyncPointClientId(CommandBufferNamespace in_namespace_id,
                                     CommandBufferId in_command_buffer_id)
    : namespace_id(in_namespace_id), command_buffer_id(in_command_buffer_id) {}

SyncToken::SyncToken()
    : verified_flush_(false),
      namespace_id_(CommandBufferNamespace::INVALID),
      release_count_(0) {}

SyncToken::SyncToken(CommandBufferNamespace namespace_id,
                     CommandBufferId command_buffer_id,
                     uint64_t release_count)
    : verified_flush_(false),
      namespace_id_(namespace_id),
      command_buffer_id_(command_buffer_id),
      release_count_(release_count) {}

SyncToken::SyncToken(const SyncToken& other) = default;
SyncToken& SyncToken::operator=(const SyncToken& other) = default;

std::string SyncToken::ToDebugString() const {
  // At the level of the generic command buffer code, the command buffer ID is
  // an arbitrary 64-bit number. For the debug output, print its upper and lower
  // 32bit words separately. This ensures more readable output for IDs allocated
  // by gpu/ipc code which uses these words for channel and route IDs, but it's
  // still a lossless representation if the IDs don't match this convention.
  uint64_t id = command_buffer_id().GetUnsafeValue();
  uint32_t channel_or_high = 0xffffffff & id;
  uint32_t route_or_low = id >> 32;
  std::ostringstream stream;
  stream << static_cast<int>(namespace_id()) << ":" << channel_or_high << ":"
         << route_or_low << ":" << release_count();
  return stream.str();
}

std::vector<SyncToken> ReduceSyncTokens(base::span<const SyncToken> tokens) {
  std::vector<SyncToken> reduced;
  for (const SyncToken& next_token : tokens) {
    auto itr =
        base::ranges::find_if(reduced, [&next_token](const SyncToken& token) {
          return next_token.namespace_id() == token.namespace_id() &&
                 next_token.command_buffer_id() == token.command_buffer_id();
        });
    if (itr == reduced.end()) {
      reduced.push_back(next_token);
    } else {
      if (itr->release_count() < next_token.release_count()) {
        *itr = next_token;
      }
    }
  }
  return reduced;
}

}  // namespace gpu