etcd网络层(六)——模拟etcd网络层的stream通道维护长连接

CentOS 7 搭建 Kubernetes 1.10 集群:kubeadm 实战指南 Kubernetes 是容器编排的事实标准,其核心在于控制平面组件(如 kubelet、kubeadm、apiserver)与底层操作系统及容器运行时的深度协同。理解 CRI(Container Runtime Interface)原理和版本兼容性,是构建稳定集群的前提——尤其在 CentOS 7 这类长期支持、内核为 3.10、systemd 219 的政企主流环境中。kubeadm 作为官方推荐的集群初始化工具,通过预检机制将常见故障前置暴露,显著提升部署确定性。本文聚焦于 Kubernetes 1.1 阅读详情

代码如下:

package main

import (
	"io"
	"log"
	"net"
	"fmt"
	"sync"
	"time"
	"strings"
	"strconv"
	"net/http"
	"encoding/json"
	"encoding/binary"
)

func main() {
	peerURL1 := "http://127.0.0.1:8081"
	peerURL2 := "http://127.0.0.1:8082"

	id1 := getPid(peerURL1)
	id2 := getPid(peerURL2)

	//开启节点1
	tr1 := &Transport{}
	tr1.Start(int64(id1))
	go func() {
		err := http.ListenAndServe(":8081",tr1.Handler())
		log.Fatal(err)
	}()



	//开启节点2
	tr2 := &Transport{}
	tr2.Start(int64(id2))
	go func() {
		err := http.ListenAndServe(":8082",tr2.Handler())
		log.Fatal(err)
	}()


	time.Sleep(time.Second*3)

	//节点1添加节点2
	tr1.AddPeer(int64(id2),peerURL2)

	//节点2添加节点1
	tr2.AddPeer(int64(id1),peerURL1)




	go func() {
		ticker := time.NewTicker(time.Second*10)
		defer ticker.Stop()
		for {
			select {
			case <- ticker.C:
				peers := tr1.GetPeer()
				for i := range peers {
					peers[i].send(&Message{MsgType:msgTypeProp, MsgBody:"Hello,I am tr1"})
				}
			}
		}
	}()


	go func() {
		ticker := time.NewTicker(time.Second*10)
		defer ticker.Stop()
		for {
			select {
			case <- ticker.C:
				peers := tr2.GetPeer()
				for i := range peers {
					peers[i].send(&Message{MsgType:msgTypeProp, MsgBody:"Hello,I am tr2"})
				}
			}
		}
	}()


	time.Sleep(time.Minute*10)


	tr1.Stop()
	tr2.Stop()
}



type Transport struct {
	ClusterID  int64
	ID          int64   // local member ID  当前节点自己的ID
	streamRt http.RoundTripper
	mu sync.RWMutex
	peers   map[int64]*peer    // peers map
}

func (tr *Transport) Start(id int64) error {
	tr.ID = id
	tr.streamRt = &http.Transport{
	Dial: (&net.Dialer{
		Timeout: 10*time.Second,
		// value taken from http.DefaultTransport
		KeepAlive: 30 * time.Second,
	}).Dial,
	}
	tr.peers = make(map[int64]*peer)

	return nil
}

func (tr *Transport) GetPeer() (result []*peer) {
	tr.mu.RLock()
	defer tr.mu.RUnlock()

	for k := range tr.peers{
		result = append(result,tr.peers[k])
	}

	return
}

func (tr *Transport) AddPeer(id int64, peerURL string) {
	tr.mu.RLock()
	if _,ok := tr.peers[id]; ok {
		tr.mu.RUnlock()
		return
	}

	tr.mu.RUnlock()

	peer := startPeer(tr,peerURL,tr.ID,id)

	tr.mu.Lock()
	tr.peers[id] = peer
	tr.mu.Unlock()
}

func (tr *Transport) Handler() http.Handler {
	streamHandler := newStreamHandler(tr,tr.ID,tr.ClusterID)
	mux := http.NewServeMux()
	mux.Handle("/raft/stream"+"/", streamHandler)
	return mux
}



type streamHandler struct {
	tr         *Transport   //关联的rafthttp.Transport实例
	id        int64  //当前节点ID
	cid      int64   //当前集群ID
}

func newStreamHandler(tr *Transport, id, cid int64) http.Handler  {
	return &streamHandler{
		tr:tr,
		id:id,
		cid:cid,
	}
}

func (h *streamHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	//请求参数校验,如Method是否是GET,检验集群ID
	if r.Method != "GET" {
		w.Header().Set("Allow", "GET")
		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
		return
	}

	id := r.Header.Get("PeerID")
	if id == ""{
		w.Header().Set("PeerID", "Must")
		http.Error(w, "PeerID is not allow empty", http.StatusMethodNotAllowed)
		return
	}

	pid,_ := strconv.ParseUint(id,10,64)




	p,ok := h.tr.peers[int64(pid)]
	if !ok {
		w.WriteHeader(http.StatusNotFound)
		time.Sleep(time.Second*5)
		return 
	}

	w.WriteHeader(http.StatusOK)  //返回状态码 200

	w.(http.Flusher).Flush()  //调用Flush()方法将响应数据发送到对端节点


   c := newCloseNotifier()
	conn := &outgoingConn{  //创建outgoingConn实例
		Writer:  w,
		Flusher: w.(http.Flusher),
		localID: h.tr.ID,
		Closer:c,
		peerID:  h.id,
	}
	p.attachOutgoingConn(conn)   //建立连接,将outgoingConn实例与对应的streamWriter实例绑定
	<- c.closeNotify()

}

type closeNotifier struct {
	done chan struct{}
}

func newCloseNotifier() *closeNotifier {
	return &closeNotifier{
		done: make(chan struct{}),
	}
}

func (n *closeNotifier) Close() error {
	close(n.done)
	return nil
}

func (n *closeNotifier) closeNotify() <-chan struct{} { return n.done }



func (tr *Transport) Stop()  {
	tr.mu.RLock()
	defer tr.mu.RUnlock()
	for _,v := range tr.peers{
		v.stop()
	}
	tr.peers = nil
}


const (
	msgTypeHeartbeat  =  "01"  //心跳
	msgTypeProp = "02"  //prop消息
)


type Message struct {
	MsgType string
	MsgBody string
}


type peer struct {
	localID int64   //当前节点ID
	// id of the remote raft peer node
	id  int64   //该peer实例对应的节点ID,对端ID

	writer         *streamWriter   //负责向Stream消息通道中写消息

	msgAppReader   *streamReader  //负责从Stream消息通道中读消息

	msgc chan *Message
	stopc  chan struct{}
}

func startPeer(t *Transport, peerURL string, localID,peerID int64) *peer {
	pr := & peer{
		localID:localID,
		id:peerID,
		writer:newstreamWriter(localID,peerID),
		msgAppReader:newstreamReader(localID,peerID,peerURL,t),
		msgc : make(chan *Message,20),
		stopc : make(chan struct{}),
	}

	go func() {
		for msg := range pr.msgc {
			select {
			case pr.writer.msgc <- msg:
			default:
				log.Printf("write to writer error msg is %v",msg)
			}
		}
	}()


	return pr
}

func (pr *peer) stop()  {
	close(pr.stopc)
}

func (pr *peer) send(msg *Message) bool{
	select {
	case pr.msgc <- msg:
		return true
	default:
		return false
	}
}

func (pr *peer) attachOutgoingConn(conn *outgoingConn) {
	select {
	case pr.writer.connc <- conn:

	default:
		log.Printf("attachOutgoingConn error")
	}
}


type streamWriter struct {
	localID int64   //本端的ID
	peerID  int64  //对端节点的ID

	closer  io.Closer    //负责关闭底层的长连接

	mu sync.Mutex

	enc  *messageEncoder
	msgc  chan *Message   //Peer会将待发送的消息写入到该通道,streamWriter则从该通道中读取消息并发送出去
	connc chan *outgoingConn   //通过该通道获取当前streamWriter实例关联的底层网络连接,  outgoingConn其实是对网络连接的一层封装,其中记录了当前连接使用的协议版本,以及用于关闭连接的Flusher和Closer等信息。
	stopc chan struct{}
}

func newstreamWriter(localID,peerID int64)  *streamWriter{
	sw := &streamWriter{
		localID:localID,
		peerID:peerID,
		msgc:make(chan *Message,20),
		connc:make(chan *outgoingConn),
		stopc:make(chan struct{}),
	}

	go sw.run()
	return sw
}


func (sw *streamWriter) writec() (chan<- *Message) {
	sw.mu.Lock()
	defer sw.mu.Unlock()
	return sw.msgc
}

func (sw *streamWriter) run() {
	var (
	 	heartbeatC  <-chan time.Time

		flusher    http.Flusher  //负责刷新底层连接,将数据真正发送出去

		msgc  chan *Message
	)


	tickc := time.NewTicker(time.Second*7)  //发送心跳的定时器
	defer tickc.Stop()

	for {

		select {
		case msg := <- msgc:
			err := sw.enc.encode(msg)
			if err != nil {
				log.Printf("send to peer peerID is %d fail,error is %v",sw.peerID,err)
			}else {
				flusher.Flush()
				log.Printf("send to peer  peerID is %d success,  MsgType is :%s,MsgBody is:%s",sw.peerID,msg.MsgType,msg.MsgBody)
			}

		case <-heartbeatC: //向对端发送心跳消息
			err := sw.enc.encode(&Message{
				MsgType: msgTypeHeartbeat,
				MsgBody: time.Now().Format("2006-01-02 15:04:05"),
			})
			if err != nil {
				log.Printf("send to peer heartbeat data fail  peerID is %d,error is %v",sw.peerID,err)
			}else {
				flusher.Flush()
				log.Printf("send to peer heartbeat data success  peerID is %d ",sw.peerID)
			}
		case conn := <- sw.connc:
			sw.enc = &messageEncoder{w:conn.Writer}
			flusher = conn.Flusher
			sw.closer = conn.Closer

			heartbeatC,msgc = tickc.C,sw.msgc

		case <- sw.stopc:
			log.Println("msgWriter stop!")
			sw.closer.Close()
			return
		}
	}
}

func (sw *streamWriter) stop()  {
	close(sw.stopc)
}


type streamReader struct {
	localID  int64
	peerID int64  //对端节点的ID
	tr     *Transport   //关联的rafthttp.Transport实例
	peerURL  string  //对端URL


	mu     sync.Mutex
	closer io.Closer   //负责关闭底层的长连接

	done   chan struct{}
}

func newstreamReader(localID,peerID int64,peerURL string,tr *Transport) *streamReader {
	sr := &streamReader{
		localID:localID,
		peerID:peerID,
		peerURL:peerURL,
		tr :tr,
		done : make(chan struct{}),
	}
	go sr.run()

	return sr
}

func (sr *streamReader) run() {
	time.Sleep(time.Second*5)
	for {
		readColser,err := sr.dial()
		if err != nil {
			log.Printf("dial peer error,peerID is %d,err is %v",sr.peerID,err)
			time.Sleep(time.Second*10)
			continue
		}
		sr.closer = readColser

		err = sr.decodeLoop(readColser)
		if err != nil {
			log.Printf("decodeLoop error,peerID is %d, error is %v",sr.peerID,err)
		}
		sr.closer.Close()
	}
}

func (sr *streamReader) dial() (io.ReadCloser, error) {
	req, err := http.NewRequest("GET", sr.peerURL+"/raft/stream/dial", nil)
	if err != nil {
		return nil,err
	}

	req.Header.Set("PeerID",fmt.Sprintf("%d",sr.localID))

	resp,err := sr.tr.streamRt.RoundTrip(req)
	if err != nil {
		return nil,err
	}

	return resp.Body,nil
}

func (sr *streamReader) decodeLoop(rc io.ReadCloser) error {
	dec := &messageDecoder{rc}
	for {
		msg,err := dec.decode()
		if err != nil {
			log.Printf("read decodeLoop error,peerID is %d,err is %v",sr.peerID,err)
			continue
		}

		log.Printf("read from peer MsgType is %s,MsgBody is %s",msg.MsgType,msg.MsgBody)
	}
}


type outgoingConn struct {
	io.Writer
	http.Flusher
	io.Closer
	localID int64
	peerID  int64
}


type messageEncoder struct {
	w io.Writer
}

func (m *messageEncoder) encode(msg *Message) error {
	byts,err := json.Marshal(msg)
	if err != nil {
		return err
	}

	dataLen := make([]byte,8)
	binary.BigEndian.PutUint64(dataLen,uint64(len(byts)))

	sendData := append(dataLen,byts...)
	_,err = m.w.Write(sendData)
	if err != nil {
		return err
	}

	return nil
}

type messageDecoder struct {
	r io.Reader
}

func (dec *messageDecoder) decode() (*Message,error) {
	var m Message
	var l uint64
	if err := binary.Read(dec.r, binary.BigEndian, &l); err != nil {
		return nil, err
	}

	buf := make([]byte, int(l))
	if _, err := io.ReadFull(dec.r, buf); err != nil {
		return &m, err
	}
	err := json.Unmarshal(buf,&m)
	if err != nil {
		return nil,err
	}
	return &m, nil
}



func getPid(purl string)  int64 {
	index := strings.LastIndex(purl,":")
	if index > 0 {
		id,err := strconv.ParseInt(purl[index+1:],10,64)
		if err != nil {
			println(err)
		}
		return  id
	}

	return 0
}

 

Golang面试(一)莉莉丝游戏-Golang后端开发-中台部门 莉莉丝游戏-Golang后端开发-中台部门 开场白,双方自我介绍,对方介绍这个岗位情况,erlang语言,全部转向go。 聊项目,介绍IM架构以及使用Go写的服务简介 动态扩容相关问题:平常30万,现在100万,你们现在是如何应对的? 如果让你调整架构实现动态扩容,你会怎么做?回答了kafka,是一种,应该还要使用docker和k8s以及微服务框架等 如果使用kafka,你是如何确保消息有序?回答了redis,好像没回答到那个点 消息发送失败的问题,如何做到消息不丢?回答持久化存储、拉消息和ACK 发送失 阅读详情

相关推荐

原神真端,原神服务端,虚拟机启动部署傻瓜式教学

没玩过抽卡 游戏想体验一下抽卡的感觉,听说原神有真端了,所以弄一个局域网的服务体验一下,这里要感谢一些服务端的分享者。

azyouyouyou的博客 1万+

etcd网络层(三)——stream实现过程

stream消息通道主要是通过长连接的方式和对端进行数据交互,peer结构体中的stream相关数据如下(忽略V2版本): type peer struct { writer *streamWriter //负责向Stream消息通道中写消息 msgAppReader *streamReader //负责从Stream消息通道中读消息 ...

skh2015java的博客 1798

Minecraft Forge模组开发入门:从环境搭建到事件监听实战

事件驱动编程是一种基于事件和事件监听器的软件架构模式,其核心原理是通过事件总线实现组件间的松耦合通信。在游戏开发领域,这种模式能够有效处理玩家交互、状态变更等异步操作,具有高度的灵活性和可扩展性。Java作为面向对象编程语言,通过注解和反射机制为事件驱动提供了天然支持。Minecraft模组开发正是事件驱动编程的典型应用场景,开发者可以利用Forge框架提供的事件总线监听游戏内各种行为。本文以Minecraft Forge模组开发为例,详细讲解如何通过Gradle构建工具搭建开发环境,并实现自定义方块注册和

culi3182的博客 396

【Golang】——利用time.Ticker做定时任务

一、前言 golang 的time.Ticker一般用来作为时间周期执行任务的。 二、demo 这个是官网贴出的例子,作用是每10s钟会输出当前的时间。 package main import ( "fmt" "time" ) func main() { ticker := time.NewTicker(time.Second) defer ticker.Stop() done := make(chan bool) go func() { time.Sle...

汤庆 5525

人工智能在高中教育中的应用现状剖析与挑战应对

人工智能在高中教育中的应用现状剖析与挑战应对

燕鹏 1341

别再乱调NvM_WriteBlock了!手把手教你搞懂Autosar NVM状态机与读写时序

本文深入解析Autosar NVM状态机与读写时序,帮助开发者避免常见错误。通过详细的状态机解读、最佳实践代码示例和异常处理策略,提升嵌入式系统中数据存储的可靠性。特别针对NvM_WriteBlock的调用逻辑和状态机机制进行实战讲解,解决工程师在实际开发中遇到的异步写入问题。

weixin_33701617的博客 347

etcd网络层源码分析(四)——stream通道实现

etcd网络层(四)——stream接口实现

高思维深思考的博客 2344

SAP-ABAP:在SAP系统中,COEP表(成本控制对象行项目表)详解

在SAP系统中,COEP表(成本控制对象行项目表)详解

baidu_35680696的博客 1840

Socket 实现TCP长连接一,最简单代码,InputStream、OutStream方式,控制台可测试

package TCP.LongConnection1; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; import java.net.So...

haoranhaoshi的博客 1248

【EPS精品教程】EPS2016三维测图版安装教程(附EPS2016安装包下载地址)

EPS地理信息工作站是北京清华山维新技术开发有限公司历经十五年精心研发和打造,为满足“以地理信息服务为中心”的信息化测绘生产需求而推出的测绘生产活动多种业务模块集成化软件系统。主要功能有:(1)测绘与地理信息多业务模块集成管理;(2)多元多尺度多种类数据集成管理;(3)跨平台异构数据转换;(4)数据监理;(5)自动缩编与综合;(6)坐标转换与动态投影;(7)地理信息模板定制;(8)GIS地理信息描述与CAD图形表达一体化支持;(9)GIS数据库更新维护;(10)图形打印与地图出版。 一、安装过程 EP..

智慧空间实验室 2万+

200、从零搭建具身智能实验平台:硬件选型软件栈与调试

我一开始图便宜,3D打印了一个平行夹爪,结果抓取力不够,稍微重点的物体就滑落,而且开合控制延迟大,VLA模型输出的动作指令根本跟不上。如果你非要自己做,记住两个原则:一是用谐波减速器而不是直驱,二是加力传感器,哪怕是一个简单的电阻应变片也行——没有力反馈,你的夹爪就是个瞎子。我的建议是,如果你用的是UR5老款,ROS1的ur_modern_driver包更成熟,但如果你要跑最新的VLA框架,很多库已经不支持ROS1了。所以,保持耐心,多备份代码,多记录日志,少熬夜。毕竟,这条路上,我们都是摸着石头过河。

sundong_81的博客 40

ETCD系列之三:网络层实现

ETCD系列之三:网络层实现 1. 概述 在理清ETCD的各个模块的实现细节后,方便线上运维,理解各种参数组合的意义。本文先从网络层入手,后续文章会依次介绍各个模块的实现。 本文将着重介绍ETCD服务的网络层实现细节。在目前的实现中,ETCD通过HTTP协议对外提供服务,同样通过HTTP协议实现集群节点间数据交互。 网络层的主要功能是实现了服务器与客户端(能发出HTTP请求的各种程序)消息交互,以及集群内部各节点之间的消息交互。 2. ETCD-SERVER整体架构 ETCD-SERVER 大体

技术心得总结 748

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

ETCD介绍—etcd概念及原理方面分析

etcd作为一个受到ZooKeeper与doozer启发而催生的项目,除了拥有与之类似的功能外,更专注于以下四点。 简单:基于HTTP+JSON的API让你用curl就可以轻松使用。 安全:可选SSL客户认证机制。 快速:每个实例每秒支持一千次写操作。 可信:使用Raft算法充分实现了分布式。 分布式系统中的数据分为控制数据和应用数据。etcd的使用场景默认处理的数据都是控制数据,对于应用数据,只推荐数据量很小,但是更新访问频繁的情况。应用场景有如下几类:场景一:服务发现(Service Discovery

chang_ge的博客 1115

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

etcd网络通讯层(一)——rafthttp中重要的接口

前面我们提到etcd-raft模块,etcd-raft模块并未提供网络层的相关实现,而是将待发送的消息封装进Ready实例返回给上层模块,然后由上层模块决定如何将这些消息发送到集群中的其他节点。etcd将网络层的相关实现单独封装成一个模块,也就是etcd-rafthttp模块。从而降低了etcd-raft和etcd-rafthttp之间的耦合,提高程序的可扩展性。 et...

skh2015java的博客 1842

ETCD是什么

1. ETCD是什么 ETCD是用于共享配置和服务发现的分布式,一致性的KV存储系统。该项目目前最新稳定版本为2.3.0. 具体信息请参考[项目首页]和[Github]。ETCD是CoreOS公司发起的一个开源项目,授权协议为Apache。 提供配置共享和服务发现的系统比较多,其中最为大家熟知的是[Zookeeper](后文简称ZK),而ETCD可以算得上是后起之秀了。在项目实现,一致性协议易理解性,运维,安全等多个维度上,ETCD相比Zookeeper都占据优势。 2. ETCD vs ZK

weixin_57763462的博客 481

etcd 启动分析_ETCD相关介绍--整体概念及原理方面

etcd作为一个受到ZooKeeper与doozer启发而催生的项目,除了拥有与之类似的功能外,更专注于以下四点。简单:基于HTTP+JSON的API让你用curl就可以轻松使用。安全:可选SSL客户认证机制。快速:每个实例每秒支持一千次写操作。可信:使用Raft算法充分实现了分布式。分布式系统中的数据分为控制数据和应用数据。etcd的使用场景默认处理的数据都是控制数据,对于应用数据,只推荐数据量...

weixin_39925413的博客 564

ETCD结构、特点及和zookeeper对比

文章目录etcd 是什么etcd结构简介etcd 数据通道etcd通信架构应用场景和ZK对比 etcd 是什么 etcd 这个名字由两部分组成: etc 和 d ,即 UNIX/Linux操作系统的“/etc” 目录和分布式( distributed )首字母的“d ” 。我们都知道,/etc目录一般用于存 储 UNIX/Linux 操作系统的配置信息 因此etc和d合起来就是一个分布式的/etc 目录。etcd 的寓意是为大规模分布式系统存储配置信息。 etcd 的官方定义如下: A highly-ava

zhangxm_qz的博客 3881

etcd网络层源码分析(二)——Transporter接口实现

1.dial网络频率限制

高思维深思考的博客 616

深入浅出之etcd

分布式系统的难点在于“部分失败”。部分失败指信息在网络的两个节点之间传送出现了故障,发送者不知道接收者是否收到了这个信息,并且导致这种故障的原因很多,接收者也可能在发生网络错误之前收到了信息,也可能没收到。 现在的键值数据库基本都是分布式的,Zookeeper是其中久负盛名的一个,它有很成熟,丰富的特性,但它有自己的缺点,具体如下: 复杂:ZooKeeper部署维护比较复杂,管理员必须掌握一系列知识,Zookeeper使用的Pzxos强一致性算法不易于理解 Zookeeper仅提供Java和C两种接口,另

不务正业随手记 1151

ETCD相关介绍--整体概念及原理方面

转载 https://www.cnblogs.com/softidea/p/6517959.html etcd作为一个受到ZooKeeper与doozer启发而催生的项目,除了拥有与之类似的功能外,更专注于以下四点。 简单:基于HTTP+JSON的API让你用curl就可以轻松使用。 安全:可选SSL客户认证机制。 快速:每个实例每秒支持一千次写操作。 可信:使用Raft算法充分实...

weixin_34097242的博客 133

游戏后端分布式学习——etcd

强一致的分布式 KV 存储,基于 Raft 共识算法定位:分布式系统的"协调大脑"——存元数据、配置、协调状态,不存业务热数据对比:Redis 是 AP 系统(高性能,弱一致),etcd 是 CP 系统(强一致,性能次之)

weixin_40453090的博客 232

云原生运维实战:ETCD 分布式存储集群运维、Kubernetes 高可用集群部署与版本平滑升级

本文从底层分布式存储 ETCD 讲起,覆盖单节点 / 三节点集群部署、etcdctl 常用命令、K8s 数据查询、物理 / 逻辑备份恢复;完整演示生产级 K8s 高可用集群搭建:环境标准化模板、ETCD 独立集群、Keepalived+Haproxy 四层负载、kubeadm 部署三 Master + 多 Worker、Calico 网络;详解 K8s 版本平滑升级流程与故障恢复。

Augustsky12138的博客 368

etcd 官方性能压测工具 benchmark 使用指南:安装、命令行参数与 KV/事务/Watch 场景实战

`etcd/tools/benchmark` 是 etcd 官方提供的集群性能基准测试工具,它直接基于 gRPC 协议向运行中的 etcd 节点发起低层请求,用于量化键值读写(put/range)、事务(txn)、分布式事务(STM)、Watch 推送与租约保活等典型负载的吞吐与延迟表现。读完本文,你将掌握该工具的三种安装与运行方式、全部全局选项与各子命令的完整参数语义,并能针对读写、事务与 Wa

gitblog_00460的博客 510

Claude 3.5架构升级:请求编排器层的零成本蒸发

大模型服务架构中,请求编排器(Request Orchestrator)曾是协调多任务、管理会话状态与保障安全策略的关键中间层。其本质是将自然语言意图翻译为结构化调度逻辑的‘人肉编译器’,但带来高延迟、状态不一致与安全边界割裂等系统性瓶颈。随着Claude-3.5系列将任务分解、状态哈希与安全飞地能力深度蒸馏进推理内核,该层正被原生协议内化为透明基础设施。这一演进不仅压缩端到端延迟超60%,更使session管理、stream恢复与PII脱敏等能力从外部组件下沉至GPU显存与TrustZone安全区域。面向

dianan0938的博客 537
上一篇: Golang runtime包下Gosched函数的作用
下一篇: Golang中path/filepath包
思维的深度
博客等级 码龄11年 2万+粉丝 391原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值