显示标签为“架构”的博文。显示所有博文
显示标签为“架构”的博文。显示所有博文

2018-07-21

民主集中制原则

考虑一个场景.

一个节点initiator,通过yarn提交一个appmaster.
然后appmaster去启动其他另外的cluster,比如prestor的coordinator和worker.

那么这时候就有这么一个从属关系.
initiator<-appmaster<-coordinator/worker.

在最初的方案的时候,appmater是以unmanaged的方式提交的.
也就是实际上是
initoator(appmaster)<-coordinator/worker的形式.

这个结构主要有两个问题.
一个是实现上,局限了只能有一个presto cluster.
虽然这点也不是架构决定的,可以重新实现.

主要是第二点的.
在initiator挂掉之后,虽然presto cluster可以继续存在.
但是没有一个比较好的方式把presto cluster的信息找回来.

因为即使在yarn cluster层面得不到实际container的各个service端口.
自然也就没办法做进一步的事情.

而managed appmaster的结构在于,至少还有appmaster这个可寻址的入口可以找到presto cluster的信息.
因为存在一个appmaster的register信息在yarn cluster层面.

所以,当initiator挂掉重启之后是有办法join回去的.
而appmaster本身在yarn上面存在一个自动拉起的机制,所以问题也不大.
至于coordinator和worker的拉起则可以交由appmaster去维护.

或者给initiator.
虽然不太和逻辑就是了.

所以问题在于怎么实际地让各个部分join回去.

这里里面的airlift framework有几个比较有意思的设计点或者说概念.

一个是discovery.
一个是inventor.
还有一个是announcer.

discovery就是所谓的微服务架构当中常见的name service了.
announcer对应的就是这个service的register/announcer了.

而inventory是个比较有趣的实现.
有时候跟discovery是interchangeable的.
但也并不完全是一回事.

区别主要在bootstrap的过程.

逻辑上来说,discovery的bootstrap uri是根据inventory拿到的.
而inventory的获得,一个途径是通过discovery的uri对应的service获得的.

所以这里有一个循环依赖的问题.

不过从实现上来说,inventory是dominated的.
所以如果它没设置,discovery还是可以自己起来的.
然后通过其他一些手段让两者一致.

还有一个比较重要的机制是airlift的discovery的replicate.
它会定义的将自身的nameservice同步到这个nameservice里的其他discovery中去.

也就是逻辑上来说,所以的discovery service都是eventually consistent的.

因此,利用这一点的话,可以让initiator/appmaster/coordinator这些discovery host共同export一个服务.
并互相announce这个服务.
这样的话,任何一个挂掉都可以从其他两个那里获得需要的service列表.

而且这里有个比较关键的点就是.
除了coordinator的地址是随机的之外,initiator和appmaster都是可确定寻址的.

但是这个服务不能是discovery服务.

因为如果是的话,presto cluster的信息也会出现在initiator上.
这样带来的问题就是这样事实上做不到多个presto集群.
毕竟实际上都是announce到同一个discovery/nameservice里.

事实上,这里存在一个类似union/联邦的制度.
各个discovery节点实际上是类似于一个联邦州的概念.
组成一个united states.
下属的各个presto cluster或者其他whatever cluster则是每个government下的实际组织架构.

实际上就是一种职责的分层涉及概念.

一些相同的职责的state作为一个class.

或者说,每一个具体的异构的function的government可以通一个high level的class label(HLCL)联系起来.

这个HLCL实际上是一个restricted/limited的responsibility/power representation.
它是一种有限职责的角色属性.
履行的是一种相对固定和松散的职责.

更多的是一种协调和平衡边界的属性/作用.

因为如果没有这个boundary在的话,下面的每个具体的functional agency都需要自己去独立的识别其他cluster下的东西.

也就是是leveled tree和fully connected graph的区别.

所以某种程度上来说,民主集中制也不算是一个特别矛盾的概念.







2017-11-27

coroutine的一些问题

为了绕开繁琐的发布流程,选了python套hadoop的pb做rpc.
主要还是走coroutine的方式.

在一些场景夹杂了callback.
主要是为了一个逻辑里访问访问多个不同服务的时候尽可能得减少block.

只是单纯yield的话,叙事还是单线条的.

比如从yarn拿一批application的信息过来,然后拿对应的配置文件路径,然后读写.

纯粹coroutine的话,大概就是for一下application然后逐个yield getconfig.
再发起read请求,继续yield.

这样的话,至少理论上可以并行发出去的请求只能串行等待了.

当然,一个折中的办法是阶段batch得yield.
就像做map reduce一样,人为分出synchronize point去集中batch yield一个stage.

而且从实现上来说,考虑到coroutine是单线程形式.
要从非IO流程激活IO流程只能人为再加一个yield先切出去给IO一个启动的机会再切回来.

这多多少少不是很符合直觉.

而比较intuition的做法就是直接加callback.
毕竟when ready的语义算是最少认知负担的了.
并且天然地就是一条条并行的处理流水线形式.

尽管实现上并没有什么太本质的区别.

callback的另一个好处或者说coroutine容易犯的一个错就是context的有效性问题.

从形式上来说,callback是一个limited的environment.
所以会比较容易地迫使去带入context,并保持其有效.
至少从个人习惯上来说是这样.

但写coroutine的时候容易有一个错觉.
就是天生的单线程线性形式.
容易陷入写串行代码的一个思路.

比如以写blocking IO的风格写coroutine.

一个例子就是直接持有self.stream去反复做读写.

这里的一个问题在于虽然coroutine保持了代码组织层面的线性执行.
但实际上来说,每一次yield触发的都是隐性的context switch.

也就是说,yield前后的reference指向就存在类似多线程情况下的concurrent modification问题.
上下两行代码的实际指向存在差异.

尽管这个可以从一个local reference来解决.
但始终无法规避前后状态会有不一致的形式的存在.

而这个对于coroutine作为提供一种简化的并发编程模型的初衷是有所违背的.

并且,为了尽可能地enforce这种local reference的做法.
在相关的API调用的接口设计上就可能需要显示的要求传入需要的context.

当然,这可能只是个风格取舍问题.

不过至少从这个层面上来说,跟callback的隔离机制还是某种程度上一致的.

但至少从简化模型的层面来说,coroutine算是没有什么意义的.

因为并行模型的核心要就是并行处理.
强行地约束成一个线性执行条件/形式的话,多多少少算是一种自欺欺人的方式.

相比之下,goroutine算是一种比较好的折衷方式.

原始的callback的when ready虽然是最符合直觉的.
但也存在为人诟病的组织形式上的嵌套callback hell的问题.

虽然可以通过注册一种binding/routing的形式,减少这种欠优雅性.
但随之而来的是叙事流程上的打散,重构,再打散的反复过程.

一个例子就是event机制.

形式上来说,就是通过一个key或者envelope去做mail routing.

相对于直接的when ready来说,感觉上多了一层可有可无的多余描述.
因为本质上来说,event名称成为了具体流程的一个代号索引.

而这个索引,在很多语言和实现里是有些无谓的.

作为对比的goroutine.
形式上就是去掉了不必要的key索引的event dispatcher.

事实上,从意图上来说就是把blocking的东西从当前执行环境移除.

这一点跟coroutine来说,算是一种哲学层面的不同.

因为coroutine虽然同样是基于把booking从当前环境移除的理念.
但做法上是为了保持线性模型.

而goroutine则更像是纯粹的把blocking的东西扔出去彻底不做.
目的是保持当前执行流程里不存在可能阻塞的东西.
然后在实现上提供一个双生的环境,只做blocking的东西.

从直觉上更符合硬件形式.
把实际的IO等操作offload到外围并行设备处理.






2009-12-05

go杂记

  终于有空看看go的tutorial.
  
  粗鲁看下,开始并没觉得有什么新意.
  很中规中矩的语法.

  当然,少不了带有python的一点风格.
  或者也不能完全说是python的风格,而是类动态语言的风格:
  运行时类型绑定.
  
  在基本数据类型方面,算是正式把c/c++里的一些潜规则内置为语言基本属性了.
  比如uint,int32等.
  既然需要明确数据类型大小,那就直接上升为语言特性好了.

  注意到它们之间是不能直接转换的.
  这个也许是出于安全考虑?
  尤其是32和64以及有符号和无符号之间,隐式转换应该确定为一个怎样的效果呢?
  不能确定,于是就限制为只能显式手工转换了.

  在众多常见的数据类型里,还有一个是string.
  这个应该算是必不可少的一个类型吧.
  跟其他语言稍微有点不同的是,string是不可写的.
  也就是说,对于实际上string底层所指向的内存区域是不可写的.
  至少在语法上是如此.
  
  按照文档上的说法,其实就是const的语义.

  值得注意一下的是map这个类型.
  在所知的大多数语言里都提供有map功能,但是作为一个内置数据类型,go应该算是比较特殊的一个.
  但是想想.go的创造者和推动者是google,想想google搜索下面的mapreduce就明白了.
  很好奇go底层会如何实现这个map,让他便捷快速轻量而又泛型.

  不过泛型map应该归功于语言本身的动态属性吧.
  很好奇一个据说有gc功能的编译型语言,在没有虚拟机的基础上,是如何做到gc的?
  是在每个runtime上构建一个轻量gc么?

  同时存在的还有称为channel的东西.
  一个类似线程安全的队列或者pool.
  有着erlang的风格.
  尤其是配合go特色的函数定义--多返回值. 
  某种程度上,一眼看上去跟erlang是何其相似.
  不同的是erlang是functional programming language,没有所谓的变量.一切都是可推导计算的.

  有一点比较有意思的是go对于interface的定义.

  通常的oo编程,都会有比较严格的类层次关系.
  也就是说子类和父类之间会有比较明显的is关系.
  从语言角度上,通常这种is约束或多或少地会在语法上有所约束.
  比如java里的extends,implements.

  如果设计之初没有考虑到这种类层次关系,而后期需要让其重构符合的话,势必会对源代码产生影响.
  即使当初比较有远见地采用了统一接口.
  但是,不能保证接口的继承关系能覆盖特定特征的集合.

  而go的作法很巧妙,也很天才.
  既然这种is的关系是抽象出来的,那么,并不需要过多地把它变成语言上面的一种强约束.
  因为毕竟,这种抽象依据角度和站立的层面不同.

  于是,go选择了很松散的is关系定义:
  type Sample interface
  {
       sampleFunction( parameter Type1 , ... )(return_item Return_Type1 ...);
  }

  只需要对以及由的类进行统一抽象,那么即便是在后期,也可以做出不同的is关系.
  更多的时候,这是一种组合式的is构建方式.

  对于一些敏捷开发方式来说,这个对于迭代式建模开发其实是一件利器.
  虽然,某种程度上说,需要这种方式的设计,本身也并不能算是一种非常良好的架构.

  但是,却能产生一个良好的架构.
  毕竟,从开始,需要限制的条件就不多了,于是后期系统少了更多的限制,也就多了更多的自由.
  这就是所谓架构的伸缩性.
  过多的假设是制约的是未来发展的弹性空间.

  且不说这个interface的风格,至少个人是比较喜欢的. 
  至少觉得描述能力比较强.
  尤其是做一些REST风格的,或者需要自我描述性比较强的场合.

  一个或许能动态解析,甚至动态层次化的结构的特性,多少算带给人新的思路.

  如同当初erlang带来的绕道的思路一样.
  
  不过,话说回来.
  go也许很适合google,但是google能不能把它发展起来,还持观望态度.
  虽然据一些测试,go对于高并发时候的性能还是很稳定的.
  但不出色.

  而且如interface的概念能让人眼前一亮,但似乎并不能找到很好的工程化的模式.
  也许,这需要时间吧.

  毕竟,在go之前,google也尝试了一个类java的noop.
  后来似乎没什么动静了. 
  也许是感觉跟jdk7的某些特性冲突了吧.
  

2009-10-13

从开心农场谈起

  传腾讯买断开心农场.

  想想其实很符合腾讯既有的策略.

  毕竟,QQ之于腾讯已经发展到了windows之于微软的地步.
  而腾讯也很明显地,在发展的轨迹上跟微软是相似的.

  平台为王的战略.

  在陆续推出了几个好的软件和服务之后.
  或者说在抄了几个号的软件和服务之后,QQ的平台做得更大了.

  将现有的QQ用户导一部分到新的应用中,于是,这些应用从一开始就有了高的人气.
  而人的猎奇心理也会带领相当部分QQ之外的人参与到这个应用中来.
  而这个应用如果恰好又是跟QQ绑定的话,那么,腾讯的抄,其实是将其他类型的非QQ用户"抄"了过来.

  于是,只要腾讯能做出来,就能将任何类型的用户整合进来,成为腾讯如何服务的用户资源储备.

  这是一个良性的异常完美的循环.
  QQ用户为QQ新产品提供源源不断的用户群.
  
  某种程度上说,只要腾讯做一个产品,就不愁没人用,不愁没有用户.

  这便是平台的魅力.

  所以,基于这一点,腾讯买断5分钟的开心农场很正常.
  而且,有数据页显示开心农场的相当部分盈利来源于QQ农场.

  说白了QQ农场的火爆,一个方面是产品设计确实完美,一方面也是有QQ用户这个几乎取之不尽用之不竭的用户来源.
  因此,某个程度上来说,是QQ在养着农场,是QQ掀起全国的偷采风潮.
  
  这样,腾讯自然会打小算盘.
  毕竟,按照现在的趋势,只要运营农场就必然有源源不断的钱收,与其在这个由自己制造的风潮里让别人获益,不如自己独吞.
  所以,买断农场也是可以理解的.
  关键在于农场还能火多久.

  想想农场为什么能火.
  
  农场在游戏的玩法上给了人两条路走.
  要么偷采,要么做老实农民.
  从表现上看,这是似乎是个很简单的游戏,偷采种菜.
  但是仔细想想,其实这是一个"开放"的游戏世界.

  想想一些经典游戏,尤其是RPG游戏的共同之处.
  那便是开放性.自由度.

  让尽可能多的人投入到游戏所设定的情景里,这便是RPG的精髓,也是所有游戏应该追求达到的目的.
  参与性,投入感,是游戏的首要准则.

  而农场显然用了一个大巧若拙的形式,达到了这个目的.
  想想偷菜对应的是什么.
  人性里的阴暗面.
  而种菜呢.

  没错,是人性里积极的一面.
  "劳动最光荣"
  通过劳动,可以得到各种各样的东西.

  可以说,种菜和偷菜,就人性来说,已经囊括了所有类型的用户.
 
  有时候,最复杂的东西就是最简单的东西.
  
  因为其简单,所以不确定因素便多.
  也就意味着结果也随着变得多样.

  WOW之所以受人推崇便在一其高自由度.
  而这一切都是受益于wow的"松散"性.
  没有过多的限制各种各样的东西,包括肢体动作伤害环境等.
  一切都有着很好的扩张性,极力模仿着现实世界.
  在物件的粒度上,尽可能地让所有东西都能够演算出来,而不是靠诸多的条件限制它.
  不像一些游戏,到了悬崖边却发现其实是掉不下去的.

  忽然想,其实所谓软件架构的灵活性,其实来源于需求的设计.
  明确的需求是建立可扩展软件的基础.

  因为需求的改变其实是不受限制或少收限制的.
  而软件,或者说代码,毕竟是成文的.
  改起来不是说说就完了的.

  或许这也是设计模式存在的理由.
  为了尽可能应付不同的需求变更所总结出来的best practice吧.

投其所好

最近看了持械入宋,发觉AI的发展或者说经济化还是非常一日千里的. 虽然说短剧本身也不是什么新事物了. 甚至AI制作也不是最近才有的. 只是从质量上来说,还是看得出来是有区分度,或者说ROI门槛了的. 这片虽然从服化道方面来说还是普通的AI剧,甚至剧情大半夜还是传统的龙王归来模式....