小编Xan*_*lip的帖子

防止代码死锁的常见解决方案是确保锁定顺序以通用方式发生,而不管哪个线程正在访问资源.

例如,给定线程T1和T2,其中T1访问资源A然后B和T2访问资源B然后A.按照需要的顺序锁定资源会导致死锁.简单的解决方案是锁定A然后锁定B,无论订单特定的线程将使用哪些资源.

问题情况:

Thread1                         Thread2
-------                         -------
Lock Resource A                 Lock Resource B
 Do Resource A thing...          Do Resource B thing...
Lock Resource B                 Lock Resource A
 Do Resource B thing...          Do Resource A thing...

可能解决方案

Thread1                         Thread2
-------                         -------
Lock Resource A                 Lock Resource A
Lock Resource B                 Lock Resource B
 Do Resource A thing...          Do Resource B thing...
 Do Resource B thing...          Do Resource A thing...

我的问题是在编码中使用了哪些其他技术,模式或常用做法来保证死锁预防？

我想问一些SO'ers他们关于用于索引时间序列的最佳数据结构的意见(也就是列式数据,也就是扁平线性).

基于采样/离散特征存在两种基本类型的时间序列:

1. 定期离散(每个样本采用共同频率)

2. 不规则的离散化(样本在任意时间点进行)

需要的查询:

1. 时间范围内的所有值[t0,t1]

2. 时间范围[t0,t1]中的所有值都大于/小于v0

3. 时间范围[t0,t1]中值范围为[v0,v1]的所有值

数据集包括汇总的时间序列(通过不规则离散化的那种)和多变量时间序列.所讨论的数据集大小约为15-20TB,因此处理以分布式方式执行 - 因为上述一些查询将导致数据集大于任何一个系统上可用的物理内存量.

此上下文中的分布式处理还意味着调度所需的数据特定计算以及时间序列查询,以便计算可以尽可能接近数据发生 - 从而减少节点到节点的通信(有点类似于map /减少范式) - 在计算和数据的短暂接近是非常关键的.

该指数应该能够应对的另一个问题是,绝大多数数据是静态/历史性的(99.999 ...%),但是每天都会增加新数据,想想"在现场传感器"或"市场数据".想法/要求是能够以尽可能低的延迟更新任何正在运行的计算(平均值,garch等),其中一些运行计算需要历史数据,其中一些将超过可以合理缓存的数据.

我已经考虑过HDF5,它对于较小的数据集效果很好/有效但随着数据集变大而开始拖动,前端也没有本机并行处理功能.

寻找建议,链接,进一步阅读等(C或C++解决方案,库)

我想编写一个模板来确定类型是否是编译时的stl容器.

我有以下一点代码:

struct is_cont{};
struct not_cont{};

template <typename T>
struct is_cont { typedef not_cont result_t; };

但我不确定如何创建必要的专业化std::vector<T,Alloc>, deque<T,Alloc>, set<T,Alloc,Comp>等...

我想知道是否有一个可以在C++中使用的matplotlib接口.(也许类似于gnuplot的东西)

我有下面这段代码,作为一个例子,dec_proxy尝试将增量运算符的效果反转到在复杂函数调用foo中执行的类型 - 顺便说一下我无法更改接口.

#include <iostream>

template<typename T>
class dec_proxy
{
public:
   dec_proxy(T& t)
   :t_(t)
   {}

   dec_proxy<T>& operator++()
   {
      --t_;
      return *this;
   }

private:
   T& t_;
};

template<typename T, typename S, typename R>
void foo(T& t, S& s, R& r)
{
  ++t;
  ++s;
  ++r;
}

int main()
{
   int i = 0;
   double j = 0;
   short  k = 0;

   dec_proxy<int> dp1(i);
   dec_proxy<double> dp2(j);
   dec_proxy<short> dp3(k);

   foo(dp1,dp2,dp3);

   //foo(dec_proxy<int>(i),     <---- Gives an error
   //   dec_proxy<double>(j),     <---- Gives an error
   //   dec_proxy<short>(k));      <---- …

我有以下层次结构:

class base
{
public:
   virtual ~base(){}
   virtual void foo() {}
};

template <typename T>
class derived1 : public base
{
   virtual void foo() {};
};

template <typename T>
class derived2 : public base
{
   virtual void foo() {};
};

现在给出一个指向base的指针,我想知道底层是derived1还是derived2.问题是derived1和derived2都可以专门用于许多不同类型,使用dynamic_cast来测试向下转换需要知道模板类型.我最终得到了凌乱,不稳定和不完整的代码:

base* b = new derived1<int>();

if (dynamic_cast<derived1<int>*> ||
    dynamic_cast<derived1<unsigned int>*> ||
    dynamic_cast<derived1<double>*>)
  std::cout << "is derived1";
else if (dynamic_cast<derived2<int>*> ||
    dynamic_cast<derived2<unsigned int>*> ||
    dynamic_cast<derived2<double>*>)
  std::cout << "is derived2";

有没有更好的方法,可以处理任何类型的专业化？

给定大小为N位和K个散列函数的布隆过滤器,其中设置了滤波器的M位(其中M <= N).

是否可以近似插入布隆过滤器的元素数量？

简单的例子

我一直在考虑以下示例,假设一个100位的BF和5个散列函数,其中设置了10位...

最佳情况:假设散列函数非常完美并且为某些X个值唯一映射一个位,那么已经设置了10位,我们可以说在BF中只插入了2个元素

最糟糕的情况:假设哈希函数是坏的并且一致地映射到相同的位(但彼此之间是唯一的),那么我们可以说已经将10个元素插入到BF中

范围似乎是[2,10],其中这个范围内的大概可能是由滤波器的假阳性概率决定的 - 我在这一点上陷入困​​境.

我最近遇到了以下面试问题,我想知道动态编程方法是否有效,或者/和是否有某种数学洞察力可以使解决方案更容易......它与构建ieee754双倍的方式非常相似.

问题: 有N个双值的向量V. 其中向量的第i个索引处的值等于1/2 ^(i + 1).例如:1/2,1/4,1/8,1/16等......

你要编写一个函数,它将一个双'r'作为输入,其中0 <r <1,并将V的索引输出到stdout,当求和时,它将给出一个最接近值'r'的值,而不是任何其他组合来自矢量V的索引

此外,索引的数量应该是最小的,并且在有两个解决方案的情况下,应该优选最接近零的解.

void getIndexes(std::vector<double>& V, double r)
{
 .... 
}

int main()
{
   std::vector<double> V;
   // populate V...
   double r = 0.3;
   getIndexes(V,r);
   return 0;
}

注意:似乎有一些SO'er没有完全阅读这个问题的心情.所以请大家注意以下几点:

1. 解决方案,也就是总和可能大于r - 因此任何策略从r逐步减去分数,直到它达到零或接近零是错误的

2. 有r的例子,其中有2个解,即| r-s0 | == | r-s1 | 并且s0 <s1 - 在这种情况下应该选择s0,这使问题稍微困难一些,因为背包式解决方案往往首先贪婪高估.

3. 如果您认为这个问题很简单,那么您很可能还没有理解它.因此,再次阅读这个问题是个好主意.

编辑(Matthieu M.): 2个例子V = {1/2, 1/4, 1/8, 1/16, 1/32}

• r = 0.3, S = {1, 3}
• r = 0.256652, S = {1}

我有以下一些使用线程和静态变量初始化的C++ 11代码.我的问题是:

什么担保或保证,不C++语言做出静态变量的单初始化 - 下面的代码显示了正确的价值观,但我似乎无法找到在新标准中提到的内存模型应如何线程交互的通道.如果变量变为线程本地？

#include <iostream>
#include <thread>

class theclass
{
public:
   theclass(const int& n)
   :n_(n)
   { printf("aclass(const int& n){}\n"); }
   int n() const { return n_; } 
private:
   int n_;
};

int operator+(const theclass& c, int n)
{
   return c.n() + n;
}

void foo()
{
   static theclass x = 1;
   static theclass y = x + 1;
   printf("%d %d\n",x.n(),y.n());
}

int main()
{
   std::thread t1(&foo);
   std::thread t2(&foo);
   t1.join();
   t2.join();
   return 0; 
}

我正在开发一个接受100k +唯一输入的应用程序 - 为简单起见假设每个输入都是浮点值(a,b,c ......等) - 尽管它们也可以是字符串等.应用程序有很多规则/与这些输入相关的事件/触发器.

例1:

Rule[(a > b) and (c <= d)] --> [execute EventX]

定义1:上述规则说:当输入'a'的值大于'b'的值并且输入'c'的值小于或等于'd'的值时,执行EventX

例2:

Rule[x != x.prev] --> [execute EventZ]

定义2:上述规则说:如果值更新后,如果输入'x'的当前值不等于其先前值(值已更改).执行EventZ

我发现,随着输入数量的增加,以及规则数量的增加,评估"特定"规则并确定是否应该触发事件所需的总计算量正在失控 - 投掷该问题的速度越来越快,而且没有按预期进行扩展.

目前,在每次新的输入更新时,相关的输入/变量在哈希表中查找,该哈希表将变量映射到包含它的规则.随后评估每个规则,如果结果为真或可操作,则异步触发相关事件.

这个问题出现在复杂事件处理领域,遗憾的是,这个领域中的大多数架构使用了上面描述的相同的死角方法 - 可能还有一些与评估/重新评估事物的频率有关的改进.我们的想法是拥有一个能够近乎实时地做出反应的系统.在多个节点上分配规则和输入似乎也不能很好地工作,因为在某些情况下,超过95%的活动规则中存在少数输入.

我希望是否有任何其他SO'ers,知道更好的方法来解决这个问题,数据/结构或算法.

我想到的一个简单的想法是,可以构建一个依赖逻辑推理的列表.

如果有两个规则是这样的:

Rule[a < b] --> [exec E1]
Rule[b >= a] --> [exec E2]

然后对'a'或'b'的更新不应该要求对两者等进行评估,但我发现构建这样的逻辑推理结构非常复杂且容易出错,并且难以完全和严格地测试.

输入可以代表股票价格,温度传感器等.

还要注意,一些输入在时间上受到限制,这意味着规则可能要求变量的状态在特定位置/状态下持续一段时间(例如:MSFT的价格>最后30秒的20美元),目前,这是通过使用值为0或1/false或true的'代表变量'(facade)来实现的(变量的值由单独的机制决定,这通常是规则被触发的结果).

还应该注意的是,由于近实时约束和每秒产生的数据量,使用具有触发器和存储过程的DB的选项是不可能的.