我有一个分配大量内存的应用程序,我正在考虑使用比malloc更好的内存分配机制.
我的主要选择是:jemalloc和tcmalloc.使用它们中的任何一个是否有任何好处？
在http://locklessinc.com/benchmarks.shtml中 ,一些机制(包括作者的专有机制 - 无锁)之间有一个很好的比较,它提到了每个机制的优点和缺点.
鉴于这两种机制都是积极的并且不断改进.有没有人对这两者的相对表现有任何见解或经验？
考虑一下这段代码:
#include <vector>
#include <iostream>
using namespace std;
class Base
{
char _type;
public:
Base(char type):
_type(type)
{}
~Base() {
cout << "Base destructor: " << _type << endl;
}
};
class uncopyable
{
protected:
uncopyable() {}
~uncopyable() {}
private:
uncopyable( const uncopyable& );
const uncopyable& operator=( const uncopyable& );
};
class Child : public Base, private uncopyable
{
int j;
public:
Child():
Base('c')
{}
~Child() {
cout << "Child destructor" << endl;
}
};
int main()
{
vector<Base> v; …我有一个多线程 C++ 程序，在极少数情况下会死锁。这个问题很难重现，我只能在远程机器上重现它。我想用来解决这个问题的方法是
我在远程机器上没有 gdb，无法在其上安装任何东西。问题是当我调试核心转储（从远程机器上的死锁或正常运行的进程获得）时，大多数线程的回溯仅显示：
(gdb) bt #0 pthread_cond_wait () 在 ../nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_wait.S:261 #1 0x0000000000000000 在 ?? ()
我正在使用使用“-g -O1”选项编译的静态链接二进制文件。当我在本地机器上中止相同二进制文件的进程时，gdb 可以从核心转储中提取整个堆栈并且没有这样的问题（但是我无法重现死锁）。我的远程机器是 SLES，我的本地机器是 ubuntu。
任何的想法？
编辑：
发现其他人有同样的问题，但仍然没有解决方案：http : //groups.google.com/group/google-coredumper/browse_thread/thread/2ca9bcf9465d1050 （我没有使用 google coredumper，但似乎 google coredumper 失败了有同样的错误，这表明问题可能出在 SLES 11）
我需要使用或不使用某些库来编译我的程序,具体取决于它运行的两个主机中的哪一个.我不知道HOST=在makefile 的右侧使用什么来使我的工作符合我的要求:
ifeq(${HOST},${ADDITIONAL_LIBS_HOST})
ADD_LIBS= ...
${ADDITIONAL_LIBS_HOST} 是来自的主人的名字
echo ${HOSTNAME}
在一个程序中,我有一个M类:
class M{
/*
very big immutable fields
*/
int status;
};
我需要一个M型对象的链表.
三种类型的线程正在访问列表:
消费者数量少于10个.生产者数量可能高达数百个.有一个修饰符.
注意:修饰符可以修改已经消耗的对象,因此存储的消费者项目可以来回移动.我没有找到任何更好的解决方案来解决这个问题(虽然,对象之间的比较是O(1),操作不再分摊O(1)).
表现非常重要.因此,我想使用原子操作或细粒度锁(每个对象一个)来避免不必要的阻塞.
我的问题是:
原子操作是首选,因为它们更轻.我想我必须使用锁来更新析构函数线程中的指针,我可以使用原子操作来处理其他线程之间的争用.如果我遗漏了某些内容并且有理由不能在状态字段上使用原子操作,请告诉我.
我想我不能使用STL列表,因为它不支持细粒度锁.但是你会建议使用Boost :: Intrusive列表(而不是自己编写)吗？ 这里提到侵入式数据结构更难以实现线程安全吗？这对于细粒度锁是否正确？
生成器,使用者和析构函数将根据某些事件异步调用(我计划使用Boost :: asio.但我不知道如何运行修饰符以最小化与其他线程的争用.选项包括:
只有在某些条件成立时,任何此类呼叫才会在列表上运行.我自己的直觉是,我如何调用修饰符之间没有区别.我错过了什么吗？
我的系统是Linux/GCC,我使用boost 1.47以防万一.
类似的问题:使用细粒度方法线程安全删除链表节点
我有一个程序在其中一个线程调用pthread_cond_siganl(或广播)时死锁.该问题在主程序中可100%重现.我无法弄清楚它有什么问题,因此提取了等待和信号被调用的代码片段.但是,无法通过提取的问题再现死锁.
valgrind在主程序上运行不会报告任何无效的读/写或内存泄漏.
我想知道调用时死锁的可能原因是什么pthread_cond_signal.
提取的片段如下.
#include <pthread.h>
#include <math.h>
#include <syscall.h>
#include <assert.h>
#include <stdlib.h>
#include <iostream>
using namespace std;
void Task() {
cerr << syscall(SYS_gettid) << " In Task, sleeping..." << endl;
sleep(5);
}
pthread_mutex_t lock;
pthread_cond_t cond;
bool doingTheTask= false;
void* func(void* ) {
pthread_mutex_lock(&lock);
if (doingTheTask) {
cerr << syscall(SYS_gettid) << " wait... " << endl;
while ( doingTheTask) {//spurious wake-up
cerr << syscall(SYS_gettid) << " waiting..." << endl ;
pthread_cond_wait(&cond, …我在go运行时查看了runtime.c文件
/usr/local/go/src/pkg/runtime
并看到以下函数定义:
void
runtime?pprof·runtime_cyclesPerSecond(int64 res)
{...}
和
int64
runtime·tickspersecond(void)
{...}
并且有很多声明像
void runtime·hashinit(void);
在runtime.h中.
我之前没有看到过这种C语法(特别是带有斜杠的语法似乎很奇怪).这是std C或某种plan9方言的一部分吗？
是否存在使条件变量使用多个互斥锁的机制？我在Linux和pthreads在C++中.
在一个应用程序中,我需要两个互斥量(而不是一个)由pthread_cond_wait()以原子方式获取和释放,但该函数只接受一个.
我有一个名为BlockingManager的类,它有以下方法:
blockMeFor( pthread_cond_t* my_cond, pthread_mutex_t* my_lock, set<int> waitees);
我正在使用它,假设它像pthread_cond_wait一样获取/释放互斥锁.
问题是,为了实现blockingManager,我也需要一个内部互斥锁,这两个互斥锁应该被原子地获取和释放.
这里有一个相关的讨论,它说等待多个互斥锁产生未定义的行为. http://sourceware.org/ml/libc-help/2011-04/msg00011.html
我面临的问题的生产者/消费者模型如下:
我们有多个客户.每个客户都有一些任务.每个任务可能有多个先决条件(在同一客户端或其他客户端的任务中).每个客户端都有一个消费者线程 任务从一个生产者线程分配给客户端.新分配的任务可能有资格在先前任务之前完成.在某些时刻可能没有任务要完成,但如果要完成任务,至少应该完成一项任务.(它应该是节省工作的)
我每个消费者线程使用一个condvar,一旦没有任务要为该线程完成,它就会阻塞.condvar可以通过其中任何一个发出信号
生产者线程分配新任务.
另一个消费者线程完成任务.
我每个消费者使用一个互斥锁来保护生产者和消费者之间的共享数据结构.和一个互斥(内部互斥)来保护多个用户之间的共享数据结构.