标签: refcounting

有没有办法在Python中获取对象的当前引用计数？

我想知道在某个执行点分配的某些对象的确切实例数.主要是为了寻找可能的内存泄漏(我主要使用RAII,几乎没有新的,但在添加新元素或类似的东西之前,我仍然可以在向量上忘记.clear()).我可以有一个

atomic<int> cntMyObject;

我 - 在析构函数中,++增加构造函数,cpy构造函数(我希望我涵盖了一切:)).但这对每个班级来说都是硬编码.在"释放"模式下禁用它并不简单.那么有没有简单优雅的方法可以轻松禁用来计算对象实例？

我有一些不可变的数据结构,我想使用引用计数来管理,在SMP系统上的线程之间共享它们.

这是发布代码的样子:

void avocado_release(struct avocado *p)
{
    if (atomic_dec(p->refcount) == 0) {
        free(p->pit);
        free(p->juicy_innards);
        free(p);
    }
}

是否atomic_dec需要在它的内存屏障？如果是这样,什么样的记忆障碍？

附加说明:应用程序必须在PowerPC和x86上运行,因此欢迎任何特定于处理器的信息.我已经知道GCC原子内置.至于不变性,refcount是唯一在对象持续时间内发生变化的字段.

考虑以下代码:

#include <memory>
#include <iostream>

using namespace std;

struct MySharedStruct
{
  int i;
};

void print_value_of_i(weak_ptr<MySharedStruct> weakPtr)
{
  if (shared_ptr<MySharedStruct> sp = weakPtr.lock())
  { cout << "Value of i = " << sp->i << endl; }
  else
  { cout << "Resource has expired"; }
}

int main()
{
  shared_ptr<MySharedStruct> sharedPtr(new MySharedStruct() );
  sharedPtr->i = 5;

  weak_ptr<MySharedStruct> weakPtr;
  weakPtr = sharedPtr;

  print_value_of_i(weakPtr);

  sharedPtr.reset(new MySharedStruct() ); // <<----- How does weak_ptr know it has expired after this line executes?
  sharedPtr->i = 10; …

这个问题来自这里.

我有三个包含python对象(l1,l2和l3)的大型列表.这些列表是在程序启动时创建的,它们总共需要16GB的RAM.该程序将专门用于linux.

创建后,我不需要以任何方式或形式修改这些列表或这些列表中的对象.它们必须保留在内存中,直到程序退出.

我在我的程序中使用os.fork()和多处理模块来生成多个子进程(当前最多20个).这些子流程中的每一个都需要能够读取三个列表(l1,l2和l3).

我的程序在其他方面工作正常并且非常快.但是我遇到内存消耗问题.由于Linux上的写时复制方法,我希望每个子进程都可以使用这三个列表而不将它们复制到内存中.但是情况并非如此,因为引用任何这些列表中的任何对象都会增加相关的引用计数,从而导致整个内存页面被复制.

所以我的问题是:

我可以禁用引用计数l1,l2以及l3这些列表中的所有对象吗？基本上将整个对象(包括诸如引用计数之类的元数据)设置为只读,以便在任何情况下都不会被修改(我认为,这将允许我利用写入时复制).

目前我担心我被迫转移到另一种编程语言来完成这项任务,因为我目前不需要的"功能"(引用计数),但仍然强加给我并导致不必要的问题.

在Delphi中,函数结果经常被实现为var-parameter(尽管QC票证不是out-parameter).

字符串常量基本上是具有负refcounter的变量,它应该抑制自动内存[de]分配.http://docwiki.embarcadero.com/RADStudio/XE3/en/Internal_Data_Formats#Long_String_Types

它确实压制了它:下面的代码不会泄漏.

type
  TDealRecord = record
    id_Type: Integer;
    Price: extended;
    Remark: String;
  end;
const const_loop = 100000000;

function TestVar: TDealRecord;
//procedure TestVar;
var
  Li: Integer;
  LRec: TDealRecord;
begin
  for Li := 1 to const_loop do begin
     FillChar(Lrec,SizeOf(LRec), 0);
     LRec.Remark := 'Test';

//     FillChar(Result,SizeOf(Result), 0);
//     Result.Remark := 'Test';
  end;
end;

但是改变操纵变量 - 它会立即开始大量泄漏.

function TestVar: TDealRecord;
//procedure TestVar;
var
  Li: Integer;
  LRec: TDealRecord;
begin
  for Li := 1 to const_loop do begin
//     FillChar(Lrec,SizeOf(LRec), 0);
//     LRec.Remark := …

  $var = 1;
  debug_zval_dump($var);

输出:

long(1) refcount(2)


  $var = 1;
  $var_dup = &$var;
  debug_zval_dump($var);exit;

输出:

long(1) refcount(1)

UPDATE

对答案非常失望......

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

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

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

谢谢!

在一个天真的引用计数智能指针实现中,引用计数器可能会溢出.在C++标准库实现中如何避免或处理这种溢出？

我目前正在尝试将单线程程序传递给多线程.该软件大量使用"refCounted"对象,这导致多线程中的一些问题.我正在寻找一些可能解决我的问题的设计模式.

主要问题是线程之间的对象删除,通常删除只减少引用计数,当refcount等于零时,则删除对象.这在monothread程序中运行良好,并且可以通过大对象的副本实现一些很好的性能提升.

但是,在多线程中,两个线程可能希望同时删除同一个对象,因为该对象受互斥锁保护,只有一个线程删除该对象并阻塞另一个.但是当它释放互斥锁时,另一个线程继续执行无效(释放对象),这会导致内存损坏.

以下是此类RefCountedObject的示例

class RefCountedObject
{
public:
RefCountedObject()
:   _refCount( new U32(1) )
{}

RefCountedObject( const RefCountedObject& obj )
:   _refCount( obj._refCount )
{
    ACE_Guard< ACE_Mutex > guard( _refCountMutex );
    ++(*_refCount);
}

~RefCountedObject()
{
    Destroy();
}

RefCountedObject& operator=( const RefCountedObject& obj )
{
    if( this != &obj )
    {
        Destroy();
        ACE_Guard< ACE_Mutex > guard( _refCountMutex );
        _refCount = obj._refCount;
        ++(*_refCount);
    }

    return *this;
}

private:
    void Destroy()
    {
        ACE_Guard< ACE_Mutex > guard( _refCountMutex );  // thread2 are waiting here …