小编Mar*_*dik的帖子

我想使用jmap或诊断一些意外的 OOM 错误jcmd。不幸的是，这些工具在 CI 管道中并不容易使用，因为我必须在后台启动 JVM 应用程序，以某种方式获取其 PID，然后获得正确的时间以使结果有用。

因此，我尝试从 JVM 应用程序启动它们，该应用程序将被诊断为 \xe2\x80\x94 程序化自拍。

在代码中的适当位置，我启动jmaporjcmd作为一个新进程：

val process = ProcessBuilder("jcmd", getPID(), "GC.class_histogram")\n    .redirectOutput(ProcessBuilder.Redirect.PIPE)\n    .redirectError(ProcessBuilder.Redirect.PIPE)\n    .start()\n\nprocess.waitFor(2, TimeUnit.MINUTES)\n

不幸的是，这两个工具的代码都挂起。系统监视器显示 JVM 应用程序和应用程序都jcmd在休眠。jcmd但是，当我在睡眠 JVM 上使用时：

jcmd 37058 GC.class_histogram\n

我立即得到所需的直方图。

知道发生了什么事吗？

我正在寻找一个具有线性代数标准功能的库.如行列式,矩阵逆,乘法......但是通用的.

Octave具有完美的双精度和复杂算术库,但我需要能够改变算术的实现.

我试图将GMP数字库与特征矩阵库一起使用.我尝试实例化模板:

Matrix<typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime>

同

Matrix<mpz_class, 3, 3> matrix;

其中mpz_class是GMP库中的数字类.

我收到编译器错误:

 /usr/include/eigen3/Eigen/src/Core/MathFunctions.h:409: error: 
 invalid static_cast from     
 type ‘const __gmp_expr<__mpz_struct [1], __mpz_struct [1]>’ 
 to type ‘int’

当我检查Eigen库的源代码时,我发现问题是mpz_class在这个模板中不能是static_cast -ed到int:

template<typename OldType, typename NewType>
struct cast_impl
{
  static inline NewType run(const OldType& x)
  {
    return static_cast<NewType>(x);
  }
};

我该如何绕过这个问题？我知道如何在运行时将mpz_class转换为int,但它必须由编译器完成,因为static_cast是编译时.

这是我的代码的简化版本:

template<typename TIterator>
TIterator findMaximalPosition(TIterator begin, TIterator end)
{
    TIterator result(begin);
    for (TIterator it = begin + 1; it != end; ++it)
    {
        if ((*it)->value > (*result)->value) // Here I just need to change to "<"
            result = it;                     // to get a findMinimalPosition
    }
    return result;
}

template<typename TIterator>
TIterator findMinimalPosition(TIterator begin, TIterator end)
{
    // almost the same
}

这只是一个简化的例子.我的代码是满的,其中两个功能都是一样的,除了一个地方<或>签名,或是否++或--应该被使用.

我的问题是:

有没有一种方法可以减少代码中的重复

1. 破坏可读性
2. 降低性能？

我正在考虑使用指向运算符的指针(<或者>)作为模板参数.这不应该降低性能,因为指针将是编译时常量.是否有一些更好或通常使用的方式？

编辑: …

我想a的内部std::vector是一对指向被占用内存的开始和结束的指针,以及一个指定属于向量的内存数组长度的整数.因此,交换两个相同大小的向量应该只需要3个内置类型的交换.

但是我几乎从不使用std::array,因此我不知道如何想象它的内部.直觉上,由于编译器已经知道数组的大小,因此不需要存储数组的末尾或预分配内存的大小,因此其内部应该只是1个指针.因此,成本应该只是1内置类型交换.

相反,文档说成本是元素数量的线性.为什么会这样？

2011年,该补丁中提交了对Eigen的移动支持.但是我在Matrix头文件中找不到移动构造函数.此外,Eigen网页仍然将移动语义列为"待办事项".所有这些表明补丁尚未提交到发布版本

此测试程序证明移动构造函数保持移动的对象不变.

#include <iostream>
#include <utility>

#include <eigen3/Eigen/Dense>

int main()
{
    Eigen::VectorXd first = Eigen::VectorXd::Constant(3, 3.14);
    std::cout << "first\n" << first << std::endl << std::endl;
    Eigen::VectorXd other = std::move(first);
    std::cout << "first\n" << first << std::endl << std::endl;
    std::cout << "other\n" << other << std::endl << std::endl;
    return 0;
}

输出是:

first
3.14
3.14
3.14

first
3.14
3.14
3.14

other
3.14
3.14
3.14

如何从Eigen 3.2.0中的上述补丁中启用复制删除移动功能.？

编辑:

似乎特征类的移动语义没有任何问题.但是,只有 …

我编写了这个脚本来从集群计算机的节点获取数据：

...
for machine in ${machines}
do
    echo "compressing data from: " ${machine}
    oarsh ${machine} "tar -zcf data_${machine}.tar.gz /tmp/data" &
done 

我运行了脚本，当我回来时我得到了这个：

compressing data from:  machine1
...
compressing data from:  machineN
me@chinqchint-30:~$ tar: Removing leading `/' from member names
tar: Removing leading `/' from member names
tar: Removing leading `/' from member names
tar: Removing leading `/' from member names
tar: Removing leading `/' from member names
...

Run Code Online (Sandbox Code Playgroud)

而且我没有收到提示。

我使用第二个终端登录，可以看到所有.tar.gz文件都已创建，但我很担心，因为我没有拿回命令行的控制权。我可以简单地终止脚本吗？

我试图解决相对简单的问题,即能够将double写入文件然后再次将文件读入double.基于这个答案,我决定使用人类可读的格式.

根据这个问题,我成功地规避了一些编译器对nan和[ - ] infinity的问题.对于有限数字,我使用std::stod函数将数字的字符串表示转换为数字本身.但有时解析会因数字接近于零而失败,例如在以下示例中:

#include <cmath>
#include <iostream>
#include <sstream>
#include <limits>

const std::size_t maxPrecision = std::numeric_limits<double>::digits;
const double small = std::exp(-730.0);

int main()
{
    std::stringstream stream;
    stream.precision(maxPrecision);
    stream << small;
    std::cout << "serialized:    " << stream.str() << std::endl;
    double out = std::stod(stream.str());
    std::cout << "de-serialized: " << out << std::endl;
    return 0;
}

在我的机器上,结果是:

serialized:     9.2263152681638151025201733115952403273156653201666065e-318
terminate called after throwing an instance of …

我有一个模板,它为类增加了一个特定的能力:

template <Class ReceiverOfAbility>
class Able : public ReceiverOfAbility, SomeOtherClass
{
...
}

然后我有一个标准的树状继承:

class Base
{};

class Derived1 : public Base
{};

class Derived2 : public Derived1
{};

...

但是在树的某个地方有一个"向后的分支"

class Derived2WithAbility : public Able<Derived2>
{};

假设我有:

 Base* basePointer = new DerivedWithAbility;

我怎样才能投basePointer给SomeOtherClass在运行时？dynamic_cast不起作用.问题是会有很多派生类,我不知道在树中哪个类继承了这个能力.我需要在树中搜索继承Able发生的地方.

有任何想法吗？

编辑:

我试过了

dynamic_cast<SomeOtherClass*>(dynamic_cast<Derived2WithAbility*>(basePointer))

但我得到:

error: ‘SomeOtherClass’ is an inaccessible base of ‘Derived2WithAbility’

任何想法为什么？

我有一个

class Widget;
std::list<Widget*> listOfPointers;

其中listOfPointers可能包含两个或多个指向同一对象的指针.所有指针都指向在堆上逐个创建的对象,而不是同一数组的成员.

我怎样才能摆脱重复？

我试过了:

listOfPointers.sort();
listOfPointers.unique();

但这是未定义的行为,因为在我的问题中没有为指针定义operator <.

我可以使用定义的运算符==将每个指针相互比较,但这会导致二次复杂度.

鉴于类型TArgument和TFunctor,我怎么能找出导致调用的一个实例的类型TFunctor与类型的参数TArgument？

这是我笨拙,肮脏的解决方案:

template <class TFunctor, typename TArgument>
class ReturnValue
{
public:
     typedef decltype(functor_(arguent_)) Type;

private:
     static TFunctor functor_;
     static TArgument arguent_;
}

但它的工作,既TFunctor和TArgument需要是缺省构造的.

有没有更好的办法？

我很难理解处理器的时间.该计划的结果:

#include <iostream>
#include <chrono>

// the function f() does some time-consuming work
void f()
{
    volatile long double d;
    int size = 10000;
    for(int n=0; n<size; ++n)
       for(int m=0; m<size; ++m)
           d = n*m;
}

int main()
{
    std::clock_t start = std::clock();
    f();
    std::clock_t end = std::clock();

    std::cout << "CPU time used: "
              << (end - start)
              << "\n";
}

似乎在210 000,220 000和230 000之间随机波动.起初我很惊讶,为什么这些离散值.然后我发现std::clock()只返回大约处理器时间.因此,返回的值可能std::clock()会舍入到10 000的倍数.这也可以解释为什么CPU时间之间的最大差异为20 000(第一次调用时为10 000 ==舍入误差,第二次调用为std::clock()10 000).

但是,如果我换到int …

根据这篇文章和这个问题的答案,用于阿波罗11号任务的软件,是第一个登陆月球的人,是用大会写的.

我觉得这很令人震惊,因为该项目始于1960年,任务发生在1969年.到目前为止,已有几种高级编程语言可供使用.例如Lisp,这是一种相当高级的语言,即使是垃圾收集,现在仍然在使用.

假设垃圾收集的高级语言减少了编程中人为错误的可能性以及当局的高风险规避,为什么管理者会承受如此巨大的危险？