小编Has*_*yed的帖子

问题在底部以粗体显示,问题也通过最终的蒸馏代码片段进行了总结.

我试图统一我的类型系统(类型系统从类型到字符串)和单个组件(由Lakos定义).我正在使用boost::array,, boost::variant和boost::mpl,以实现这一目标.我想让我的类型的解析器和生成器规则统一在一个变体中.有一个未定义的类型,一个int4(见下文)类型和一个int8类型.该变体读作variant<undefined, int4,int8>.

int4特征:

struct rbl_int4_parser_rule_definition
{
  typedef boost::spirit::qi::rule<std::string::iterator, rbl_int4()> rule_type;

  boost::spirit::qi::int_parser<rbl_int4> parser_int32_t;

  rule_type rule;

  rbl_int4_parser_rule_definition()
  {
    rule.name("rbl int4 rule");
    rule = parser_int32_t;  
  }
};

template<>
struct rbl_type_parser_rule<rbl_int4>
{
  typedef rbl_int4_parser_rule_definition string_parser;
};

上面的变体从未定义开始,然后我初始化规则.我有一个问题,导致50页的错误,我终于设法跟踪它,Variant operator=在分配期间使用,而a boost::spirit::qi::int_parser<>不能分配给另一个(operator =).

相比之下,我的未定义类型没有问题:

struct rbl_undefined_parser_rule_definition
{
  typedef boost::spirit::qi::rule<std::string::iterator, void()> rule_type;
  rule_type rule;

  rbl_undefined_parser_rule_definition()
  {
    rule.name("undefined parse rule");
    rule = boost::spirit::qi::eps;
  }
};

template<>
struct rbl_type_parser_rule<rbl_undefined>
{
  typedef rbl_undefined_parser_rule_definition string_parser;
};

蒸馏问题:

#include <string>
#include <boost/spirit/include/qi.hpp> …

编译静态链接静态库的共享对象时遇到了很多问题.此问题仅出现在x84_64平台上.在x86_32上进行相同的编译工作时,我没有任何问题.

也许这是一个特定于操作系统的GCC配置,但我的研究表明它是如何在x86_64平台上运行GCC的.无论如何,我在Ubuntu 10.04 x86_64上使用gcc 4.4.3.

问题是如何解决的？...确保使用-fPIC编译所有静态库依赖项.

问题1: -fpic和-fPIC之间有什么区别(显然-fPIC会在x86上生成更多指令)？为什么后一种类型在x86_64上下文中更相关？

问题2:我的假设是,当您链接静态代码时,您在链接时将函数硬连接到二进制文件中,为什么它需要"位置无关代码"机制提供的间接级别？

问题3:现在如果x86不需要-fpic/-fPIC来链接共享对象与静态存档,为什么在x86_64中需要它？

问题4:即使需要,为什么不隐式提供？我认为突破性变化应该是一个很大的禁忌

以下代码吐出1两次,我期望看到0然后1

def pv(v) :
  print v


def test() :
  value = []
  value.append(0)
  value.append(1)
  x=[]
  for v in value :
    x.append(lambda : pv(v))
  return x

x = test()
for xx in x:
  xx()

我希望python lambdas绑定到一个局部变量指向的引用,在场景后面.然而,情况似乎并非如此.我已经在一个大型系统中遇到了这个问题,其中lambda正在做现代C++的一个绑定的等价物(例如'boost :: bind'),在这种情况下,你将绑定到智能ptr或复制contstruct lambda的副本.

那么,如何将局部变量绑定到lambda函数并在使用时保留正确的引用？我对这种行为非常惊讶,因为我不希望这种语言来自垃圾收集器.

有问题的代码如下所示(l3_e是导致问题的变量):

 for category in cat :
      for l2 in cat[category].entries :
        for l3 in cat[category].entries[l2].entry["sub_entries"] :
          l3_e = cat[category].entries[l2].entry["sub_entries"][l3]
          url = "http://forums.heroesofnewerth.com/" + l3_e.entry["url"]
          self.l4_processing_status[l3_e] = 0
          l3_discovery_requests.append( Request(
            url, callback = lambda response : self.parse_l4(response,l3_e))) …

当前选择: lua-jit.令人印象深刻的基准测试,我已经习惯了语法.编写高性能ABI需要仔细考虑如何构建我的C++.

其他感兴趣的问题

1. Gambit-C和Guile是可嵌入的语言
2. Lua性能提示(可选择使用已禁用的收集器运行,并在处理运行结束时调用收集器始终是一个选项).

背景

我正在研究一个实时高容量(复杂)事件处理系统.我有一个DSL,代表源的事件结构的模式,存储格式,某些特定于域的构造,触发内部事件(构造和驱动通用处理),以及编码始终发生的某些处理步骤.

DSL看起来非常类似于SQL,事实上我使用berkeley db(通过sqlite3接口)来长期存储事件.这里的重要部分是事件处理是基于集合完成的,就像SQL一样.然而,我得出结论,我不应该在DSL中添加通用处理逻辑,而是嵌入lua或lisp来处理这个问题.

处理核心是arround boost :: asio,它是多线程的,rpc是通过协议缓冲区完成的,事件是使用协议缓冲区IO库编码的 - 事件不是使用协议缓冲区对象构建的,它们只使用相同的编码/解码库.我将创建一个包含行的数据集对象,与数据库引擎在内存集中的存储方式非常相似.首先处理DSL中的处理步骤,然后将其呈现给通用处理逻辑.

无论我使用哪种可嵌入的脚本环境,我的处理核心中的每个线程都可能需要它自己的嵌入式语言环境(这就是lua至少在你做多线程工作时需要它的方式).

问题

目前的选择是在lisp ECL和lua之间.请记住,性能和吞吐量是一个强烈要求,这意味着非常需要最小化内存分配:

1. 如果你在我的位置,你会选择哪种语言？

2. 有没有我应该考虑的替代方案(不建议没有可嵌入实现的语言).Javascript v8也许吧？

3. lisp更适合这个领域吗？我不认为lua和lisp在它们提供的方面有所不同.叫我出去:D

4. 我应该考虑其他任何属性(如下所示)吗？

5. 我断言任何形式的嵌入式数据库IO(请参阅下面的示例DSL以获取上下文)使脚本语言调用在数量级上相形见绌,并且选择这两者不会给总体吞吐量增加太多开销.我是在正确的轨道上吗？:d

期望的属性

1. 我想将我的数据集映射到lisp列表或lua表,我想最小化冗余数据副本.例如,如果两个表具有相同的形状,则从一个数据集向另一个数据集添加行应尝试使用引用语义.

2. 我可以保证在我进行lua/lisp调用时,作为输入传递的数据集不会改变.我希望lua和lisp在可能的情况下强制不改变数据集.

3. 在嵌入式调用结束后,应该销毁数据集,创建的任何引用都需要用副本替换(我猜).

DSL示例

我附上了一个DSL供您观看,这样您就可以了解我想要实现的目标.注意:DSL不显示通用处理.

// Derived Events : NewSession EndSession
NAMESPACE WebEvents
{
  SYMBOLTABLE DomainName(TEXT) AS INT4;
  SYMBOLTABLE STPageHitId(GUID) AS INT8;
  SYMBOLTABLE UrlPair(TEXT hostname ,TEXT scriptname) AS INT4;
  SYMBOLTABLE UserAgent(TEXT UserAgent) AS INT4;  

  EVENT 3:PageInput
  {
    //------------------------------------------------------------//
    REQUIRED 1:PagehitId              GUID
    REQUIRED 2:Attribute              TEXT;
    REQUIRED 3:Value                  TEXT; 

    FABRRICATED 4:PagehitIdSymbol     INT8;
    //------------------------------------------------------------// …

更新

我的问题是如何在spring boot中初始化一个孤立的spring webmvc web-app.隔离的Web应用程序应该:

1. 不应该在应用程序类中初始化自己.我们希望通过自动配置在启动器中执行这些操作.我们有多个这样的网络应用程序,我们需要自动配置的灵活性.
2. 能够使用以下接口自定义自身:( WebSecurityConfigurer我们有多个web-apps,每个都以自己的方式执行安全性)和EmbeddedServletContainerCustomizer(设置servlet的上下文路径).
3. 我们需要隔离特定于某些Web应用程序的bean,并且不希望它们进入父上下文.

进展

下面的配置类列在我的META-INF/spring.factories中.

以下策略不会导致运行web-mvc servlet.未设置上下文路径,也未定制安全性.我的预感是我需要包含某些webmvc bean来处理上下文并根据存在的bean自动配置 - 类似于我如何通过包含来启动基于引导的属性占位符配置PropertySourcesPlaceholderConfigurer.class.

@Configuration
@AutoConfigureAfter(DaoServicesConfiguration.class)
public class MyServletConfiguration {
    @Autowired
    ApplicationContext parentApplicationContext;

    @Bean
    public ServletRegistrationBean myApi() {
        AnnotationConfigWebApplicationContext applicationContext = new AnnotationConfigWebApplicationContext();
        applicationContext.setParent(parentApplicationContext);
        applicationContext.register(PropertySourcesPlaceholderConfigurer.class);
        // a few more classes registered. These classes cannot be added to 
        // the parent application context.
        // includes implementations of 
        //   WebSecurityConfigurerAdapter
        //   EmbeddedServletContainerCustomizer

        applicationContext.scan(
                // a few packages
        );

        DispatcherServlet ds = new DispatcherServlet();
        ds.setApplicationContext(applicationContext);

        ServletRegistrationBean …

在嵌入SQLite3并使用内存数据库的应用程序中,是否可以在应用程序的两个运行实例之间复制数据库？我可以通过自制协议复制我的所有数据库访问来手动执行此操作,但它似乎应该在数据库层内完成.

AFAIK当GC正在执行其操作时,VM会阻止所有正在运行的线程 - 或者至少在压缩堆时.这是CLR和JVM的现代实现中的情况(截至2010年1月的生产版本)？请不要提供有关GC的基本链接,因为我了解基本的工作原理.

我假设全局锁定就是这种情况,因为当压缩发生时,引用在移动期间可能是无效的,并且最简单的方法就是锁定整个堆(即,通过阻塞所有线程来间接).我可以想象更强大的机制,但KISS经常占上风.

如果我不正确,我的问题将通过对用于最小化阻塞的策略的简单解释来回答.如果我的假设是正确的,请提供以下两个问题的一些见解:

1. 如果这确实是这种行为,那么像JBOSS和Glassfish这样的重量级企业引擎如何保持一致的高TPS率？我在JBOSS上做了一些谷歌搜索,我期待在APACHE上找到适合网络处理的内存分配器.

2. 面对NUMA式架构(可能在不久的将来),这听起来像是一场灾难,除非进程受到线程和内存分配的CPU限制.

我正在研究一个软实时事件处理系统.我希望尽可能减少代码中具有非确定性时序的调用次数.我需要构造一个由字符串,数字,时间戳和GUID组成的消息.大概std::vector的boost::variant的.

我一直想用alloca在过去类似性质的代码中.然而,当人们研究系统编程文献时,总是会对这个函数调用提出大量警告.就个人而言,我不能想到过去15年中没有虚拟内存的服务器类机器,而且我知道Windows堆栈一次增长一个虚拟内存页面,所以我假设Unices也是如此.这里没有砖墙(再也没有),堆栈就像堆一样可能耗尽空间,那么是什么给出了？为什么人们没有超过阿洛卡？我可以想到许多负责任地使用alloca的用例(字符串处理任何人？).

无论如何,我决定测试性能差异(见下文),并且alloca和malloc之间存在5倍的速度差异(测试捕获了我将如何使用alloca).那么,有变化吗？我们是否应该谨慎对待风并使用alloca(包裹在a中std::allocator)每当我们完全可以确定物体的使用寿命时？

我厌倦了生活在恐惧中!

编辑:

好吧有限制,对于Windows来说这是一个链接时间限制.对于Unix来说,它似乎是可调的.似乎页面对齐的内存分配器是有序的:D任何人都知道通用的便携式实现:D？

码:

#include <stdlib.h>
#include <time.h>

#include <boost/date_time/posix_time/posix_time.hpp>
#include <iostream>

using namespace boost::posix_time;

int random_string_size()
{
    return ( (rand() % 1023) +1 );
}

int random_vector_size()
{
    return ( (rand() % 31) +1);
}

void alloca_test()
{
    int vec_sz = random_vector_size();

    void ** vec = (void **) alloca(vec_sz * sizeof(void *));    

    for(int i = 0 ; i < vec_sz ; i++)
    {
        vec[i] = alloca(random_string_size()); …

template <typename TAG>
fn(int left, TAG, int right)
{
}

fn(0, some_type_tag(), 1);
/* or */
fn(0,int(), 1); // where the primitive, int, is not empty.

编辑:这个问题有两个视角.

1. 函数声明与定义.声明可能没有命名参数,但声明可能会这样做.这不是感兴趣的视角.
2. 该模板在元编程中有所体现.有问题的参数是用于从特征中提取元结构的标记.这就是参数未命名的原因,我只关心编译时信息 - 标签的类型.

/编辑

我的标签通常是空结构,但是在我的代码的某些部分,它们是原始类型的typedef.所以,我很想知道现代编译器是否会实际传递参数.这有两个方面.

1. 调整堆栈大小,考虑未命名参数类型的大小.
2. 实际上用传递的值构造堆栈.

让我们把它保持到gcc 4.5和msvc 2008+

编辑:当我为任何感兴趣的人改变我的设计时,我会在这里放一个github链接.

背景

我更换boost::intrusive,intrusive_set与我自己的实现为64位编译侵入设定的东西3×8个字节的指针到我的容器节点.我的容器有2 ^ 16个节点的限制,所以我可以将它降低到每个节点4个字节,带有2个16位偏移序数(大小减少6倍).

在下面的示例中base是侵入式集合容器.该derived班有一个std::vector<container_entry_type<entry_type> >.显然,对于这种间接级别,我需要在派生中有一堆嵌套的typedef,我想在base中引用它.

ps,容器用于数据描述语言的AST.因此,包含的元素是小数据类型,3 x 8字节非常重要.特别是因为容器用于验证紧密循环中的数据集.

孤立的问题

我想实现以下语义:

template<typename TWO>
class base
{
public:
  void foo(typename TWO::dummy & d);
};

template<typename DUMMY>
class derived
  : private base< derived<DUMMY> >
{
public:
  typedef DUMMY dummy;
};

struct tag{};

int main()
{
  derived<tag> foo;
}

但我无法从基础访问嵌套的typedef.这就是clang对此事所说的话:

main.cc: In instantiation of ‘base<derived<tag> >’:
main.cc:9:7:   instantiated from ‘derived<tag>’
main.cc:20:16:   instantiated from here
main.cc:5:8: error: no type named ‘dummy’ in …