标签: reference-counting

我在C++ FAQ中引入了一个有趣的基类实现,根据我的天真理解,它可以作为一些智能指针实现的替代(例如shared_ptr).以下是逐字的示例代码,但请按照上面的链接获取解释:

class Fred {
public:

  static Fred create1(std::string const& s, int i);
  static Fred create2(float x, float y);

  Fred(Fred const& f);
  Fred& operator= (Fred const& f);
 ~Fred();

  void sampleInspectorMethod() const;   // No changes to this object
  void sampleMutatorMethod();           // Change this object

  ...

private:

  class Data {
  public:
    Data() : count_(1) { }
    Data(Data const& d) : count_(1) { }              // Do NOT copy the 'count_' member!
    Data& operator= (Data const&) { return *this; }  // Do …

假设我有一个shared_ptr数组:

std::shared_ptr<int> sp(new T[10], [](T *p) { delete[] p; });

一个方法:

shared_ptr<T> ptr_at_offset(int offset) {
    // I want to return a shared_ptr to (sp.get() + offset) here
    // in a way that the reference count to sp is incremented...
}

基本上,我要做的是返回一个新的shared_ptr,增加引用计数,但指向原始数组的偏移量; 我想避免在调用者在某个偏移处使用数组时删除数组.如果我回来sp.get() + offset可能会发生,对吗？我认为初始化一个新shared_ptr的包含sp.get() + offset也没有意义.

C++的新手,所以不确定我是否正确接近这个.

我有以下代码使用Rc和Box; 那些有什么区别？哪一个更好？

use std::rc::Rc;

fn main() {
    let a = Box::new(1);
    let a1 = &a;
    let a2 = &a;
    let b = Rc::new(1);
    let b1 = b.clone();
    let b2 = b.clone();

    println!("{} {}", a1, a2);
    println!("{} {}", b1, b2);
}

游乐场链接

Rust如何处理Rcs和Arcs 的"隔离岛"场景？

"隔离岛"是这样一种情况,其中object A包含指向object的对象,B而object B包含指向object的指针A,但是在其他任何地方都没有指向任何对象的指针.

Rust是否足够智能来检测这个或是否会导致内存泄漏？

我正在寻找相当于LWARX和STWCX(在PowerPC处理器上找到)或在x86平台上实现类似功能的方法.此外,哪里是最好的地方找到这样的事情(即锁定/等待免费编程的好文章/网站/论坛).

编辑
我想我可能需要提供更多细节,因为我假设我只是在寻找CAS(比较和交换)操作.我要做的是实现一个带有智能指针的无锁引用计数系统,可以通过多个线程访问和更改.我基本上需要一种在x86处理器上实现以下功能的方法.

int* IncrementAndRetrieve(int **ptr)
{
  int val;
  int *pval;
  do
  {
    // fetch the pointer to the value
    pval = *ptr;

    // if its NULL, then just return NULL, the smart pointer
    // will then become NULL as well
    if(pval == NULL)
      return NULL;

    // Grab the reference count
    val = lwarx(pval);

    // make sure the pointer we grabbed the value from
    // is still the same one referred to by  'ptr'
    if(pval != *ptr)
      continue;

    // Increment …

在我正在修改的幻灯片上说如下:

可以通过维护对每个对象的引用数量的计数,或者通过跟踪来自根的引用链来识别活动对象.

引用计数很昂贵 - 每次参考更改时都需要操作,并且它不会发现周期性结构,但它可以递增地回收空间.

跟踪涉及仅在需要回收空间时识别活动对象 - 将成本从一般访问转移到GC运行的时间,通常仅在内存不足时.

我理解为什么引用计数很昂贵的原则,但不明白什么"没有发现周期性结构,但它可以逐步回收空间".手段.有人能帮我一点吗？

谢谢

我试图在线程之间共享一个只用于只读的映像.通常我使用boost :: shared_ptrs做这种事情,但由于cv :: Mat已经是下面的引用计数容器,我一直试图以相同的方式使用它,假设它是基于对线程安全的引用的线程安全在这里引用计数:

• http://opencv.willowgarage.com/documentation/cpp/basic_structures.html

但是我遇到的问题可能表明它们实际上并不是线程安全的; 该任务是非原子的.偶尔我会在引用计数增量内得到一个seg-fault,这意味着原始对象已被破坏.

所以具体问题是:

• cv :: Mat赋值原子？

所以我正在阅读这篇文章,试图从Python解释器中删除全局解释器锁(GIL)以提高多线程性能并看到一些有趣的东西.

事实证明,删除GIL实际上使事情变得更糟的地方之一是内存管理:

使用自由线程,引用计数操作会失去线程安全性.因此,补丁引入了全局引用计数互斥锁以及用于更新计数的原子操作.在Unix上,使用标准的pthread_mutex_t锁(包含在PyMutex结构中)和以下函数实现锁定......

...在Unix上,必须强调的是,简单的引用计数操作已经被不少于三个函数调用替换,加上实际锁定的开销.它的价格要贵得多......

...显然细粒度的引用计数锁定是性能不佳的主要原因,但即使你取消锁定,引用计数性能仍然对任何类型的额外开销(例如,函数调用等)非常敏感. ).在这种情况下,性能仍然是使用GIL的Python的两倍.

然后:

引用计数是一种用于自由线程的非常糟糕的内存管理技术.这已经广为人知,但性能数据更加具体.对于任何尝试使用GIL删除补丁的人来说,这肯定是最具挑战性的问题.

所以问题是,如果引用计数对于线程来说太糟糕了,Objective-C如何做呢？我编写了多线程的Objective-C应用程序,并没有注意到内存管理的大量开销.他们在做别的吗？像某种每个对象锁而不是全局锁？Objective-C的引用计数在线程上实际上在技术上是不安全的吗？我不是一个真正推测的并发专家,但我有兴趣知道.

在这个答案中,我找到了一种在Python中获取对象引用计数的方法.

他们提到使用sys.getrefcount().我尝试过,但是我得到了意想不到的结果.当有1个引用时,似乎计数为20.为什么会这样？

我查看了文档,但似乎没有解释原因.

你如何使用std.typecons.RefCounted!(T)D中的引用计数对象？

我试图std.array.Array通过查看源代码来弄清楚内部是什么,但是虽然我可以阅读源代码,但我无法确定什么是"有效负载"或者当有涉及按位结构复制的事情时它是如何工作的,以及为什么有些东西在内部和外部结构中重复.

任何人都可以提供一个示例或链接,如何使用它,比如,包装一个简单的Win32 HANDLE？

谢谢!