'GPU内核方法优化'

admin

2023-03-07 8b06b1cbf112d55307ea8a6efe711db4e7506d89

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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#ifndef MINI_CHROMIUM_BASE_SCOPED_GENERIC_H_
#define MINI_CHROMIUM_BASE_SCOPED_GENERIC_H_
 
#include <stdlib.h>
 
#include <algorithm>
 
#include "base/compiler_specific.h"
#include "base/macros.h"
 
namespace base {
 
template<typename T, typename Traits>
class ScopedGeneric {
 private:
  struct Data : public Traits {
    explicit Data(const T& in) : generic(in) {}
    Data(const T& in, const Traits& other) : Traits(other), generic(in) {}
    T generic;
  };
 
 public:
  typedef T element_type;
  typedef Traits traits_type;
 
  ScopedGeneric() : data_(traits_type::InvalidValue()) {}
 
  explicit ScopedGeneric(const element_type& value) : data_(value) {}
 
  ScopedGeneric(const element_type& value, const traits_type& traits)
      : data_(value, traits) {
  }
 
  ScopedGeneric(ScopedGeneric<T, Traits>&& rvalue)
      : data_(rvalue.release(), rvalue.get_traits()) {
  }
 
  ~ScopedGeneric() {
    FreeIfNecessary();
  }
 
  ScopedGeneric& operator=(ScopedGeneric<T, Traits>&& rvalue) {
    reset(rvalue.release());
    return *this;
  }
 
  void reset(const element_type& value = traits_type::InvalidValue()) {
    if (data_.generic != traits_type::InvalidValue() && data_.generic == value)
      abort();
    FreeIfNecessary();
    data_.generic = value;
  }
 
  void swap(ScopedGeneric& other) {
    using std::swap;
    swap(static_cast<Traits&>(data_), static_cast<Traits&>(other.data_));
    swap(data_.generic, other.data_.generic);
  }
 
  element_type release() WARN_UNUSED_RESULT {
    element_type old_generic = data_.generic;
    data_.generic = traits_type::InvalidValue();
    return old_generic;
  }
 
  const element_type& get() const { return data_.generic; }
 
  bool is_valid() const { return data_.generic != traits_type::InvalidValue(); }
 
  bool operator==(const element_type& value) const {
    return data_.generic == value;
  }
  bool operator!=(const element_type& value) const {
    return data_.generic != value;
  }
 
  Traits& get_traits() { return data_; }
  const Traits& get_traits() const { return data_; }
 
 private:
  void FreeIfNecessary() {
    if (data_.generic != traits_type::InvalidValue()) {
      data_.Free(data_.generic);
      data_.generic = traits_type::InvalidValue();
    }
  }
 
  template <typename T2, typename Traits2> bool operator==(
      const ScopedGeneric<T2, Traits2>& p2) const;
  template <typename T2, typename Traits2> bool operator!=(
      const ScopedGeneric<T2, Traits2>& p2) const;
 
  Data data_;
 
  DISALLOW_COPY_AND_ASSIGN(ScopedGeneric);
};
 
template<class T, class Traits>
void swap(const ScopedGeneric<T, Traits>& a,
          const ScopedGeneric<T, Traits>& b) {
  a.swap(b);
}
 
template<class T, class Traits>
bool operator==(const T& value, const ScopedGeneric<T, Traits>& scoped) {
  return value == scoped.get();
}
 
template<class T, class Traits>
bool operator!=(const T& value, const ScopedGeneric<T, Traits>& scoped) {
  return value != scoped.get();
}
 
}  // namespace base
 
#endif  // MINI_CHROMIUM_BASE_SCOPED_GENERIC_H_