小编Æle*_*lex的帖子

我已经设法从我的应用程序中分叉并执行不同的程序.我正在研究如何等待从exec调用的进程通过管道或stdout返回结果.但是,我可以使用单个fork进行一组进程,还是需要多次fork并再次调用相同的程序？我可以为每个不同的流程获得PID吗？我希望我的应用程序调用相同的程序,我目前正在调用多次但使用不同的参数:我想要一组8个进程运行同一个程序并通过管道返回结果.有人可以指点我正确的方向吗？我已经浏览了linux.die手册页,但是在描述中它们非常简洁和神秘.是否有电子书或PDF格式我可以找到详细信息？谢谢!

pid_t pID = fork();
 if (pID == 0){
  int proc = execl(BOLDAGENT,BOLDAGENT,"-u","2","-c","walkevo.xml",NULL);
  std::cout << strerror(errno) << std::endl;
}

例如,我如何通过PID控制哪个子(根据参数xml文件)获得了哪个结果(通过管道或标准输出),从而采取相应的行动？我是否必须将子进程封装在一个对象中,然后从那里开始工作,还是可以将它们组合在一起？

首先让我说我已阅读本教程并已阅读此问题.我的问题是:

1. 堆栈有多大？处理器/体系结构/编译器是否依赖？

2. 有没有办法确切知道我的函数/类堆栈有多少内存可用,以及当前使用多少内存以避免溢出？

3. 在现代计算机上使用现代编译器(比如gcc 4.5)(比如6 GB ram),我是否需要担心堆栈溢出或者它已成为过去？

4. 实际的堆栈内存是物理上在RAM上还是在CPU缓存上？

5. 与堆访问和读取相比,堆栈内存访问和读取速度有多快？我意识到时间是PC特定的,所以比例就足够了.

6. 我已经读过在堆栈上分配大变量/对象是不可取的.太大了多少钱？这个问题给出了win32中一个主题的1MB的答案.Linux amd64中的一个线程怎么样？

如果已经提出并回答了这些问题我很抱歉,欢迎任何链接!

我有这个小片段:

Action* newAction(Agent& a, ACTION_MODE& m)
{
  Action *new_action;
  do
  {
    new_action = new Action(a,m);
  }
  while (!state->addAction(new_action));
  return new_action;
}

state->addAction(Action *a); 如果添加*a,则返回true;如果*a未添加,则返回false(检查*a是否已存在).

现在,我知道很多人认为goto被认为是邪恶的,所以,在上面的代码片段中,在每个循环中重新分配new_action而不删除它,是不是错了？

以下片段不会更"明智"吗？

retry :
    Action *new_action = new Action(a,m);
    if (state->addAction(new_action))
    {
      return new_action;
    }
    else
    {
      delete new_action;
      goto retry;
    }

如果这看起来很简单,我很抱歉,这是我一段时间以来一直想知道的事情.什么是正确的,删除​​内存然后重新分配,或者我可以立即重新分配？

编辑:

会更好吗？

Action* newAction(Agent& a, ACTION_MODE& m)
{      
  // state will only allow an action to be added if it does not already exist
  Action *new_action = new Action(a,m);

  if (!new_action) return 0; …

我有点腌渍.我知道从块中调用[self methodName]会导致保留周期.

但是在这个类中由于多线程,我不能允许执行块从块以外的任何其他地方访问的方法,因为它可能会导致严重的问题.

当前代码:

 if (_getRunning==NO){
        __weak SyncArrayMT *_weak_self = self;
        _get_t = ^void (void){
            _weak_self->_getRunning = YES;
            NSArray *objects = [_weak_self get:getQuery 
                                usingClassCtor:ctor 
                                 withAuthBlock:authBlock];
            if (_weak_self.getBlockCb)
                _weak_self.getBlockCb(objects);
            _weak_self->_getRunning = NO;
        };
    }

确实如此,它称之为[self getmethod].虽然调度块可以运行此方法,但我不希望此类之外的任何内容调用此方法.那么,可以这样覆盖这个继承的方法:

- (NSArray *) get:(NSString *)getQuery usingClassCtor:(initBlock)initCb withAuthBlock:(authenticate)authBlock
{
    NSLog(@"Direct call to get is not allowed - use the threaded method");
    return nil;
}

然后将块更改为:

        _get_t = ^void (void){
            _weak_self->_getRunning = YES;
            NSArray *objects = [super get:getQuery 
                                usingClassCtor:ctor 
                                 withAuthBlock:authBlock];
            if (_weak_self.getBlockCb)
                _weak_self.getBlockCb(objects);
            _weak_self->_getRunning = NO;
        }; …

我正在进行人工智能的博士研究,而且我已经开始使用CUDA库作为我的测试平台了.我以前玩过CUDA,我对GPGPU的工作原理有基本的了解,但我对浮点精度感到不安.

看看GTX680,我看到FP64:1/24 FP32,而特斯拉的完整FP64为1.31 TFLOPS.我很清楚,一张是游戏卡,而另一张是专业卡.

我问的原因很简单:我买不起特斯拉,但我可能得到两个GTX680.虽然主要目标是拥有尽可能多的CUDA内核和内存,但浮点精度可能会成为一个问题.

我的问题是:

1. Gaming GPU中的小浮点精度有多大妥协？
2. 是不是32位浮点精度的1/24太小了？特别是与之前的费米1/8 FP32相比
3. 由于浮动精度较小,是否存在计算结果错误的风险？即在SVM,VSM,Matrix操作,深度信念网络等中,由于浮点较小,我可能会遇到算法结果的问题,还是仅仅意味着操作需要更长时间/使用更多内存？

谢谢 !

通过在类的命令中调用保存函数(ala boost-serialize)可能会产生什么负面/未定义的行为？

我正在使用C++ 11和std :: hash算法.我想知道,使用了什么实际的哈希实现？我会假设MD5或SHA,但我不能从互联网上挖掘任何信息.

另外,我想知道散列的实际返回位宽,因为我必须将它存储在MySQL中.

最后,是否最好使用std :: hash,比如说其他一些库如crypto ++？

我想把自己的头缠在我已经想了很长时间的事情上。假设我有一堂课Base

class Base
{
public:
    virtual ~Base(){}
    virtual bool operator== ( const Base & rhs ) const;
};

现在，另一个类继承自它。它有两个相等运算符：

class A : public Base
{
public:
    bool operator== ( const A & rhs ) const;
    bool operator== ( const Base & rhs ) const;
private:
    int index__;
};

还有另一个也继承自Base的类，它还具有两个相等运算符：

class B : public Base
{
public:
    bool operator== ( const B & rhs ) const;
    bool operator== ( const Base & rhs ) const;
private:
    int index__;
};

这是我的理解（不一定正确）。我只能使用第一个运算符来检查相同的类对象是否相等。但是，我可以使用第二个运算符来检查它们是否是相同类型的类，然后是否相等。现在，存在另一个类，该类环绕Base的指针，但是这些指针是多态类型A或B。 …

在哪里或如何获得find_package支持的软件包的完整列表？我了解这些是模块，因此它们必须位于某个地方？我正在建立用于C ++ / ROS的在线自动包装系统，并且需要详细了解可用清单（作为包装）。

首先我要说的是,我仔细阅读了关于SO的所有类似问题:

1. 确定每个块的线程数和每个网格块数
2. 每个SM的线程数,每个块的线程数
3. CUDA块和线程
4. 变形和最佳块数

我的目的是尝试动态计算(而不是硬编码值)我正在开发的前馈神经网络库.

我的数据不是正方形点阵(矩阵),正如我所看到的大多数例子一样,而是两个向量产生矩阵,行到行的行数不等:

float x[6] {1.f, 1.f, 0.f, 1.f, 1.f, 0.f}; 
thrust::device_vector<float> in_vec( x, x+6 );
float y[9] {1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f};
thrust::device_vector<float> w_vec( y, y+9 );
thrust::device_vector<float> o_wec(9);
thrust::device_vector<float> mtx_vec( 9 * 6 );

float * i_ptr = thrust::raw_pointer_cast( in_vec.data() );
float * w_ptr = thrust::raw_pointer_cast( w_vec.data() );
float * out_ptr = thrust::raw_pointer_cast( mtx_vec.data() );

dim3 threadsPerBlock(9,6);
dim3 numBlocks(1,1);
prop_mtx<<<numBlocks,threadsPerBlock>>>( w_ptr, i_ptr, out_ptr, 6 );

和内核:

__global__ void …